public void ApplyPermanently(Unit unit, UnitStats modifiedStats)
{
if (unit.NativeTerrainId == Id)
{
modifiedStats.Attack += 1;
modifiedStats.Defense += 1;
}
}
public override void ApplyPermanently(Unit unit, UnitStats modifiedStats)
{
if (CasterStats.SkillLevel <= SecondarySkillLevel.Basic)
{
modifiedStats.MinDamage = modifiedStats.MaxDamage = unit.InitialStats.MaxDamage;
}
else
{
modifiedStats.MinDamage = modifiedStats.MaxDamage = unit.InitialStats.MaxDamage + 1;
}
}
public void ApplyOnDefense(AttackData attackData, UnitStats modifiedStats)
{
}
public void ApplyOnAttack(AttackData attackData, UnitStats modifiedStats)
{
}
public void CalculateDamage(CombatDamageCalculatorInputData data, out int minDamage, out int maxDamage, out string notes)
{
if (data.AttackerCount == 0)
{
minDamage = 0;
maxDamage = 0;
notes = null;
return;
}
CombatDamageModifier damageModifier = new CombatDamageModifier();
AttackData attackData = new AttackData {
Attacker = data.Attacker, Defender = data.Defender
};
List <ICombatUnitStatsModifier> attackerStatsModifiers = new List <ICombatUnitStatsModifier>();
List <ICombatUnitStatsModifier> defenderStatsModifiers = new List <ICombatUnitStatsModifier>();
List <ICombatDamageModifierProvider> attackerDamageModifierProviders = new List <ICombatDamageModifierProvider>();
List <ICombatDamageModifierProvider> defenderDamageModifierProviders = new List <ICombatDamageModifierProvider>();
if (data.Terrain != null)
{
attackerStatsModifiers.Add(data.Terrain);
defenderStatsModifiers.Add(data.Terrain);
}
if (data.AttackerHeroStats != null)
{
attackerStatsModifiers.Add(data.AttackerHeroStats);
attackerDamageModifierProviders.Add(data.AttackerHeroStats);
}
if (data.DefenderHeroStats != null)
{
defenderStatsModifiers.Add(data.DefenderHeroStats);
defenderDamageModifierProviders.Add(data.DefenderHeroStats);
}
if (data.AttackerSpells != null)
{
attackerStatsModifiers.AddRange(data.AttackerSpells);
attackerDamageModifierProviders.AddRange(data.AttackerSpells);
}
if (data.DefenderSpells != null)
{
defenderStatsModifiers.AddRange(data.DefenderSpells);
defenderDamageModifierProviders.AddRange(data.DefenderSpells);
}
attackerStatsModifiers.Add(UnitUniqueTraitManager.Instance);
defenderStatsModifiers.Add(UnitUniqueTraitManager.Instance);
attackerDamageModifierProviders.Add(UnitUniqueTraitManager.Instance);
defenderDamageModifierProviders.Add(UnitUniqueTraitManager.Instance);
/////////////////////////
UnitStats modifiedAttackerStats = data.Attacker.InitialStats.Copy();
UnitStats modifiedDefenderStats = data.Defender.InitialStats.Copy();
foreach (ICombatUnitStatsModifier modifier in attackerStatsModifiers)
{
modifier.ApplyPermanently(data.Attacker, modifiedAttackerStats);
modifier.ApplyOnAttack(attackData, modifiedAttackerStats);
}
foreach (ICombatUnitStatsModifier modifier in defenderStatsModifiers)
{
modifier.ApplyPermanently(data.Defender, modifiedDefenderStats);
modifier.ApplyOnDefense(attackData, modifiedDefenderStats);
}
int totalAttack = modifiedAttackerStats.Attack;
int totalDefense = modifiedDefenderStats.Defense;
if (totalAttack > totalDefense)
{
double primarySkillBonus = Math.Min((totalAttack - totalDefense) * 0.05, 3.0);
damageModifier.DamageBonuses.Add(primarySkillBonus);
}
else if (totalAttack < totalDefense)
{
double primarySkillReduction = Math.Min((totalDefense - totalAttack) * 0.025, 0.7);
damageModifier.DamageReductions.Add(primarySkillReduction);
}
/////////////////////////
foreach (ICombatDamageModifierProvider provider in attackerDamageModifierProviders)
{
provider.ApplyOnAttack(attackData, damageModifier);
}
foreach (ICombatDamageModifierProvider provider in defenderDamageModifierProviders)
{
provider.ApplyOnDefense(attackData, damageModifier);
}
int minBaseDamage = data.AttackerCount * modifiedAttackerStats.MinDamage;
int maxBaseDamage = data.AttackerCount * modifiedAttackerStats.MaxDamage;
minDamage = PerformCalculation(minBaseDamage, damageModifier);
maxDamage = PerformCalculation(maxBaseDamage, damageModifier);
notes = GenerateNotes(data);
}
public void ApplyPermanently(Unit unit, UnitStats modifiedStats)
{
}
public void ApplyOnDefense(AttackData attackData, UnitStats modifiedStats)
{
if (attackData.Attacker.Id == 110) // Behemoth
{
modifiedStats.Defense = (int)(modifiedStats.Defense * 0.6);
}
if (attackData.Attacker.Id == 111) // Ancient Behemoth
{
modifiedStats.Defense = (int)(modifiedStats.Defense * 0.2);
}
}
public void ApplyOnAttack(AttackData attackData, UnitStats modifiedStats)
{
}
public void ApplyPermanently(Unit unit, UnitStats modifiedStats)
{
}
public override void ApplyPermanently(Unit unit, UnitStats modifiedStats)
{
if (unit.IsRanged)
{
return;
}
int bonus = (CasterStats.SkillLevel <= SecondarySkillLevel.Basic) ? 3 : 6;
if (CasterStats.IsSpecialized)
{
switch (unit.Level)
{
case 1:
case 2:
bonus += 3;
break;
case 3:
case 4:
bonus += 2;
break;
case 5:
case 6:
bonus += 1;
break;
}
}
modifiedStats.Attack += bonus;
}
public override void ApplyPermanently(Unit unit, UnitStats modifiedStats)
{
int reduction = (CasterStats.SkillLevel <= SecondarySkillLevel.Basic) ? 3 : 6;
if (CasterStats.IsSpecialized)
{
switch (unit.Level)
{
case 1:
case 2:
reduction += 3;
break;
case 3:
case 4:
reduction += 2;
break;
case 5:
case 6:
reduction += 1;
break;
}
}
modifiedStats.Attack -= reduction;
}
public override void ApplyOnAttack(AttackData attackData, UnitStats modifiedStats)
{
List<int> affectedUnitIds = new List<int>();
affectedUnitIds.Add(26); // Green Dragon
affectedUnitIds.Add(27); // Gold Dragon
affectedUnitIds.Add(54); // Bone Dragon
affectedUnitIds.Add(55); // Ghost Dragon
affectedUnitIds.Add(68); // Red Dragon
affectedUnitIds.Add(69); // Black Dragon
affectedUnitIds.Add(96); // Hydra
affectedUnitIds.Add(97); // Chaos Hydra
affectedUnitIds.Add(110); // Behemoth
affectedUnitIds.Add(111); // Ancient Behemoth
affectedUnitIds.Add(124); // Firebird
affectedUnitIds.Add(125); // Phoenix
affectedUnitIds.Add(137); // Fairy Dragon
affectedUnitIds.Add(138); // Rust Dragon
affectedUnitIds.Add(139); // Crystal Dragon
affectedUnitIds.Add(140); // Azure Dragon
if (CasterStats.SkillLevel >= SecondarySkillLevel.Advanced)
{
affectedUnitIds.Add(12); // Angel
affectedUnitIds.Add(13); // Archangel
affectedUnitIds.Add(82); // Devil
affectedUnitIds.Add(83); // Archdevil
}
if (CasterStats.SkillLevel == SecondarySkillLevel.Expert)
{
affectedUnitIds.Add(40); // Giant
affectedUnitIds.Add(41); // Titan
}
if (affectedUnitIds.Contains(attackData.Defender.Id))
{
int bonus = 8;
if (CasterStats.IsSpecialized)
{
switch (attackData.Attacker.Level)
{
case 1:
bonus += 4;
break;
case 2:
bonus += 3;
break;
case 3:
bonus += 2;
break;
case 4:
bonus += 1;
break;
}
}
modifiedStats.Attack += bonus;
}
}
public virtual void ApplyOnDefense(AttackData attackData, UnitStats modifiedStats)
{
}
public override void ApplyPermanently(Unit unit, UnitStats modifiedStats)
{
if (CasterStats.SkillLevel <= SecondarySkillLevel.Basic)
{
modifiedStats.Attack += modifiedStats.Defense;
}
else if (CasterStats.SkillLevel <= SecondarySkillLevel.Advanced)
{
modifiedStats.Attack += modifiedStats.Defense * 3 / 2;
}
else
{
modifiedStats.Attack += modifiedStats.Defense * 2;
}
modifiedStats.Defense = 0;
}
public override void ApplyPermanently(Unit unit, UnitStats modifiedStats)
{
int reduction;
if (CasterStats.SkillLevel <= SecondarySkillLevel.Basic)
{
reduction = 3;
}
else if (CasterStats.SkillLevel <= SecondarySkillLevel.Advanced)
{
reduction = 4;
}
else
{
reduction = 5;
}
if (CasterStats.IsSpecialized)
{
reduction += 2;
}
modifiedStats.Defense -= reduction;
modifiedStats.Defense = Math.Max(modifiedStats.Defense, 0);
}
public override void ApplyOnAttack(AttackData attackData, UnitStats modifiedStats)
{
List <int> affectedUnitIds = new List <int>();
affectedUnitIds.Add(26); // Green Dragon
affectedUnitIds.Add(27); // Gold Dragon
affectedUnitIds.Add(54); // Bone Dragon
affectedUnitIds.Add(55); // Ghost Dragon
affectedUnitIds.Add(68); // Red Dragon
affectedUnitIds.Add(69); // Black Dragon
affectedUnitIds.Add(96); // Hydra
affectedUnitIds.Add(97); // Chaos Hydra
affectedUnitIds.Add(110); // Behemoth
affectedUnitIds.Add(111); // Ancient Behemoth
affectedUnitIds.Add(124); // Firebird
affectedUnitIds.Add(125); // Phoenix
affectedUnitIds.Add(137); // Fairy Dragon
affectedUnitIds.Add(138); // Rust Dragon
affectedUnitIds.Add(139); // Crystal Dragon
affectedUnitIds.Add(140); // Azure Dragon
if (CasterStats.SkillLevel >= SecondarySkillLevel.Advanced)
{
affectedUnitIds.Add(12); // Angel
affectedUnitIds.Add(13); // Archangel
affectedUnitIds.Add(82); // Devil
affectedUnitIds.Add(83); // Archdevil
}
if (CasterStats.SkillLevel == SecondarySkillLevel.Expert)
{
affectedUnitIds.Add(40); // Giant
affectedUnitIds.Add(41); // Titan
}
if (affectedUnitIds.Contains(attackData.Defender.Id))
{
int bonus = 8;
if (CasterStats.IsSpecialized)
{
switch (attackData.Attacker.Level)
{
case 1:
bonus += 4;
break;
case 2:
bonus += 3;
break;
case 3:
bonus += 2;
break;
case 4:
bonus += 1;
break;
}
}
modifiedStats.Attack += bonus;
}
}
