public UnitAttackArgs(BattleSideType attackerSideType, int attackerUnit, int attackerUnitId, int targetUnit, int damage, int unitHealth)
{
m_attackerSideType = attackerSideType;
m_damage = damage;
m_targetUnit = targetUnit;
m_attackerUnit = attackerUnit;
m_attackerUnitId = attackerUnitId;
m_unitHealth = unitHealth;
}
protected override int[] GetUnitsDamage(BattleSideType battleSideTime, Unit unit, int unitCount, Random random)
{
int[] result = new int[unitCount];
DamageGenerator damageGenerator = GetDamageGenerator(battleSideTime, unit);
for (int i = 0; i < result.Length; i++)
{
result[i] = damageGenerator.Generate();
}
return(result);
}
internal BattleSideStep(Battle battle, BattleSideType sideType)
{
BattleSide battleSide = battle.Sides[(int)sideType];
m_counts = new short[battleSide.Counts.Length];
Array.Copy(battleSide.Counts, m_counts, m_counts.Length);
m_healts = new int[battleSide.Units.Length];
for (int i = 0; i < battleSide.Units.Length; i++)
{
m_healts[i] = battleSide.Units[i].Health;
}
m_general = battleSide.General;
}
private int AttackUnits2(
int unitIndex,
int unitCount,
int targetIndex,
Battle battle,
BattleStep newStep,
BattleSideType attackerSide,
Random random,
UnitAttackHandler unitAttackHandler)
{
Unit unit = battle.Sides[(int)attackerSide].Units[unitIndex];
return(AttackUnits2(unit, unitIndex, unitCount, targetIndex, battle, newStep, attackerSide, random, unitAttackHandler));
}
private static BattleSideType GetEnemySide(BattleSideType side)
{
switch (side)
{
case BattleSideType.Player:
return(BattleSideType.Enemy);
case BattleSideType.Enemy:
return(BattleSideType.Player);
default:
throw new ArgumentOutOfRangeException("side");
}
}
internal Step(Battle battle, List <UnitAttackArgs> attacks)
{
AddAttacks(battle, attacks);
List <UnitAttackArgs> temp = new List <UnitAttackArgs>();
BattleSideType side = BattleSideType.Player;
int attacker = int.MinValue;
foreach (UnitAttackArgs arg in attacks)
{
if (side != arg.AttackerSide || arg.AttackerUnit != attacker)
{
if (temp.Count > 0)
{
SquadAttack attack = new SquadAttack(battle, temp);
if (side == BattleSideType.Player)
{
PlayerSqadsAttacks.Add(attack);
}
else
{
EnemySqadsAttacks.Add(attack);
}
temp.Clear();
}
side = arg.AttackerSide;
attacker = arg.AttackerUnit;
}
temp.Add(arg);
}
if (temp.Count > 0)
{
SquadAttack attack = new SquadAttack(battle, temp);
if (side == BattleSideType.Player)
{
PlayerSqadsAttacks.Add(attack);
}
else
{
EnemySqadsAttacks.Add(attack);
}
}
}
protected override int[] GetUnitsDamage(BattleSideType battleSideTime, Unit unit, int unitCount, Random random)
{
int[] originalDamages = new int[unitCount];
for (int i = 0; i < originalDamages.Length; i++)
{
originalDamages[i] = random.Next(1, 101) > unit.Accuracy
? unit.MinDamage
: unit.MaxDamage;
}
Shuffle(originalDamages, random);
/*byte[] temp = new byte[unitCount];
* byte bound = (byte)Math.Round((double)255 * unit.Accuracy / 100);
* random.NextBytes(temp);
* for(int i = 0; i < temp.Length; i++)
* {
* originalDamages[i] = temp[i] > bound
* ? unit.MinDamage
* : unit.MaxDamage;
* }*/
return(originalDamages);
}
private DamageGenerator GetDamageGenerator(BattleSideType battleSideTime, Unit unit)
{
DamageGenerator result;
if (battleSideTime == BattleSideType.Player)
{
if (m_attackerChances.TryGetValue(unit.Id, out result))
{
return(result);
}
}
else
{
if (m_defenderChances.TryGetValue(unit.Id, out result))
{
return(result);
}
}
if (result == null)
{
result = new DamageGenerator(unit,
battleSideTime == BattleSideType.Player
? m_targetAttackerChance
: m_targetDefenderChance);
if (battleSideTime == BattleSideType.Player)
{
m_attackerChances[unit.Id] = result;
}
else
{
m_defenderChances[unit.Id] = result;
}
}
return(result);
}
protected abstract int[] GetUnitsDamage(BattleSideType battleSideTime, Unit unit, int unitCount, Random random);
private int AttackUnits2(
Unit unit,
int unitIndex,
int unitCount,
int targetIndex,
Battle battle,
BattleStep newStep,
BattleSideType attackerSide,
Random random,
UnitAttackHandler unitAttackHandler)
{
BattleSideType defenderSideType = GetEnemySide(attackerSide);
BattleSideStep defenderSideStep = newStep.Sides[(int)defenderSideType];
int[] originalDamages = GetUnitsDamage(attackerSide, unit, unitCount, random);
int[] reducedDamages = originalDamages;
double towerBonus = battle.Sides[(int)defenderSideType].TowerBonus;
if (towerBonus > 0 && unit.IgnoreTowerBonus != 100)
{
towerBonus = towerBonus * (1 - unit.IgnoreTowerBonus / 100);
reducedDamages = new int[originalDamages.Length];
for (int i = 0; i < originalDamages.Length; i++)
{
reducedDamages[i] = (int)Math.Truncate(originalDamages[i] * towerBonus);
}
}
if (targetIndex < 0)
{
targetIndex = GetTargetIndex(unit, defenderSideStep.Counts, defenderSideStep.Healts);
}
if (targetIndex < 0)
{
// no more targets
return(-1);
}
int[] damages = GetDamageWithTargetUnitReduction(
battle.Sides[(int)defenderSideType].Units[targetIndex],
originalDamages,
reducedDamages);
int unitId = 0;
foreach (int temp in damages)
{
int damage = temp;
unitId++;
if (unitAttackHandler != null)
{
if (unit.AttackOnArea)
{
unitAttackHandler(null, new UnitAttackArgs(
attackerSide,
unitIndex,
unitId,
targetIndex,
Math.Min(damage, defenderSideStep.Healts[targetIndex]),
defenderSideStep.Healts[targetIndex]));
}
else
{
unitAttackHandler(null, new UnitAttackArgs(
attackerSide,
unitIndex,
unitId,
targetIndex,
damage,
defenderSideStep.Healts[targetIndex]));
}
}
defenderSideStep.Healts[targetIndex] -= damage;
if (defenderSideStep.Healts[targetIndex] <= 0)
{
defenderSideStep.Counts[targetIndex]--;
damage = -defenderSideStep.Healts[targetIndex];
int targetUnitHealth = battle.Sides[(int)defenderSideType].Units[targetIndex].Health;
defenderSideStep.Healts[targetIndex] = targetUnitHealth;
if (unit.AttackOnArea)
{
while (damage > 0)
{
targetUnitHealth = battle.Sides[(int)defenderSideType].Units[targetIndex].Health;
int remDamage;
int killedUnits = Math.DivRem(
damage,
targetUnitHealth,
out remDamage);
if (killedUnits < defenderSideStep.Counts[targetIndex])
{
defenderSideStep.Counts[targetIndex] -= (short)killedUnits;
defenderSideStep.Healts[targetIndex] -= (short)remDamage;
int prevDamage = 0;
if (defenderSideStep.Healts[targetIndex] <= 0)
{
prevDamage = remDamage + defenderSideStep.Healts[targetIndex];
remDamage = remDamage - prevDamage;
defenderSideStep.Counts[targetIndex]--;
defenderSideStep.Healts[targetIndex] = targetUnitHealth;
}
damage = 0;
if (unitAttackHandler != null)
{
if (prevDamage > 0)
{
unitAttackHandler(null, new UnitAttackArgs(
attackerSide,
unitIndex,
unitId,
targetIndex,
prevDamage,
battle.Sides[(int)defenderSideType].Units[targetIndex].Health));
}
for (int i = 0; i < killedUnits; i++)
{
unitAttackHandler(null, new UnitAttackArgs(
attackerSide,
unitIndex,
unitId,
targetIndex,
targetUnitHealth,
battle.Sides[(int)defenderSideType].Units[targetIndex].Health));
}
if (remDamage > 0)
{
unitAttackHandler(null, new UnitAttackArgs(
attackerSide,
unitIndex,
unitId,
targetIndex,
remDamage,
battle.Sides[(int)defenderSideType].Units[targetIndex].Health));
}
}
}
else
{
// squad killed
damage -= defenderSideStep.Counts[targetIndex] * targetUnitHealth;
if (unitAttackHandler != null)
{
for (int i = 0; i < defenderSideStep.Counts[targetIndex]; i++)
{
unitAttackHandler(null, new UnitAttackArgs(
attackerSide,
unitIndex,
unitId,
targetIndex,
targetUnitHealth,
targetUnitHealth));
}
}
defenderSideStep.Counts[targetIndex] = 0;
targetIndex = GetTargetIndex(unit, defenderSideStep.Counts, defenderSideStep.Healts);
if (targetIndex < 0)
{
// no more targets
return(-1);
}
damages = GetDamageWithTargetUnitReduction(
battle.Sides[(int)defenderSideType].Units[targetIndex],
originalDamages,
reducedDamages);
}
}
}
if (unit.AttackWeaknessTarget || defenderSideStep.Counts[targetIndex] == 0)
{
targetIndex = GetTargetIndex(unit, defenderSideStep.Counts, defenderSideStep.Healts);
if (targetIndex < 0)
{
return(targetIndex);
}
damages = GetDamageWithTargetUnitReduction(
battle.Sides[(int)defenderSideType].Units[targetIndex],
originalDamages,
reducedDamages);
}
}
}
return(targetIndex);
}
