public string SelectFrom(string tableName)
{
var result = innerSelector.SelectFrom(tableName);
var replaceResult = replacementSelector.SelectRandom(result);
return(replaceResult);
}
public void DecoratorSelectsFromInnerSelector()
{
mockInnerSelector.Setup(s => s.SelectFrom("table")).Returns("percentile");
var result = decorator.SelectFrom("table");
Assert.That(result, Is.EqualTo("percentile"));
}
public void GetPercentile(int roll, string content)
{
mockDice.Setup(d => d.Roll(1).d(100).AsSum <int>()).Returns(roll);
var result = percentileSelector.SelectFrom(tableName);
Assert.That(result, Is.EqualTo(content));
}
public Item Generate()
{
var armor = new Item();
armor.Name = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.MundaneArmors);
if (armor.Name == AttributeConstants.Shield)
{
armor.Name = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.MundaneShields);
}
armor.ItemType = ItemTypeConstants.Armor;
var tableName = string.Format(TableNameConstants.Collections.Formattable.ITEMTYPEAttributes, armor.ItemType);
armor.Attributes = attributesSelector.SelectFrom(tableName, armor.Name);
var isMasterwork = booleanPercentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.IsMasterwork);
if (isMasterwork)
{
armor.Traits.Add(TraitConstants.Masterwork);
}
var size = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.MundaneGearSizes);
armor.Traits.Add(size);
return(armor);
}
private Item GenerateMundaneItem()
{
var tableName = string.Format(TableNameConstants.Percentiles.Formattable.POWERItems, PowerConstants.Mundane);
var itemType = percentileSelector.SelectFrom(tableName);
var generator = mundaneItemGeneratorFactory.CreateGeneratorOf(itemType);
return(generator.Generate());
}
public void RollPercentile()
{
table.Add(9266, "9266 content");
mockDice.Setup(d => d.Roll(1).d(100).AsSum()).Returns(9266);
var result = percentileSelector.SelectFrom(tableName);
Assert.That(result, Is.EqualTo(table[9266]));
}
public void SelectFromTable()
{
var result = percentileSelector.SelectFrom("StringPercentileTable");
Assert.That(result, Is.EqualTo("one")
.Or.EqualTo("two")
.Or.EqualTo("three")
.Or.Empty
.Or.EqualTo("eleven to one hundred"));
}
public string SelectFrom(string tableName)
{
var result = innerSelector.SelectFrom(tableName);
var replaceTargets = replacementTables.Keys.Where(k => result.Contains(k));
foreach (var replaceTarget in replaceTargets)
{
var replacement = innerSelector.SelectFrom(replacementTables[replaceTarget]);
result = result.Replace(replaceTarget, replacement);
}
return(result);
}
public Item GenerateAtPower(string power)
{
var tableName = string.Format(TableNameConstants.Percentiles.Formattable.POWERITEMTYPEs, power, ItemTypeConstants.Armor);
var result = typeAndAmountPercentileSelector.SelectFrom(tableName);
var abilityCount = 0;
while (result.Type == "SpecialAbility")
{
abilityCount += result.Amount;
result = typeAndAmountPercentileSelector.SelectFrom(tableName);
}
if (result.Amount == 0)
{
return(specificGearGenerator.GenerateFrom(power, result.Type));
}
var armor = new Item();
armor.ItemType = ItemTypeConstants.Armor;
armor.Magic.Bonus = result.Amount;
tableName = string.Format(TableNameConstants.Percentiles.Formattable.ARMORTYPETypes, result.Type);
armor.Name = percentileSelector.SelectFrom(tableName);
tableName = string.Format(TableNameConstants.Collections.Formattable.ITEMTYPEAttributes, armor.ItemType);
armor.Attributes = collectionsSelector.SelectFrom(tableName, armor.Name);
armor.Magic.SpecialAbilities = specialAbilitiesSelector.GenerateFor(armor.ItemType, armor.Attributes, power, armor.Magic.Bonus, abilityCount);
return(armor);
}
public string GenerateCurse()
{
var curse = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.Curses);
if (curse == CurseConstants.Intermittent)
{
return(string.Format("{0} ({1})", curse, GetIntermittentFunctioning()));
}
if (curse == CurseConstants.Drawback)
{
return(percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.CurseDrawbacks));
}
return(curse);
}
public Item GenerateAtPower(string power)
{
if (power == PowerConstants.Minor)
{
throw new ArgumentException("Cannot generate minor staves");
}
var tablename = string.Format(TableNameConstants.Percentiles.Formattable.POWERITEMTYPEs, power, ItemTypeConstants.Staff);
var staffName = percentileSelector.SelectFrom(tablename);
var staff = new Item();
staff.Name = staffName;
staff.ItemType = ItemTypeConstants.Staff;
staff.Attributes = new[] { AttributeConstants.OneTimeUse, AttributeConstants.Charged };
staff = BuildStaff(staff);
staff.Magic.Charges = chargesGenerator.GenerateFor(staff.ItemType, staffName);
if (staff.Name != StaffConstants.Power)
{
return(staff);
}
staff.Magic.Bonus = 2;
return(staff);
}
public Item Generate()
{
var type = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.MundaneWeapons);
var tableName = string.Format(TableNameConstants.Percentiles.Formattable.WEAPONTYPEWeapons, type);
var weaponName = percentileSelector.SelectFrom(tableName);
var weapon = new Item();
if (weaponName == AttributeConstants.Ammunition)
{
weapon = ammunitionGenerator.Generate();
}
else
{
weapon.Name = weaponName;
if (weapon.Name.Contains("Composite"))
{
weapon.Name = GetCompositeBowName(weaponName);
var compositeStrengthBonus = GetCompositeBowBonus(weaponName);
weapon.Traits.Add(compositeStrengthBonus);
}
weapon.ItemType = ItemTypeConstants.Weapon;
tableName = string.Format(TableNameConstants.Collections.Formattable.ITEMTYPEAttributes, weapon.ItemType);
weapon.Attributes = collectionsSelector.SelectFrom(tableName, weapon.Name);
}
var isMasterwork = booleanPercentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.IsMasterwork);
if (isMasterwork)
{
weapon.Traits.Add(TraitConstants.Masterwork);
}
if (weapon.Attributes.Contains(AttributeConstants.Thrown) && weapon.Attributes.Contains(AttributeConstants.Melee) == false)
{
weapon.Quantity = dice.Roll().d20().AsSum();
}
var size = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.MundaneGearSizes);
weapon.Traits.Add(size);
return(weapon);
}
public Item Generate()
{
var tool = new Item();
tool.Name = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.Tools);
tool.ItemType = ItemTypeConstants.Tool;
return(tool);
}
public IEnumerable <string> GenerateFor(string itemType, IEnumerable <string> attributes)
{
var tableName = GetTableName(itemType, attributes);
var result = percentileSelector.SelectFrom(tableName);
if (string.IsNullOrEmpty(result))
{
return(Enumerable.Empty <string>());
}
return(result.Split(','));
}
public Item Generate()
{
var roll = dice.Roll().Percentile().AsSum();
var ammunition = new Item();
ammunition.Name = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.Ammunitions);
ammunition.Quantity = Math.Max(1, roll / 2);
ammunition.Attributes = attributesSelector.SelectFrom(TableNameConstants.Collections.Set.AmmunitionAttributes, ammunition.Name);
ammunition.ItemType = ItemTypeConstants.Weapon;
return(ammunition);
}
private string GetTraitFor(string name)
{
switch (name)
{
case WondrousItemConstants.HornOfValhalla: return(percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.HornOfValhallaTypes));
case WondrousItemConstants.CandleOfInvocation: return(percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.IntelligenceAlignments));
case WondrousItemConstants.RobeOfTheArchmagi: return(percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.RobeOfTheArchmagiColors));
default: return(string.Empty);
}
}
public Item GenerateAtPower(string power)
{
var wand = new Item();
wand.ItemType = ItemTypeConstants.Wand;
wand.IsMagical = true;
var tablename = string.Format(TableNameConstants.Percentiles.Formattable.POWERITEMTYPEs, power, wand.ItemType);
var spell = percentileSelector.SelectFrom(tablename);
wand.Magic.Charges = chargesGenerator.GenerateFor(wand.ItemType, spell);
wand.Name = string.Format("Wand of {0}", spell);
wand.Attributes = new[] { AttributeConstants.Charged, AttributeConstants.OneTimeUse };
return(wand);
}
private SpecialAbility GenerateAbilityFrom(IEnumerable <SpecialAbility> availableAbilities, IEnumerable <string> tableNames)
{
var abilityName = string.Empty;
do
{
var index = dice.Roll().d(tableNames.Count()).AsSum() - 1;
var tableName = tableNames.ElementAt(index);
abilityName = percentileSelector.SelectFrom(tableName);
if (abilityName == "BonusSpecialAbility")
{
return new SpecialAbility {
Name = abilityName
}
}
;
} while (!availableAbilities.Any(a => a.Name == abilityName));
return(availableAbilities.First(a => a.Name == abilityName));
}
public TypeAndAmountPercentileResult SelectFrom(string tableName)
{
var percentileResult = percentileSelector.SelectFrom(tableName);
var result = new TypeAndAmountPercentileResult();
if (string.IsNullOrEmpty(percentileResult))
{
return(result);
}
if (percentileResult.Contains(",") == false)
{
var message = string.Format("Table {0} was not formatted for type and amount parsing", tableName);
throw new FormatException(message);
}
var parsedResult = percentileResult.Split(',');
result.Type = parsedResult[0];
result.Amount = dice.Roll(parsedResult[1]).AsSum();
return(result);
}
public IEnumerable <Attack> AddAttacks(IEnumerable <Feat> feats, IEnumerable <Attack> attacks, int numberOfHands)
{
var allAttacks = new List <Attack>(attacks);
var unnaturalAttacks = allAttacks.Where(a => !a.IsNatural);
if (!unnaturalAttacks.Any())
{
return(allAttacks);
}
//Duplicate attacks
var repeatedAttacks = unnaturalAttacks.Where(a => a.Frequency.Quantity > 1).ToArray();
foreach (var attack in repeatedAttacks)
{
var individualAttacks = Enumerable.Range(1, attack.Frequency.Quantity)
.Select(i => Clone(attack))
.ToArray();
foreach (var individualAttack in individualAttacks)
{
individualAttack.Frequency.Quantity = 1;
}
allAttacks.Remove(attack);
allAttacks.AddRange(individualAttacks);
}
var equipmentAttacks = unnaturalAttacks.Where(a => a.Name == AttributeConstants.Melee || a.Name == AttributeConstants.Ranged);
if (!equipmentAttacks.Any())
{
return(allAttacks);
}
//Add additional melee attacks for two/multi-weapon fighting
var superiorTwoWeaponFeat = feats.Any(f => f.Name == FeatConstants.SpecialQualities.TwoWeaponFighting_Superior ||
f.Name == FeatConstants.SpecialQualities.MultiweaponFighting_Superior);
var greaterTwoWeaponFeat = feats.Any(f => f.Name == FeatConstants.TwoWeaponFighting_Greater ||
f.Name == FeatConstants.Monster.MultiweaponFighting_Greater);
var improvedTwoWeaponFeat = feats.Any(f => f.Name == FeatConstants.TwoWeaponFighting_Improved ||
f.Name == FeatConstants.Monster.MultiweaponFighting_Improved);
var twoWeaponFeat = feats.Any(f => f.Name == FeatConstants.TwoWeaponFighting ||
f.Name == FeatConstants.Monster.MultiweaponFighting);
var twoWeaponMelee = superiorTwoWeaponFeat ||
greaterTwoWeaponFeat ||
improvedTwoWeaponFeat ||
twoWeaponFeat ||
equipmentAttacks.Count(a => a.IsMelee) > 1 ||
percentileSelector.SelectFrom(.99);
var twoWeaponRanged = superiorTwoWeaponFeat ||
greaterTwoWeaponFeat ||
improvedTwoWeaponFeat ||
twoWeaponFeat ||
equipmentAttacks.Count(a => !a.IsMelee) > 1 ||
percentileSelector.SelectFrom(.99);
if (!twoWeaponMelee && !twoWeaponRanged)
{
return(allAttacks);
}
if (twoWeaponMelee)
{
allAttacks = AddAttacksPerHand(AttributeConstants.Melee, numberOfHands, allAttacks);
}
if (twoWeaponRanged)
{
allAttacks = AddAttacksPerHand(AttributeConstants.Ranged, numberOfHands, allAttacks);
}
foreach (var attack in equipmentAttacks)
{
if (attack.IsPrimary)
{
attack.MaxNumberOfAttacks = 4;
attack.AttackBonuses.Add(-6);
if (twoWeaponFeat)
{
attack.AttackBonuses.Add(2);
}
if (superiorTwoWeaponFeat)
{
attack.AttackBonuses.Add(4);
}
}
else
{
attack.MaxNumberOfAttacks = 1;
attack.AttackBonuses.Add(-10);
if (twoWeaponFeat)
{
attack.AttackBonuses.Add(6);
}
if (improvedTwoWeaponFeat)
{
attack.MaxNumberOfAttacks++;
}
if (greaterTwoWeaponFeat)
{
attack.MaxNumberOfAttacks++;
}
if (superiorTwoWeaponFeat)
{
attack.AttackBonuses.Add(4);
}
}
}
return(allAttacks);
}
public Intelligence GenerateFor(Item item)
{
var highStatResult = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.IntelligenceStrongStats);
var highStat = Convert.ToInt32(highStatResult);
var intelligence = new Intelligence();
intelligence.Ego += highStat - 10 - highStat % 2;
intelligence.Ego += item.Magic.Bonus;
foreach (var ability in item.Magic.SpecialAbilities)
{
intelligence.Ego += ability.BonusEquivalent;
}
switch (dice.Roll().d3().AsSum())
{
case 1: intelligence.CharismaStat = 10; break;
case 2: intelligence.IntelligenceStat = 10; break;
case 3: intelligence.WisdomStat = 10; break;
}
intelligence.CharismaStat = SetHighStat(highStat, intelligence.CharismaStat);
intelligence.IntelligenceStat = SetHighStat(highStat, intelligence.IntelligenceStat);
intelligence.WisdomStat = SetHighStat(highStat, intelligence.WisdomStat);
intelligence.Communication = attributesSelector.SelectFrom(TableNameConstants.Collections.Set.IntelligenceCommunication, highStatResult);
if (intelligence.Communication.Contains("Speech"))
{
intelligence.Languages = GenerateLanguages(intelligence.IntelligenceStat);
}
intelligence.Ego += BoostEgoByCommunication(intelligence.Communication, "Read");
intelligence.Ego += BoostEgoByCommunication(intelligence.Communication, "Read magic");
intelligence.Ego += BoostEgoByCommunication(intelligence.Communication, "Telepathy");
var intelligenceAttributesResult = intelligenceAttributesSelector.SelectFrom(TableNameConstants.Collections.Set.IntelligenceAttributes, highStatResult);
intelligence.Senses = intelligenceAttributesResult.Senses;
var lesserPowers = GeneratePowers("Lesser", intelligenceAttributesResult.LesserPowersCount);
intelligence.Ego += lesserPowers.Count;
intelligence.Powers.AddRange(lesserPowers);
var greaterPowers = GeneratePowers("Greater", intelligenceAttributesResult.GreaterPowersCount);
var roll = dice.Roll().d4().AsSum();
if (roll <= intelligenceAttributesResult.GreaterPowersCount)
{
greaterPowers.RemoveAt(greaterPowers.Count - 1);
intelligence.SpecialPurpose = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.IntelligenceSpecialPurposes);
intelligence.DedicatedPower = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.IntelligenceDedicatedPowers);
intelligence.Ego += 4;
}
intelligence.Ego += greaterPowers.Count * 2;
intelligence.Powers.AddRange(greaterPowers);
intelligence.Alignment = GetAlignment(item);
intelligence.Personality = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.PersonalityTraits);
return(intelligence);
}
public Boolean SelectFrom(String tableName)
{
var result = innerSelector.SelectFrom(tableName);
return(Convert.ToBoolean(result));
}
public Item GenerateFrom(string power, string specificGearType)
{
var tableName = string.Format(TableNameConstants.Percentiles.Formattable.POWERSpecificITEMTYPEs, power, specificGearType);
var result = typeAndAmountPercentileSelector.SelectFrom(tableName);
var gear = new Item();
gear.Name = result.Type;
gear.Magic.Bonus = result.Amount;
gear.Magic.SpecialAbilities = GetSpecialAbilities(specificGearType, gear.Name);
gear.ItemType = GetItemType(specificGearType);
tableName = string.Format(TableNameConstants.Collections.Formattable.SpecificITEMTYPEAttributes, specificGearType);
gear.Attributes = collectionsSelector.SelectFrom(tableName, gear.Name);
tableName = string.Format(TableNameConstants.Collections.Formattable.SpecificITEMTYPETraits, specificGearType);
var traits = collectionsSelector.SelectFrom(tableName, gear.Name);
foreach (var trait in traits)
{
gear.Traits.Add(trait);
}
if (gear.Attributes.Contains(AttributeConstants.Charged))
{
gear.Magic.Charges = chargesGenerator.GenerateFor(specificGearType, gear.Name);
}
if (gear.Name == WeaponConstants.JavelinOfLightning)
{
gear.IsMagical = true;
}
else if (gear.Name == ArmorConstants.CastersShield)
{
var hasSpell = booleanPercentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.CastersShieldContainsSpell);
if (hasSpell)
{
var spellType = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.CastersShieldSpellTypes);
var spellLevel = spellGenerator.GenerateLevel(PowerConstants.Medium);
var spell = spellGenerator.Generate(spellType, spellLevel);
var formattedSpell = string.Format("{0} ({1}, {2})", spell, spellType, spellLevel);
gear.Contents.Add(formattedSpell);
}
}
gear.Name = RenameGear(gear.Name);
gear.Quantity = GetQuantity(gear);
if (gear.Name == WeaponConstants.SlayingArrow || gear.Name == WeaponConstants.GreaterSlayingArrow)
{
var designatedFoe = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.DesignatedFoes);
var trait = string.Format("Designated Foe: {0}", designatedFoe);
gear.Traits.Add(trait);
}
if (gear.IsMagical == false)
{
var size = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.MundaneGearSizes);
gear.Traits.Add(size);
}
return(gear);
}
public Item GenerateAtPower(string power)
{
var tablename = string.Format(TableNameConstants.Percentiles.Formattable.POWERITEMTYPEs, power, ItemTypeConstants.Weapon);
var bonus = percentileSelector.SelectFrom(tablename);
var specialAbilitiesCount = 0;
while (bonus == "SpecialAbility")
{
specialAbilitiesCount++;
bonus = percentileSelector.SelectFrom(tablename);
}
if (bonus == ItemTypeConstants.Weapon)
{
return(specificGearGenerator.GenerateFrom(power, bonus));
}
var type = percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.WeaponTypes);
tablename = string.Format(TableNameConstants.Percentiles.Formattable.WEAPONTYPEWeapons, type);
var name = percentileSelector.SelectFrom(tablename);
var weapon = new Item();
if (name == AttributeConstants.Ammunition)
{
weapon = ammunitionGenerator.Generate();
}
else
{
weapon.ItemType = ItemTypeConstants.Weapon;
weapon.Name = name;
if (weapon.Name.Contains("Composite"))
{
weapon.Name = GetCompositeBowName(name);
var compositeStrengthBonus = GetCompositeBowBonus(name);
weapon.Traits.Add(compositeStrengthBonus);
}
tablename = string.Format(TableNameConstants.Collections.Formattable.ITEMTYPEAttributes, weapon.ItemType);
weapon.Attributes = collectionsSelector.SelectFrom(tablename, weapon.Name);
}
weapon.Magic.Bonus = Convert.ToInt32(bonus);
weapon.Magic.SpecialAbilities = specialAbilitiesGenerator.GenerateFor(weapon.ItemType, weapon.Attributes, power, weapon.Magic.Bonus, specialAbilitiesCount);
if (weapon.Magic.SpecialAbilities.Any(a => a.Name == SpecialAbilityConstants.SpellStoring))
{
var shouldStoreSpell = booleanPercentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.SpellStoringContainsSpell);
if (shouldStoreSpell)
{
var spellType = spellGenerator.GenerateType();
var level = spellGenerator.GenerateLevel(PowerConstants.Minor);
var spell = spellGenerator.Generate(spellType, level);
weapon.Contents.Add(spell);
}
}
if (weapon.Attributes.Contains(AttributeConstants.Thrown) && weapon.Attributes.Contains(AttributeConstants.Melee) == false)
{
weapon.Quantity = dice.Roll().d20().AsSum();
}
return(weapon);
}
public bool IsAdvanced(string creature)
{
var advancements = typeAndAmountSelector.Select(TableNameConstants.TypeAndAmount.Advancements, creature);
return(percentileSelector.SelectFrom(.9) && advancements.Any());
}
public string GenerateType()
{
return(percentileSelector.SelectFrom(TableNameConstants.Percentiles.Set.SpellTypes));
}