WeaponData.LoadData C# (CSharp) Method

LoadData() public method

public LoadData ( ) : void
return void
    public void LoadData()
    {
        ArrayList data = XMLHandler.LoadXML(dir+filename);

        if(data.Count > 0)
        {
            foreach(Hashtable entry in data)
            {
                if(entry[XMLHandler.NODE_NAME] as string == WeaponData.WEAPONS)
                {
                    if(entry.ContainsKey(XMLHandler.NODES))
                    {
                        ArrayList subs = entry[XMLHandler.NODES] as ArrayList;
                        icon = new string[subs.Count];
                        weapon = new Weapon[subs.Count];

                        foreach(Hashtable val in subs)
                        {
                            if(val[XMLHandler.NODE_NAME] as string == WeaponData.WEAPON)
                            {
                                // old attack conversion
                                BaseAttack[] tmpAtk = new BaseAttack[0];

                                int i = int.Parse((string)val["id"]);
                                icon[i] = "";

                                weapon[i] = new Weapon();
                                if(val.ContainsKey("minimumlevel"))
                                {
                                    weapon[i].minimumLevel = int.Parse((string)val["minimumlevel"]);
                                }
                                if(val.ContainsKey("minimumclasslevel"))
                                {
                                    weapon[i].minimumClassLevel = int.Parse((string)val["minimumclasslevel"]);
                                }
                                weapon[i].equipPart = new bool[int.Parse((string)val["equipparts"])];
                                weapon[i].blockPart = new bool[int.Parse((string)val["equipparts"])];
                                if(val.ContainsKey("dropable")) weapon[i].dropable = true;
                                weapon[i].equipType = (EquipType)System.Enum.Parse(typeof(EquipType), (string)val["equiptype"]);
                                weapon[i].skillEffect = new SkillEffect[int.Parse((string)val["effects"])];

                                if(val.ContainsKey("element"))
                                {
                                    weapon[i].ownAttack = true;
                                    weapon[i].element = int.Parse((string)val["element"]);
                                }

                                int count;
                                if(val.ContainsKey("races"))
                                {
                                    count = int.Parse((string)val["races"]);
                                }
                                else count = DataHolder.Races().GetDataCount();
                                weapon[i].raceValue = new int[count];

                                if(val.ContainsKey("sizes"))
                                {
                                    count = int.Parse((string)val["sizes"]);
                                }
                                else count = DataHolder.Sizes().GetDataCount();
                                weapon[i].sizeValue = new int[count];

                                if(val.ContainsKey("elements"))
                                {
                                    count = int.Parse((string)val["elements"]);
                                }
                                else count = DataHolder.Elements().GetDataCount();
                                weapon[i].elementValue = new int[count];
                                weapon[i].elementOperator = new SimpleOperator[count];

                                if(val.ContainsKey("attacks"))
                                {
                                    weapon[i].baseAttack = new int[int.Parse((string)val["attacks"])];
                                }
                                else
                                {
                                    // old attack conversion
                                    if(val.ContainsKey("baseattacks"))
                                    {
                                        weapon[i].baseAttack = new int[int.Parse((string)val["baseattacks"])];
                                        tmpAtk = new BaseAttack[weapon[i].baseAttack.Length];
                                        for(int j=0; j<tmpAtk.Length; j++)
                                        {
                                            tmpAtk[j] = new BaseAttack(DataHolder.StatusValueCount);
                                        }
                                    }
                                    else
                                    {
                                        tmpAtk = new BaseAttack[1];
                                        tmpAtk[0] = new BaseAttack(DataHolder.StatusValueCount);
                                        tmpAtk[0].SetData(val);
                                    }
                                }

                                if(val.ContainsKey("skills"))
                                {
                                    weapon[i].equipmentSkill = new EquipmentSkill[int.Parse((string)val["skills"])];
                                }

                                weapon[i].buyPrice = int.Parse((string)val["buyprice"]);
                                if(val.ContainsKey("sellprice"))
                                {
                                    weapon[i].sellable = true;
                                    weapon[i].sellPrice = int.Parse((string)val["sellprice"]);
                                    weapon[i].sellSetter = (ValueSetter)System.Enum.Parse(typeof(ValueSetter), (string)val["sellsetter"]);
                                }
                                if(val.ContainsKey("counter"))
                                {
                                    weapon[i].bonus.counterBonus = int.Parse((string)val["counter"]);
                                }
                                if(val.ContainsKey("escape"))
                                {
                                    weapon[i].bonus.escapeBonus = int.Parse((string)val["escape"]);
                                }
                                if(val.ContainsKey("hitbonus"))
                                {
                                    weapon[i].bonus.hitBonus = int.Parse((string)val["hitbonus"]);
                                }
                                if(val.ContainsKey("animationid"))
                                {
                                    weapon[i].battleAnimations.animateBaseAttack = true;
                                    weapon[i].battleAnimations.baseAttackAnimationID = int.Parse((string)val["animationid"]);
                                }
                                if(val.ContainsKey("movespeedreduction"))
                                {
                                    weapon[i].bonus.speedBonus = -float.Parse((string)val["movespeedreduction"]);
                                }

                                ArrayList s = val[XMLHandler.NODES] as ArrayList;
                                foreach(Hashtable ht in s)
                                {
                                    this.LoadLanguages(ht, i, subs.Count);
                                    if(ht[XMLHandler.NODE_NAME] as string == WeaponData.EQUIPPART)
                                    {
                                        weapon[i].equipPart[int.Parse((string)ht["id"])] = bool.Parse((string)ht["enabled"]);
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.BLOCKPART)
                                    {
                                        weapon[i].blockPart[int.Parse((string)ht["id"])] = bool.Parse((string)ht["blocked"]);
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.BONUS)
                                    {
                                        int id = int.Parse((string)ht["id"]);
                                        if(id < weapon[i].bonus.statusBonus.Length)
                                        {
                                            weapon[i].bonus.statusBonus[id] = int.Parse((string)ht["value"]);
                                        }
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.EFFECT)
                                    {
                                        weapon[i].skillEffect[int.Parse((string)ht["id"])] = (SkillEffect)System.Enum.Parse(typeof(SkillEffect), (string)ht["value"]);
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.PREFAB)
                                    {
                                        weapon[i].prefabName = ht[XMLHandler.CONTENT] as string;
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.SKILL)
                                    {
                                        int j = int.Parse((string)ht["id"]);
                                        weapon[i].equipmentSkill[j] = new EquipmentSkill(DataHolder.StatusValueCount);
                                        weapon[i].equipmentSkill[j].skill = int.Parse((string)ht["skill"]);
                                        if(ht.ContainsKey("slvl"))
                                        {
                                            weapon[i].equipmentSkill[j].skillLevel = int.Parse((string)ht["slvl"]);
                                        }
                                        if(ht.ContainsKey("level"))
                                        {
                                            weapon[i].equipmentSkill[j].requireLevel = true;
                                            weapon[i].equipmentSkill[j].level = int.Parse((string)ht["level"]);
                                        }
                                        if(ht.ContainsKey("classlevel"))
                                        {
                                            weapon[i].equipmentSkill[j].requireClassLevel = true;
                                            weapon[i].equipmentSkill[j].classLevel = int.Parse((string)ht["classlevel"]);
                                        }
                                        if(ht.ContainsKey("class"))
                                        {
                                            weapon[i].equipmentSkill[j].requireClass = true;
                                            weapon[i].equipmentSkill[j].classNumber = int.Parse((string)ht["class"]);
                                        }
                                        if(ht.ContainsKey(XMLHandler.NODES))
                                        {
                                            ArrayList ss = ht[XMLHandler.NODES] as ArrayList;
                                            foreach(Hashtable skill in ss)
                                            {
                                                if(skill[XMLHandler.NODE_NAME] as string == WeaponData.STATUS)
                                                {
                                                    int k = int.Parse((string)skill["id"]);
                                                    weapon[i].equipmentSkill[j].requireStatus[k] = true;
                                                    weapon[i].equipmentSkill[j].statusValue[k] = int.Parse((string)skill["value"]);
                                                    weapon[i].equipmentSkill[j].statusRequirement[k] = (ValueCheck)System.Enum.Parse(typeof(ValueCheck), (string)skill["requirement"]);
                                                }
                                            }
                                        }
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.ANIMATIONS)
                                    {
                                        weapon[i].ownBaseAnimations = bool.Parse((string)ht["ownbase"]);
                                        weapon[i].battleAnimations = new BattleAnimationSettings(ht);
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.BASEATTACK)
                                    {
                                        int j = int.Parse((string)ht["id"]);
                                        if(j < tmpAtk.Length)
                                        {
                                            tmpAtk[j].SetData(ht);
                                        }
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.BONUSSETTINGS)
                                    {
                                        weapon[i].bonus.SetData(ht);
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.ATTACK)
                                    {
                                        int j = int.Parse((string)ht["id"]);
                                        if(j < weapon[i].baseAttack.Length)
                                        {
                                            weapon[i].baseAttack[j] = int.Parse((string)ht["id2"]);;
                                        }
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.RACE)
                                    {
                                        int id = int.Parse((string)ht["id"]);
                                        if(id < weapon[i].raceValue.Length)
                                        {
                                            weapon[i].raceValue[id] = int.Parse((string)ht["value"]);
                                        }
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.ELEMENT)
                                    {
                                        int j = int.Parse((string)ht["id"]);
                                        weapon[i].elementValue[j] = int.Parse((string)ht["value"]);
                                        weapon[i].elementOperator[j] = (SimpleOperator)System.Enum.Parse(
                                                typeof(SimpleOperator), (string)ht["operator"]);
                                    }
                                    else if(ht[XMLHandler.NODE_NAME] as string == WeaponData.SIZE)
                                    {
                                        int id = int.Parse((string)ht["id"]);
                                        if(id < weapon[i].sizeValue.Length)
                                        {
                                            weapon[i].sizeValue[id] = int.Parse((string)ht["value"]);
                                        }
                                    }
                                }

                                // old attack import
                                if(weapon[i].ownAttack && tmpAtk.Length > 0)
                                {
                                    weapon[i].baseAttack = DataHolder.BaseAttacks().ImportOldAttack(tmpAtk, "Weapon");
                                }
                            }
                        }
                    }
                }
            }
        }
    }