public override void AddToInventory(IInventory inventory, int quantity = 1)
{
if (data.Flags.HasFlag(LeveledItemFlags.CalculateForEachItem))
{
for (var i = 0; i < quantity; i++)
{
var random = Random.Range(0, 100);
if (random < chanceNone)
{
continue;
}
var index = Random.Range(0, items.Length);
var itemData = items[index].Item1;
inventory.AddItem(itemData, 1);
}
}
else
{
var random = Random.Range(0, 100);
if (random < chanceNone)
{
return;
}
var index = Random.Range(0, items.Length);
var itemData = items[index].Item1;
inventory.AddItem(itemData, quantity);
}
}
//###################
//## I INVENTORY ##
//###################
public override void RemoveItemFromSlot(int slotNo)
{
CollectableSO item = mInv.GetItemInSlot(slotNo);
if (item != null)
{
bool succ = mPlayerInv.AddItem(item);
if (succ)
{
mInv.RemoveItem(slotNo);
SoundManager.Instance.PlaySound("Uninstall");
}
}
}
/// <summary>
/// Handles outputting to things with the inventory interface.
/// </summary>
/// <param name="OUT_INV"></param>
public void OutputToInventory(IInventory OUT_INV)
{
//If the inventory is completely full, then just return.
if (OUT_INV.IsFull())
{
return;
}
else
{
//Get the item list with all its counts.
List <ItemAmount> ITEM_LIST = INV.GetItemAmountList();
//For each unique item, attempt to add its count.
foreach (ItemAmount ITEM_INFO in ITEM_LIST)
{
//If attempting to add the items would be successful,
if (OUT_INV.AttemptAddItem(ITEM_INFO.Item, ITEM_INFO.Amount))
{
GenericEntity OUT_INFO = OUT_INV.GetEntity();
List <GenericItem> UNIQUE_ITEMS = INV.GetUniqueItemsList();
if (UNIQUE_ITEMS.Contains(ITEM_INFO.Item))
{
UNIQUE_ITEMS.Add(ITEM_INFO.Item);
}
//Check if it is valid for us to place these items into the given entity.
if (GameManager.Instance.isItemPlacementValid(UNIQUE_ITEMS, OUT_INV.GetEntity().FLAGS))
{
OUT_INV.AddItem(ITEM_INFO.Item, ITEM_INFO.Amount);
INV.ExtractItem(ITEM_INFO.Item, ITEM_INFO.Amount);
}
}
}
}
}
protected virtual Boolean SwitchItems(ItemSlot p_targetSlot, ItemSlot p_originSlot, BaseItem p_originItem)
{
ItemContainer parent = p_originSlot.Parent;
BaseItem item = p_targetSlot.Item;
Boolean flag = parent.Inventory.IsItemPlaceableAt(item, p_originSlot.Index);
Boolean flag2 = m_inventory.IsItemPlaceableAt(p_originItem, p_targetSlot.Index);
if (!flag || !flag2)
{
return(false);
}
if (!(parent.Inventory is CharacterInventoryController))
{
if (!Consumable.AreSameConsumables(p_originItem, item))
{
parent.Inventory.AddItem(item, p_originSlot.Index);
}
m_inventory.AddItem(p_originItem, p_targetSlot.Index);
return(true);
}
EquipCommand p_command = new EquipCommand(parent.Inventory, m_inventory, p_originItem, item, p_originSlot.Index, p_targetSlot.Index);
if (LegacyLogic.Instance.UpdateManager.PartyTurnActor.CanDoCommand(p_command, LegacyLogic.Instance.WorldManager.Party.CurrentCharacter))
{
LegacyLogic.Instance.CommandManager.AddCommand(p_command);
return(true);
}
return(false);
}
public void AddItem(CollectableSO item, int slotNo)
{
if (!mInv.AddItem(slotNo, item))
{
Debug.LogWarning("Item in slot no " + slotNo + " does already exist!!");
}
}
public virtual void DepositInventory(IInventory receivingInventory)
{
foreach (var item in ItemInventory)
{
receivingInventory.AddItem(item, null);
RemoveItem(item, null);
}
}
public void InventoryAddItem_Test()
{
Item i = new Item(0, "Icecream", "mango", true);
var result = _inventory.AddItem(i);
Assert.IsNotNull(result);
Assert.AreEqual(result.Name, "Icecream");
}
// Transfer item from this inventory to another
public void TransferItem(ItemRecord item, int quantity, IInventory targetInventory)
{
RemoveItem(item, quantity);
// Play the item sound
item.PickupSound.PlaySound2D();
// Transfer the item with the container's owner data
targetInventory.AddItem(item, quantity);
}
//Adds this gameobject to inventory and disables this gameobject when player collides into it
void OnTriggerEnter2D(Collider2D col)
{
if (col.gameObject.tag == "Player")
{
//Create item object to add to inventory
Item tempItem = new Item(gameObject.name, typeOfItem.type);
inventory.AddItem(tempItem);
gameObject.SetActive(false);
}
}
public virtual void putItem(Item item, IInventory inventoryToAdd, int?amount = null)
{
Item itemToPut = TryGetItem(item);
if (itemToPut == null)
{
throw new InventoryException("Item to put not found in own inventory");
}
inventoryToAdd.AddItem(itemToPut, amount);
RemoveItem(itemToPut, amount);
}
private static void HandleUnequipItem(GameSession session, PacketReader packet)
{
long itemUid = packet.ReadLong();
Player player = session.Player;
IInventory inventory = player.Inventory;
// Unequip gear
(ItemSlot itemSlot, Item item) = inventory.Equips.FirstOrDefault(x => x.Value.Uid == itemUid);
if (item is not null)
{
if (!inventory.Equips.Remove(itemSlot, out Item unequipItem))
{
return;
}
unequipItem.Slot = -1;
unequipItem.IsEquipped = false;
inventory.AddItem(session, unequipItem, false);
session.FieldManager.BroadcastPacket(EquipmentPacket.UnequipItem(player.FieldPlayer, unequipItem));
player.FieldPlayer.ComputeStats();
return;
}
// Unequip cosmetics
(ItemSlot itemSlot2, Item item2) = inventory.Cosmetics.FirstOrDefault(x => x.Value.Uid == itemUid);
if (item2 is null)
{
return;
}
if (!inventory.Cosmetics.Remove(itemSlot2, out Item unequipItem2))
{
return;
}
unequipItem2.Slot = -1;
unequipItem2.IsEquipped = false;
inventory.AddItem(session, unequipItem2, false);
session.FieldManager.BroadcastPacket(EquipmentPacket.UnequipItem(player.FieldPlayer, unequipItem2));
}
public Player()
{
animationOn = new Animation("Resources/sprites/player.png", 64, 58);
SetAnimation(animationOn);
animationOn.Start();
SetPhysics(true);
moveLeft = new Move(this, -3, 0);
moveRight = new Move(this, 3, 0);
jump = new Jump(this, 3);
jumpLeft = new List <Command> {
};
jumpLeft.Add(jump);
jumpLeft.Add(moveLeft);
jumpRight = new List <Command> {
};
jumpRight.Add(jump);
jumpRight.Add(moveRight);
backpack = new Backpack(6);
backpack.AddItem(new HealingPotion());
backpack.AddItem(new HealingPotion());
backpack.AddItem(new ManaPotion());
backpack.AddItem(new ManaPotion());
backpack.AddItem(new SpeedPotion());
backpack.AddItem(new JumpPotion());
}
public void SetLocation(IInventory location)
{
if (location == null)
{
throw new ArgumentNullException("location");
}
if (location != _location)
{
_location?.RemoveItem(this);
_location = location;
_location.AddItem(this);
}
}
public void Interact(InteractionType type, Interactor actor)
{
Transform item = actor.GetItem();
IInventory prevMount = mount;
if (mount != null)
{
mount.RemoveItem(transform);
}
mount = null;
actor.AddItem(transform);
if (item != null && prevMount != null)
{
prevMount.AddItem(item);
}
}
protected override void ClassSpecificExecute()
{
if (actionType)
{
inventory.AddItem(itemData);
}
else
{
inventory.RemoveItem(itemData);
}
var data = new Dictionary <string, string>();
data["id"] = itemData.Id.ToString();
data["action"] = actionType ? "add" : "remove";
NetworkController.SendEvent(data);
}
public InventoryTransaction MoveInto(IInventory other)
{
if (other is null)
{
throw new ArgumentNullException(nameof(other), "Cannot move into a \"null\" inventory.");
}
if (storedItem == null)
{
return(InventoryTransaction.None);
}
var result = other.AddItem(storedItem);
if (result.Status == TransactionStatus.Complete)
{
storedItem = null;
}
return(result);
}
public void AddItemsToInventory(IInventory p_inventory)
{
Boolean flag = false;
NpcEffect npcEffect;
if (LegacyLogic.Instance.WorldManager.Party.HirelingHandler.HasEffect(ETargetCondition.HIRE_BONUSTRADEDISC, out npcEffect) && npcEffect.TargetEffect != ETargetCondition.NONE)
{
flag = true;
}
foreach (BaseItem baseItem in m_items)
{
if (flag)
{
baseItem.PriceMultiplicator = 1f - npcEffect.EffectValue;
}
else
{
baseItem.PriceMultiplicator = 1f;
}
p_inventory.AddItem(baseItem);
}
}
private void OnTriggerEnter2D(Collider2D other)
{
ICollectable col = other.GetComponent <ICollectable>();
if (col != null)
{
CollectableSO so = col.OnCollect();
if (so == null)
{
return;
}
if (mInventory.AddItem(so))
{
mAudioSource.Play();
Destroy(other.gameObject);
}
else
{
col.IsCollected = false;
}
}
}
public static bool GiveItemFromSelectBox(GameSession session, Item sourceItem, int index, out OpenBoxResult result)
{
result = OpenBoxResult.Success;
SelectItemBox box = sourceItem.Function.SelectItemBox;
ItemDropMetadata metadata = ItemDropMetadataStorage.GetItemDropMetadata(box.BoxId);
if (metadata == null)
{
result = OpenBoxResult.UnableToOpen;
return(false);
}
IInventory inventory = session.Player.Inventory;
// Select boxes disregards group ID. Adding these all to a filtered list
List <DropGroupContent> dropContentsList = new();
foreach (DropGroup group in metadata.DropGroups)
{
foreach (DropGroupContent dropGroupContent in group.Contents)
{
if (dropGroupContent.SmartDropRate == 100)
{
List <Job> recommendJobs = ItemMetadataStorage.GetRecommendJobs(dropGroupContent.ItemIds.First());
if (recommendJobs.Contains(session.Player.Job) || recommendJobs.Contains(Job.None))
{
dropContentsList.Add(dropGroupContent);
}
continue;
}
dropContentsList.Add(dropGroupContent);
}
}
DropGroupContent dropContents = dropContentsList[index];
int amount = Random.Shared.Next((int)dropContents.MinAmount, (int)dropContents.MaxAmount);
foreach (int id in dropContents.ItemIds)
{
if (inventory.CanHold(id, amount))
{
continue;
}
result = OpenBoxResult.InventoryFull;
return(false);
}
inventory.ConsumeItem(session, sourceItem.Uid, 1);
foreach (int id in dropContents.ItemIds)
{
Item newItem = new(id, amount, dropContents.Rarity)
{
EnchantLevel = dropContents.EnchantLevel
};
newItem.Stats = new(newItem);
if (inventory.CanHold(newItem))
{
inventory.AddItem(session, newItem, true);
continue;
}
result = OpenBoxResult.InventoryFull;
MailHelper.InventoryWasFull(newItem, session.Player.CharacterId);
}
return(true);
}
private void Start()
{
Instance = this;
Inventory = new JobCallInventory(this);
Inventory.AddItem(new DirtBlockItem(50));
}
private static void HandleUpgradeGem(GameSession session, PacketReader packet)
{
long equipUid = packet.ReadLong();
byte slot = packet.ReadByte();
long itemUid = packet.ReadLong();
ItemGemstoneUpgradeMetadata metadata;
IInventory inventory = session.Player.Inventory;
if (equipUid == 0) // this is a gemstone in the player's inventory
{
if (!inventory.HasItem(itemUid))
{
session.Send(ItemSocketSystemPacket.Notice((int)ItemSocketSystemNotice.ItemIsNotInYourInventory));
return;
}
Item gem = inventory.GetByUid(itemUid);
if (gem == null)
{
return;
}
metadata = ItemGemstoneUpgradeMetadataStorage.GetMetadata(gem.Id);
if (metadata == null || metadata.NextItemId == 0)
{
return;
}
if (!CheckGemUpgradeIngredients(inventory, metadata))
{
return;
}
for (int i = 0; i < metadata.IngredientItems.Count; i++)
{
if (!ConsumeIngredients(session, inventory, metadata.IngredientAmounts[i], metadata.IngredientItems[i]))
{
return;
}
}
inventory.ConsumeItem(session, gem.Uid, 1);
Item upgradeGem = new(metadata.NextItemId, rarity : gem.Rarity);
inventory.AddItem(session, upgradeGem, true);
session.Send(ItemSocketSystemPacket.UpgradeGem(equipUid, slot, upgradeGem));
return;
}
// upgrade gem mounted on a equipment
if (!inventory.HasItem(equipUid))
{
session.Send(ItemSocketSystemPacket.Notice((int)ItemSocketSystemNotice.ItemIsNotInYourInventory));
return;
}
Gemstone gemstone = inventory.GetByUid(equipUid).Stats.GemSockets[slot].Gemstone;
if (gemstone == null)
{
return;
}
metadata = ItemGemstoneUpgradeMetadataStorage.GetMetadata(gemstone.Id);
if (metadata == null || metadata.NextItemId == 0)
{
return;
}
if (!CheckGemUpgradeIngredients(inventory, metadata))
{
return;
}
for (int i = 0; i < metadata.IngredientItems.Count; i++)
{
if (!ConsumeIngredients(session, inventory, metadata.IngredientAmounts[i], metadata.IngredientItems[i]))
{
return;
}
}
Item newGem = new(metadata.NextItemId)
{
IsLocked = gemstone.IsLocked,
UnlockTime = gemstone.UnlockTime
};
Player owner = GameServer.PlayerManager.GetPlayerById(gemstone.OwnerId);
if (owner != null)
{
newGem.OwnerCharacterId = owner.CharacterId;
newGem.OwnerCharacterName = owner.Name;
}
Gemstone upgradedGemstone = new()
{
Id = metadata.NextItemId,
IsLocked = gemstone.IsLocked,
UnlockTime = gemstone.UnlockTime,
OwnerId = gemstone.OwnerId,
OwnerName = gemstone.OwnerName
};
inventory.GetByUid(equipUid).Stats.GemSockets[slot].Gemstone = gemstone;
session.Send(ItemSocketSystemPacket.UpgradeGem(equipUid, slot, newGem));
}
public bool AddItem(IGrabableItem item) => bodyPartImplementation.AddItem(item);
public virtual void AddToInventory(IInventory inventory, int quantity = 1)
{
inventory.AddItem(this, quantity);
}
public int Create([FromBody] InventoryItem item)
{
return(objitem.AddItem(item));
}
public void Add(GameObject item)
{
inventory.AddItem(item);
Instantiate(slot, slotsContainer.transform, false);
UpdateSlots();
}
protected override void OnUseFinish()
{
if (ProgressCanceled)
{
LastCallback.SafeInvoke();
return;
}
if (LastUseImmune)
{
//don't do anything if skill immunity was used
return;
}
bool removedItem = false;
bool attachScript = false;
IWIBase finalItem = null;
string scriptToAttach = string.Empty;
if (State.HasBeenMastered && !string.IsNullOrEmpty(Extensions.AttachScriptOnUseUnmastered))
{
scriptToAttach = Extensions.AttachScriptOnUseMastered;
}
else if (!string.IsNullOrEmpty(Extensions.AttachScriptOnUseUnmastered))
{
scriptToAttach = Extensions.AttachScriptOnUseUnmastered;
}
//if we only target certain scripts for failure and this one doesn't have at least one of those scripts, treat it as a win
if (Extensions.FailureTargetScripts.Count > 0)
{
if (MoveItemToInventory)
{
if (!LastItemToMove.HasAtLeastOne(Extensions.FailureTargetScripts))
{
LastSkillResult = true;
}
}
else
{
if (!LastFromStack.TopItem.HasAtLeastOne(Extensions.FailureTargetScripts))
{
LastSkillResult = true;
}
}
}
try {
WIStackError error = WIStackError.None;
if (LastSkillResult)
{
attachScript = Extensions.AttachScriptOnSuccess;
//we either add it based on inventory or else stacks
if (MoveItemToInventory)
{
Debug.Log("Adding to inventory, we were successful");
//convert it to a stack item BEFORE pushing it so we know we'll have the actual copy
finalItem = LastItemToMove.GetStackItem(WIMode.Unloaded);
StartCoroutine(LastInventory.AddItem(finalItem));
removedItem = true;
}
else
{
finalItem = LastFromStack.TopItem;
removedItem = (Stacks.Pop.AndPush(LastFromStack, LastToStack, ref error));
}
if (State.HasBeenMastered)
{
GUIManager.PostSuccess(Extensions.GUIMessageOnSuccessMastered);
}
else
{
GUIManager.PostSuccess(Extensions.GUIMessageOnSuccessUnmastered);
}
}
else
{
attachScript = Extensions.AttachScriptOnFail;
if (MoveItemToInventory)
{
//we're moving things into our inventory
if (Extensions.DestroyItemOnFail)
{
//Debug.Log("Destroying item on failure");
LastItemToMove.RemoveFromGame();
removedItem = true;
//don't attach a script because there's nothing to attach it to
}
else if (Extensions.SubstituteItemOnFail)
{
//Debug.Log("Adding substitution instead");
LastItemToMove.RemoveFromGame();
finalItem = Extensions.Substitution.ToStackItem();
StartCoroutine(LastInventory.AddItem(finalItem));
removedItem = true;
}
else if (Extensions.MoveItemOnFail)
{
Debug.Log("Failed, but still moving item - item null? " + (LastItemToMove == null).ToString());
finalItem = LastItemToMove.GetStackItem(WIMode.Unloaded);
StartCoroutine(LastInventory.AddItem(finalItem));
removedItem = true;
}
}
else
{
//we're moving things from stack to stack
if (Extensions.DestroyItemOnFail)
{
//just get rid of it
Stacks.Pop.AndToss(LastFromStack);
removedItem = true;
}
else if (Extensions.SubstituteItemOnFail)
{
//just get rid of it
Stacks.Pop.AndToss(LastFromStack);
removedItem = true;
//then put substitute item in other stack
//only attach a script if we actually push the item
finalItem = Extensions.Substitution.ToStackItem();
removedItem = Stacks.Push.Item(LastToStack, finalItem, ref error);
}
else if (Extensions.MoveItemOnFail)
{
finalItem = LastFromStack.TopItem;
removedItem = Stacks.Pop.AndPush(LastFromStack, LastToStack, ref error);
}
}
if (finalItem == null)
{
Debug.Log("Final item was null in remove item skill, not applying extensions");
}
else
{
if (Extensions.UnskilledRepPenaltyOnFail > 0 || Extensions.SkilledRepPenaltyOnFail > 0)
{
//only do this if we CAN suffer a rep loss
int globalRepLoss = 0;
int ownerRepLoss = 0;
if (State.HasBeenMastered)
{
globalRepLoss = Mathf.Max(1, Mathf.FloorToInt(
(finalItem.BaseCurrencyValue * Globals.BaseCurrencyToReputationMultiplier) *
Mathf.Lerp(Extensions.UnskilledRepPenaltyOnFail, Extensions.SkilledRepPenaltyOnFail, State.NormalizedMasteryLevel) *
Extensions.MasterRepPenaltyOnFail));
ownerRepLoss = Mathf.Max(1, Mathf.FloorToInt(
(finalItem.BaseCurrencyValue * Globals.BaseCurrencyToReputationMultiplier) *
Mathf.Lerp(Extensions.UnskilledOwnerRepPenaltyOnFail, Extensions.SkilledOwnerRepPenaltyOnFail, State.NormalizedMasteryLevel) *
Extensions.MasterOwnerRepPenaltyOnFail));
GUIManager.PostDanger(Extensions.GUIMessageOnFailureMastered);
}
else
{
globalRepLoss = Mathf.Max(1, Mathf.FloorToInt(
(finalItem.BaseCurrencyValue * Globals.BaseCurrencyToReputationMultiplier) *
Mathf.Lerp(Extensions.UnskilledRepPenaltyOnFail, Extensions.SkilledRepPenaltyOnFail, State.NormalizedMasteryLevel)));
ownerRepLoss = Mathf.Max(1, Mathf.FloorToInt(
(finalItem.BaseCurrencyValue * Globals.BaseCurrencyToReputationMultiplier) *
Mathf.Lerp(Extensions.UnskilledOwnerRepPenaltyOnFail, Extensions.SkilledOwnerRepPenaltyOnFail, State.NormalizedMasteryLevel)));
GUIManager.PostDanger(Extensions.GUIMessageOnFailureUnmastered);
}
Profile.Get.CurrentGame.Character.Rep.LoseGlobalReputation(globalRepLoss);
//see if we've just stolen from a character
Character character = null;
if (LastSkillTarget != null && LastSkillTarget.IOIType == ItemOfInterestType.WorldItem && LastSkillTarget.worlditem.Is <Character>(out character))
{
Profile.Get.CurrentGame.Character.Rep.LosePersonalReputation(character.worlditem.FileName, character.worlditem.DisplayName, ownerRepLoss);
}
}
}
}
} catch (Exception e) {
Debug.LogWarning("Couldn't move item because: " + e.ToString());
}
if (attachScript && finalItem != null && !string.IsNullOrEmpty(scriptToAttach))
{
//Debug.Log("Attaching script " + scriptToAttach + " to final item");
finalItem.Add(scriptToAttach);
}
if (removedItem)
{
if (LastSkillResult)
{
MasterAudio.PlaySound(Extensions.SoundTypeOnSuccess, Extensions.SoundOnSuccess);
}
else
{
MasterAudio.PlaySound(Extensions.SoundTypeOnFailure, Extensions.SoundOnFailure);
}
}
LastCallback.SafeInvoke();
}
public static bool GiveItemFromOpenBox(GameSession session, Item item, out OpenBoxResult boxResult)
{
boxResult = OpenBoxResult.Success;
OpenItemBox box = item.Function.OpenItemBox;
ItemDropMetadata metadata = ItemDropMetadataStorage.GetItemDropMetadata(box.BoxId);
if (metadata == null)
{
session.Send(NoticePacket.Notice("No items found", NoticeType.Chat));
boxResult = OpenBoxResult.UnableToOpen;
return(false);
}
if (box.AmountRequired > item.Amount)
{
boxResult = OpenBoxResult.UnableToOpen;
return(false);
}
IInventory inventory = session.Player.Inventory;
List <Item> rewards = new();
// Receive one item from each drop group
if (box.ReceiveOneItem)
{
foreach (DropGroup group in metadata.DropGroups)
{
bool receivedItem = false;
// Randomize the contents
IOrderedEnumerable <DropGroupContent> dropContent = group.Contents.OrderBy(_ => Random.Shared.Next());
foreach (DropGroupContent content in dropContent)
{
// If player has already received an item from this group, skip other contents
if (box.ReceiveOneItem && receivedItem)
{
continue;
}
List <Item> items = GetItemsFromDropGroup(content, session.Player, item);
foreach (Item newItem in items)
{
receivedItem = true;
rewards.Add(newItem);
}
}
}
}
else
{
// receive all items from each drop group
foreach (DropGroup group in metadata.DropGroups)
{
foreach (DropGroupContent dropContent in group.Contents)
{
List <Item> items = GetItemsFromDropGroup(dropContent, session.Player, item);
rewards.AddRange(items);
}
}
}
// Check if any inventory of the rewards is full
if (rewards.Any(reward => inventory.GetFreeSlots(reward.InventoryTab) <= 0))
{
boxResult = OpenBoxResult.InventoryFull;
return(false);
}
// Remove the box and required items
if (box.RequiredItemId > 0)
{
Item requiredItem = inventory.GetByUid(box.RequiredItemId);
if (requiredItem is null)
{
boxResult = OpenBoxResult.UnableToOpen;
return(false);
}
inventory.ConsumeItem(session, requiredItem.Uid, 1);
}
inventory.ConsumeItem(session, item.Uid, box.AmountRequired);
// give the rewards
foreach (Item reward in rewards)
{
reward.Uid = DatabaseManager.Items.Insert(reward);
if (inventory.CanHold(reward))
{
inventory.AddItem(session, reward, true);
continue;
}
boxResult = OpenBoxResult.InventoryFull;
MailHelper.InventoryWasFull(reward, session.Player.CharacterId);
}
return(true);
}
private static void HandleEquipItem(GameSession session, PacketReader packet)
{
long itemUid = packet.ReadLong();
string equipSlotStr = packet.ReadUnicodeString();
if (!Enum.TryParse(equipSlotStr, out ItemSlot equipSlot))
{
Logger.Warning("Unknown equip slot: {equipSlotStr}", equipSlotStr);
return;
}
Player player = session.Player;
IInventory inventory = player.Inventory;
Item item = inventory.GetByUid(itemUid);
if (item is null || !item.CanEquip(session))
{
return;
}
// Get correct equipped inventory
Dictionary <ItemSlot, Item> equippedInventory = player.GetEquippedInventory(item.InventoryTab);
if (equippedInventory == null)
{
Logger.Warning("equippedInventory was null: {inventoryTab}", item.InventoryTab);
return;
}
if (item.TransferType == TransferType.BindOnEquip & !item.IsBound())
{
item.BindItem(session.Player);
}
// Remove the item from the users inventory
inventory.RemoveItem(session, itemUid, out _);
// Move previously equipped item back to inventory
if (equippedInventory.Remove(equipSlot, out Item prevItem))
{
prevItem.Slot = item.Slot;
prevItem.IsEquipped = false;
inventory.AddItem(session, prevItem, false);
session.FieldManager.BroadcastPacket(EquipmentPacket.UnequipItem(player.FieldPlayer, prevItem));
if (prevItem.InventoryTab == InventoryTab.Gear)
{
player.FieldPlayer.ComputeStats();
}
}
// Handle unequipping pants when equipping dresses
// Handle unequipping off-hand when equipping two-handed weapons
if (item.IsDress || item.IsTwoHand)
{
if (equippedInventory.Remove(item.IsDress ? ItemSlot.PA : ItemSlot.LH, out Item prevItem2))
{
prevItem2.Slot = -1;
if (prevItem == null)
{
prevItem2.Slot = item.Slot;
}
prevItem2.IsEquipped = false;
inventory.AddItem(session, prevItem2, false);
session.FieldManager.BroadcastPacket(EquipmentPacket.UnequipItem(player.FieldPlayer, prevItem2));
}
}
// Handle unequipping dresses when equipping pants
// Handle unequipping two-handed main-hands when equipping off-hand weapons
if (item.ItemSlot is ItemSlot.PA or ItemSlot.LH)
{
ItemSlot prevItemSlot = item.ItemSlot == ItemSlot.PA ? ItemSlot.CL : ItemSlot.RH;
if (equippedInventory.ContainsKey(prevItemSlot))
{
if (equippedInventory[prevItemSlot] != null && equippedInventory[prevItemSlot].IsDress)
{
if (equippedInventory.Remove(prevItemSlot, out Item prevItem2))
{
prevItem2.Slot = item.Slot;
prevItem2.IsEquipped = false;
inventory.AddItem(session, prevItem2, false);
session.FieldManager.BroadcastPacket(EquipmentPacket.UnequipItem(player.FieldPlayer, prevItem2));
}
}
}
}
// Equip new item
item.IsEquipped = true;
item.ItemSlot = equipSlot;
equippedInventory[equipSlot] = item;
session.FieldManager.BroadcastPacket(EquipmentPacket.EquipItem(player.FieldPlayer, item, equipSlot));
// Add stats if gear
if (item.InventoryTab == InventoryTab.Gear)
{
player.FieldPlayer.ComputeStats();
}
}
