/// <returns>(city-dead,town-dead,explorer-dead)</returns>
public async Task DamageAttackers(int damageFromDefenders)
{
@event.attackerDamageFromDefenders = damageFromDefenders;
if (damageFromDefenders == 0)
{
return;
}
@event.attackerDamageFromBadlands = BadLandsCount;
int remainingDamageToApply = damageFromDefenders + BadLandsCount;
// ! must use current Attackers counts, because some have lost their strife so tokens are different than when they started.
var remaningAttackers = currentAttackers.Clone();
while (remainingDamageToApply > 0 && remaningAttackers.Any())
{
HealthToken attackerToDamage = PickSmartInvaderToDamage(remaningAttackers, remainingDamageToApply);
// Apply real damage
var(damageInflicted, _) = await grp.ApplyDamageTo1(remainingDamageToApply, attackerToDamage, true);
remainingDamageToApply -= damageInflicted;
// Apply tracking damage
--remaningAttackers[attackerToDamage];
var damagedAttacker = attackerToDamage.AddDamage(damageInflicted);
if (damagedAttacker.RemainingHealth > 0)
{
++remaningAttackers[damagedAttacker];
}
}
@event.endingAttackers = remaningAttackers;
}
/// <summary> Not Badland-aware </summary>
/// <returns>(damage inflicted,damagedInvader)</returns>
public async Task <(int, Token)> ApplyDamageTo1(int availableDamage, HealthToken invaderToken, bool fromRavage = false) // !! change Token to HealthToken
{
var damagedInvader = invaderToken.AddDamage(availableDamage);
if (!damagedInvader.IsDestroyed)
{
Tokens.Adjust(invaderToken, -1);
Tokens.Adjust(damagedInvader, 1);
}
else
{
await DestroyStrategy.OnInvaderDestroyed(Space, invaderToken, fromRavage);
}
int damageInflicted = invaderToken.RemainingHealth - damagedInvader.RemainingHealth;
return(damageInflicted, damagedInvader); // damage inflicted
}
static async Task DamageInvaderHealthByItsOwnStrife(TokenCountDictionary tokens, HealthToken originalInvader)
{
var newInvader = originalInvader.AddDamage(originalInvader.StrifeCount);
if (newInvader == originalInvader)
{
return;
}
if (newInvader.IsDestroyed)
{
await tokens.Destroy(originalInvader, tokens[originalInvader]);
}
else
{
tokens.Adjust(newInvader, tokens[originalInvader]);
tokens.Init(originalInvader, 0);
}
}
public async Task <int> ApplyDamageToToken(int damageToDahan, HealthToken token)
{
// Destroy what can be destroyed
if (token.RemainingHealth <= damageToDahan)
{
int destroyed = damageToDahan / token.RemainingHealth;
await Destroy(destroyed, token);
damageToDahan -= destroyed * token.RemainingHealth;
}
// if we can apply partial damage
if (0 < damageToDahan && 0 < _tokens[token])
{
_tokens.Adjust(token, -1);
_tokens.Adjust(token.AddDamage(damageToDahan), 1);
damageToDahan = 0; // damage should be used up
}
return(damageToDahan);
}