GameLogic.cpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** rtype
** File description:
** GameLogic.cpp - Server-side game logic implementation
*/
 
#include "server/Game/Logic/GameLogic.hpp"
#include <algorithm>
#include <atomic>
#include <cmath>
#include <thread>
#include "common/Animation/AnimationDatabase.hpp"
#include "common/ECS/Components/Animation.hpp"
#include "common/ECS/Components/AnimationSet.hpp"
#include "common/ECS/Components/Collider.hpp"
#include "common/ECS/Components/Enemy.hpp"
#include "common/ECS/Components/Health.hpp"
#include "common/ECS/Components/LuaScript.hpp"
#include "common/ECS/Components/PendingDestroy.hpp"
#include "common/ECS/Components/Player.hpp"
#include "common/ECS/Components/Projectile.hpp"
#include "common/ECS/Components/Spawner.hpp"
#include "common/ECS/Components/Sprite.hpp"
#include "common/ECS/Components/Transform.hpp"
#include "common/ECS/Components/Velocity.hpp"
#include "common/ECS/Components/Weapon.hpp"
#include "common/ECS/Prefabs/PrefabFactory.hpp"
#include "common/ECS/Systems/AISystem/AISystem.hpp"
#include "common/ECS/Systems/AnimationSystem/AnimationSystem.hpp"
#include "common/ECS/Systems/BoundarySystem/BoundarySystem.hpp"
#include "common/ECS/Systems/BuffSystem/BuffSystem.hpp"
#include "common/ECS/Systems/CollisionSystem/CollisionSystem.hpp"
#include "common/ECS/Systems/HealthSystem/HealthSystem.hpp"
#include "common/ECS/Systems/ISystem.hpp"
#include "common/ECS/Systems/MapSystem/MapSystem.hpp"
#include "common/ECS/Systems/MovementSystem/MovementSystem.hpp"
#include "common/ECS/Systems/OrbitalSystem/OrbitalSystem.hpp"
#include "common/ECS/Systems/SpawnSystem/SpawnSystem.hpp"
#include "common/ECS/Systems/WeaponSystem/WeaponSystem.hpp"
#include "common/Logger/Logger.hpp"
#include "common/MapLoader/MapLoader.hpp"
#include "server/Core/EventBus/EventBus.hpp"
#include "server/Core/ThreadPool/ThreadPool.hpp"
#include "server/Events/GameEvent/GameEndedEvent.hpp"
#include "server/Game/StateManager/GameOverState.hpp"
#include "server/Game/StateManager/InGameState.hpp"
#include "server/Game/StateManager/LobbyState.hpp"
#include "server/Scripting/LuaEngine.hpp"
#include "server/Scripting/LuaSystemAdapter.hpp"
 
namespace server {
 
    GameLogic::GameLogic(std::shared_ptr<ecs::wrapper::ECSWorld> world,
                         std::shared_ptr<ThreadPool> threadPool, std::shared_ptr<EventBus> eventBus)
        : _stateManager(std::make_shared<GameStateManager>()),
          _threadPool(threadPool),
          _eventBus(eventBus),
          _gameActive(false) {
        // Create ECSWorld if not provided
        if (!world) {
            _world = std::make_shared<ecs::wrapper::ECSWorld>();
        } else {
            _world = world;
        }
 
        if (_threadPool) {
            LOG_INFO("GameLogic: ThreadPool enabled for parallel execution (", _threadPool->size(),
                     " workers)");
        } else {
            LOG_DEBUG("GameLogic: Running in single-threaded mode");
        }
 
        // Initialize Lua scripting engine
        _luaEngine = std::make_unique<scripting::LuaEngine>("server/Scripting/scripts/");
        _luaEngine->setWorld(_world.get());
        LOG_INFO("GameLogic: Lua scripting engine initialized");
        if (_eventBus) {
            LOG_DEBUG("GameLogic: EventBus enabled for event publishing");
        }
 
        LOG_DEBUG("GameLogic: GameStateManager initialized");
    }
 
    GameLogic::~GameLogic() = default;
 
    bool GameLogic::initialize() {
        if (_initialized.exchange(true)) {
            return true;  // Already initialized
        }
 
        try {
            LOG_INFO("Initializing game logic...");
 
            // Create and register all systems with ECSWorld in execution order
            _world->createSystem<ecs::MovementSystem>("MovementSystem");
            _world->createSystem<ecs::OrbitalSystem>("OrbitalSystem");
            _world->createSystem<ecs::AnimationSystem>("AnimationSystem");
            _world->createSystem<ecs::MapSystem>("MapSystem");
            _world->createSystem<ecs::CollisionSystem>("CollisionSystem");
            _world->createSystem<ecs::BuffSystem>("BuffSystem");
            _world->createSystem<ecs::HealthSystem>("HealthSystem");
 
            // Register Lua system BEFORE SpawnSystem so wave_manager can queue spawns
            auto luaSystem = std::make_unique<scripting::LuaSystemAdapter>(_luaEngine.get(), _world.get());
            _world->registerSystem("Lua", std::move(luaSystem));
            LOG_INFO("✓ Lua system registered (executes before spawn processing)");
 
            // SpawnSystem processes spawn requests queued by Lua scripts
            _world->createSystem<ecs::SpawnSystem>("SpawnSystem");
 
            _world->createSystem<ecs::AISystem>("AISystem");
            _world->createSystem<ecs::BoundarySystem>("BoundarySystem");
            _world->createSystem<ecs::WeaponSystem>("WeaponSystem");
 
            LOG_INFO("✓ All systems registered (", _world->getSystemCount(), " systems)");
            if (_threadPool) {
                LOG_INFO("✓ Systems will execute in parallel mode (4 groups)");
            } else {
                LOG_INFO("✓ Systems will execute sequentially");
            }
 
            // Initialize game state manager with states
            _stateManager->registerState(0, std::make_shared<LobbyState>());
            _stateManager->registerState(1, std::make_shared<InGameState>());
            _stateManager->registerState(2, std::make_shared<GameOverState>());
 
            // Connect EventBus to GameStateManager so it can publish events
            if (_eventBus) {
                _stateManager->setEventBus(_eventBus);
            }
 
            // Start in InGame state (skip lobby for dev)
 
            _stateManager->changeState(1);
 
            LOG_INFO("✓ GameStateManager initialized with 3 states");
 
            _gameActive = true;
 
            LOG_INFO("✓ Initialization complete!");
            return true;
        } catch (const std::exception &e) {
            LOG_ERROR("Initialization failed: ", e.what());
            _initialized.store(false);
            return false;
        }
    }
 
    void GameLogic::update(float deltaTime, uint32_t lcurrentTick) {
        (void)lcurrentTick;  // Unused for now
        if (!_gameActive) {
            return;
        }
 
        // 1. Process accumulated player input
        _processInput();
 
        if (_stateManager) {
            _stateManager->update(deltaTime);
        }
 
        _executeSystems(deltaTime);
 
        _checkGameOverCondition();  // Check BEFORE cleaning up dead entities
 
        _cleanupDeadEntities();
    }
 
    uint32_t GameLogic::spawnPlayer(uint32_t playerId, const std::string &playerName) {
        try {
            LOG_INFO("Spawning player: ", playerName, " (ID: ", playerId, ")");
 
            // Check if player already exists
            if (_playerMap.contains(playerId)) {
                LOG_ERROR("Player ", playerId, " already exists!");
                return 0;
            }
 
            // Create new player entity using the wrapper API
            ecs::AnimationSet playerAnimations = AnimDB::createPlayerAnimations();
            ecs::wrapper::Entity playerEntity =
                _world->createEntity()
                    .with(ecs::Transform(_gameRules.getPlayerSpawnX(), _gameRules.getPlayerSpawnY()))
                    .with(ecs::Velocity(0.0f, 0.0f, _gameRules.getDefaultPlayerSpeed()))
                    .with(
                        ecs::Health(_gameRules.getDefaultPlayerHealth(), _gameRules.getDefaultPlayerHealth()))
                    .with(ecs::Player(0, 3, playerId))  // score=0, lives=3
                    .with(ecs::Collider(50.0f, 50.0f, 0.0f, 0.0f, 1, 0xFFFFFFFF, false))
                    .with(ecs::Weapon(_gameRules.getDefaultPlayerFireRate(), 0.0f, 0,
                                      _gameRules.getDefaultPlayerDamage()))
                    .with(ecs::Sprite("PlayerShips.gif", {1, 69, 33, 14}, 3.0f, 0.0f, false, false, 0))
                    .with(playerAnimations)
                    .with(ecs::Animation("player_idle"));
            ecs::Address entityAddress = playerEntity.getAddress();
 
            // Register player (protected by mutex for thread safety)
            {
                std::scoped_lock lock(_playerMutex);
                _playerMap[playerId] = entityAddress;
                _hadPlayers = true;  // Mark that at least one player has joined
            }
 
            LOG_INFO("✓ Player spawned at (", _gameRules.getPlayerSpawnX(), ", ",
                     _gameRules.getPlayerSpawnY(), ") with entity ID: ", entityAddress);
 
            // Spawn orbital drone for the player
            uint32_t droneId = ecs::PrefabFactory::createOrbitalModule(_world->getRegistry(), entityAddress,
                                                                       90.0f,  // radius
                                                                       1.2f,   // speed (rad/s)
                                                                       0.0f,   // start angle
                                                                       15,     // damage
                                                                       50      // health
            );
 
            if (droneId != 0) {
                LOG_INFO("✓ Orbital drone spawned for player (ID: ", droneId, ")");
            }
 
            return entityAddress;
        } catch (const std::exception &e) {
            LOG_ERROR("Failed to spawn player: ", e.what());
            return 0;
        }
    }
 
    void GameLogic::despawnPlayer(uint32_t playerId) {
        try {
            ecs::Address playerEntity = 0;
 
            // Find and remove player from map (protected by mutex)
            {
                std::scoped_lock lock(_playerMutex);
                auto it = _playerMap.find(playerId);
                if (it == _playerMap.end()) {
                    LOG_WARNING("Player ", playerId, " not found");
                    return;
                }
                playerEntity = it->second;
                _playerMap.erase(it);
            }
 
            LOG_INFO("Despawning player ", playerId, " (entity: ", playerEntity, ")");
 
            // Mark entity for destruction with proper client notification
            _world->getEntity(playerEntity)
                .with<ecs::PendingDestroy>(ecs::PendingDestroy(ecs::DestroyReason::Manual));
            LOG_INFO("✓ Player marked for destruction (will be processed in next tick)");
        } catch (const std::exception &e) {
            LOG_ERROR("Failed to despawn player: ", e.what());
        }
    }
 
    void GameLogic::processPlayerInput(uint32_t playerId, int inputX, int inputY, bool isShooting,
                                       uint32_t sequenceId) {
        std::scoped_lock lock(_inputMutex);
 
        // Filter duplicates (redundant inputs)
        // If we have already processed this sequence ID or a newer one, ignore it.
        auto it = _lastReceivedSequenceId.find(playerId);
        if (it != _lastReceivedSequenceId.end()) {
            if (sequenceId <= it->second) {
                return;  // Already processed
            }
        }
        _lastReceivedSequenceId[playerId] = sequenceId;
 
        // Add to queue
        _pendingInput[playerId].push_back({playerId, inputX, inputY, isShooting, sequenceId});
    }
 
    void GameLogic::_processInput() {
        std::scoped_lock lock(_inputMutex);
 
        for (auto &[playerId, inputs] : _pendingInput) {
            if (inputs.empty()) {
                continue;
            }
 
            // SMART JITTER BUFFER
            // Target buffer size: 2-3 frames (~33-50ms buffer)
            // Strategy:
            // - If buffer > 5: Speed up (process 2 inputs) -> Catch up lag
            // - If buffer < 1: Slow down (process 0 inputs) -> Build up buffer (handled by empty check)
            // - Normal: Process 1 input
 
            size_t inputsToProcess = 1;
            if (inputs.size() > 5) {
                inputsToProcess = 2;  // Catch up
            }
 
            for (size_t i = 0; i < inputsToProcess && !inputs.empty(); ++i) {
                const auto &input = inputs.front();
                _applyPlayerInput(playerId, input);
                inputs.pop_front();
            }
        }
    }
 
    void GameLogic::_applyPlayerInput(uint32_t playerId, const PlayerInput &input) {
        auto it = _playerMap.find(playerId);
        if (it == _playerMap.end()) {
            return;
        }
 
        ecs::Address playerEntity = it->second;
        try {
            // Get entity wrapper and check if it still exists
            ecs::wrapper::Entity entity = _world->getEntity(playerEntity);
 
            // Check if entity has required components (entity might be destroyed)
            if (!entity.has<ecs::Velocity>() || !entity.has<ecs::Transform>()) {
                LOG_WARNING("Player ", playerId,
                            " entity missing Velocity or Transform component (entity destroyed?)");
                return;
            }
 
            ecs::Velocity &vel = entity.get<ecs::Velocity>();
            ecs::Transform &transform = entity.get<ecs::Transform>();
 
            // Update animation based on movement
            if (entity.has<ecs::Animation>()) {
                ecs::Animation &anim = entity.get<ecs::Animation>();
 
                // If no input (0, 0), stop the player and play idle animation
                if (input.inputX == 0 && input.inputY == 0) {
                    vel.setDirection(0.0f, 0.0f);
 
                    // Switch to idle animation if currently moving
                    if (anim.getCurrentClipName() != "player_idle") {
                        anim.setCurrentClipName("player_idle");
                        anim.setCurrentFrameIndex(0);
                        anim.setTimer(0.0f);
                    }
                } else {
                    // Normalize diagonal movement
                    float dirX = static_cast<float>(input.inputX);
                    float dirY = static_cast<float>(input.inputY);
 
                    // Normalize if diagonal
                    if (dirX != 0.0f && dirY != 0.0f) {
                        float length = std::sqrt(dirX * dirX + dirY * dirY);
                        dirX /= length;
                        dirY /= length;
                    }
 
                    vel.setDirection(dirX, dirY);
 
                    // Switch to movement animation if currently idle
                    if (anim.getCurrentClipName() != "player_movement") {
                        anim.setCurrentClipName("player_movement");
                        anim.setCurrentFrameIndex(0);
                        anim.setTimer(0.0f);
                    }
                }
            } else {
                // Fallback if no Animation component (shouldn't happen for players)
                // Normalize diagonal movement
                float dirX = static_cast<float>(input.inputX);
                float dirY = static_cast<float>(input.inputY);
 
                // Normalize if diagonal
                if (dirX != 0.0f && dirY != 0.0f) {
                    float length = std::sqrt(dirX * dirX + dirY * dirY);
                    dirX /= length;
                    dirY /= length;
                }
 
                // CRITICAL: Apply movement directly here to match client-side prediction
                // The client predicts movement per-input at FIXED_TIMESTEP rate
                // We must do the same to stay synchronized
                float speed = vel.getSpeed();
                auto pos = transform.getPosition();
                float newX = pos.x + dirX * speed * FIXED_TIMESTEP;
                float newY = pos.y + dirY * speed * FIXED_TIMESTEP;
                transform.setPosition(newX, newY);
 
                // Keep velocity direction at (0,0) so MovementSystem doesn't apply additional movement
                // Player movement is entirely controlled by input processing, not by MovementSystem
                vel.setDirection(0.0f, 0.0f);
            }
 
            // Handle shooting
            auto &weapon = entity.get<ecs::Weapon>();
 
            if (input.isShooting) {
                if (entity.has<ecs::Weapon>()) {
                    weapon.setShouldShoot(true);
                }
            } else {
                if (entity.has<ecs::Weapon>()) {
                    weapon.setShouldShoot(false);
                }
            }
 
            _lastAppliedSequenceId[playerId] = input.sequenceId;
        } catch (const std::exception &e) {
            LOG_ERROR("Error applying input for player ", playerId, ": ", e.what());
        }
    }
 
    void GameLogic::_executeSystems(float deltaTime) {
        if (!_threadPool) {
            // Sequential execution (no ThreadPool)
            _world->update(deltaTime);
            return;
        }
 
        // Parallel execution with ThreadPool
        // Group systems by dependency - systems in the same group can run in parallel
 
        // Group 1: Independent systems (can run in parallel)
        std::vector<std::string> group1 = {"MovementSystem", "OrbitalSystem"};
 
        // Group 2: Animation must run after Movement to update sprite frames
        std::vector<std::string> group2 = {"AnimationSystem"};
 
        // Group 3: Depends on positions (after Movement and Animation)
        std::vector<std::string> group3 = {"CollisionSystem", "BoundarySystem"};
 
        // Group 4: Depends on collision results
        std::vector<std::string> group4 = {"HealthSystem", "WeaponSystem"};
 
        // Group 5: Lua scripts (wave_manager) must run before spawning
        std::vector<std::string> group5 = {"Lua"};
 
        // Group 6: Process spawn requests from Lua and AI
        std::vector<std::string> group6 = {"AISystem", "SpawnSystem"};
 
        // Execute each group in order, but parallelize within groups
        auto executeGroup = [this, deltaTime](const std::vector<std::string> &group) {
            // Use shared_ptr to safely share the atomic counter between threads
            auto completed = std::make_shared<std::atomic<int>>(0);
            const int total = static_cast<int>(group.size());
 
            for (const auto &systemName : group) {
                // Capture completed by value (shared_ptr copy is thread-safe)
                _threadPool->enqueue([this, systemName, deltaTime, completed]() {
                    _world->updateSystem(systemName, deltaTime);
                    (*completed)++;
                });
            }
 
            // Wait for all tasks in this group to complete
            while (*completed < total) {
                std::this_thread::yield();
            }
        };
 
        // Execute groups sequentially, systems within groups in parallel
        executeGroup(group1);
        executeGroup(group2);
        executeGroup(group3);
        executeGroup(group4);
        executeGroup(group5);  // Lua scripts
        executeGroup(group6);  // Spawning (processes Lua's spawn requests)
    }
 
    void GameLogic::_cleanupDeadEntities() {
        // Query all entities marked for destruction
        auto entitiesToDestroy = _world->query<ecs::PendingDestroy>();
 
        for (auto &entity : entitiesToDestroy) {
            ecs::Address entityAddress = entity.getAddress();
 
            // Remove from player map if it's a player entity
            if (entity.has<ecs::Player>()) {
                std::scoped_lock lock(_playerMutex);
                for (auto it = _playerMap.begin(); it != _playerMap.end();) {
                    if (it->second == entityAddress) {
                        LOG_INFO("Removing player ", it->first, " from player map (entity destroyed)");
                        it = _playerMap.erase(it);
                    } else {
                        ++it;
                    }
                }
            }
 
            // Actually destroy the entity
            _world->destroyEntity(entity);
        }
    }
 
    void GameLogic::_checkGameOverCondition() {
        // Only check in InGame state
        if (_stateManager->getCurrentState() != 1) {
            return;
        }
 
        // Don't check if no players have ever joined
        if (!_hadPlayers) {
            return;
        }
 
        bool allPlayersDead = true;
        bool anyEnemiesRemain = false;
 
        {
            std::scoped_lock lock(_playerMutex);
 
            // If player map is empty and we had players, they're all dead
            if (!_playerMap.empty()) {
                // Check if all players are dead
                for (const auto &[playerId, entityAddress] : _playerMap) {
                    try {
                        ecs::wrapper::Entity entity = _world->getEntity(entityAddress);
                        if (entity.has<ecs::Health>() && entity.get<ecs::Health>().getCurrentHealth() > 0) {
                            allPlayersDead = false;
                            break;
                        }
                    } catch (...) {
                        // Entity doesn't exist, consider dead
                    }
                }
            }
        }
 
        // Check if there are any enemies left alive
        auto enemies = _world->query<ecs::Enemy, ecs::Health>();
        for (auto &enemyEntity : enemies) {
            try {
                if (enemyEntity.has<ecs::Health>()) {
                    const ecs::Health &health = enemyEntity.get<ecs::Health>();
                    if (health.getCurrentHealth() > 0) {
                        anyEnemiesRemain = true;
                        break;
                    }
                }
            } catch (...) {
                // Skip invalid entities
            }
        }
 
        // Check if any spawner is still active (has more waves to spawn)
        bool spawnerStillActive = false;
        auto spawners = _world->query<ecs::Spawner>();
        for (auto &spawnerEntity : spawners) {
            try {
                if (spawnerEntity.has<ecs::Spawner>()) {
                    const ecs::Spawner &spawner = spawnerEntity.get<ecs::Spawner>();
                    if (spawner.isActive) {
                        spawnerStillActive = true;
                        break;
                    }
                }
            } catch (...) {
                // Skip invalid entities
            }
        }
 
        // Victory: All enemies defeated, no more waves to spawn, and at least one player alive
        if (!anyEnemiesRemain && !spawnerStillActive && !allPlayersDead) {
            LOG_INFO("Victory! All enemies defeated!");
            _gameActive = false;  // Stop game loop
            _stateManager->changeState(2);
            if (_eventBus) {
                _eventBus->publish(GameEndedEvent("Victory"));
            }
            return;
        }
 
        // Defeat: All players dead
        if (allPlayersDead) {
            LOG_INFO("Defeat! All players eliminated.");
            _gameActive = false;  // Stop game loop
            _stateManager->changeState(2);
            if (_eventBus) {
                _eventBus->publish(GameEndedEvent("Defeat"));
            }
        }
    }
 
    void GameLogic::resetGame() {
        LOG_INFO("Resetting game...");
 
        _gameActive = true;
        _hadPlayers = false;  // Reset player tracking
        _playerMap.clear();
        _pendingInput.clear();
        _lastReceivedSequenceId.clear();
        _lastAppliedSequenceId.clear();
 
        // Clear all entities from the world
        _world->clear();
        LOG_INFO("✓ Game reset");
    }
 
    void GameLogic::onGameStart() {
        LOG_INFO("Game started! Loading map...");
 
        // Charger la map maintenant que le jeu démarre
        loadMap("assets/maps/level_1.json");
 
        LOG_INFO("✓ Map loaded and spawning will begin!");
    }
 
    bool GameLogic::loadMap(const std::string &mapFilePath) {
        LOG_INFO("Loading map from: ", mapFilePath);
 
        // Load map data from JSON file
        auto mapDataOpt = map::MapLoader::loadFromFile(mapFilePath);
        if (!mapDataOpt.has_value()) {
            LOG_ERROR("Failed to load map from: ", mapFilePath);
            return false;
        }
 
        ecs::MapData mapData = mapDataOpt.value();
        LOG_INFO("✓ Map loaded: '", mapData.getName(), "' (", mapData.getMapId(), ")");
 
        // Create or update map entity
        // Check if there's already an active map entity
        auto mapEntities = _world->query<ecs::MapData>();
 
        if (!mapEntities.empty()) {
            // Update existing map entity
            auto mapEntity = mapEntities[0];
            mapEntity.with(mapData);
            LOG_INFO("Updated existing map entity");
        } else {
            // Create new map entity
            _world->createEntity().with(mapData);
            LOG_INFO("Created new map entity");
        }
 
        // Load spawn script if specified
        const std::string &spawnScript = mapData.getSpawnScript();
        if (!spawnScript.empty() && _luaEngine) {
            LOG_INFO("Loading spawn script: ", spawnScript);
 
            // Create spawner entity with the map's spawn script
            _world->createEntity().with(ecs::Spawner()).with(ecs::LuaScript(spawnScript));
 
            LOG_INFO("✓ Spawner created with script: ", spawnScript);
        }
 
        LOG_INFO("✓ Map '", mapData.getName(), "' is now active!");
        LOG_INFO("  - Scroll speed: ", mapData.getScrollSpeed(), " px/s");
        if (mapData.getDuration() > 0.0f) {
            LOG_INFO("  - Duration: ", mapData.getDuration(), " seconds");
        } else {
            LOG_INFO("  - Duration: Infinite");
        }
 
        return true;
    }
 
}  // namespace server