public void SelectARandomClassForACharacter()
{
var character = new CharacterSheet(CharacterStrategy.Default());
subject.ChooseAny(character);
Assert.NotNull(character.Class.Name);
}
public void NonCastersDoNothing()
{
var character = new CharacterSheet(CharacterStrategy.Default());
var prepareSpells = new PrepareSpells();
prepareSpells.ExecuteStep(character);
}
public void BreaksDescriptionIntoIndividualComponentsForMoreFlexibleDescriptions()
{
// Set up Descriptors
var descs = new MemoryStore();
descs.AddListItem(new MemoryStore("pattern", new string[] { "dragon" }));
descs.AddListItem(new MemoryStore("color", new string[] { "black" }));
// Set up Templates
var temps = new MemoryStore();
temps.AddListItem(new MemoryStore("template", "{{feature}} of a {{descriptor \"color\"}} {{descriptor \"pattern\"}}."));
// Set up physical Feature
var mem = new MemoryStore();
mem.SetValue("name", "tattoo");
mem.SetValue("descriptors", descs);
mem.SetValue("templates", temps);
var phys = new PhysicalFeature(mem);
var gateway = EntityGateway <PhysicalFeature> .LoadWithSingleItem(phys);
var subject = new CreatePhysicalFeatures(gateway);
var character = new CharacterSheet(CharacterStrategy.Default());
character.Gender = Gender.Female;
subject.ExecuteStep(character);
Assert.Equal(character.Appearance.PhysicalAppearance, "Tattoo of a black dragon.");
}
public void CharacterDesignerWillExecuteStepsUntilCharacterIsAtStrategyLevelIfTypeIsLevelUp()
{
var data = new MemoryStore();
data.SetValue("name", "Test One");
data.SetValue("type", "levelup");
var steps = new MemoryStore();
steps.AddListItem(new MemoryStore("step", "Tests.Actions.CharacterGeneration.DummyStepLevelUp"));
data.SetValue("steps", steps);
var build = new CharacterStrategy();
build.TargetLevel = 5;
var character = new CharacterSheet(build);
character.SetClass(Class.CreateForTesting());
var designer = new CharacterDesigner(data);
designer.ExecuteStep(character);
Assert.Equal(designer.DesignerType, CharacterDesigner.Type.LevelUp);
Assert.Equal(character.Level, 5);
Assert.Equal(character.Age, 4);
}
public void CanGetAComponentWithADefaultIfMissing()
{
var sheet = new CharacterSheet(CharacterStrategy.Default());
var comp = sheet.GetOrDefault <Occupation>(Occupation.Unemployed());
Assert.Equal(Occupation.Unemployed(), comp);
}
protected virtual void Following()
{
Vector3 ToEnemyDistance = (following.transform.position - transform.position);
//Vector3 direction = ToEnemyDistance.normalized;
if (ToEnemyDistance.sqrMagnitude >= CircleRadius)
{
followingCharacter = null;
Status = AIStatus.BackToStart;
}
else
{
if (ToEnemyDistance.x > DistanceToAttack)
{
RunRight();
}
else if (ToEnemyDistance.x < -DistanceToAttack)
{
RunLeft();
}
else
{
Status = AIStatus.Attacking;
CanAttack = true;
}
}
}
private void ProcessSteps(CharacterSheet character, CharacterStrategy strategy)
{
foreach (var step in designSteps)
{
ShortLog.DebugFormat("Executing Step: {0}", step);
step.ExecuteStep(character);
}
}
public void IfNothingIsAffordableStop()
{
var character = new CharacterSheet(CharacterStrategy.Default());
character.Inventory.CoinPurse.SetValue(1);
subject.ExecuteStep(character);
Assert.Empty(character.Inventory.All);
}
public void IfChoiceListIsEmptyChooseAnyRace()
{
var strategy = new CharacterStrategy();
var sheet = new CharacterSheet(strategy);
raceSelectorSubject.ExecuteStep(sheet);
Assert.NotNull(sheet.Race);
}
public void SelectACombatStyle()
{
var character = new CharacterSheet(CharacterStrategy.Default());
var step = new SelectCombatStyle();
step.ExecuteStep(character);
Assert.NotNull(character.Get <CombatStyle>());
}
public void AddingASpecialAbilityAddsToComponentList()
{
var character = new CharacterSheet(CharacterStrategy.Default());
var ability = new CompAbility();
character.Add(ability);
Assert.Equal(character.Components.Get <CompAbility>(), ability);
}
public void DoNotSpendMoneyYouDoNotHave()
{
var character = new CharacterSheet(CharacterStrategy.Default());
character.Inventory.CoinPurse.SetValue(200);
subject.ExecuteStep(character);
Assert.True(character.Inventory.All.Count() >= 1);
}
public void AddingAnAbilityThatImplementsIComponentWillCallInitialize()
{
var character = new CharacterSheet(CharacterStrategy.Default());
var ability = new CompAbility();
character.Add(ability);
Assert.True(ability.Called);
}
public void AssignsARandomPersonalityType()
{
var builder = new PersonalityBuilder();
var cs = new CharacterSheet(CharacterStrategy.Default());
builder.Random(cs);
Assert.NotNull(cs.PersonalityType);
Assert.IsType <PersonalityType>(cs.PersonalityType);
}
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);
}
public void CharacterCreatorExecutesEachBuildStepInSequence()
{
var strategy = CharacterStrategy.Default();
var characterSheet = new CharacterSheet(strategy);
subject.ExecuteStep(characterSheet);
Assert.Equal("Dummy One", characterSheet.Name);
Assert.Equal(16, characterSheet.AbilityScores.GetScore(AbilityScoreTypes.Strength));
}
public void AssignsSomeRandomIdeals()
{
var builder = new PersonalityBuilder();
var cs = new CharacterSheet(CharacterStrategy.Default());
builder.Random(cs);
Assert.NotNull(cs.Ideal);
Assert.IsType <Ideal>(cs.Ideal);
}
public void CharactersHaveVitalStats()
{
var sheet = new CharacterSheet(CharacterStrategy.Default());
sheet.FirstName = "Foobar";
sheet.Alignment = CharacterAlignment.LawfulGood;
Assert.Equal("Foobar", sheet.Name);
Assert.Equal(CharacterAlignment.LawfulGood, sheet.Alignment);
}
public void SettlementsHaveManyCharactersInThem()
{
var settlement = new Settlement(new SettlementStrategy());
settlement.AddInhabitant(new CharacterSheet(CharacterStrategy.Default()));
settlement.AddInhabitant(new CharacterSheet(CharacterStrategy.Default()));
Assert.Equal(2, settlement.Population);
}
public void AddNamedWeightedTable()
{
var strat = new CharacterStrategy();
strat.AddCustomValue("colors", "red", 10);
Assert.Equal("red", strat.ChooseOption <string>("colors"));
var copy = strat.Copy();
Assert.Equal("red", copy.ChooseOption <string>("colors"));
}
public void CanSerializeAndDeserializeTheCharacterStrategy()
{
var archer = strategies.Find("archer");
var saved = new YamlObjectStore();
saved.Serialize(archer);
var loaded = new CharacterStrategy(saved);
Assert.Equal(archer.Name, loaded.Name);
}
public void IfFeatIsAlreadySelectedItCannotBeSelectedAgain()
{
var character = new CharacterSheet(CharacterStrategy.Default());
var cr1 = Feat.Named("Combat Reflexes");
var cr2 = Feat.Named("Combat Reflexes");
Assert.True(cr2.IsQualified(character));
character.Add(cr1);
Assert.False(cr2.IsQualified(character));
}
public void HasAGroupOfRequiredStandardComponentsAdded()
{
var character = new CharacterSheet(CharacterStrategy.Default());
Assert.NotNull(character.Get <Inventory>());
Assert.NotNull(character.Get <OffenseStats>());
Assert.NotNull(character.Get <DefenseStats>());
Assert.NotNull(character.Get <SizeStats>());
Assert.NotNull(character.Get <SilverNeedle.Characters.Attacks.MeleeAttackBonus>());
}
public void CharacterIsNotQualifiedIfWrongClassButRightLevel()
{
var character = new CharacterSheet(CharacterStrategy.Default());
var wizard = Class.CreateForTesting();
wizard.Name = "Wizard";
character.SetClass(wizard);
character.SetLevel(4);
Assert.False(prereq.IsQualified(character.Components));
}
public void CharacterIsNotQualifiedIfRightClassButToLowLevel()
{
var character = new CharacterSheet(CharacterStrategy.Default());
var fighter = Class.CreateForTesting();
fighter.Name = "Fighter";
character.SetClass(fighter);
character.SetLevel(3);
Assert.False(prereq.IsQualified(character.Components));
}
public void CharacterIsQualifiedIfHasTheSameClassAtAppropriateLevel()
{
var character = new CharacterSheet(CharacterStrategy.Default());
var fighter = Class.CreateForTesting();
fighter.Name = "Fighter";
character.SetClass(fighter);
character.SetLevel(4);
Assert.True(prereq.IsQualified(character.Components));
}
public void IfNoPreferredFeatsArePossibleJustSelectRandomlyFromAnyPossible()
{
var buildStrategy = new CharacterStrategy();
var character = new CharacterSheet(buildStrategy);
character.Add(new FeatToken());
selector.ExecuteStep(character);
Assert.True(character.Feats.First().Equals(powerattack) ||
character.Feats.First().Equals(empowerspell));
}
public void AddSpecialAbilitiesFromFirstLevelForClass()
{
var cls = Class.CreateForTesting();
var lvl1 = new Level(1);
cls.Levels.Add(lvl1);
var character = new CharacterSheet(CharacterStrategy.Default());
subject.AssignClass(character, cls);
}
public void HasAbilityToAddWeightingForOccupationalSkillsToStrategy()
{
var occ = new Occupation("peasant", "commonet", new string[] { });
occ.Skills = new string[] { "Perception" };
var strategy = new CharacterStrategy();
occ.AddSkillEntry(strategy, 10);
Assert.True(strategy.FavoredSkills.HasOption("Perception"));
}
public void PicksUpSomeRandomGearWorthLessThan20000()
{
var character = new CharacterSheet(CharacterStrategy.Default());
character.Inventory.CoinPurse.SetValue(50000);
subject.ExecuteStep(character);
Assert.True(character.Inventory.CoinPurse.Value >= 30000);
Assert.True(character.Inventory.All.Count() >= 1);
}
