C++ Object实体类

*暂未完成，因为无尽BUG滚滚来。

好长时间没写完，一是能力不够，二是我还得给老板写WEB的代码。可是我不会WEB！js和PHP简直就是世界上最好的语言，因为它们能够让人更快地进入极乐世界。

让我写一个gm后台，他说好不好看无所谓，能用就行。于是，我就写了一个根据JSON数据自动生成页面的代码……哈哈，平均15分钟完成一个功能，简直不要太爽。懒人自然有懒办法。当然，之前写工具花费了大量时间。

回家还要玩激战2刷每日，还挺忙的……

好吧，我已经没有力气给自己吐槽了。。。所以，直接上代码吧，不废话了。

 

以下代码为C++代码。

简直通俗易懂。

 

接下来（预计实现）：

1.结构改造：在代码中定义一个对象的属性关联以及拥有属性是不太方便的，应该将这种关系和数据放置于配置表中。甚至是接下来的事件类和故事（story）类也应当如此。

1.1 首先，需要定义基本动作，

1.2 定义动作指令

1.3 需要一个虚拟机，基于栈的或者是基于寄存器的。还是栈虚拟机实现更简单一点，尽管效率稍差。

1.3.1  图形界面或者脚本程序。前者对于设计师来说更加友好。

1.4 协议。应当将虚拟机生成的字节码翻译成数据发送给主程序处理。

1.5 存储。生成的字节码应该被存储在配置表或者数据库中。

1.6 处理。主程序应该有足够通用、健壮和效率的算法来处理这个字节码。

看来这是一个大工程。

 

2.集中测试（2018.11.1 19:25）

LunaObject.h

#pragma once

#include "stdinc.h"
#include "Location.h"
#include "QualitiesManager.h"
#include "QualInc.h"

namespace Lunacia
{
    class ObjectInfo final
    {
    private:
        //info name: value pointer
        std::unordered_map<std::string, void*> _infos;
        std::unordered_map<std::string, std::function<void(const std::string&)>> _destory;

    public:
        ObjectInfo();
        ObjectInfo(std::unordered_map<std::string, void*>& infos);
        ~ObjectInfo();

    public:
        template<typename T>
        T& Get(const std::string& name)
        {
            if (!IsExist(name))
            {
                ErrorThrow("The data is not exist what name is " + name);
            }

            return *(static_cast<T*>(_infos.find(name)->second));
        }

        template<typename T>
        void Set(const std::string& name, T& val)
        {
            auto itFound = _infos.find(name);
            void* pFound = nullptr;
            if (itFound == _infos.end())
            {
                Add(name, val);
                return;
            }

            pFound = itFound->second;
            T* pVal = static_cast<T*>(pFound);
            *pVal = val;
        }

        template<typename T>
        void Replace(const std::string& name, const T& value)
        {
            Delete<T>(name);
            Add(name, value);
        }

        template<typename T>
        bool Add(const std::string& name, const T& value)
        {
            T* pValue = new T();
            *pValue = value;

            std::function<void(const std::string&)> destoryFunc = [this](const std::string& n)->void
            {
                this->Delete<T>(n);
            };

            _destory.insert(std::make_pair(name, destoryFunc));
            return _infos.insert(std::make_pair(name, static_cast<void*>(pValue))).second;
        }

        template<typename T>
        bool Delete(const std::string& name)
        {
            auto itFound = _infos.find(name);
            if (itFound == _infos.end())
            {
                return false;
            }
            void* pVal = itFound->second;

            T* pDel = static_cast<T*>(pVal);
            delete pDel;
            pVal = nullptr;

            _destory.erase(name);
            return _infos.erase(name) == 1;
        }

        bool IsExist(const std::string& name) const;
    };

    //////////LunaObject//////////
    class LunaObject
    {
    public:
        LunaObject();
        virtual ~LunaObject();

    public:
        virtual void QualitiesCorrelation() = 0;

    public:
        virtual ObjectInfo& Info();
        virtual void Destory();

#ifdef __Debug
    public:
#else
    protected:
#endif // __Debug
        ObjectInfo m_info;
        QualitiesManager m_qualManager;
    };

    ///////////NullObject///////////
    class NullObject: public LunaObject
    {
    private:
        static NullObject* _instance;

    private:
        NullObject();

    public:
        friend class ObjectManager;
        void Destory() override;
        ObjectInfo& Info() override;

        static NullObject* const GetInstance();

    private:
        void QualitiesCorrelation() override;
    };

    extern NullObject NULL_OBJECT;
    extern NullObject* const NULLPTR_OBJECT;
};

//#define ADDOBJ(className)   g_ObjectManager.AddObject(#className,new className)

 

LunaObject.cpp

#include "LunaObject.h"

namespace Lunacia
{
    LunaObject::LunaObject()
    {
    }

    LunaObject::~LunaObject()
    {
        Destory();
    }

    ObjectInfo & LunaObject::Info()
    {
        return m_info;
    }

    void LunaObject::Destory()
    {
        m_qualManager.Clear();
    }

    /**
    *    @class: NullObject.
    *  @lazy initializate: false.
    *  @thread safe: true.
    *
    */
    NullObject* NullObject::_instance = new NullObject();

    static NullObject* const NULLPTR_OBJECT = NullObject::GetInstance();
    static NullObject NULL_OBJECT = *NULLPTR_OBJECT;

    NullObject::NullObject()
    {
    }

    NullObject* const NullObject::GetInstance()
    {
        return _instance;
    }

    void NullObject::Destory() 
    {
        ErrorThrow("Destory Function: It is null object!");
    }

    ObjectInfo & NullObject::Info()
    {
        ErrorThrow("GetObjectInfo Function: It is null object!");
        return m_info;
    }

    void NullObject::QualitiesCorrelation() 
    {
        ErrorThrow("QualitiesCorrelation Function: It is null object!");
    }

    //////////////ObjectInfo//////////////
    ObjectInfo::ObjectInfo()
    {
    }

    ObjectInfo::ObjectInfo(std::unordered_map<std::string, void*>& infos):
        _infos(infos)
    {
    }

    ObjectInfo::~ObjectInfo()
    {
        std::unordered_map<std::string, void*>::iterator it;
        while (!_infos.empty())
        {
            it = _infos.begin();

            const std::string& name = it->first;
            (_destory[name])(name);
        } 

        _infos.clear();
        _destory.clear();
    }

    bool ObjectInfo::IsExist(const std::string & name) const
    {
        if (_infos.find(name) == _infos.end())
        {
            return false;
        }
        return true;
    }
};

 

ObjectManager.h

#pragma once

#include "LunaObject.h"
#include "UniqueID.h"

namespace Lunacia
{
    class ObjectManager final
    {
    public:
        ObjectManager();
        ~ObjectManager();

        void Clear();

    public:
        int Add(LunaObject * obj);

        template<class T, typename  std::enable_if <std::is_base_of<LunaObject, T>::value, T> ::type * = nullptr >
        int Add();

        template<class T, typename  std::enable_if <std::is_base_of<LunaObject, T>::value, T> ::type * = nullptr >
        LunaObject* Create();

        void Remove(int id);
        LunaObject*const Find(int id);
        const LunaObject*const Find(int id) const;

    private:
        std::map<int, LunaObject*> m_objects;
    };
    ///////////////

    template<class T, typename  std::enable_if <std::is_base_of<LunaObject, T>::value, T> ::type *>
    inline int ObjectManager::Add()
    {
        LunaObject* pObj = Create<T>();
        return Add(pObj);
    }

    template<class T, typename  std::enable_if <std::is_base_of<LunaObject, T>::value, T> ::type *>
    inline LunaObject * ObjectManager::Create()
    {
        return new T();
    }

};

 

ObjectManager.cpp

#include "ObjectManager.h"

namespace Lunacia
{
    ObjectManager::ObjectManager()
    {
    }
    
    ObjectManager::~ObjectManager()
    {
    }

    void ObjectManager::Clear()
    {
        for (auto& itEach : m_objects)
        {
            LunaObject* lo = itEach.second;
            lo->Destory();

            delete lo;
            lo = NULLPTR_OBJECT;
        }
    }

    int ObjectManager::Add(LunaObject * obj)
    {
        int id = static_cast<int>(UniqueID::Get());
        obj->Info().Set("id", id);

        return m_objects.insert(std::make_pair(id, obj)).second ? id : -1;
    }

    void ObjectManager::Remove(int id)
    {
        auto itFound = m_objects.find(id);
        if (itFound != m_objects.end())
        {
            return;
        }
        LunaObject* & pObjFound = itFound->second;
        pObjFound->Destory();

        delete pObjFound;
        pObjFound = NULLPTR_OBJECT;
    }

    LunaObject * const ObjectManager::Find(int id)
    {
        const ObjectManager* pSelf = this;

        return const_cast<LunaObject * const>(pSelf->Find(id));
    }

    const LunaObject * const ObjectManager::Find(int id) const
    {
        auto itFound = m_objects.find(id);
        if (itFound == m_objects.end())
        {
            return NULLPTR_OBJECT;
        }
        return itFound->second;
    }
};

 

Human.h(测试用) （将会被宏代替（一句宏生成一个类））

#pragma once
#include "LunaObject.h"

namespace Lunacia
{
    class Human : public LunaObject
    {
    public:
        Human();
        ~Human();

    public:
        void QualitiesCorrelation() override;
    };
};

 

Human.cpp(测试用)

#include "Human.h"

namespace Lunacia
{
    Human::Human()
    {
    }

    Human::~Human()
    {
    }

    void Human::QualitiesCorrelation()
    {
        //TODO: rebuild at config file.
        PtrQuality ptrHeal = m_qualManager.AddQuality<QualHealth>();
        PtrQuality ptrLifeIn = m_qualManager.AddQuality<QualLifeInstinct>();
        PtrQuality ptrCour = m_qualManager.AddQuality<QualCourage>();

        ptrHeal->SetLimit(1000);
        ptrHeal->SetValue(ptrHeal->GetLimit());

        ptrLifeIn->SetLimit(1000);
        ptrHeal->SetValue(ptrLifeIn->GetLimit());

        ptrCour->SetLimit(1000);
        ptrHeal->SetValue(ptrCour->GetLimit());

        ptrLifeIn->AddPassive(ptrHeal);
        ptrHeal->AddPassive(ptrCour);

        return;
    }

}

 

UniqueID.h（初版，用于测试）

#pragma once
#include "stdinc.h"

namespace Lunacia
{
    //Unique ID Local, not global.
    class UniqueID final
    {
    public:
        static int64_t Get(int8_t suffix_8bit = 0);
        static void Load(void* pData);

    private:
        static void ReInitPool();
        
    private:
        static const size_t _count = 5000;    //TODO:  Rebuild it.    //The larger the number, the more uniform the distribution.
        static int _curSize;
        static int _curMax;    //TODO:  Rebuild it.
        static std::array<int64_t, _count> _idsPool;
    };
};

 

UniqueID.cpp

#include "UniqueID.h"
#include "Random.h"

namespace Lunacia
{
    int UniqueID::_curMax = 100;
    std::array<int64_t, UniqueID::_count> UniqueID::_idsPool;
    int UniqueID::_curSize = UniqueID::_count;

    int64_t UniqueID::Get(int8_t suffix_8bit)
    {    
        if (_curSize >= _idsPool.size() - 1)
        {
            ReInitPool();
        }

        return (_idsPool[_curSize++] << 8) | suffix_8bit;
    }

    void UniqueID::Load(void* pData)
    {
    
    }

    void UniqueID::ReInitPool()
    {
        int curMin = _curMax;
        _curMax += _count;
        for (int i = 0; i < _count; ++i)
        {
            _idsPool[i] = i + curMin;
        }

        for (int n = 0; n < _count - 1; ++n)
        {
            uint64_t ran = RandomAvg::GetRandNum(n + 1, _count);
            std::swap(_idsPool[n], _idsPool[ran]);
        }

        _curSize = 0;
    }
};

 

 Encounter.h（测试类）

#include "stdinc.h"
#include "QualDefine.h"

#pragma once

namespace Lunacia
{
    class Encounter
    {
    public:
        struct QualInfluence 
        {
            QualityType type;
            int32_t influence;
        };

    public:
        Encounter();
        ~Encounter();

    private:
        QualityType GetRandomType() const;
        int32_t GetRamdomInfluence() const;

    public:
        void GetRandomInfluence(QualInfluence& __out res) const;
    };

};

Encounter.cpp

#include <bitset>

#include "Encounter.h"
#include "Random.h"

namespace Lunacia
{

    Encounter::Encounter()
    {
        
    }

    Encounter::~Encounter()
    {

    }

    QualityType Encounter::GetRandomType() const
    {
        int rand = static_cast<int>(RandomAvg::GetRandNum(1, static_cast<uint32_t>(QualityType::__QualityType_MAX)));
        return static_cast<QualityType>(rand);
    }

    int32_t Encounter::GetRamdomInfluence() const
    {

        return g_rn.GetRandNum<int32_t>() * static_cast<int>(std::pow(-1, RandomAvg::GetRandNum() % 2));
    }

    void Encounter::GetRandomInfluence(QualInfluence& res) const
    {
        res.type = GetRandomType();
        res.influence = GetRamdomInfluence();
    }
};

 

_main.cpp(测试用主函数)

#include "Tilee.h"
#include "Location.h"
#include "stdinc.h"
#include "Random.h"
#include "Rational.h"

#include "ObjectManager.h"
#include "QualHealth.h"
#include "QualLifeInstinct.h"

#include "LunaObject.h"
#include "Human.h"
#include "UniqueID.h"
#include "UClock.h"

#include "Encounter.h"

using namespace Lunacia;

ObjectManager* pOm = new ObjectManager();
std::vector<LunaObject*> g_objs;

RandomItem<LunaObject*> * g_ri;
Encounter g_ec;

const std::function<uint64_t(const LunaObject* const &)>& GetWeightFunc = [](const LunaObject*const & obj) -> uint64_t
{
    const Quality* const res = obj->m_qualManager.GetQuality(QualityType::HEALTH);
    if (res == nullptr)
    {
        return 0l;
    }

    return res->GetValue();
};

void loop() 
{
    Encounter::QualInfluence eqi;
    g_ec.GetRandomInfluence(eqi);

    LunaObject* const pObj = g_ri->GetRandItem();
    Quality* const res = pObj->m_qualManager.FindQuality(eqi.type);

    if (res == nullptr)
    {
        return;
    }
    res->AddValue(eqi.influence);

    std::cout<<"ID: " << pObj->Info().Get<int>("id") << "    " << static_cast<int64_t>(eqi.type) << " :  "<< eqi.influence << std::endl;
}

void init(int count)
{
    for (size_t i = 0; i < count; i++)
    {
        LunaObject* h = pOm->Create<Human>();
        h->QualitiesCorrelation();

        int id = pOm->Add(h);

        g_objs.push_back(h);
    }

    g_ri = new RandomItem<LunaObject*>(g_objs, GetWeightFunc);
}

int main(void)
{    
    init(100);
    const int64_t RateBase = 10000;

    int64_t Rate = RateBase / 100;
    UClock uck;
    
    int64_t pre = GetCurrentTime();
    int64_t e = 0;
    int64_t cur = 0;
    uint64_t i = 0;

    //TEST: Loop
    while (true) 
    {
        cur = GetCurrentTime();
        e += cur - pre;
        pre = cur;

        while (e >= Rate)
        {
            loop();
            e -= Rate;
            i++;
            //std::cout << e << std::endl;
        }

        if (i >= 10000)
        {
            i = 0;
            delete g_ri;
            g_ri = new RandomItem<LunaObject*>(g_objs, GetWeightFunc);
            system("cls");
        }
    }

    system("pause");
    return 0;
}