Esempio n. 1
0
	public ParseEquippedItem(EquipedItem item)
	{
		Debug.Log(item.UniqueItemId);
		uniqueItemId = item.UniqueItemId;
		level = item.Level;
		slotIndex = (int)item.equipSlot;
	}
Esempio n. 2
0
    public void Remove()
    {
        inventory[(int)equipedItemNumber] = null;                       // clear inventory inner slot
        UI_Inventory.instance.ChangeSlot(null, (int)equipedItemNumber); // delete icon
        UI_Inventory.instance.defineSlot((int)equipedItemNumber);       // change selection
        playerController.UnequipItem((int)equipedItemNumber);           // drop

        equipedItemNumber = EquipedItem.none;
    }
Esempio n. 3
0
 //public List<EquipedItem> Items;
 //[XmlIgnore]
 //public RPGWeapon Weapon;
 public Equipment()
 {
     //Items = new List<EquipedItem>();
     EquippedHead = new EquipedItem();
     EquippedBody = new EquipedItem();
     EquippedArmL = new EquipedItem();
     EquippedArmR = new EquipedItem();
     EquippedLegs = new EquipedItem();
      //Weapon = new RPGWeapon();
 }
Esempio n. 4
0
    public bool UnequipItem(EquipedItem item)
    {
        foreach(InventoryItem i in Items)
        {
            if(i.UniqueItemId == item.UniqueItemId)
                i.IsItemEquipped = false;
        }

        return true;
    }
Esempio n. 5
0
    //public List<EquipedItem> Items;

    //[XmlIgnore]
    //public RPGWeapon Weapon;

    public Equipment()
    {
        //Items = new List<EquipedItem>();
        EquippedHead = new EquipedItem();
        EquippedBody = new EquipedItem();
        EquippedArmL = new EquipedItem();
        EquippedArmR = new EquipedItem();
        EquippedLegs = new EquipedItem();
        //Weapon = new RPGWeapon();
    }
Esempio n. 6
0
 private bool RemoveItem(EquipedItem equipmentSlot)
 {
     // TODO: check weight + item count
     //Act(ActOptions.ToCharacter, "You stop using {0}.", equipmentSlot.Item);
     //Act(ActOptions.ToRoom, "{0} stops using {1}.", this, equipmentSlot.Item);
     Act(ActOptions.ToAll, "{0:N} stop{0:v} using {1}.", this, equipmentSlot.Item);
     equipmentSlot.Item.ChangeContainer(this); // add in inventory
     equipmentSlot.Item.ChangeEquipedBy(null); // clear equiped by
     equipmentSlot.Item = null;                // unequip
     return(true);
 }
Esempio n. 7
0
    public bool UnequipItem(EquipedItem item)
    {
        foreach (InventoryItem i in Items)
        {
            if (i.UniqueItemId == item.UniqueItemId)
            {
                i.IsItemEquipped = false;
            }
        }

        return(true);
    }
Esempio n. 8
0
    public void AddToInventory(Item itemToAdd, int slotIndex)
    {
        // inventory[slotIndex] = item;
        inventory.SetValue(itemToAdd, slotIndex);
        UI_Inventory.instance.ChangeSlot(itemToAdd.Sprite, slotIndex);

        equipedItemNumber = (EquipedItem)slotIndex;
        Debug.Log(equipedItemNumber);
        Debug.Log((int)equipedItemNumber);

        // equipedItem = itemToAdd;
        UI_Inventory.instance.defineSlot(slotIndex);
    }
Esempio n. 9
0
 public void EquipNew()
 {
     for (int i = 0; i < inventory.Length; i--)
     {
         if (inventory[i - 1] != null)
         {
             Debug.Log("Try to equip: success");
             equipedItemNumber = (EquipedItem)i;
             UI_Inventory.instance.defineSlot(i);
             return;
         }
     }
     Debug.Log(equipedItemNumber);
     throw new System.Exception("inventory doesn't contain any item");
 }
Esempio n. 10
0
 private void ListenSwitchSlot()
 {
     if (Input.GetKeyDown(KeyCode.Alpha1))
     {
         if (inventory[(int)EquipedItem.first] != null)
         {
             equipedItemNumber = EquipedItem.first;
             playerController.ChangeItem((int)equipedItemNumber);
             UI_Inventory.instance.defineSlot((int)equipedItemNumber);
         }
     }
     else if (Input.GetKeyDown(KeyCode.Alpha2))
     {
         if (inventory[(int)EquipedItem.second] != null)
         {
             equipedItemNumber = EquipedItem.second;
             playerController.ChangeItem((int)equipedItemNumber);
             UI_Inventory.instance.defineSlot((int)equipedItemNumber);
         }
     }
     else if (Input.GetKeyDown(KeyCode.Alpha3))
     {
         if (inventory[(int)EquipedItem.third] != null)
         {
             equipedItemNumber = EquipedItem.third;
             playerController.ChangeItem((int)equipedItemNumber);
             UI_Inventory.instance.defineSlot((int)equipedItemNumber);
         }
     }
     else if (Input.GetKeyDown(KeyCode.Alpha4))
     {
         if (inventory[(int)EquipedItem.fourth] != null)
         {
             equipedItemNumber = EquipedItem.fourth;
             playerController.ChangeItem((int)equipedItemNumber);
             UI_Inventory.instance.defineSlot((int)equipedItemNumber);
         }
     }
     else if (Input.GetKeyDown(KeyCode.Alpha5))
     {
         if (inventory[(int)EquipedItem.fifth] != null)
         {
             equipedItemNumber = EquipedItem.fifth;
             playerController.ChangeItem((int)equipedItemNumber);
             UI_Inventory.instance.defineSlot((int)equipedItemNumber);
         }
     }
 }
Esempio n. 11
0
    public void RemoveAndEquip()
    {
        Remove();

        if (!InvenotryIsEmpty())
        {
            this.EquipNew();                                   // change item it inventory, get new equipedItemNumber
            playerController.EquipNew((int)equipedItemNumber); // change item in hand
        }
        else
        {
            equipedItemNumber = EquipedItem.none;
        }

        Debug.Log((int)equipedItemNumber);
    }
Esempio n. 12
0
        private bool WearItem(IEquipable item, bool replace) // equivalent to wear_obj in act_obj.C:1467
        {
            // TODO: check level
            WearLocations wearLocation = item.WearLocation;

            if (wearLocation == WearLocations.None)
            {
                Log.Default.WriteLine(LogLevels.Warning, "Item {0} cannot be equiped", item.DebugName);
                if (replace) // replace means, only item is trying to be worn
                {
                    Act(ActOptions.ToCharacter, "{0} cannot be worn.", item);
                }
                return(false);
            }
            EquipedItem equipmentSlot = SearchEquipmentSlot(item, replace);

            if (equipmentSlot == null)
            {
                if (replace) // we dont' want to spam if character is trying to wear all, replace is set to true only when wearing one item
                {
                    Act(ActOptions.ToCharacter, "You cannot wear {0}.", item);
                }
                return(false);
            }
            if (replace && equipmentSlot.Item != null)
            {
                IEquipable removeItem = equipmentSlot.Item;
                //Act(ActOptions.ToCharacter, "You remove {0}.", removeItem);
                //Act(ActOptions.ToRoom, "{0} removes {1}.", this, removeItem);
                Act(ActOptions.ToAll, "{0:N} remove{0:v} {1}.", this, removeItem);
                //equipmentSlot.Item = null  already done by ChangeEquipedBy
                removeItem.ChangeEquipedBy(null);
                removeItem.ChangeContainer(this);
            }
            // TODO: different phrase depending on wear location
            //Act(ActOptions.ToCharacter, "You wear {0}.", item);
            //Act(ActOptions.ToRoom, "{0} wears {1}.", this, item);
            Act(ActOptions.ToAll, "{0:N} wear{0:v} {1}.", this, item);
            equipmentSlot.Item = item;  // equip
            item.ChangeContainer(null); // remove from inventory
            item.ChangeEquipedBy(this); // set as equiped by this
            return(true);
        }
Esempio n. 13
0
 // Remove item
 protected virtual bool DoRemove(string rawParameters, params CommandParameter[] parameters)
 {
     if (parameters.Length == 0)
     {
         Send("Remove what?");
     }
     else
     {
         EquipedItem equipmentSlot = FindHelpers.FindByName(Equipments.Where(x => x.Item != null && CanSee(x.Item)), x => x.Item, parameters[0]);
         if (equipmentSlot?.Item == null)
         {
             Send(StringHelpers.ItemInventoryNotFound);
         }
         else
         {
             RemoveItem(equipmentSlot);
         }
     }
     return(true);
 }
Esempio n. 14
0
	public void UnequipItem(EquipedItem item)
	{
		PlayerManager.Instance.Hero.UnequipItem(item.UniqueItemId, item.Level);
		if(item.rpgArmor.armorStatsSets.Count >0)
		{
			PlayerManager.Instance.Hero.profile.RemoveArmorStats(item.rpgArmor.armorStatsSets[Mathf.Min(item.rpgArmor.armorStatsSets.Count, item.Level)-1]);
		}
	}
Esempio n. 15
0
    /*private List<EquipedItem> GetUnequipingItems(RPGEquipmentSlot slot)
     * {
     *  List<RPGEquipmentSlot> slotsID = new List<RPGEquipmentSlot>();
     *  slotsID.Add(slot);
     *  return GetUnequipingItems(slotsID);
     * }*/

    /*private EquipedItem GetUnequipingItems(EquipmentSlots slot)
     * {
     *  EquipedItem item = new EquipedItem();
     *
     *  foreach(EquipedItem equiped in Items)
     *      {
     *          foreach(RPGEquipmentSlot es in equiped.Slots)
     *          {
     *              if (es.UniqueId == newEquipmentID.UniqueId)
     *                  items.Add(equiped);
     *          }
     *      }
     *  }
     * }*/

    // Unequip one item

    /*public bool UnEquipItem(RPGEquipmentSlot equipmentSlot, Player player)
     * {
     *  List<EquipedItem> dropingItems = GetUnequipingItems(equipmentSlot);
     *  PlayerEquip.itemsToUnequip = dropingItems;
     *  //only if items doest not remain in inventory
     *     if (!player.Hero.Settings.EquipedItemInInventory)
     *  {
     *      foreach(EquipedItem e in dropingItems)
     *      {
     *             player.Hero.Inventory.AddItem(e.rpgItem, player);
     *      }
     *  }
     *  RemoveItem(dropingItems);
     *
     *  return true;
     * }*/

    // Remove item from all collections

    /*private void RemoveItem(EquipedItem dropingItem)
     * {
     * foreach(EquipedItem e in Items)
     *          {
     *              if (e == eq)
     *              {
     *                  Items.Remove(e);
     *                  break;
     *              }
     *          }
     *      }
     * }
     * }*/

    /*private void SetWeapon(RPGWeapon weapon)
     * {
     *  if (weapon.IsAmmo)
     *      return;
     *  Weapon = weapon;
     *  NeedAmmo = weapon.NeedAmmo;
     * }*/

    public bool EquipItem(InventoryItem item)
    {
        EquipedItem equiped = new EquipedItem();

        //equiped.CurrentAmount = item.CurrentAmount;
        //equiped.CurrentDurability = item.CurrentDurability;
        equiped.UniqueItemId = item.UniqueItemId;
        equiped.rpgItem      = item.rpgItem;
        //equiped.rpgItem.LoadIcon();
        //get equipment slots
        RPGArmor e = (RPGArmor)equiped.rpgItem;

        equiped.Slot = e.EquipmentSlotIndex;

        if (!e.CanYouEquip())
        {
            //TODO display error message
            return(false);
        }
        //if equipment slot is used

        /*if (IsEquipmentSlotUsed(equiped.Slot))
         * {
         *  List<EquipedItem> dropingItems = GetUnequipingItems(equiped.Slot);
         *  //only if items does not remain in inventory
         *     if (!player.Hero.Settings.EquipedItemInInventory)
         *  {
         *      foreach(EquipedItem equip in dropingItems)
         *      {
         *             player.Hero.Inventory.AddItem(equip.rpgItem, player);
         *      }
         *  }
         *  //remove dropping items from equip
         *  RemoveItem(dropingItems);
         *  PlayerEquip.itemsToUnequip = dropingItems;
         * }*/
        //if(IsEquipmentSlotUsed(equiped.Slot))


        switch (equiped.Slot)
        {
        case EquipmentSlots.Head:
            if (IsEquipmentSlotUsed(EquipmentSlots.Head))
            {
                Player.Instance.Hero.HeadInventory.UnequipItem(EquippedHead);
            }
            EquippedHead = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.Head);
            break;

        case EquipmentSlots.Body:
            if (IsEquipmentSlotUsed(EquipmentSlots.Body))
            {
                Player.Instance.Hero.BodyInventory.UnequipItem(EquippedBody);
            }
            EquippedBody = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.Body);
            break;

        case EquipmentSlots.ArmL:
            if (IsEquipmentSlotUsed(EquipmentSlots.ArmL))
            {
                Player.Instance.Hero.ArmLInventory.UnequipItem(EquippedArmL);
            }
            EquippedArmL = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.ArmL);
            break;

        case EquipmentSlots.ArmR:
            if (IsEquipmentSlotUsed(EquipmentSlots.ArmR))
            {
                Player.Instance.Hero.ArmRInventory.UnequipItem(EquippedArmR);
            }
            EquippedArmR = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.ArmR);
            break;

        case EquipmentSlots.Legs:
            if (IsEquipmentSlotUsed(EquipmentSlots.Legs))
            {
                Player.Instance.Hero.LegsInventory.UnequipItem(EquippedLegs);
            }
            EquippedLegs = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.Legs);
            break;
        }

        //Items.Add(equiped);
        return(true);
    }
Esempio n. 16
0
    /*private List<EquipedItem> GetUnequipingItems(RPGEquipmentSlot slot)
     {
     List<RPGEquipmentSlot> slotsID = new List<RPGEquipmentSlot>();
     slotsID.Add(slot);
     return GetUnequipingItems(slotsID);
     }*/
    /*private EquipedItem GetUnequipingItems(EquipmentSlots slot)
     {
     EquipedItem item = new EquipedItem();

     foreach(EquipedItem equiped in Items)
         {
             foreach(RPGEquipmentSlot es in equiped.Slots)
             {
                 if (es.UniqueId == newEquipmentID.UniqueId)
                     items.Add(equiped);
             }
         }
     }
     }*/
    // Unequip one item
    /*public bool UnEquipItem(RPGEquipmentSlot equipmentSlot, Player player)
     {
     List<EquipedItem> dropingItems = GetUnequipingItems(equipmentSlot);
     PlayerEquip.itemsToUnequip = dropingItems;
     //only if items doest not remain in inventory
        if (!player.Hero.Settings.EquipedItemInInventory)
     {
         foreach(EquipedItem e in dropingItems)
         {
                player.Hero.Inventory.AddItem(e.rpgItem, player);
         }
     }
     RemoveItem(dropingItems);

     return true;
     }*/
    // Remove item from all collections
    /*private void RemoveItem(EquipedItem dropingItem)
     {
    foreach(EquipedItem e in Items)
             {
                 if (e == eq)
                 {
                     Items.Remove(e);
                     break;
                 }
             }
         }
    }
     }*/
    /*private void SetWeapon(RPGWeapon weapon)
     {
     if (weapon.IsAmmo)
         return;
     Weapon = weapon;
     NeedAmmo = weapon.NeedAmmo;
     }*/
    public bool EquipItem(InventoryItem item)
    {
        EquipedItem equiped = new EquipedItem() ;
         //equiped.CurrentAmount = item.CurrentAmount;
         //equiped.CurrentDurability = item.CurrentDurability;
         equiped.UniqueItemId = item.UniqueItemId;
         equiped.rpgItem = item.rpgItem;
         //equiped.rpgItem.LoadIcon();
         //get equipment slots
         RPGArmor e = (RPGArmor)equiped.rpgItem;
         equiped.Slot = e.EquipmentSlotIndex;

         if (!e.CanYouEquip())
         {
         //TODO display error message
         return false;
         }
         //if equipment slot is used
         /*if (IsEquipmentSlotUsed(equiped.Slot))
         {
         List<EquipedItem> dropingItems = GetUnequipingItems(equiped.Slot);
         //only if items does not remain in inventory
            if (!player.Hero.Settings.EquipedItemInInventory)
         {
             foreach(EquipedItem equip in dropingItems)
             {
                    player.Hero.Inventory.AddItem(equip.rpgItem, player);
             }
         }
         //remove dropping items from equip
         RemoveItem(dropingItems);
         PlayerEquip.itemsToUnequip = dropingItems;
         }*/
        //if(IsEquipmentSlotUsed(equiped.Slot))

        switch (equiped.Slot)
        {
        case EquipmentSlots.Head:
            if(IsEquipmentSlotUsed(EquipmentSlots.Head))
                Player.Instance.Hero.HeadInventory.UnequipItem(EquippedHead);
            EquippedHead = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.Head);
            break;
        case EquipmentSlots.Body:
            if(IsEquipmentSlotUsed(EquipmentSlots.Body))
                Player.Instance.Hero.BodyInventory.UnequipItem(EquippedBody);
            EquippedBody = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.Body);
            break;
        case EquipmentSlots.ArmL:
            if(IsEquipmentSlotUsed(EquipmentSlots.ArmL))
                Player.Instance.Hero.ArmLInventory.UnequipItem(EquippedArmL);
            EquippedArmL = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.ArmL);
            break;
        case EquipmentSlots.ArmR:
            if(IsEquipmentSlotUsed(EquipmentSlots.ArmR))
                Player.Instance.Hero.ArmRInventory.UnequipItem(EquippedArmR);
            EquippedArmR = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.ArmR);
            break;
        case EquipmentSlots.Legs:
            if(IsEquipmentSlotUsed(EquipmentSlots.Legs))
                Player.Instance.Hero.LegsInventory.UnequipItem(EquippedLegs);
            EquippedLegs = equiped;
            Player.Instance.avatar.EquipBodyPart(e.FBXName, EquipmentSlots.Legs);
            break;
        }

         //Items.Add(equiped);
         return true;
    }
Esempio n. 17
0
	//HACK
	public void UnequipHead()
	{
		if(EquippedHead != null)
		{
			UnequipItem(EquippedHead);
			EquippedHead = null;
			PlayerManager.Instance.avatarStatus.UpdatePortrait(EquippedFace.rpgArmor.headPortraitPath);
			PlayerManager.Instance.avatar.UnequipHead();
		}
	}
Esempio n. 18
0
 /*private List<EquipedItem> GetUnequipingItems(RPGEquipmentSlot slot)
 {
     List<RPGEquipmentSlot> slotsID = new List<RPGEquipmentSlot>();
     slotsID.Add(slot);
     return GetUnequipingItems(slotsID);
 }*/
 
 /*private EquipedItem GetUnequipingItems(EquipmentSlots slot)
 {
     EquipedItem item = new EquipedItem();
     
     foreach(EquipedItem equiped in Items)
         {
             foreach(RPGEquipmentSlot es in equiped.Slots)
             {
                 if (es.UniqueId == newEquipmentID.UniqueId)
                     items.Add(equiped);
             }
         }
     }
 }*/
 
 // Unequip one item
 /*public bool UnEquipItem(RPGEquipmentSlot equipmentSlot, Player player)
 {
     List<EquipedItem> dropingItems = GetUnequipingItems(equipmentSlot);
     PlayerEquip.itemsToUnequip = dropingItems;
     //only if items doest not remain in inventory
        if (!player.Hero.Settings.EquipedItemInInventory)
     {
         foreach(EquipedItem e in dropingItems)
         {
                player.Hero.Inventory.AddItem(e.rpgItem, player);
         }
     }
     RemoveItem(dropingItems);
     
     return true;
 }*/
 
 // Remove item from all collections
 /*private void RemoveItem(EquipedItem dropingItem)
 {
    foreach(EquipedItem e in Items)
             {
                 if (e == eq)
                 {
                     Items.Remove(e);
                     break;
                 }
             }
         }
    }
 }*/
 
 /*private void SetWeapon(RPGWeapon weapon)
 {
     if (weapon.IsAmmo)
         return;
     Weapon = weapon;
     NeedAmmo = weapon.NeedAmmo;
 }*/
 
 public bool EquipItem(RPGArmor armor, int level)
 {
     /*EquipedItem equiped = new EquipedItem() ;
     //equiped.CurrentAmount = item.CurrentAmount;
     //equiped.CurrentDurability = item.CurrentDurability;
     equiped.UniqueItemId = item.UniqueItemId;
     equiped.rpgItem = (RPGArmor)item.rpgItem;
     //equiped.rpgItem.LoadIcon();
     //get equipment slots
     RPGArmor e = (RPGArmor)equiped.rpgItem;
     equiped.Slot = e.EquipmentSlotIndex;
     */
     //if equipment slot is used
     /*if (IsEquipmentSlotUsed(equiped.Slot))
     {
         List<EquipedItem> dropingItems = GetUnequipingItems(equiped.Slot);
         //only if items does not remain in inventory
            if (!player.Hero.Settings.EquipedItemInInventory)
         {
             foreach(EquipedItem equip in dropingItems)
             {
                    player.Hero.Inventory.AddItem(equip.rpgItem, player);    
             }
         }
         //remove dropping items from equip
         RemoveItem(dropingItems);
         PlayerEquip.itemsToUnequip = dropingItems;
     }*/
    //if(IsEquipmentSlotUsed(equiped.Slot))

		EquipedItem e = new EquipedItem(armor.UniqueId, level, armor);
		if(armor.armorStatsSets.Count >0)
		{
			PlayerManager.Instance.Hero.profile.AddArmorStats(armor.armorStatsSets[Mathf.Min(armor.armorStatsSets.Count, e.Level)-1]);
		}
		//e.UniqueItemId = armor.UniqueId;
		//e.rpgArmor = armor;
		//e.Level = level;
	    switch (e.rpgArmor.EquipmentSlotIndex)
	    {
			case EquipmentSlots.Face:
				if(IsEquipmentSlotUsed(EquipmentSlots.Face))
				UnequipItem(EquippedFace);
					//PlayerManager.Instance.Hero.ArmoryInventory.UnequipItem(EquippedFace.UniqueItemId, EquippedFace.Level);
				EquippedFace = e;
				if(PlayerManager.Instance.avatar != null)
			{
					PlayerManager.Instance.avatar.EquipBodyPart(e.rpgArmor.FBXName[Mathf.Min(e.Level, e.rpgArmor.FBXName.Count) - 1], EquipmentSlots.Face);
				PlayerManager.Instance.avatarStatus.UpdatePortrait(EquippedFace.rpgArmor.headPortraitPath);
			}
				break;
	        case EquipmentSlots.Head:
	            if(IsEquipmentSlotUsed(EquipmentSlots.Head))
				UnequipItem(EquippedHead);
	                //PlayerManager.Instance.Hero.ArmoryInventory.UnequipItem(EquippedHead.UniqueItemId, EquippedHead.Level);
	            EquippedHead = e;
	            if(PlayerManager.Instance.avatar != null)
			{
	                PlayerManager.Instance.avatar.EquipBodyPart(e.rpgArmor.FBXName[Mathf.Min(e.Level, e.rpgArmor.FBXName.Count) - 1], EquipmentSlots.Head);
				PlayerManager.Instance.avatarStatus.UpdatePortrait(EquippedHead.rpgArmor.headPortraitPath);
			}
	            break;
	        case EquipmentSlots.Body:
	            if(IsEquipmentSlotUsed(EquipmentSlots.Body))
				UnequipItem(EquippedBody);
				//PlayerManager.Instance.Hero.ArmoryInventory.UnequipItem(EquippedBody.UniqueItemId, EquippedBody.Level);
	            EquippedBody = e;
	            if(PlayerManager.Instance.avatar != null)
				PlayerManager.Instance.avatar.EquipBodyPart(e.rpgArmor.FBXName[Mathf.Min(e.Level, e.rpgArmor.FBXName.Count) - 1], EquipmentSlots.Body);
	            break;
	        case EquipmentSlots.ArmL:
	            if(IsEquipmentSlotUsed(EquipmentSlots.ArmL))
				UnequipItem(EquippedArmL);
				//PlayerManager.Instance.Hero.ArmoryInventory.UnequipItem(EquippedArmL.UniqueItemId, EquippedArmL.Level);
	            EquippedArmL = e;
	            if(PlayerManager.Instance.avatar != null)
				PlayerManager.Instance.avatar.EquipBodyPart(e.rpgArmor.FBXName[Mathf.Min(e.Level, e.rpgArmor.FBXName.Count) - 1], EquipmentSlots.ArmL);
	            break;
	        case EquipmentSlots.ArmR:
	            if(IsEquipmentSlotUsed(EquipmentSlots.ArmR))
					UnequipItem(EquippedArmR);
					//PlayerManager.Instance.Hero.ArmoryInventory.UnequipItem(EquippedArmR.UniqueItemId, EquippedArmR.Level);
	            EquippedArmR = e;
	            if(PlayerManager.Instance.avatar != null)
				PlayerManager.Instance.avatar.EquipBodyPart(e.rpgArmor.FBXName[Mathf.Min(e.Level, e.rpgArmor.FBXName.Count) - 1], EquipmentSlots.ArmR);
	            break;
	        case EquipmentSlots.Legs:
	            if(IsEquipmentSlotUsed(EquipmentSlots.Legs))
				//PlayerManager.Instance.Hero.ArmoryInventory.UnequipItem(EquippedLegs.UniqueItemId, EquippedLegs.Level);
					UnequipItem(EquippedLegs);
	            EquippedLegs = e;
	            if(PlayerManager.Instance.avatar != null)
				PlayerManager.Instance.avatar.EquipBodyPart(e.rpgArmor.FBXName[Mathf.Min(e.Level, e.rpgArmor.FBXName.Count) - 1], EquipmentSlots.Legs);
	            break;
	    }

		//onEquipItem(e.UniqueItemId, e.Level, (int)e.rpgArmor.EquipmentSlotIndex);
		//PlayerManager.Instance.Hero.profile.UpdateEquippedItems(equippedItems);
     //Items.Add(equiped);
     return true;
 }
Esempio n. 19
0
        private static void ProcessOnOneTarget(ICharacter source, ICharacter victim, IAbility ability, bool cannotMiss, bool cannotBeDodgedParriedBlocked)
        {
            if (ability?.Effects == null || ability.Effects.Count == 0 || !source.IsValid || !victim.IsValid)
            {
                return;
            }
            // Miss/Dodge/Parray/Block check (only for harmful ability)
            CombatHelpers.AttackResults attackResult = CombatHelpers.AttackResults.Hit;
            if (ability.Behavior == AbilityBehaviors.Harmful)
            {
                // Starts fight if needed (if A attacks B, A fights B and B fights A)
                if (source != victim)
                {
                    if (source.Fighting == null)
                    {
                        source.StartFighting(victim);
                    }
                    if (victim.Fighting == null)
                    {
                        victim.StartFighting(source);
                    }
                    // TODO: Cannot attack slave without breaking slavery
                }
                if (ability.Kind == AbilityKinds.Skill)
                {
                    // TODO: refactor same code in Character.OneHit
                    // Miss, dodge, parry, ...
                    attackResult = CombatHelpers.YellowMeleeAttack(source, victim, cannotMiss, cannotBeDodgedParriedBlocked);
                    Log.Default.WriteLine(LogLevels.Debug, $"{source.DebugName} -> {victim.DebugName} : attack result = {attackResult}");
                    switch (attackResult)
                    {
                    case CombatHelpers.AttackResults.Miss:
                        victim.Act(ActOptions.ToCharacter, "{0} misses you.", source);
                        source.Act(ActOptions.ToCharacter, "You miss {0}.", victim);
                        return;     // no effect applied

                    case CombatHelpers.AttackResults.Dodge:
                        victim.Act(ActOptions.ToCharacter, "You dodge {0}'s {1}.", source, ability.Name);
                        source.Act(ActOptions.ToCharacter, "{0} dodges your {1}.", victim, ability.Name);
                        return;     // no effect applied

                    case CombatHelpers.AttackResults.Parry:
                        victim.Act(ActOptions.ToCharacter, "You parry {0}'s {1}.", source, ability.Name);
                        source.Act(ActOptions.ToCharacter, "{0} parries your {1}.", victim, ability.Name);
                        return;     // no effect applied

                    case CombatHelpers.AttackResults.Block:
                        EquipedItem victimShield = victim.Equipments.FirstOrDefault(x => x.Item != null && x.Slot == EquipmentSlots.Shield);
                        if (victimShield != null)     // will never be null because MeleeAttack will not return Block if no shield
                        {
                            victim.Act(ActOptions.ToCharacter, "You block {0}'s {1} with {2}.", source, ability.Name, victimShield.Item);
                            source.Act(ActOptions.ToCharacter, "{0} blocks your {1} with {2}.", victim, ability.Name, victimShield.Item);
                        }
                        // effect applied
                        break;

                    case CombatHelpers.AttackResults.Critical:
                    case CombatHelpers.AttackResults.CrushingBlow:
                    case CombatHelpers.AttackResults.Hit:
                        // effect applied
                        break;

                    default:
                        Log.Default.WriteLine(LogLevels.Error, $"Ability {ability.Name}[{ability.Kind}] returned an invalid attack result: {attackResult}");
                        break;
                    }
                }
                else if (ability.Kind == AbilityKinds.Spell && ability.Behavior == AbilityBehaviors.Harmful)
                {
                    // Miss/Hit/Critical
                    attackResult = CombatHelpers.SpellAttack(source, victim, cannotMiss);
                    switch (attackResult)
                    {
                    case CombatHelpers.AttackResults.Miss:
                        victim.Act(ActOptions.ToCharacter, "{0} misses you.", source);
                        source.Act(ActOptions.ToCharacter, "You miss {0}.", victim);
                        return;     // no effect applied

                    case CombatHelpers.AttackResults.Hit:
                    case CombatHelpers.AttackResults.Critical:
                        // effect applied
                        break;

                    default:
                        Log.Default.WriteLine(LogLevels.Error, $"Ability {ability.Name}[{ability.Kind}] returned an invalid attack result: {attackResult}");
                        break;
                    }
                }
                else
                {
                    Log.Default.WriteLine(LogLevels.Error, $"Ability {ability.Name} has an invalid kind: {ability.Kind}");
                }
            }
            // Apply effects
            foreach (AbilityEffect effect in ability.Effects)
            {
                effect.Process(source, victim, ability, attackResult);
            }
        }