add missed methods (mobs, inventory)

Author: usermicrodevices

CMakeLists.txt

@@ -104,6 +104,10 @@ set(NETWORK_SOURCES
 
 # Core logic system
 set(LOGIC_CORE_SOURCES
+    src/game/LootItem.cpp
+    src/game/LootTable.cpp
+    src/game/LootTableManager.cpp
+    src/game/MobSystem.cpp
     src/game/LogicCore.cpp
     src/game/LogicWorld.cpp
     src/game/LogicEntity.cpp

include/game/GameLogic.hpp

@@ -15,7 +15,7 @@
 #include "game/PlayerManager.hpp"
 #include "game/InventorySystem.hpp"
 #include "game/LootTableManager.hpp"
-#include "game/MobSystem.hpp"
+//#include "game/MobSystem.hpp"
 #include "game/SkillSystem.hpp"
 #include "game/QuestManager.hpp"
 #include "game/EntityManager.hpp"

include/game/LootItem.hpp

@@ -61,6 +61,9 @@ class LootItem {
     const glm::vec3& GetIconColor() const { return iconColor_; }
 
     // Setters
+    void SetId(uint64_t id) { id_ = id; }
+    void SetName(const std::string& name) { name_ = name; }
+    void SetRarity(LootRarity rarity = LootRarity::COMMON) { rarity_ = rarity; }
     void SetStackSize(int size);
     void SetLevelRequirement(int level);
     void SetIconColor(const glm::vec3& color);

include/game/LootTable.hpp

@@ -1,13 +1,17 @@
 #pragma once
 
-#include <vector>
+#include <algorithm>
+#include <fstream>
 #include <random>
+#include <vector>
 #include <unordered_map>
 
+#include "logging/Logger.hpp"
 #include "game/LootItem.hpp"
 
 struct LootEntry {
-    std::string itemId;
+    uint64_t itemId;
+    std::string name;
     float dropChance = 0.0f;  // 0.0 to 1.0
     int minQuantity = 1;
     int maxQuantity = 1;

include/game/MobSystem.hpp

@@ -1,19 +1,24 @@
 // MobSystem.hpp
 #pragma once
 
-#include <vector>
-#include <unordered_map>
+#include <algorithm>
 #include <chrono>
+#include <cmath>
 #include <random>
+#include <vector>
+#include <unordered_map>
 
 #include <glm/glm.hpp>
 
-#include "game/WorldChunk.hpp"
-#include "game/LootTable.hpp"
+#include "logging/Logger.hpp"
+#include "config/ConfigManager.hpp"
 
-//#include "game/NPCEntity.hpp"
-enum class NPCType;
-class NPCEntity;
+//#include "game/WorldChunk.hpp"
+//#include "game/LootTable.hpp"
+//#include "game/PlayerManager.hpp"
+//#include "game/EntityManager.hpp"
+//#include "game/LootTableManager.hpp"
+#include "game/NPCEntity.hpp"
 
 // Mob spawn zone
 struct MobSpawnZone {
@@ -25,7 +30,7 @@ struct MobSpawnZone {
     int maxMobs = 10;
     float respawnTime = 30.0f; // seconds
     std::string name;
-    std::string lootTableId;  // Add loot table reference
+    std::string lootTableId;
 };
 
 // Mob variant (leveled version of a mob type)
@@ -35,7 +40,7 @@ struct MobVariant {
     float healthMultiplier = 1.0f;
     float damageMultiplier = 1.0f;
     float experienceReward = 10.0f;
-    std::string lootTableId;  // Reference to loot table
+    std::string lootTableId;
 };
 
 // Mob death info for rewards

include/game/NPCEntity.hpp

@@ -15,7 +15,7 @@
 
 #include "game/GameEntity.hpp"
 #include "game/LootTableManager.hpp"
-#include "game/MobSystem.hpp"
+//#include "game/MobSystem.hpp"
 #include "logging/Logger.hpp"
 #include "config/ConfigManager.hpp"
 
@@ -421,6 +421,8 @@ class NPCEntity : public GameEntity {
     float summon_cooldown_ = 0.0f;
 
     // Patrol and movement
+    float patrol_wait_timer_ = 0.0f;
+    bool waiting_at_patrol_point_ = false;
     glm::vec3 spawn_position_;
     std::queue<glm::vec3> patrol_queue_;
 
@@ -439,6 +441,6 @@ class NPCEntity : public GameEntity {
     static constexpr float DESPAWN_DELAY = 10.0f;
 
     friend class NPCAISystem;
-    friend class MobSystem;
+    //friend class MobSystem;
     friend class EntityManager;
 };

src/game/GameLogic.cpp

@@ -952,18 +952,20 @@ void GameLogic::SaveGameState() {
             {"server_time", GetCurrentTimestamp()},
             {"world_seed", GetWorldConfig().seed},
             {"active_chunks", LogicWorld::GetInstance().GetActiveChunkCount()},
-            {"active_npcs", 0}, // LogicEntity::GetInstance().GetActiveNPCCount() if exposed
+            {"active_npcs", 0}, // TODO: expose from LogicEntity if needed
             {"world_config", {
                 {"view_distance", GetWorldConfig().viewDistance},
                 {"chunk_size", GetWorldConfig().chunkSize},
                 {"terrain_scale", GetWorldConfig().terrainScale}
             }}
         };
 
-        auto& dbClient = CitusClient::GetInstance();
-        dbClient.SaveGameState("current_game", gameState);
-
-        Logger::Debug("game state saved");
+        // Use DbManager instead of direct CitusClient
+        if (!DbManager::GetInstance().SaveGameState("current_game", gameState)) {
+            Logger::Error("Failed to save game state: DbManager returned false");
+        } else {
+            Logger::Debug("Game state saved");
+        }
     } catch (const std::exception& e) {
         Logger::Error("Failed to save game state: {}", e.what());
     }

src/game/InventorySystem.cpp

@@ -59,7 +59,7 @@ bool InventorySystem::AddItem(uint64_t playerId, const LootItem& item, int quant
 
     // Need new slots
     while (quantity > 0) {
-        if (inventory.inventorySlots.size() >= inventory.maxInventorySize) {
+        if (inventory.inventorySlots.size() >= (uint64_t)inventory.maxInventorySize) {
             Logger::Error("Inventory full for player {}", playerId);
             SaveInventory(playerId);
             return false;
@@ -80,6 +80,38 @@ bool InventorySystem::AddItem(uint64_t playerId, const LootItem& item, int quant
     return true;
 }
 
+bool InventorySystem::MoveItem(uint64_t playerId, int fromSlot, int toSlot) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    auto it = playerInventories_.find(playerId);
+    if (it == playerInventories_.end())
+        return false;
+
+    auto& inventory = it->second;
+    // Validate slot indices
+    if (fromSlot < 0 || fromSlot >= static_cast<int>(inventory.inventorySlots.size()) ||
+        toSlot < 0 || toSlot >= static_cast<int>(inventory.inventorySlots.size()))
+        return false;
+
+    if (fromSlot == toSlot)
+        return true;   // Nothing to do
+
+    auto& slotFrom = inventory.inventorySlots[fromSlot];
+    auto& slotTo = inventory.inventorySlots[toSlot];
+
+    // Swap the contents
+    std::swap(slotFrom.item, slotTo.item);
+    std::swap(slotFrom.quantity, slotTo.quantity);
+    std::swap(slotFrom.equipped, slotTo.equipped);
+
+    // Update position fields to match their new indices
+    slotFrom.position = fromSlot;
+    slotTo.position = toSlot;
+
+    SaveInventory(playerId);
+    return true;
+}
+
 bool InventorySystem::RemoveItem(uint64_t playerId, uint64_t itemId, int quantity) {
     std::lock_guard<std::mutex> lock(mutex_);
 
@@ -137,7 +169,7 @@ bool InventorySystem::EquipItem(uint64_t playerId, int inventorySlot) {
     auto& inventory = it->second;
 
     if (!ValidateSlot(playerId, inventorySlot) || 
-        inventorySlot >= inventory.inventorySlots.size()) {
+        (uint64_t)inventorySlot >= inventory.inventorySlots.size()) {
         return false;
     }
 
@@ -151,7 +183,7 @@ bool InventorySystem::EquipItem(uint64_t playerId, int inventorySlot) {
     }
 
     int equipSlot = GetEquipmentSlotForItem(*slot.item);
-    if (equipSlot == -1 || equipSlot >= inventory.equipmentSlots.size()) {
+    if (equipSlot == -1 || (uint64_t)equipSlot >= inventory.equipmentSlots.size()) {
         return false;
     }
 
@@ -296,6 +328,73 @@ bool InventorySystem::AddGold(uint64_t playerId, int64_t amount) {
     return true;
 }
 
+bool InventorySystem::RemoveGold(uint64_t playerId, int64_t amount) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    auto it = playerInventories_.find(playerId);
+    if (it == playerInventories_.end()) {
+        return false;   // No inventory → cannot remove gold
+    }
+
+    if (amount < 0) return false;           // Cannot remove negative amount
+    if (it->second.gold < amount) return false;  // Insufficient funds
+
+    it->second.gold -= amount;
+    SaveInventory(playerId);
+    return true;
+}
+
+bool InventorySystem::TransferGold(uint64_t fromPlayerId, uint64_t toPlayerId, int64_t amount) {
+    if (fromPlayerId == toPlayerId || amount <= 0)
+        return false;
+
+    std::lock_guard<std::mutex> lock(mutex_); // Lock once for atomicity
+
+    auto fromIt = playerInventories_.find(fromPlayerId);
+    auto toIt   = playerInventories_.find(toPlayerId);
+
+    if (fromIt == playerInventories_.end() || toIt == playerInventories_.end())
+        return false;                         // Both players must have inventories
+
+    if (fromIt->second.gold < amount)
+        return false;                         // Insufficient funds
+
+    // Perform transfer
+    fromIt->second.gold -= amount;
+    toIt->second.gold += amount;
+
+    // Cap at max (though gold is int64_t, addition could overflow, but unlikely)
+    if (toIt->second.gold < 0) toIt->second.gold = INT64_MAX;
+
+    // Save both inventories (optional – SaveInventory already writes to DB)
+    SaveInventory(fromPlayerId);
+    SaveInventory(toPlayerId);
+    return true;
+}
+
+std::shared_ptr<LootItem> InventorySystem::GetItem(uint64_t playerId, int slot) {
+    std::lock_guard<std::mutex> lock(mutex_);
+
+    auto it = playerInventories_.find(playerId);
+    if (it == playerInventories_.end())
+        return nullptr;
+
+    if (slot < 0 || slot >= static_cast<int>(it->second.inventorySlots.size()))
+        return nullptr;
+
+    const auto& slotData = it->second.inventorySlots[slot];
+    return slotData.item; // may be nullptr if slot empty
+}
+
+std::vector<InventorySlot> InventorySystem::GetInventory(uint64_t playerId) const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto it = playerInventories_.find(playerId);
+    if (it == playerInventories_.end()) {
+        return {};
+    }
+    return it->second.inventorySlots;
+}
+
 // Helper method implementations
 bool InventorySystem::ValidateSlot(uint64_t playerId, int slot) const {
     auto it = playerInventories_.find(playerId);
@@ -318,6 +417,8 @@ int InventorySystem::GetEquipmentSlotForItem(const LootItem& item) const {
 }
 
 bool InventorySystem::MeetsRequirements(uint64_t playerId, const LootItem& item) const {
+    (void)playerId;
+    (void)item;
     // TODO: Implement player level and other requirement checks
     // For now, just check level requirement
     // This would need access to player stats/level

src/game/LogicCore.cpp

@@ -490,6 +490,68 @@ void LogicCore::HandleLogin(uint64_t sessionId, const nlohmann::json& data) {
         });
 }
 
+void LogicCore::HandleChat(uint64_t sessionId, const nlohmann::json& data) {
+    uint64_t playerId = GetPlayerIdBySession(sessionId);
+    if (playerId == 0) {
+        SendError(sessionId, "Player not authenticated", 401);
+        return;
+    }
+
+    if (!data.contains("message") || !data["message"].is_string()) {
+        SendError(sessionId, "Missing or invalid message", 400);
+        return;
+    }
+
+    std::string chatMessage = data["message"];
+    if (chatMessage.empty()) {
+        SendError(sessionId, "Message cannot be empty", 400);
+        return;
+    }
+
+    // Optional: handle commands (starting with '/')
+    if (chatMessage[0] == '/') {
+        // Delegate to a command handler if desired
+        // For now, just treat as normal chat
+    }
+
+    auto player = playerManager_.GetPlayer(playerId);
+    if (!player) {
+        SendError(sessionId, "Player not found", 500);
+        return;
+    }
+
+    Logger::Info("Chat from player {} ({}): {}", playerId, player->GetName(), chatMessage);
+
+    nlohmann::json chatJson = {
+        {"type", "chat"},
+        {"playerId", playerId},
+        {"playerName", player->GetName()},
+        {"message", chatMessage},
+        {"timestamp", GetCurrentTimestamp()}
+    };
+
+    std::string channel = data.value("channel", "local");
+    if (channel == "global") {
+        // Broadcast to all online players
+        auto& connMgr = ConnectionManager::GetInstance();
+        auto sessions = connMgr.GetAllSessions();
+        for (auto& session : sessions) {
+            if (session && session->IsConnected()) {
+                session->Send(chatJson);
+            }
+        }
+    } else {
+        // Default to local broadcast (nearby players)
+        playerManager_.BroadcastToNearbyPlayers(playerId, chatJson);
+    }
+
+    FirePythonEvent("player_chat", {
+        {"playerId", playerId},
+        {"message", chatMessage},
+        {"channel", channel}
+    });
+}
+
 void LogicCore::HandleCombat(uint64_t sessionId, const nlohmann::json& data) {
     uint64_t playerId = GetPlayerIdBySession(sessionId);
     if (playerId == 0) {

src/game/LootTable.cpp

@@ -1,12 +1,9 @@
-#include <fstream>
-#include <algorithm>
-
 #include "game/LootTable.hpp"
-#include "logging/Logger.hpp"
 
 nlohmann::json LootEntry::Serialize() const {
     return {
         {"itemId", itemId},
+        {"name", name},
         {"dropChance", dropChance},
         {"minQuantity", minQuantity},
         {"maxQuantity", maxQuantity},
@@ -22,6 +19,7 @@ nlohmann::json LootEntry::Serialize() const {
 
 void LootEntry::Deserialize(const nlohmann::json& data) {
     itemId = data["itemId"];
+    name = data["name"];
     dropChance = data["dropChance"];
     minQuantity = data["minQuantity"];
     maxQuantity = data["maxQuantity"];