Merge pull request #203 from UchuServer/enhancement/factions

Enhancement/factions

Author: MickVermeulen

Uchu.World/Handlers/Commands/CharacterCommandHandler.cs

@@ -1061,9 +1061,10 @@ public async Task<string> Complete(string[] arguments, Player player)
         [CommandHandler(Signature = "clear", Help = "Clears your inventory", GameMasterLevel = GameMasterLevel.Admin)]
         public async Task<string> Clear(string[] arguments, Player player)
         {
-            foreach (var item in player.GetComponent<InventoryManagerComponent>()[InventoryType.Items].Items)
+            var inventory = player.GetComponent<InventoryManagerComponent>();
+            foreach (var item in inventory[InventoryType.Items].Items)
             {
-                await item.DecrementCountAsync(item.Count);
+                await inventory.RemoveItemAsync(item);
             }
 
             return "Cleared inventory";

Uchu.World/Handlers/GameMessages/GeneralHandler.cs

@@ -3,29 +3,51 @@
 using Microsoft.EntityFrameworkCore;
 using Uchu.Core;
 using Uchu.Core.Client;
+using Uchu.Core.Resources;
 using Uchu.World.Client;
 
 namespace Uchu.World.Handlers.GameMessages
 {
     public class GeneralHandler : HandlerGroup
     {
+        
+        /// <summary>
+        /// For the faction initial missions this sets their state from started to ready to complete on an interaction
+        /// </summary>
+        /// <param name="gameObject">The game object to interact with</param>
+        /// <param name="missions">The missions inventory of a player</param>
+        private static async Task HandleFactionVendorInteraction(GameObject gameObject, MissionInventoryComponent missions)
+        {
+            // For some reason the targets of faction missions are different game objects than the one you interact with
+            var targetLot = (int) gameObject.Lot switch
+            {
+                Lot.SentinelFactionVendor => Lot.SentinelFactionVendorProxy, 
+                Lot.ParadoxFactionVendor => Lot.ParadoxFactionVendorProxy, 
+                Lot.AssemblyFactionVendor => Lot.AssemblyFactionVendorProxy, 
+                Lot.VentureFactionVendor => Lot.VentureFactionVendorProxy, 
+                _ => default
+            };
+
+            if (targetLot != default)
+                await missions.GoToNpcAsync(targetLot);
+        }
+        
         [PacketHandler]
         public async Task RequestUseHandler(RequestUseMessage message, Player player)
         {
             Logger.Information($"{player} interacted with {message.TargetObject}");
 
             var inventory = player.GetComponent<MissionInventoryComponent>();
-            
             await inventory.GoToNpcAsync(
                 message.TargetObject.Lot
             );
+            
+            // Handle interactions with the faction vendors
+            await HandleFactionVendorInteraction(message.TargetObject, inventory);
 
             if (message.IsMultiInteract)
             {
-                //
                 // Multi-interact is mission
-                //
-
                 if (message.MultiInteractType == 0) // Mission Component
                 {
                     player.GetComponent<MissionInventoryComponent>().MessageOfferMission(
@@ -36,14 +58,12 @@ await inventory.GoToNpcAsync(
                 else if (message.MultiInteractType == 1) // Any other case
                 {
                     await message.TargetObject.OnInteract.InvokeAsync(player);
-
                     await inventory.InteractAsync(message.TargetObject.Lot);
                 }
             }
             else if (message.TargetObject != default)
             {
                 await message.TargetObject.OnInteract.InvokeAsync(player);
-                
                 await inventory.InteractAsync(message.TargetObject.Lot);
             }
         }

Uchu.World/Handlers/WorldInitializationHandler.cs

@@ -259,7 +259,8 @@ private static InventoryNode InventoryNode(Character character)
                     ItemContainerNode(character, InventoryType.Items),
                     ItemContainerNode(character, InventoryType.Bricks),
                     ItemContainerNode(character, InventoryType.Models),
-                    ItemContainerNode(character, InventoryType.Behaviors)
+                    ItemContainerNode(character, InventoryType.Behaviors),
+                    ItemContainerNode(character, InventoryType.Hidden)
                 }
             };
         }

Uchu.World/Objects/Components/Player/InventoryManagerComponent.cs

@@ -88,6 +88,11 @@ await inventory.LoadItems(
 
                     _inventories.Add(inventoryType, inventory);
                 }
+
+                // Finally load all the sub items
+                if (this[InventoryType.Hidden] is {} hiddenInventory)
+                    await hiddenInventory.LoadItems(playerCharacter.Items.Where(i => i.ParentId != ObjectId.Invalid 
+                        && (InventoryType) i.InventoryType == InventoryType.Hidden));
             });
 
             Listen(OnDestroyed, () =>
@@ -106,11 +111,7 @@ await inventory.LoadItems(
         public async Task SaveAsync(UchuContext context)
         {
             var itemsToSave = Items;
-            
-            // If the inventory is empty something went terribly wrong, do NOT save
-            if (itemsToSave.Length == 0)
-                return;
-            
+
             var character = await context.Characters.Where(c => c.Id == GameObject.Id)
                 .Include(c => c.Items)
                 .FirstAsync();
@@ -193,6 +194,19 @@ public Item FindItem(Lot lot, InventoryType inventoryType)
             return _inventories[inventoryType].Items.FirstOrDefault(i => i.Lot == lot);
         }
 
+        /// <summary>
+        /// Finds and returns the first item of a certain lot in a certain inventory given that the provided argument
+        /// item is its parent
+        /// </summary>
+        /// <param name="lot">The lot of the item to look for</param>
+        /// <param name="inventoryType">The inventory type to look in for the item</param>
+        /// <param name="rootItem">The root item that this item needs to belong to</param>
+        /// <returns>The item retrieved from the given inventory</returns>
+        public Item FindItem(Lot lot, InventoryType inventoryType, Item rootItem)
+        {
+            return _inventories[inventoryType].Items.FirstOrDefault(i => i.Lot == lot && i.RootItem?.Id == rootItem.Id);
+        }
+
         /// <summary>
         /// Finds an item by looking for the provided lot in the given inventory type and ensuring that said item has a
         /// count of at least minimumCount
@@ -223,14 +237,7 @@ public Item[] FindItems(Lot lot) => _inventories.Values.SelectMany(
         /// <returns>List of all found items</returns>
         public Item[] FindItems(Lot lot, InventoryType inventoryType) =>
             _inventories[inventoryType].Items.Where(i => i.Lot == lot).ToArray();
-        
-        /// <summary>
-        /// If this is a sub item, it returns the root item of this item. If this item is a root item, it returns itself.
-        /// </summary>
-        /// <param name="item">The item to find the root item for</param>
-        /// <returns>The root item of this item if it is a sub item, the same item otherwise</returns>
-        public Item GetRootItem(Item item) => Items.FirstOrDefault(i => i.Id == item.RootItem?.Id) ?? item;
-        
+
         #endregion finditem
 
         /// <summary>
@@ -297,19 +304,26 @@ private static async Task<ItemComponent> GetItemComponentForLotAysnc(Lot lot)
 
             return itemComponent;
         }
-        
+
         /// <summary>
         /// Adds a new lot to the inventory. The lot will automatically instantiated as the required amount of items
         /// based on the provided count and the stack size of that item.
         /// </summary>
+        /// <remarks>
+        /// The returning list may be empty if it was possible to distribute over already existing stacks
+        /// </remarks>
         /// <param name="lot">The lot to add to the inventory</param>
         /// <param name="count">The count of the lot we want to add to the inventory</param>
-        /// <param name="inventoryType">Optional explicit inventory type to add this lot to, if not provided this will be
-        /// implicitly retrieved from the item lot, generally used for vendor buy back</param>
         /// <param name="settings">Optional <c>LegoDataDictionary</c> to instantiate the item with</param>
-        public async Task AddLotAsync(Lot lot, uint count, LegoDataDictionary settings = default, 
-            InventoryType inventoryType = default)
+        /// <param name="inventoryType">Optional explicit inventory type to add this lot to, if not provided this will be
+        ///     implicitly retrieved from the item lot, generally used for vendor buy back</param>
+        /// <param name="rootItem">An optional parent item</param>
+        /// <returns>The list of items that were created while adding the lot</returns>
+        public async Task AddLotAsync(Lot lot, uint count, LegoDataDictionary settings = default,
+            InventoryType inventoryType = default, Item rootItem = default)
         {
+            var createdItems = new List<Item>();
+            
             // For players, the faction token proxy needs to be replaced with an actual faction token
             // If this wasn't possible, exit
             if (!HandleFactionToken(ref lot))
@@ -363,14 +377,15 @@ public async Task AddLotAsync(Lot lot, uint count, LegoDataDictionary settings =
                 while (totalToAdd > 0)
                 {
                     var toAdd = (uint) Min(stackSize, (int) totalToAdd);
-                    var item = await Item.Instantiate(GameObject, lot, inventory, toAdd, extraInfo: settings);
+                    var item = await Item.Instantiate(GameObject, lot, inventory, toAdd, extraInfo: settings, rootItem: rootItem);
 
                     // Might occur if the inventory is full or an error occured during slot claiming
                     if (item == null)
                         return; // TODO: Message item to player with mail
 
                     Start(item);
                     item.MessageCreation();
+                    createdItems.Add(item);
 
                     totalToAdd -= toAdd;
                     totalAdded += toAdd;
@@ -394,6 +409,12 @@ public async Task AddLotAsync(Lot lot, uint count, LegoDataDictionary settings =
                     await OnLotAdded.InvokeAsync(lot, (uint)totalAdded);
                 });
             }
+            
+            // Create sub items if this was a root item
+            if (rootItem == null)
+                foreach (var createdItem in createdItems)
+                foreach (var subItemLot in createdItem.SubItemLots)
+                    await AddLotAsync(subItemLot, 1, default, InventoryType.Hidden, createdItem);
         }
 
         /// <summary>
@@ -463,7 +484,7 @@ public async Task RemoveLotAsync(Lot lot, uint count, InventoryType inventoryTyp
                 {
                     var amountToRemove = (uint) Min((int) count, (int) itemToRemove.Count);
                     await itemToRemove.DecrementCountAsync(amountToRemove, silent);
-
+   
                     count -= amountToRemove;
                     if (count == 0)
                         return;

Uchu.World/Objects/Components/Player/MissionInventoryComponent.cs

@@ -6,6 +6,7 @@
 using Microsoft.EntityFrameworkCore;
 using Uchu.Core;
 using Uchu.Core.Client;
+using Uchu.Core.Resources;
 using Uchu.World.Client;
 using Uchu.World.Objects.Components;
 using Uchu.World.Systems.Missions;
@@ -267,6 +268,17 @@ public bool HasMission(int id)
             }
         }
 
+        
+        /// <summary>
+        /// Returns the mission with a given id from the mission inventory.
+        /// </summary>
+        /// <param name="missionId">The id of the mission to get from the inventory</param>
+        /// <returns>A mission instance if the player has this mission, <c>default</c> otherwise.</returns>
+        public MissionInstance GetMission(MissionId missionId)
+        {
+            return GetMission((int) missionId);
+        }
+
         /// <summary>
         /// Returns the mission with a given id from the mission inventory.
         /// </summary>
@@ -630,7 +642,8 @@ await StartUnlockableAchievementsAsync<PetTameTask>(MissionTaskType.TamePet, Pet
         /// <returns>A list of all the achievements a player can unlock, given the task type and the lot</returns>
         private MissionInstance[] UnlockableAchievements<T>(MissionTaskType type, Lot lot)
             where T : MissionTaskInstance => ClientCache.Achievements.Where(m =>
-                m.Tasks.OfType<T>().Any(t => t.Type == type && t.Targets.Contains((int) lot))
+                m.Tasks.OfType<T>().Any(t => t.Type == type 
+                                             && (t.Targets.Contains((int) lot) || t.Parameters.Contains((int) lot)))
                 && CanAccept(m)).ToArray();
 
         /// <summary>
@@ -643,6 +656,7 @@ private MissionInstance[] UnlockableAchievements<T>(MissionTaskType type, Lot lo
         private async Task StartUnlockableAchievementsAsync<T>(MissionTaskType type, Lot lot, Func<T, Task> progress = null)
             where T : MissionTaskInstance
         {
+            var testMission = ClientCache.Achievements.Where(m => m.MissionId == 568);
             foreach (var achievement in UnlockableAchievements<T>(type, lot))
             {
                 // Loading these here instead of out of the loop might seem odd but heuristically the chances of starting a