public CharacterDesigner(IObjectStore data)
{
Name = data.GetString("name");
if (data.HasKey("type"))
{
DesignerType = data.GetEnum <Type>("type");
}
ShortLog.DebugFormat("Loading Character Creator: {0}", Name);
designSteps = new List <ICharacterDesignStep>();
foreach (var step in data.GetObjectList("steps"))
{
if (step.HasKey("step"))
{
var typeName = step.GetString("step");
ShortLog.DebugFormat("Adding Build Step: {0}", typeName);
var item = typeName.Instantiate <ICharacterDesignStep>(step);
designSteps.Add(item);
}
else if (step.HasKey("designer"))
{
var designer = step.GetString("designer");
ShortLog.DebugFormat("Adding Designer: {0}", designer);
var item = new DesignerExecuterStep(designer);
designSteps.Add(item);
}
}
}
/// <summary>
/// Instantiates an object and passes in IObjectStore information
/// If no constructor with IObjectStore data is available but there is
/// an empty Constructor it will utilize that
/// </summary>
/// <param name="type"></param>
/// <param name="constructor"></param>
/// <returns></returns>
public static T Instantiate <T>(this System.Type type, params IObjectStore[] constructor)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
try
{
if (constructor.Length > 0)
{
var types = constructor.Select(x => x.GetType()).ToArray();
ShortLog.DebugFormat("type is {0}", type.ToString());
var matchConstructor = type.GetConstructor(types);
//Could not find a matching constructor, just try for an empty one
if (matchConstructor == null)
{
return((T)Activator.CreateInstance(type));
}
}
return((T)Activator.CreateInstance(type, constructor));
}
catch
{
ShortLog.ErrorFormat("Failed to created type: {0}", type.ToString());
throw;
}
}
private void LoadFromObjectStore(IObjectStore data)
{
Name = data.GetString("name");
ShortLog.Debug("Loading Class: " + Name);
SkillPoints = data.GetInteger("skillpoints");
HitDice = DiceStrings.ParseSides(data.GetString("hitdice"));
BaseAttackBonusRate = data.GetFloat("baseattackbonus");
FortitudeSaveRate = data.GetFloat("fortitude");
ReflexSaveRate = data.GetFloat("reflex");
WillSaveRate = data.GetFloat("will");
ClassDevelopmentAge = data.GetEnum <ClassDevelopmentAge>("developedage");
CustomBuildStep = data.GetStringOptional("custom-build-step");
//Load Levels
var levels = data.GetObjectListOptional("levels");
if (levels != null)
{
foreach (var l in levels)
{
var level = new Level(l);
Levels.Add(level);
}
}
var dice = data.GetStringOptional("startingwealth");
if (dice != null)
{
StartingWealthDice = DiceStrings.ParseDice(dice);
}
this.HitDicePerLevel = new DiceClassLevelModifier(new Cup(new Die(HitDice)), StatNames.HitDice, this.Name, 1);
}
public string Generate(int maxLength)
{
var name = "";
var currentKey = InitialKey();
while (name.Length < maxLength)
{
if (!states.ContainsKey(currentKey))
{
break;
}
var state = states[currentKey];
if (state.Tokens.Empty())
{
break;
}
var next = state.ChooseOne();
if (next == TERMINATOR)
{
break;
}
name += next;
currentKey = NextKey(currentKey, next);
}
ShortLog.DebugFormat("Markov Name Generator: {0}", name);
return(name.Titlize());
}
public static T SUT <T>(this ITypeResolver resolvr) where T : ILogSource
{
if (!resolvr.HasLifetimeScope)
{
resolvr.BeginLifetimeScope();
}
if (_growl == null)
{
_growl = new GrowlListener(nameof(MustExtensions));
}
var obj = resolvr.Resolve <T>();
obj.LogAdded += (s, e) =>
{
if (e.ShowAs == ShowLogAs.Intro)
{
_lastTitle = e.Title;
return;
}
if (e.ShowAs == ShowLogAs.Outro)
{
e.Title = _lastTitle;
}
var m = ShortLog.Format(e);
OutputHelper.WriteLine(m);
};
obj.LogAdded += _growl.HandleLogEvent;
return(obj);
}
/// <summary>
/// Loads from yaml.
/// </summary>
/// <returns>The from yaml.</returns>
/// <param name="yaml">Yaml data to load from.</param>
private static IList <Class> LoadFromYaml(YamlNodeWrapper yaml)
{
var classes = new List <Class>();
foreach (var node in yaml.Children())
{
var cls = new Class();
cls.Name = node.GetString("name");
ShortLog.Debug("Loading Class: " + cls.Name);
cls.SkillPoints = node.GetInteger("skillpoints");
cls.HitDice = DiceStrings.ParseSides(node.GetString("hitdice"));
cls.BaseAttackBonusRate = node.GetFloat("baseattackbonus");
cls.FortitudeSaveRate = node.GetFloat("fortitude");
cls.ReflexSaveRate = node.GetFloat("reflex");
cls.WillSaveRate = node.GetFloat("will");
cls.ClassDevelopmentAge = node.GetEnum <ClassDevelopmentAge>("developedage");
var armor = node.GetCommaStringOptional("armorproficiencies");
cls.ArmorProficiencies.Add(armor);
var weapons = node.GetCommaStringOptional("weaponproficiencies");
cls.WeaponProficiencies.Add(weapons);
// Get the Skills for this class
var skills = node.GetNode("skills").Children();
foreach (var s in skills)
{
cls.AddClassSkill(s.Value);
}
classes.Add(cls);
}
return(classes);
}
private void ProcessSteps(CharacterSheet character, CharacterStrategy strategy)
{
foreach (var step in designSteps)
{
ShortLog.DebugFormat("Executing Step: {0}", step);
step.ExecuteStep(character);
}
}
public void Initialize(ComponentContainer components)
{
var sr = components.Get <SkillRanks>();
foreach (var s in this.SkillNames)
{
sr.SetClassSkill(s);
}
ShortLog.DebugFormat("Adding Class Skills: {0}".Formatted(this.SkillNames));
}
/// <summary>
/// Gets all of the feats.
/// </summary>
/// <returns>The feats that are loaded.</returns>
public static IList <Feat> GetFeats()
{
if (loadedFeats == null || loadedFeats.Count == 0)
{
var yaml = FileHelper.OpenYaml(TraitDataFile);
loadedFeats = LoadFromYaml(yaml);
ShortLog.Debug("Loaded Traits: " + loadedFeats.Count);
}
return(loadedFeats);
}
public IEnumerable <IObjectStore> GetDataFiles <T>()
{
var type = typeof(T);
if (!fileListMap.ContainsKey(type.FullName))
{
ShortLog.ErrorFormat("Could not find data file of type: {0}", type.FullName);
throw MissingDataFileException.MissingDataFilesForType(type.FullName);
}
return(fileListMap[type.FullName]);
}
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 Add <T>(T feature)
{
ShortLog.DebugFormat("Adding component: {0}", feature.ToString());
this.Components.Add(feature);
var statMod = feature as IModifiesStats;
if (statMod != null)
{
this.ProcessStatModifier(statMod);
}
}
/// <summary>
/// Adds a class skill.
/// </summary>
/// <param name="name">Name of the skill.</param>
public void AddClassSkill(string name)
{
if (!this.IsClassSkill(name))
{
this.ClassSkills.Add(name);
}
else
{
ShortLog.Debug("Not adding class skill as it already is there: " + name);
}
}
public virtual void ExecuteStep(CharacterSheet character)
{
ShortLog.DebugFormat("Executing Designer: {0}", Name);
if (DesignerType == Type.LevelUp)
{
ProcessLevelUp(character, character.Strategy);
}
else
{
ProcessSteps(character, character.Strategy);
}
}
public Armor(IObjectStore data)
{
ShortLog.DebugFormat("Loading Armor: {0}", data.GetString("name"));
this.Name = data.GetString("name");
this.ArmorClass = data.GetInteger("armor_class");
this.Weight = data.GetFloat("weight");
this.MaximumDexterityBonus = data.GetInteger("maximum_dexterity_bonus");
this.ArmorCheckPenalty = data.GetInteger("armor_check_penalty");
this.ArcaneSpellFailureChance = data.GetInteger("arcane_spell_failure_chance");
this.ArmorType = data.GetEnum <ArmorType>("armor_type");
this.Value = data.GetString("cost").ToCoinValue();
}
/// <summary>
/// Gets the skill.
/// </summary>
/// <returns>The skill.</returns>
/// <param name="skill">Skill name to lookup.</param>
public CharacterSkill GetSkill(string skill)
{
try
{
return(this.skills[skill]);
}
catch
{
ShortLog.ErrorFormat("Cannot find skill: {0}", skill);
throw;
}
}
/// <summary>
/// The implementing class must handle modifiers to stats under its control
/// </summary>
/// <param name="modifier">Modifier for stats</param>
public void ProcessModifier(IModifiesStats modifier)
{
foreach (var a in modifier.Modifiers)
{
CharacterSkill sk;
if (this.skills.TryGetValue(a.StatisticName, out sk))
{
ShortLog.DebugFormat("Modifying Skill ({0}) by {1}", a.StatisticName, a.Modifier.ToString());
sk.AddModifier(a);
}
}
}
public void ExecuteStep(CharacterSheet character)
{
var tokens = character.GetAll <SkillModifierToken>();
foreach (var token in tokens)
{
var matchingSkills = character.SkillRanks.GetSkills().Where(x => token.Qualifies(x.Skill));
var chosen = matchingSkills.ChooseOne();
ShortLog.DebugFormat("Skill Modifier Token assigned to {0}", chosen.Skill.Name);
chosen.AddModifier(token.CreateModifier(chosen.Skill));
}
}
/// <summary>
/// Gets a wrapper node based on key for traversing trees. Throws exception if not found
/// </summary>
/// <returns>The node from the key</returns>
/// <param name="key">Key to lookup in YAML node</param>
public YamlNodeWrapper GetNode(string key)
{
try
{
var item = this.mappingNode.Children[new YamlScalarNode(key)];
return(new YamlNodeWrapper(item));
}
catch
{
ShortLog.ErrorFormat("Yaml Node not found: {0}", key);
throw;
}
}
public void LoadAndRunAllDesignersToLevel20()
{
var strategies = GatewayProvider.All <CharacterStrategy>();
foreach (var strat in strategies)
{
ShortLog.DebugFormat("Validating Strategy: {0}", strat.Name);
strat.TargetLevel = 20;
var gen = GatewayProvider.Find <CharacterDesigner>(strat.Designer);
var character = new CharacterSheet(strat);
gen.ExecuteStep(character);
}
}
public static void DebugReflector()
{
var assemblies = GetAssemblies();
foreach (var a in assemblies)
{
ShortLog.DebugFormat("Loaded Assembly: {0}", a.FullName);
foreach (var t in a.GetExportedTypes().OrderBy(x => x.FullName))
{
ShortLog.DebugFormat("Exported Type: {0}", t.FullName);
}
}
}
public static T Instantiate <T>(this string typeName, params IObjectStore[] constructor)
{
// Search all loaded assemblies for the type name
var type = FindType(typeName);
if (type == null)
{
throw new TypeNotFoundException(typeName);
}
ShortLog.DebugFormat("Type is: {0}", type.ToString());
return(type.Instantiate <T>(constructor));
}
private void LoadObject(IObjectStore data)
{
Name = data.GetString("name");
ShortLog.Debug("Loading Race: " + Name);
SizeSetting = (CharacterSize)System.Enum.Parse(typeof(CharacterSize), data.GetString("size"));
HeightRange = DiceStrings.ParseDice(data.GetString("height"));
WeightRange = DiceStrings.ParseDice(data.GetString("weight"));
BaseMovementSpeed = data.GetInteger("basemovementspeed");
var languages = data.GetObject("languages");
KnownLanguages.Add(languages.GetListOptional("known"));
AvailableLanguages.Add(languages.GetListOptional("available"));
}
/// <summary>
/// Loads from yaml.
/// </summary>
/// <param name="yaml">Yaml data to parse.</param>
private void LoadFromYaml(YamlNodeWrapper yaml)
{
this.races = new List <Race>();
foreach (var raceNode in yaml.Children())
{
var race = new Race();
race.Name = raceNode.GetString("name");
ShortLog.Debug("Loading Race: " + race.Name);
race.SizeSetting = (CharacterSize)System.Enum.Parse(typeof(CharacterSize), raceNode.GetString("size"));
race.HeightRange = DiceStrings.ParseDice(raceNode.GetString("height"));
race.WeightRange = DiceStrings.ParseDice(raceNode.GetString("weight"));
var abilities = raceNode.GetNode("abilities");
foreach (var ability in abilities.ChildrenToDictionary())
{
var modifier = new AbilityScoreAdjustment();
modifier.Reason = "Racial Trait";
modifier.Modifier = int.Parse(ability.Value);
// Special case is races that can choose
if (string.Compare(ability.Key, "choose", true) == 0)
{
modifier.RacialModifier = true;
}
else
{
modifier.AbilityName = AbilityScore.GetType(ability.Key);
}
race.AbilityModifiers.Add(modifier);
}
var traits = raceNode.GetNode("traits");
foreach (var trait in traits.Children())
{
race.Traits.Add(trait.Value);
}
var languages = raceNode.GetNode("languages");
race.KnownLanguages.Add(languages.GetCommaStringOptional("known"));
race.AvailableLanguages.Add(languages.GetCommaStringOptional("available"));
// Get Speed
race.BaseMovementSpeed = raceNode.GetInteger("basemovementspeed");
this.races.Add(race);
}
}
public void ExecuteStep(CharacterSheet character)
{
if (character.Get <ICastingPreparation>() == null)
{
return;
}
ShortLog.Debug("-- PrepareSpells --");
var spellCastings = character.GetAll <ICastingPreparation>();
foreach (var sc in spellCastings)
{
Prepare(sc);
}
}
private void LoadObject(IObjectStore data)
{
ShortLog.DebugFormat("Loading Feat: {0}", Name);
Description = data.GetStringOptional("description");
AllowMultiple = data.GetBoolOptional("allow-multiple");
// Get any prerequisites
var prereq = data.GetObjectListOptional("prerequisites");
if (prereq != null)
{
Prerequisites = new PrerequisiteList(prereq);
}
Tags = data.GetListOptional("tags").ToList();
}
public static void InitializeHelpers()
{
//Only initialize Once TODO - Better solutions
if (helpers.Count > 0)
{
return;
}
Handlebars.RegisterHelper("descriptor", (writer, context, parameters) => {
ShortLog.DebugFormat("Getting descriptor: {0}", parameters[0].ToString());
var value = context.descriptors[parameters[0].ToString()] as string[];
writer.WriteSafeString(value.ChooseOne());
});
RegisterSupportedHelpers();
}
private void FilterPreferredFeats(CharacterSheet character, WeightedOptionTable <string> preferredFeats, FeatToken token)
{
foreach (var entry in preferredFeats.All)
{
var f = feats.Find(entry.Option);
if (FeatIsValid(f, token, character))
{
preferredFeats.Enable(entry.Option);
}
else
{
preferredFeats.Disable(entry.Option);
ShortLog.DebugFormat("Preferred Feat [{0}] Token [{1}]- Not meeting requirements", f.Name, token.ToString());
}
}
}
private void LoadDescriptors(IEnumerable <IObjectStore> descriptors)
{
if (descriptors == null)
{
return;
}
foreach (var descriptor in descriptors)
{
// Descriptor format in YAML is "- key: [item1, item2, item3]"
var keyName = descriptor.Keys.First();
ShortLog.DebugFormat("Descriptor KeyName: {0}", keyName);
var m = descriptor.GetList(keyName);
Descriptors.Add(keyName, m);
}
}
public Weapon(IObjectStore data)
{
ShortLog.DebugFormat("Loading Weapon: {0}", data.GetString("name"));
this.Name = data.GetString("name");
this.Weight = data.GetFloat("weight");
this.Damage = data.GetString("damage");
this.DamageType = data.GetEnum <DamageTypes>("damage_type");
this.CriticalThreat = data.GetIntegerOptional("critical_threat");
this.CriticalModifier = data.GetIntegerOptional("critical_modifier");
this.Range = data.GetIntegerOptional("range");
this.Type = data.GetEnum <WeaponType>("type");
this.Group = data.GetEnum <WeaponGroup>("group");
this.Level = data.GetEnum <WeaponTrainingLevel>("training_level");
this.Value = data.GetStringOptional("cost").ToCoinValue();
this.CriticalThreat = this.CriticalThreat == 0 ? 20 : this.CriticalThreat;
this.CriticalModifier = this.CriticalModifier == 0 ? 2 : this.CriticalModifier;
}
