public IEnumerable<string> GetAllPossible(Alignment alignment, CharacterClass characterClass)
{
var alignmentBaseRaces = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.BaseRaceGroups, alignment.Goodness);
var classBaseRaces = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.BaseRaceGroups, characterClass.Name);
return alignmentBaseRaces.Intersect(classBaseRaces).Intersect(new[] { SetBaseRace });
}
public IEnumerable<string> GetAllPossible(Alignment alignment, CharacterClass characterClass)
{
var tableName = string.Format(TableNameConstants.Formattable.Percentile.GOODNESSCLASSBaseRaces, alignment.Goodness, characterClass.Name);
var baseRaces = percentileResultSelector.SelectAllFrom(tableName);
return baseRaces.Where(r => RaceIsAllowed(r, characterClass.Level));
}
public Race GenerateWith(Alignment alignment, CharacterClass characterClass, RaceRandomizer baseRaceRandomizer, RaceRandomizer metaraceRandomizer)
{
var race = new Race();
race.BaseRace = baseRaceRandomizer.Randomize(alignment, characterClass);
race.Metarace = metaraceRandomizer.Randomize(alignment, characterClass);
race.MetaraceSpecies = DetermineMetaraceSpecies(alignment, race.Metarace);
race.IsMale = DetermineIfMale(race.BaseRace, characterClass.Name);
race.Size = DetermineSize(race.BaseRace);
race.HasWings = DetermineIfRaceHasWings(race);
race.LandSpeed = DetermineLandSpeed(race);
race.AerialSpeed = DetermineAerialSpeed(race);
race.Age = DetermineAge(race, characterClass);
var tableName = string.Format(TableNameConstants.Formattable.Adjustments.GENDERHeights, race.Gender);
var baseHeights = adjustmentsSelector.SelectFrom(tableName);
var heightModifier = GetModifier(race, TableNameConstants.Set.Collection.HeightRolls);
race.HeightInInches = baseHeights[race.BaseRace] + heightModifier;
tableName = string.Format(TableNameConstants.Formattable.Adjustments.GENDERWeights, race.Gender);
var baseWeights = adjustmentsSelector.SelectFrom(tableName);
var weightModifier = GetModifier(race, TableNameConstants.Set.Collection.WeightRolls);
race.WeightInPounds = baseWeights[race.BaseRace] + heightModifier * weightModifier;
return race;
}
protected override bool CharacterClassIsAllowed(string className, Alignment alignment)
{
var warriors = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, GroupConstants.Warriors);
var alignmentClasses = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, alignment.ToString());
var allowedClasses = warriors.Intersect(alignmentClasses);
return allowedClasses.Contains(className);
}
protected override bool CharacterClassIsAllowed(string className, Alignment alignment)
{
var spellcasters = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, GroupConstants.Spellcasters);
var alignmentClasses = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, alignment.ToString());
var allowedClasses = alignmentClasses.Except(spellcasters);
return allowedClasses.Contains(className);
}
public bool VerifyCharacterClassCompatibility(Alignment alignment, CharacterClass characterClass, ILevelRandomizer levelRandomizer, RaceRandomizer baseRaceRandomizer, RaceRandomizer metaraceRandomizer)
{
var baseRaces = baseRaceRandomizer.GetAllPossible(alignment, characterClass);
var metaraces = metaraceRandomizer.GetAllPossible(alignment, characterClass);
var races = GetAllRacePrototypes(baseRaces, metaraces);
return races.Any(r => VerifyRaceCompatibility(r, characterClass, levelRandomizer));
}
public bool VerifyAlignmentCompatibility(Alignment alignment, IClassNameRandomizer classNameRandomizer, ILevelRandomizer levelRandomizer, RaceRandomizer baseRaceRandomizer, RaceRandomizer metaraceRandomizer)
{
var classNames = classNameRandomizer.GetAllPossibleResults(alignment);
var levels = levelRandomizer.GetAllPossibleResults();
var characterClasses = GetAllCharacterClassPrototypes(classNames, levels);
return characterClasses.Any(c => VerifyCharacterClassCompatibility(alignment, c, levelRandomizer, baseRaceRandomizer, metaraceRandomizer));
}
public void Setup()
{
alignment = new Alignment();
mockAlignmentRandomizer = new Mock<IAlignmentRandomizer>();
alignmentGenerator = new AlignmentGenerator();
mockAlignmentRandomizer.Setup(r => r.Randomize()).Returns(alignment);
}
private Alignment GenerateAlignment()
{
var alignment = new Alignment();
alignment.Lawfulness = percentileResultSelector.SelectFrom(TableNameConstants.Set.Percentile.AlignmentLawfulness);
alignment.Goodness = percentileResultSelector.SelectFrom(TableNameConstants.Set.Percentile.AlignmentGoodness);
return alignment;
}
public string Randomize(Alignment alignment, CharacterClass characterClass)
{
var baseRaces = GetAllPossible(alignment, characterClass);
if (baseRaces.Any() == false)
throw new IncompatibleRandomizersException();
return baseRaces.Single();
}
public string Randomize(Alignment alignment)
{
var classes = GetAllPossibleResults(alignment);
if (classes.Any() == false)
throw new IncompatibleRandomizersException();
return classes.Single();
}
public string Randomize(Alignment alignment, CharacterClass characterClass)
{
var results = GetAllPossible(alignment, characterClass);
if (results.Any() == false)
throw new IncompatibleRandomizersException();
var tableName = string.Format(TableNameConstants.Formattable.Percentile.GOODNESSCLASSMetaraces, alignment.Goodness, characterClass.Name);
return generator.Generate(() => percentileResultSelector.SelectFrom(tableName), m => results.Contains(m));
}
public Character()
{
Alignment = new Alignment();
Class = new CharacterClass();
Race = new Race();
InterestingTrait = string.Empty;
Combat = new Combat();
Ability = new Ability();
Equipment = new Equipment();
Magic = new Magic();
}
public void AlignmentIsNotEqualIfLawfulnessDiffers()
{
alignment.Lawfulness = "lawfulness";
alignment.Goodness = "goodness";
var otherAlignment = new Alignment();
otherAlignment.Lawfulness = "other lawfulness";
otherAlignment.Goodness = "goodness";
Assert.That(alignment, Is.Not.EqualTo(otherAlignment));
}
public void AlignmentIsEqualIfGoodnessesAndLawfulnessesMatch()
{
alignment.Lawfulness = "lawfulness";
alignment.Goodness = "goodness";
var otherAlignment = new Alignment();
otherAlignment.Lawfulness = "lawfulness";
otherAlignment.Goodness = "goodness";
Assert.That(alignment, Is.EqualTo(otherAlignment));
}
public string Randomize(Alignment alignment)
{
var possibleClassNames = GetAllPossibleResults(alignment);
if (possibleClassNames.Any() == false)
throw new IncompatibleRandomizersException();
var tableName = string.Format(TableNameConstants.Formattable.Percentile.GOODNESSCharacterClasses, alignment.Goodness);
return generator.Generate(() => percentileResultSelector.SelectFrom(tableName),
c => possibleClassNames.Contains(c));
}
public void Setup()
{
mockCollectionsSelector = new Mock<ICollectionsSelector>();
randomizer = new SetClassNameRandomizer(mockCollectionsSelector.Object);
alignment = new Alignment();
alignmentClasses = new List<string>();
alignment.Goodness = "goodness";
alignment.Lawfulness = "lawfulness";
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, alignment.Full)).Returns(alignmentClasses);
}
public void RaceRandomizerTestsSetup()
{
mockPercentileResultSelector = new Mock<IPercentileSelector>();
mockAdjustmentsSelector = new Mock<IAdjustmentsSelector>();
generator = new ConfigurableIterationGenerator();
adjustments = new Dictionary<string, int>();
characterClass = new CharacterClass();
alignment = new Alignment();
characterClass.Level = 1;
mockAdjustmentsSelector.Setup(p => p.SelectFrom(TableNameConstants.Set.Adjustments.LevelAdjustments)).Returns(adjustments);
}
public void Setup()
{
mockCollectionsSelector = new Mock<ICollectionsSelector>();
npcRandomizer = new AnyNPCClassNameRandomizer(mockCollectionsSelector.Object);
npcs = new List<string>();
alignment = new Alignment();
npcs.Add("npc 1");
npcs.Add("npc 2");
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, GroupConstants.NPCs)).Returns(npcs);
mockCollectionsSelector.Setup(s => s.SelectRandomFrom(It.IsAny<IEnumerable<string>>())).Returns((IEnumerable<string> c) => c.Last());
}
public void ClassNameRandomizerTestsSetup()
{
mockCollectionsSelector = new Mock<ICollectionsSelector>();
mockPercentileResultSelector = new Mock<IPercentileSelector>();
generator = new ConfigurableIterationGenerator();
alignment = new Alignment();
alignmentClasses = new List<string>();
groupClasses = new List<string>();
alignment.Goodness = "goodness";
alignment.Lawfulness = "lawfulness";
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, classNameGroup)).Returns(groupClasses);
mockPercentileResultSelector.Setup(s => s.SelectAllFrom(It.IsAny<string>())).Returns(new[] { ClassName, AlignmentClassName, GroupClassName });
mockCollectionsSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.Collection.ClassNameGroups, alignment.ToString())).Returns(alignmentClasses);
alignmentClasses.Add(AlignmentClassName);
groupClasses.Add(GroupClassName);
}
public IEnumerable<string> RegenerateSpecialistFields(Alignment alignment, CharacterClass characterClass, Race race)
{
if (characterClass.SpecialistFields.Any() == false || race.Metarace == RaceConstants.Metaraces.None)
return characterClass.SpecialistFields;
var allClassSpecialistFields = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.SpecialistFields, characterClass.Name);
var allMetaraceSpecialistFields = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.SpecialistFields, race.Metarace);
var applicableFields = allClassSpecialistFields.Intersect(allMetaraceSpecialistFields);
if (applicableFields.Any() == false)
return characterClass.SpecialistFields;
var nonAlignmentFields = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.ProhibitedFields, alignment.ToString());
var possibleSpecialistFields = applicableFields.Except(nonAlignmentFields);
return PopulateFields(characterClass.SpecialistFields.Count(), possibleSpecialistFields);
}
public CharacterClass GenerateWith(Alignment alignment, ILevelRandomizer levelRandomizer, IClassNameRandomizer classNameRandomizer)
{
var characterClass = new CharacterClass();
characterClass.Level = levelRandomizer.Randomize();
characterClass.Name = classNameRandomizer.Randomize(alignment);
var tableName = string.Format(TableNameConstants.Formattable.TrueOrFalse.CLASSHasSpecialistFields, characterClass.Name);
var isSpecialist = booleanPercentileSelector.SelectFrom(tableName);
if (!isSpecialist)
return characterClass;
characterClass.SpecialistFields = GenerateSpecialistFields(characterClass, alignment);
characterClass.ProhibitedFields = GenerateProhibitedFields(characterClass);
return characterClass;
}
public string GenerateFrom(Alignment alignment, CharacterClass characterClass, Race race, IEnumerable<Feat> feats)
{
if (characterClass.Name == CharacterClassConstants.Adept && characterClass.Level == 1)
return string.Empty;
var levelAdjustments = adjustmentsSelector.SelectFrom(TableNameConstants.Set.Adjustments.LevelAdjustments);
var effectiveCharacterClass = GetEffectiveCharacterClass(characterClass);
var animals = AnimalsForCharacter(effectiveCharacterClass, race, levelAdjustments);
if (animals.Any() == false)
return string.Empty;
var improvedFamiliars = collectionsSelector.SelectFrom(TableNameConstants.Set.Collection.Animals, FeatConstants.ImprovedFamiliar);
var characterHasImprovedFamiliarFeat = feats.Any(f => f.Name == FeatConstants.ImprovedFamiliar);
var animal = generator.Generate(() => collectionsSelector.SelectRandomFrom(animals),
a => characterHasImprovedFamiliarFeat || improvedFamiliars.Contains(a) == false);
return animal;
}
public void AttractCohortOfDifferingAlignment()
{
mockLeadershipSelector.Setup(s => s.SelectCohortLevelFor(9265)).Returns(42);
mockBooleanPercentileSelector.Setup(s => s.SelectFrom(TableNameConstants.Set.TrueOrFalse.AttractCohortOfDifferentAlignment)).Returns(true);
var incompatibleAlignment = new Alignment("incompatible alignment");
var cohortAlignment = new Alignment("cohort alignment");
allowedAlignments.Add(cohortAlignment.ToString());
mockAlignmentGenerator.SetupSequence(g => g.GenerateWith(mockAnyAlignmentRandomizer.Object))
.Returns(incompatibleAlignment).Returns(cohortAlignment);
var cohort = new Character();
mockCharacterGenerator.Setup(g => g.GenerateWith(mockSetAlignmentRandomizer.Object, mockAnyPlayerClassNameRandomizer.Object, mockSetLevelRandomizer.Object, mockAnyBaseRaceRandomizer.Object, mockAnyMetaraceRandomizer.Object, mockRawStatRandomizer.Object))
.Returns(cohort);
var generatedCohort = leadershipGenerator.GenerateCohort(9266, 90210, leaderAlignment, "class name");
Assert.That(generatedCohort, Is.EqualTo(cohort));
mockSetAlignmentRandomizer.VerifySet(r => r.SetAlignment = cohortAlignment);
}
protected override bool AlignmentIsAllowed(Alignment alignment)
{
return alignment.Goodness == AlignmentConstants.Neutral || alignment.Lawfulness == AlignmentConstants.Neutral;
}
protected abstract bool CharacterClassIsAllowed(string className, Alignment alignment);
public IEnumerable<string> GetAllPossibleResults(Alignment alignment)
{
var tableName = string.Format("{0}CharacterClasses", alignment.Goodness);
var classNames = percentileResultSelector.SelectAllFrom(tableName);
return classNames.Where(c => CharacterClassIsAllowed(c, alignment));
}
public void Setup()
{
randomizer = new NoMetaraceRandomizer();
alignment = new Alignment();
characterClass = new CharacterClass();
}
public void NotAllowed(string lawfulness, string goodness)
{
var expectedAlignment = new Alignment { Lawfulness = lawfulness, Goodness = goodness };
Assert.That(alignments, Is.All.Not.EqualTo(expectedAlignment));
}
public void Allowed(string lawfulness, string goodness)
{
var expectedAlignment = new Alignment { Lawfulness = lawfulness, Goodness = goodness };
Assert.That(alignments, Contains.Item(expectedAlignment));
}
