public int attack(Enemy.EnemyClass enemy)
{
int minDamageAfterArmor = (int)MinDamageWithEquipment() * (100 - enemy.armor) / 100;
int maxDamageAfterArmor = (int)MaxDamageWithEquipment() * (100 - enemy.armor) / 100;
return(damageDealt.Next(minDamageAfterArmor, maxDamageAfterArmor));
}
public int overpower(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= Overpower.levelRequired)
{
mana -= Overpower.mana;
}
else
{
mana -= 1000;
}
int overpowerBashAbilityAfterArmor = Overpower.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(overpowerBashAbilityAfterArmor - 3, overpowerBashAbilityAfterArmor + 3));
}
public int assault(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= Assault.levelRequired)
{
mana -= Assault.mana;
}
else
{
mana -= 1000;
}
int assaultAbilityAfterArmor = Assault.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(assaultAbilityAfterArmor - 8, assaultAbilityAfterArmor + 8));
}
public int shieldbash(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= Shieldbash.levelRequired)
{
mana -= Shieldbash.mana;
}
else
{
mana -= 1000;
}
int shieldBashAbilityAfterArmor = Shieldbash.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(shieldBashAbilityAfterArmor - 2, shieldBashAbilityAfterArmor + 2));
}
public int mightyblow(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= mightyBlowAbility.levelRequired)
{
mana -= mightyBlowAbility.mana;
}
else
{
mana -= 1000;
}
int mightyBlowAbilityAfterArmor = mightyBlowAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(mightyBlowAbilityAfterArmor - 7, mightyBlowAbilityAfterArmor + 7));
}
public int belowthebelt(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= belowTheBeltAbility.levelRequired)
{
mana -= belowTheBeltAbility.mana;
}
else
{
mana -= 1000;
}
int shootAbilityAfterArmor = belowTheBeltAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(shootAbilityAfterArmor - 3, shootAbilityAfterArmor + 3));
}
public int backstab(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= backstabAbility.levelRequired)
{
mana -= backstabAbility.mana;
}
else
{
mana -= 1000;
}
int backstabAbilityAfterArmor = backstabAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(backstabAbilityAfterArmor - 2, backstabAbilityAfterArmor + 2));
}
public int ambush(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= ambushAbility.levelRequired)
{
mana -= ambushAbility.mana;
}
else
{
mana -= 1000;
}
int ambushAbilityAfterArmor = ambushAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(ambushAbilityAfterArmor - 5, ambushAbilityAfterArmor + 10));
}
public int blizzard(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= blizzardAbility.levelRequired)
{
mana -= blizzardAbility.mana;
}
else
{
mana -= 1000;
}
int blizzardAfterResistance = blizzardAbility.averageDamage * (100 - enemy.iceResistance) / 100;
return(damageDealt.Next(blizzardAfterResistance - 15, blizzardAfterResistance + 15));
}
public int inferno(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= infernoAbility.levelRequired)
{
mana -= infernoAbility.mana;
}
else
{
mana -= 1000;
}
int infernoAfterResistance = infernoAbility.averageDamage * (100 - enemy.fireResistance) / 100;
return(damageDealt.Next(infernoAfterResistance - 10, infernoAfterResistance + 10));
}
public int lightning(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= lightningAbility.levelRequired)
{
mana -= lightningAbility.mana;
}
else
{
mana -= 1000;
}
int lightningAfterResistance = lightningAbility.averageDamage * (100 - enemy.lightningResistance) / 100;
return(damageDealt.Next(lightningAfterResistance - 15, lightningAfterResistance + 15));
}
public int immolate(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= immolateAbility.levelRequired)
{
mana -= immolateAbility.mana;
}
else
{
mana -= 1000;
}
int immolateAfterResistance = immolateAbility.averageDamage * (100 - enemy.fireResistance) / 100;
return(damageDealt.Next(immolateAfterResistance - 7, immolateAfterResistance + 7));
}
public int execute(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= executeAbility.levelRequired)
{
mana -= executeAbility.mana;
}
else
{
mana -= 1000;
}
int executeAbilityAfterArmor = executeAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(executeAbilityAfterArmor - 4, executeAbilityAfterArmor + 4));
}
public int rampage(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= rampageAbility.levelRequired)
{
mana -= rampageAbility.mana;
}
else
{
mana -= 1000;
}
int rampageAbilityAfterArmor = rampageAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(rampageAbilityAfterArmor - 10, rampageAbilityAfterArmor + 10));
}
public int whirlwind(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= whirlwindAbility.levelRequired)
{
mana -= whirlwindAbility.mana;
}
else
{
mana -= 1000;
}
int whirlwindAbilityAfterArmor = whirlwindAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(whirlwindAbilityAfterArmor - 8, whirlwindAbilityAfterArmor + 8));
}
public int hearthstrike(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= Execute.levelRequired)
{
mana -= Execute.mana;
}
else
{
mana -= 1000;
}
int hearthStrikeAbilityAfterArmor = HeartStrike.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(hearthStrikeAbilityAfterArmor - 5, hearthStrikeAbilityAfterArmor + 10));
}
public int hookandtackle(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= hookAndTackleAbility.levelRequired)
{
mana -= hookAndTackleAbility.mana;
}
else
{
mana -= 1000;
}
int hookAndTackleAbilityAfterArmor = hookAndTackleAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(hookAndTackleAbilityAfterArmor - 5, hookAndTackleAbilityAfterArmor + 10));
}
public int fireball(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= fireballAbility.levelRequired)
{
mana -= fireballAbility.mana;
}
else
{
mana -= 1000;
}
int fireballAfterResistance = fireballAbility.averageDamage * (100 - enemy.fireResistance) / 100;
return(damageDealt.Next(fireballAfterResistance - 2, fireballAfterResistance + 2));
}
public int throatcut(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= throatCutAbility.levelRequired)
{
mana -= throatCutAbility.mana;
}
else
{
mana -= 1000;
}
int throatCutAbilityAfterArmor = throatCutAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(throatCutAbilityAfterArmor - 5, throatCutAbilityAfterArmor + 10));
}
public int shock(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= shockAbility.levelRequired)
{
mana -= shockAbility.mana;
}
else
{
mana -= 1000;
}
int shockAfterResistance = shockAbility.averageDamage * (100 - enemy.lightningResistance) / 100;
return(damageDealt.Next(shockAfterResistance - 8, shockAfterResistance + 8));
}
public int multistrike(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= multistrikeAbility.levelRequired)
{
mana -= multistrikeAbility.mana;
}
else
{
mana -= 1000;
}
int multistrikeAfterArmor = multistrikeAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(multistrikeAfterArmor - 8, multistrikeAfterArmor + 8));
}
public int icelance(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= iceLanceAbility.levelRequired)
{
mana -= iceLanceAbility.mana;
}
else
{
mana -= 1000;
}
int iceLanceAfterResistance = iceLanceAbility.averageDamage * (100 - enemy.iceResistance) / 100;
return(damageDealt.Next(iceLanceAfterResistance - 5, iceLanceAfterResistance + 10));
}
public int stealthkill(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= stealthKillAbility.levelRequired)
{
mana -= stealthKillAbility.mana;
}
else
{
mana -= 1000;
}
int stealthKillAbilityAfterArmor = stealthKillAbility.averageDamage * (100 - enemy.armor) / 100;
return(damageDealt.Next(stealthKillAbilityAfterArmor - 5, stealthKillAbilityAfterArmor + 10));
}
public int iceblast(Enemy.EnemyClass enemy)
{
Random damageDealt = new Random();
if (level >= IceBlast.levelRequired)
{
mana -= IceBlast.mana;
}
else
{
mana -= 1000;
}
int iceBlastAfterResistance = IceBlast.averageDamage * (100 - enemy.iceResistance) / 100;
return(damageDealt.Next(iceBlastAfterResistance - 4, iceBlastAfterResistance + 4));
}
