sharedobject.hpp

Go to the documentation of this file.

#pragma once
 
#include <optional>
#include <algorithm>
#include <glm/glm.hpp>
 
#include "shared/utilities/serialize_macro.hpp"
#include "shared/utilities/typedefs.hpp"
#include "shared/game/stat.hpp"
#include "shared/game/sharedmodel.hpp"
#include "shared/game/celltype.hpp"
#include "shared/game/status.hpp"
#include <chrono>
 
enum class ObjectType {
    Object, //  Generic object type (base class)
    SolidSurface,
    Potion,
    Player,
    Enemy,
    Torchlight,
    SpikeTrap,
    DungeonMaster,
    FireballTrap,
    Projectile,
    FloorSpike,
    Lava,
    FakeWall,
    ArrowTrap,
    TeleporterTrap,
    Spell,
    Slime,
    Minotaur,
    Python,
    Item,
    Exit,
    Orb,
    Weapon,
    WeaponCollider,
    Mirror
};
 
std::string objectTypeString(ObjectType type);
 
struct SharedStats {
    SharedStats():
        health(0,0,0), speed(0,0,0) {}
    SharedStats(Stat<int>&& health, Stat<int>&& speed):
        health(health), speed(speed) {}
 
    Stat<int> health;
    Stat<int> speed;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & health & speed;
    }
};
 
struct SharedStatuses {
public:
    SharedStatuses() = default;
 
    void addStatus(Status st, size_t len);
 
    std::vector<std::string> getStatusStrings() const;
 
    void tickStatus();
 
    size_t getStatusLength(Status st) const;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & map;
    }
 
private:
    std::unordered_map<Status, size_t> map;
};
 
 
using UsedItemsMap = std::unordered_map<SpecificID, std::pair<ModelType, double>>;
 
struct SharedInventory {
    // need to share itemtype data...
    int selected;
    int inventory_size;
    std::vector<ModelType> inventory;   // For GUI model
    std::vector<int> usesRemaining;     // For GUI text description
    UsedItemsMap usedItems;             // For GUI effect duration
 
    bool hasOrb;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar& selected& inventory_size& inventory& usedItems & hasOrb& usesRemaining;
    }
}; 
 
struct SharedTrapInventory {
    // need to share itemtype data...
    int selected;
    int inventory_size;
    std::vector<ModelType> inventory;
    std::unordered_map<CellType, std::time_t> trapsInCooldown;
    std::unordered_map<CellType, int> trapsCooldown;
    int trapsPlaced;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar& selected& inventory_size& inventory& trapsInCooldown& trapsPlaced & trapsCooldown;
    }
};
 
struct SharedItemInfo {
    bool held; // for rendering
    bool used; // for rendering
    double remaining_time;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar& used& held& remaining_time;
    }
};
 
struct SharedWeaponInfo {
    bool attacked;
    bool lightning;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar& attacked& lightning;
    }
};
 
enum class SurfaceType {
    Wall,
    Floor,
    Ceiling,
    Pillar,
};
 
struct SharedSolidSurface {
    SurfaceType surfaceType;
 
    bool is_internal;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & surfaceType & is_internal;
    }
};
 
struct SharedPhysics {
    glm::vec3 corner;
 
    glm::vec3 facing;
 
    glm::vec3 dimensions;
 
    glm::vec3 getCenterPosition() const;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar& corner& facing & dimensions;
    }
};
 
struct SharedTrapInfo {
    bool triggered;
    bool dm_hover;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & triggered & dm_hover;
    }
};
 
struct SharedPlayerInfo {
    bool is_alive;
    time_t respawn_time; // unix timestamp in ms when the player will be respawned
    bool render; // for invis potion
    bool used_mirror_to_reflect_lightning;  //  To tell the player that they successfully reflected lightning
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & is_alive & respawn_time & render & used_mirror_to_reflect_lightning;
    }
};
 
struct SharedPointLightInfo {
    float intensity;
    // lighting properties of that the light source
    // emits
    glm::vec3 ambient_color;
    glm::vec3 diffuse_color;
    glm::vec3 specular_color; // shiny effects
    // these two affect the dropoff of the light intensity
    // as distance increases
    float attenuation_linear;
    float attenuation_quadratic;
 
    bool is_cut = false;
 
    DEF_SERIALIZE(Archive& ar, const int version) {
        ar & intensity & ambient_color & diffuse_color & specular_color &
            attenuation_linear & attenuation_quadratic & is_cut;
    }
};
 
struct SharedExit {
    bool open;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & open;
    }
};
 
enum class AnimState {
    IdleAnim,
    WalkAnim,
    SprintAnim,
    JumpAnim,
    LandAnim,
    AttackAnim,
    DrinkPotionAnim,
    DeathAnim
};
 
struct SharedDMInfo {
    bool paralyzed;
 
    int mana_remaining;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & paralyzed & mana_remaining;
    }
};
 
 
struct SharedCompass {
 
    float angle;
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar& angle;
    }
};
 
class SharedObject {
public:
    EntityID globalID;
    ObjectType type;
    SharedPhysics physics;
    ModelType modelType;
    AnimState animState;
 
    boost::optional<SharedStats> stats;
    boost::optional<SharedItemInfo> iteminfo;
    boost::optional<SharedSolidSurface> solidSurface;
    boost::optional<SharedTrapInfo> trapInfo;
    boost::optional<SharedPlayerInfo> playerInfo;
    boost::optional<SharedInventory> inventoryInfo;
    boost::optional<SharedTrapInventory> trapInventoryInfo;
    boost::optional<SharedPointLightInfo> pointLightInfo;
    boost::optional<SharedStatuses> statuses;
    boost::optional<SharedExit> exit;
    boost::optional<SharedWeaponInfo> weaponInfo;
    boost::optional<SharedDMInfo> DMInfo;
    boost::optional<SharedCompass> compass;
 
    SharedObject() {} // cppcheck-suppress uninitMemberVar
    ~SharedObject() {}
     
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & globalID & type & physics & modelType & animState & stats & 
             iteminfo & solidSurface & trapInfo & playerInfo & 
             inventoryInfo & statuses & trapInventoryInfo & pointLightInfo &
             exit & weaponInfo & DMInfo & compass;
    }
private:
};