Room.hpp

Go to the documentation of this file.

 
#ifndef RTYPE_GAME_ROOM_HPP_
    #define RTYPE_GAME_ROOM_HPP_
 
    #include <cstdint>
    #include <string>
    #include <vector>
    #include <mutex>    
    #include "Game/Player.hpp"
    #include <memory>
    #include <list>
    #include <algorithm>
    #include <unordered_set>
    #include "RType/Network/Packet.hpp"
    #include "Systems/NetworkSyncSystem.hpp"
    #include "RType/ECS/Registry.hpp"
 
namespace rtp::server
{
    class Room {
        public:
            enum State {
                Waiting,        
                InGame,         
                Finished        
            };
 
            enum RoomType {
                Lobby,          
                Public,         
                Private         
            };
 
            enum PlayerType {
                None,          
                Player,        
                Spectator      
            };
 
        public:
            Room(ecs::Registry& registry, NetworkSyncSystem& network, uint32_t id, const std::string &name,
                 uint32_t maxPlayers, float difficulty, float speed, RoomType type,
                 uint32_t creatorSessionId = 0, uint32_t levelId = 1, uint32_t seed = 0,
                 uint32_t durationMinutes = 0);
 
            ~Room();
 
            bool canJoin(void) const;
 
            bool addPlayer(const PlayerPtr &player, PlayerType type = PlayerType::Player);
 
            void removePlayer(uint32_t sessionId, bool disconnected = false);
 
            const std::list<PlayerPtr> getPlayers(void) const;
 
            uint32_t getId(void) const;
 
            RoomType getType(void) const;
 
            float getDifficulty(void) const;
 
            float getSpeed(void) const;
 
            uint32_t getLevelId(void) const;
 
            uint32_t getSeed(void) const;
 
            uint32_t getDurationMinutes(void) const;
 
            PlayerType getPlayerType(uint32_t sessionId) const;
 
            void setPlayerType(uint32_t sessionId, PlayerType type);
 
            bool hasActivePlayers() const;
 
            std::string getName(void) const;
 
            uint32_t getMaxPlayers(void) const;
 
            uint32_t getCurrentPlayerCount(void) const;
 
            State getState(void) const;
 
            bool startGame(float dt);
 
            void forceFinishGame(void);
 
            void update(uint32_t serverTick, float dt);
 
            void broadcastRoomState(uint32_t serverTick);
 
            void banUser(const std::string &username);
            bool isBanned(const std::string &username) const;
 
        private:
            void broadcastSystemMessage(const std::string &message);
            NetworkSyncSystem _network;       
            ecs::Registry& _registry;    
            uint32_t _id;                     
            std::string _name;                
            uint32_t _maxPlayers;             
            std::list<std::pair<PlayerPtr, PlayerType>>
                _players;                     
            State _state;                     
            RoomType _type;                   
            uint32_t _creatorSessionId;       
            std::pair<std::string, int>
                _bestRoomScore;               
            uint32_t _levelId = 0;            
            uint32_t _seed = 0;               
            float _difficulty = 0;            
            float _speed = 0;                 
            uint32_t durationMinutes = 0;     
            float _startedDt = 0.0f;          
            uint32_t _currentTimeSeconds;     
            mutable std::mutex _mutex;        
            std::unordered_set<std::string> _bannedUsers; 
            float _scoreTick{0.0f};          
    };
} // namespace rtp::server
 
#endif /* !RTYPE_GAME_ROOM_HPP_ */