ObjectConfig.h

Go to the documentation of this file.

/*
 * i6engine
 * Copyright (2016) Daniel Bonrath, Michael Baer, All rights reserved.
 *
 * This file is part of i6engine; i6engine is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __I6ENGINE_API_OBJECTCONFIG_H__
#define __I6ENGINE_API_OBJECTCONFIG_H__

#include "i6engine/utils/sharedPtr.h"

#include "i6engine/math/i6eQuaternion.h"
#include "i6engine/math/i6eVector.h"

#include "i6engine/api/GameMessage.h"
#include "i6engine/api/GameMessageStruct.h"
#include "i6engine/api/configs/attributeMap.h"

#include "boost/function.hpp"

namespace i6e {
namespace api {

        class Component;
        class GameObject;

        typedef utils::sharedPtr<Component, Component> ComPtr;
        typedef boost::function<ComPtr(const int64_t, const attributeMap &)> createGOCCallback;
        typedef utils::sharedPtr<GameObject, GameObject> GOPtr;
        typedef utils::weakPtr<GameObject, GameObject> WeakGOPtr;
        typedef void (*CreateGO)(GOPtr, const attributeMap &);

namespace objects {
        enum ObjectMessageTypes {
                ObjReset = 0,
                ObjCreate,
                ObjCreateAndCall,
                ObjLevel,
                ObjType,
                ObjRegisterCTemplate,
                ObjTicker,
                ObjInsert,
                ObjState,
                ObjKillMe,
                ObjConditionalMessage,
                Position,
                ObjClean,
                ObjPause,
                ObjComponentTicking
        };

        typedef struct ISIXE_MODULES_API GOTemplateComponent {
                std::string _template;
                int64_t _id;
                attributeMap _params;
                bool _owner;
                std::string _identifier;
                bool _deleted;

                GOTemplateComponent() : _template(), _id(-1), _params(), _owner(false), _identifier(), _deleted(false) {
                }

                GOTemplateComponent(const std::string & t, int64_t i, const attributeMap & p, bool b, const std::string & id, bool deleted) : _template(t), _id(i), _params(p), _owner(b), _identifier(id), _deleted(deleted) {
                }

                GOTemplateComponent(const std::string & t, const attributeMap & p, const std::string & id, bool deleted, bool owner) : _template(t), _id(-1), _params(p), _owner(owner), _identifier(id), _deleted(deleted) {
                }

                template<class Archive>
                void serialize(Archive & ar, const unsigned int) {
                        ar & _template;
                        ar & _id;
                        ar & _params;
                        ar & _owner;
                        ar & _identifier;
                        ar & _deleted;
                }
        } GOTemplateComponent;

        typedef struct ISIXE_MODULES_API GOTemplate {
                std::string _type; // Type of the GO
                std::vector<GOTemplateComponent> _components; // template name, id, params, owner
                template<class Archive>
                void serialize(Archive & ar, const unsigned int) {
                        ar & _type;
                        ar & _components;
                }
        } GOTemplate;

        typedef struct ISIXE_MODULES_API Object_Create_Create : GameMessageStruct {
                std::string tpl;
                core::IPKey owner;
                uint64_t uuid;
                GOTemplate tmpl;
                bool send;
                Object_Create_Create();
                Object_Create_Create(const int64_t i, const std::string & t, const core::IPKey & own, uint64_t u, const GOTemplate & g, const bool b);
                template<class Archive>
                void serialize(Archive & ar, const unsigned int) {
                        ar & boost::serialization::base_object<GameMessageStruct>(*this);
                        ar & tpl;
                        ar & owner;
                        ar & uuid;
                        ar & tmpl;
                        ar & send;
                }
                Object_Create_Create * copy() { return new Object_Create_Create(*this); }
        } Object_Create_Create;

        typedef struct ISIXE_MODULES_API Object_Create_Delete : GameMessageStruct {
                core::IPKey owner;
                Object_Create_Delete();
                Object_Create_Delete(const int64_t i, const core::IPKey & o);
                template<class Archive>
                void serialize(Archive & ar, const unsigned int) {
                        ar & boost::serialization::base_object<GameMessageStruct>(*this);
                        ar & owner;
                }
                Object_Create_Delete * copy() { return new Object_Create_Delete(*this); }
        } Object_Create_Delete;

        typedef struct ISIXE_MODULES_API Object_Level_Create : GameMessageStruct {
                std::string file;
                std::string flags;
                std::function<void(uint16_t)> callback;
                std::function<void(void)> func;
                Object_Level_Create();
                Object_Level_Create(const std::string & fi, const std::string & fl, const std::function<void(uint16_t)> & cb, const std::function<void(void)> & fu);
                template<class Archive>
                void serialize(Archive & ar, const unsigned int) {
                        ar & boost::serialization::base_object<GameMessageStruct>(*this);
                        ar & file;
                        ar & flags;
                }
                Object_Level_Create * copy() { return new Object_Level_Create(*this); }
        } Object_Level_Create;

        typedef struct ISIXE_MODULES_API Object_Type_Delete : GameMessageStruct {
                std::string type;
                Object_Type_Delete();
                Object_Type_Delete(const std::string & t);
                template<class Archive>
                void serialize(Archive & ar, const unsigned int) {
                        ar & boost::serialization::base_object<GameMessageStruct>(*this);
                        ar & type;
                }
                Object_Type_Delete * copy() { return new Object_Type_Delete(*this); }
        } Object_Type_Delete;

        typedef struct ISIXE_MODULES_API Object_RegisterCTemplate_Create : GameMessageStruct {
                std::string name;
                createGOCCallback func;
                Object_RegisterCTemplate_Create();
                Object_RegisterCTemplate_Create(const std::string & n, const createGOCCallback & f);
                Object_RegisterCTemplate_Create * copy() { return new Object_RegisterCTemplate_Create(*this); }
        } Object_RegisterCTemplate_Create;

        typedef struct ISIXE_MODULES_API Object_State_Update : GameMessageStruct {
                core::IPKey receiver;
                Object_State_Update();
                Object_State_Update(const core::IPKey & r);
                Object_State_Update * copy() { return new Object_State_Update(*this); }
        } Object_State_Update;

        typedef struct ISIXE_MODULES_API Object_CreateAndCall_Create : GameMessageStruct {
                std::string tpl;
                core::IPKey owner;
                uint64_t uuid;
                GOTemplate tmpl;
                bool send;
                boost::function<void(const GOPtr &)> func;
                Object_CreateAndCall_Create();
                Object_CreateAndCall_Create(const int64_t i, const std::string & t, const core::IPKey & own, uint64_t u, const GOTemplate & g, const bool b, const boost::function<void(const GOPtr &)> & f);
                Object_CreateAndCall_Create * copy() { return new Object_CreateAndCall_Create(*this); }
        } Object_CreateAndCall_Create;

        typedef struct ISIXE_MODULES_API Object_ConditionalMessage_Update : GameMessageStruct {
                GameMessage::Ptr msg;
                boost::function<bool(const GOPtr &)> func;
                bool sync;
                uint32_t comFamID;
                Object_ConditionalMessage_Update();
                Object_ConditionalMessage_Update(const GameMessage::Ptr & m, const boost::function<bool(const GOPtr &)> & f, bool s, uint32_t c);
                Object_ConditionalMessage_Update * copy() { return new Object_ConditionalMessage_Update(*this); }
        } Object_ConditionalMessage_Update;

        typedef struct ISIXE_MODULES_API Object_KillMe_Update : GameMessageStruct {
                Object_KillMe_Update();
                Object_KillMe_Update * copy() { return new Object_KillMe_Update(*this); }
        } Object_KillMe_Update;

        typedef struct ISIXE_MODULES_API Position_Update : GameMessageStruct {
                Vec3 pos;
                Quaternion rot;
                Vec3 scale;

                Position_Update();
                Position_Update(const int64_t i, const int64_t ci, const Vec3 & p, const Quaternion & r, const Vec3 & s);
                Position_Update * copy() { return new Position_Update(*this); }
                template<class Archive>
                void serialize(Archive & ar, const unsigned int) {
                        ar & boost::serialization::base_object<GameMessageStruct>(*this);
                        ar & pos;
                        ar & rot;
                        ar & scale;
                }
        } Position_Update;

        typedef struct ISIXE_MODULES_API Object_Clean_Delete : GameMessageStruct {
                Object_Clean_Delete();
                Object_Clean_Delete * copy() {
                        return new Object_Clean_Delete(*this);
                }
        } Object_Clean_Delete;

        typedef struct ISIXE_MODULES_API Object_Pause_Update : GameMessageStruct {
                bool pause;
                Object_Pause_Update(bool p) : pause(p) {
                }
                Object_Pause_Update * copy() {
                        return new Object_Pause_Update(*this);
                }
        } Object_Pause_Update;

        typedef struct ISIXE_MODULES_API Object_ComponentTicking_Update : GameMessageStruct {
                bool allowTicking;
                Object_ComponentTicking_Update(bool a) : allowTicking(a) {
                }
                Object_ComponentTicking_Update * copy() {
                        return new Object_ComponentTicking_Update(*this);
                }
        } Object_ComponentTicking_Update;

} /* namespace objects */
} /* namespace api */
} /* namespace i6e */

#endif /* __I6ENGINE_API_OBJECTCONFIG_H__ */