GameObject.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_GAMEOBJECT_H__
#define __I6ENGINE_API_GAMEOBJECT_H__

#include <map>

#include "i6engine/utils/i6eThreadSafety.h"
#include "i6engine/utils/sequence_map.h"
#include "i6engine/utils/weakPtr.h"

#include "i6engine/core/messaging/IPKey.h"

#include "i6engine/api/GameMessage.h"
#include "i6engine/api/components/Component.h"
#include "i6engine/api/configs/attributeMap.h"

#include "boost/function.hpp"

namespace i6e {
namespace modules {
        class ObjectMailbox;
} /* namespace modules */
namespace api {

        class Component;
        class GameObject;

        typedef utils::weakPtr<GameObject> WeakGOPtr;
        typedef utils::sharedPtr<Component, Component> ComPtr;
        typedef utils::sequence_map<int64_t, ComPtr> component_table_t;
        typedef std::pair<int64_t, ComPtr> component_table_pair_t;

        class ISIXE_MODULES_API GameObject {
        public:
                GameObject() {
                }
                GameObject(const int64_t goid, const core::IPKey & ownerNode, uint64_t uuid, const std::string & tpl, const boost::function<ComPtr(const int64_t, const std::string &, const attributeMap &, const WeakGOPtr &)> & f);

                ~GameObject();

                inline int64_t getID() const {
                        return _objGoid;
                }

                ComPtr getGOC(uint32_t famID) const;

                ComPtr getGOC(uint32_t famID, const std::string & identifier) const;

                template<typename T>
                utils::sharedPtr<T, api::Component> getGOC(uint32_t famID) const;

                template<typename T>
                utils::sharedPtr<T, api::Component> getGOC(uint32_t famID, const std::string & identifier) const;

                template<typename T>
                utils::sharedPtr<T, api::Component> getGOC() const;

                template<typename T>
                utils::sharedPtr<T, api::Component> getGOC(const std::string & identifier) const;

                ComPtr getGOCID(const int64_t id) const;

                std::vector<ComPtr> getGOCList() const;

                void setGOC(const ComPtr & objNewGOC);

                void clearGOCs();

                void setDie() const;

                inline std::string getType() const { return _type; }

                void setType(const std::string & type);

                void deleteGOC(uint32_t famID);

                void deleteGOC(uint32_t famID, const std::string & identifier);

                void sendCreateMessage() const;

                void synchronize(std::vector<GameMessage::Ptr> & messages, bool all) const;

                void sendDeleteMessage() const;

                inline core::IPKey getOwner() const { return _owner; }

                void News(const GameMessage::Ptr & msg);

                void initializeComponents();

                uint64_t getUUID() const {
                        return _uuid;
                }

                void setSelf(const WeakGOPtr & self) {
                        _self = self;
                }

                void setFlags(const std::vector<std::string> & flags) {
                        _flags = flags;
                }

                std::vector<std::string> getFlags() const {
                        return _flags;
                }

                void setSend(bool send) {
                        _send = send;
                }

                bool getSend() const {
                        return _send;
                }

        private:
                std::string _type;

                int64_t _objGoid;

                component_table_t _objComponents;

                std::string _template;

                std::map<std::string, GameMessage::Ptr> _messages;

                core::IPKey _owner;

                uint64_t _uuid;

                boost::function<ComPtr(const int64_t, const std::string &, const attributeMap &, const WeakGOPtr &)> _componentFunc;

                WeakGOPtr _self;

                std::vector<std::string> _flags;
                bool _send;

                ASSERT_THREAD_SAFETY_HEADER
        };

        template<typename T>
        utils::sharedPtr<T, Component> GameObject::getGOC(uint32_t famID) const {
                component_table_t::const_iterator it = _objComponents.find(famID);
                // GOComponent not found
                if (it == _objComponents.end()) {
                        return utils::sharedPtr<T, Component>();
                }

                // Return a pointer to the found GOComponent
                return utils::dynamic_pointer_cast<T>(it->second);
        }

        template<typename T>
        utils::sharedPtr<T, Component> GameObject::getGOC(uint32_t famID, const std::string & identifier) const {
                component_table_t::const_iterator it = _objComponents.find(famID);
                // GOComponent not found
                if (it == _objComponents.end()) {
                        return utils::sharedPtr<T, Component>();
                }

                if (it->second->getIdentifier() != identifier) {
                        for (ComPtr & c : it->second->_subComps) {
                                if (c->getIdentifier() == identifier) {
                                        return utils::dynamic_pointer_cast<T>(c);
                                }
                        }

                        return utils::sharedPtr<T, Component>();
                }

                // Return a pointer to the found GOComponent
                return utils::dynamic_pointer_cast<T>(it->second);
        }

        template<typename T>
        utils::sharedPtr<T, Component> GameObject::getGOC() const {
                for (const std::pair<int64_t, ComPtr> & com : _objComponents) {
                        auto c = utils::dynamic_pointer_cast<T>(com.second);
                        if (c != nullptr) {
                                return c;
                        }
                }

                // Return a pointer to the found GOComponent
                return utils::sharedPtr<T, Component>();
        }

        template<typename T>
        utils::sharedPtr<T, Component> GameObject::getGOC(const std::string & identifier) const {
                for (const std::pair<int64_t, ComPtr> & com : _objComponents) {
                        auto co = utils::dynamic_pointer_cast<T>(com.second);
                        if (co != nullptr) {
                                for (ComPtr & c : co->_subComps) {
                                        if (c->getIdentifier() == identifier) {
                                                return utils::dynamic_pointer_cast<T>(c);
                                        }
                                }
                        }
                }

                // Return a pointer to the found GOComponent
                return utils::sharedPtr<T, Component>();
        }

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

#endif /* __I6ENGINE_API_GAMEOBJECT_H__ */