objectmanager.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
 
#define GLM_ENABLE_EXPERIMENTAL
#include "glm/gtx/hash.hpp"
 
#include "server/game/object.hpp"
#include "server/game/player.hpp"
#include "server/game/enemy.hpp"
#include "server/game/dungeonmaster.hpp"
#include "server/game/solidsurface.hpp"
#include "server/game/torchlight.hpp"
//#include "server/game/grid.hpp"
#include "shared/utilities/smartvector.hpp"
 
// forward declarations to use pointers
class Trap; 
class Projectile;
class Item;
class Exit;
class Orb;
class WeaponCollider;
 
 
class ObjectManager {
public:
    ObjectManager();
    ~ObjectManager();
 
    /*  Object CRUD methods */
 
    SpecificID createObject(Object* object);
 
    bool removeObject(EntityID globalID);
 
    bool removeObject(Object** object_dbl_ptr);
 
    bool replaceObject(EntityID globalID, Object* object);
 
    Object* getObject(EntityID globalID);
 
    /*  SpecificID object getters by type   */
 
    Object* getBaseObject(SpecificID base_objectID);
 
    Item* getItem(SpecificID itemID);
 
    SolidSurface* getSolidSurface(SpecificID surfaceID);
 
    Player* getPlayer(SpecificID playerID);
 
    DungeonMaster* getDM();
 
    Enemy* getEnemy(SpecificID enemyID);
 
    Torchlight* getTorchlight(SpecificID torchlightID);
 
    Trap* getTrap(SpecificID trapID);
 
    SmartVector<Object*> getObjects();
 
    SmartVector<Object*> getMovableObjects();
 
    SmartVector<Item*> getItems();
 
    SmartVector<SolidSurface*> getSolidSurfaces();
 
    SmartVector<Player*> getPlayers();
 
    SmartVector<Enemy*> getEnemies();
 
    SmartVector<Trap*> getTraps();
 
    SmartVector<Projectile*> getProjectiles();
 
    SmartVector<Torchlight*> getTorchlights();
 
    SmartVector<WeaponCollider*> getWeaponColliders();
 
    SmartVector<Exit*> getExits();
 
    /*  Object Movement */
    
    bool moveObject(Object* object, glm::vec3 newCornerPosition);
 
    std::vector<glm::ivec2> objectGridCells(Object* object);
 
    std::unordered_map<glm::ivec2, std::vector<Object*>> cellToObjects;
 
    /*  SharedGameState generation  */
    
    std::vector<boost::optional<SharedObject>> toShared();
 
private:
 
    SpecificID _createObject(Object* object, boost::optional<EntityID> id = boost::none);
 
    /*
     * Note on how Objects are stored:
     * 
     * The ObjectManager class maintains a SmartVector<Object *> objects vector
     * that holds pointers to all Objects in the game instance at the current
     * timestep.
     * 
     * The global objects SmartVector is indexed by each object's global
     * EntityID; that is, if an object's EntityID is x, then a pointer to that
     * object is stored in index x of the objects SmartVector.
     * 
     * The Objects are dynamically allocated on the heap when created, meaning
     * there is no guaranteed contiguous object storage in memory.
     * 
     * Type-specific vectors are available for convenience and contain duplicate
     * pointers; e.g., a SmartVector<Item *> will contain Item * pointers to all
     * objects whose types derive from Item.
     * 
     * The type-specific vectors are indexed by their objects' type-specific
     * SpecificID; that is, if an object is stored in SmartVector<Item *> items
     * and its SpecificID is x, then at index x of items is a pointer to that
     * object.
     * 
     * As each object has only one type-specific SpecificID, each object may
     * only be stored in one type-specific SmartVector.
     */
 
    SmartVector<Object *> objects;
 
    SmartVector<Object*> movableObjects;
 
    /*  Type-specific object smart vectors  */
    
    SmartVector<Object *> base_objects;
 
    SmartVector<Item *> items;
 
    SmartVector<SolidSurface *> solid_surfaces;
 
    SmartVector<Player *> players;
 
    SmartVector<Enemy *> enemies;
 
    SmartVector<Torchlight *> torchlights;
 
    SmartVector<Trap *> traps;
 
    SmartVector<Projectile *> projectiles;
 
    SmartVector<WeaponCollider*> weaponColliders;
 
    SmartVector<Exit*> exits;
 
    DungeonMaster * dm; 
};