Esempio n. 1
0
 public sealed override bool IsImmune(CombatTypeFlags damageType)
 {
     if (HasFlag(PlayerFlags.CannotBeAttacked))
     {
         return(true);
     }
     return(base.IsImmune(damageType));
 }
Esempio n. 2
0
        private static void ParseItemNode(XmlNode node, ushort id)
        {
            if (id > 30000 && id < 30100)
            {
                id -= 30000;

                if (!Templates.ContainsKey(id))
                {
                    Templates.Add(id, new ItemTemplate());
                }
            }

            ItemTemplate item = Templates[id];

            item.Id = id;

            Debug.Assert(node.Attributes != null, "node.Attributes != null");
            item.Name = node.Attributes["name"].InnerText;

            XmlAttribute articleAttribute = node.Attributes["article"];

            if (articleAttribute != null)
            {
                item.Article = articleAttribute.InnerText;
            }

            XmlAttribute pluralAttribute = node.Attributes["plural"];

            if (pluralAttribute != null)
            {
                item.PluralName = pluralAttribute.InnerText;
            }

            if (node.HasChildNodes)
            {
                foreach (XmlNode attributeNode in node.ChildNodes)
                {
                    if (attributeNode.Attributes == null)
                    {
                        continue;
                    }

                    XmlAttribute keyAttribute   = attributeNode.Attributes["key"];
                    XmlAttribute valueAttribute = attributeNode.Attributes["value"];

                    if (keyAttribute == null || valueAttribute == null)
                    {
                        continue;
                    }

                    switch (keyAttribute.InnerText.ToLowerInvariant())
                    {
                    case "type":
                        switch (valueAttribute.InnerText.ToLowerInvariant())
                        {
                        case "key":
                            item.Type = ItemTypes.Key;
                            break;

                        case "magicfield":
                            item.Type = ItemTypes.MagicField;
                            break;

                        case "container":
                            item.Group = ItemGroups.Container;
                            item.Type  = ItemTypes.Container;
                            break;

                        case "depot":
                            item.Type = ItemTypes.Depot;
                            break;

                        case "mailbox":
                            item.Type = ItemTypes.Mailbox;
                            break;

                        case "trashholder":
                            item.Type = ItemTypes.TrashHolder;
                            break;

                        case "teleport":
                            item.Type = ItemTypes.Teleport;
                            break;

                        case "door":
                            item.Type = ItemTypes.Door;
                            break;

                        case "bed":
                            item.Type = ItemTypes.Bed;
                            break;

                        case "rune":
                            item.Type = ItemTypes.Rune;
                            break;

                        default:
                            Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown type: " + valueAttribute.InnerText);
                            break;
                        }
                        break;

                    case "description":
                        item.Description = valueAttribute.InnerText;
                        break;

                    case "runespellname":
                        item.RuneSpellName = valueAttribute.InnerText;
                        break;

                    case "weight":
                        item.Weight = uint.Parse(valueAttribute.InnerText);
                        break;

                    case "showcount":
                        item.ShowCount = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "armor":
                        item.Armor = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "defense":
                        item.Defense = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "extradef":
                        item.ExtraDefense = short.Parse(valueAttribute.InnerText);
                        break;

                    case "attack":
                        item.Attack = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "rotateto":
                        item.RotateTo = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "movable":
                    case "moveable":
                        item.IsMoveable = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "blockprojectile":
                        item.DoesBlockProjectile = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "pickupable":
                    case "allowpickupable":
                        item.DoesAllowPickupable = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "floorchange":
                        if (!Enum.TryParse(valueAttribute.InnerText, true, out item.FloorChange))
                        {
                            Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown floorchange: " + valueAttribute.InnerText);
                        }
                        break;

                    case "corpsetype":
                        if (!Enum.TryParse(valueAttribute.InnerText, true, out item.CorpseType))
                        {
                            Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown corpsetype: " + valueAttribute.InnerText);
                        }
                        break;

                    case "containersize":
                        item.MaxItems = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "fluidsource":
                        if (!Enum.TryParse(valueAttribute.InnerText, true, out item.FluidSource))
                        {
                            Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown fluidsource: " + valueAttribute.InnerText);
                        }
                        break;

                    case "readable":
                        item.CanReadText = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "writeable":
                        item.CanWriteText = int.Parse(valueAttribute.InnerText) != 0;
                        item.CanReadText  = item.CanWriteText;
                        break;

                    case "maxtextlen":
                        item.MaxTextLength = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "writeonceitemid":
                        item.WriteOnceItemId = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "weapontype":
                        if (!Enum.TryParse(valueAttribute.InnerText, true, out item.WeaponType))
                        {
                            Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown weapontype: " + valueAttribute.InnerText);
                        }
                        break;

                    case "slottype":
                        switch (valueAttribute.InnerText.ToLowerInvariant())
                        {
                        case "head":
                            item.SlotPosition |= SlotPositionFlags.Head;
                            break;

                        case "body":
                            item.SlotPosition |= SlotPositionFlags.Armor;
                            break;

                        case "legs":
                            item.SlotPosition |= SlotPositionFlags.Legs;
                            break;

                        case "feet":
                            item.SlotPosition |= SlotPositionFlags.Feet;
                            break;

                        case "backpack":
                            item.SlotPosition |= SlotPositionFlags.Backpack;
                            break;

                        case "two-handed":
                            item.SlotPosition |= SlotPositionFlags.TwoHand;
                            break;

                        case "right-hand":
                            item.SlotPosition &= ~SlotPositionFlags.LeftHand;
                            break;

                        case "left-hand":
                            item.SlotPosition &= ~SlotPositionFlags.RightHand;
                            break;

                        case "necklace":
                            item.SlotPosition |= SlotPositionFlags.Necklace;
                            break;

                        case "ring":
                            item.SlotPosition |= SlotPositionFlags.Ring;
                            break;

                        case "ammo":
                            item.SlotPosition |= SlotPositionFlags.Ammo;
                            break;

                        case "hand":
                            item.SlotPosition |= SlotPositionFlags.Hand;
                            break;

                        default:
                            Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown slottype: " + valueAttribute.InnerText);
                            break;
                        }
                        break;

                    case "ammotype":
                        if (!Enum.TryParse(valueAttribute.InnerText, true, out item.AmmoType))
                        {
                            Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown ammotype: " + valueAttribute.InnerText);
                        }
                        break;

                    case "shoottype":
                        if (!Enum.TryParse(valueAttribute.InnerText, true, out item.ShootType))
                        {
                            Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown shoottype: " + valueAttribute.InnerText);
                        }
                        break;

                    case "effect":
                        //if (!Enum.TryParse(valueAttribute.InnerText, true, out item.MagicEffect)) TODO: Item Magic Effect
                        //    Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown magiceffect: " + valueAttribute.InnerText);
                        break;

                    case "range":
                        item.ShootRange = byte.Parse(valueAttribute.InnerText);
                        break;

                    case "stopduration":
                        item.StopTime = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "decayto":
                        item.DecayTo = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "transformequipto":
                        item.TransformEquipTo = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "transformdeequipto":
                        item.TransformDequipTo = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "duration":
                        item.DecayTime = uint.Parse(valueAttribute.InnerText);
                        break;

                    case "showduration":
                        item.ShowDuration = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "charges":
                        item.Charges = uint.Parse(valueAttribute.InnerText);
                        break;

                    case "showcharges":
                        item.ShowCharges = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "showattributes":
                        item.ShowAttributes = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "hitchance":
                        item.HitChance = Math.Min((sbyte)100, Math.Max((sbyte)-100, sbyte.Parse(valueAttribute.InnerText)));
                        break;

                    case "maxhitchance":
                        item.MaxHitChance = Math.Min(100, int.Parse(valueAttribute.InnerText));
                        break;

                    case "replaceable":
                        item.IsReplaceable = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "leveldoor":
                        item.LevelDoor = uint.Parse(valueAttribute.InnerText);
                        break;

                    case "malesleeper":
                    case "maletransformto":
                        ushort value = ushort.Parse(valueAttribute.InnerText);

                        if (item.TransformToOnUse == null)
                        {
                            item.TransformToOnUse = new ushort[2];
                        }

                        item.TransformToOnUse[(int)Genders.Male] = value;

                        ItemTemplate other = Templates[id];
                        if (other.TransformToFree == 0)
                        {
                            other.TransformToFree = item.Id;
                        }

                        if (item.TransformToOnUse[(int)Genders.Female] == 0)
                        {
                            item.TransformToOnUse[(int)Genders.Female] = value;
                        }
                        break;

                    case "femalesleeper":
                    case "femaletransformto":
                        value = ushort.Parse(valueAttribute.InnerText);

                        if (item.TransformToOnUse == null)
                        {
                            item.TransformToOnUse = new ushort[2];
                        }

                        item.TransformToOnUse[(int)Genders.Female] = value;

                        other = Templates[id];
                        if (other.TransformToFree == 0)
                        {
                            other.TransformToFree = item.Id;
                        }

                        if (item.TransformToOnUse[(int)Genders.Male] == 0)
                        {
                            item.TransformToOnUse[(int)Genders.Male] = value;
                        }
                        break;

                    case "transformto":
                        item.TransformToFree = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "destroyto":
                        item.DestroyTo = ushort.Parse(valueAttribute.InnerText);
                        break;

                    case "walkstack":
                        item.WalkStack = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "blocking":
                        item.DoesBlockSolid = int.Parse(valueAttribute.InnerText) != 0;
                        break;

                    case "allowdistread":
                        item.AllowDistanceRead = Tools.ConvertLuaBoolean(valueAttribute.InnerText);
                        break;

                    case "invisible":
                        item.GetAbilitiesWithInitializer().Invisible = Tools.ConvertLuaBoolean(valueAttribute.InnerText);
                        break;

                    case "speed":
                        item.GetAbilitiesWithInitializer().Speed = int.Parse(valueAttribute.InnerText);
                        break;

                    case "healthgain":
                        Abilities abilities = item.GetAbilitiesWithInitializer();
                        abilities.Regeneration = true;
                        abilities.HealthGain   = uint.Parse(valueAttribute.InnerText);
                        break;

                    case "healthticks":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.Regeneration = true;
                        abilities.HealthTicks  = uint.Parse(valueAttribute.InnerText);
                        break;

                    case "managain":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.Regeneration = true;
                        abilities.ManaGain     = uint.Parse(valueAttribute.InnerText);
                        break;

                    case "manaticks":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.Regeneration = true;
                        abilities.ManaTicks    = uint.Parse(valueAttribute.InnerText);
                        break;

                    case "manashield":
                        item.GetAbilitiesWithInitializer().ManaShield = Tools.ConvertLuaBoolean(valueAttribute.InnerText);
                        break;

                    case "skillsword":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeSkillModifiers();
                        abilities.SkillModifiers[(int)Skills.Sword] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "skillaxe":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeSkillModifiers();
                        abilities.SkillModifiers[(int)Skills.Axe] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "skillclub":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeSkillModifiers();
                        abilities.SkillModifiers[(int)Skills.Club] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "skilldist":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeSkillModifiers();
                        abilities.SkillModifiers[(int)Skills.Distance] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "skillfish":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeSkillModifiers();
                        abilities.SkillModifiers[(int)Skills.Fishing] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "skillshield":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeSkillModifiers();
                        abilities.SkillModifiers[(int)Skills.Shield] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "skillfist":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeSkillModifiers();
                        abilities.SkillModifiers[(int)Skills.Fist] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "maxhitpoints":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeStatModifiers();
                        abilities.StatModifiers[(int)Stats.MaxHitPoints] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "maxhitpointspercent":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeStatModifiersPercent();
                        abilities.StatModifiersPercent[(int)Stats.MaxHitPoints] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "maxmanapoints":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeStatModifiers();
                        abilities.StatModifiers[(int)Stats.MaxManaPoints] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "maxmanapointspercent":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeStatModifiersPercent();
                        abilities.StatModifiersPercent[(int)Stats.MaxManaPoints] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "magicpoints":
                    case "magiclevelpoints":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeStatModifiers();
                        abilities.StatModifiers[(int)Stats.MagicPoints] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "magicpointspercent":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeStatModifiersPercent();
                        abilities.StatModifiersPercent[(int)Stats.MagicPoints] = int.Parse(valueAttribute.InnerText);
                        break;

                    case "fieldabsorbpercentenergy":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeFieldAbsorbPercent();
                        abilities.FieldAbsorbPercent[(int)CombatTypeFlags.EnergyDamage] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "fieldabsorbpercentfire":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeFieldAbsorbPercent();
                        abilities.FieldAbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.FireDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "fieldabsorbpercentpoison":
                    case "fieldabsorpercentearth":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeFieldAbsorbPercent();
                        abilities.FieldAbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.EarthDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentall":
                    case "absorbpercentallelements":
                        short shortVal = short.Parse(valueAttribute.InnerText);
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();

                        for (CombatTypeFlags i = CombatTypeFlags.First; i <= CombatTypeFlags.Last; i++)
                        {
                            abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)i)] += shortVal;
                        }
                        break;

                    case "absorbpercentelements":
                        shortVal  = short.Parse(valueAttribute.InnerText);
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.EnergyDamage)] += shortVal;
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.EarthDamage)]  += shortVal;
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.FireDamage)]   += shortVal;
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.IceDamage)]    += shortVal;
                        break;

                    case "absorbpercentmagic":
                        shortVal  = short.Parse(valueAttribute.InnerText);
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.EnergyDamage)] += shortVal;
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.DeathDamage)]  += shortVal;
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.EarthDamage)]  += shortVal;
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.HolyDamage)]   += shortVal;
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.FireDamage)]   += shortVal;
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.IceDamage)]    += shortVal;
                        break;

                    case "absorbpercentenergy":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.EnergyDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentfire":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.FireDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentpoison":
                    case "absorbpercentearth":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.EarthDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentice":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.IceDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentholy":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.HolyDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentdeath":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.DeathDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentlifedrain":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.LifeDrain)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentmanadrain":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.ManaDrain)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentdrown":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.DrownDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentphysical":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.PhysicalDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercenthealing":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.Healing)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "absorbpercentundefined":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.InitializeAbsorbPercent();
                        abilities.AbsorbPercent[Tools.FlagEnumToArrayPoint((uint)CombatTypeFlags.UndefinedDamage)] += short.Parse(valueAttribute.InnerText);
                        break;

                    case "suppressdrunk":
                        if (Tools.ConvertLuaBoolean(valueAttribute.InnerText))
                        {
                            item.GetAbilitiesWithInitializer().ConditionSupressions |= ConditionFlags.Drunk;
                        }
                        break;

                    case "suppressenergy":
                        if (Tools.ConvertLuaBoolean(valueAttribute.InnerText))
                        {
                            item.GetAbilitiesWithInitializer().ConditionSupressions |= ConditionFlags.Energy;
                        }
                        break;

                    case "suppressfire":
                        if (Tools.ConvertLuaBoolean(valueAttribute.InnerText))
                        {
                            item.GetAbilitiesWithInitializer().ConditionSupressions |= ConditionFlags.Fire;
                        }
                        break;

                    case "suppresspoison":
                        if (Tools.ConvertLuaBoolean(valueAttribute.InnerText))
                        {
                            item.GetAbilitiesWithInitializer().ConditionSupressions |= ConditionFlags.Poison;
                        }
                        break;

                    case "suppressdrown":
                        if (Tools.ConvertLuaBoolean(valueAttribute.InnerText))
                        {
                            item.GetAbilitiesWithInitializer().ConditionSupressions |= ConditionFlags.Drown;
                        }
                        break;

                    case "suppressphysical":
                        if (Tools.ConvertLuaBoolean(valueAttribute.InnerText))
                        {
                            item.GetAbilitiesWithInitializer().ConditionSupressions |= ConditionFlags.Bleeding;
                        }
                        break;

                    case "suppressfreeze":
                        if (Tools.ConvertLuaBoolean(valueAttribute.InnerText))
                        {
                            item.GetAbilitiesWithInitializer().ConditionSupressions |= ConditionFlags.Freezing;
                        }
                        break;

                    case "suppressdazzle":
                        if (Tools.ConvertLuaBoolean(valueAttribute.InnerText))
                        {
                            item.GetAbilitiesWithInitializer().ConditionSupressions |= ConditionFlags.Dazzled;
                        }
                        break;

                    case "suppresscurse":
                        if (Tools.ConvertLuaBoolean(valueAttribute.InnerText))
                        {
                            item.GetAbilitiesWithInitializer().ConditionSupressions |= ConditionFlags.Cursed;
                        }
                        break;

                    case "elementice":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.ElementDamage = ushort.Parse(valueAttribute.InnerText);
                        abilities.ElementType   = CombatTypeFlags.IceDamage;
                        break;

                    case "elementearth":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.ElementDamage = ushort.Parse(valueAttribute.InnerText);
                        abilities.ElementType   = CombatTypeFlags.EarthDamage;
                        break;

                    case "elementfire":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.ElementDamage = ushort.Parse(valueAttribute.InnerText);
                        abilities.ElementType   = CombatTypeFlags.FireDamage;
                        break;

                    case "elementenergy":
                        abilities = item.GetAbilitiesWithInitializer();
                        abilities.ElementDamage = ushort.Parse(valueAttribute.InnerText);
                        abilities.ElementType   = CombatTypeFlags.EnergyDamage;
                        break;

                    case "partnerdirection":
                        if (!Enum.TryParse(valueAttribute.InnerText, true, out item.BedPartnerDirection))
                        {
                            Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown partnerdirection: " + valueAttribute.InnerText);
                        }
                        break;

                    case "field":
                        //WILL BE IMPLEMENTED LATER
                        break;

                    default:
                        Logger.Log(LogLevels.Warning, "ParseItemNode: Unknown key value: " + keyAttribute.InnerText);
                        break;
                        // CURRENTLY SKIPPING ATTRIBUTES
                    }
                }
            }
        }