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)); }