private void Initialize()
{
if (_monsterModel.Size != CreatureSize.None && !String.IsNullOrWhiteSpace(_monsterModel.Type) && !String.IsNullOrWhiteSpace(_monsterModel.Alignment))
{
string sizeString = _stringService.GetString(_monsterModel.Size);
_details = _stringService.CapitalizeWords(sizeString + " " + _monsterModel.Type + ", " + _monsterModel.Alignment);
}
else if (_monsterModel.Size != CreatureSize.None && !String.IsNullOrWhiteSpace(_monsterModel.Type))
{
string sizeString = _stringService.GetString(_monsterModel.Size);
_details = _stringService.CapitalizeWords(sizeString + " " + _monsterModel.Type);
}
else if (_monsterModel.Size != CreatureSize.None)
{
_details = _stringService.GetString(_monsterModel.Size);
}
else if (!String.IsNullOrWhiteSpace(_monsterModel.Type))
{
_details = _monsterModel.Type;
}
else
{
_details = "Unknown";
}
}
/// <summary>
/// Creates an instance of <see cref="MonsterViewModel"/>
/// </summary>
public MonsterViewModel(MonsterModel monsterModel)
{
_monsterModel = monsterModel;
_size = _monsterModel.Size != CreatureSize.None ? _stringService.GetString(_monsterModel.Size) : "Unknown";
_alignment = !String.IsNullOrWhiteSpace(_monsterModel.Alignment) ? _stringService.CapitalizeWords(_monsterModel.Alignment) : "Unknown";
_ac = !String.IsNullOrWhiteSpace(_monsterModel.AC) ? _stringService.CapitalizeWords(_monsterModel.AC) : "Unknown";
_hp = !String.IsNullOrWhiteSpace(_monsterModel.HP) ? _monsterModel.HP : "Unknown";
_type = !String.IsNullOrWhiteSpace(_monsterModel.Type) ? _stringService.CapitalizeWords(_monsterModel.Type) : "Unknown";
if (!String.IsNullOrWhiteSpace(_monsterModel.CR))
{
string xp = _stringService.CRXPString(_monsterModel.CR);
if (!String.IsNullOrWhiteSpace(xp))
{
_cr = String.Format("{0} ({1} XP)", _monsterModel.CR, xp);
}
else
{
_cr = _monsterModel.CR;
}
}
else
{
_cr = "Unknown";
}
_passivePerception = _monsterModel.PassivePerception.ToString();
_speed = !String.IsNullOrWhiteSpace(_monsterModel.Speed) ? _stringService.CapitalizeWords(_monsterModel.Speed) : "Unknown";
_strength = _monsterModel.Strength.ToString();
_dexterity = _monsterModel.Dexterity.ToString();
_constitution = _monsterModel.Constitution.ToString();
_intelligence = _monsterModel.Intelligence.ToString();
_wisdom = _monsterModel.Wisdom.ToString();
_charisma = _monsterModel.Charisma.ToString();
_strengthBonus = _statService.GetStatBonusString(_monsterModel.Strength);
_dexterityBonus = _statService.GetStatBonusString(_monsterModel.Dexterity);
_constitutionBonus = _statService.GetStatBonusString(_monsterModel.Constitution);
_intelligenceBonus = _statService.GetStatBonusString(_monsterModel.Intelligence);
_wisdomBonus = _statService.GetStatBonusString(_monsterModel.Wisdom);
_charismaBonus = _statService.GetStatBonusString(_monsterModel.Charisma);
_strengthSave = _monsterModel.Saves.ContainsKey(Ability.Strength) ? _statService.AddPlusOrMinus(_monsterModel.Saves[Ability.Strength]) : _strengthBonus;
_dexteritySave = _monsterModel.Saves.ContainsKey(Ability.Dexterity) ? _statService.AddPlusOrMinus(_monsterModel.Saves[Ability.Dexterity]) : _dexterityBonus;
_constitutionSave = _monsterModel.Saves.ContainsKey(Ability.Constitution) ? _statService.AddPlusOrMinus(_monsterModel.Saves[Ability.Constitution]) : _constitutionBonus;
_intelligenceSave = _monsterModel.Saves.ContainsKey(Ability.Intelligence) ? _statService.AddPlusOrMinus(_monsterModel.Saves[Ability.Intelligence]) : _intelligenceBonus;
_wisdomSave = _monsterModel.Saves.ContainsKey(Ability.Wisdom) ? _statService.AddPlusOrMinus(_monsterModel.Saves[Ability.Wisdom]) : _wisdomBonus;
_charismaSave = _monsterModel.Saves.ContainsKey(Ability.Charisma) ? _statService.AddPlusOrMinus(_monsterModel.Saves[Ability.Charisma]) : _charismaBonus;
foreach (KeyValuePair <Skill, int> skillPair in _monsterModel.Skills)
{
string skillString = _stringService.GetString(skillPair.Key);
string skillRoll = _statService.AddPlusOrMinus(skillPair.Value);
_skills[skillString] = skillRoll;
}
_vulnerabilities = !String.IsNullOrWhiteSpace(_monsterModel.Vulnerabilities) ? _stringService.CapitalizeWords(_monsterModel.Vulnerabilities) : "None";
_resistances = !String.IsNullOrWhiteSpace(_monsterModel.Resistances) ? _stringService.CapitalizeWords(_monsterModel.Resistances) : "None";
_immunities = !String.IsNullOrWhiteSpace(_monsterModel.Immunities) ? _stringService.CapitalizeWords(_monsterModel.Immunities) : "None";
_conditionImmunities = !String.IsNullOrWhiteSpace(_monsterModel.ConditionImmunities) ? _stringService.CapitalizeWords(_monsterModel.ConditionImmunities) : "None";
_senses = !String.IsNullOrWhiteSpace(_monsterModel.Senses) ? _stringService.CapitalizeWords(_monsterModel.Senses) : "None";
_languages = _monsterModel.Languages.Count > 0 ? _stringService.CapitalizeWords(String.Join(", ", _monsterModel.Languages)) : "None";
_environment = !String.IsNullOrWhiteSpace(_monsterModel.Environment) ? _stringService.CapitalizeWords(_monsterModel.Environment) : "Unknown";
_description = _monsterModel.Description;
foreach (TraitModel traitModel in _monsterModel.Traits)
{
_traits.Add(new TraitViewModel(traitModel));
}
foreach (MonsterActionModel monsterAction in _monsterModel.Actions)
{
_actions.Add(new MonsterActionViewModel(monsterAction));
}
foreach (MonsterActionModel monsterAction in _monsterModel.Reactions)
{
_reactions.Add(new MonsterActionViewModel(monsterAction));
}
foreach (MonsterActionModel monsterAction in _monsterModel.LegendaryActions)
{
_legendaryActions.Add(new MonsterActionViewModel(monsterAction));
}
_spellSlots = new List <string>(_monsterModel.SpellSlots);
while (_spellSlots.Count < 9)
{
_spellSlots.Add("0");
}
_spells = new List <string>(_monsterModel.Spells);
_rollAbilityBonusCommand = new RelayCommand(obj => true, obj => RollAbilityBonus((Ability)obj));
_rollAbilitySaveCommand = new RelayCommand(obj => true, obj => RollAbilitySave((Ability)obj));
_rollSkillCommand = new RelayCommand(obj => true, obj => RollSkill((string)obj));
_rollAttackToHitCommand = new RelayCommand(obj => true, obj => RollAttackToHit((MonsterAttackViewModel)obj));
_rollAttackDamageCommand = new RelayCommand(obj => true, obj => RollAttackDamage((MonsterAttackViewModel)obj));
_showSpellDialogCommand = new RelayCommand(obj => true, obj => ShowSpellDialog((string)obj));
}
/// <summary>
/// Creates an instance of <see cref="RandomEncounterDialogViewModel"/>
/// </summary>
public RandomEncounterDialogViewModel(List <EncounterCharacterModel> encounterCharacters)
{
_encounterCharacters = encounterCharacters;
foreach (EncounterChallenge encounterChallenge in Enum.GetValues(typeof(EncounterChallenge)))
{
if (encounterChallenge != EncounterChallenge.Unknown)
{
_difficultyOptions.Add(new KeyValuePair <EncounterChallenge, string>(encounterChallenge, _stringService.GetString(encounterChallenge)));
}
}
_selectedDifficultyOption = _difficultyOptions.FirstOrDefault();
_environmentOptions.Add(new KeyValuePair <string, string>(null, "Any Environment"));
foreach (MonsterModel monster in _compendium.Monsters)
{
if (!String.IsNullOrWhiteSpace(monster.Environment))
{
foreach (string environmentSplit in monster.Environment.Split(new char[] { ',' }))
{
string environment = environmentSplit.Trim();
if (!_environmentOptions.Any(x => x.Value.ToLower() == environment.ToLower()))
{
_environmentOptions.Add(new KeyValuePair <string, string>(environment, _stringService.CapitalizeWords(environment)));
}
}
}
}
_selectedEnvironmentOption = _environmentOptions.FirstOrDefault();
_minMonsters = 1;
_maxMonsters = 10;
_acceptCommand = new RelayCommand(obj => true, obj => OnAccept());
_rejectCommand = new RelayCommand(obj => true, obj => OnReject());
_generateMonstersCommand = new RelayCommand(obj => true, obj => GenerateMonsters());
_viewMonsterDetailsCommand = new RelayCommand(obj => true, obj => ViewMonsterDetails((EncounterMonsterViewModel)obj));
}
private void InitializeFromMonsterModel()
{
if (_monsterModel != null)
{
Name = _monsterModel.Name;
string hpString = _monsterModel.HP;
if (hpString.Contains(" "))
{
hpString = hpString.Split(new char[] { ' ' })[0];
}
int hp = 0;
if (int.TryParse(hpString, out hp))
{
MaxHP = hp;
}
PassivePerception = _monsterModel.PassivePerception;
string acString = _monsterModel.AC;
if (acString.Contains(" "))
{
acString = acString.Split(new char[] { ' ' })[0];
}
int ac = 0;
if (int.TryParse(acString, out ac))
{
AC = ac;
}
InitiativeBonus = _statService.GetStatBonus(_monsterModel.Dexterity);
_cr = _monsterModel.CR;
List <MonsterAttackModel> attacks = new List <MonsterAttackModel>();
foreach (MonsterActionModel monsterActionModel in _monsterModel.Actions)
{
foreach (MonsterAttackModel monsterAttack in monsterActionModel.Attacks)
{
attacks.Add(monsterAttack);
}
}
int numberOfAttacks = 1;
List <KeyValuePair <MonsterAttackModel, int> > multiattacks = new List <KeyValuePair <MonsterAttackModel, int> >();
foreach (MonsterActionModel monsterActionModel in _monsterModel.Actions)
{
if (monsterActionModel.Name.ToLower().Contains("multiattack") ||
monsterActionModel.Name.ToLower().Contains("multi-attack"))
{
string multiattackText = String.Join(" ", monsterActionModel.TextCollection).ToLower();
int attacksIndex = multiattackText.IndexOf("attacks");
if (attacksIndex != -1)
{
string upToAttacks = multiattackText.Substring(0, attacksIndex);
foreach (string word in upToAttacks.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Reverse())
{
if (word == "one")
{
numberOfAttacks = 1;
break;
}
else if (word == "two")
{
numberOfAttacks = 2;
break;
}
else if (word == "three")
{
numberOfAttacks = 3;
break;
}
else if (word == "four")
{
numberOfAttacks = 4;
break;
}
else if (word == "five")
{
numberOfAttacks = 5;
break;
}
}
}
foreach (MonsterAttackModel monsterAttackModel in attacks)
{
int nameIndex = multiattackText.IndexOf(monsterAttackModel.Name.ToLower());
if (nameIndex != -1)
{
string upToAttackName = multiattackText.Substring(0, nameIndex);
foreach (string word in upToAttackName.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Reverse())
{
if (word == "one")
{
multiattacks.Add(new KeyValuePair <MonsterAttackModel, int>(monsterAttackModel, 1));
break;
}
else if (word == "two")
{
multiattacks.Add(new KeyValuePair <MonsterAttackModel, int>(monsterAttackModel, 2));
break;
}
else if (word == "three")
{
multiattacks.Add(new KeyValuePair <MonsterAttackModel, int>(monsterAttackModel, 3));
break;
}
else if (word == "four")
{
multiattacks.Add(new KeyValuePair <MonsterAttackModel, int>(monsterAttackModel, 4));
break;
}
else if (word == "five")
{
multiattacks.Add(new KeyValuePair <MonsterAttackModel, int>(monsterAttackModel, 5));
break;
}
}
}
}
}
}
int averageMultiAttackDamage = 0;
foreach (KeyValuePair <MonsterAttackModel, int> multiAttackPair in multiattacks)
{
if (attacks.Contains(multiAttackPair.Key))
{
attacks.Remove(multiAttackPair.Key);
}
if (!String.IsNullOrEmpty(multiAttackPair.Key.Roll))
{
(double, double, double)avgMinMax = _diceService.EvaluateExpressionAvgMinMax(multiAttackPair.Key.Roll);
averageMultiAttackDamage += (int)avgMinMax.Item1 * multiAttackPair.Value;
}
}
int averageSingleAttackDamage = 0;
int totalAverageSingleAttackDamage = 0;
int attacksWithRolls = 0;
foreach (MonsterAttackModel monsterAttackModel in attacks)
{
if (!String.IsNullOrEmpty(monsterAttackModel.Roll))
{
(double, double, double)avgMinMax = _diceService.EvaluateExpressionAvgMinMax(monsterAttackModel.Roll);
totalAverageSingleAttackDamage += (int)avgMinMax.Item1;
attacksWithRolls++;
}
}
if (attacksWithRolls > 0)
{
averageSingleAttackDamage = totalAverageSingleAttackDamage / attacksWithRolls;
}
int averageSpellDamage = 0;
int totalAverageSpellDamage = 0;
int spellsWithRolls = 0;
foreach (string spellName in _monsterModel.Spells)
{
SpellModel spellModel = _compendium.Spells.FirstOrDefault(x => x.Name.ToLower() == spellName.ToLower());
if (spellModel != null && spellModel.Rolls.Any())
{
int maxRoll = 0;
foreach (string roll in spellModel.Rolls)
{
(double, double, double)avgMinMax = _diceService.EvaluateExpressionAvgMinMax(roll);
maxRoll = Math.Max((int)avgMinMax.Item1, maxRoll);
}
totalAverageSpellDamage += maxRoll;
spellsWithRolls++;
}
}
if (spellsWithRolls > 0)
{
averageSpellDamage = totalAverageSpellDamage / spellsWithRolls;
}
_averageDamageTurn = Math.Max(Math.Max(averageMultiAttackDamage, averageSingleAttackDamage), averageSpellDamage);
_damageVulnerabilities = _stringService.CapitalizeWords(_monsterModel.Vulnerabilities);
_damageResistances = _stringService.CapitalizeWords(_monsterModel.Resistances);
_damageImmunities = _stringService.CapitalizeWords(_monsterModel.Immunities);
_conditionImmunities = _stringService.CapitalizeWords(_monsterModel.ConditionImmunities);
}
else
{
Name = String.Empty;
PassivePerception = 0;
InitiativeBonus = 0;
_averageDamageTurn = 0;
_quantity = 1;
_cr = String.Empty;
_damageVulnerabilities = String.Empty;
_damageResistances = String.Empty;
_damageImmunities = String.Empty;
_conditionImmunities = String.Empty;
}
}
/// <summary>
/// Creates an instance of <see cref="MonsterSearchInput"/>
/// </summary>
public MonsterSearchInput(Compendium compendium, StringService stringService, StatService statService)
{
_compendium = compendium;
_stringService = stringService;
_statService = statService;
foreach (MonsterSortOption sort in Enum.GetValues(typeof(MonsterSortOption)))
{
_sortOptions.Add(new KeyValuePair <MonsterSortOption, string>(sort, sort.ToString().Replace("_", " ")));
}
_sizes.Add(new KeyValuePair <CreatureSize, string>(CreatureSize.None, "Any Size"));
foreach (CreatureSize size in Enum.GetValues(typeof(CreatureSize)))
{
if (size != CreatureSize.None)
{
_sizes.Add(new KeyValuePair <CreatureSize, string>(size, _stringService.GetString(size)));
}
}
_alignments.Add(new KeyValuePair <Alignment, string>(Enums.Alignment.None, "Any Alignment"));
foreach (Alignment alignment in Enum.GetValues(typeof(Alignment)))
{
if (alignment != Enums.Alignment.None)
{
_alignments.Add(new KeyValuePair <Alignment, string>(alignment, _stringService.GetString(alignment)));
}
}
foreach (MonsterModel monster in _compendium.Monsters)
{
if (!_types.Any(x => x.Value.ToLower() == monster.Type.ToLower()))
{
_types.Add(new KeyValuePair <string, string>(monster.Type, _stringService.CapitalizeWords(monster.Type)));
}
int number = 0;
if (!_crs.Any(x => x.Value == monster.CR) && (monster.CR.Contains("/") || Int32.TryParse(monster.CR, out number)))
{
_crs.Add(new KeyValuePair <string, string>(monster.CR, monster.CR));
}
if (!String.IsNullOrWhiteSpace(monster.Environment))
{
foreach (string environmentSplit in monster.Environment.Split(new char[] { ',' }))
{
string environment = environmentSplit.Trim();
if (!_environments.Any(x => x.Value.ToLower() == environment.ToLower()))
{
_environments.Add(new KeyValuePair <string, string>(environment, _stringService.CapitalizeWords(environment)));
}
}
}
}
_types = _types.OrderBy(x => x.Value).ToList();
_types.Insert(0, new KeyValuePair <string, string>(null, "Any Type"));
_crs = _crs.OrderBy(x => _statService.CRToFloat(x.Value)).ToList();
_crs.Insert(0, new KeyValuePair <string, string>("-", "Unknown"));
_crs.Insert(0, new KeyValuePair <string, string>(null, "Any CR"));
_environments = _environments.OrderBy(x => x.Value).ToList();
_environments.Insert(0, new KeyValuePair <string, string>(null, "Any Environment"));
Reset();
}
