fix LogicEntity

Author: usermicrodevices

include/game/LogicEntity.hpp

@@ -15,46 +15,46 @@ class LogicEntity {
 public:
     LogicEntity();
     ~LogicEntity();
-    
+
     // Initialization
     void Initialize();
     void Shutdown();
-    
+
     // NPC management
     uint64_t SpawnNPC(NPCType type, const glm::vec3& position, uint64_t ownerId = 0);
     void DespawnNPC(uint64_t npcId);
     void UpdateNPCs(float deltaTime);
     NPCEntity* GetNPCEntity(uint64_t npcId);
-    
+
     // Entity management
     GameEntity* GetEntity(uint64_t entityId);
     PlayerEntity* GetPlayerEntity(uint64_t playerId);
-    
+
     // Collision management
     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);
     void UpdateCollisions(float deltaTime);
-    
+
     // Loot management
     void CreateLootEntity(const glm::vec3& position, std::shared_ptr<LootItem> item, int quantity);
-    
+
     // Statistics
     int GetActiveNPCCount() const { return activeNPCCount_; }
-    
+
 private:
     std::unique_ptr<NPCManager> npcManager_;
     std::unordered_map<uint64_t, std::unique_ptr<NPCEntity>> npcEntities_;
     std::mutex npcMutex_;
     std::atomic<int> activeNPCCount_{0};
-    
+
     MobSystem& mobSystem_;
     EntityManager& entityManager_;
     std::unique_ptr<CollisionSystem> collisionSystem_;
-    
+
     // Loot systems
-    std::unique_ptr<InventorySystem> inventorySystem_;
     std::unique_ptr<LootTableManager> lootTableManager_;
-    
+    //std::unique_ptr<InventorySystem> inventorySystem_;
+
     void InitializeNPCSystem();
     void InitializeMobSystem();
     void InitializeCollisionSystem();

src/game/LogicEntity.cpp

@@ -18,14 +18,11 @@ void LogicEntity::Initialize() {
     InitializeNPCSystem();
     InitializeMobSystem();
     InitializeCollisionSystem();
-    
     auto& config = ConfigManager::GetInstance();
-    
     // Initialize loot systems
-    inventorySystem_ = std::make_unique<InventorySystem>();
+    //inventorySystem_ = std::make_unique<InventorySystem>();
     lootTableManager_ = std::make_unique<LootTableManager>();
     lootTableManager_->LoadLootTables("config/loot_tables.json");
-    
     Logger::Info("LogicEntity initialized");
 }
 
@@ -35,42 +32,35 @@ void LogicEntity::Shutdown() {
         npcEntities_.clear();
         activeNPCCount_ = 0;
     }
-    
     npcManager_.reset();
     collisionSystem_.reset();
-    inventorySystem_.reset();
+    //inventorySystem_.reset();
     lootTableManager_.reset();
-    
     Logger::Info("LogicEntity shutdown");
 }
 
 void LogicEntity::InitializeNPCSystem() {
     Logger::Info("Initializing NPC system...");
     npcManager_ = std::make_unique<NPCManager>();
-    
     auto& config = ConfigManager::GetInstance();
     int initialNPCCount = config.GetInt("npcs.initial_count", 20);
-    
     std::random_device rd;
     std::mt19937 gen(rd());
     std::uniform_real_distribution<float> posDist(-200.0f, 200.0f);
     std::uniform_int_distribution<int> npcTypeDist(0, 3);
-    
     for (int i = 0; i < initialNPCCount; ++i) {
         float x = posDist(gen);
         float z = posDist(gen);
         float y = 20.0f; // Default height
         NPCType type = static_cast<NPCType>(npcTypeDist(gen));
         SpawnNPC(type, glm::vec3(x, y, z));
     }
-    
     Logger::Info("Spawned {} initial NPCs", initialNPCCount);
 }
 
 void LogicEntity::InitializeMobSystem() {
     Logger::Info("Initializing mob system...");
     mobSystem_.Initialize();
-    
     auto& config = ConfigManager::GetInstance();
     if (config.HasKey("mobs")) {
         nlohmann::json mobConfig = config.GetJson("mobs");
@@ -85,56 +75,46 @@ void LogicEntity::InitializeCollisionSystem() {
 
 uint64_t LogicEntity::SpawnNPC(NPCType type, const glm::vec3& position, uint64_t ownerId) {
     std::lock_guard<std::mutex> lock(npcMutex_);
-    
     uint64_t npcId = npcManager_->SpawnNPC(type, position, ownerId);
     if (npcId == 0) {
         Logger::Error("Failed to spawn NPC type {}", static_cast<int>(type));
         return 0;
     }
-    
     NPCEntity* npc = npcManager_->GetNPC(npcId);
     if (!npc) {
         Logger::Error("Failed to get spawned NPC");
         return 0;
     }
-    
     npcEntities_[npcId] = std::unique_ptr<NPCEntity>(npc);
     activeNPCCount_++;
-    
     // Register in collision system
     BoundingSphere bounds{position, 1.0f};
     collisionSystem_->RegisterEntity(npcId, bounds, CollisionType::ENTITY);
-    
     Logger::Debug("Spawned NPC {} at [{:.1f}, {:.1f}, {:.1f}]",
                   npcId, position.x, position.y, position.z);
     return npcId;
 }
 
 void LogicEntity::DespawnNPC(uint64_t npcId) {
     std::lock_guard<std::mutex> lock(npcMutex_);
-    
     auto it = npcEntities_.find(npcId);
     if (it == npcEntities_.end()) {
         return;
     }
-    
     collisionSystem_->UnregisterEntity(npcId);
     npcManager_->DespawnNPC(npcId);
     npcEntities_.erase(it);
     activeNPCCount_--;
-    
     Logger::Debug("Despawned NPC {}", npcId);
 }
 
 void LogicEntity::UpdateNPCs(float deltaTime) {
     std::lock_guard<std::mutex> lock(npcMutex_);
-    
     for (auto& [npcId, npc] : npcEntities_) {
         if (!npc) continue;
         npc->Update(deltaTime);
         collisionSystem_->UpdateEntity(npcId, npc->GetPosition());
     }
-    
     mobSystem_.UpdateSpawnZones(deltaTime);
     mobSystem_.ProcessRespawns(deltaTime);
 }
@@ -177,6 +157,5 @@ void LogicEntity::CreateLootEntity(const glm::vec3& position, std::shared_ptr<Lo
     uint64_t entityId = entityManager_.CreateEntity(EntityType::ITEM, position);
     BoundingSphere bounds{position, 0.5f};
     collisionSystem_->RegisterEntity(entityId, bounds, CollisionType::TRIGGER);
-    
     Logger::Debug("Created loot entity {}: {} x{}", entityId, item->GetName(), quantity);
 }