GameObj.hpp

[詳解]

#pragma once
 
#include <vector>
#include <typeinfo>
#include <cassert>
#include <string>
#include <map>
 
#include "utility/ID/IDAssignment.h"
#include "ComponentList.hpp"
#include "Transform.hpp"
#include "Accessor.hpp"
 
using std::string;
using std::vector;
using std::map;
using Kisaragi_Lib::ID::IDAssignment;
 
 
namespace Kisaragi_Lib
{
    class ComponentBase;
    class Collision2DBase;
 
    namespace GameObj
    {
        class GameObjBase
        {
        private:
            //ユーザーが派生クラスで扱った時に勝手にdeleteしないようにする.
            ComponentList componentList;
 
        protected:
            bool isActive;
            string id;
            string name;
 
        public:
 
            string GetName()
            {
                return name;
            }
 
            virtual void OnCollisionEnter(GameObjBase* _other)
            {
                //TODO ここでメッセージ受信
            }
 
            virtual void OnCollisionStay(GameObjBase* _other)
            {
                //TODO ここでメッセージ受信
            }
 
            virtual void OnCollisionExit(GameObjBase* _other)
            {
                //TODO ここでメッセージ受信
            }
 
            Transform2D transform;
 
            GameObjBase() : isActive(true) {}
            virtual ~GameObjBase(){}
 
            /// <summary>
            /// コンポーネントを追加
            /// </summary>
            /// <typeparam name="T">追加したいコンポーネントの型</typeparam>
            template<class T>
            void AddComponent()
            {
                componentList.AddComponent<T>(this);
            }
 
            /// <summary>
            /// コンポーネントを取得する
            /// </summary>
            /// <typeparam name="T">捜索するコンポーネントの型</typeparam>
            /// <returns>
            /// <param>成功時 : 発見したコンポーネントのポインタ</param>
            /// <param>失敗時 : プログラム終了</param>
            /// </returns>
            template<class T>
            T& GetComponent()
            {
                return componentList.GetComponent<T>();
            }
 
            /// <summary>
            /// コンポーネントを取得する
            /// </summary>
            /// <typeparam name="T">捜索するコンポーネントの型</typeparam>
            /// <returns>
            /// <param>成功時 : 発見したコンポーネントのポインタ</param>
            /// <param>失敗時 : 何も返さない</param>
            /// </returns>
            template<class T>
            T& TryGetComponent()
            {
                return componentList.TryGetComponent<T>();
            }
 
            
            void AddRemoveComponent(ComponentBase* _com);
 
            void AddRemoveComponent(string _id);
 
            void Destroy();
 
            string ID() const;
 
            void ID(string _id);
 
            virtual void Update() {};
 
            virtual void Start() {};
 
            //TODO あたまおかしい
            void MessageComponentList(string _message);
        };
 
        class GameObjectFacade
        {
        public:
 
            GameObjectFacade();
            
 
            ~GameObjectFacade();
 
            template <class T>
            GameObjBase* Create()
            {
                //TODO GameObjBaseの派生クラスではないなら
                /*if (!(typeid(GameObjBase).before(typeid(T))))
                {
                    assert(false);
                }*/
 
                string tmpID = idAssignment.GetID();
 
                //既に存在するIDなら
                assert(objects.count(tmpID) == 0);
 
                //生成
                objects.emplace(tmpID, new T);
 
                //ID登録
                objects[tmpID]->ID(tmpID);
 
                //Startを呼び出す.
                objects[tmpID]->Start();
 
                return objects[tmpID];
            }
 
            
            /// <summary>
            /// GameObjct派生クラスを全て破棄する
            /// </summary>
            void FinalizeGameObject();
 
            /// <summary>
            /// 破棄オブジェクトの登録
            /// </summary>
            /// <param name="_id">破棄オブジェクトのID</param>
            void AddDestroy(string _id);
 
            /// <summary>
            /// 破棄オブジェクトの登録.
            /// </summary>
            /// <param name="_obj">破棄オブジェクト</param>
            void AddDestroy(GameObjBase* _obj);
 
            /// <summary>
            /// オブジェクトを破棄する.
            /// </summary>
            void Destroy();
 
            void MessageRemoveComponent();
 
            void MessageUpdate();
 
            GameObjBase* FindName(string _name)
            {
                for (auto& obj : objects)
                {
                    if (obj.second->GetName() == _name)
                    {
                        return obj.second;
                    }
                }
            }
 
            template<class T>
            T& GetGameObject()
            {
                for (auto& obj : objects)
                {
                    if (typeid(*obj.second).name() == typeid(T).name())
                    {
                        return *((T*)obj.second);
                    }
                }
            }
 
            template<class T>
            T& GetGameObject(string _name)
            {
                std::vector<GameObjBase*> objs;
 
                for (auto& obj : objects)
                {
                    if (typeid(*obj.second).name() == typeid(T).name())
                    {
                        objs.push_back(((T*)obj.second));
                    }
                }
 
                for (auto& obj : objs)
                {
                    if (obj->GetName() == _name)
                    {
                        return *((T*)obj);
                        
                    }
                }
            }
 
 
        private:
            map<string,GameObjBase*> objects;
            IDAssignment idAssignment;
            map<string,string>destroyID;
 
            void InitIDAssignment();
 
        };
 
        GameObjectFacade& GetGameObjectFacade();
 
        
    }
 
}