continue refactor network layer

Author: usermicrodevices

include/game/GameData.hpp

@@ -1,17 +1,98 @@
 #pragma once
 
 #include <cstdint>
+#include <variant>
 
 #include <glm/glm.hpp>
 #include <nlohmann/json.hpp>
 
+enum class LootRarity {
+    COMMON,
+    UNCOMMON,
+    RARE,
+    EPIC,
+    LEGENDARY,
+    MYTHIC
+};
+
+enum class LootType {
+    MISC,
+    WEAPON,
+    AMMO,
+    ARMOR,
+    CONSUMABLE,
+    MATERIAL,
+    QUEST,
+    KEY,
+    CURRENCY,
+    JEWELRY
+};
+
+enum class InventoryMoveType {
+    REMOVE,
+    USE, // use for self
+    TRADE
+};
+
+struct WeaponStats {
+    uint16_t damage; // use as default if weapon like knife (without ammo, ammo_capacity always zero)
+    uint8_t ammo_capacity;
+    uint8_t delay_between_shots; // milliseconds, delay reloading between shots
+    uint8_t element;          // 0=physical, 1=fire, etc.
+    uint8_t required_level;
+};
+
+struct AmmoStats {
+    float speed;
+    uint16_t damage;
+};
+
+struct ArmorStats {
+    uint16_t defense;
+    uint16_t durability;
+    uint16_t max_durability;
+    uint8_t armor_class;      // light/medium/heavy
+    uint8_t required_level;
+};
+
+struct ConsumableStats {
+    uint16_t effect_id;       // e.g., healing potion, mana elixir
+    uint16_t effect_power;
+    uint32_t cooldown_ms;
+};
+
+struct JewelryStats {
+    uint16_t stat_bonus_type; // strength, intelligence, etc.
+    uint16_t stat_bonus_value;
+    uint8_t socket_count;
+};
+
+struct QuestItem {
+    uint32_t quest_id;
+    uint32_t objective_index;
+};
+
+using LootPayload = std::variant<
+std::monostate,      // MISC, MATERIAL, KEY, CURRENCY
+WeaponStats,
+AmmoStats,
+ArmorStats,
+ConsumableStats,
+JewelryStats,
+QuestItem
+>;
+
+
 struct AuthenticationData {
+    uint64_t timestamp;
+    uint64_t session_id;
     std::string username;
     std::string password;
-    uint64_t session_id;
 };
 
 struct PlayerStateData {
+    uint64_t timestamp;
+    uint64_t session_id;
     uint64_t player_id;
     uint32_t input_id;
     glm::vec3 position;
@@ -22,30 +103,80 @@ struct PlayerStateData {
     bool jumping;
     bool crouching;
     bool sprinting;
-    uint64_t timestamp;
-    uint64_t session_id;
 };
 
 struct PlayerPositionData {
+    uint64_t timestamp;
+    uint64_t session_id;
     uint64_t player_id;
     glm::vec3 position;
     glm::vec3 velocity;
-    uint64_t timestamp;
-    uint64_t session_id;
 };
 
-struct ChunkRequestData {
+struct ChunkData {
+    uint64_t timestamp;
+    uint64_t session_id;
     int chunk_x;
     int chunk_z;
     uint8_t lod;
-    uint64_t session_id;  // which session requested it
+    nlohmann::json chunk_json;
 };
 
-struct ChunkData {
-    int chunk_x;
-    int chunk_z;
-    uint8_t lod;
-    nlohmann::json chunk_json;  // already serialized
+struct CollisionData {
+    uint64_t timestamp;
+    uint64_t session_id;
+    glm::vec3 position;
+    float radius;
+};
+
+struct NpcData {
+    uint64_t timestamp;
+    uint64_t session_id;
+    uint64_t player_id;
+    uint64_t npc_id;
+    float damage;
+    float health;
+    bool is_dead;
+    std::string type; // "combat" or "dialogue"
+    nlohmann::json quests; // for dialogue
+};
+
+struct FamiliarData {
     uint64_t timestamp;
     uint64_t session_id;
+    uint64_t familiar_id;
+    uint64_t target_id;
+    bool success;
+    std::string command;
+};
+
+struct EntitySpawnData {
+    uint64_t timestamp;
+    uint64_t session_id;
+    uint64_t entity_id;
+    int type;
+    glm::vec3 position;
+};
+
+struct LootPickupData {
+    uint64_t timestamp;
+    uint64_t session_id;
+    uint64_t player_id;
+    uint64_t loot_id;           // world instance ID
+    LootType type;
+    LootRarity rarity;
+    uint16_t quantity;          // stack size (ignored for non‑stackables)
+    LootPayload payload;        // type‑safe extra data
+};
+
+struct InventoryData {
+    uint64_t timestamp;
+    uint64_t session_id;
+    uint64_t player_id;
+    uint64_t loot_id; // world instance ID
+    int use_slot_id; // equipmentSlots
+    int inv_slot_id; // inventorySlots
+    uint64_t target_id; // optional, if move_type TRADE
+    uint16_t quantity;
+    InventoryMoveType move_type;
 };

include/game/GameLogic.hpp

@@ -30,62 +30,35 @@ class GameLogic : public LogicCore, public std::enable_shared_from_this<GameLogi
 public:
     static GameLogic& GetInstance();
 
-    // Core lifecycle
     void Initialize() override;
     void Shutdown() override;
 
-    // World configuration
     struct WorldConfig : public LogicWorld::WorldConfig {};
     void SetWorldConfig(const WorldConfig& config);
     const WorldConfig& GetWorldConfig() const;
 
-    // World maintenance
     void PerformMaintenance();
 
-    // IPC message handling
-    void HandleIPCMessage(const nlohmann::json& message);
-
-    // World methods
     std::shared_ptr<WorldChunk> GetOrCreateChunk(int chunkX, int chunkZ);
     void GenerateWorldAroundPlayer(uint64_t playerId, const glm::vec3& position);
     void PreloadWorldData(float radius);
     float GetTerrainHeight(float x, float z) const;
     BiomeType GetBiomeAt(float x, float z) const;
 
-    // Entity methods
     uint64_t SpawnNPC(NPCType type, const glm::vec3& position, uint64_t ownerId = 0);
     void DespawnNPC(uint64_t npcId);
     NPCEntity* GetNPCEntity(uint64_t npcId);
     GameEntity* GetEntity(uint64_t entityId);
     std::shared_ptr<Player> GetPlayer(uint64_t playerId);
 
-    // Collision methods
     CollisionResult CheckCollision(const glm::vec3& position, float radius, uint64_t excludeEntityId = 0);
     bool Raycast(const glm::vec3& origin, const glm::vec3& direction, float maxDistance, RaycastHit& hit);
 
-    // Loot methods
     void CreateLootEntity(const glm::vec3& position, std::shared_ptr<LootItem> item, int quantity);
-    void HandleLootPickup(uint64_t sessionId, const nlohmann::json& data);
-    void HandleInventoryMove(uint64_t sessionId, const nlohmann::json& data);
-    void HandleItemUse(uint64_t sessionId, const nlohmann::json& data);
-    void HandleItemDrop(uint64_t sessionId, const nlohmann::json& data);
-    void HandleTradeRequest(uint64_t sessionId, const nlohmann::json& data);
-    void HandleGoldTransaction(uint64_t sessionId, const nlohmann::json& data);
-
-    // Message handlers (remaining non-virtual ones)
-    void HandleNPCInteraction(uint64_t sessionId, const nlohmann::json& data);
-    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);
-
-    // Message handling entry points
-    void HandleMessage(uint64_t sessionId, const nlohmann::json& message);
-
-    // Player connection/disconnection
+
     void OnPlayerConnected(uint64_t sessionId, uint64_t playerId) override;
     void OnPlayerDisconnected(uint64_t sessionId) override;
 
-    // Broadcasting methods (still used)
     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,
@@ -106,23 +79,34 @@ class GameLogic : public LogicCore, public std::enable_shared_from_this<GameLogi
     void SendAuthenticationSuccess(uint64_t sessionId, uint64_t playerId, const std::string& message);
     void SendAuthenticationFailure(uint64_t sessionId, const std::string& message);
 
-    // Callback setters for network layer
     void SetSendAuthenticationResponseCallback(std::function<void(uint64_t sessionId, bool success, const std::string& message, uint64_t playerId)> cb);
     void SetSendChunkCallback(std::function<void(uint64_t sessionId, const ChunkData&)> cb);
+    void SetSendCollisionResponseCallback(std::function<void(uint64_t session_id, const CollisionResult& result)> cb);
     void SetPlayerStateCallback(std::function<void(const PlayerStateData&)> cb);
     void SetBroadcastPlayerPositionCallback(std::function<void(const PlayerPositionData&, float radius)> cb);
+    void SetSendNPCInteractionResponseCallback(std::function<void(uint64_t session_id, const NpcData& response)> cb);
+    void SetSendFamiliarCommandResponseCallback(std::function<void(uint64_t session_id, const FamiliarData& response)> cb);
+    void SetSendEntitySpawnResponseCallback(std::function<void(uint64_t session_id, const EntitySpawnData& response)> cb);
+    void SetSendLootPickupResponseCallback(std::function<void(uint64_t session_id, const LootPickupData& response)> cb);
+    void SetSendInventoryResponseCallback(std::function<void(uint64_t session_id, const InventoryData& response)> cb);
 
-    // Incoming data entry points (called by sessions)
     void OnAuthentication(const AuthenticationData& data);
-    void OnChunkRequest(const ChunkRequestData& data);
+    void OnChunkRequest(const ChunkData& data);
+    void OnCollisionCheck(const CollisionData& data);
     void OnPlayerPosition(const PlayerPositionData& data);
     void OnPlayerState(const PlayerStateData& data);
+    void OnNPCInteraction(const NpcData& data);
+    void OnFamiliarCommand(const FamiliarData& data);
+    void OnEntitySpawnRequest(const EntitySpawnData& data);
+    void OnLootPickup(const LootPickupData& data);
+    void OnInventory(const InventoryData& data);
 
-    // Overrides of virtual methods from LogicCore
+    // scripting
+    void RegisterPythonEventHandlers() override;
     void FirePythonEvent(const std::string& eventName, const nlohmann::json& data) override;
     nlohmann::json CallPythonFunction(const std::string& moduleName, const std::string& functionName,
                                       const nlohmann::json& args) override;
-    void RegisterPythonEventHandlers() override;
+
     void SaveGameState() override;
     void CleanupOldData() override;
     void ProcessGameTick(float deltaTime) override;
@@ -135,7 +119,6 @@ class GameLogic : public LogicCore, public std::enable_shared_from_this<GameLogi
     void HandleCombat(uint64_t sessionId, const nlohmann::json& data) override;
     void HandleQuest(uint64_t sessionId, const nlohmann::json& data) override;
 
-    // Additional helpers
     void SetDatabaseService(DatabaseService* dbService);
     void SetConnectionManager(std::shared_ptr<ConnectionManager> connMgr);
     void SetDatabaseBackend(std::unique_ptr<DatabaseBackend> backend);
@@ -157,17 +140,21 @@ class GameLogic : public LogicCore, public std::enable_shared_from_this<GameLogi
 
     std::function<void(uint64_t, bool, const std::string&, uint64_t)> sendAuthResponseCb_;
     std::function<void(uint64_t, const ChunkData&)> sendChunkCb_;
+    std::function<void(uint64_t, const CollisionResult&)> sendCollisionResponseCb_;
     std::function<void(const PlayerPositionData&, float)> broadcastPlayerPositionCb_;
     std::function<void(const PlayerStateData&)> playerStateCb_;
+    std::function<void(uint64_t, const NpcData&)> sendNPCInteractionResponseCb_;
+    std::function<void(uint64_t, const FamiliarData&)> sendFamiliarCommandResponseCb_;
+    std::function<void(uint64_t, const EntitySpawnData&)> sendEntitySpawnResponseCb_;
+    std::function<void(uint64_t, const LootPickupData&)> sendLootPickupResponseCb_;
+    std::function<void(uint64_t, const InventoryData&)> sendInventoryResponseCb_;
 
     bool pythonEnabled_ = false;
 
     void GameLoop() override;
     void SpawnerLoop() override;
     void UpdateWorld(float deltaTime);
 
-    // Helper methods
-    void RegisterWorldHandlers();
     bool LoadGameData();
     void SaveChunkData();
 

include/game/InventorySystem.hpp

@@ -8,6 +8,8 @@
 
 #include "database/DbManager.hpp"
 #include "logging/Logger.hpp"
+
+#include "game/GameData.hpp"
 #include "game/LootItem.hpp"
 
 struct InventorySlot {
@@ -27,15 +29,16 @@ class InventorySystem {
     // Inventory management
     bool AddItem(uint64_t playerId, const LootItem& item, int quantity = 1);
     bool RemoveItem(uint64_t playerId, uint64_t itemId, int quantity = 1);
+    bool UseItem(uint64_t playerId, uint64_t itemId, int quantity = 1);
     bool MoveItem(uint64_t playerId, int fromSlot, int toSlot);
     bool SwapItems(uint64_t playerId, int slot1, int slot2);
     bool SplitStack(uint64_t playerId, int slot, int splitQuantity);
     bool MergeStacks(uint64_t playerId, int sourceSlot, int targetSlot);
 
     // Equipment management
-    bool EquipItem(uint64_t playerId, int inventorySlot);
-    bool UnequipItem(uint64_t playerId, int equipmentSlot);
-    bool AutoEquip(uint64_t playerId, uint64_t itemId);
+    bool EquipItem(uint64_t playerId, int inventorySlot, int quantity = 1);
+    bool UnequipItem(uint64_t playerId, int equipmentSlot, int quantity = 1);
+    bool AutoEquip(uint64_t playerId, uint64_t itemId, int quantity = 1);
 
     // Query methods
     std::shared_ptr<LootItem> GetItem(uint64_t playerId, int slot);

include/game/LogicCore.hpp

@@ -54,10 +54,10 @@ class LogicCore {
     uint64_t GetPlayerIdBySession(uint64_t sessionId) const;
     uint64_t GetSessionIdByPlayer(uint64_t playerId) const;
 
-    void SendError(uint64_t sessionId, const std::string& message, int code = 0);
-    void SendSuccess(uint64_t sessionId, const std::string& message, const nlohmann::json& data = {});
-    void SendToSession(uint64_t sessionId, const nlohmann::json& message);
-    void SendBinaryToSession(uint64_t sessionId, uint16_t messageType, const std::vector<uint8_t>& data);
+    void SendError(uint64_t sessionId, const std::string& description, int code = 0);
+    void SendSuccess(uint64_t sessionId, const std::string& description, const nlohmann::json& data = {});
+    void SendToSession(uint64_t sessionId, uint16_t messageType, const std::vector<uint8_t>& data);
+    void SendToSessionJson(uint64_t sessionId, const nlohmann::json& message);
 
     // Python scripting – virtual, to be overridden by GameLogic
     virtual void FirePythonEvent(const std::string& eventName, const nlohmann::json& data);