GameManager.hpp

Go to the documentation of this file.

 
#ifndef RTYPE_GAME_GAMEMANAGER_HPP_
    #define RTYPE_GAME_GAMEMANAGER_HPP_
 
    #include <cstdint>
    #include <string>
    #include <vector>
    #include <memory>
    #include <map>
    #include <mutex>
    #include <thread>
    #include <chrono>
    
    #include "RType/Logger.hpp"
    #include "Game/Room.hpp"
    #include "Game/Player.hpp"
    #include "ServerNetwork/ServerNetwork.hpp"
    #include "RType/ECS/Registry.hpp"
 
    /* Systems */
    #include "Systems/NetworkSyncSystem.hpp"
    #include "Systems/MovementSystem.hpp"
    #include "Systems/AuthSystem.hpp"
    #include "Systems/RoomSystem.hpp"
    #include "Systems/PlayerSystem.hpp"
    #include "Systems/EntitySystem.hpp"
    #include "Systems/PlayerMouvementSystem.hpp"
    #include "Systems/PlayerShootSystem.hpp"
    #include "Systems/EnemyAISystem.hpp"
    #include "Systems/LevelSystem.hpp"
    #include "Systems/CollisionSystem.hpp"
    #include "Systems/EnemyShootSystem.hpp"
    #include "Systems/BulletCleanupSystem.hpp"
    #include "Systems/HomingSystem.hpp"
    #include "Systems/BoomerangSystem.hpp"
 
    /* Components */
    #include "RType/ECS/Components/InputComponent.hpp"
    #include "RType/ECS/Components/Transform.hpp"
    #include "RType/ECS/Components/Velocity.hpp"
    #include "RType/ECS/Components/NetworkId.hpp"
    #include "RType/ECS/Components/EntityType.hpp"
    #include "RType/ECS/Components/SimpleWeapon.hpp"
    #include "RType/ECS/Components/Ammo.hpp"
    #include "RType/ECS/Components/MouvementPattern.hpp"
    #include "RType/ECS/Components/Health.hpp"
    #include "RType/ECS/Components/BoundingBox.hpp"
    #include "RType/ECS/Components/Damage.hpp"
    #include "RType/ECS/Components/Powerup.hpp"
    #include "RType/ECS/Components/MovementSpeed.hpp"
    #include "RType/ECS/Components/Shield.hpp"
    #include "RType/ECS/Components/DoubleFire.hpp"
    #include "RType/ECS/Components/Homing.hpp"
    #include "RType/ECS/Components/Boomerang.hpp"
 
namespace rtp::server
{
    class GameManager {
        public:
            GameManager(ServerNetwork &networkManager);
 
            ~GameManager();
 
            void gameLoop(void);
 
            void startGame(Room &room);
 
        private:
            // Network Event Processing
            
            void processNetworkEvents(void);
 
            void handlePlayerConnect(uint32_t sessionId);
 
            void handlePlayerDisconnect(uint32_t sessionId);
 
            void handlePlayerLoginAuth(uint32_t sessionId, const net::Packet &packet);
 
            void handlePlayerRegisterAuth(uint32_t sessionId, const net::Packet &packet);
 
            void handleListRooms(uint32_t sessionId);
 
            void handleCreateRoom(uint32_t sessionId, const net::Packet &packet);
 
            void handleJoinRoom(uint32_t sessionId, const net::Packet &packet);
 
            void handleLeaveRoom(uint32_t sessionId, const net::Packet &packet);
 
            void handleSetReady(uint32_t sessionId, const net::Packet &packet);
 
            void handleUpdateSelectedWeapon(uint32_t sessionId, const net::Packet &packet);
 
            void handleRoomChatSended(uint32_t sessionId, const net::Packet &packet);
 
            void handlePacket(uint32_t sessionId, const net::Packet &packet);
            void handlePing(uint32_t sessionId, const net::Packet &packet);
 
            bool handleChatCommand(PlayerPtr player, const std::string& message);
            void sendChatToSession(uint32_t sessionId, const std::string& message);
            void sendSystemMessageToRoom(uint32_t roomId, const std::string& message);
 
            void sendEntitySpawnToSessions(const ecs::Entity& entity,
                                           const std::vector<uint32_t>& sessions);
            void sendRoomEntitySpawnsToSession(uint32_t roomId, uint32_t sessionId);
 
        private:
            ServerNetwork &_networkManager;                            
            ecs::Registry _registry;                              
            std::unique_ptr<NetworkSyncSystem> _networkSyncSystem; 
            std::unique_ptr<MovementSystem> _movementSystem;           
            std::unique_ptr<AuthSystem> _authSystem;                   
            std::unique_ptr<RoomSystem> _roomSystem;                   
            std::unique_ptr<PlayerSystem> _playerSystem;               
            std::unique_ptr<EntitySystem> _entitySystem;               
            std::unique_ptr<PlayerMouvementSystem> _playerMouvementSystem; 
            std::unique_ptr<PlayerShootSystem> _playerShootSystem;      
            std::unique_ptr<EnemyAISystem> _enemyAISystem;              
            std::unique_ptr<LevelSystem> _levelSystem;                  
            std::unique_ptr<HomingSystem> _homingSystem;                
            std::unique_ptr<BoomerangSystem> _boomerangSystem;          
            std::unique_ptr<CollisionSystem> _collisionSystem;          
            std::unique_ptr<EnemyShootSystem> _enemyShootSystem;        
            std::unique_ptr<BulletCleanupSystem> _bulletCleanupSystem;  
            uint32_t _serverTick = 0;                                  
            mutable std::mutex _mutex;                                 
            bool _gamePaused = false;                                  
            float _gameSpeed = 1.0f;                                   
    };
}
 
#endif // RTYPE_GAME_GAMEMANAGER_HPP_