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