GameLogic.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** rtype
** File description:
** GameLogic.hpp - Server-side game logic implementation
*/
 
#pragma once
 
#include <atomic>
#include <deque>
#include <memory>
#include <mutex>
#include <unordered_map>
#include <vector>
#include "common/ECSWrapper/ECSWorld.hpp"
#include "server/Game/Logic/IGameLogic.hpp"
#include "server/Game/Rules/GameRules.hpp"
#include "server/Game/StateManager/GameStateManager.hpp"
 
namespace scripting {
    class LuaEngine;
    class LuaSystemAdapter;
}  // namespace scripting
 
namespace ecs {
    class ISystem;
}
 
namespace server {
    class ThreadPool;
    class EventBus;
 
    class GameLogic : public IGameLogic {
       public:
        explicit GameLogic(std::shared_ptr<ecs::wrapper::ECSWorld> world = nullptr,
                           std::shared_ptr<ThreadPool> threadPool = nullptr,
                           std::shared_ptr<EventBus> eventBus = nullptr);
 
        ~GameLogic() override;
 
        bool initialize() override;
        void update(float deltaTime, uint32_t currentTick) override;
        uint32_t spawnPlayer(uint32_t playerId, const std::string &playerName) override;
        void despawnPlayer(uint32_t playerId) override;
        void processPlayerInput(uint32_t playerId, int inputX, int inputY, bool isShooting,
                                uint32_t sequenceId) override;
 
        uint32_t getLastProcessedInput(uint32_t playerId) const override {
            std::lock_guard<std::mutex> lock(_inputMutex);
            auto it = _lastAppliedSequenceId.find(playerId);
            return (it != _lastAppliedSequenceId.end()) ? it->second : 0;
        }
 
        ecs::Registry &getRegistry() override { return _world->getRegistry(); }
        bool isGameActive() const override { return _gameActive; }
        void resetGame() override;
        void onGameStart();
 
        std::shared_ptr<ecs::wrapper::ECSWorld> getECSWorld() { return _world; }
 
        std::shared_ptr<GameStateManager> getStateManager() { return _stateManager; }
 
        GameRules &getGameRules() { return _gameRules; }
 
        const GameRules &getGameRules() const override { return _gameRules; }
 
        bool loadMap(const std::string &mapFilePath);
 
       private:
        void _executeSystems(float deltaTime);
 
        void _processInput();
 
        void _cleanupDeadEntities();
 
        void _checkGameOverCondition();
 
        // ECS World
        std::shared_ptr<ecs::wrapper::ECSWorld> _world;
 
        // Lua scripting
        std::unique_ptr<scripting::LuaEngine> _luaEngine;
 
        // Player management
        std::unordered_map<uint32_t, ecs::Address> _playerMap;  // playerId -> entityAddress
 
        // Input queue
        struct PlayerInput {
            uint32_t playerId;
            int inputX;
            int inputY;
            bool isShooting;
            uint32_t sequenceId;
        };
 
        void _applyPlayerInput(uint32_t playerId, const PlayerInput &input);
 
        // Per-player input queue (FIFO)
        // Use deque for efficient front removal
        std::unordered_map<uint32_t, std::deque<PlayerInput>> _pendingInput;
 
        // Last processed input sequence ID per player (for redundancy)
        std::unordered_map<uint32_t, uint32_t> _lastReceivedSequenceId;
        std::unordered_map<uint32_t, uint32_t> _lastAppliedSequenceId;
 
        // Game state
        std::shared_ptr<GameStateManager> _stateManager;
        std::shared_ptr<ThreadPool> _threadPool;  // Optional: for parallel system execution
        std::shared_ptr<EventBus> _eventBus;      // Optional: for publishing events
        bool _gameActive{false};
        bool _hadPlayers{false};  // Track if any players have joined the game
        std::atomic<bool> _initialized{false};
 
        // Thread synchronization
        mutable std::mutex _inputMutex;  // Protects _pendingInput
        std::mutex _playerMutex;         // Protects _playerMap
 
        // Game rules
        GameRules _gameRules;
 
        // Constants
        static constexpr float FIXED_TIMESTEP = 1.0f / 60.0f;  // 60 Hz
    };
 
}  // namespace server