inventory working :D

Services/PetInventoryService.cs

@@ -5,180 +5,151 @@ namespace PetCompanion.Services
 {
     public class PetInventoryService
     {
-        private readonly PetInventoryRepository _inventoryRepository;
-        private readonly PetRepository _petRepository;
-        private readonly GameItemsRepository _gameItemsRepository;
+        private readonly PetInventoryRepository petInventoryRepository;
+        private readonly PetRepository petRepository;
+        private readonly GameItemsRepository gameItemsRepository;
+        private readonly GameItemService gameItemService;
 
         public PetInventoryService(
-            PetInventoryRepository inventoryRepository,
+            PetInventoryRepository petInventoryRepository,
             PetRepository petRepository,
-            GameItemsRepository gameItemsRepository)
+            GameItemsRepository gameItemsRepository,
+            GameItemService gameItemService)
         {
-            _inventoryRepository = inventoryRepository;
-            _petRepository = petRepository;
-            _gameItemsRepository = gameItemsRepository;
+            this.petInventoryRepository = petInventoryRepository;
+            this.petRepository = petRepository;
+            this.gameItemsRepository = gameItemsRepository;
+            this.gameItemService = gameItemService;
         }
 
-        public async Task<Inventory> GetInventory(string petId, string userId)
+        public Inventory GetInventory(string petId, string userId)
         {
-            var pet = _petRepository.GetPetById(petId, userId);
+            var pet = petRepository.GetPetById(petId, userId);
             if (pet == null)
                 throw new Exception("Pet not found");
 
-            return await _inventoryRepository.GetPetInventory(petId);
+            return petInventoryRepository.GetPetInventory(petId);
         }
 
-        public async Task<Inventory> CreateInventory(string petId)
+        public Inventory CreateInventory(string petId)
         {
             var inventory = new Inventory
             {
                 PetId = petId,
                 Capacity = 20,
-                Items = new List<InventoryItem>()
+                Items = new List<int>()
             };
 
-            await _inventoryRepository.SaveInventory(inventory);
+            petInventoryRepository.SavePetInventory(inventory);
             return inventory;
         }
 
-        public async Task<Pet> UseItem(string petId, string userId, int itemId)
+        public Pet UseItem(string petId, string userId, int itemId)
         {
-            var pet = _petRepository.GetPetById(petId, userId);
+            var pet = petRepository.GetPetById(petId, userId);
             if (pet == null)
                 throw new Exception("Pet not found");
 
-            var inventory = await _inventoryRepository.GetPetInventory(petId);
-            var item = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
-
-            if (item == null || item.Quantity <= 0)
+            if (!pet.Inventory.Items.Any(i => i == itemId))
                 throw new Exception("Item not found in inventory");
 
-            item.Quantity--;
-            if (item.Quantity <= 0)
-                inventory.Items.Remove(item);
+            var gameItem = gameItemsRepository.GetById(itemId);
 
-            await _inventoryRepository.SaveInventory(inventory);
-            return _petRepository.UpdatePet(pet);
+            gameItemService.ApplyItemEffect(pet, gameItem);
+
+            pet.Inventory.Items.Remove(itemId);
+
+            return petRepository.UpdatePet(pet);
         }
 
-        public async Task<Pet> EquipItem(string petId, string userId, int itemId)
+        public Pet EquipItem(string petId, string userId, int itemId)
         {
-            var pet = _petRepository.GetPetById(petId, userId);
+            var pet = petRepository.GetPetById(petId, userId);
             if (pet == null)
                 throw new Exception("Pet not found");
 
-            var inventory = await _inventoryRepository.GetPetInventory(petId);
-            var item = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
-
-            if (item == null || item.Quantity <= 0)
+            if (!pet.Inventory.Items.Any(i => i == itemId))
                 throw new Exception("Item not found in inventory");
 
-            if (item.GameItem.Type != ItemType.Equipment)
+            var gameItem = gameItemsRepository.GetById(itemId);
+
+            if (gameItem.Type != ItemType.Equipment)
                 throw new Exception("Item is not equipment");
 
-            var equippedItems = await _inventoryRepository.GetEquippedItems(petId);
-            if (equippedItems.ContainsKey(item.GameItem.EquipTarget))
+            // If there's already an item equipped in that slot, unequip it first
+            if (pet.EquippedItems.ContainsKey(gameItem.EquipTarget))
             {
-                await UnequipItem(petId, userId, item.GameItem.EquipTarget);
+                UnequipItem(petId, userId, gameItem.EquipTarget);
             }
 
-            item.Quantity--;
-            if (item.Quantity <= 0)
-                inventory.Items.Remove(item);
+            // Apply equipment effects
+            gameItemService.ApplyItemEffect(pet, gameItem);
 
-            await _inventoryRepository.SaveInventory(inventory);
-            return _petRepository.UpdatePet(pet);
+            // Mark item as equipped
+            pet.EquippedItems[gameItem.EquipTarget] = itemId;
+
+            // Remove from inventory
+            pet.Inventory.Items.Remove(itemId);
+
+            petInventoryRepository.UpdateEquippedItems(petId, pet.EquippedItems);
+
+            return petRepository.UpdatePet(pet);
         }
 
-        public async Task<Pet> UnequipItem(string petId, string userId, ItemEquipTarget equipTarget)
+        public Pet UnequipItem(string petId, string userId, ItemEquipTarget equipTarget)
         {
-            var pet = _petRepository.GetPetById(petId, userId);
+            var pet = petRepository.GetPetById(petId, userId);
             if (pet == null)
                 throw new Exception("Pet not found");
 
-            var equippedItems = await _inventoryRepository.GetEquippedItems(petId);
-            if (!equippedItems.ContainsKey(equipTarget))
-                return pet;
+            if (!pet.EquippedItems.ContainsKey(equipTarget))
+                throw new Exception("No item equipped in that slot");
 
-            var itemId = equippedItems[equipTarget];
-            var item = _gameItemsRepository.GetById(itemId);
+            var equippedItemId = pet.EquippedItems[equipTarget];
+            var equippedItem = gameItemsRepository.GetById(equippedItemId);
 
-            if (item != null)
+            if (equippedItem != null)
             {
-                var inventory = await _inventoryRepository.GetPetInventory(petId);
-                var inventoryItem = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
+                // Remove equipment effects
+                gameItemService.RemoveItemEffect(pet, equippedItem);
 
-                if (inventoryItem != null)
-                    inventoryItem.Quantity++;
-                else
-                    inventory.Items.Add(new InventoryItem
-                    {
-                        GameItemId = itemId,
-                        Quantity = 1,
-                        GameItem = item,
-                        InventoryId = pet.Id
-                    });
-
-                await _inventoryRepository.SaveInventory(inventory);
+                // Add item back to inventory
+                pet.Inventory.Items.Add(equippedItemId);
             }
 
-            return _petRepository.UpdatePet(pet);
+            pet.EquippedItems.Remove(equipTarget);
+
+            return petRepository.UpdatePet(pet);
         }
 
-        public async Task<Pet> DropItem(string petId, string userId, int itemId)
+        public Pet DropItem(string petId, string userId, int itemId)
         {
-            var pet = _petRepository.GetPetById(petId, userId);
-            if (pet == null)
-                throw new Exception("Pet not found");
+            var pet = petRepository.GetPetById(petId, userId);
 
-            var inventory = await _inventoryRepository.GetPetInventory(petId);
-            if (inventory == null)
-                throw new Exception("Inventory not found");
-
-            var item = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
-            if (item == null || item.Quantity <= 0)
+            if (!pet.Inventory.Items.Any(i => i == itemId))
                 throw new Exception("Item not found in inventory");
 
-            item.Quantity--;
-            if (item.Quantity <= 0)
-                inventory.Items.Remove(item);
+            var gameItem = gameItemsRepository.GetById(itemId);
 
-            await _inventoryRepository.SaveInventory(inventory);
-            return pet;
+            pet.Inventory.Items.Remove(itemId);
+
+            return petRepository.UpdatePet(pet);
         }
 
-        public async Task<Pet> AddItemToPet(string petId, string userId, int itemId, int quantity)
+        public Pet AddItemToPet(string petId, string userId, int itemId, int quantity)
         {
-            var pet = _petRepository.GetPetById(petId, userId);
-            if (pet == null)
-                throw new Exception("Pet not found");
+            var pet = petRepository.GetPetById(petId, userId);
+            var gameItem = gameItemsRepository.GetById(itemId);
 
-            var gameItem = _gameItemsRepository.GetById(itemId);
             if (gameItem == null)
                 throw new Exception("Item not found");
 
-            var inventory = await _inventoryRepository.GetPetInventory(petId);
-            if (inventory == null)
-                throw new Exception("Inventory not found");
-
-            var existingItem = inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
-            if (existingItem != null)
+            for (int i = 0; i < quantity; i++)
             {
-                existingItem.Quantity += quantity;
-            }
-            else
-            {
-                inventory.Items.Add(new InventoryItem
-                {
-                    GameItemId = itemId,
-                    Quantity = quantity,
-                    GameItem = gameItem,
-                    InventoryId = inventory.PetId
-                });
+                pet.Inventory.Items.Add(itemId);
             }
 
-            await _inventoryRepository.SaveInventory(inventory);
-            return pet;
+            return petRepository.UpdatePet(pet);
         }
     }
 }

Services/PetService.cs

@@ -52,7 +52,7 @@ namespace PetCompanion.Services
 
             var createdPet = petRepository.CreatePet(pet);
 
-            var inventory = petInventoryService.CreateInventory(petId).Result;
+            var inventory = petInventoryService.CreateInventory(petId);
 
             return createdPet;
         }
@@ -155,98 +155,6 @@ namespace PetCompanion.Services
             return petRepository.UpdatePetResources(pet);
         }
 
-        public Pet UseItem(string petId, string userId, int itemId)
-        {
-            var pet = petRepository.GetPetById(petId, userId);
-            if (pet == null)
-                throw new Exception("Pet not found");
-
-            var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
-            if (inventoryItem == null || inventoryItem.Quantity <= 0)
-                throw new Exception("Item not found in inventory");
-
-            gameItemService.ApplyItemEffect(pet, inventoryItem.GameItem);
-
-            inventoryItem.Quantity--;
-            if (inventoryItem.Quantity <= 0)
-                pet.Inventory.Items.Remove(inventoryItem);
-
-            return petRepository.UpdatePet(pet);
-        }
-
-        public Pet EquipItem(string petId, string userId, int itemId)
-        {
-            var pet = petRepository.GetPetById(petId, userId);
-            if (pet == null)
-                throw new Exception("Pet not found");
-
-            var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
-            if (inventoryItem == null || inventoryItem.Quantity <= 0)
-                throw new Exception("Item not found in inventory");
-
-            if (inventoryItem.GameItem.Type != ItemType.Equipment)
-                throw new Exception("Item is not equipment");
-
-            // If there's already an item equipped in that slot, unequip it first
-            if (pet.EquippedItems.ContainsKey(inventoryItem.GameItem.EquipTarget))
-            {
-                UnequipItem(pet, inventoryItem.GameItem.EquipTarget);
-            }
-
-            // Apply equipment effects
-            gameItemService.ApplyItemEffect(pet, inventoryItem.GameItem);
-
-            // Mark item as equipped
-            pet.EquippedItems[inventoryItem.GameItem.EquipTarget] = itemId;
-
-            // Remove from inventory
-            inventoryItem.Quantity--;
-            if (inventoryItem.Quantity <= 0)
-                pet.Inventory.Items.Remove(inventoryItem);
-
-            return petRepository.UpdatePet(pet);
-        }
-
-        public Pet UnequipItem(string petId, string userId, ItemEquipTarget equipTarget)
-        {
-            var pet = petRepository.GetPetById(petId, userId);
-            if (pet == null)
-                throw new Exception("Pet not found");
-
-            UnequipItem(pet, equipTarget);
-            return petRepository.UpdatePet(pet);
-        }
-
-        private void UnequipItem(Pet pet, ItemEquipTarget equipTarget)
-        {
-            if (!pet.EquippedItems.ContainsKey(equipTarget))
-                return;
-
-            var equippedItemId = pet.EquippedItems[equipTarget];
-            var equippedItem = gameItemsRepository.GetById(equippedItemId);
-
-            if (equippedItem != null)
-            {
-                // Remove equipment effects
-                gameItemService.RemoveItemEffect(pet, equippedItem);
-
-                // Add item back to inventory
-                var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == equippedItemId);
-                if (inventoryItem != null)
-                    inventoryItem.Quantity++;
-                else
-                    pet.Inventory.Items.Add(new InventoryItem
-                    {
-                        GameItemId = equippedItemId,
-                        Quantity = 1,
-                        GameItem = equippedItem,
-                        InventoryId = pet.Id
-                    });
-            }
-
-            pet.EquippedItems.Remove(equipTarget);
-        }
-
         public Pet GetPet(string petId, string userId)
         {
             var pet = petRepository.GetPetById(petId, userId);
@@ -254,47 +162,5 @@ namespace PetCompanion.Services
                 throw new Exception("Pet not found");
             return pet;
         }
-
-        public Pet DropItem(string petId, string userId, int itemId)
-        {
-            var pet = GetPet(petId, userId);
-
-            var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
-            if (inventoryItem == null || inventoryItem.Quantity <= 0)
-                throw new Exception("Item not found in inventory");
-
-            inventoryItem.Quantity--;
-            if (inventoryItem.Quantity <= 0)
-                pet.Inventory.Items.Remove(inventoryItem);
-
-            return petRepository.UpdatePet(pet);
-        }
-
-        public Pet AddItemToPet(string petId, string userId, int itemId, int quantity)
-        {
-            var pet = GetPet(petId, userId);
-            var gameItem = gameItemsRepository.GetById(itemId);
-
-            if (gameItem == null)
-                throw new Exception("Item not found");
-
-            var inventoryItem = pet.Inventory.Items.FirstOrDefault(i => i.GameItemId == itemId);
-            if (inventoryItem != null)
-            {
-                inventoryItem.Quantity += quantity;
-            }
-            else
-            {
-                pet.Inventory.Items.Add(new InventoryItem
-                {
-                    GameItemId = itemId,
-                    Quantity = quantity,
-                    GameItem = gameItem,
-                    InventoryId = pet.Id
-                });
-            }
-
-            return petRepository.UpdatePet(pet);
-        }
     }
 }

Services/PetSkillService.cs

@@ -14,16 +14,16 @@ namespace PetCompanion.Services
             _petRepository = petRepository;
         }
 
-        public async Task<IEnumerable<PetSkill>> GetPetSkills(string petId, string userId)
+        public IEnumerable<PetSkill> GetPetSkills(string petId, string userId)
         {
             var pet = _petRepository.GetPetById(petId, userId);
             if (pet == null)
                 throw new Exception("Pet not found");
 
-            return await _petSkillRepository.GetPetSkills(petId);
+            return _petSkillRepository.GetPetSkills(petId);
         }
 
-        public async Task<PetSkill> AllocateSkillPoint(string petId, string userId, int skillId)
+        public PetSkill AllocateSkillPoint(string petId, string userId, int skillId)
         {
             var pet = _petRepository.GetPetById(petId, userId);
             if (pet == null)
@@ -32,7 +32,7 @@ namespace PetCompanion.Services
             if (pet.SkillPoints <= 0)
                 throw new Exception("No skill points available");
 
-            var skills = await _petSkillRepository.GetPetSkills(petId);
+            var skills = _petSkillRepository.GetPetSkills(petId);
             var existingSkill = skills.FirstOrDefault(s => s.SkillId == skillId);
 
             if (existingSkill != null)
@@ -41,7 +41,7 @@ namespace PetCompanion.Services
                     throw new Exception("Skill already at maximum tier");
 
                 existingSkill.CurrentTier++;
-                await _petSkillRepository.SavePetSkill(existingSkill);
+                _petSkillRepository.SavePetSkill(existingSkill);
             }
             else
             {
@@ -51,7 +51,7 @@ namespace PetCompanion.Services
                     SkillId = skillId,
                     CurrentTier = SkillTier.I
                 };
-                await _petSkillRepository.SavePetSkill(existingSkill);
+                _petSkillRepository.SavePetSkill(existingSkill);
             }
 
             pet.SkillPoints--;

Services/SkillService.cs

@@ -21,11 +21,11 @@ namespace PetCompanion.Services
             _petSkillRepository = petSkillRepository;
         }
 
-        public async Task<PetSkill> AllocateSkillPoint(string petId, string userId, int skillId)
+        public PetSkill AllocateSkillPoint(string petId, string userId, int skillId)
         {
-            var pet = await _context.Pets
+            var pet = _context.Pets
                 .Include(p => p.Skills)
-                .FirstOrDefaultAsync(p => p.Id == petId && p.UserId == userId);
+                .FirstOrDefault(p => p.Id == petId && p.UserId == userId);
 
             if (pet == null)
                 throw new Exception("Pet not found");
@@ -33,9 +33,9 @@ namespace PetCompanion.Services
             if (pet.SkillPoints <= 0)
                 throw new Exception("No skill points available");
 
-            var skill = await _context.Skills
+            var skill = _context.Skills
                 .Include(s => s.Effects)
-                .FirstOrDefaultAsync(s => s.Id == skillId);
+                .FirstOrDefault(s => s.Id == skillId);
 
             if (skill == null)
                 throw new Exception("Skill not found");
@@ -51,7 +51,7 @@ namespace PetCompanion.Services
                 if (effect != null)
                     effect.PetSkillUpgrade(ref pet);
 
-                await _petSkillRepository.SavePetSkill(existingSkill);
+                _petSkillRepository.SavePetSkill(existingSkill);
             }
             else
             {
@@ -61,7 +61,7 @@ namespace PetCompanion.Services
                     SkillId = skillId,
                     CurrentTier = SkillTier.I
                 };
-                await _petSkillRepository.SavePetSkill(newSkill);
+                _petSkillRepository.SavePetSkill(newSkill);
 
                 var effect = skill.Effects.FirstOrDefault(e => e.Tier == SkillTier.I);
                 if (effect != null)
@@ -69,16 +69,16 @@ namespace PetCompanion.Services
             }
 
             pet.SkillPoints--;
-            await _context.SaveChangesAsync();
+            _context.SaveChanges();
 
-            return (await _petSkillRepository.GetPetSkills(petId)).First(ps => ps.SkillId == skillId);
+            return _petSkillRepository.GetPetSkills(petId).First(ps => ps.SkillId == skillId);
         }
 
-        public async Task<IEnumerable<Skill>> GetAvailableSkills()
+        public IEnumerable<Skill> GetAvailableSkills()
         {
-            return await _context.Skills
+            return _context.Skills
                 .Include(s => s.Effects)
-                .ToListAsync();
+                .ToList();
         }
     }
 }