Example #1
0
        public static bool CheckMatch(VendorItem vitem, SearchCriteria searchCriteria)
        {
            if (vitem == null)
            {
                return(false);
            }

            Item item = vitem.Item;

            if (searchCriteria.MinPrice > -1 && vitem.Price < searchCriteria.MinPrice)
            {
                return(false);
            }

            if (searchCriteria.MaxPrice > -1 && vitem.Price > searchCriteria.MaxPrice)
            {
                return(false);
            }

            if (!String.IsNullOrEmpty(searchCriteria.SearchName))
            {
                string name = GetItemName(item);

                if (name == null)
                {
                    return(false); // TODO? REturn null names?
                }

                if (!CheckKeyword(searchCriteria.SearchName, item) && name.ToLower().IndexOf(searchCriteria.SearchName.ToLower()) < 0)
                {
                    return(false);
                }
            }

            if (searchCriteria.SearchType != Layer.Invalid && searchCriteria.SearchType != item.Layer)
            {
                return(false);
            }

            if (searchCriteria.Details.Count == 0)
            {
                return(true);
            }

            foreach (SearchDetail detail in searchCriteria.Details)
            {
                object o     = detail.Attribute;
                int    value = detail.Value;

                if (value == 0)
                {
                    value = 1;
                }

                if (o is AosAttribute)
                {
                    AosAttributes attrs = RunicReforging.GetAosAttributes(item);

                    if (attrs == null || attrs[(AosAttribute)o] < value)
                    {
                        return(false);
                    }
                }
                else if (o is AosWeaponAttribute)
                {
                    AosWeaponAttributes attrs = RunicReforging.GetAosWeaponAttributes(item);

                    if ((AosWeaponAttribute)o == AosWeaponAttribute.MageWeapon)
                    {
                        if (attrs == null || attrs[(AosWeaponAttribute)o] == 0 || attrs[(AosWeaponAttribute)o] > Math.Max(0, 30 - value))
                        {
                            return(false);
                        }
                    }
                    else if (attrs == null || attrs[(AosWeaponAttribute)o] < value)
                    {
                        return(false);
                    }
                }
                else if (o is SAAbsorptionAttribute)
                {
                    SAAbsorptionAttributes attrs = RunicReforging.GetSAAbsorptionAttributes(item);

                    if (attrs == null || attrs[(SAAbsorptionAttribute)o] < value)
                    {
                        return(false);
                    }
                }
                else if (o is AosArmorAttribute)
                {
                    AosArmorAttributes attrs = RunicReforging.GetAosArmorAttributes(item);

                    if (attrs == null || attrs[(AosArmorAttribute)o] < value)
                    {
                        return(false);
                    }
                }
                else if (o is SkillName)
                {
                    if (detail.Category != Category.RequiredSkill)
                    {
                        AosSkillBonuses skillbonuses = RunicReforging.GetAosSkillBonuses(item);

                        if (skillbonuses != null)
                        {
                            bool hasSkill = false;

                            for (int i = 0; i < 5; i++)
                            {
                                SkillName check;
                                double    bonus;

                                if (skillbonuses.GetValues(i, out check, out bonus) && check == (SkillName)o && bonus >= value)
                                {
                                    hasSkill = true;
                                    break;
                                }
                            }

                            if (!hasSkill)
                            {
                                return(false);
                            }
                        }
                        else if (item is SpecialScroll && value >= 105)
                        {
                            if (((SpecialScroll)item).Skill != (SkillName)o || ((SpecialScroll)item).Value < value)
                            {
                                return(false);
                            }
                        }
                        else
                        {
                            return(false);
                        }
                    }
                    else if (!(item is BaseWeapon) || ((BaseWeapon)item).DefSkill != (SkillName)o)
                    {
                        return(false);
                    }
                }
                else if (o is SlayerName && (!(item is ISlayer) || ((((ISlayer)item).Slayer != (SlayerName)o && ((ISlayer)item).Slayer2 != (SlayerName)o))))
                {
                    return(false);
                }
                else if (o is TalismanSlayerName && (!(item is BaseTalisman) || ((BaseTalisman)item).Slayer != (TalismanSlayerName)o))
                {
                    return(false);
                }
                else if (o is AosElementAttribute)
                {
                    if (item is BaseWeapon)
                    {
                        BaseWeapon wep = item as BaseWeapon;

                        if (detail.Category == Category.DamageType)
                        {
                            int phys, fire, cold, pois, nrgy, chaos, direct;
                            wep.GetDamageTypes(null, out phys, out fire, out cold, out pois, out nrgy, out chaos, out direct);

                            switch ((AosElementAttribute)o)
                            {
                            case AosElementAttribute.Physical: if (phys < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Fire: if (fire < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Cold: if (cold < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Poison: if (pois < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Energy: if (nrgy < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Chaos: if (chaos < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Direct: if (direct < value)
                                {
                                    return(false);
                                }
                                break;
                            }
                        }
                        else
                        {
                            switch ((AosElementAttribute)o)
                            {
                            case AosElementAttribute.Physical:
                                if (wep.WeaponAttributes.ResistPhysicalBonus < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Fire:
                                if (wep.WeaponAttributes.ResistFireBonus < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Cold:
                                if (wep.WeaponAttributes.ResistColdBonus < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Poison:
                                if (wep.WeaponAttributes.ResistPoisonBonus < value)
                                {
                                    return(false);
                                }
                                break;

                            case AosElementAttribute.Energy:
                                if (wep.WeaponAttributes.ResistEnergyBonus < value)
                                {
                                    return(false);
                                }
                                break;
                            }
                        }
                    }
                    else if (item is BaseArmor && detail.Category == Category.Resists)
                    {
                        BaseArmor armor = item as BaseArmor;

                        switch ((AosElementAttribute)o)
                        {
                        case AosElementAttribute.Physical:
                            if (armor.PhysicalResistance < value)
                            {
                                return(false);
                            }
                            break;

                        case AosElementAttribute.Fire:
                            if (armor.FireResistance < value)
                            {
                                return(false);
                            }
                            break;

                        case AosElementAttribute.Cold:
                            if (armor.ColdResistance < value)
                            {
                                return(false);
                            }
                            break;

                        case AosElementAttribute.Poison:
                            if (armor.PoisonResistance < value)
                            {
                                return(false);
                            }
                            break;

                        case AosElementAttribute.Energy:
                            if (armor.EnergyResistance < value)
                            {
                                return(false);
                            }
                            break;
                        }
                    }
                    else if (detail.Category != Category.DamageType)
                    {
                        AosElementAttributes attrs = RunicReforging.GetElementalAttributes(item);

                        if (attrs == null || attrs[(AosElementAttribute)o] < value)
                        {
                            return(false);
                        }
                    }
                    else
                    {
                        return(false);
                    }
                }
                else if (o is Misc)
                {
                    switch ((Misc)o)
                    {
                    case Misc.ExcludeFel: break;

                    case Misc.GargoyleOnly:
                        if (!IsGargoyle(item))
                        {
                            return(false);
                        }
                        break;

                    case Misc.NotGargoyleOnly:
                        if (IsGargoyle(item))
                        {
                            return(false);
                        }
                        break;

                    case Misc.ElvesOnly:
                        if (!IsElf(item))
                        {
                            return(false);
                        }
                        break;

                    case Misc.NotElvesOnly:
                        if (IsElf(item))
                        {
                            return(false);
                        }
                        break;

                    case Misc.FactionItem:
                        if (!(item is Server.Factions.IFactionItem))
                        {
                            return(false);
                        }
                        break;

                    case Misc.PromotionalToken:
                        if (!(item is PromotionalToken))
                        {
                            return(false);
                        }
                        break;

                    case Misc.Cursed:
                        if (item.LootType != LootType.Cursed)
                        {
                            return(false);
                        }
                        break;

                    case Misc.NotCursed:
                        if (item.LootType == LootType.Cursed)
                        {
                            return(false);
                        }
                        break;

                    case Misc.CannotRepair:
                        if (CheckCanRepair(item))
                        {
                            return(false);
                        }
                        break;

                    case Misc.NotCannotBeRepaired:
                        if (!CheckCanRepair(item))
                        {
                            return(false);
                        }
                        break;

                    case Misc.Brittle:
                        NegativeAttributes neg2 = RunicReforging.GetNegativeAttributes(item);
                        if (neg2 == null || neg2.Brittle == 0)
                        {
                            return(false);
                        }
                        break;

                    case Misc.NotBrittle:
                        NegativeAttributes neg3 = RunicReforging.GetNegativeAttributes(item);
                        if (neg3 != null && neg3.Brittle > 0)
                        {
                            return(false);
                        }
                        break;

                    case Misc.Antique:
                        NegativeAttributes neg4 = RunicReforging.GetNegativeAttributes(item);
                        if (neg4 == null || neg4.Antique == 0)
                        {
                            return(false);
                        }
                        break;

                    case Misc.NotAntique:
                        NegativeAttributes neg5 = RunicReforging.GetNegativeAttributes(item);
                        if (neg5 != null && neg5.Antique > 0)
                        {
                            return(false);
                        }
                        break;
                    }
                }
                else if (o is string)
                {
                    string str = o as string;

                    if (str == "WeaponVelocity" && (!(item is BaseRanged) || ((BaseRanged)item).Velocity < value))
                    {
                        return(false);
                    }

                    /*if (str == "BalancedWeapon" && (!(item is BaseRanged) || !((BaseRanged)item).Balanced))
                     *  return false;*/

                    if (str == "SearingWeapon" && (!(item is BaseWeapon) || !((BaseWeapon)item).SearingWeapon))
                    {
                        return(false);
                    }

                    if (str == "ArtifactRarity")
                    {
                        bool isarty = false;

                        if (item is BaseWeapon && ((BaseWeapon)item).ArtifactRarity > value)
                        {
                            isarty = true;
                        }

                        else if (item is BaseArmor && ((BaseArmor)item).ArtifactRarity > value)
                        {
                            isarty = true;
                        }

                        else if (item is BaseClothing && ((BaseClothing)item).ArtifactRarity > value)
                        {
                            isarty = true;
                        }

                        else if (item is BaseJewel && ((BaseJewel)item).ArtifactRarity > value)
                        {
                            isarty = true;
                        }

                        else if (item is SimpleArtifact && ((SimpleArtifact)item).ArtifactRarity > value)
                        {
                            isarty = true;
                        }

                        else if (item is Artifact && ((Artifact)item).ArtifactRarity > value)
                        {
                            isarty = true;
                        }

                        if (!isarty)
                        {
                            return(false);
                        }
                    }
                }
            }

            return(true);
        }