Example #1
0
        public void Initialize(int id)
        {
            DefenderStruct ds = DataStructs.Defenders.Find(d => d.ID == id);

            ID = id;
            HP = new HitPoints(ds.HP, ds.HP, 0);
            HPBar.Percentage = 100;
            HPRegen          = ds.HPRegen;
            Velocity         = ds.Velocity;
            IsMelee          = ds.IsMelee;
            IsGround         = ds.IsGround;
            MeleeSightRange  = ds.MeleeSightRange;
            State            = eState.Running;
            Armor            = ds.ArmorType;

            IsAlive      = true;
            IsSpawned    = false;
            RespawnTimer = new SimpleTimer(ds.SpawnDelay);

            #region Weapons
            Weapons             = new List <BaseWeapon>();
            ShortestWeaponRange = int.MaxValue;
            foreach (WeaponStruct ws in ds.Weapons)
            {
                BaseWeapon w = new BaseWeapon(Common.InvalidVector2, ws, this);
                Weapons.Add(w);
                if (ShortestWeaponRange > ws.Range)
                {
                    ShortestWeaponRange = ws.Range;
                }
            }
            if (Weapons.Count == 0)
            {
                throw new Exception("A defender must at least have one weapon.");
            }
            #endregion

            AnimationFactory.Create(ds.AnimationType, out RunAni, out AtkAni, out DieAni, out RelativeAABB, out Icon);
            Animation = RunAni;

            HPBar.BarDrawRect   = new Rectangle(HPBar.BarDrawRect.X, HPBar.BarDrawRect.Y, Animation.FrameSize.X, HPBar.BarDrawRect.Height);
            Animation.DrawColor = ds.DrawColor;
            CenterLocOffset     = new Vector2(Animation.FrameSize.X / 2, Animation.FrameSize.Y / 2);
            m_AABB = RelativeAABB;

            #region Feetoffset
            Vector2 extraFeetOffset = Vector2.Zero;
            switch (ds.AnimationType)
            {
            case eAnimation.Soldier01:
                extraFeetOffset = new Vector2(0, -32);
                break;

            case eAnimation.Crocy:
                extraFeetOffset = new Vector2(0, -32);
                break;

            default:
                throw new CaseStatementMissingException("This animation was not added to the BaseDefender.Initialize() or it was not set (None).");
            }
            FeetLocOffset = new Vector2(Animation.FrameSize.X / 2, Animation.FrameSize.Y) + extraFeetOffset;
            #endregion
        }
Example #2
0
        public static void LoadDefenders()
        {
            Defenders.Clear();
            string[] defenderXmls = Directory.GetFiles("Data/Defenders", "*.xml");

            foreach (string path in defenderXmls)
            {
                XDocument      doc = XDocument.Load(path);
                DefenderStruct ds;

                XElement IDNode = doc.Root.Element("ID");
                if (IDNode != null)
                {
                    ds = new DefenderStruct(int.Parse(IDNode.Value));
                }
                else
                {
                    throw new NullReferenceException("ID node missing. " + path);
                }

                #region General
                XElement generalNode;

                generalNode = doc.Root.Element("Name");
                if (generalNode != null)
                {
                    ds.Name = generalNode.Value;
                }
                else
                {
                    throw new NullReferenceException("Name node missing. " + path);
                }
                generalNode = null;

                generalNode = doc.Root.Element("Description");
                if (generalNode != null)
                {
                    ds.Desc = generalNode.Value;
                }
                else
                {
                    throw new NullReferenceException("Desc node missing. " + path);
                }
                generalNode = null;

                generalNode = doc.Root.Element("HP");
                if (generalNode != null)
                {
                    ds.HP = int.Parse(generalNode.Value);
                }
                else
                {
                    throw new NullReferenceException("HP node missing. " + path);
                }
                generalNode = null;

                generalNode = doc.Root.Element("IsMelee");
                if (generalNode != null)
                {
                    ds.IsMelee = bool.Parse(generalNode.Value);
                }
                generalNode = null;

                generalNode = doc.Root.Element("MeleeSightRange");
                if (generalNode != null)
                {
                    ds.MeleeSightRange = int.Parse(generalNode.Value);
                }
                generalNode = null;

                generalNode = doc.Root.Element("SpawnDelay");
                if (generalNode != null)
                {
                    ds.SpawnDelay = int.Parse(generalNode.Value);
                }
                generalNode = null;

                generalNode = doc.Root.Element("Armor");
                if (generalNode != null)
                {
                    ds.ArmorType = (eArmorType)Enum.Parse(typeof(eArmorType), generalNode.Value);
                }
                generalNode = null;

                generalNode = doc.Root.Element("Animation");
                if (generalNode != null)
                {
                    ds.AnimationType = (eAnimation)Enum.Parse(typeof(eAnimation), generalNode.Value);
                }
                else
                {
                    throw new NullReferenceException("Animation node missing. " + path);
                }
                generalNode = null;

                generalNode = doc.Root.Element("Velocity");
                if (generalNode != null)
                {
                    ds.Velocity = float.Parse(generalNode.Value);
                }
                generalNode = null;

                generalNode = doc.Root.Element("IsGround");
                if (generalNode != null)
                {
                    ds.IsGround = bool.Parse(generalNode.Value);
                }
                generalNode = null;

                generalNode = doc.Root.Element("HPRegen");
                if (generalNode != null)
                {
                    ds.HPRegen = int.Parse(generalNode.Value);
                }
                generalNode = null;

                #endregion

                #region Weapons
                XElement weaponsMainNode = doc.Root.Element("Weapons");
                if (weaponsMainNode != null)
                {
                    foreach (XElement wpnNode in weaponsMainNode.Elements())
                    {
                        XElement wpnRange      = wpnNode.Element("Range");
                        int      wpnRangeValue = 0;
                        if (wpnRange != null)
                        {
                            wpnRangeValue = int.Parse(wpnRange.Value);
                        }

                        XElement wpnRoF      = wpnNode.Element("RoF");
                        int      wpnRoFValue = 0;
                        if (wpnRoF != null)
                        {
                            wpnRoFValue = int.Parse(wpnRoF.Value);
                        }

                        XElement wpnDmg      = wpnNode.Element("Damage");
                        int      wpnDmgValue = 0;
                        if (wpnDmg != null)
                        {
                            wpnDmgValue = int.Parse(wpnDmg.Value);
                        }

                        XElement wpnSplash      = wpnNode.Element("Splash");
                        int      wpnSplashValue = 0;
                        if (wpnSplash != null)
                        {
                            wpnSplashValue = int.Parse(wpnSplash.Value);
                        }

                        XElement wpnSplashDmgPerc      = wpnNode.Element("SplashDmgPercentage");
                        int      wpnSplashDmgPercValue = 0;
                        if (wpnSplashDmgPerc != null)
                        {
                            wpnSplashDmgPercValue = int.Parse(wpnDmg.Value);
                        }

                        XElement           wpnAttackableTargets = wpnNode.Element("AttackableTargets");
                        eAttackableTargets wpnAttackableTargetsValue;
                        if (wpnAttackableTargets == null)
                        {
                            wpnAttackableTargetsValue = eAttackableTargets.Ground;
                        }
                        else
                        {
                            wpnAttackableTargetsValue = (eAttackableTargets)Enum.Parse(typeof(eAttackableTargets), wpnAttackableTargets.Value);
                        }

                        XElement    dmgType      = wpnNode.Element("DamageType");
                        eDamageType dmgTypeValue = eDamageType.Normal;
                        if (dmgType != null)
                        {
                            dmgTypeValue = (eDamageType)Enum.Parse(typeof(eDamageType), dmgType.Value);
                        }

                        WeaponStruct ws = new WeaponStruct(wpnRangeValue, wpnRoFValue, wpnDmgValue, wpnSplashValue, wpnSplashDmgPercValue, wpnAttackableTargetsValue)
                        {
                            DamageType = dmgTypeValue
                        };

                        XElement shootFXNode = wpnNode.Element("ShootFX");
                        if (shootFXNode != null)
                        {
                            ws.ShootFX = int.Parse(shootFXNode.Value);
                        }
                        XElement impactFXNode = wpnNode.Element("ImpactFX");
                        if (impactFXNode != null)
                        {
                            ws.ImpactFX = int.Parse(impactFXNode.Value);
                        }

                        #region Modifiers
                        XElement modifierNode = wpnNode.Element("Stunchance");
                        if (modifierNode != null)
                        {
                            ws.WeaponModifiers.StunChance = int.Parse(modifierNode.Value);
                        }
                        modifierNode = null;
                        modifierNode = wpnNode.Element("Slows");
                        if (modifierNode != null)
                        {
                            ws.WeaponModifiers.Slows = bool.Parse(modifierNode.Value);
                        }
                        modifierNode = null;
                        modifierNode = wpnNode.Element("RootChance");
                        if (modifierNode != null)
                        {
                            ws.WeaponModifiers.RootChance = int.Parse(modifierNode.Value);
                        }
                        modifierNode = null;
                        modifierNode = wpnNode.Element("ArmorReductionValue");
                        if (modifierNode != null)
                        {
                            ws.WeaponModifiers.ArmorReductionValue = int.Parse(modifierNode.Value);
                        }
                        modifierNode = null;
                        #endregion

                        ds.Weapons.Add(ws);
                    }
                }
                #endregion

                Defenders.Add(ds);
            }
        }