public void ThrowsAnExceptionIfValueDoesNotMeetExpectations() { var table = new WeightedOptionTable<string>(); table.AddEntry("Foo", 30); table.AddEntry("Bar", 20); table.GetOption(160); }
private void BuildWeightedTable(WeightedOptionTable <string> tableToBuild, IEnumerable <IObjectStore> nodes) { foreach (var child in nodes) { tableToBuild.AddEntry(child.GetString("name"), child.GetInteger("weight")); } }
public void ThrowsAnExceptionIfValueDoesNotMeetExpectations() { var table = new WeightedOptionTable <string>(); table.AddEntry("Foo", 30); table.AddEntry("Bar", 20); Assert.Throws(typeof(IndexOutOfRangeException), () => table.GetOption(160)); }
public void IfAllOptionsAreDisabledThanFlagAsEmpty() { var table = new WeightedOptionTable <int>(); table.AddEntry(1, 1); table.Disable(1); Assert.True(table.IsEmpty); }
public void ReturnsTrueIfOptionExists() { var table = new WeightedOptionTable <string>(); table.AddEntry("Foo", 1); Assert.True(table.HasOption("Foo")); Assert.False(table.HasOption("Bar")); }
private WeightedOptionTable <T> GetCustomTable <T>(string tableName) { if (customTables.ContainsKey(tableName) == false) { customTables[tableName] = new WeightedOptionTable <T>(); } return(customTables[tableName] as WeightedOptionTable <T>); }
public void ChoosesSkillsBasedOnTheStrategyRecommendation() { var strategy = new WeightedOptionTable <string>(); strategy.AddEntry("Climb", 20); distributor.AssignSkillPoints(skills, strategy, 1, 1); Assert.Equal(1, skills.GetSkill("Climb").Ranks); }
public void EmptyOptionTableChoosesFromAnyOfTheClasses() { var character = new CharacterSheet(CharacterStrategy.Default()); var choices = new WeightedOptionTable <string>(); Assert.Null(character.Class); subject.ChooseClass(character, choices); Assert.NotNull(character.Class.Name); }
private void AssignByStrategy(CharacterSheet character, WeightedOptionTable <AbilityScoreTypes> abilities) { var tokens = character.GetAndRemoveAll <AbilityScoreToken>(); foreach (var token in tokens) { var modifier = token.CreateAdjustment(abilities.ChooseRandomly()); character.Add(modifier); } }
public void CanInitializeFromAListOfProperObjects() { var list = new List <DummyEntry>(); list.Add(new DummyEntry("Foo", 4)); list.Add(new DummyEntry("Bar", 2)); var table = new WeightedOptionTable <DummyEntry>(list); Assert.Equal(2, table.All.Count()); }
public void ChoosingClassFromWeightedOptionTableSelectsFromThoseClasses() { var character = new CharacterSheet(CharacterStrategy.Default()); var choices = new WeightedOptionTable <string>(); choices.AddEntry("Fighter", 10); subject.ChooseClass(character, choices); Assert.Equal("Fighter", character.Class.Name); }
public WeightedOptionTable <ClassOrigin> GetClassOriginOptions(string cls) { var table = new WeightedOptionTable <ClassOrigin>(); var origins = classOrigins.Where(x => string.Equals(x.Class, cls, StringComparison.OrdinalIgnoreCase)); foreach (var origin in origins) { table.AddEntry(origin, origin.Weighting); } return(table); }
private void DisableOptionsThatAlreadyHaveSkillFocus(WeightedOptionTable <string> skillTable, IEnumerable <SkillFocus> existingSkillFocuses) { foreach (var sf in existingSkillFocuses) { if (sf != this) { ShortLog.DebugFormat("Skill Focus - Disable Skill {0}", sf.CharacterSkill.Name); skillTable.Disable(sf.CharacterSkill.Name); } } }
public void IfSkillHasMaxRanksChooseOtherPreferredSkill() { var strategy = new WeightedOptionTable <string>(); strategy.AddEntry("Climb", 2000000); // This is not a 100% guaranteed test. But it should be reliable enough. If failures happen will adjust strategy.AddEntry("Acrobatics", 1); distributor.AssignSkillPoints(skills, strategy, 2, 1); Assert.Equal(1, skills.GetSkill("Climb").Ranks); Assert.Equal(1, skills.GetSkill("Acrobatics").Ranks); }
public void PullsAnOptionOutBasedOnWeightedValue() { var table = new WeightedOptionTable<string>(); table.AddEntry("Foo", 30); table.AddEntry("Bar", 20); table.AddEntry("Woo", 3); Assert.AreEqual("Foo", table.GetOption(23)); Assert.AreEqual("Bar", table.GetOption(31)); Assert.AreEqual("Woo", table.GetOption(53)); }
public WeightedOptionTable <Homeland> GetRacialOptions(string race) { var table = new WeightedOptionTable <Homeland>(); var options = homelands.Where(x => string.Equals(x.Race, race, StringComparison.OrdinalIgnoreCase)); foreach (var opt in options) { table.AddEntry(opt, opt.Weighting); } return(table); }
private void FillInMissingAbilities(WeightedOptionTable <AbilityScoreTypes> abilityTable) { //build empty table foreach (var a in EnumHelpers.GetValues <AbilityScoreTypes>()) { if (!abilityTable.HasOption(a)) { abilityTable.AddEntry(a, 1); } } }
public void ReturnsARandomListBasedOnPreferredOptions() { var table = new WeightedOptionTable <string>(); table.AddEntry("Foo", 1); table.AddEntry("Bar", 1000000); var list = table.UniqueList(); Assert.Equal("Bar", list.First()); Assert.Equal("Foo", list.Last()); }
public void BecauseStringComparisonsCanBeMessyIfFindingEntryByStringUseCaseInsensitiveIfString() { var table = new WeightedOptionTable <string>(); table.AddEntry("Foo", 1); table.AddEntry("Bar", 2); table.Disable("foo"); Assert.Equal(1, table.Enabled.Count()); Assert.True(table.HasOption("bar")); }
private void BuildAbilityTable(WeightedOptionTable <AbilityScoreTypes> abilityTable, IEnumerable <IObjectStore> nodes) { if (nodes != null) { foreach (var child in nodes) { abilityTable.AddEntry(child.GetEnum <AbilityScoreTypes>("name"), child.GetInteger("weight")); } } FillInMissingAbilities(abilityTable); }
public ClassOriginGroup(IObjectStore data) { Origins = new WeightedOptionTable <ClassOrigin>(); Name = data.GetString("class"); var table = data.GetObjectList("table"); foreach (var entry in table) { var origin = new ClassOrigin(Name, entry); Origins.AddEntry(origin, origin.Weighting); } }
private void ParseYaml(YamlNodeWrapper yaml) { drawbacks = new WeightedOptionTable <Drawback>(); foreach (var node in yaml.Children()) { var drawback = new Drawback(); drawback.Name = node.GetString("name"); drawback.Weighting = node.GetInteger("weight"); drawback.Traits.Add(node.GetCommaStringOptional("traits")); drawbacks.AddEntry(drawback, drawback.Weighting); } }
public HomelandGroup(IObjectStore data) { Homelands = new WeightedOptionTable <Homeland>(); Name = data.GetString("race"); var table = data.GetObjectList("table"); foreach (var entry in table) { var homeland = new Homeland(Name, entry); Homelands.AddEntry(homeland, homeland.Weighting); } }
public void CanAddOptionsAndItTracksTheRanges() { var table = new WeightedOptionTable<string>(); table.AddEntry("Foo", 30); table.AddEntry("Bar", 20); table.AddEntry("Woo", 3); var options = table.All().ToArray(); Assert.AreEqual(3, options.Count()); Assert.AreEqual(30, options[0].MaximumValue); Assert.AreEqual(50, options[1].MaximumValue); Assert.AreEqual(31, options[1].MinimumValue); }
public void IfAllPreferredSkillsAreMaxedAssignAPointToRemainingClassSkills() { var strategy = new WeightedOptionTable <string>(); strategy.AddEntry("Climb", 1); //Set Knowledge (Arcana) as a class skill skills.SetClassSkill("Knowledge (Arcana)"); distributor.AssignSkillPoints(skills, strategy, 2, 1); Assert.Equal(1, skills.GetSkill("Climb").Ranks); Assert.Equal(1, skills.GetSkill("Knowledge (Arcana)").Ranks); }
public void ChooseClass(CharacterSheet character, WeightedOptionTable <string> classChoices) { if (classChoices.IsEmpty) { ChooseAny(character); return; } var choice = classChoices.ChooseRandomly(); var cls = classes.Find(choice); AssignClass(character, cls); }
private void ChooseRace(CharacterSheet character, WeightedOptionTable <string> options) { if (options.IsEmpty) { this.SetRace(character, raceGateway.All().ToList().ChooseOne()); return; } var choice = options.ChooseRandomly(); var race = raceGateway.Find(choice); this.SetRace(character, race); }
public void DisabledEntriesCanBeReenabled() { var table = new WeightedOptionTable <string>(); table.AddEntry("Foo", 483); var entry = table.All.First(); var originalMax = entry.MaximumValue; table.Disable("Foo"); Assert.True(entry.Disabled); table.Enable("Foo"); Assert.False(entry.Disabled); Assert.Equal(originalMax, entry.MaximumValue); }
public void EntriesCanBeDisabledWhichForcesADifferentOptionToBeChosen() { var table = new WeightedOptionTable <string>(); table.AddEntry("Foo", 12); table.AddEntry("Bar", 100); table.Disable("Bar"); for (int i = 0; i < 1000; i++) { var result = table.ChooseRandomly(); Assert.Equal("Foo", result); } }
public void AssignSkillPoints(SkillRanks skills, WeightedOptionTable <string> preferredSkills, int skillPoints, int maxLevel) { int assigned = 0; while (assigned < skillPoints) { var selectedSkill = ChooseSkill(skills, preferredSkills, maxLevel); if (selectedSkill != null) { selectedSkill.AddRank(); assigned++; } } }