private void ProcessSabPower() => SabotageOffensivePower =
MathConts.RoundNumber(
(SabFullAttack > 0 ?
SabFullAttack
:
(((SabotageOffensivePower - SabotageDecrease) / 2) + Squad.SabPowers.AttackPower.Total)) + SabOnTurnBonusAttack
);
private void InitiliazeAttack(FightStages defensor)
{
float dfx = defensor.Squad.AtkPowers.DefensePower.Bonus;
float atvii = defensor.Defense.CripleStrikeToAttack;
float baseDefense = MathConts.RoundNumber(defensor.Squad.AtkPowers.DefensePower.Base);
float totalDefense = defensor.Defense.AttackDefensivePower;
defensorAttack.Initialize(defensor.Squad.AtkMonster.MonsterName, dfx, atvii, baseDefense, totalDefense);
}
private void InitiliazeDefense(FightStages attacker)
{
float ativ = attacker.Squad.DefPowers.AttackPower.Bonus;
float atx = attacker.Attack.DefOnTurnBonusAttack;
float baseAttack = MathConts.RoundNumber(attacker.Squad.DefPowers.AttackPower.Base);
float totalAttack = attacker.Attack.DefenseOffensivePower;
attackerDefense.Initialize(attacker.Squad.DefMonster.MonsterName, ativ, atx, baseAttack, totalAttack);
}
private void InitiliazeDefense(FightStages defensor)
{
float dfi = defensor.Squad.DefPowers.DefensePower.Bonus;
float dfiii = defensor.Squad.DefPowers.DefensePower.DivergeDamageToDefense;
float dfv = defensor.Squad.DefPowers.DefensePower.CriticalHitResistance;
float dfix = defensor.Defense.StopBleedingPower;
float sabiii = defensor.Defense.DefenseDecrease;
float sabix = defensor.Defense.CriticalResistanteDecrease;
float atvii = defensor.Defense.CripleStrikeToDefense;
float baseDefense = MathConts.RoundNumber(defensor.Squad.DefPowers.DefensePower.Base);
float totalDefense = defensor.Defense.DefenseDefensivePower;
defensorDefense.Initialize(defensor.Squad.DefMonster.MonsterName, dfi, dfiii, dfv, dfix, sabiii, sabix, atvii, baseDefense, totalDefense);
}
private void InitiliazeAttack(FightStages attacker)
{
float ati = attacker.Squad.AtkPowers.AttackPower.Bonus;
float atiii = attacker.Attack.CriticalHitPower;
float atv = attacker.Attack.BleedingPower;
float atviii = attacker.Attack.DoubleStrikePower;
float atix = attacker.Attack.AdrenalineRushPower;
float atx = attacker.Attack.AtkOnTurnBonusAttack;
float sabiv = attacker.Attack.AttackDecrease;
float baseAttack = MathConts.RoundNumber(attacker.Squad.AtkPowers.AttackPower.Base);
float totalAttack = attacker.Attack.AttackOffensivePower;
attackerAttack.Initialize(attacker.Squad.AtkMonster.MonsterName, ati, atiii, atv, atviii, atix, atx, sabiv, baseAttack, totalAttack);
}
private void CriplingStrike(Attack attack)
{
if (attack.CripleStrikePower > 0)
{
switch (attack.GetCripleStrikeTarget())
{
case AbilityType.ATTACK: CripleStrikeToAttack = MathConts.GetPercentageOf(AttackDefensivePower, attack.CripleStrikePower); break;
case AbilityType.DEFENSE: CripleStrikeToDefense = MathConts.GetPercentageOf(DefenseDefensivePower, attack.CripleStrikePower); break;
case AbilityType.SABOTAGE: CripleStrikeToSabotage -= MathConts.GetPercentageOf(SabotageDefensivePower, attack.CripleStrikePower); break;
}
}
AttackDefensivePower = MathConts.RoundNumber(AttackDefensivePower - CripleStrikeToAttack);
DefenseDefensivePower = MathConts.RoundNumber(DefenseDefensivePower - CripleStrikeToDefense);
SabotageDefensivePower = MathConts.RoundNumber(SabotageDefensivePower - CripleStrikeToSabotage);
}
public void CalculatePercentagesOfDamage()
{
float maxPercentage = 100.0f;
float totalPercentage = maxPercentage - DivergeDamageToDefense - DivergeDamageToAttack - DivergeDamageToSabotage;
int numberOfMonstersAlive = HowManyAlive();
float percentageToMonsters = MathConts.RoundNumber(totalPercentage / numberOfMonstersAlive);
PercentageDamageDefense = !DefenseMonsterFainted ? percentageToMonsters + DivergeDamageToDefense : 0;
PercentageDamageAttack = !AttackMonsterFainted ? percentageToMonsters + DivergeDamageToAttack : 0;
PercentageDamageSabotage = !SabotageMonsterFainted ? percentageToMonsters + DivergeDamageToSabotage : 0;
float percentages = PercentageDamageDefense + PercentageDamageAttack + PercentageDamageSabotage;
if (percentages > maxPercentage)
{
PercentageDamageDefense = MathConts.RoundNumber(PercentageDamageDefense - (percentages - maxPercentage));
}
else
{
PercentageDamageDefense = MathConts.RoundNumber(PercentageDamageDefense + (maxPercentage - percentages));
}
}
private void InitiliazeSabotage(FightStages defensor)
{
float sabi = defensor.Squad.SabPowers.SabotagePower.Bonus;
float dfx_sabviii = 0.0f;
if (defensor.Attack.SabFullDefense > 0)
{
dfx_sabviii = defensor.Defense.SabFullDefense;
ImagesFillers.GetAbilityIcon(Icon_dfx_sabviii, AbilityIndex.DEFENSE10.ToString());
}
else
{
dfx_sabviii = defensor.Squad.DefPowers.DefensePower.Bonus;
ImagesFillers.GetAbilityIcon(Icon_dfx_sabviii, AbilityIndex.SABOTAGE8.ToString());
}
float atvii = defensor.Defense.CripleStrikeToSabotage;
float sabv = defensor.Defense.SabotageDecrease;
float baseDefense = MathConts.RoundNumber(defensor.Squad.SabPowers.DefensePower.Base);
float totalDefense = defensor.Defense.SabotageDefensivePower;
defensorSabotage.Initialize(defensor.Squad.SabMonster.MonsterName, sabi, dfx_sabviii, atvii, sabv, baseDefense, totalDefense);
}
private void InitiliazeSabotage(FightStages attacker)
{
float sabi = attacker.Squad.SabPowers.SabotagePower.Bonus;
float ativ_sabvii = 0.0f;
if (attacker.Attack.SabFullAttack > 0)
{
ativ_sabvii = attacker.Attack.SabFullAttack;
ImagesFillers.GetAbilityIcon(Icon_ativ_sabvii, AbilityIndex.ATTACK4.ToString());
}
else
{
ativ_sabvii = attacker.Squad.SabPowers.AttackPower.Bonus;
ImagesFillers.GetAbilityIcon(Icon_ativ_sabvii, AbilityIndex.SABOTAGE7.ToString());
}
float atx = attacker.Attack.SabOnTurnBonusAttack;
float sabv = attacker.Attack.SabotageDecrease;
float baseAttack = MathConts.RoundNumber(attacker.Squad.SabPowers.AttackPower.Base);
float totalAttack = attacker.Attack.SabotageOffensivePower;
attackerSabotage.Initialize(attacker.Squad.SabMonster.MonsterName, sabi, ativ_sabvii, atx, sabv, baseAttack, totalAttack);
}
private void ProcessDefPower() => DefenseOffensivePower = MathConts.RoundNumber(DefenseOffensivePower + DefOnTurnBonusAttack);
private void ProcessAtkPower() => AttackOffensivePower = MathConts.RoundNumber(AdrenalineRushPower + DoubleStrikePower + AttackBasePower);
private float ApplyDoubleStrike(float attackPower) => DoubleStrike?MathConts.RoundNumber(attackPower * 2) : 0;
private void ProcessSabPower() => SabotageDefensivePower =
MathConts.RoundNumber(SabFullDefense > 0 ?
SabFullDefense
:
((SabotageDefensivePower - SabotageDecrease) / 2) + Squad.SabPowers.DefensePower.Total
);
private void ProcessDefPower() => DefenseDefensivePower = MathConts.RoundNumber(DefenseDefensivePower - DefenseDecrease);
public void ProcessAtkPower() => AttackDefensivePower = MathConts.RoundNumber(Squad.AtkPowers.DefensePower.Total);