Exemple #1
0
        private IEnumerable <SpellQuantity> GetSpellsPerDay(string caster, int casterLevel, Ability castingAbility, IEnumerable <string> domains)
        {
            var spellsForClass  = typeAndAmountSelector.Select(TableNameConstants.TypeAndAmount.SpellsPerDay, $"{caster}:{casterLevel}");
            var maxSpellLevel   = castingAbility.FullScore - 10;
            var spellsForCaster = spellsForClass.Where(s => Convert.ToInt32(s.Type) <= maxSpellLevel);

            var spellsPerDay = new List <SpellQuantity>();

            foreach (var typeAndAmount in spellsForCaster)
            {
                var spellQuantity = new SpellQuantity();
                spellQuantity.Level          = Convert.ToInt32(typeAndAmount.Type);
                spellQuantity.Quantity       = typeAndAmount.Amount;
                spellQuantity.Source         = caster;
                spellQuantity.HasDomainSpell = domains.Any() && spellQuantity.Level > 0;

                if (spellQuantity.Level > 0 && spellQuantity.Level <= castingAbility.Modifier)
                {
                    spellQuantity.BonusSpells = (castingAbility.Modifier - spellQuantity.Level) / 4 + 1;
                }

                spellsPerDay.Add(spellQuantity);
            }

            return(spellsPerDay);
        }
Exemple #2
0
        private IEnumerable <Spell> GetRandomKnownSpellsForLevel(string creature, SpellQuantity spellQuantity, string caster, Alignment alignment, IEnumerable <string> domains)
        {
            var spellNames  = GetSpellNamesForCaster(creature, caster, alignment, spellQuantity.Level, domains);
            var knownSpells = new HashSet <Spell>();

            if (spellQuantity.Quantity >= spellNames.Count())
            {
                foreach (var spellName in spellNames)
                {
                    var spell = BuildSpell(spellName, spellQuantity.Level, caster);
                    knownSpells.Add(spell);
                }

                return(knownSpells);
            }

            while (spellQuantity.Quantity > knownSpells.Count)
            {
                var spellName = collectionsSelector.SelectRandomFrom(spellNames);
                var spell     = BuildSpell(spellName, spellQuantity.Level, caster);
                knownSpells.Add(spell);
            }

            var specialistSpellsForLevel = GetSpellNamesForFields(domains, spellQuantity.Level);
            var knownSpellNames          = knownSpells.Select(s => s.Name);
            var unknownSpecialistSpells  = specialistSpellsForLevel.Except(knownSpellNames);

            if (spellQuantity.HasDomainSpell && unknownSpecialistSpells.Any())
            {
                while (spellQuantity.Quantity + 1 > knownSpells.Count)
                {
                    var spellName = collectionsSelector.SelectRandomFrom(specialistSpellsForLevel);
                    var spell     = BuildSpell(spellName, spellQuantity.Level, caster);

                    knownSpells.Add(spell);
                }
            }
            else if (spellQuantity.HasDomainSpell)
            {
                while (spellQuantity.Quantity + 1 > knownSpells.Count)
                {
                    var spellName = collectionsSelector.SelectRandomFrom(spellNames);
                    var spell     = BuildSpell(spellName, spellQuantity.Level, caster);
                    knownSpells.Add(spell);
                }
            }

            return(knownSpells);
        }
Exemple #3
0
        private IEnumerable <SpellQuantity> GetKnownSpellQuantities(string caster, int casterLevel, Ability castingAbility, IEnumerable <string> domains)
        {
            var spellsForClass = typeAndAmountSelector.Select(TableNameConstants.TypeAndAmount.KnownSpells, $"{caster}:{casterLevel}");
            var maxSpellLevel  = castingAbility.FullScore - Ability.DefaultScore;
            var spellQuantitiesForCharacter = spellsForClass.Where(s => Convert.ToInt32(s.Type) <= maxSpellLevel);

            var spellQuantities = new List <SpellQuantity>();

            foreach (var typeAndAmount in spellQuantitiesForCharacter)
            {
                var spellQuantity = new SpellQuantity();
                spellQuantity.Level          = Convert.ToInt32(typeAndAmount.Type);
                spellQuantity.HasDomainSpell = domains.Any() && spellQuantity.Level > 0;
                spellQuantity.Quantity       = typeAndAmount.Amount;

                spellQuantities.Add(spellQuantity);
            }

            return(spellQuantities);
        }
Exemple #4
0
        private IEnumerable <Spell> GetPreparedSpellsForLevel(SpellQuantity spellQuantity, IEnumerable <Spell> knownSpells, IEnumerable <string> domains)
        {
            var preparedSpells      = new List <Spell>();
            var knownSpellsForLevel = knownSpells.Where(s => s.Level == spellQuantity.Level && s.Source == spellQuantity.Source);

            while (spellQuantity.Quantity + spellQuantity.BonusSpells > preparedSpells.Count)
            {
                var spell = collectionsSelector.SelectRandomFrom(knownSpellsForLevel);
                preparedSpells.Add(spell);
            }

            if (spellQuantity.HasDomainSpell)
            {
                var specialistSpells         = GetSpellNamesForFields(domains);
                var specialistSpellsForLevel = knownSpellsForLevel.Where(s => specialistSpells.Contains(s.Name));
                var spell = collectionsSelector.SelectRandomFrom(specialistSpellsForLevel);

                preparedSpells.Add(spell);
            }

            return(preparedSpells);
        }
Exemple #5
0
 public void Setup()
 {
     spellQuantity = new SpellQuantity();
 }