Example #1
0
        public void GetReadySpellsReturnsEmptyListIfNoSpellsAreReady()
        {
            var cleric  = CharacterTestTemplates.Cleric().WithDivineCasting();
            var casting = cleric.Get <DivineCasting>();

            AssertExtensions.EquivalentLists(new string[] { }, casting.GetReadySpells(6));
        }
Example #2
0
        public void AddsDiceToTheStatisticBasedOnLevelOfCharacter()
        {
            var character = CharacterTestTemplates.Cleric();
            var diceStat  = new DiceStatistic("stat-name", "1d6");

            character.Add(diceStat);
            //Example based on channel energy
            var yaml = @"---
name: stat-name
class: cleric
dice: 1d6
rate: 2
start-level: 1";
            var mod  = new DiceClassLevelModifier(yaml.ParseYaml());

            character.Add(mod);

            Assert.Equal("1d6", diceStat.DisplayString());
            character.SetLevel(2);
            Assert.Equal("1d6", diceStat.DisplayString());
            character.SetLevel(3);
            Assert.Equal("2d6", diceStat.DisplayString());
            character.SetLevel(4);
            Assert.Equal("2d6", diceStat.DisplayString());
            character.SetLevel(12);
            Assert.Equal("6d6", diceStat.DisplayString());
            character.SetLevel(19);
            Assert.Equal("10d6", diceStat.DisplayString());
        }
Example #3
0
        public void PicksPositiveEnergyIfAlignmentIsGood()
        {
            var c = CharacterTestTemplates.Cleric();

            c.Alignment = CharacterAlignment.ChaoticGood;
            c.Add(channel);
            Assert.Equal(ChannelEnergy.POSITIVE_ENERGY, channel.EnergyType);
        }
Example #4
0
        public void PicksNegativeEnergyIfAlignmentIsEvil()
        {
            var c = CharacterTestTemplates.Cleric();

            c.Alignment = CharacterAlignment.LawfulEvil;
            c.Add(channel);
            Assert.Equal(ChannelEnergy.NEGATIVE_ENERGY, channel.EnergyType);
        }
Example #5
0
        public void NeutralCharactersPickSomething()
        {
            var c = CharacterTestTemplates.Cleric();

            c.Alignment = CharacterAlignment.Neutral;
            c.Add(channel);
            Assert.False(string.IsNullOrEmpty(channel.EnergyType));
        }
Example #6
0
        public void DivineCastersKnowAllSpellsAvailableAtTime()
        {
            var cleric    = CharacterTestTemplates.Cleric().WithDivineCasting();
            var casting   = cleric.Get <DivineCasting>();
            var spellList = casting.SpellList;

            AssertCharacter.KnowsSpells(0, spellList.GetAllSpells(0), cleric);
            AssertCharacter.KnowsSpells(1, spellList.GetAllSpells(1), cleric);
        }
Example #7
0
        public void SaveDCandDamageAreAddedToTheLargerComponentPool()
        {
            var character = CharacterTestTemplates.Cleric();

            character.Add(channel);
            Assert.NotNull(character.FindStat("Channel Energy Save DC"));
            Assert.NotNull(character.FindStat("Channel Energy Dice"));
            Assert.NotNull(character.FindStat("Channel Energy Uses Per Day"));
        }
Example #8
0
        public void TestAllDomainsLoadAndAddProperly()
        {
            var domains = GatewayProvider.All <Domain>();

            foreach (var d in domains)
            {
                var character = CharacterTestTemplates.Cleric();
                character.Add(d);
            }
        }
Example #9
0
        public void CanReadySpellsFromListOfAvailableSpells()
        {
            var cleric    = CharacterTestTemplates.Cleric().WithDivineCasting();
            var casting   = cleric.Get <DivineCasting>();
            var spellList = casting.SpellList;

            casting.PrepareSpell(0, "spell 0-1");
            casting.PrepareSpell(1, "spell 1-1");
            AssertExtensions.EquivalentLists(new string[] { "spell 0-1" }, casting.GetReadySpells(0));
            AssertExtensions.EquivalentLists(new string[] { "spell 1-1" }, casting.GetReadySpells(1));
        }
Example #10
0
        public void ChoosesClassCharacterHasIfNotAlreadyChosen()
        {
            var character = CharacterTestTemplates.Cleric();
            character.Add(new FavoredClassToken());

            var step = new ProcessFavoredClassToken();
            step.ExecuteStep(character);
            
            var favored = character.Get<FavoredClass>();
            Assert.True(favored.Qualifies(character.Class));
        }
Example #11
0
        public void ChannelEnergyAddsASpecialAttack()
        {
            var character = CharacterTestTemplates.Cleric();

            character.AbilityScores.SetScore(AbilityScoreTypes.Charisma, 12);
            character.SetLevel(4);
            character.Add(channel);
            Assert.Equal(channel.Damage.ToString(), "1d6");
            var channelAttack = character.Offense.Attacks().First(x => x.Name.Contains("Channel"));

            Assert.NotNull(channelAttack);
        }
Example #12
0
        public DomainCastingTests()
        {
            cleric = CharacterTestTemplates.Cleric();
            var domain  = Domain.CreateForTesting("air", new string[] { "air-1", "air-2" });
            var domain2 = Domain.CreateForTesting("earth", new string[] { "earth-1", "earth-2" });
            var config  = new MemoryStore();

            config.SetValue("casting-ability", "wisdom");
            domainCasting = new DomainCasting(config);
            cleric.Add(domain);
            cleric.Add(domain2);
            cleric.Add(domainCasting);
        }
Example #13
0
        public void SpellsWithADescriptorOfOpposingAlignmentAreNotInAvailableList()
        {
            var caster = CharacterTestTemplates.Cleric();

            caster.Alignment = CharacterAlignment.LawfulEvil;
            var rule = new CannotCastSpellsOfOpposingAlignment();

            caster.Add(rule);

            var spell     = new Spell("Good One", "healing", new string[] { "good" });
            var evilSpell = new Spell("Good One", "healing", new string[] { "evil" });

            Assert.False(rule.CanCastSpell(spell));
            Assert.True(rule.CanCastSpell(evilSpell));
        }
Example #14
0
        public void ChoosesANumberOfDomainsBasedOnConfiguration()
        {
            var configure = new MemoryStore();

            configure.SetValue("count", "2");
            var selectDomains = new SelectDomains(configure);

            var character = CharacterTestTemplates.Cleric();

            selectDomains.ExecuteStep(character);
            var domains = character.GetAll <Domain>();

            Assert.Equal(domains.Count(), 2);
            Assert.NotEqual(domains.ElementAt(0), domains.ElementAt(1));
        }
Example #15
0
        public void CalculatesTheAlignmentAndStrengthBasedOnCharacterLevelAndAlignment()
        {
            var cleric = CharacterTestTemplates.Cleric();

            cleric.Alignment = CharacterAlignment.ChaoticGood;
            var aura = new AuraOfAlignment();

            cleric.Add(aura);
            Assert.Equal("Faint", aura.Strength);
            cleric.SetLevel(2);
            Assert.Equal("Moderate", aura.Strength);
            cleric.SetLevel(5);
            Assert.Equal("Strong", aura.Strength);
            cleric.SetLevel(15);
            Assert.Equal("Overwhelming", aura.Strength);
            Assert.Equal("Aura (Overwhelming Chaotic Good)", aura.DisplayString());
        }
Example #16
0
        public void FindsDomainsAssociatedWithCharacterAndAddsThoseSpells()
        {
            var character = CharacterTestTemplates.Cleric();
            var domain    = Domain.CreateForTesting("Air", new string[] { "air 1", "air 2" });

            character.Add(domain);

            var configure = new MemoryStore();

            configure.SetValue("casting-ability", "wisdom");

            var addSpells = new AddDomainSpells(configure);

            addSpells.ExecuteStep(character);

            var spellCasting = character.Get <DomainCasting>();

            Assert.NotNull(spellCasting);
        }
Example #17
0
        public void ProcessesLevelsOnLevelUp()
        {
            var yaml      = @"---
name: Feature
levels:
  - level: 1
    name: l1
    attributes:
      - attribute:
        name: Some attribute
  - level: 2
    name: l2
    attributes:
      - attribute:
        name: Not There";
            var feature   = new LevelingClassFeature(yaml.ParseYaml());
            var character = CharacterTestTemplates.Cleric();

            character.Add(feature);
            Assert.NotNull(character.Components.GetAll <Feature>().First(x => x.Name == "Some attribute"));
            Assert.Null(character.Components.GetAll <Feature>().FirstOrDefault(x => x.Name == "Not There"));
        }
Example #18
0
        public void IfMultipleTokensAreAvailableTheNextOneShouldChooseSomethingDifferent()
        {
            var classes = new Class[] {
                Class.CreateForTesting("Cleric", SilverNeedle.Dice.DiceSides.d8),
                Class.CreateForTesting("Bard", SilverNeedle.Dice.DiceSides.d6)
            };

            var cleric = CharacterTestTemplates.Cleric();
            cleric.Add(new FavoredClassToken());
            cleric.Add(new FavoredClassToken());

            var step = new ProcessFavoredClassToken(EntityGateway<Class>.LoadFromList(classes));
            step.ExecuteStep(cleric);
            
            var allFavored = cleric.GetAll<FavoredClass>();
            AssertExtensions.EquivalentLists(
                new string[] { "Cleric", "Bard" },
                allFavored.Select(x => x.ClassName)
            );


        }