Server.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** Created by mael on 08/12/2025.
** File description:
** Server.hpp
*/
 
#pragma once
 
#include <cstdint>
#include <memory>
#include "server/Core/Clock/FrameTimer.hpp"
#include "server/Network/ServerNetworkManager.hpp"
#include "server/Rooms/Lobby/Lobby.hpp"
#include "server/Rooms/RoomManager/RoomManager.hpp"
#include "server/Sessions/SessionManager/SessionManager.hpp"
 
// Forward declarations
namespace server {
    class ServerLoop;
    class EventBus;
    class CommandHandler;
    struct CommandContext;
}  // namespace server
 
namespace ecs::wrapper {
    class Entity;
}
 
namespace RType::Messages::Shared {
    enum class Action;
}
 
namespace RType::Messages::S2C {
    class EntityState;
}
 
namespace NetworkMessages {
    enum class MessageType : uint16_t;
}
 
class Server {
   public:
    explicit Server(uint16_t port, size_t maxClients = 32);
 
    ~Server();
 
    bool initialize();
 
    void run();
 
    void stop();
 
   private:
    void handlePacket(HostNetworkEvent &event);
 
    void _handleHandshakeRequest(HostNetworkEvent &event);
 
    void _handleRegisterRequest(HostNetworkEvent &event);
 
    void _handleLoginRequest(HostNetworkEvent &event);
 
    void _handlePlayerInput(HostNetworkEvent &event);
 
    void _handleDisconnect(HostNetworkEvent &event);
 
    void _handleListRooms(HostNetworkEvent &event);
 
    void _handleCreateRoom(HostNetworkEvent &event);
 
    void _handleJoinRoom(HostNetworkEvent &event);
 
    void _handleAutoMatchmaking(HostNetworkEvent &event);
 
    void _handleUpdateAutoMatchmakingPref(HostNetworkEvent &event);
 
    void _onMatchmakingRoomCreated(std::shared_ptr<server::Room> room);
 
    void _handleLeaveRoom(HostNetworkEvent &event);
 
    void _handleStartGame(HostNetworkEvent &event);
 
    void _handleChatMessage(HostNetworkEvent &event);
 
    void _broadcastGameState();
 
    void _processPendingDestructions();
 
    void _sendGameStartToRoom(std::shared_ptr<server::Room> room);
 
    void _sendGameStartToSpectator(uint32_t spectatorId, std::shared_ptr<server::Room> room);
 
    void _broadcastRoomState(std::shared_ptr<server::Room> room);
 
    void _broadcastRoomList(const std::vector<IPeer *> &specificPeers);
 
    void _broadcastRoomListToAll();
 
    RType::Messages::S2C::EntityState _serializeEntity(ecs::wrapper::Entity &entity,
                                                       server::IGameLogic *gameLogic = nullptr);
 
    void _actionToInput(RType::Messages::Shared::Action action, int &dx, int &dy, bool &shoot);
 
    std::shared_ptr<server::Session> _getSessionFromPeer(IPeer *peer);
 
    void _sendPacket(IPeer *peer, NetworkMessages::MessageType type, const std::vector<uint8_t> &payload,
                     bool reliable = true);
 
    std::vector<RType::Messages::S2C::EntityState> _serializeEntities(
        std::shared_ptr<ecs::wrapper::ECSWorld> world, server::IGameLogic *gameLogic = nullptr);
 
    void _sendSystemMessage(uint32_t playerId, const std::string &message);
 
    void _sendKickedNotification(uint32_t playerId);
 
   public:
    std::shared_ptr<server::Lobby> getLobby() const { return _lobby; }
 
    void notifyRoomUpdate(std::shared_ptr<server::Room> room);
 
    bool kickPlayer(uint32_t playerId);
 
   private:
    uint16_t _port;
    size_t _maxClients;
 
    std::unique_ptr<ServerNetworkManager> _networkManager;
    std::shared_ptr<server::EventBus> _eventBus;
 
    // Architecture components
    std::shared_ptr<server::SessionManager> _sessionManager;
    std::shared_ptr<server::RoomManager> _roomManager;
    std::shared_ptr<server::Lobby> _lobby;
    std::unique_ptr<server::CommandHandler> _commandHandler;
 
    // NOTE: No global _gameLoop anymore - each Room has its own
 
    // Track session ID to peer mapping for network communication
    std::unordered_map<std::string, IPeer *> _sessionPeers;
    // Reverse lookup: peer -> session ID for fast disconnect handling
    std::unordered_map<IPeer *, std::string> _peerToSession;
    // Lookup: Player ID -> Session ID for broadcasting
    std::unordered_map<uint32_t, std::string> _playerIdToSessionId;
    // Lookup: Player ID -> Username for preference persistence
    std::unordered_map<uint32_t, std::string> _playerIdToUsername;
 
    bool _initialized = false;
    bool _running = false;
 
    // Frame timing for accurate deltaTime calculation
    server::FrameTimer _frameTimer;
};