public static RPGArmor CreateRandomArmorPiece()
{
int c = new RPGCalc().Roll(Enum.GetValues(typeof(ArmorClass)).Length);
ArmorClass ac = (ArmorClass)Enum.Parse(typeof(ArmorClass), c.ToString());
return(new RPGArmor(ac));
}
public void MaxKeyAbilityScore_Aggregates()
{
// Arrange
var dexterity = Mock.Of <IAbilityScore>();
var abilityScores = new Mock <IAbilityScoreSection>();
abilityScores.Setup(abs => abs.Dexterity)
.Returns(dexterity);
var mockCharacter = new Mock <ICharacter>();
mockCharacter.Setup(c => c.AbilityScores)
.Returns(abilityScores.Object);
mockCharacter.Setup(c => c.Size)
.Returns(SizeCategory.Medium);
ArmorClass ac = new ArmorClass(mockCharacter.Object);
ac.MaxKeyAbilityScore.Add(() => 5);
ac.MaxKeyAbilityScore.Add(() => 1);
ac.MaxKeyAbilityScore.Add(() => 3);
// Act
var maxDex = ac.MaxKeyAbilityScore.GetTotal();
Assert.AreEqual(1, maxDex,
"An armor class has max dex equal to the smallest allowed max dex. (If there is a max dex of 5, 3, and 1, the actual max dex is 1.)");
}
public DnDObject(ArmorClass ac, HitPoints hp, PhysicalProperties physicalProperties, Resistance resistance)
{
AC = ac;
HP = hp;
PhysicalProperties = physicalProperties;
Resistance = resistance;
}
public void SizeBonuses_Small()
{
// Arrange
var dexterity = Mock.Of <IAbilityScore>();
var abilityScores = new Mock <IAbilityScoreSection>();
abilityScores.Setup(abs => abs.Dexterity)
.Returns(dexterity);
var mockCharacter = new Mock <ICharacter>();
mockCharacter.Setup(c => c.AbilityScores)
.Returns(abilityScores.Object);
mockCharacter.Setup(c => c.Size)
.Returns(SizeCategory.Small);
ArmorClass ac = new ArmorClass(mockCharacter.Object);
// Act
var modifier = ac.GetSizeModifier();
// Assert
Assert.AreEqual(1, modifier);
}
public void MaxKeyAbilityScore_Default()
{
// Arrange
var dexterity = Mock.Of <IAbilityScore>();
var abilityScores = new Mock <IAbilityScoreSection>();
abilityScores.Setup(abs => abs.Dexterity)
.Returns(dexterity);
var mockCharacter = new Mock <ICharacter>();
mockCharacter.Setup(c => c.AbilityScores)
.Returns(abilityScores.Object);
mockCharacter.Setup(c => c.Size)
.Returns(SizeCategory.Medium);
ArmorClass ac = new ArmorClass(mockCharacter.Object);
// Act
var maxDex = ac.MaxKeyAbilityScore.GetTotal();
Assert.AreEqual(Byte.MaxValue, maxDex,
"By default, an armor class has a max dex of +255.");
}
public static RPGArmor CreateRandomShield()
{
int c = new RPGCalc().Roll(3) + 8;
ArmorClass ac = (ArmorClass)Enum.Parse(typeof(ArmorClass), c.ToString());
return(new RPGArmor(ac));
}
public BaseBattleStats(ushort type,
byte lvl,
WeaponType weapon,
WeaponClass weaponClass,
ArmorType armor,
ArmorClass armorClass,
decimal maxHp,
decimal attack,
byte splash,
byte range,
byte stealth,
byte speed,
ushort groupSize,
ushort carry,
decimal normalizedCost)
{
Type = type;
Lvl = lvl;
Weapon = weapon;
WeaponClass = weaponClass;
Armor = armor;
ArmorClass = armorClass;
MaxHp = maxHp;
Attack = attack;
Splash = splash;
Range = range;
Stealth = stealth;
Speed = speed;
GroupSize = groupSize;
Carry = carry;
NormalizedCost = normalizedCost;
}
public DefenseScores DeepCopy()
{
return(new DefenseScores
{
ArmorClass = ArmorClass.DeepCopy(),
HitPoints = HitPoints.DeepCopy()
});
}
private IArmorPieceConfiguration GetSpecificConfiguration(ArmorType type, ArmorClass armorClass)
{
var configurations = GetArmorTypeConfigurations(type);
var classFilteredConfigurations = configurations
.Where(config => config.Class == armorClass)
.ToArray();
return(RandomHelper.GetRandomElement(classFilteredConfigurations));
}
public ArmorItem GenerateArmor(ItemRareness rareness, ArmorClass armorClass)
{
if (GetIfRarenessExceedMax(rareness))
{
throw new ArgumentException("Item generator cannot generate epic items.");
}
return(armorGenerator.GenerateArmor(rareness, armorClass));
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destType)
{
if (destType == typeof(string) && value is ArmorClass)
{
ArmorClass a = (ArmorClass)value;
return(a.ArmorWorn + "," + a.ArmorType + "," + a.ArmorAC + "," + a.ArmorStealth + "," + a.ShieldType + "," + a.ShieldAC + "," + a.MiscAC + "," + a.MagicAC);
}
return(base.ConvertTo(context, culture, value, destType));
}
public void PopulateValues(ArmorClass armorClass)
{
numDamageReduction.Value = armorClass.DamageReduction + armorClass.MiscDamageReductionMod;
lblEnergyBonus.Text = armorClass.TotalEnergyBonus.ToString();
lblKineticBonus.Text = armorClass.TotalKineticBonus.ToString();
numEnergyMisc.Value = armorClass.MiscEnergyMod;
numKineticMisc.Value = armorClass.MiscKineticMod;
lblEnergyTotal.Text = armorClass.EnergyArmorClass.ToString();
lblKineticTotal.Text = armorClass.KineticArmorClass.ToString();
lblManeuversTotal.Text = armorClass.ManeuversArmorClass.ToString();
lblResistances.Text = string.Join(";", armorClass.Resistances.Select(r => $"{r.Type.ToString()}-{r.Value.ToString()}").ToList());
}
//random attributes
private AttributesDto ItemAttributes(int level, ArmorClass armor, Quality quality)
{
var multiplier = 1.0;
switch (quality)
{
case Quality.Common: break;
case Quality.Rare:
multiplier = 1.4;
break;
case Quality.Epic:
multiplier = 1.7;
break;
case Quality.Legendary: break;
}
var attr = new AttributesDto();
switch (armor)
{
case ArmorClass.Sword:
attr.Hp = (int)(level * multiplier);
attr.Damage = 2 * (int)(level * multiplier);
attr.Defense = (int)(level * multiplier);
return(attr);
case ArmorClass.Armor:
attr.Hp = 2 * (int)(level * multiplier);
attr.Damage = (int)(level * multiplier);
attr.Defense = (int)(level * multiplier);
return(attr);
case ArmorClass.Trousers:
attr.Hp = (int)(level * multiplier);
attr.Damage = (int)(level * multiplier);
attr.Defense = 2 * (int)(level * multiplier);
return(attr);
case ArmorClass.Consumable:
attr.Hp = 5 * (int)(level * multiplier);
attr.Damage = 0;
attr.Defense = 0;
return(attr);
default:
return(attr);
}
}
private Tuple <ItemDto, AttributesDto> GenerateItemBasedOnLevel(int level, ArmorClass armorClass)
{
var quality = _random.Next(0, 100);
var item = new ItemDto()
{
Price = level * 15, ArmorClass = armorClass, RequiredLevel = level, Quality = ItemQuality(quality), Name = ItemName(armorClass)
};
item.Image = (armorClass.ToString().ToLower() + "_" + item.Quality.ToString().ToLower() + ".jpg");
var attr = ItemAttributes(level, armorClass, item.Quality);
return(new Tuple <ItemDto, AttributesDto>(item, attr));
}
public ArmorType GetArmorTypeFromClass(ArmorClass c)
{
switch (c)
{
case (ArmorClass.Belt):
{
return(ArmorType.Belt);
//break;
}
case (ArmorClass.LeatherArmor):
case (ArmorClass.ChainArmor):
case (ArmorClass.PlateArmor):
{
return(ArmorType.Torso);
//break;
}
case (ArmorClass.SmallHelm):
case (ArmorClass.FullHelm):
{
return(ArmorType.Head);
//break;
}
case (ArmorClass.LightBoots):
case (ArmorClass.HeavyBoots):
{
return(ArmorType.Feet);
//break;
}
case (ArmorClass.RoundShield):
case (ArmorClass.KiteShield):
case (ArmorClass.TowerShield):
{
return(ArmorType.Shield);
//break;
}
default:
{
return(ArmorType.Torso);
//break;
}
}
}
public void LoadArmorClass(ArmorClass ac, string modValue)
{
txtTotal.Text = ac.Total;
txtTouch.Text = ac.Touch;
txtFlat.Text = ac.FlatFooted;
txtArmor.Text = ac.ArmorBonus;
txtNatural.Text = ac.NaturalArmor;
txtSize.Text = ac.SizeModifier;
txtDeflection.Text = ac.Deflection;
txtShield.Text = ac.ShieldBonus;
txtModifier.Text = modValue;
txtMisc.Text = ac.MiscModifier;
txtOther.Text = ac.OtherModifiers;
}
public void GetTotal_Aggregates()
{
// Arrange
var mockAbilityScore = new Mock <IAbilityScore>();
mockAbilityScore.Setup(abs => abs.GetModifier())
.Returns(3);
var abilityScores = new Mock <IAbilityScoreSection>();
abilityScores.Setup(abs => abs.Dexterity)
.Returns(mockAbilityScore.Object);
var mockCharacter = new Mock <ICharacter>();
mockCharacter.Setup(c => c.AbilityScores)
.Returns(abilityScores.Object);
mockCharacter.Setup(c => c.Size)
.Returns(SizeCategory.Small);
ArmorClass ac = new ArmorClass(mockCharacter.Object);
ac.ArmorBonuses.Add(() => 3);
ac.CircumstanceBonuses.Add(() => 4);
ac.DeflectionBonuses.Add(() => 5);
ac.DodgeBonuses.Add(() => 6);
ac.InsightBonuses.Add(() => 7);
ac.LuckBonuses.Add(() => 8);
ac.MoraleBonuses.Add(() => 9);
ac.NaturalArmorBonuses.Add(() => 10);
ac.NaturalArmorEnhancementBonuses.Add(() => 11);
ac.ProfaneBonuses.Add(() => 12);
ac.SacredBonuses.Add(() => 13);
ac.ShieldBonuses.Add(() => 14);
ac.UntypedBonuses.Add(() => 15);
ac.Penalties.Add(() => 16);
ac.MaxKeyAbilityScore.Add(() => 2);
// Act
var result = ac.GetTotal();
// Assert
Assert.AreEqual(114, result,
"114 = (10 base) + (3 dex; +2 max dex) + (1 size) + (3 armor) + (4 circumstance) + (5 deflection) + (6 dodge) + (7 insight) + (8 luck) + (9 morale) + (10 natural) + (11 natural enhancement) + (12 profane) + (13 sacred) + (14 shield) + (15 untyped) - (16 penalties)");
}
private ArmorClass GetEquipmentArmorClassBonuses(ArmorClass armorClass, Equipment equipment)
{
if (equipment.Armor != null)
{
var armor = equipment.Armor as Armor;
var bonus = armor.ArmorBonus + armor.Magic.Bonus;
armorClass.AddBonus(ArmorClassConstants.Armor, bonus);
}
if (equipment.Shield != null)
{
var shield = equipment.Shield as Armor;
var bonus = shield.ArmorBonus + shield.Magic.Bonus;
armorClass.AddBonus(ArmorClassConstants.Shield, bonus);
}
return(armorClass);
}
public static string GetNameFromArmorClassEnum(ArmorClass ac)
{
string name = Enum.GetName(typeof(ArmorClass), ac);
// often the name has two words, with midCaps involved.
for (int i = 1; i < name.Length; i++) // start at 1 because it always starts with a cap
{
// if caps
if (name[i].ToString() != name[i].ToString().ToLower())
{
// then insert a space before this index.
name = name.Insert(i, " ");
break;
}
}
return(name);
}
public ArmorClass GetArmorClass()
{
ArmorClass ac = new ArmorClass()
{
ArmorBonus = GetStringOrNull(txtArmor.Text, true),
NaturalArmor = GetStringOrNull(txtNatural.Text, true),
Deflection = GetStringOrNull(txtDeflection.Text, true),
MiscModifier = GetStringOrNull(txtMisc.Text, true),
OtherModifiers = GetStringOrNull(txtOther.Text, true),
ShieldBonus = GetStringOrNull(txtShield.Text, true),
SizeModifier = GetStringOrNull(txtSize.Text, true),
FlatFooted = txtFlat.Text,
Total = txtTotal.Text,
Touch = txtTouch.Text
};
return(ac);
}
private ArmorClass GetRacialArmorClassBonuses(ArmorClass armorClass, string creatureName, CreatureType creatureType)
{
var creatureBonuses = bonusSelector.SelectFor(TableNameConstants.TypeAndAmount.ArmorClassBonuses, creatureName);
var creatureTypeBonuses = bonusSelector.SelectFor(TableNameConstants.TypeAndAmount.ArmorClassBonuses, creatureType.Name);
var bonuses = creatureBonuses.Union(creatureTypeBonuses);
foreach (var subtype in creatureType.SubTypes)
{
var subtypeBonuses = bonusSelector.SelectFor(TableNameConstants.TypeAndAmount.ArmorClassBonuses, subtype);
bonuses = bonuses.Union(subtypeBonuses);
}
foreach (var bonus in bonuses)
{
armorClass.AddBonus(bonus.Target, bonus.Bonus, bonus.Condition);
}
return(armorClass);
}
private void Awake()
{
armorClass = CharacterManager.instance.character.armorClass;
totalValue = displayObject.transform.Find(total).GetComponent <TextMeshProUGUI>();
dexModifierValue = displayObject.transform.Find(dexModifier).GetComponent <TextMeshProUGUI>();
sizeModifierValue = displayObject.transform.Find(sizeModifier).GetComponent <TextMeshProUGUI>();
armorValue = displayObject.transform.Find(armor).GetComponent <TMP_InputField>();
shieldValue = displayObject.transform.Find(shield).GetComponent <TMP_InputField>();
alterationValue = displayObject.transform.Find(currentAlteration).GetComponent <TMP_InputField>();
armorValue.onValueChanged.AddListener(ModifyArmor);
shieldValue.onValueChanged.AddListener(ModifyShield);
alterationValue.onValueChanged.AddListener(ModifyAlteration);
ResetDisplays();
CharacterManager.instance.onValuesReset += ResetDisplays;
}
public ArmorClass GenerateWith(Dictionary <string, Ability> abilities, string size, string creatureName, CreatureType creatureType, IEnumerable <Feat> feats, int naturalArmor, Equipment equipment)
{
var armorClass = new ArmorClass();
armorClass.Dexterity = abilities[AbilityConstants.Dexterity];
if (creatureType.SubTypes.Contains(CreatureConstants.Types.Subtypes.Incorporeal))
{
var deflectionBonus = Math.Max(1, abilities[AbilityConstants.Charisma].Modifier);
armorClass.AddBonus(ArmorClassConstants.Deflection, deflectionBonus);
}
armorClass.SizeModifier = adjustmentsSelector.SelectFrom <int>(TableNameConstants.Adjustments.SizeModifiers, size);
var inertialArmorFeat = feats.FirstOrDefault(f => f.Name == FeatConstants.SpecialQualities.InertialArmor);
if (inertialArmorFeat != null)
{
armorClass.AddBonus(ArmorClassConstants.Armor, inertialArmorFeat.Power);
}
if (feats.Any(f => f.Name == FeatConstants.SpecialQualities.UnearthlyGrace))
{
armorClass.AddBonus(ArmorClassConstants.Deflection, abilities[AbilityConstants.Charisma].Modifier);
}
if (naturalArmor > 0)
{
armorClass.AddBonus(ArmorClassConstants.Natural, naturalArmor);
}
if (feats.Any(f => f.Name == FeatConstants.TwoWeaponDefense))
{
armorClass.AddBonus(ArmorClassConstants.Shield, 1);
}
armorClass = GetRacialArmorClassBonuses(armorClass, creatureName, creatureType);
armorClass = GetEquipmentArmorClassBonuses(armorClass, equipment);
return(armorClass);
}
public RPGArmor(ArmorClass a, int ArmorDefense, int MaxDexBonus, int MaxDurability, int Value, string Name)
{
// set all armor similarities
this.BaseSpeed = 0;
this.Actions = null;
this.Color1 = Color.Gray;
this.Color2 = Color.Black;
this.m_class = a;
this.m_type = GetArmorTypeFromClass(a);
this.Name = Name;
this.Slot = GetSlotFromArmorClassEnum(a);
// set specifics
this.m_Defense = ArmorDefense;
this.m_MaxDex = MaxDexBonus;
this.m_DurabilityMax = MaxDurability;
this.ItemValue = Value;
ResetDurability();
UpdateDescription();
}
public ArmorItem GenerateArmor(ItemRareness rareness, ArmorClass armorClass)
{
var armorType = GenerateArmorType();
var config = GetSpecificConfiguration(armorType, armorClass);
var rarenessConfig = GetRarenessConfiguration(config, rareness);
var material = RandomHelper.GetRandomElement(rarenessConfig.Materials);
var inventoryImage = GetArmorImage(config, material);
var worldImage = GetWorldImage(material, armorType);
var equippedImage = GetEquippedImage(material, config);
var protection = GenerateProtection(rarenessConfig.Protection);
var name = GenerateName(material, config.TypeName, armorType);
var description = GenerateDescription(rareness, material);
var weightConfig = GetWeightConfiguration(config, material);
var maxDurability = weightConfig.Durability;
var bonusesCount = RandomHelper.GetRandomValue(rarenessConfig.MinBonuses, rarenessConfig.MaxBonuses);
var itemConfig = new ArmorItemConfiguration
{
Name = name,
Key = Guid.NewGuid().ToString(),
ArmorType = armorType,
Description = description,
InventoryImage = inventoryImage,
WorldImage = worldImage,
EquippedImage = equippedImage,
Protection = protection,
Rareness = rareness,
Weight = weightConfig.Weight,
MaxDurability = maxDurability
};
bonusesGenerator.GenerateBonuses(itemConfig, bonusesCount);
var durabilityPercent = RandomHelper.GetRandomValue(MinDurabilityPercent, MaxDurabilityPercent);
var durability = Math.Min(itemConfig.MaxDurability, (int)Math.Round(itemConfig.MaxDurability * (durabilityPercent / 100d)));
itemConfig.Durability = durability;
return(new ArmorItem(itemConfig));
}
public Creature()
{
Abilities = new Dictionary <string, Ability>();
Alignment = new Alignment();
ArmorClass = new ArmorClass();
Attacks = Enumerable.Empty <Attack>();
ChallengeRating = string.Empty;
Feats = Enumerable.Empty <Feat>();
HitPoints = new HitPoints();
Name = string.Empty;
Reach = new Measurement("feet");
Saves = new Dictionary <string, Save>();
Size = string.Empty;
Skills = Enumerable.Empty <Skill>();
Space = new Measurement("feet");
SpecialQualities = Enumerable.Empty <Feat>();
Template = string.Empty;
Type = new CreatureType();
Speeds = new Dictionary <string, Measurement>();
Equipment = new Equipment();
Magic = new Magic();
Languages = new List <string>();
}
public void Default()
{
// Arrange
var dexterity = Mock.Of <IAbilityScore>();
var abilityScores = new Mock <IAbilityScoreSection>();
abilityScores.Setup(abs => abs.Dexterity)
.Returns(dexterity);
var mockCharacter = new Mock <ICharacter>();
mockCharacter.Setup(c => c.AbilityScores)
.Returns(abilityScores.Object);
mockCharacter.Setup(c => c.Size)
.Returns(SizeCategory.Small);
ArmorClass ac = new ArmorClass(mockCharacter.Object);
// Assert
Assert.AreSame(dexterity, ac.KeyAbilityScore);
Assert.IsInstanceOf <ArmorBonusTracker>(ac.ArmorBonuses);
Assert.IsInstanceOf <CircumstanceBonusTracker>(ac.CircumstanceBonuses);
Assert.IsInstanceOf <DeflectionBonusTracker>(ac.DeflectionBonuses);
Assert.IsInstanceOf <DodgeBonusTracker>(ac.DodgeBonuses);
Assert.IsInstanceOf <InsightBonusTracker>(ac.InsightBonuses);
Assert.IsInstanceOf <LuckBonusTracker>(ac.LuckBonuses);
Assert.IsInstanceOf <MoraleBonusTracker>(ac.MoraleBonuses);
Assert.IsInstanceOf <NaturalArmorBonusTracker>(ac.NaturalArmorBonuses);
Assert.IsInstanceOf <NaturalArmorBonusTracker>(ac.NaturalArmorEnhancementBonuses);
Assert.IsInstanceOf <ProfaneBonusTracker>(ac.ProfaneBonuses);
Assert.IsInstanceOf <SacredBonusTracker>(ac.SacredBonuses);
Assert.IsInstanceOf <ShieldBonusTracker>(ac.ShieldBonuses);
Assert.IsInstanceOf <UntypedBonusTracker>(ac.UntypedBonuses);
Assert.IsInstanceOf <PenaltyTracker>(ac.Penalties);
}
//random item name
private string ItemName(ArmorClass armorClass)
{
var additives = new[] { "Iron", "Bronze", "Silver", "Steel", "Golden", "Leather", "Cloth" };
string[] names;
string full;
switch (armorClass)
{
case ArmorClass.Sword:
names = new[] { "Cleaver", "Sword", "Rapier", "Scimitar", "Katana", "Dagger" };
full = additives[_random.Next(additives.Length)] + " " +
names[_random.Next(names.Length)];
return(full);
case ArmorClass.Armor:
names = new[] { "Torso", "Chestplate", "Jacket", "Deffender", "Spiked Armor" };
full = additives[_random.Next(additives.Length)] + " " +
names[_random.Next(names.Length)];
return(full);
case ArmorClass.Trousers:
names = new[] { "Legs", "Skirt", "Trousers", "Spiked Legs", "Trimmed Skirt" };
full = additives[_random.Next(additives.Length)] + " " +
names[_random.Next(names.Length)];
return(full);
case ArmorClass.Consumable:
names = new[] { "Potion", "Chicken", "Raw Beef", "Roasted Chicken", "Bread", "Spicy Juice" };
full = names[_random.Next(names.Length)];
return(full);
default:
return("");
}
}
public Combat()
{
ArmorClass = new ArmorClass();
SavingThrows = new SavingThrows();
BaseAttack = new BaseAttack();
}
public override void WritePropertyXML(XmlWriter xmlWriter)
{
base.WritePropertyXML(xmlWriter);
xmlWriter.WriteStartElement("Type");
xmlWriter.WriteString(Methods.GetCreatureTypeString(Type));
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("ChallengeRating");
xmlWriter.WriteString(ChallengeRating.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("AttackSets");
foreach (AttackSet attackSet in AttackSets)
{
attackSet.WriteXML(xmlWriter);
}
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Strength");
xmlWriter.WriteString(Strength.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Dexterity");
xmlWriter.WriteString(Dexterity.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Constitution");
xmlWriter.WriteString(Constitution.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Intelligence");
xmlWriter.WriteString(Intelligence.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Wisdom");
xmlWriter.WriteString(Wisdom.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Charisma");
xmlWriter.WriteString(Charisma.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("BaseAttackBonus");
xmlWriter.WriteString(BaseAttackBonus.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("GrappleModifier");
xmlWriter.WriteString(GrappleModifier.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("HitPoints");
xmlWriter.WriteString(HitPoints.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("HitDice");
xmlWriter.WriteString(HitDice.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("HitDieType");
xmlWriter.WriteString(Methods.GetDieTypeString(HitDieType));
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("ArmorClass");
xmlWriter.WriteString(ArmorClass.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("TouchArmorClass");
xmlWriter.WriteString(TouchArmorClass.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("FlatFootedArmorClass");
xmlWriter.WriteString(FlatFootedArmorClass.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Speed");
Speed.WriteXML(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("FortitudeSave");
xmlWriter.WriteString(FortitudeSave.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("ReflexSave");
xmlWriter.WriteString(ReflexSave.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("WillSave");
xmlWriter.WriteString(WillSave.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Feats");
foreach (string feat in Feats)
{
xmlWriter.WriteStartElement("Feat");
xmlWriter.WriteString(feat);
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Space");
xmlWriter.WriteString(Space.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Reach");
xmlWriter.WriteString(Reach.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Size");
xmlWriter.WriteString(Methods.GetSizeString(Size));
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("DamageReductions");
foreach (DamageReduction dr in DamageReductions)
{
dr.WriteXML(xmlWriter);
}
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("Immunities");
Immunities.WriteXML(xmlWriter);
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("EnergyResistances");
foreach (EnergyResistance er in EnergyResistances)
{
er.WriteXML(xmlWriter);
}
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("SpellResistance");
xmlWriter.WriteString(SpellResistance.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("FastHealing");
xmlWriter.WriteString(FastHealing.ToString());
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("SpecialAttacks");
xmlWriter.WriteString(SpecialAttacks);
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("SpecialQualities");
xmlWriter.WriteString(String.Join(", ", SpecialQualities));
xmlWriter.WriteEndElement();
}
public void SetArmorClass(ArmorClass classIn) => _armorClass = classIn;
