public void AddArmor(string id)
 {
     Armor x = new Armor();
     x.ID = id;
     x.Description = "An Armor Set";
     Armors.Add(x);
 }

 public Armor(Armor armor)
     : base(armor)
 {
     this.armorValue = armor.ArmorValue;
     this.exterieur = armor.exterieur;
     this.interieur = armor.interieur;
 }

        public void ArmorEqualsAndHashCode()
        {
            Armor armor = new Armor(ArmorType.Unarmored, 5);

            //Using IsTrue/IsFalse to cover all paths (aren't covered, when using Equals)
            //Equal tests
            Assert.IsTrue(armor.Equals(armor));
            Assert.AreEqual(armor.GetHashCode(), armor.GetHashCode());

            object equal = new Armor(ArmorType.Unarmored, 5);
            Assert.IsTrue(armor.Equals(equal));
            Assert.AreEqual(equal.GetHashCode(), armor.GetHashCode());

            //Not equal tests
            Assert.IsFalse(armor.Equals(null));

            object notEqual = new object();
            Assert.IsFalse(armor.Equals(notEqual));
            Assert.AreNotEqual(notEqual.GetHashCode(), armor.GetHashCode());

            notEqual = new Armor(ArmorType.Medium, 5);
            Assert.IsFalse(armor.Equals(notEqual));
            Assert.AreNotEqual(notEqual.GetHashCode(), armor.GetHashCode());

            notEqual = new Armor(ArmorType.Unarmored, 3);
            Assert.IsFalse(armor.Equals(notEqual));
            Assert.AreNotEqual(notEqual.GetHashCode(), armor.GetHashCode());
        }

 void changeArmor(Armor armor)
 {
     if(armorSwitcher != null){
         armorSwitcher.changeAnimationLayer(armor.armorAnimationLayerName);
         armorSwitcher.switchArm(armor.armSprite);
     }
 }

    private static Armor CreateHat()
    {
        Armor armor = new Armor();

        string[] hatNames = new string[] {
            "Small Hat",
            "Mid Hat",
            "Large Hat"
                                            };

        //fill in all of the values for that item type
        armor.Name = hatNames[Random.Range(0, hatNames.Length)];

        //assign properties for the item
        armor.ArmorLevel = Random.Range(10, 50);

        //assign the icon for the weapon
        armor.Icon = Resources.Load(GameSetting2.HAT_ICON_PATH + armor.Name) as Texture2D;

        //assign the eqipment slot where this can be assigned
        armor.Slot = EquipmentSlot.Head;

        //return the melee weapon
        return armor;
    }

        public void HeavyArmorDamageRecalculation()
        {
            //Test with an amount of 0
            Armor heavy = new Armor(ArmorType.Heavy, 0);

            Assert.AreEqual(80, heavy.RecalculateDamage(Pierce));
            Assert.AreEqual(120, heavy.RecalculateDamage(Siege));
            Assert.AreEqual(90, heavy.RecalculateDamage(Magic));
            Assert.AreEqual(100, heavy.RecalculateDamage(Chaos));

            //Test with an amount of 10
            heavy = new Armor(ArmorType.Heavy, 10);

            Assert.AreEqual(64, heavy.RecalculateDamage(Pierce));
            Assert.AreEqual(111, heavy.RecalculateDamage(Siege));
            Assert.AreEqual(85, heavy.RecalculateDamage(Magic));
            Assert.AreEqual(93, heavy.RecalculateDamage(Chaos));

            //Test with a high amount
            heavy = new Armor(ArmorType.Heavy, 10000);

            Assert.IsTrue(heavy.RecalculateDamage(Pierce) > 0);
            Assert.IsTrue(heavy.RecalculateDamage(Siege) > 0);
            Assert.IsTrue(heavy.RecalculateDamage(Magic) > 0);
            Assert.IsTrue(heavy.RecalculateDamage(Chaos) > 0);
        }

 public Armor(Armor armor)
 {
     this.name = armor.name;
     this.type = armor.type;
     this.value = armor.value;
     this.armortype = armor.armortype;
     this.trait = armor.trait;
 }

 /// <summary>
 /// 穿上護甲
 /// </summary>
 void EquipArmor(Armor _armor)
 {
     //穿上裝備，如果返回false代表無法裝備
     if (!_armor.Equip())
         return;
     Equip(_armor, true);//穿上裝備
     AddArmorBuffer(_armor.BufferID);
 }

 public void takeArmor(Armor someArmor)
 {
     if ( someArmor.Owner != null ) {
         throw new ArgumentException();
     }
     ownArmor = someArmor;
     ownArmor.Owner = this;
 }

	public void UpdateBonuses(Armor a, Weapon w) {
		if (a != null) {
			armorbonus = a.armorBonus;
		}
		if (w != null) {
			attackbonus = w.damageBonus;
			speedbonus = w.speedBonus;
		}
	}

        public object Clone()
        {
            Armor armor = new Armor();

            armor.DmgBlock = this.DmgBlock;
            armor.Name = this.Name;

            return armor;
        }

    public void AddItem(Item pItem)
    {
        pItems.Add(pItem);

        if (pItem.ItmType == Item.ItemType.Weapon && pEquipedWeapon == null)
            pEquipedWeapon = pItem as Weapon;
        else if (pItem.ItmType == Item.ItemType.Armor && pEquipedArmor == null)
            pEquipedArmor = pItem as Armor;
    }

 public bool addArmor(Armor a)
 {
     if(a.getWeight() + weight > weightLimit) {
         return false;
     } else {
         armors.Add(a);
         weight += a.getWeight();
         return true;
     }
 }

 public Unit(string name = defaultName, double health = defaultHealth)
 {
     if ( health < 10 || health > 100 ) {
         throw new ArgumentException();
     }
     this.name = name;
     this.health = health;
     ownWeapon = NoWeapon;
     ownArmor = NoArmor;
 }

 public void removeArmor()
 {
     if(isPrimarySlotOccupied()){
         primaryarmor.transform.parent = null;
         primaryarmor.disableAbility();
         primaryarmor.enableSprite();
         primaryarmor.drop(owner.getCollider());
         defaultArmor();
         primaryarmor = null;
     }
 }

        // Write program entries TO XML-file
        private static void DataToXML(Armor[] armorArr)
        {
            XmlSerializer serializerFromData = new XmlSerializer(armorArr.GetType());

            TextWriter writerToFile = new StreamWriter("..\\..\\ArmorSerialization\\Armor.xml");

            serializerFromData.Serialize(writerToFile, armorArr);

            // Close the writerToFile [StreamWriter]
            writerToFile.Close();
        }

        public void ArmorTest()
        {
            // Create a new Human character.
            Character objCharacter = new Character();
            objCharacter.LoadMetatype(Guid.Parse("e28e7075-f635-4c02-937c-e4fc61c51602"));

            // Add ArmorValue 6 Armor to the character. Their total Armor should be 6 with a Encumbrance penalty of 0 since there is nothing with a +value.
            Armor objArmor = new Armor(objCharacter);
            objArmor.ArmorValue = "6";
            objCharacter.Armor.Add(objArmor);

            Assert.AreEqual(6, objCharacter.ArmorValue, "ArmorValue does not equal the expected value of 6.");
            Assert.AreEqual(6, objCharacter.TotalArmorValue, "TotalArmorValue does not equal the expected value of 6.");
            Assert.AreEqual(0, objCharacter.ArmorEncumbrance, "ArmorEncumbrance does not equal the expected value of 0.");

            // Add an Armor Mod to the Armor. This should bring the Armor value up to 8.
            ArmorMod objMod = new ArmorMod(objCharacter);
            objMod.ArmorValue = 2;
            objCharacter.Armor[0].ArmorMods.Add(objMod);

            Assert.AreEqual(8, objCharacter.ArmorValue, "ArmorValue does not equal the expected value of 8.");
            Assert.AreEqual(8, objCharacter.TotalArmorValue, "TotalArmorValue does not equal the expected value of 8.");
            Assert.AreEqual(0, objCharacter.ArmorEncumbrance, "ArmorEncumbrance does not equal the expected value of 0.");

            // Add an additional +6 value Armor to the character. Their total Aromr should be 14 with an Encumbrance penalty of 2.
            Armor objPlusArmor = new Armor(objCharacter);
            objPlusArmor.ArmorValue = "+6";
            objCharacter.Armor.Add(objPlusArmor);

            Assert.AreEqual(14, objCharacter.ArmorValue, "ArmorValue does not equal the expected value of 14.");
            Assert.AreEqual(14, objCharacter.TotalArmorValue, "TotalArmorValue does not equal the expected value of 14.");
            Assert.AreEqual(2, objCharacter.ArmorEncumbrance, "ArmorEncumbrance does not equal the expected value of 2.");

            // Increase the character's STR to 4. This should reduce the Armor Encumbrance penalty to 1.
            objCharacter.STR.Value = 4;

            Assert.AreEqual(14, objCharacter.ArmorValue, "ArmorValue does not equal the expected value of 14.");
            Assert.AreEqual(14, objCharacter.TotalArmorValue, "TotalArmorValue does not equal the expected value of 14.");
            Assert.AreEqual(1, objCharacter.ArmorEncumbrance, "ArmorEncumbrance does not equal the expected value of 1.");

            // Unequipping the Armor Mod should reduce the Armor value down to 12.
            objCharacter.Armor[0].ArmorMods[0].Equipped = false;

            Assert.AreEqual(12, objCharacter.ArmorValue, "ArmorValue does not equal the expected value of 12.");
            Assert.AreEqual(12, objCharacter.TotalArmorValue, "TotalArmorValue does not equal the expected value of 12.");
            Assert.AreEqual(1, objCharacter.ArmorEncumbrance, "ArmorEncumbrance does not equal the expected value of 1.");

            // Unequipping the +value Armor should put the character back to Armor 6 with no Encumbrance penalty.
            objCharacter.Armor[1].Equipped = false;

            Assert.AreEqual(6, objCharacter.ArmorValue, "ArmorValue does not equal the expected value of 6.");
            Assert.AreEqual(6, objCharacter.TotalArmorValue, "TotalArmorValue does not equal the expected value of 6.");
            Assert.AreEqual(0, objCharacter.ArmorEncumbrance, "ArmorEncumbrance does not equal the expected value of 0.");
        }

        public Health(int amount, Killable owner, Armor armor)
        {
            if (amount <= 0) {
                throw new System.ArgumentException("Healthes with a negative amount aren't allowed");
            }

            MaxAmount = amount;
            Amount = amount;
            Owner = owner;
            Armor = armor;
        }

        public static bool TryParseArmorShortName(string shortName, out Armor armor)
        {
            int tmp;
            if (_armorShortCutNameToIdTable.TryGetValue(shortName, out tmp))
            {
                armor = (Armor)tmp;
                return true;
            }

            armor = Armor.Invalid;
            return false;
        }

	public override Item Clone ()
	{
		Armor item = new Armor();
		base.CloneBase(item);

		//copy all vars before return
		item.Fits = Fits;
		item.ArmorValue = ArmorValue;
		item.DefenseValue = DefenseValue;

		return item;
	}