receive entity spawn/update/despawn messages

Author: usermicrodevices

include/game/GameLogic.hpp

@@ -2,20 +2,17 @@
 
 #include <cmath>
 #include <memory>
+#include <unordered_map>
 
 #include <glm/glm.hpp>
 #include <nlohmann/json.hpp>
 
-// #include "config/ConfigManager.hpp"
-// #include "logging/Logger.hpp"
-// #include "network/ConnectionManager.hpp"
-// #include "database/DbManager.hpp"
+#include "network/PredictionSystem.hpp"
 
 #include "game/LogicCore.hpp"
 #include "game/PlayerManager.hpp"
 #include "game/InventorySystem.hpp"
 #include "game/LootTableManager.hpp"
-//#include "game/MobSystem.hpp"
 #include "game/SkillSystem.hpp"
 #include "game/QuestManager.hpp"
 #include "game/EntityManager.hpp"
@@ -109,6 +106,13 @@ class GameLogic : public LogicCore
     void BroadcastToAllPlayersBinary(uint16_t messageType, const std::vector<uint8_t>& data);
     void BroadcastToPlayers(const std::vector<uint64_t>& sessionIds, const nlohmann::json& message);
 
+    // Broadcast entity spawn to nearby players
+    void BroadcastEntitySpawn(uint64_t entityId, EntityType type, const glm::vec3& position,
+                              float yaw, const std::string& name);
+    void SendPositionCorrection(uint64_t sessionId, const glm::vec3& position, const glm::vec3& velocity);
+    void BroadcastPlayerState(uint64_t playerId, const ServerState& state);
+    void BroadcastEntityDespawn(uint64_t entityId, const glm::vec3& position);
+
 private:
     GameLogic();
     ~GameLogic();
@@ -125,6 +129,9 @@ class GameLogic : public LogicCore
     // Connection manager for broadcasting
     std::shared_ptr<ConnectionManager> connectionManager_;
 
+    std::unordered_map<uint64_t, PredictionSystem> playerPrediction_;
+    std::mutex predictionMutex_;
+
     // Thread functions
     void GameLoop();
     void SpawnerLoop();

include/game/Player.hpp

@@ -329,6 +329,10 @@ class Player : public GameEntity {
     nlohmann::json JsonGetInventory() const;
     nlohmann::json ToJson() const;
 
+    // =============== Movement state getters/setters ===============
+    bool IsOnGround() const { return onGround_; }
+    void SetOnGround(bool g) { onGround_ = g; }
+
 private:
     uint64_t id_;
     std::string username_;
@@ -362,6 +366,8 @@ class Player : public GameEntity {
     std::unordered_map<std::string, nlohmann::json> completed_quests_;
     std::vector<std::string> achievements_;
 
+    bool onGround_{true};
+
     // Active buffs/debuffs
     struct ActiveBuff {
         std::string buff_id;

include/network/GameSession.hpp

@@ -315,6 +315,8 @@ class GameSession : public IConnection, public std::enable_shared_from_this<Game
                                const glm::vec3& velocity, uint32_t last_input_id);
     void SendPositionCorrection(const glm::vec3& position, const glm::vec3& velocity);
 
+    void SetPlayerStateHandler(std::function<void(const ClientInput&)> handler);
+
 private:
     // Core networking
     asio::ip::tcp::socket socket_;
@@ -399,6 +401,8 @@ class GameSession : public IConnection, public std::enable_shared_from_this<Game
     // Queue management
     size_t max_write_queue_size_{1000};
 
+    std::function<void(const ClientInput&)> player_state_handler_;
+
     // Private methods
     void StartHeartbeat();
     void CheckHeartbeat();

src/game/GameLogic.cpp

@@ -410,8 +410,21 @@ void GameLogic::HandleGoldTransaction(uint64_t sessionId, const nlohmann::json&
     }
 }
 
+void GameLogic::SendPositionCorrection(uint64_t sessionId, const glm::vec3& position, const glm::vec3& velocity) {
+    BinaryProtocol::BinaryWriter writer;
+    writer.WriteVector3(position);
+    writer.WriteVector3(velocity);
+    writer.WriteUInt64(GetCurrentTimestamp());
+    SendBinaryToSession(sessionId, BinaryProtocol::MESSAGE_TYPE_PLAYER_POSITION_CORRECTION, writer.GetBuffer());
+}
+
 // =============== World Message Handlers ===============
 void GameLogic::RegisterWorldHandlers() {
+    RegisterBinaryHandler(BinaryProtocol::MESSAGE_TYPE_PLAYER_STATE,
+        [this](uint64_t sessionId, uint16_t /*messageType*/, const std::vector<uint8_t>& data) {
+            HandlePlayerState(sessionId, data);
+    });
+
     RegisterHandler("world_chunk_request", [this](uint64_t sessionId, const nlohmann::json& data) {
         HandleWorldChunkRequest(sessionId, data);
     });
@@ -507,6 +520,10 @@ void GameLogic::OnPlayerConnected(uint64_t sessionId, uint64_t playerId) {
 void GameLogic::OnPlayerDisconnected(uint64_t sessionId) {
     // Capture player ID before base class removes the mapping
     uint64_t playerId = GetPlayerIdBySession(sessionId);
+    {
+        std::lock_guard<std::mutex> lock(predictionMutex_);
+        playerPrediction_.erase(playerId);
+    }
     Logger::Info("GameLogic: Player {} disconnected from session {}", playerId, sessionId);
     FirePythonEvent("player_disconnected", {
         {"sessionId", sessionId},
@@ -592,6 +609,77 @@ void GameLogic::HandlePlayerPositionUpdate(uint64_t sessionId, const nlohmann::j
     }
 }
 
+void GameLogic::HandlePlayerState(uint64_t sessionId, const std::vector<uint8_t>& data) {
+    try {
+        // Deserialize client input
+        ClientInput input = ClientInput::Deserialize(data.data(), data.size());
+        if (!input.IsValid()) {
+            Logger::Warn("Invalid client input from session {}", sessionId);
+            return;
+        }
+
+        uint64_t playerId = GetPlayerIdBySession(sessionId);
+        if (playerId == 0) {
+            Logger::Warn("No player for session {}", sessionId);
+            return;
+        }
+
+        // Store input in the player's prediction system
+        {
+            std::lock_guard<std::mutex> lock(predictionMutex_);
+            playerPrediction_[playerId].StoreClientInput(input);
+        }
+
+        // Get authoritative player state
+        auto player = GetPlayer(playerId);
+        if (!player) return;
+
+        // Simulate movement using the prediction system
+        // (We'll compute the authoritative state from the last confirmed state plus unprocessed inputs)
+        PredictionSystem* pred = &playerPrediction_[playerId];
+        auto currentTime = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::steady_clock::now().time_since_epoch()).count();
+
+            // Get the last confirmed state from prediction system (or from player)
+            ServerState authState;
+            authState.last_processed_input = 0; // TODO: track last processed input
+            authState.timestamp = currentTime;
+            authState.position = player->GetPosition();
+            authState.velocity = player->GetVelocity(); // assuming Player has velocity
+            authState.rotation = player->GetRotation(); // assuming Player has rotation
+            authState.on_ground = player->IsOnGround(); // assuming Player has onGround
+
+            // Simulate with unprocessed inputs
+            auto unprocessed = pred->GetUnprocessedInputs(authState.last_processed_input);
+            if (!unprocessed.empty()) {
+                float deltaTime = 1.0f / 30.0f; // or compute based on time difference
+                authState = pred->SimulateMovement(authState, unprocessed, deltaTime);
+            }
+
+            // Update authoritative player state
+            player->SetPosition(authState.position);
+            player->SetVelocity(authState.velocity);
+            player->SetRotation(authState.rotation);
+            player->SetOnGround(authState.on_ground);
+
+            // Broadcast authoritative state to nearby players (optional)
+            BroadcastPlayerState(playerId, authState);
+
+            // Check if client needs a correction (compare with client's last reported position)
+            // We need to store the client's last reported position; for simplicity we can compare
+            // with the position that the client sent (which is not directly available here, but we
+            // could pass it in the input). For now, we'll just send a correction if the simulation
+            // moved significantly from the last confirmed state.
+            static float correctionThreshold = 0.5f; // 0.5 meters
+            if (glm::distance(authState.position, player->GetPosition()) > correctionThreshold) {
+                SendPositionCorrection(sessionId, authState.position, authState.velocity);
+            }
+
+    } catch (const std::exception& e) {
+        Logger::Error("HandlePlayerState error: {}", e.what());
+    }
+}
+
 void GameLogic::HandleNPCInteraction(uint64_t sessionId, const nlohmann::json& data) {
     try {
         uint64_t npcId = data.value("npcId", 0ULL);
@@ -774,6 +862,19 @@ void GameLogic::HandleEntitySpawnRequest(uint64_t sessionId, const nlohmann::jso
 }
 
 // =============== Broadcasting ===============
+void GameLogic::BroadcastEntitySpawn(uint64_t entityId, EntityType type, const glm::vec3& position,
+                                     float yaw, const std::string& name) {
+    BinaryProtocol::BinaryWriter writer;
+    writer.WriteUInt64(entityId);
+    writer.WriteUInt8(static_cast<uint8_t>(type));
+    writer.WriteString(name);
+    writer.WriteVector3(position);
+    writer.WriteFloat(yaw);
+    writer.WriteUInt64(GetCurrentTimestamp());
+
+    BroadcastToNearbyPlayers(position, BinaryProtocol::MESSAGE_TYPE_ENTITY_SPAWN, writer.GetBuffer(), 100.0f);
+}
+
 void GameLogic::BroadcastBinaryToNearbyPlayers(const glm::vec3& position, uint16_t messageType,
                                               const std::vector<uint8_t>& data, float radius) {
     if (!connectionManager_) return;
@@ -1137,3 +1238,22 @@ void GameLogic::BroadcastToPlayers(const std::vector<uint64_t>& sessionIds, cons
         Logger::Error("Error broadcasting to specific players: {}", e.what());
     }
 }
+
+void GameLogic::BroadcastPlayerState(uint64_t playerId, const ServerState& state) {
+    // Create a binary update message (ENTITY_UPDATE or PLAYER_STATE) for other players
+    BinaryProtocol::BinaryWriter writer;
+    writer.WriteUInt64(playerId);
+    writer.WriteVector3(state.position);
+    writer.WriteVector3(state.rotation);
+    writer.WriteVector3(state.velocity);
+    writer.WriteUInt64(state.timestamp);
+    BroadcastToNearbyPlayers(state.position, BinaryProtocol::MESSAGE_TYPE_ENTITY_UPDATE, writer.GetBuffer(), 100.0f);
+}
+
+void GameLogic::BroadcastEntityDespawn(uint64_t entityId, const glm::vec3& position) {
+    BinaryProtocol::BinaryWriter writer;
+    writer.WriteUInt64(entityId);
+    writer.WriteUInt64(GetCurrentTimestamp());
+
+    BroadcastToNearbyPlayers(position, BinaryProtocol::MESSAGE_TYPE_ENTITY_DESPAWN, writer.GetBuffer(), 100.0f);
+}

src/game/Player.cpp

@@ -231,7 +231,8 @@ race_(PlayerRace::HUMAN),
 status_(PlayerStatus::IDLE),
 inventory_system_(InventorySystem::GetInstance()),
 skill_system_(SkillSystem::GetInstance()),
-quest_manager_(QuestManager::GetInstance())
+quest_manager_(QuestManager::GetInstance()),
+onGround_(true)
 {
     ApplyRaceBonuses();
     ApplyClassBonuses();
@@ -250,7 +251,8 @@ race_(PlayerRace::HUMAN),
 status_(PlayerStatus::IDLE),
 inventory_system_(InventorySystem::GetInstance()),
 skill_system_(SkillSystem::GetInstance()),
-quest_manager_(QuestManager::GetInstance())
+quest_manager_(QuestManager::GetInstance()),
+onGround_(true)
 {
     ApplyRaceBonuses();
     ApplyClassBonuses();
@@ -270,7 +272,8 @@ race_(race),
 status_(PlayerStatus::IDLE),
 inventory_system_(InventorySystem::GetInstance()),
 skill_system_(SkillSystem::GetInstance()),
-quest_manager_(QuestManager::GetInstance())
+quest_manager_(QuestManager::GetInstance()),
+onGround_(true)
 {
     ApplyRaceBonuses();
     ApplyClassBonuses();

src/main.cpp

@@ -113,6 +113,7 @@ void WorkerMain(int workerId, const WorkerGroupConfig& groupConfig, ProcessPool*
                 auto session = std::make_shared<GameSession>(std::move(socket), sslCtx);
                 Logger::Debug("Worker {} created new game session {}",
                             workerId, session->GetSessionId());
+
                 // Message handler - simplified for demonstration
                 session->SetMessageHandler([session, workerId, processPool](const nlohmann::json& msg) {
                     try {
@@ -140,6 +141,13 @@ void WorkerMain(int workerId, const WorkerGroupConfig& groupConfig, ProcessPool*
                         session->SendError("Internal server error", 500);
                     }
                 });
+
+                // --- Binary message handler ---
+                session->SetDefaultBinaryMessageHandler([session, workerId](uint16_t type,
+                                                        const std::vector<uint8_t>& data) {
+                    GameLogic::GetInstance().HandleBinaryMessage(session->GetSessionId(), type, data);
+                });
+
                 session->SetCloseHandler([session, workerId]() { // Close handler
                     Logger::Info("Worker {} session {} closing", workerId, session->GetSessionId());
                     GameLogic::GetInstance().OnPlayerDisconnected(session->GetSessionId());

src/network/GameSession.cpp

@@ -101,6 +101,9 @@ void GameSession::StartProtocolNegotiation() {
     // Send protocol capabilities to client
     SendProtocolCapabilities();
 
+    // Setup default binary handlers
+    SetupDefaultHandlers();
+
     // Start reading messages
     DoBinaryRead();
 
@@ -1608,3 +1611,24 @@ void GameSession::HandleFamiliarCommand(const nlohmann::json& data) {
         handler_it->second(BinaryProtocol::MESSAGE_TYPE_NPC_INTERACTION, writer.GetBuffer());
     }
 }
+
+void GameSession::SetPlayerStateHandler(std::function<void(const ClientInput&)> handler) {
+    player_state_handler_ = std::move(handler);
+}
+
+void GameSession::SetupDefaultHandlers() {
+    SetBinaryMessageHandler(BinaryProtocol::MESSAGE_TYPE_PLAYER_STATE,
+        [this](uint16_t type, const std::vector<uint8_t>& data) {
+            (void)type;
+            try {
+                ClientInput input = ClientInput::Deserialize(data.data(), data.size());
+                if (player_state_handler_) {
+                    player_state_handler_(input);
+                } else {
+                    Logger::Warn("Session {}: no player state handler registered", sessionId_);
+                }
+            } catch (const std::exception& e) {
+                Logger::Error("Session {}: failed to deserialize player state: {}", sessionId_, e.what());
+            }
+        });
+}