GameSession.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "Core/Ecs/Systems/AnimationSystem.h"
#include "Core/Ecs/Systems/ParticleSystem.h"
#include "Core/Ecs/World.h"
#include "Core/Gameplay/MechanismController.h"
#include "Core/Levels/CameraFraming.h"
#include "Core/Levels/GridPosition.h"
#include "Core/Levels/Level.h"
#include "Core/Levels/LevelOutcome.h"
#include "Core/Physics/Aabb.h"
#include "Core/Physics/PlayerInput.h"
#include "Core/Physics/TopDownConfig.h"
#include "HMI/Game/GameEvents.h"
#include "HMI/Game/IGameMode.h"
#include "HMI/Graphics/Camera2D.h"
#include "HMI/Graphics/CameraZones.h"
#include "HMI/Graphics/FollowCamera.h"
#include "HMI/Graphics/MechanismVisuals.h"
#include "HMI/Graphics/RoomGrid.h"
#include "HMI/Graphics/SpriteRenderer.h"
#include "HMI/Input/GameKeyBindings.h"
#include "HMI/Input/GamepadBindings.h"

 
namespace hmi {
 
class SpriteBatch;
class TextureAtlas;
class TextureCache;
class InputState;
class BitmapFont;
class Localization;

class GameSession : private IGameModePasses {
public:
    GameSession(SpriteBatch& batch, const TextureAtlas& atlas, TextureCache& cache,
                int viewportWidth, int viewportHeight, core::Level level,
                const GameKeyBindings& gameBindings, const GamepadBindings& gamepadBindings,
                const BitmapFont& font, const Localization* localization = nullptr);

    core::LevelOutcome update(const InputState& input, float fixedDelta);

    core::LevelOutcome update(const core::PlayerInput& input, float fixedDelta);

    void reload();

    void render(int viewportWidth, int viewportHeight, RenderMode mode, float interpolationAlpha);

    void setSkins(const SkinCatalog* skins, std::string skinSet = {}) {
        _tileSkins = skins;
        _tileSkinSet = skinSet;
        _renderer.setSkins(skins, std::move(skinSet));
    }

    [[nodiscard]] bool loaded() const {
        return _level.has_value();
    }

    [[nodiscard]] const std::string& loadError() const {
        return _loadError;
    }

    [[nodiscard]] const std::vector<GameEvent>& lastStepEvents() const noexcept {
        return _lastStepEvents;
    }

    [[nodiscard]] SceneStatistics renderStatistics() const noexcept {
        return _renderer.lastScene().statistics();
    }

    void setGameMode(std::unique_ptr<IGameMode> mode);

    [[nodiscard]] const IGameMode& gameMode() const noexcept {
        return *_mode;
    }
 
private:
    // --- Passes du pas fixe (hmi::IGameModePasses, LOT-05) ---
    //
    // Heritage PRIVE : ces passes sont offertes au mode de jeu, pas a l'appelant de la session.
    // Elles ne font chacune que ce que leur nom dit, et aucune ne decide de ce qui vient apres --
    // c'est tout l'objet de la separation (EX-ARCH-002).
    void snapshotPreviousPositions() override;
    void advanceParticles(float fixedDelta) override;
    void advanceScreenShake(float fixedDelta) override;
    void moveCharacter(const core::PlayerInput& input, float fixedDelta) override;
    void advanceAnimations(float fixedDelta) override;
    void updateCamera(float fixedDelta) override;
    void updateMechanisms(const core::PlayerInput& input) override;
    void detectEvents() override;
    void updateMechanismVisuals(float fixedDelta) override;
    [[nodiscard]] core::LevelOutcome evaluateOutcome() override;
    void onLevelLost() override;

    [[nodiscard]] core::Aabb playerBox();
 
    void loadLevel(core::Level level);
    void spawnPlayer(core::GridPosition entry);
    void applyMechanismVisual(core::Entity entity, bool active, MechanismVisualState& state,
                              const SceneTextures& textures, float fixedDelta);
    void refreshMechanismDiagnosticTint(RenderMode mode);
    [[nodiscard]] std::vector<core::Aabb> collectActiveDangerBoxes();
    void refreshPlayerSprite();
    void centerCameraOnRoom(core::GridPosition roomIndex);
    void updateCurrentRoom();
    void centerCameraOnZone(const core::CameraZone& zone);
    void updateCurrentCameraZone();
    void centerCameraOnWholeLevel();
    void updateFollowCamera(float fixedDelta);
    void applyCameraFraming(int viewportWidth, int viewportHeight, float interpolationAlpha);
    void updateTileAnimations(float fixedDelta);
    void renderHud(int viewportWidth, int viewportHeight);
 
    const TextureAtlas& _atlas;
    TextureCache& _cache;
    const GameKeyBindings& _gameBindings;
    const GamepadBindings& _gamepadBindings;
    SpriteBatch& _batch;
    const BitmapFont& _font;
    const Localization* _localization;  // non possede ; nul = HUD desactive (EX-NFR-040)
    core::World _world;
    Camera2D _camera;
    SpriteRenderer _renderer;
    ComposedScene _hudScene;
    std::optional<core::Level> _level;
    std::optional<core::MechanismController> _mechanisms;
    std::vector<core::Entity> _doorEntities;
    std::vector<core::Entity> _switchEntities;
    core::AnimationSystem _animation;
    core::TopDownConfig _movementConfig;
    core::ParticleSystem _particles;
    ScreenShakeState _screenShake;
    core::Entity _player{};
    int _levelWidth = 0;
    int _levelHeight = 0;
    std::optional<RoomGrid> _roomGrid;
    core::GridPosition _currentRoomIndex{};
    std::optional<std::size_t> _currentZoneIndex;
    core::CameraFramingConfig _cameraFraming;
    FollowCameraState _followCameraState;
    core::Vector2 _previousFollowCenter{};
    std::string _loadError;
 
    // Habillage des tuiles (LOT-46 TACHE-05) : copie locale de ce que setSkins() transmet aussi a
    // _renderer, necessaire pour decouvrir les assets animes au pas fixe (update()), independamment
    // du rendu (render()).
    const SkinCatalog* _tileSkins = nullptr;  // non possede
    std::string _tileSkinSet;
    std::unordered_map<std::string, core::Animation> _tileAnimations;
    std::set<std::string> _warnedExcludedAnimations;
 
    // Apparence des mecanismes pilotee par l'etat (LOT-47) : une horloge par instance suivie
    // (porte, declencheur, danger commute/temporise/mobile), independante de _tileAnimations
    // ci-dessus.
    std::vector<MechanismVisualState> _doorVisuals;
    std::vector<MechanismVisualState> _switchVisuals;
    std::vector<MechanismVisualState> _dangerSwitchedVisuals;
    std::vector<MechanismVisualState> _dangerBlinkVisuals;
    std::vector<MechanismVisualState> _dangerMoverVisuals;
    std::set<std::string> _warnedMissingMechanismClips;
 
    // Détection d'événements (LOT-60 TACHE-03) : snapshots du pas précédent, pour ne diffuser une
    // transition qu'au pas où elle a réellement lieu (même discipline que MechanismVisualState
    // ci-dessus -- previousXxx/initialized).
    std::unique_ptr<IGameMode> _mode;
 
    MechanismEventState _previousMechanismEventState;
    bool _gameEventsInitialized = false;
    std::vector<GameEvent> _lastStepEvents;
};
 
}  // namespace hmi