public void CanBeCharacter_FalseIfNullLevelAdjustment(int levelAdjustment)
{
var creatureData = new CreatureDataSelection();
creatureData.LevelAdjustment = levelAdjustment;
mockCreatureDataSelector
.Setup(s => s.SelectFor("creature"))
.Returns(creatureData);
var canBeCharacter = verifier.CanBeCharacter("creature");
Assert.That(canBeCharacter, Is.True);
}
private void UpdateCreatureArmorClass(Creature creature, CreatureDataSelection animalData)
{
foreach (var naturalArmorBonus in creature.ArmorClass.NaturalArmorBonuses)
{
naturalArmorBonus.Value += 2;
naturalArmorBonus.Condition = "In base or hybrid form";
}
if (!creature.ArmorClass.NaturalArmorBonuses.Any())
{
creature.ArmorClass.AddBonus(ArmorClassConstants.Natural, 2, "In base or hybrid form");
}
creature.ArmorClass.AddBonus(ArmorClassConstants.Natural, animalData.NaturalArmor + 2, "In animal or hybrid form");
}
private IEnumerable <Feat> UpdateCreatureFeats(
Creature creature,
HitPoints animalHitPoints,
CreatureDataSelection animalData,
IEnumerable <Skill> animalSkills,
IEnumerable <Attack> animalAttacks,
int animalBaseAttack,
IEnumerable <Feat> animalSpecialQualities)
{
var animalFeats = featsGenerator.GenerateFeats(
animalHitPoints,
animalBaseAttack,
creature.Abilities,
animalSkills,
animalAttacks,
animalSpecialQualities,
animalData.CasterLevel,
creature.Speeds,
animalData.NaturalArmor,
animalData.NumberOfHands,
animalData.Size,
animalData.CanUseEquipment);
foreach (var feat in animalFeats)
{
var matching = creature.Feats.FirstOrDefault(f =>
f.Name == feat.Name &&
!f.Foci.Except(feat.Foci).Any() &&
!feat.Foci.Except(f.Foci).Any());
if (matching == null || feat.CanBeTakenMultipleTimes)
{
creature.Feats = creature.Feats.Union(new[] { feat });
}
else if (matching.Power < feat.Power)
{
matching.Power = feat.Power;
}
}
return(animalFeats);
}
private CreatureDataSelection Parse(IEnumerable <string> creatureData)
{
var selection = new CreatureDataSelection();
var data = creatureData.ToArray();
selection.ChallengeRating = data[DataIndexConstants.CreatureData.ChallengeRating];
if (!string.IsNullOrEmpty(data[DataIndexConstants.CreatureData.LevelAdjustment]))
{
selection.LevelAdjustment = Convert.ToInt32(data[DataIndexConstants.CreatureData.LevelAdjustment]);
}
selection.Reach = Convert.ToDouble(data[DataIndexConstants.CreatureData.Reach]);
selection.Size = data[DataIndexConstants.CreatureData.Size];
selection.Space = Convert.ToDouble(data[DataIndexConstants.CreatureData.Space]);
selection.CanUseEquipment = Convert.ToBoolean(data[DataIndexConstants.CreatureData.CanUseEquipment]);
selection.CasterLevel = Convert.ToInt32(data[DataIndexConstants.CreatureData.CasterLevel]);
selection.NaturalArmor = Convert.ToInt32(data[DataIndexConstants.CreatureData.NaturalArmor]);
selection.NumberOfHands = Convert.ToInt32(data[DataIndexConstants.CreatureData.NumberOfHands]);
return(selection);
}
private (IEnumerable <Attack> AnimalAttacks, int AnimalBaseAttack) UpdateCreatureAttacks(Creature creature, CreatureType animalCreatureType, HitPoints animalHitPoints, CreatureDataSelection animalData)
{
var baseAttackBonus = attacksGenerator.GenerateBaseAttackBonus(animalCreatureType, animalHitPoints);
creature.BaseAttackBonus += baseAttackBonus;
foreach (var attack in creature.Attacks)
{
if (attack.IsSpecial)
{
attack.Name += $" (in {creature.Type.Name} form)";
}
else
{
attack.Name += $" (in {creature.Type.Name} or Hybrid form)";
}
}
creature.GrappleBonus = attacksGenerator.GenerateGrappleBonus(
creature.Name,
creature.Size,
creature.BaseAttackBonus,
creature.Abilities[AbilityConstants.Strength]);
var animalAttacks = attacksGenerator.GenerateAttacks(
AnimalSpecies,
animalData.Size,
animalData.Size,
creature.BaseAttackBonus,
creature.Abilities,
creature.HitPoints.RoundedHitDiceQuantity);
var allFeats = creature.Feats.Union(creature.SpecialQualities);
animalAttacks = attacksGenerator.ApplyAttackBonuses(animalAttacks, allFeats, creature.Abilities);
foreach (var animalAttack in animalAttacks)
{
animalAttack.Name += " (in Animal form)";
}
var biggerSize = GetBiggerSize(creature.Size, animalData.Size);
var lycanthropeAttacks = attacksGenerator.GenerateAttacks(
LycanthropeSpecies,
SizeConstants.Medium,
biggerSize,
creature.BaseAttackBonus,
creature.Abilities,
creature.HitPoints.RoundedHitDiceQuantity);
lycanthropeAttacks = attacksGenerator.ApplyAttackBonuses(lycanthropeAttacks, allFeats, creature.Abilities);
foreach (var lycanthropeAttack in lycanthropeAttacks)
{
var searchName = lycanthropeAttack.Name.Replace(" (in Hybrid form)", string.Empty);
var animalAttack = animalAttacks.FirstOrDefault(a => a.Name.StartsWith(searchName));
if (animalAttack == null)
{
continue;
}
if (!string.IsNullOrEmpty(lycanthropeAttack.DamageEffect))
{
animalAttack.DamageEffect = lycanthropeAttack.DamageEffect;
}
}
creature.Attacks = creature.Attacks.Union(animalAttacks).Union(lycanthropeAttacks);
return(animalAttacks, baseAttackBonus);
}
private IEnumerable <Feat> UpdateCreatureSpecialQualities(
Creature creature,
CreatureType animalCreatureType,
HitPoints animalHitPoints,
CreatureDataSelection animalData,
IEnumerable <Skill> animalSkills)
{
var animalSpecialQualities = featsGenerator.GenerateSpecialQualities(
AnimalSpecies,
animalCreatureType,
animalHitPoints,
creature.Abilities,
animalSkills,
animalData.CanUseEquipment,
animalData.Size,
creature.Alignment);
foreach (var sq in animalSpecialQualities)
{
var matching = creature.SpecialQualities.FirstOrDefault(f =>
f.Name == sq.Name &&
!f.Foci.Except(sq.Foci).Any() &&
!sq.Foci.Except(f.Foci).Any());
if (matching == null)
{
creature.SpecialQualities = creature.SpecialQualities.Union(new[] { sq });
}
else if (matching.Power < sq.Power)
{
matching.Power = sq.Power;
}
}
var lycanthropeSpecialQualities = featsGenerator.GenerateSpecialQualities(
LycanthropeSpecies,
creature.Type,
creature.HitPoints,
creature.Abilities,
creature.Skills,
creature.CanUseEquipment,
creature.Size,
creature.Alignment);
foreach (var sq in lycanthropeSpecialQualities)
{
var matching = creature.SpecialQualities.FirstOrDefault(f =>
f.Name == sq.Name &&
!f.Foci.Except(sq.Foci).Any() &&
!sq.Foci.Except(f.Foci).Any());
if (matching == null)
{
creature.SpecialQualities = creature.SpecialQualities.Union(new[] { sq });
}
else if (matching.Power < sq.Power)
{
matching.Power = sq.Power;
}
}
return(animalSpecialQualities);
}
private IEnumerable <Skill> UpdateCreatureSkills(Creature creature, CreatureType animalCreatureType, HitPoints animalHitPoints, CreatureDataSelection animalData)
{
var animalSkills = skillsGenerator.GenerateFor(
animalHitPoints,
AnimalSpecies,
animalCreatureType,
creature.Abilities,
creature.CanUseEquipment,
animalData.Size,
false);
var newCap = creature.HitPoints.RoundedHitDiceQuantity + 3;
if (LycanthropeSpecies.Contains("Afflicted"))
{
var controlShape = new Skill(
SkillConstants.Special.ControlShape,
creature.Abilities[AbilityConstants.Wisdom],
animalHitPoints.RoundedHitDiceQuantity);
controlShape.ClassSkill = true;
animalSkills = animalSkills.Union(new[] { controlShape });
foreach (var animalSkill in animalSkills)
{
animalSkill.Ranks = 0;
}
animalSkills = skillsGenerator.ApplySkillPointsAsRanks(
animalSkills,
animalHitPoints,
animalCreatureType,
creature.Abilities,
false);
}
foreach (var creatureSkill in creature.Skills)
{
creatureSkill.RankCap = newCap;
}
foreach (var animalSkill in animalSkills)
{
animalSkill.RankCap = newCap;
var creatureSkill = creature.Skills.FirstOrDefault(s => s.Key == animalSkill.Key);
if (creatureSkill != null)
{
creatureSkill.Ranks += animalSkill.Ranks;
creatureSkill.ClassSkill |= animalSkill.ClassSkill;
foreach (var bonus in animalSkill.Bonuses)
{
creatureSkill.AddBonus(bonus.Value, bonus.Condition);
}
}
else
{
creature.Skills = creature.Skills.Union(new[] { animalSkill });
}
}
return(animalSkills);
}
private HitPoints UpdateCreatureHitPoints(Creature creature, CreatureType animalCreatureType, CreatureDataSelection animalData)
{
var animalHitPoints = hitPointsGenerator.GenerateFor(AnimalSpecies, animalCreatureType, creature.Abilities[AbilityConstants.Constitution], animalData.Size);
creature.HitPoints.HitDice.Add(animalHitPoints.HitDice[0]);
creature.HitPoints.RollTotal(dice);
creature.HitPoints.RollDefaultTotal(dice);
return(animalHitPoints);
}
public void Setup()
{
selection = new CreatureDataSelection();
}
