public float ComputeSlashingDefense(IStatsVariables baseAttributeStats, IReadOnlyCollection <Effect> effects)
{
var strengthBonus = baseAttributeStats.Strength() / 200;
var dexterityBonus = baseAttributeStats.Dexterity() / 200;
return(ComputeMeleeDefense(strengthBonus + dexterityBonus, EffectRelationships.SlashingDefenseRelationship, effects));
}
public void Populate(IStatsVariables existingVars, IReadOnlyCollection <Effect> activeEffects, IReadOnlyCollection <IVariables> relatedVars)
{
AttributeStatPopulator.Populate(existingVars, activeEffects, relatedVars);
DefenseStatPopulator.Populate(existingVars, activeEffects, relatedVars);
DamageStatPopulator.Populate(existingVars, activeEffects, relatedVars);
VitalStatsPopulator.Populate(existingVars, activeEffects, relatedVars);
}
public float ComputeUnarmedDamage(IStatsVariables stats, IReadOnlyCollection <Effect> effects)
{
var strengthBonus = stats.Strength() / 200;
var dexterityBonus = stats.Dexterity() / 200;
return(ComputeMeleeDamage(strengthBonus + dexterityBonus, EffectRelationships.UnarmedDamageRelationship, effects));
}
public ProcessedAttack ProcessAttack(Attack attack, IStatsVariables stats)
{
var applicableDefenses = stats.GetDefenseReferences().Where(x => x.StatValue != 0);
var damageLookups = attack.Damages.ToDictionary(x => x.Type, x => x.Value);
var resultingDefenses = new List <Damage>();
foreach (var applicableDefense in applicableDefenses)
{
if (!damageLookups.ContainsKey(applicableDefense.StatType))
{
continue;
}
float defendedAmount;
if (damageLookups[applicableDefense.StatType] > applicableDefense.StatValue)
{
defendedAmount = applicableDefense.StatValue;
}
else
{
defendedAmount = applicableDefense.StatValue - damageLookups[applicableDefense.StatType];
}
damageLookups[applicableDefense.StatType] -= defendedAmount;
resultingDefenses.Add(new Damage(applicableDefense.StatType, defendedAmount));
}
var resultingDamage = damageLookups.Select(x => new Damage(x.Key, x.Value));
return(new ProcessedAttack(resultingDamage.ToList(), resultingDefenses));
}
public void Populate(IStatsVariables stats, IReadOnlyCollection <Effect> activeEffects, IReadOnlyCollection <IVariables> relatedVars)
{
var iceDamage = ComputeIceDamage(stats, activeEffects);
var fireDamage = ComputeFireDamage(stats, activeEffects);
var windDamage = ComputeWindDamage(stats, activeEffects);
var earthDamage = ComputeEarthDamage(stats, activeEffects);
var lightDamage = ComputeLightDamage(stats, activeEffects);
var darkDamage = ComputeDarkDamage(stats, activeEffects);
var slashingDamage = ComputeSlashingDamage(stats, activeEffects);
var bluntDamage = ComputeBluntDamage(stats, activeEffects);
var piercingDamage = ComputePiercingDamage(stats, activeEffects);
var unarmedDamage = ComputeUnarmedDamage(stats, activeEffects);
var pureDamage = ComputeDamage(stats, activeEffects);
stats.IceDamage(iceDamage);
stats.FireDamage(fireDamage);
stats.WindDamage(windDamage);
stats.EarthDamage(earthDamage);
stats.LightDamage(lightDamage);
stats.DarkDamage(darkDamage);
stats.SlashingDamage(slashingDamage);
stats.BluntDamage(bluntDamage);
stats.PiercingDamage(piercingDamage);
stats.UnarmedDamage(unarmedDamage);
stats.Damage(pureDamage);
}
public void PopulateMP(IStatsVariables stats, IReadOnlyCollection <Effect> activeEffects)
{
var intelligenceBonus = stats.Intelligence() * 5;
var maxMagicStat = (int)activeEffects.GetPotencyFor(EffectTypes.MagicBonusAmount,
EffectTypes.MagicBonusPercentage, intelligenceBonus);
stats.MaxMagic(maxMagicStat);
}
public void PopulateHP(IStatsVariables stats, IReadOnlyCollection <Effect> activeEffects)
{
var constitutionBonus = stats.Constitution() * 5;
var maxHealthStat = (int)activeEffects.GetPotencyFor(EffectTypes.HealthBonusAmount,
EffectTypes.HealthBonusPercentage, constitutionBonus);
stats.MaxHealth(maxHealthStat);
}
public Attack GenerateAttack(IStatsVariables stats)
{
var damages = stats.GetDamageReferences()
.Where(x => x.StatValue != 0)
.Select(x => new Damage(x.StatType, x.StatValue))
.ToArray();
return(new Attack(damages));
}
public float ComputeDamage(IStatsVariables stats, IReadOnlyCollection <Effect> effects)
{
var amount = effects.GetPotencyFor(EffectTypes.DamageBonusAmount);
var percentage = effects.GetPotencyFor(EffectTypes.DamageBonusPercentage);
if (percentage == 0)
{
return(amount);
}
var addition = amount * (percentage / 100);
return(amount + addition);
}
public static float GetDamageFromDamageType(this IStatsVariables stats, int damageType)
{
if (damageType == DamageTypes.PiercingDamage)
{
return(stats.PiercingDamage());
}
if (damageType == DamageTypes.SlashingDamage)
{
return(stats.SlashingDamage());
}
if (damageType == DamageTypes.BluntDamage)
{
return(stats.BluntDamage());
}
if (damageType == DamageTypes.UnarmedDamage)
{
return(stats.UnarmedDamage());
}
if (damageType == DamageTypes.FireDamage)
{
return(stats.FireDamage());
}
if (damageType == DamageTypes.IceDamage)
{
return(stats.IceDamage());
}
if (damageType == DamageTypes.WindDamage)
{
return(stats.WindDamage());
}
if (damageType == DamageTypes.EarthDamage)
{
return(stats.EarthDamage());
}
if (damageType == DamageTypes.LightDamage)
{
return(stats.LightDamage());
}
if (damageType == DamageTypes.DarkDamage)
{
return(stats.DarkDamage());
}
if (damageType == DamageTypes.Damage)
{
return(stats.Damage());
}
return(0);
}
public static ICollection <StatReference> GetDefenseReferences(this IStatsVariables stats)
{
return(new[]
{
new StatReference(DamageTypes.IceDamage, stats.IceDefense()),
new StatReference(DamageTypes.FireDamage, stats.FireDefense()),
new StatReference(DamageTypes.WindDamage, stats.WindDefense()),
new StatReference(DamageTypes.EarthDamage, stats.EarthDefense()),
new StatReference(DamageTypes.LightDamage, stats.LightDefense()),
new StatReference(DamageTypes.DarkDamage, stats.DarkDefense()),
new StatReference(DamageTypes.SlashingDamage, stats.SlashingDefense()),
new StatReference(DamageTypes.BluntDamage, stats.BluntDefense()),
new StatReference(DamageTypes.PiercingDamage, stats.PiercingDefense()),
new StatReference(DamageTypes.UnarmedDamage, stats.UnarmedDefense()),
new StatReference(DamageTypes.Damage, stats.Defense())
});
}
public void Populate(IStatsVariables stats, IReadOnlyCollection <Effect> activeEffects, IReadOnlyCollection <IVariables> relatedVars)
{
var strengthValue = (int)activeEffects.CalculateBonusFor(EffectTypes.StrengthBonusAmount, EffectTypes.StrengthBonusPercentage);
var dexterityValue = (int)activeEffects.CalculateBonusFor(EffectTypes.DexterityBonusAmount, EffectTypes.DexterityBonusPercentage);
var constitutionValue = (int)activeEffects.CalculateBonusFor(EffectTypes.ConstitutionBonusAmount, EffectTypes.ConstitutionBonusPercentage);
var intelligenceValue = (int)activeEffects.CalculateBonusFor(EffectTypes.IntelligenceBonusAmount, EffectTypes.IntelligenceBonusPercentage);
var wisdomValue = (int)activeEffects.CalculateBonusFor(EffectTypes.WisdomBonusAmount, EffectTypes.WisdomBonusPercentage);
var charismaValue = (int)activeEffects.CalculateBonusFor(EffectTypes.CharismaBonusAmount, EffectTypes.CharismaBonusPercentage);
var allAttributeValue = (int)activeEffects.GetPotencyFor(EffectTypes.AllAttributeBonusAmount);
stats.Strength(strengthValue + allAttributeValue);
stats.Dexterity(dexterityValue + allAttributeValue);
stats.Constitution(constitutionValue + allAttributeValue);
stats.Intelligence(intelligenceValue + allAttributeValue);
stats.Wisdom(wisdomValue + allAttributeValue);
stats.Charisma(charismaValue + allAttributeValue);
}
public static void MaxHealth(this IStatsVariables stats, int value) => stats[StatsVariableTypes.MaxHealth] = value;
public float ComputePiercingDamage(IStatsVariables stats, IReadOnlyCollection <Effect> effects)
{
return(ComputeMeleeDamage(stats.Dexterity() / 100, EffectRelationships.PiercingDamageRelationship, effects));
}
public void Populate(IStatsVariables stats, IReadOnlyCollection <Effect> activeEffects, IReadOnlyCollection <IVariables> relatedVars)
{
PopulateHP(stats, activeEffects);
PopulateMP(stats, activeEffects);
}
public float ComputeLightDefense(IStatsVariables baseAttributeStats, IReadOnlyCollection <Effect> effects)
{
return(ComputeElementalDefense(baseAttributeStats.Intelligence() / 100, EffectRelationships.LightDefenseRelationship, effects));
}
public float ComputeBluntDamage(IStatsVariables stats, IReadOnlyCollection <Effect> effects)
{
return(ComputeMeleeDamage(stats.Strength() / 100, EffectRelationships.BluntDamageRelationship, effects));
}
public float ComputeBluntDefense(IStatsVariables baseAttributeStats, IReadOnlyCollection <Effect> effects)
{
return(ComputeMeleeDefense(baseAttributeStats.Strength() / 100, EffectRelationships.BluntDefenseRelationship, effects));
}
public float ComputePiercingDefense(IStatsVariables baseAttributeStats, IReadOnlyCollection <Effect> effects)
{
return(ComputeMeleeDefense(baseAttributeStats.Dexterity() / 100, EffectRelationships.PiercingDefenseRelationship, effects));
}
public static int Initiative(this IStatsVariables stats)
{
return((int)stats.GetVariable(GameStatsVariableTypes.Initiative));
}
public static float Damage(this IStatsVariables stats) => stats.Get(StatsVariableTypes.Damage);
public static void SetExperience(this IStatsVariables stats, int experience)
{
stats[GameStatsVariableTypes.Experience] = experience;
}
public static void RemoveExperience(this IStatsVariables stats, int experience)
{
var currentExperience = stats.GetVariable(GameStatsVariableTypes.Experience);
stats[GameStatsVariableTypes.Experience] = (int)(currentExperience - experience);
}
public static int Experience(this IStatsVariables stats)
{
return((int)stats.GetVariable(GameStatsVariableTypes.Experience));
}
public static void Damage(this IStatsVariables stats, float value) => stats[StatsVariableTypes.Damage] = value;
public static float Defense(this IStatsVariables stats) => stats.Get(StatsVariableTypes.Defense);
public static int MaxHealth(this IStatsVariables stats) => (int)stats.Get(StatsVariableTypes.MaxHealth);
public static void Defense(this IStatsVariables stats, float value) => stats[StatsVariableTypes.Defense] = value;
public float ComputeEarthDamage(IStatsVariables stats, IReadOnlyCollection <Effect> effects)
{
return(ComputeElementalDamage(stats.Intelligence() / 100, EffectRelationships.EarthDamageRelationship, effects));
}
public static void Initiative(this IStatsVariables stats, int initiative)
{
stats[GameStatsVariableTypes.Initiative] = initiative;
}
