public void AllImmutableRequirementsMet()
{
selection.RequiredBaseAttack = 2;
selection.RequiredStats["stat"] = 16;
stats["stat"] = new Stat("stat");
stats["stat"].Value = 16;
stats["other stat"] = new Stat("other stat");
stats["other stat"].Value = 15;
selection.RequiredSkillRanks["class skill"] = 5;
selection.RequiredSkillRanks["cross-class skill"] = 5;
skills["class skill"] = new Skill("class skill", stats["stat"], 10);
skills["class skill"].Ranks = 10;
skills["class skill"].ClassSkill = false;
skills["other class skill"] = new Skill("other class skill", stats["stat"], 10);
skills["other class skill"].Ranks = 9;
skills["other class skill"].ClassSkill = false;
skills["cross-class skill"] = new Skill("cross-class skill", stats["stat"], 10);
skills["cross-class skill"].Ranks = 5;
skills["cross-class skill"].ClassSkill = true;
skills["other cross-class skill"] = new Skill("other cross-class skill", stats["stat"], 10);
skills["other cross-class skill"].Ranks = 4;
skills["other cross-class skill"].ClassSkill = true;
selection.RequiredCharacterClasses["class name"] = 1;
characterClass.Name = "class name";
characterClass.Level = 1;
var met = selection.ImmutableRequirementsMet(2, stats, skills, characterClass);
Assert.That(met, Is.True);
}
public void RequirementsMetIfAnyMinimumStatIsMet()
{
selection.MinimumStats["stat"] = 9266;
selection.MinimumStats["stat 2"] = 600;
stats["stat 2"] = new Stat("stat 2");
stats["stat 2"].Value = 600;
var met = selection.RequirementsMet(race, 4, stats);
Assert.That(met, Is.True);
}
public void ApplyFeatThatGrantSkillBonusesToSkills()
{
var skills = new Dictionary<string, Skill>();
var baseStat = new Stat("base stat");
skills["skill 1"] = new Skill("skill 1", baseStat, 1);
skills["skill 1"].Bonus = 1;
skills["skill 2"] = new Skill("skill 2", baseStat, 1);
skills["skill 2"].Bonus = 2;
skills["skill 3"] = new Skill("skill 3", baseStat, 1);
skills["skill 3"].Bonus = 3;
skills["skill 4"] = new Skill("skill 4", baseStat, 1);
skills["skill 4"].Bonus = 4;
mockSkillsGenerator.Setup(g => g.GenerateWith(characterClass, race, stats)).Returns(skills);
var feats = new List<Feat>();
feats.Add(new Feat());
feats.Add(new Feat());
feats.Add(new Feat());
feats[0].Name = "feat1";
feats[0].Power = 1;
feats[1].Name = "feat2";
feats[1].Power = 2;
feats[2].Name = "feat3";
feats[2].Power = 3;
mockFeatsGenerator.Setup(g => g.GenerateWith(characterClass, race, stats, skills, baseAttack)).Returns(feats);
var featGrantingSkillBonuses = new[] { "feat3", "feat1" };
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.FeatGroups, FeatConstants.SkillBonus))
.Returns(featGrantingSkillBonuses);
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.SkillGroups, "feat1")).Returns(new[] { "skill 1" });
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.SkillGroups, "feat3")).Returns(new[] { "skill 2", "skill 4" });
var ability = abilitiesGenerator.GenerateWith(characterClass, race, stats, baseAttack);
Assert.That(ability.Skills["skill 1"].Bonus, Is.EqualTo(2));
Assert.That(ability.Skills["skill 2"].Bonus, Is.EqualTo(5));
Assert.That(ability.Skills["skill 3"].Bonus, Is.EqualTo(3));
Assert.That(ability.Skills["skill 4"].Bonus, Is.EqualTo(7));
}
public void CircumstantialBonusIsNotOverwritten()
{
var skills = new Dictionary<string, Skill>();
var baseStat = new Stat("base stat");
skills["skill 1"] = new Skill("skill 1", baseStat, 1);
skills["skill 1"].Bonus = 1;
skills["skill 2"] = new Skill("skill 2", baseStat, 1);
skills["skill 2"].Bonus = 2;
mockSkillsGenerator.Setup(g => g.GenerateWith(characterClass, race, stats)).Returns(skills);
var feats = new List<Feat>();
feats.Add(new Feat());
feats.Add(new Feat());
feats[0].Name = "feat1";
feats[0].Foci = new[] { "skill 1 (with qualifiers)", "skill 2" };
feats[0].Power = 1;
feats[1].Name = "feat2";
feats[1].Foci = new[] { "skill 1" };
feats[1].Power = 1;
mockFeatsGenerator.Setup(g => g.GenerateWith(characterClass, race, stats, skills, baseAttack)).Returns(feats);
var featGrantingSkillBonuses = new[] { "feat1", "feat2" };
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.FeatGroups, FeatConstants.SkillBonus))
.Returns(featGrantingSkillBonuses);
var ability = abilitiesGenerator.GenerateWith(characterClass, race, stats, baseAttack);
Assert.That(ability.Skills["skill 1"].CircumstantialBonus, Is.True);
Assert.That(ability.Skills["skill 2"].CircumstantialBonus, Is.False);
}
public void OnlyApplySkillFeatToSkillsIfSkillFocusIsPurelySkill()
{
var skills = new Dictionary<string, Skill>();
var baseStat = new Stat("base stat");
skills["skill 1"] = new Skill("skill 1", baseStat, 1);
skills["skill 1"].Bonus = 1;
mockSkillsGenerator.Setup(g => g.GenerateWith(characterClass, race, stats)).Returns(skills);
var feats = new List<Feat>();
feats.Add(new Feat());
feats[0].Name = "feat1";
feats[0].Foci = new[] { "skill 1 (with qualifiers)", "non-skill focus" };
feats[0].Power = 1;
var featGrantingSkillBonuses = new[] { "feat2", "feat1" };
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.FeatGroups, FeatConstants.SkillBonus))
.Returns(featGrantingSkillBonuses);
mockFeatsGenerator.Setup(g => g.GenerateWith(characterClass, race, stats, skills, baseAttack)).Returns(feats);
var ability = abilitiesGenerator.GenerateWith(characterClass, race, stats, baseAttack);
Assert.That(ability.Skills["skill 1"].Bonus, Is.EqualTo(1));
}
public void Setup()
{
baseStat = new Stat("base stat");
skill = new Skill("skill name", baseStat, 90210);
}
public void StatRequirementsNotMet()
{
selection.RequiredStats["stat"] = 16;
stats["stat"].Value = 15;
stats["other stat"] = new Stat("other stat");
stats["other stat"].Value = 157;
var met = selection.ImmutableRequirementsMet(1, stats, skills, characterClass);
Assert.That(met, Is.False);
}
public void Setup()
{
mockAdjustmentsSelector = new Mock<IAdjustmentsSelector>();
mockCollectionsSelector = new Mock<ICollectionsSelector>();
mockBooleanPercentileSelector = new Mock<IBooleanPercentileSelector>();
spellsGenerator = new SpellsGenerator(mockCollectionsSelector.Object, mockAdjustmentsSelector.Object, mockBooleanPercentileSelector.Object);
characterClass = new CharacterClass();
spellcasters = new List<string>();
stats = new Dictionary<string, Stat>();
spellsPerDayForClass = new Dictionary<string, int>();
spellsKnownForClass = new Dictionary<string, int>();
classSpells = new List<string>();
spellLevels = new Dictionary<string, int>();
divineCasters = new List<string>();
characterClass.Name = "class name";
characterClass.Level = 9266;
spellcasters.Add(characterClass.Name);
spellcasters.Add("other class");
spellsPerDayForClass["0"] = 90210;
spellsPerDayForClass["1"] = 42;
spellsKnownForClass["0"] = 2;
spellsKnownForClass["1"] = 1;
stats["stat"] = new Stat("stat");
stats["stat"].Value = 11;
stats["other stat"] = new Stat("other stat");
stats["other stat"].Value = 11;
classSpells.Add("spell 1");
classSpells.Add("spell 2");
classSpells.Add("spell 3");
classSpells.Add("spell 4");
spellLevels[classSpells[0]] = 0;
spellLevels[classSpells[1]] = 0;
spellLevels[classSpells[2]] = 1;
spellLevels[classSpells[3]] = 1;
divineCasters.Add("other divine class");
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, GroupConstants.Spellcasters)).Returns(spellcasters);
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, SpellConstants.Sources.Divine)).Returns(divineCasters);
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.StatGroups, characterClass.Name + GroupConstants.Spellcasters)).Returns(new[] { "stat" });
var tableName = string.Format(TableNameConstants.Formattable.Adjustments.LevelXCLASSSpellsPerDay, characterClass.Level, characterClass.Name);
mockAdjustmentsSelector.Setup(s => s.SelectFrom(tableName)).Returns(spellsPerDayForClass);
tableName = string.Format(TableNameConstants.Formattable.Adjustments.LevelXCLASSKnownSpells, characterClass.Level, characterClass.Name);
mockAdjustmentsSelector.Setup(s => s.SelectFrom(tableName)).Returns(spellsKnownForClass);
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.SpellGroups, characterClass.Name)).Returns(classSpells);
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.SpellGroups, "domain 1")).Returns(new[] { classSpells[0], classSpells[2] });
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.SpellGroups, "domain 2")).Returns(new[] { classSpells[1], classSpells[3] });
tableName = string.Format(TableNameConstants.Formattable.Adjustments.CLASSSpellLevels, characterClass.Name);
mockAdjustmentsSelector.Setup(s => s.SelectFrom(tableName)).Returns(spellLevels);
var index = 0;
mockCollectionsSelector.Setup(s => s.SelectRandomFrom(It.IsAny<IEnumerable<string>>())).Returns((IEnumerable<string> c) => c.ElementAt(index++ % c.Count()));
mockCollectionsSelector.Setup(s => s.SelectRandomFrom(It.IsAny<IEnumerable<Spell>>())).Returns((IEnumerable<Spell> c) => c.ElementAt(index++ % c.Count()));
}
public Skill(string name, Stat baseStat, int rankCap)
{
Name = name;
BaseStat = baseStat;
RankCap = rankCap;
}
private int GetTotalSkillPoints(CharacterClass characterClass, Stat intelligence, Race race)
{
var pointsTable = adjustmentsSelector.SelectFrom(TableNameConstants.Set.Adjustments.SkillPointsForClasses);
var perLevel = pointsTable[characterClass.Name] + intelligence.Bonus;
var multiplier = characterClass.Level;
var monsters = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.BaseRaceGroups, GroupConstants.Monsters);
if (monsters.Contains(race.BaseRace) == false)
multiplier += 3;
if (race.BaseRace == RaceConstants.BaseRaces.Human)
perLevel++;
return Math.Max(perLevel * multiplier, characterClass.Level);
}
public void Setup()
{
selection = new RacialFeatSelection();
race = new Race();
stats = new Dictionary<string, Stat>();
stats["stat"] = new Stat("stat");
stats["stat"].Value = 42;
}
public void IfNoWorkingSkillFoci_ReturnNoFocus()
{
focusTypes["focus type"] = new[] { "skill 1" };
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.SkillGroups, GroupConstants.Skills)).Returns(new[] { "skill 1", "skill 2" });
var stat = new Stat("stat");
skills["skill 2"] = new Skill("skill 2", stat, 1);
var focus = featFocusGenerator.GenerateFrom("featId", "focus type", skills, requiredFeats, otherFeats, characterClass);
Assert.That(focus, Is.EqualTo(FeatConstants.Foci.All));
}
public void IfAvailableFociFromSkillsContainsSkills_OnlyUseProvidedSkills()
{
focusTypes["focus type"] = new[] { "skill 1", "skill 2" };
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.SkillGroups, GroupConstants.Skills)).Returns(new[] { "skill 1", "skill 2", "skill 3" });
var stat = new Stat("stat");
skills["skill 2"] = new Skill("skill 2", stat, 1);
skills["skill 3"] = new Skill("skill 3", stat, 1);
var focus = featFocusGenerator.GenerateFrom("featToFill", "focus type", skills);
Assert.That(focus, Is.EqualTo("skill 2"));
}
public void StatBasedFrequenciesCannotBeNegative()
{
AddClassFeat(characterClass.Name, "feat1", frequencyQuantity: 1);
classFeatSelections[characterClass.Name][0].FrequencyQuantityStat = "stat";
stats["stat"] = new Stat("stat");
stats["stat"].Value = 1;
var feats = classFeatsGenerator.GenerateWith(characterClass, race, stats, racialFeats, skills);
var onlyFeat = feats.Single();
Assert.That(onlyFeat.Frequency.Quantity, Is.EqualTo(0));
}
public void Setup()
{
stat = new Stat("stat name");
}
public void Setup()
{
selection = new AdditionalFeatSelection();
feats = new List<Feat>();
stats = new Dictionary<string, Stat>();
stats["stat"] = new Stat("stat");
skills = new Dictionary<string, Skill>();
characterClass = new CharacterClass();
}
public void AssignStatsToSkills()
{
classSkills.Add("class skill");
crossClassSkills.Add("cross class skill");
specialistSkills.Add("specialist skill");
var classSkillSelection = new SkillSelection();
classSkillSelection.BaseStatName = "stat 1";
var crossClassSkillSelection = new SkillSelection();
crossClassSkillSelection.BaseStatName = "stat 2";
var specialistSkillSelection = new SkillSelection();
specialistSkillSelection.BaseStatName = "stat 3";
mockSkillSelector.Setup(s => s.SelectFor("class skill")).Returns(classSkillSelection);
mockSkillSelector.Setup(s => s.SelectFor("cross class skill")).Returns(crossClassSkillSelection);
mockSkillSelector.Setup(s => s.SelectFor("specialist skill")).Returns(specialistSkillSelection);
stats["stat 1"] = new Stat("stat 1");
stats["stat 2"] = new Stat("stat 2");
stats["stat 3"] = new Stat("stat 3");
var skills = skillsGenerator.GenerateWith(characterClass, race, stats);
Assert.That(skills["class skill"].BaseStat, Is.EqualTo(stats["stat 1"]));
Assert.That(skills["cross class skill"].BaseStat, Is.EqualTo(stats["stat 2"]));
Assert.That(skills["specialist skill"].BaseStat, Is.EqualTo(stats["stat 3"]));
}
public void Setup()
{
mockCollectionsSelector = new Mock<ICollectionsSelector>();
mockAdjustmentsSelector = new Mock<IAdjustmentsSelector>();
mockFeatsSelector = new Mock<IFeatsSelector>();
mockFeatFocusGenerator = new Mock<IFeatFocusGenerator>();
racialFeatsGenerator = new RacialFeatsGenerator(mockCollectionsSelector.Object, mockAdjustmentsSelector.Object, mockFeatsSelector.Object,
mockFeatFocusGenerator.Object);
race = new Race();
baseRaceFeats = new List<RacialFeatSelection>();
metaraceFeats = new List<RacialFeatSelection>();
speciesFeats = new List<RacialFeatSelection>();
skills = new Dictionary<string, Skill>();
stats = new Dictionary<string, Stat>();
race.BaseRace = "base race";
race.Metarace = "metarace";
race.MetaraceSpecies = "metarace species";
stats["stat"] = new Stat("stat");
stats["stat"].Value = 14;
mockFeatsSelector.Setup(s => s.SelectRacial("base race")).Returns(baseRaceFeats);
mockFeatsSelector.Setup(s => s.SelectRacial("metarace")).Returns(metaraceFeats);
mockFeatsSelector.Setup(s => s.SelectRacial("metarace species")).Returns(speciesFeats);
}
