servergamestate.hpp

Go to the documentation of this file.

#pragma once
 
#include "server/game/gridcell.hpp"
#include "shared/utilities/constants.hpp"
#include "shared/utilities/typedefs.hpp"
#include "shared/game/sharedgamestate.hpp"
#include "shared/utilities/config.hpp"
#include "shared/utilities/smartvector.hpp"
#include "shared/utilities/custom_hash.hpp"
#include "server/audio/soundtable.hpp"
#include "server/game/object.hpp"
#include "shared/game/event.hpp"
#include "server/game/grid.hpp"
#include "server/game/objectmanager.hpp"
#include "server/game/spawner.hpp"
 
#include <string>
#include <vector>
#include <chrono>
#include <unordered_map>
#include <queue>
#include <boost/container_hash/hash.hpp>
 
using EventList = std::vector<std::pair<EntityID, Event>>;
 
struct IntPairHash {
    size_t operator()(const std::pair<int, int>& pair) const {
        std::size_t c = 0;
 
        boost::hash_combine(c, pair.first);
        boost::hash_combine(c, pair.second);
 
        return c;
    }
};
 
class ServerGameState {
public:
    ObjectManager objects;
 
    std::unique_ptr<Spawner> spawner;
 
    ServerGameState();
 
    explicit ServerGameState(GamePhase start_phase);
 
    ServerGameState(GamePhase start_phase, const GameConfig& config);
 
    explicit ServerGameState(GameConfig config);
 
    ~ServerGameState();
 
    void update(const EventList& events);
 
    void markForDeletion(EntityID id);
 
    void markAsUpdated(EntityID id);
 
    //  TODO: Add specific update methods (E.g., updateMovement() to update
    //  object movement)
 
    void updateMovement();
 
    bool hasObjectCollided(Object* object, glm::vec3 newCornerPosition);
 
    void updateItems();
 
    void updateAttacks();
 
    void updateEnemies();
 
    void doProjectileTicks();
 
    void doTorchlightTicks();
 
    void updateTraps();
 
    void handleDeaths();
 
    void handleRespawns();
 
    void handleDM();
 
    void updateCompass();
 
    void tickStatuses();
 
    void spawnEnemies();
 
    void handleTickVelocity();
 
    void deleteEntities();
 
    void updatePlayerLightningInvulnerabilityStatus();
 
    void updateDungeonMasterParalysis();
 
    /*  SharedGameState generation  */
 
    //  TODO: Modify this function to dynamically allocate a SharedGameState
    //  instance and return a pointer (perhaps a unique pointer) to it
    std::vector<SharedGameState> generateSharedGameState(bool send_all);
 
    /* Audio Information */
    SoundTable& soundTable();
 
    /*  Other getters and setters   */
 
    unsigned int getTimestep() const;
 
    GamePhase getPhase() const;
 
    void setPhase(GamePhase phase);
 
    MatchPhase getMatchPhase() const;
 
    void transitionToRelayRace();
 
    void setPlayerVictory(bool playerVictory);
 
    void addPlayerToLobby(LobbyPlayer player);
 
    void updateLobbyPlayer(EntityID id, LobbyPlayer player);
 
    void removePlayerFromLobby(EntityID id);
 
    const Lobby& getLobby() const;
 
    Trap* placeTrapInCell(GridCell* cell, CellType type);
 
    /*  Maze initialization */
    
    void loadMaze(const Grid& grid);
 
    /*  Maze getters    */
 
    Grid& getGrid();
 
    /*  Debugger Methods    */
 
    std::string to_string();
 
private:
    std::unordered_set<EntityID> entities_to_delete;
 
    std::unordered_set<EntityID> updated_entities;
 
    unsigned int timestep;
 
    Lobby lobby;
 
    GamePhase phase;
 
    MatchPhase matchPhase;
 
    time_t relay_finish_time;
 
    bool playerVictory;
 
    unsigned int numPlayerDeaths;
 
    std::string maze_file;
 
    std::string maps_directory;
 
    Grid grid;
 
    std::unordered_set<std::pair<Object*, Object*>, pair_hash> collidedObjects;
 
    Trap* currentGhostTrap;
 
    std::optional<glm::vec3> dmLightningCutLights;
 
    std::optional<glm::vec3> dmActionCutLights;
 
    unsigned int lastLightCut;
 
    unsigned int lastLightningLightCut;
 
    void spawnWall(GridCell* cell, int col, int row, bool is_internal);
 
    void spawnTorch(GridCell *cell, glm::vec3 orb_pos, glm::vec3 exit_pos);
 
    Trap* spawnFireballTrap(GridCell *cell);
 
    Trap* spawnArrowTrap(GridCell* cell);
 
    Trap* spawnFloorSpike(GridCell* cell);
 
    Trap* spawnLava(GridCell* cell);
 
    std::unordered_map<EntityID, std::array<std::optional<EntityID>, MAX_POINT_LIGHTS>> lightSourcesPerPlayer;
 
    SoundTable sound_table;
 
    GameConfig config;
};