internal BattleState GetWithDefeatedRemoved()
{
BattleStageSide newLeftSide = LeftSide.GetRepositionedSurvivors();
BattleStageSide newRightSide = RightSide.GetRepositionedSurvivors();
return(new BattleState(newLeftSide, newRightSide));
}
private List <BattleRound> GetProgression(BattleStageSide left, BattleStageSide right)
{
BattleState currentState = new BattleState(left, right);
List <BattleRound> ret = new List <BattleRound>();
while (ret.Count < BattleRoundLimit)
{
IEnumerable <BattalionBattleEffects> effects = currentState.GetUnitEffects().ToArray();
BattleState withEffectsApplied = currentState.GetWithEffectsApplied(effects);
if (withEffectsApplied.Status == BattleStatus.Ongoing)
{
BattleState withDefeatedRemoved = withEffectsApplied.GetWithDefeatedRemoved();
BattleRound round = new BattleRound(currentState, effects, withEffectsApplied, withDefeatedRemoved);
ret.Add(round);
currentState = withDefeatedRemoved;
}
else
{
BattleRound round = new BattleRound(currentState, effects, withEffectsApplied, withEffectsApplied);
ret.Add(round);
break;
}
}
return(ret);
}
public Battle ToBattle()
{
BattleStageSide baseLeftSide = new BattleStageSide(leftUnitsList);
BattleStageSide baseRightSide = new BattleStageSide(rightUnitsList);
BattleStageSide leftSide = baseLeftSide.GetRepositionedSurvivors();
BattleStageSide rightSide = baseRightSide.GetRepositionedSurvivors();
return(new Battle(leftSide, rightSide));
}
public override BattalionBattleEffects GetEffect(BattalionState self, BattleStageSide allies, BattleStageSide enemies)
{
BattalionEffectsBuilder builder = new BattalionEffectsBuilder(this);
int rallyStrength = self.GetAttribute(BattalionAttribute.RallyStrength);
foreach (BattalionState item in allies)
{
builder.Add(item.Id, BattalionAttribute.RemainingMoral, rallyStrength);
}
return(builder.ToEffects());
}
public BattalionBattleEffects GetEffects(BattleStageSide allies, BattleStageSide enemies)
{
List <BattalionStateModifier> modifiers = new List <BattalionStateModifier>();
List <BattalionSpawnEffect> spawns = new List <BattalionSpawnEffect>();
foreach (BattalionEffector attack in EffectSources)
{
var effects = attack.GetEffect(this, allies, enemies);
modifiers.AddRange(effects.UnitModifications);
spawns.AddRange(effects.UnitSpawns);
}
return(new BattalionBattleEffects(modifiers, spawns));
}
/// <summary>
/// Returns all front units until a unit has anticharge
/// </summary>
private IEnumerable <BattalionState> GetChargeTargets(BattleStageSide enemies, BattalionState regularTarget)
{
IEnumerable <BattalionState> frontLineUnits = enemies.Where(unit => unit.Position.IsFrontLine);
if (frontLineUnits.Any(IsAntiCharge))
{
return(new BattalionState[0]);
}
else
{
return(frontLineUnits.Where(unit => unit != regularTarget));
}
}
private IEnumerable <BattalionState> GetSplashTargets(BattalionState target, BattleStageSide enemies)
{
IEnumerable <BattalionPosition> positions = target.Position.GetAdjacentPositions().ToArray();
HashSet <BattalionPosition> set = new HashSet <BattalionPosition>(positions);
List <BattalionState> ret = new List <BattalionState>();
foreach (var item in enemies)
{
if (set.Contains(item.Position))
{
ret.Add(item);
}
}
return(ret);
}
public override BattalionBattleEffects GetEffect(BattalionState self, BattleStageSide allies, BattleStageSide enemies)
{
BattalionEffectsBuilder builder = new BattalionEffectsBuilder(this);
int reloadingState = self.GetAttribute(BattalionAttribute.ReloadingState);
if (reloadingState > 0)
{
builder.Add(self.Id, BattalionAttribute.ReloadingState, -1);
}
else
{
if (IsWithinAttackingRange(self.Position))
{
DoAttack(builder, self, enemies);
}
}
return(builder.ToEffects());
}
private void DoAttack(BattalionEffectsBuilder builder, BattalionState self, BattleStageSide enemies)
{
BattalionState target = enemies.GetTargetFor(self.Position);
BattalionAttribute damageAttribute = GetDamageAttributeFor(damageType);
builder.Add(target.Id, damageAttribute, weaponStrength);
if (splashDamage > 0)
{
IEnumerable <BattalionState> splashTargets = GetSplashTargets(target, enemies).ToArray();
foreach (BattalionState splashTarget in splashTargets)
{
builder.Add(splashTarget.Id, damageAttribute, splashDamage);
}
}
int reloadingSpeed = self.GetAttribute(BattalionAttribute.ReloadingSpeed);
builder.Add(self.Id, BattalionAttribute.ReloadingState, reloadingSpeed);
}
private BattleState GetNewBattleState(IEnumerable <BattalionState> modifiedUnits, IEnumerable <BattalionSpawnEffect> spawns)
{
ModifiedSideSorter leftSideSorter = new ModifiedSideSorter(LeftSide);
ModifiedSideSorter rightSideSorter = new ModifiedSideSorter(RightSide);
foreach (BattalionState battalionState in modifiedUnits)
{
leftSideSorter.Incorporate(battalionState);
rightSideSorter.Incorporate(battalionState);
}
foreach (BattalionSpawnEffect spawn in spawns)
{
IncorporateSpawn(spawn, leftSideSorter, rightSideSorter);
}
BattleStageSide left = leftSideSorter.ToSide();
BattleStageSide right = rightSideSorter.ToSide();
return(new BattleState(left, right));
}
public override BattalionBattleEffects GetEffect(BattalionState self, BattleStageSide allies, BattleStageSide enemies)
{
BattalionEffectsBuilder builder = new BattalionEffectsBuilder(this);
if (self.Position.X == 0)
{
BattalionState target = enemies.GetTargetFor(self.Position);
if (attackType == MeleeAttackType.Regular || attackType == MeleeAttackType.Charging)
{
DoMeleeAttack(builder, self, target);
}
if (attackType == MeleeAttackType.Charging)
{
IEnumerable <BattalionState> chargeTargets = GetChargeTargets(enemies, target);
foreach (BattalionState chargeTarget in chargeTargets)
{
DoMeleeAttack(builder, self, chargeTarget);
}
}
}
return(builder.ToEffects());
}
public abstract BattalionBattleEffects GetEffect(BattalionState self, BattleStageSide allies, BattleStageSide enemies);
public Battle(BattleStageSide left, BattleStageSide right)
{
Progression = GetProgression(left, right).AsReadOnly();
}
public BattleState(BattleStageSide leftSide, BattleStageSide rightSide)
{
LeftSide = leftSide;
RightSide = rightSide;
Status = GetStatus();
}
public ModifiedSideSorter(BattleStageSide basis)
{
unitsDictionary = basis.ToDictionary(item => item.Id);
}
