Esempio n. 1
0
        public virtual void ProcessItem(IdentResponse item)
        {
            Items.Add(item);

            if (!LimitStatsToOnlyItemsWithWorkmanship || item.LongValues.ContainsKey(IntValueKey.ItemWorkmanship))
            {
                SpellStats.ProcessItem(item);
            }
        }
Esempio n. 2
0
        public override void ProcessItem(IdentResponse item)
        {
            base.ProcessItem(item);

            var equipableSlots = item.LongValues.FirstOrDefault(r => r.Key == Mag.Shared.Constants.IntValueKey.EquipableSlots_Decal);
            var iconOverlay    = item.LongValues.FirstOrDefault(r => r.Key == Mag.Shared.Constants.IntValueKey.IconOverlay_Decal_DID);

            if ((EquipMask)equipableSlots.Value == EquipMask.Cloak)
            {
                CloakCountsByLevel[iconOverlay.Value - 27700 + 1]++;
            }
        }
Esempio n. 3
0
            public void Add(IdentResponse item)
            {
                var damage = item.LongValues[IntValueKey.MaxDamage_Decal];

                if (!DamageHits.ContainsKey(damage))
                {
                    DamageHits[damage] = 1;
                }
                else
                {
                    DamageHits[damage]++;
                }
            }
Esempio n. 4
0
        public override void ProcessItem(IdentResponse item)
        {
            base.ProcessItem(item);

            var type        = item.LongValues.FirstOrDefault(r => r.Key == Mag.Shared.Constants.IntValueKey.WeenieClassId_Decal);
            var iconOverlay = item.LongValues.FirstOrDefault(r => r.Key == Mag.Shared.Constants.IntValueKey.IconOverlay_Decal_DID);

            if (type.Value == 42635) // Blue
            {
                BlueAetheriaCountsByLevel[iconOverlay.Value - 27700 + 1]++;
            }
            else if (type.Value == 42637) // Yellow
            {
                YellowAetheriaCountsByLevel[iconOverlay.Value - 27700 + 1]++;
            }
            else if (type.Value == 42636) // Red
            {
                RedAetheriaCountsByLevel[iconOverlay.Value - 27700 + 1]++;
            }
        }
Esempio n. 5
0
        public override void ProcessItem(IdentResponse item)
        {
            base.ProcessItem(item);

            if (!LimitStatsToOnlyItemsWithWorkmanship || item.LongValues.ContainsKey(IntValueKey.ItemWorkmanship))
            {
                var skill = GetSkill(item);

                if (!allStatsBySkill.TryGetValue(skill, out var statsBySkill))
                {
                    statsBySkill           = new Dictionary <WeaponType, Dictionary <int, Stat> >();
                    allStatsBySkill[skill] = statsBySkill;
                }

                var weaponType = GetWeaponType(item);

                if (!statsBySkill.TryGetValue(weaponType, out var skillStatsByWeaponType))
                {
                    skillStatsByWeaponType   = new Dictionary <int, Stat>();
                    statsBySkill[weaponType] = skillStatsByWeaponType;
                }

                if (item.LongValues.ContainsKey(IntValueKey.WieldRequirements) && item.LongValues.ContainsKey(IntValueKey.WieldDifficulty))
                {
                    if (item.LongValues[IntValueKey.WieldRequirements] == (int)WieldRequirement.RawSkill)
                    {
                        var wieldDifficulty = item.LongValues[IntValueKey.WieldDifficulty];

                        if (!skillStatsByWeaponType.TryGetValue(wieldDifficulty, out var skillStatsByWeaponTypeAndWieldDifficulty))
                        {
                            skillStatsByWeaponTypeAndWieldDifficulty = new Stat();
                            skillStatsByWeaponType[wieldDifficulty]  = skillStatsByWeaponTypeAndWieldDifficulty;
                        }

                        skillStatsByWeaponTypeAndWieldDifficulty.Add(item);
                    }
                }
            }
        }
Esempio n. 6
0
        public override void ProcessItem(IdentResponse item)
        {
            base.ProcessItem(item);

            if (!LimitStatsToOnlyItemsWithWorkmanship || item.LongValues.ContainsKey(IntValueKey.ItemWorkmanship))
            {
                if (item.LongValues.ContainsKey(IntValueKey.WieldRequirements) && item.LongValues.ContainsKey(IntValueKey.WieldDifficulty))
                {
                    var wieldDifficulty = item.LongValues[IntValueKey.WieldDifficulty];

                    if (item.LongValues[IntValueKey.WieldRequirements] == (int)WieldRequirement.RawSkill)
                    {
                        if (!HitsByRawSkillWieldReqValue.ContainsKey(wieldDifficulty))
                        {
                            HitsByRawSkillWieldReqValue[wieldDifficulty] = 1;
                        }
                        else
                        {
                            HitsByRawSkillWieldReqValue[wieldDifficulty]++;
                        }
                    }
                    else if (item.LongValues[IntValueKey.WieldRequirements] == (int)WieldRequirement.Level)
                    {
                        if (!HitsByLevelWieldReqValue.ContainsKey(wieldDifficulty))
                        {
                            HitsByLevelWieldReqValue[wieldDifficulty] = 1;
                        }
                        else
                        {
                            HitsByLevelWieldReqValue[wieldDifficulty]++;
                        }
                    }
                }

                if (item.LongValues.ContainsKey(IntValueKey.EquipableSlots_Decal))
                {
                    var value = item.LongValues[IntValueKey.EquipableSlots_Decal];

                    if (!HitsByValidLocations.ContainsKey(value))
                    {
                        HitsByValidLocations[value] = 1;
                    }
                    else
                    {
                        HitsByValidLocations[value]++;
                    }
                }

                if (item.LongValues.ContainsKey(IntValueKey.EquipmentSetId))
                {
                    var value = item.LongValues[IntValueKey.EquipmentSetId];

                    if (!HitsByEquipmentSet.ContainsKey(value))
                    {
                        HitsByEquipmentSet[value] = 1;
                    }
                    else
                    {
                        HitsByEquipmentSet[value]++;
                    }
                }
            }
        }
Esempio n. 7
0
        protected static Skill GetSkill(IdentResponse item)
        {
            if (item.LongValues.ContainsKey(IntValueKey.WieldSkillType))
            {
                return((Skill)item.LongValues[IntValueKey.WieldSkillType]);
            }

            // item is no wield req

            var itemName = item.StringValues[StringValueKey.Name];

            // axes
            if (TableContains(HeavyWeaponNames.HeavyAxes, itemName))
            {
                return(Skill.HeavyWeapons);
            }
            if (TableContains(LightWeaponNames.LightAxes, itemName))
            {
                return(Skill.LightWeapons);
            }
            if (TableContains(FinesseWeaponNames.FinesseAxes, itemName))
            {
                return(Skill.FinesseWeapons);
            }
            if (TableContains(TwoHandedWeaponNames.TwoHandedAxes, itemName))
            {
                return(Skill.TwoHandedCombat);
            }

            // daggers
            if (TableContains(HeavyWeaponNames.HeavyDaggers, itemName))
            {
                return(Skill.HeavyWeapons);
            }
            if (TableContains(LightWeaponNames.LightDaggers, itemName))
            {
                return(Skill.LightWeapons);
            }
            if (TableContains(FinesseWeaponNames.FinesseDaggers, itemName))
            {
                return(Skill.FinesseWeapons);
            }

            // maces
            if (TableContains(HeavyWeaponNames.HeavyMaces, itemName))
            {
                return(Skill.HeavyWeapons);
            }
            if (TableContains(LightWeaponNames.LightMaces, itemName))
            {
                return(Skill.LightWeapons);
            }
            if (TableContains(FinesseWeaponNames.FinesseMaces, itemName))
            {
                return(Skill.FinesseWeapons);
            }
            if (TableContains(TwoHandedWeaponNames.TwoHandedMaces, itemName))
            {
                return(Skill.TwoHandedCombat);
            }

            // spears
            if (TableContains(HeavyWeaponNames.HeavySpears, itemName))
            {
                return(Skill.HeavyWeapons);
            }
            if (TableContains(LightWeaponNames.LightSpears, itemName))
            {
                return(Skill.LightWeapons);
            }
            if (TableContains(FinesseWeaponNames.FinesseSpears, itemName))
            {
                return(Skill.FinesseWeapons);
            }
            if (TableContains(TwoHandedWeaponNames.TwoHandedSpears, itemName))
            {
                return(Skill.TwoHandedCombat);
            }

            // staffs
            if (TableContains(HeavyWeaponNames.HeavyStaffs, itemName))
            {
                return(Skill.HeavyWeapons);
            }
            if (TableContains(LightWeaponNames.LightStaffs, itemName))
            {
                return(Skill.LightWeapons);
            }
            if (TableContains(FinesseWeaponNames.FinesseStaffs, itemName))
            {
                return(Skill.FinesseWeapons);
            }

            // swords
            if (TableContains(HeavyWeaponNames.HeavySwords, itemName))
            {
                return(Skill.HeavyWeapons);
            }
            if (TableContains(LightWeaponNames.LightSwords, itemName))
            {
                return(Skill.LightWeapons);
            }
            if (TableContains(FinesseWeaponNames.FinesseSwords, itemName))
            {
                return(Skill.FinesseWeapons);
            }
            if (TableContains(TwoHandedWeaponNames.TwoHandedSwords, itemName))
            {
                return(Skill.TwoHandedCombat);
            }

            // unarmed
            if (TableContains(HeavyWeaponNames.HeavyUnarmed, itemName))
            {
                return(Skill.HeavyWeapons);
            }
            if (TableContains(LightWeaponNames.LightUnarmed, itemName))
            {
                return(Skill.LightWeapons);
            }
            if (TableContains(FinesseWeaponNames.FinesseUnarmed, itemName))
            {
                return(Skill.FinesseWeapons);
            }

            // missile
            if (MissileNames.BowNames.Contains(itemName))
            {
                return(Skill.MissileWeapons);
            }
            if (MissileNames.CrossbowNames.Contains(itemName))
            {
                return(Skill.MissileWeapons);
            }
            if (MissileNames.AtlatlNames.Contains(itemName))
            {
                return(Skill.MissileWeapons);
            }

            // casters
            if (CasterNames.CasterItems.Contains(itemName))
            {
                return(Skill.WarMagic);
            }

            throw new Exception($"Couldn't find Skill for {itemName}");
            //Console.WriteLine($"Couldn't find Skill for {itemName}");

            return(Skill.None);
        }
Esempio n. 8
0
        protected static WeaponType GetWeaponType(IdentResponse item)
        {
            var itemName = item.StringValues[StringValueKey.Name];

            // axes
            if (TableContains(HeavyWeaponNames.HeavyAxes, itemName))
            {
                return(WeaponType.Axe);
            }
            if (TableContains(LightWeaponNames.LightAxes, itemName))
            {
                return(WeaponType.Axe);
            }
            if (TableContains(FinesseWeaponNames.FinesseAxes, itemName))
            {
                return(WeaponType.Axe);
            }
            if (TableContains(TwoHandedWeaponNames.TwoHandedAxes, itemName))
            {
                return(WeaponType.Axe);
            }

            // daggers
            if (TableContains(HeavyWeaponNames.HeavyDaggers_SingleStrike, itemName))
            {
                return(WeaponType.Dagger);
            }
            if (TableContains(HeavyWeaponNames.HeavyDaggers_MultiStrike, itemName))
            {
                return(WeaponType.DaggerMS);
            }
            if (TableContains(LightWeaponNames.LightDaggers_SingleStrike, itemName))
            {
                return(WeaponType.Dagger);
            }
            if (TableContains(LightWeaponNames.LightDaggers_MultiStrike, itemName))
            {
                return(WeaponType.DaggerMS);
            }
            if (TableContains(FinesseWeaponNames.FinesseDaggers_SingleStrike, itemName))
            {
                return(WeaponType.Dagger);
            }
            if (TableContains(FinesseWeaponNames.FinesseDaggers_MultiStrike, itemName))
            {
                return(WeaponType.DaggerMS);
            }

            // maces
            if (TableContains(HeavyWeaponNames.HeavyMaces, itemName))
            {
                return(WeaponType.Mace);
            }
            if (TableContains(LightWeaponNames.LightMaces, itemName))
            {
                return(WeaponType.Mace);
            }
            if (TableContains(FinesseWeaponNames.FinesseMaces_NonJittes, itemName))
            {
                return(WeaponType.Mace);
            }
            if (TableContains(FinesseWeaponNames.FinesseMaces_Jittes, itemName))
            {
                return(WeaponType.MaceJitte);
            }
            if (TableContains(TwoHandedWeaponNames.TwoHandedMaces, itemName))
            {
                return(WeaponType.Mace);
            }

            // spears
            if (TableContains(HeavyWeaponNames.HeavySpears, itemName))
            {
                return(WeaponType.Spear);
            }
            if (TableContains(LightWeaponNames.LightSpears, itemName))
            {
                return(WeaponType.Spear);
            }
            if (TableContains(FinesseWeaponNames.FinesseSpears, itemName))
            {
                return(WeaponType.Spear);
            }
            if (TableContains(TwoHandedWeaponNames.TwoHandedSpears, itemName))
            {
                return(WeaponType.Spear);
            }

            // staffs
            if (TableContains(HeavyWeaponNames.HeavyStaffs, itemName))
            {
                return(WeaponType.Staff);
            }
            if (TableContains(LightWeaponNames.LightStaffs, itemName))
            {
                return(WeaponType.Staff);
            }
            if (TableContains(FinesseWeaponNames.FinesseStaffs, itemName))
            {
                return(WeaponType.Staff);
            }

            // swords
            if (TableContains(HeavyWeaponNames.HeavySwords_SingleStrike, itemName))
            {
                return(WeaponType.Sword);
            }
            if (TableContains(HeavyWeaponNames.HeavySwords_MultiStrike, itemName))
            {
                return(WeaponType.SwordMS);
            }
            if (TableContains(LightWeaponNames.LightSwords_SingleStrike, itemName))
            {
                return(WeaponType.Sword);
            }
            if (TableContains(LightWeaponNames.LightSwords_MultiStrike, itemName))
            {
                return(WeaponType.SwordMS);
            }
            if (TableContains(FinesseWeaponNames.FinesseSwords_SingleStrike, itemName))
            {
                return(WeaponType.Sword);
            }
            if (TableContains(FinesseWeaponNames.FinesseSwords_MultiStrike, itemName))
            {
                return(WeaponType.SwordMS);
            }
            if (TableContains(TwoHandedWeaponNames.TwoHandedSwords, itemName))
            {
                return(WeaponType.Sword);
            }

            // unarmed
            if (TableContains(HeavyWeaponNames.HeavyUnarmed, itemName))
            {
                return(WeaponType.Unarmed);
            }
            if (TableContains(LightWeaponNames.LightUnarmed, itemName))
            {
                return(WeaponType.Unarmed);
            }
            if (TableContains(FinesseWeaponNames.FinesseUnarmed, itemName))
            {
                return(WeaponType.Unarmed);
            }

            // missile
            if (MissileNames.BowNames.Contains(itemName))
            {
                return(WeaponType.Bow);
            }
            if (MissileNames.CrossbowNames.Contains(itemName))
            {
                return(WeaponType.Crossbow);
            }
            if (MissileNames.AtlatlNames.Contains(itemName))
            {
                return(WeaponType.Atlatl);
            }

            // casters
            if (CasterNames.CasterItems.Contains(itemName))
            {
                return(WeaponType.Caster);
            }

            throw new Exception($"Couldn't find WeaponType for {itemName}");
            //Console.WriteLine($"Couldn't find WeaponType for {itemName}");

            return(WeaponType.Undef);
        }