/// <summary>
/// Assigns the ability scores to the character
/// </summary>
/// <param name="abilities">Abilities to assign score to.</param>
public void AssignAbilities(AbilityScores abilities)
{
foreach (var e in EnumHelpers.GetValues <AbilityScoreTypes>())
{
abilities.SetScore(e, AverageScore);
}
}
public int GetAbilityScoreValue(string ScoreName)
{
if (ScoreName.Length == 0)
{
return(-100);
}
AbilityScores = AbilityScores.Replace("*", string.Empty);
List <string> Scores = AbilityScores.Split(',').ToList();
string temp = string.Empty;
foreach (string score in Scores)
{
if (score.Contains(ScoreName))
{
temp = score.Replace(ScoreName, string.Empty).Trim();
if (temp == "-")
{
temp = "0";
}
if (temp.IndexOf(PathfinderConstants.PAREN_LEFT) >= 0)
{
temp = temp.Substring(0, temp.IndexOf(PathfinderConstants.PAREN_LEFT));
}
return(Convert.ToInt32(temp));
}
}
return(-100);
}
public static int SetInitialHitPoints(int Level, IClass Class, AbilityScores AbilityScores, int?CurrentHP)
{
int returnHP = 0;
if (CurrentHP == null)
{
if (Level == 1)
{
returnHP = Class.HitDie + AbilityScores.Constitution.HitPointAdjustment;
}
else
{
for (int i = 0; i <= Level - 1; i++)
{
int roll = 0;
if (i == 0)
{
roll = Class.HitDie;
}
else
{
roll = DiceManager.Roll(1, Class.HitDie).Total + AbilityScores.Constitution.HitPointAdjustment;
}
returnHP += roll;
}
}
}
else
{
returnHP = Convert.ToInt32(CurrentHP);
}
return(returnHP);
}
public string WeaponAttackBonus(int equipmentId)
{
var weapon = Equipment.Single(n => n.Id == equipmentId).Equipment;
var bonus = 0;
var strBonus = AbilityScores.Single(n => n.AbilityId == 1).Bonus;
var dexBonus = AbilityScores.Single(n => n.AbilityId == 2).Bonus;
if (weapon.WeaponType.IsRanged)
{
bonus = dexBonus;
}
else
{
bonus = strBonus;
}
if (weapon.WeaponType.IsFinesse)
{
if (weapon.WeaponType.IsFinesse)
{
bonus = Math.Max(strBonus, dexBonus);
}
}
var proficiencyBonus = _ProficiencyBonus; //TODO: Get weapon proficiency from user
var weaponBonus = weapon.Bonus + bonus + proficiencyBonus;
if (weaponBonus >= 0)
{
return("+" + weaponBonus.ToString());
}
return(weaponBonus.ToString());
}
/// <summary>
/// Assigns the abilities.
/// </summary>
/// <param name="abilities">Abilities to assign to</param>
public void AssignAbilities(AbilityScores abilities)
{
foreach (var e in EnumHelpers.GetValues <AbilityScoreTypes>())
{
abilities.SetScore(e, this.Roll4d6());
}
}
public AbilityScoreViewModel()
{
navManager = PageNavigationManager.Instance;
D6 = new Dice(6);
Scores = Statics.CharacterCreating.CreatingCharacter.Scores;
Numbers = Statics.CharacterCreating.ScoreRolls;
NumbersUsed = Statics.CharacterCreating.ScoreRollsUsed;
}
public string SavingThrowBonus(int abilityId)
{
var bonus = AbilityScores.Single(n => n.AbilityId == abilityId).Bonus;
var proficiencyBonus = SavingThrows.Contains(abilityId) ? _ProficiencyBonus : 0;
var total = bonus + proficiencyBonus;
return((total >= 0 ? "+" : null) + total.ToString());
}
public GrammarParseResult GetValue(string name)
{
CreatureAction action = Prototype.CreatureActions.SingleOrDefault(x => x.Name.Equals(name));
if (action != null)
{
return(Engine.Parsers.ParserHelper.Evaluate(action.ActionText, Controller.Instance.CurrentRuleSet));
}
//Assume it's an attribute if it's not an action
GrammarParseResult result = new GrammarParseResult($"{IndividualName}'s ({Prototype.EntityName}) {name}");
//Check Abilities
AbilityAttr ability = AbilityScores.SingleOrDefault(x => x.Key.Name.Equals(name)).Key;
if (ability != null)
{
result.Value = AbilityScores[ability];
result.EvaluatedText = AbilityScores[ability].ToString();
return(result);
}
//Check Ability Skills
AbilitySkillAttr abilityskill = AbilitySkillScores.SingleOrDefault(x => x.Key.Name.Equals(name)).Key;
if (ability != null)
{
result.Value = AbilitySkillScores[abilityskill];
result.EvaluatedText = AbilitySkillScores[abilityskill].ToString();
return(result);
}
//Check Counters
CounterAttr counter = CounterValues.SingleOrDefault(x => x.Key.Name.Equals(name)).Key;
if (ability != null)
{
result.Value = CounterValues[counter];
result.EvaluatedText = CounterValues[counter].Value.ToString();
return(result);
}
//Check Other Attributes
OtherAttr otherAttr = OtherScores.SingleOrDefault(x => x.Key.Name.Equals(name)).Key;
if (ability != null)
{
result.Value = OtherScores[otherAttr];
result.EvaluatedText = OtherScores[otherAttr].ToString();
return(result);
}
result.IsSuccessful = false;
result.Value = 0;
result.Output = $"Creatures of type \"{Prototype.EntityName}\" do not have an action or attribute with name \"{name}\"";
return(result);
}
// TODO alter this -- temporary for runtime example -- need to change according to character creation
private void Awake()
{
this.initiative = 0;
this.abilityScores = new AbilityScores();
this.isAlive = true;
this.CharacterName = "test" + this.name;
this.CharacterClass = new VanillaRogue();
this.Race = new DummyRace();
}
public void InitiativeIsBasedOnDexterity()
{
var abilities = new AbilityScores();
abilities.SetScore(AbilityScoreTypes.Dexterity, 18);
var init = new Initiative(abilities);
Assert.AreEqual(4, init.TotalValue);
}
public string SkillBonus(int skillId)
{
var skill = Skills.Single(n => n.Id == skillId);
var bonus = AbilityScores.Single(n => n.AbilityId == skill.AbilityId).Bonus;
var proficiencyBonus = PlayerSkills.Contains(skillId) ? _ProficiencyBonus : 0;
var total = bonus + proficiencyBonus;
return((total >= 0 ? "+" : null) + total.ToString());
}
public static int UpdateHitPoints(IClass Class, AbilityScores AbilityScores, int CurrentHP, int newLevels = 1)
{
int newRoll = CurrentHP;
for (int i = 0; i <= newLevels - 1; i++)
{
newRoll += DiceManager.Roll(1, Class.HitDie).Total + AbilityScores.Constitution.HitPointAdjustment;
}
return(newRoll);
}
public CombatScores(AbilityScores abilityScore, PersonalInformation personalInfo,
CharacterProgress characterProg)
{
abilityScores = abilityScore;
personalInformation = personalInfo;
characterProgress = characterProg;
currentHealth = getMaxHealth();
currentComposure = getMaxComposure();
}
public void TestMethod1()
{
AbilityScores scores = new AbilityScores();
int i = 4;
int[] testScore = new int[2] {
i, -3
};
scores.SetStat("Strength", i);
Assert.AreEqual(testScore[1], scores.Scores["Strength"][1]);
}
public void SetUp()
{
var abilities = new AbilityScores();
abilities.SetScore(AbilityScoreTypes.Strength, 16);
abilities.SetScore(AbilityScoreTypes.Dexterity, 16);
var size = new SizeStats(CharacterSize.Small, 1, 1);
inventory = new Inventory();
smallStats = new OffenseStats(abilities, size, inventory);
}
public void SetUp()
{
var abilities = new AbilityScores();
abilities.SetScore(AbilityScoreTypes.Strength, 16);
abilities.SetScore(AbilityScoreTypes.Dexterity, 16);
abilities.SetScore(AbilityScoreTypes.Constitution, 9);
abilities.SetScore(AbilityScoreTypes.Wisdom, 12);
var size = new SizeStats(CharacterSize.Small);
smallStats = new DefenseStats(abilities, size, new Inventory());
}
public static AbilityScores UpdateAbilityScores(AbilityScores abilityScores)
{
AbilityScoreManager abilityScoreRules = new AbilityScoreManager();
abilityScores.Strength = abilityScoreRules.SetStrength(abilityScores.Strength.Value);
abilityScores.Dexterity = abilityScoreRules.SetDexterity(abilityScores.Dexterity.Value);
abilityScores.Constitution = abilityScoreRules.SetConstitution(abilityScores.Constitution.Value);
abilityScores.Intelligence = abilityScoreRules.SetIntelligence(abilityScores.Intelligence.Value);
abilityScores.Wisdom = abilityScoreRules.SetWisdom(abilityScores.Wisdom.Value);
abilityScores.Charisma = abilityScoreRules.SetCharisma(abilityScores.Charisma.Value);
return(abilityScores);
}
public void CreateAverageScores()
{
var roller = new AverageAbilityScoreGenerator();
var abilities = new AbilityScores();
roller.AssignAbilities(abilities);
Assert.AreEqual(10, abilities.GetScore(AbilityScoreTypes.Strength));
Assert.AreEqual(10, abilities.GetScore(AbilityScoreTypes.Dexterity));
Assert.AreEqual(10, abilities.GetScore(AbilityScoreTypes.Constitution));
Assert.AreEqual(10, abilities.GetScore(AbilityScoreTypes.Intelligence));
Assert.AreEqual(10, abilities.GetScore(AbilityScoreTypes.Wisdom));
Assert.AreEqual(10, abilities.GetScore(AbilityScoreTypes.Charisma));
}
private void button_Click(object sender, RoutedEventArgs e)
{
AbilityScores frmAbility = new AbilityScores();
frmAbility.ShowDialog();
//tStr.Text = frmAbility.Strength.ToString();
//tDex.Text = frmAbility.Dexterity.ToString();
//tCon.Text = frmAbility.Constitution.ToString();
//tInt.Text = frmAbility.Intelligence.ToString();
//tWis.Text = frmAbility.Wisdom.ToString();
//tCha.Text = frmAbility.Charisma.ToString();
}
public void SetupCharacter()
{
_skillList = new List <Skill> ();
_skillList.Add(new Skill("Climb", AbilityScoreTypes.Strength, false));
_skillList.Add(new Skill("Disable Device", AbilityScoreTypes.Dexterity, true));
_skillList.Add(new Skill("Stealth", AbilityScoreTypes.Dexterity, false));
_abilityScores = new AbilityScores();
_abilityScores.SetScore(AbilityScoreTypes.Strength, 14);
_abilityScores.SetScore(AbilityScoreTypes.Dexterity, 12);
Subject = new SkillRanks(_skillList, _abilityScores);
}
//Level 1: 12 + Constitution Modifier
//Onwards: 1d12 (or 7) + Constitution Modifier
//TODO finish this method. Allow user to roll their hp somewhere?
public override int CalculateHitPoints(int level, AbilityScores scores)
{
int hp = 0;
if (level == 1)
{
hp = 12 + scores.Scores["Constitution"][1];
}
else
{
}
return(hp);
}
public void fillBarracks(GameObject barracksEntryTemplate, List <Character> characterList)
{
characters = characterList;
foreach (Character character in characters)
{
AbilityScores abilityScores = character.characterSheet.abilityScores;
GameObject newBarracksEntryPanel = (GameObject)Instantiate(barracksEntryTemplate);
BarracksEntry newBarracksEntry = newBarracksEntryPanel.GetComponentInChildren <BarracksEntry>();
newBarracksEntryPanel.transform.SetParent(barracksRoster.transform, false);
newBarracksEntry.assignCharacter(character);
characterEntries[character] = newBarracksEntry;
}
//Destroy(barracksEntryTemplate);
}
public void CharactersCanRollSomeStats()
{
var roller = new StandardAbilityScoreGenerator();
var abilities = new AbilityScores();
roller.AssignAbilities(abilities);
//Values should be between 3 and 18 for all abilities
foreach (var a in abilities.Abilities)
{
Assert.GreaterOrEqual(a.TotalValue, 3);
Assert.LessOrEqual(a.TotalValue, 18);
}
}
public CharacterSheet(AbilityScores abilityScore, PersonalInformation personalInfo,
CharacterProgress characterProg, CombatScores cScores, SkillScores sScores, CharacterColors characterColors, Character character, CharacterLoadout loadout)
{
abilityScores = abilityScore;
personalInformation = personalInfo;
characterProgress = characterProg;
combatScores = cScores;
skillScores = sScores;
inventory = new Inventory();
inventory.character = character;
this.characterColors = characterColors;
characterLoadout = new CharacterLoadoutActual(loadout, character, characterColors);
// Character Armor
// Character Inventory
}
public static AbilityScores Generate
(int strength, int dexterity, int constitution,
int wisdom, int intelligence, int charisma)
{
AbilityScores scores = new AbilityScores();
scores.Strength.ScoreValue = strength;
scores.Dexterity.ScoreValue = dexterity;
scores.Constitution.ScoreValue = constitution;
scores.Wisdom.ScoreValue = wisdom;
scores.Intelligence.ScoreValue = intelligence;
scores.Charisma.ScoreValue = charisma;
return(scores);
}
public static void Main()
{
var scores = new AbilityScores()
{
Speed = 1, Durability = 1
};
var skills = new Skills(scores);
Console.WriteLine("Before change: " + skills.GetCurrentScores());
scores.Speed = 2;
scores.Durability = 0;
Console.WriteLine("After change: " + skills.GetCurrentScores());
}
public void Test_AbilityScore_Creation(ScoreType primaryOriginAbilityScore, ScoreType secondaryOriginAbilityScore,
int expectedStrength, int expectedConstitution, int expectedDexterity, int expectedIntelligence, int expectedWisdom, int expectedCharisma)
{
AbilityScores abilityScores;
abilityScores = new AbilityScores(new NullOrigin(primaryOriginAbilityScore), new NullOrigin(secondaryOriginAbilityScore),
new int[]{ 14, 12, 10, 8, 6});
Assert.That(abilityScores[ScoreType.Strength], Is.EqualTo(expectedStrength), "Incorrect Strength");
Assert.That(abilityScores[ScoreType.Constitution], Is.EqualTo(expectedConstitution), "Incorrect Constitution");
Assert.That(abilityScores[ScoreType.Dexterity], Is.EqualTo(expectedDexterity), "Incorrect Dexterity");
Assert.That(abilityScores[ScoreType.Intelligence], Is.EqualTo(expectedIntelligence), "Incorrect Intelligence");
Assert.That(abilityScores[ScoreType.Wisdom], Is.EqualTo(expectedWisdom), "Incorrect Wisdom");
Assert.That(abilityScores[ScoreType.Charisma], Is.EqualTo(expectedCharisma), "Incorrect Charisma");
}
// FUNCTION: GetAbilityScoreModifier
// PARAMETERS: abilityScore:string, name of ability score
// RETURNS: int, the caluclated ability score mod
// Takes the name of an ability score, grabs the score from the Characters AbilityScores dictionary,
// and calculates the ability score modifier.
private int GetAbilityScoreModifier(string abilityScore)
{
if (!string.IsNullOrEmpty(abilityScore))
{
int abilityScoreValue = 0;
if (AbilityScores.ContainsKey(abilityScore))
{
abilityScoreValue = AbilityScores[abilityScore];
}
int totalAS = abilityScoreValue;
double modifier = ((Convert.ToDouble(totalAS) - 10) / 2.0);
return((int)Math.Floor(modifier));
}
return(0);
}
public void YouCanCopyOneSetOfAbilityScoresToAnother()
{
var abilityScores = new AbilityScores();
var copyFrom = new AbilityScores();
foreach (var e in copyFrom.Abilities)
{
e.SetValue(15);
}
abilityScores.Copy(copyFrom);
foreach (var e in abilityScores.Abilities)
{
Assert.AreEqual(e.TotalValue, copyFrom.GetScore(e.Name));
}
}
public void SetLevel1HitPoints()
{
var constitutionModifier = (int)AbilityScores.getAbilityScoreModifier(AbilityScores.GetConstitutionScore());
switch (ClassDetails.Name)
{
default: throw new Exception("invalid characterClass provided");
case "Barbarian": HitPoints = 12 + constitutionModifier; break;
case "Bard": HitPoints = 8 + constitutionModifier; break;
case "Cleric": HitPoints = 8 + constitutionModifier; break;
case "Druid": HitPoints = 8 + constitutionModifier; break;
case "Fighter": HitPoints = 10 + constitutionModifier; break;
case "Monk": HitPoints = 8 + constitutionModifier; break;
case "Paladin": HitPoints = 10 + constitutionModifier; break;
case "Ranger": HitPoints = 10 + constitutionModifier; break;
case "Rogue": HitPoints = 8 + constitutionModifier; break;
case "Sorcerer": HitPoints = 6 + constitutionModifier; break;
case "Warlock": HitPoints = 8 + constitutionModifier; break;
case "Wizard": HitPoints = 6 + constitutionModifier; break;
}
// The Hill Dwarf subrace hit point maximum increases by 1
if (this.RaceDetails.SubRace == "Hill Dwarf")
{
HitPoints += 1;
}
// Sorcerer Draconic Ancestry
if (this.ClassDetails.SorcerousOrigin == "Draconic")
{
HitPoints += 1;
}
}
/// <summary>
/// Sets the ability scores for race.
/// </summary>
/// <param name="abilities">Abilities for adjustments.</param>
/// <param name="race">Race selected.</param>
private void SetAbilityScoresForRace(AbilityScores abilities, Race race)
{
// Add Ability Modifiers
foreach (var adj in race.AbilityModifiers)
{
if (adj.RacialModifier)
{
var ability = EnumHelpers.ChooseOne <AbilityScoreTypes>();
var a = abilities.GetAbility(ability);
a.AddModifier(adj);
}
else
{
var a = abilities.GetAbility(adj.AbilityName);
a.AddModifier(adj);
}
}
}
