sharedgamestate.hpp

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
#include <chrono>
#include <vector>
#include <boost/serialization/string.hpp>
 
//#include "server/game/servergamestate.hpp"
#include "shared/game/sharedobject.hpp"
#include "shared/utilities/smartvector.hpp"
#include "shared/utilities/serialize_macro.hpp"
#include "shared/utilities/config.hpp"
//#include "server/game/constants.hpp"
#include "shared/game/constants.hpp"
 
//  Forward declaration of PlayerRole enum to avoid circular reference
enum class PlayerRole;
 
enum class GamePhase {
    TITLE_SCREEN,
    LOBBY,
    INTRO_CUTSCENE,
    GAME,
    RESULTS
};
 
enum class MatchPhase {
    MazeExploration,
    RelayRace
};
 
struct LobbyPlayer {
    EntityID id;
 
    PlayerRole desired_role;
 
    bool ready;
 
    LobbyPlayer() {}
 
    LobbyPlayer(EntityID id, PlayerRole desired_role, bool ready)
        : id(id), desired_role(desired_role), ready(ready) {}
 
    DEF_SERIALIZE(Archive& ar, unsigned int version) {
        ar& id& desired_role & ready;
    }
 
    /*  Debug Methods   */
    
    std::string to_string(unsigned int tab_offset);
    std::string to_string() { return this->to_string(0); }
};
 
struct Lobby {
    std::string name;
 
    std::vector<boost::optional<LobbyPlayer>> players;
 
    int max_players;
 
    Lobby() : Lobby(4) {}
 
    explicit Lobby(int max_players) : Lobby("Default Lobby Name", max_players) {}
 
    Lobby(const std::string& name, int max_players) : name(name), max_players(max_players) {
        //  Reserve max_players slots in the players vector
        for (int i = 0; i < max_players; i++) {
            this->players.push_back(boost::none);
        }
    }
 
    const boost::optional<LobbyPlayer>& getPlayer(int playerIndex) const;
 
    const boost::optional<LobbyPlayer>& getPlayer(EntityID id) const;
 
    int numPlayersInLobby() const;
 
 
    DEF_SERIALIZE(Archive& ar, unsigned int version) {
        ar & name & players & max_players;
    }
 
    //  TODO: Add a player role listing? I.e., which player is playing which
    //  character and which player is playing as the Dungeon Master?
 
    /*  Debug Methods   */
 
    std::string to_string(unsigned int tab_offset) const;
    std::string to_string() const { return this->to_string(0); }
};
 
struct SharedGameState {
    std::unordered_map<EntityID, boost::optional<SharedObject>> objects;
 
    unsigned int timestep;
 
    Lobby lobby;
 
    GamePhase phase;
 
    MatchPhase matchPhase;
 
    time_t relay_finish_time;
 
    bool playerVictory;
 
    unsigned int numPlayerDeaths;
 
    SharedGameState():
        objects(std::unordered_map<EntityID, boost::optional<SharedObject>>())
    {
        this->phase = GamePhase::TITLE_SCREEN;
        this->timestep = FIRST_TIMESTEP;
        this->lobby.max_players = MAX_PLAYERS;
        this->matchPhase = MatchPhase::MazeExploration;
        this->relay_finish_time = 0;
        this->playerVictory = false;
        this->numPlayerDeaths = 0;
    }
 
    SharedGameState(GamePhase start_phase, const GameConfig& config):
        objects(std::unordered_map<EntityID, boost::optional<SharedObject>>())
    {
        this->phase = start_phase;
        this->timestep = FIRST_TIMESTEP;
        this->lobby.max_players = config.server.max_players;
        this->lobby.name = config.server.lobby_name;
        this->matchPhase = MatchPhase::MazeExploration;
        this->relay_finish_time = 0;
        this->playerVictory = false;
        this->numPlayerDeaths = 0;
    }
 
    DEF_SERIALIZE(Archive& ar, const unsigned int version) {
        ar & objects & timestep & lobby & phase & matchPhase
            & relay_finish_time & playerVictory & numPlayerDeaths;
    }
 
    void update(const SharedGameState& update);
};