fix build bugs

Author: usermicrodevices

include/game/GameLogic.hpp

@@ -87,6 +87,7 @@ class GameLogic : public LogicCore
     void HandleCollisionCheck(uint64_t sessionId, const nlohmann::json& data);
     void HandleEntitySpawnRequest(uint64_t sessionId, const nlohmann::json& data);
     void HandleFamiliarCommand(uint64_t sessionId, const nlohmann::json& data);
+    void HandlePlayerState(uint64_t sessionId, const std::vector<uint8_t>& data);
 
     // Message handling
     void HandleMessage(uint64_t sessionId, const nlohmann::json& message);
@@ -96,9 +97,10 @@ class GameLogic : public LogicCore
     void OnPlayerDisconnected(uint64_t sessionId);
 
     // Broadcasting
-    void BroadcastBinaryToNearbyPlayers(const glm::vec3& position, uint16_t messageType, 
+    void BroadcastToNearbyPlayers(const glm::vec3& position, uint16_t messageType,
+                                             const std::vector<uint8_t>& data, float radius = 50.0f);
+    void BroadcastToNearbyOnlinePlayers(const glm::vec3& position, uint16_t messageType,
                                         const std::vector<uint8_t>& data, float radius = 50.0f);
-    void BroadcastToNearbyPlayers(const glm::vec3& position, const nlohmann::json& message, float radius = 50.0f);
     void SyncNearbyEntitiesToPlayer(uint64_t sessionId, const glm::vec3& position);
 
     // Helper broadcast methods

include/game/Player.hpp

@@ -337,6 +337,8 @@ class Player : public GameEntity {
     uint64_t id_;
     std::string username_;
 
+    bool onGround_{true};
+
     //struct Position {float x, y, z;} position_;
     std::chrono::system_clock::time_point last_movement_;
 
@@ -366,8 +368,6 @@ 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/GameServer.hpp

@@ -17,6 +17,8 @@
 #include "network/WebSocketProtocol.hpp"
 #include "network/WebSocketSession.hpp"
 
+#include "game/GameLogic.hpp"
+
 class GameServer {
 public:
     GameServer(const WorkerGroupConfig& groupConfig, const ConfigManager& globalConfig);

include/network/GameSession.hpp

@@ -433,5 +433,6 @@ class GameSession : public IConnection, public std::enable_shared_from_this<Game
     asio::ip::tcp::socket& GetSocket();
     const asio::ip::tcp::socket& GetSocket() const;
     void HandleNetworkError(std::error_code ec);
+    void SetupDefaultHandlers();
 };
 

include/network/PredictionSystem.hpp

@@ -14,11 +14,11 @@ struct ClientInput {
     bool jumping{false};
     bool crouching{false};
     bool sprinting{false};
-    
+
     // Serialization
     std::vector<uint8_t> Serialize() const;
     static ClientInput Deserialize(const uint8_t* data, size_t length);
-    
+
     // Validity check
     bool IsValid() const { return input_id > 0; }
 };
@@ -30,85 +30,85 @@ struct ServerState {
     glm::vec3 velocity;
     glm::vec3 rotation;
     bool on_ground{true};
-    
+
     // Serialization
     std::vector<uint8_t> Serialize() const;
     static ServerState Deserialize(const uint8_t* data, size_t length);
-    
+
     // Interpolation
     static ServerState Interpolate(const ServerState& a, const ServerState& b, float t);
 };
 
 class PredictionSystem {
 public:
     PredictionSystem();
-    
+
     // Client-side methods
     void StoreClientInput(const ClientInput& input);
     ServerState PredictPosition(uint64_t current_time) const;
-    
+
     // Server-side methods
     void StoreServerState(const ServerState& state);
     std::vector<ClientInput> GetUnprocessedInputs(uint32_t last_processed) const;
-    
+
     // Reconciliation
     struct ReconciliationResult {
         bool needs_correction{false};
         ServerState corrected_state;
         std::vector<uint32_t> processed_inputs;
     };
-    
+
     ReconciliationResult ReconcileWithServer(const ServerState& server_state);
-    
+
     // State management
     ServerState GetLastConfirmedState() const { return last_confirmed_state_; }
     ServerState GetLatestPredictedState() const { return latest_predicted_state_; }
-    
+
     // Input history
     const std::deque<ClientInput>& GetInputHistory() const { return input_history_; }
-    
+
     // Clear history
     void Clear();
-    
+
     // Statistics
     struct PredictionStats {
         uint32_t total_predictions{0};
         uint32_t corrections_sent{0};
         uint32_t corrections_received{0};
         float average_correction_distance{0.0f};
         uint64_t last_correction_time{0};
-        
+
         void Reset();
         std::string ToString() const;
     };
-    
+
     const PredictionStats& GetStats() const { return stats_; }
-    
+
+    // Helper methods
+    ServerState SimulateMovement(const ServerState& start_state,
+                                const std::vector<ClientInput>& inputs,
+                                float delta_time) const;
+
+    ServerState ApplyInput(const ServerState& state, const ClientInput& input, float delta_time) const;
+
 private:
     mutable std::mutex mutex_;
-    
+
     // Input history (client-side)
     std::deque<ClientInput> input_history_;
     static constexpr size_t MAX_INPUT_HISTORY = 1000;
-    
+
     // Server state history
     std::deque<ServerState> server_state_history_;
     static constexpr size_t MAX_STATE_HISTORY = 100;
-    
+
     // Current states
     ServerState last_confirmed_state_;
     mutable ServerState latest_predicted_state_;
-    
+
     // Statistics
     PredictionStats stats_;
-    
-    // Helper methods
-    ServerState SimulateMovement(const ServerState& start_state,
-                                const std::vector<ClientInput>& inputs,
-                                float delta_time) const;
-    
-    ServerState ApplyInput(const ServerState& state, const ClientInput& input, float delta_time) const;
-    
+
     // Physics constants
     static constexpr float GRAVITY = -9.81f;
     static constexpr float MAX_SPEED = 10.0f;
@@ -121,18 +121,18 @@ class PredictionSystem {
 class InputBuffer {
 public:
     InputBuffer(size_t max_size = 1000);
-    
+
     void AddInput(const ClientInput& input);
     std::vector<ClientInput> GetOrderedInputs() const;
     ClientInput GetNextInput() const;
     bool HasInputs() const { return !inputs_.empty(); }
     void Clear();
     size_t Size() const { return inputs_.size(); }
-    
+
 private:
     mutable std::mutex mutex_;
     std::vector<ClientInput> inputs_;
     size_t max_size_;
-    
+
     void SortAndTrim();
 };

include/network/WebSocketSession.hpp

@@ -7,6 +7,7 @@
 #include "logging/Logger.hpp"
 
 #include "network/IConnection.hpp"
+#include "network/BinaryProtocol.hpp"
 #include "network/WebSocketProtocol.hpp"
 
 class WebSocketSession : public IConnection, public std::enable_shared_from_this<WebSocketSession> {

src/game/GameLogic.cpp

@@ -592,7 +592,7 @@ void GameLogic::HandlePlayerPositionUpdate(uint64_t sessionId, const nlohmann::j
             positionWriter.WriteVector3(glm::vec3(0, 0, 0));
             positionWriter.WriteUInt64(GetCurrentTimestamp());
 
-            BroadcastBinaryToNearbyPlayers(position, BinaryProtocol::MESSAGE_TYPE_PLAYER_POSITION,
+            BroadcastToNearbyPlayers(position, BinaryProtocol::MESSAGE_TYPE_PLAYER_POSITION,
                                           positionWriter.GetBuffer(), 100.0f);
 
             FirePythonEvent("player_move_3d", {
@@ -862,55 +862,52 @@ 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) {
+void GameLogic::BroadcastToNearbyPlayers(const glm::vec3& position, uint16_t messageType,
+                                         const std::vector<uint8_t>& data, float radius) {
     if (!connectionManager_) return;
     auto& pm = PlayerManager::GetInstance();
-    auto onlinePlayers = pm.GetOnlinePlayers(); // returns vector of shared_ptr<Player>
-    for (const auto& player : onlinePlayers) {
-        if (glm::distance(player->GetPosition(), position) <= radius) {
-            uint64_t sessionId = GetSessionIdByPlayer(player->GetId());
-            if (sessionId != 0) {
-                auto session = connectionManager_->GetSession(sessionId);
-                if (session && session->IsConnected()) {
-                    session->SendBinary(messageType, data);
-                }
+    auto nearby = pm.GetPlayersInRadius(position, radius);
+    for (auto& player : nearby) {
+        uint64_t sessionId = pm.GetSessionIdByPlayerId(player->GetId());
+        if (sessionId != 0) {
+            auto session = connectionManager_->GetSession(sessionId);
+            if (session && session->IsConnected()) {
+                session->SendBinary(messageType, data);
             }
         }
     }
 }
 
-void GameLogic::BroadcastToNearbyPlayers(const glm::vec3& position, const nlohmann::json& message, float radius) {
+void GameLogic::BroadcastToNearbyOnlinePlayers(const glm::vec3& position, uint16_t messageType,
+                                              const std::vector<uint8_t>& data, float radius) {
     if (!connectionManager_) return;
     auto& pm = PlayerManager::GetInstance();
     auto onlinePlayers = pm.GetOnlinePlayers();
-    std::string serialized = message.dump();
     for (const auto& player : onlinePlayers) {
         if (glm::distance(player->GetPosition(), position) <= radius) {
             uint64_t sessionId = GetSessionIdByPlayer(player->GetId());
             if (sessionId != 0) {
                 auto session = connectionManager_->GetSession(sessionId);
                 if (session && session->IsConnected()) {
-                    session->SendRaw(serialized);
+                    session->SendBinary(messageType, data);
                 }
             }
         }
     }
 }
 
+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::SyncNearbyEntitiesToPlayer(uint64_t sessionId, const glm::vec3& position) {
     // Send a batch of entity data (positions, types, etc.) to the player
     auto nearbyEntities = EntityManager::GetInstance().GetEntitiesInRadius(position, 100.0f);

src/game/Player.cpp

@@ -225,14 +225,14 @@ Player::Player(uint64_t id, const std::string& username)
 : GameEntity(EntityType::PLAYER, glm::vec3(0.0f, 0.0f, 0.0f)),
 id_(id),
 username_(username),
+onGround_(true),
 last_movement_(std::chrono::system_clock::now()),
 player_class_(PlayerClass::WARRIOR),
 race_(PlayerRace::HUMAN),
 status_(PlayerStatus::IDLE),
 inventory_system_(InventorySystem::GetInstance()),
 skill_system_(SkillSystem::GetInstance()),
-quest_manager_(QuestManager::GetInstance()),
-onGround_(true)
+quest_manager_(QuestManager::GetInstance())
 {
     ApplyRaceBonuses();
     ApplyClassBonuses();
@@ -245,14 +245,14 @@ Player::Player(const glm::vec3& position)
 : GameEntity(EntityType::PLAYER, position),
 id_(0),
 username_(""),
+onGround_(true),
 last_movement_(std::chrono::system_clock::now()),
 player_class_(PlayerClass::WARRIOR),
 race_(PlayerRace::HUMAN),
 status_(PlayerStatus::IDLE),
 inventory_system_(InventorySystem::GetInstance()),
 skill_system_(SkillSystem::GetInstance()),
-quest_manager_(QuestManager::GetInstance()),
-onGround_(true)
+quest_manager_(QuestManager::GetInstance())
 {
     ApplyRaceBonuses();
     ApplyClassBonuses();
@@ -266,14 +266,14 @@ Player::Player(const glm::vec3& position, PlayerClass player_class, PlayerRace r
 : GameEntity(EntityType::PLAYER, position),
 id_(0),
 username_(""),
+onGround_(true),
 last_movement_(std::chrono::system_clock::now()),
 player_class_(player_class),
 race_(race),
 status_(PlayerStatus::IDLE),
 inventory_system_(InventorySystem::GetInstance()),
 skill_system_(SkillSystem::GetInstance()),
-quest_manager_(QuestManager::GetInstance()),
-onGround_(true)
+quest_manager_(QuestManager::GetInstance())
 {
     ApplyRaceBonuses();
     ApplyClassBonuses();

src/network/GameServer.cpp

@@ -102,8 +102,8 @@ void GameServer::DoAccept() {
                     if (webSocketFactory_) {
                         auto wsConn = webSocketFactory_(std::move(socket), sslContext_);
                         auto session = std::make_shared<WebSocketSession>(wsConn);
-                        session->SetBinaryMessageHandler([world](uint16_t type, const std::vector<uint8_t>& data) {
-                            world->HandleBinaryMessage(type, data); // Your world's binary handler
+                        session->SetBinaryMessageHandler([session](uint16_t type, const std::vector<uint8_t>& data) {
+                            GameLogic::GetInstance().HandleBinaryMessage(session->GetSessionId(), type, data);
                         });
                         ConnectionManager::GetInstance().Start(session);
                         session->Start();