Exemplo n.º 1
0
 public static List <BonusRef> GetBonusesApplyingTo(Guid applyTo, BonusApplyToType type, List <BonusRef> bonuses)
 {
     return
         (bonuses.Where(
              x =>
              x.Bonues.ApplyTo != null && x.Bonues.ApplyTo.ApplyToType == type &&
              (x.Bonues.ApplyTo.ApplyToAll || x.Bonues.ApplyTo.ApplyToGuid == applyTo)).ToList());
 }
Exemplo n.º 2
0
        public List <ElementId> GetSubItemsFromBonusApplyToType(BonusApplyToType type)
        {
            switch (type)
            {
            case BonusApplyToType.BaseAttack:
                return(new List <ElementId>());

            case BonusApplyToType.Ability:
                return(new List <ElementId>());

            case BonusApplyToType.Ac:
                return(new List <ElementId>(new[] { new ElementId {
                                                        ID = Configuration.AcFlatFootedId, Name = "Flat footed only"
                                                    }, new ElementId {
                                                        ID = Configuration.AcTouchId, Name = "Touch only"
                                                    }, }));

            case BonusApplyToType.Class:
                return(new List <ElementId>(new[]
                {
                    new ElementId {
                        ID = Configuration.SpellPrDayId, Name = "Spell Pr Day"
                    },
                    new ElementId {
                        ID = Configuration.ExistingCasterLevelDivineId, Name = "Existing caster level (divine)"
                    },
                    new ElementId {
                        ID = Configuration.ExistingCasterLevelArcaneId, Name = "Existing caster level (arcane)"
                    },
                }));

            case BonusApplyToType.DamageRecuction:
                return(new List <ElementId>());

            case BonusApplyToType.Grapple:
                return(new List <ElementId>());

            case BonusApplyToType.HitPoints:
                return(new List <ElementId>());

            case BonusApplyToType.Initiativ:
                return(new List <ElementId>());

            case BonusApplyToType.Item:
                return(new List <ElementId>(new[] { new ElementId {
                                                        ID = Configuration.WeightReductionInProcentage, Name = "Weight Reduction In Procentage"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.CostIncreaseInGold, Name = "Cost Increase In Gold"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.CostIncreaseInGoldPrLbWeight, Name = "Cost Increase In Gold pr lb weight"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.ArmorCheckPeneltyReduction, Name = "Armor Check Penelty Reduction"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.ExtraAC, Name = "Extra AC"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.MaxDexBonus, Name = "Max Dex Bonus"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.MaxSpeed, Name = "Max Speed"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.ArcaneSpellFailure, Name = "Arcane Spell Failure"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.Damage, Name = "Damage (All items)"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.DamageWeapon, Name = "Damage (Weapons only)"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.DamageShield, Name = "Damage (Shield only)"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.DamageArmor, Name = "Damage (Armor only)"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.DamageMisc, Name = "Damage (Misc only)"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.DamageUnarmed, Name = "Damage (Unarmed only)"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.AttackBonues, Name = "Attack bonues"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.CritRange, Name = "Crit Range (multiplier)"
                                                    },
                                                    new ElementId {
                                                        ID = Configuration.RangeIncrement, Name = "Range Increment (ft)"
                                                    }, }).OrderBy(x => x.Name).ToList());

            case BonusApplyToType.Race:
                return(new List <ElementId>(new[]
                {
                    new ElementId {
                        ID = Configuration.SizeId, Name = "Size Category"
                    },
                    new ElementId {
                        ID = Configuration.SpeedId, Name = "Speed"
                    },
                }).OrderBy(x => x.Name).ToList());

            case BonusApplyToType.Round:
                return(new List <ElementId>());

            case BonusApplyToType.Save:
                return(new List <ElementId>());

            case BonusApplyToType.Skill:
                var list = new List <ElementId>(new[]
                {
                    new ElementId {
                        ID = Configuration.SkillPointPrLevel, Name = "Skill point pr level"
                    },
                }).OrderBy(x => x.Name).ToList();
                list.AddRange(GetAll <Ability>().Cast <ElementId>().Select(x => new ElementId
                {
                    ID          = x.ID,
                    Description = x.Description,
                    Name        = "Skill based on " + x.Name
                }).ToList());
                return(list);

            case BonusApplyToType.SpecialAbility:
                return(new List <ElementId>(new[]
                {
                    new ElementId {
                        ID = Configuration.Feat, Name = "Feat"
                    },
                }).OrderBy(x => x.Name).ToList());

            case BonusApplyToType.Spell:
                return(new List <ElementId>());

            case BonusApplyToType.SpellSchool:
                return(new List <ElementId>());

            case BonusApplyToType.SpellResistance:
                return(new List <ElementId>());

            default:
                throw new NotImplementedException("BonusApplyToType not supported");
            }
        }
Exemplo n.º 3
0
        public List <ElementId> GetItemsFromBonusApplyToType(BonusApplyToType type)
        {
            switch (type)
            {
            case BonusApplyToType.BaseAttack:
                return(new List <ElementId>(new[] { new ElementId
                                                    {
                                                        ID = Configuration.BabId,
                                                        Name = "Base Attack",
                                                    } }));

            case BonusApplyToType.Ability:
                return(GetAll <Ability>().Cast <ElementId>().ToList());

            case BonusApplyToType.Ac:
                return(new List <ElementId>(new [] { new ElementId
                                                     {
                                                         ID = Configuration.AcId,
                                                         Name = "AC",
                                                     } }));

            case BonusApplyToType.Class:
                return(GetAll <ClassBase>().Cast <ElementId>().ToList());

            case BonusApplyToType.DamageRecuction:
                return(new List <ElementId>(new[] { new ElementId {
                                                        ID = Configuration.DamageRecuctionId, Name = "Damage Recuction"
                                                    }, }));

            case BonusApplyToType.Grapple:
                return(new List <ElementId>(new[] { new ElementId {
                                                        ID = Configuration.GrappleId, Name = "Grapple"
                                                    }, }));

            case BonusApplyToType.HitPoints:
                return(new List <ElementId>(new[]
                {
                    new ElementId {
                        ID = Configuration.HitPointsId, Name = "Hit Points"
                    },
                    new ElementId {
                        ID = Configuration.HitPointsDmg, Name = "Damage"
                    },
                    new ElementId {
                        ID = Configuration.HitPointsDmgNl, Name = "Non lethal damage"
                    },
                    new ElementId {
                        ID = Configuration.HitPointsHeal, Name = "Heal"
                    },
                }));

            case BonusApplyToType.Initiativ:
                return(new List <ElementId>(new[] { new ElementId {
                                                        ID = Configuration.InitiativId, Name = "Initiativ"
                                                    }, }));

            case BonusApplyToType.Item:
                return(GetAll <ItemBase>().Cast <ElementId>().ToList());

            case BonusApplyToType.Race:
                return(GetAll <Race>().Cast <ElementId>().ToList());

            case BonusApplyToType.Round:
                return(new List <ElementId>(new[] { new ElementId
                                                    {
                                                        ID = Configuration.MoveAction,
                                                        Name = "Move Action",
                                                    },
                                                    new ElementId
                                                    {
                                                        ID = Configuration.StandardAction,
                                                        Name = "Standard Action",
                                                    },
                                                    new ElementId
                                                    {
                                                        ID = Configuration.FullRoundAction,
                                                        Name = "Full Round Action",
                                                    }, }));

            case BonusApplyToType.Save:
                return(GetAll <SaveType>().Cast <ElementId>().ToList());

            case BonusApplyToType.Skill:
                return(GetAll <Skill>().Cast <ElementId>().ToList());

            case BonusApplyToType.SpecialAbility:
                return(GetAll <SpecialAbility>().Cast <ElementId>().ToList());

            case BonusApplyToType.Spell:
                return(GetAll <Spell>().Cast <ElementId>().ToList());

            case BonusApplyToType.SpellSchool:
                return(GetAll <SpellSchool>().Cast <ElementId>().ToList());

            case BonusApplyToType.SpellResistance:
                return(new List <ElementId>(new[] { new ElementId {
                                                        ID = Configuration.SpellResistanceId, Name = "Spell Resistance"
                                                    }, }));

            default:
                throw new NotImplementedException("BonusApplyToType not supported");
            }
        }