public void CreateAnimation(string AnimationName, DeathmatchMap Map, Squad ActiveSquad, Squad EnemySquad, Attack ActiveAttack,
SquadBattleResult BattleResult, AnimationScreen.AnimationUnitStats UnitStats, AnimationBackground ActiveTerrain, string ExtraText, bool IsLeftAttacking)
{
AnimationScreen NewAnimationScreen = new AnimationScreen(AnimationName, Map, ActiveSquad, EnemySquad, ActiveAttack, BattleResult, UnitStats, ActiveTerrain, ExtraText, IsLeftAttacking);
ListNextAnimationScreen.Add(NewAnimationScreen);
}
public void CreateAnimation(AnimationInfo Info, DeathmatchMap Map, Squad ActiveSquad, Squad EnemySquad, Attack ActiveAttack,
SquadBattleResult BattleResult, AnimationScreen.AnimationUnitStats UnitStats, AnimationBackground ActiveTerrain, string ExtraText, bool IsLeftAttacking)
{
AnimationScreen NewAnimationScreen = new AnimationScreen(Info.AnimationName, Map, ActiveSquad, EnemySquad, ActiveAttack, BattleResult, UnitStats, ActiveTerrain, ExtraText, IsLeftAttacking);
NewAnimationScreen.Load();
NewAnimationScreen.UpdateKeyFrame(0);
Dictionary <int, Timeline> DicExtraTimeline = Info.GetExtraTimelines(NewAnimationScreen);
foreach (KeyValuePair <int, Timeline> ActiveExtraTimeline in DicExtraTimeline)
{
NewAnimationScreen.ListAnimationLayer[0].AddTimelineEvent(ActiveExtraTimeline.Key, ActiveExtraTimeline.Value);
}
ListNextAnimationScreen.Add(NewAnimationScreen);
}
public void GenerateNextAnimationScreens(Squad ActiveSquad, SupportSquadHolder ActiveSquadSupport, Squad TargetSquad, SupportSquadHolder TargetSquadSupport,
AnimationScreen.AnimationUnitStats UnitStats, AnimationScreen.BattleAnimationTypes BattleAnimationType, SquadBattleResult AttackingResult)
{
bool IsActiveSquadOnRight = BattleAnimationType == AnimationScreen.BattleAnimationTypes.RightAttackLeft || BattleAnimationType == AnimationScreen.BattleAnimationTypes.LeftConteredByRight;
bool HorionztalMirror = BattleAnimationType == AnimationScreen.BattleAnimationTypes.RightConteredByLeft || BattleAnimationType == AnimationScreen.BattleAnimationTypes.LeftAttackRight;
Squad NonDemoRightSquad;
Squad NonDemoRightSupport;
Squad NonDemoLeftSquad;
Squad NonDemoLeftSupport;
GetLeftRightSquads(IsActiveSquadOnRight, ActiveSquad, ActiveSquadSupport, TargetSquad, TargetSquadSupport, out NonDemoRightSquad, out NonDemoRightSupport, out NonDemoLeftSquad, out NonDemoLeftSupport);
Squad AttackingSquad = NonDemoRightSquad;
Squad ActiveUnitSupport = NonDemoRightSupport;
Attack ActiveAttack = AttackingSquad.CurrentLeader.CurrentAttack;
string ActiveTerrain = NonDemoRightSquad.CurrentMovement;
SquadBattleResult BattleResult = AttackingResult;
Squad EnemySquad = NonDemoLeftSquad;
Squad EnemySupport = NonDemoLeftSupport;
if (BattleAnimationType == AnimationScreen.BattleAnimationTypes.LeftAttackRight || BattleAnimationType == AnimationScreen.BattleAnimationTypes.LeftConteredByRight)
{
AttackingSquad = NonDemoLeftSquad;
ActiveUnitSupport = NonDemoLeftSupport;
ActiveAttack = AttackingSquad.CurrentLeader.CurrentAttack;
ActiveTerrain = NonDemoLeftSquad.CurrentMovement;
EnemySquad = NonDemoRightSquad;
EnemySupport = NonDemoRightSupport;
}
string ExtraTextIntro = AttackingSquad.CurrentLeader.FullName + " Attacks!";
string ExtraTextHit = AttackingSquad.CurrentLeader.FullName + " hits! " + EnemySquad.CurrentLeader.FullName + " takes " + BattleResult.ArrayResult[0].AttackDamage + " damage!";
string ExtraTextMiss = AttackingSquad.CurrentLeader.FullName + " misses! " + EnemySquad.CurrentLeader.FullName + " takes 0 damage!";
string ExtraTextKill = EnemySquad.CurrentLeader.FullName + " is destroyed!";
AnimationBackground ActiveAnimationBackground = new AnimationBackground2D("Backgrounds 2D/Ground", Content, GraphicsDevice);
CreateAnimation(AttackingSquad.CurrentLeader.Animations.MoveFoward, this, AttackingSquad, EnemySquad, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, "", HorionztalMirror);
CreateAnimation(ActiveAttack.Animations.Start, this, AttackingSquad, EnemySquad, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, ExtraTextIntro, HorionztalMirror);
if (BattleResult.ArrayResult[0].AttackMissed)
{
CreateAnimation(ActiveAttack.Animations.EndMiss, this, AttackingSquad, EnemySquad, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, ExtraTextMiss, HorionztalMirror);
}
else
{
// Check for support
if (EnemySupport != null)
{
CreateAnimation("Default Animations/Support In", this, EnemySquad, EnemySupport, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, "", HorionztalMirror);
if (BattleResult.ArrayResult[0].Target.ComputeRemainingHPAfterDamage(BattleResult.ArrayResult[0].AttackDamage) > 0)
{
CreateAnimation(ActiveAttack.Animations.EndHit, this, AttackingSquad, EnemySupport, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, "", HorionztalMirror);
CreateAnimation("Default Animations/Support Out", this, EnemySquad, EnemySupport, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, "", HorionztalMirror);
}
else
{
CreateAnimation(ActiveAttack.Animations.EndDestroyed, this, AttackingSquad, EnemySupport, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, "", HorionztalMirror);
CreateAnimation("Default Animations/Support Destroyed", this, EnemySquad, EnemySupport, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, "", HorionztalMirror);
}
}
else
{
if (BattleResult.ArrayResult[0].Target.ComputeRemainingHPAfterDamage(BattleResult.ArrayResult[0].AttackDamage) <= 0)
{
CreateAnimation(ActiveAttack.Animations.EndDestroyed, this, AttackingSquad, EnemySquad, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, ExtraTextKill, HorionztalMirror);
}
else
{
CreateAnimation(ActiveAttack.Animations.EndHit, this, AttackingSquad, EnemySquad, ActiveAttack, BattleResult, UnitStats, ActiveAnimationBackground, ExtraTextHit, HorionztalMirror);
}
}
}
}
public void InitPlayerBattle(Squad ActiveSquad, SupportSquadHolder ActiveSquadSupport, int AttackerPlayerIndex,
Squad TargetSquad, SupportSquadHolder TargetSquadSupport, int DefenderPlayerIndex,
bool IsActiveSquadOnRight)
{
if (TargetSquad.CurrentLeader.Boosts.AttackFirstModifier && !ActiveSquad.CurrentLeader.Boosts.AttackFirstModifier)
{
Squad ActiveSquadTemp = ActiveSquad;
SupportSquadHolder ActiveSquadSupportTemp = ActiveSquadSupport;
int AttackerPlayerIndexTemp = AttackerPlayerIndex;
ActiveSquad = TargetSquad;
ActiveSquadSupport = TargetSquadSupport;
AttackerPlayerIndex = DefenderPlayerIndex;
TargetSquad = ActiveSquadTemp;
TargetSquadSupport = ActiveSquadSupportTemp;
DefenderPlayerIndex = AttackerPlayerIndexTemp;
}
ActivePlayerIndex = AttackerPlayerIndex;
ActiveSquadIndex = ListPlayer[AttackerPlayerIndex].ListSquad.IndexOf(ActiveSquad);
TargetPlayerIndex = DefenderPlayerIndex;
TargetSquadIndex = ListPlayer[TargetPlayerIndex].ListSquad.IndexOf(TargetSquad);
bool ShowAnimation = Constants.ShowAnimation && ActiveSquad.CurrentLeader.CurrentAttack.Animations.Start.AnimationName != null;
ListNextAnimationScreen.Clear();
NonDemoScreen.ListNonDemoBattleFrame.Clear();
ListActionMenuChoice.RemoveAllSubActionPanels();
SquadBattleResult AttackingResult = CalculateFinalHP(ActiveSquad, ActiveSquadSupport.ActiveSquadSupport, ActivePlayerIndex,
BattleMenuOffenseFormationChoice, TargetSquad, TargetSquadSupport.ActiveSquadSupport, TargetPlayerIndex, true, true);
AnimationScreen.AnimationUnitStats UnitStats = new AnimationScreen.AnimationUnitStats(ActiveSquad, TargetSquad, IsActiveSquadOnRight);
SquadBattleResult DefendingResult = new SquadBattleResult(new BattleResult[1] {
new BattleResult()
});
if (ShowAnimation)
{
if (IsActiveSquadOnRight)
{
GenerateNextAnimationScreens(ActiveSquad, ActiveSquadSupport, TargetSquad, TargetSquadSupport, UnitStats, AnimationScreen.BattleAnimationTypes.RightAttackLeft, AttackingResult);
}
else
{
GenerateNextAnimationScreens(ActiveSquad, ActiveSquadSupport, TargetSquad, TargetSquadSupport, UnitStats, AnimationScreen.BattleAnimationTypes.LeftAttackRight, AttackingResult);
}
}
if (AttackingResult.ArrayResult[0].Target.ComputeRemainingHPAfterDamage(AttackingResult.ArrayResult[0].AttackDamage) > 0)
{
//Counter.
if (TargetSquad.CurrentLeader.BattleDefenseChoice == Unit.BattleDefenseChoices.Attack)
{
DefendingResult = CalculateFinalHP(TargetSquad, null, TargetPlayerIndex,
BattleMenuDefenseFormationChoice, ActiveSquad, null, ActivePlayerIndex, true, true);
if (ShowAnimation)
{
if (IsActiveSquadOnRight)
{
GenerateNextAnimationScreens(ActiveSquad, ActiveSquadSupport, TargetSquad, TargetSquadSupport, UnitStats, AnimationScreen.BattleAnimationTypes.RightConteredByLeft, DefendingResult);
}
else
{
GenerateNextAnimationScreens(ActiveSquad, ActiveSquadSupport, TargetSquad, TargetSquadSupport, UnitStats, AnimationScreen.BattleAnimationTypes.LeftConteredByRight, DefendingResult);
}
}
}
}
if (ShowAnimation)
{
PushScreen(ListNextAnimationScreen[0]);
ListNextAnimationScreen.RemoveAt(0);
ListNextAnimationScreen.Add(new EndBattleAnimationScreen(this, ActiveSquad, ActiveSquadSupport, AttackerPlayerIndex,
TargetSquad, TargetSquadSupport, DefenderPlayerIndex, AttackingResult, DefendingResult));
}
else
{
NonDemoScreen.InitNonDemo(ActiveSquad, ActiveSquadSupport, AttackerPlayerIndex, AttackingResult, BattleMenuOffenseFormationChoice,
TargetSquad, TargetSquadSupport, DefenderPlayerIndex, DefendingResult, BattleMenuDefenseFormationChoice, IsActiveSquadOnRight);
NonDemoScreen.Alive = true;
ListGameScreen.Insert(0, NonDemoScreen);
}
//AttackingSquad Activations.
for (int U = 0; U < ActiveSquad.UnitsAliveInSquad; U++)
{
ActiveSquad[U].UpdateSkillsLifetime(SkillEffect.LifetimeTypeBattle);
}
//DefendingSquad Activations.
for (int U = 0; U < TargetSquad.UnitsAliveInSquad; U++)
{
TargetSquad[U].UpdateSkillsLifetime(SkillEffect.LifetimeTypeBattle);
}
FinalizeMovement(ActiveSquad, (int)GetTerrain(ActiveSquad).MovementCost);
ActiveSquad.EndTurn();
bool HasAfterAttack = false;
ActionPanelDeathmatch AfterAttack = new ActionPanelMainMenu(this, ActiveSquad, AttackerPlayerIndex);
if (ActiveSquad.CurrentLeader.Boosts.PostAttackModifier.Attack)
{
HasAfterAttack = true;
AfterAttack.AddChoiceToCurrentPanel(new ActionPanelAttackPart1(ActiveSquad.CanMove, ActiveSquad, AttackerPlayerIndex, this));
}
if (ActiveSquad.CurrentLeader.Boosts.PostAttackModifier.Move)
{
HasAfterAttack = true;
CursorPosition = ActiveSquad.Position;
AfterAttack.AddChoiceToCurrentPanel(new ActionPanelMovePart1(this, ActiveSquad.Position, CameraPosition, ActiveSquad, AttackerPlayerIndex, true));
}
if (HasAfterAttack)
{
AfterAttack.AddChoiceToCurrentPanel(new ActionPanelWait(this, ActiveSquad));
ListActionMenuChoice.Add(AfterAttack);
}
}
public override void Update(Microsoft.Xna.Framework.GameTime gameTime)
{
if (!IsInit)
{
IsInit = true;
for (int P = 0; P < Map.ListPlayer.Count && (RightSquad == null || LeftSquad == null); P++)
{
for (int U = 0; U < Map.ListPlayer[P].ListSquad.Count && (RightSquad == null || LeftSquad == null); U++)
{
if (Map.ListPlayer[P].ListSquad[U].ID == _RightUnitID)
{
RightSquad = Map.ListPlayer[P].ListSquad[U];
Map.ActivePlayerIndex = P;
Map.ActiveSquadIndex = U;
}
else if (Map.ListPlayer[P].ListSquad[U].ID == _LeftUnitID)
{
LeftSquad = Map.ListPlayer[P].ListSquad[U];
Map.TargetPlayerIndex = P;
Map.TargetSquadIndex = U;
}
else
{
continue;
}
}
}
if (RightSquad == null || LeftSquad == null)
{
ExecuteEvent(this, 0);
IsEnded = true;
return;
}
BattleMap.SquadBattleResult RightUnitResult = new BattleMap.SquadBattleResult();
BattleMap.SquadBattleResult LeftUnitResult = new BattleMap.SquadBattleResult();
RightUnitResult.ArrayResult = new BattleResult[1] {
new BattleResult()
};
LeftUnitResult.ArrayResult = new BattleResult[1] {
new BattleResult()
};
RightUnitResult.ArrayResult[0].AttackDamage = _RightUnitAttackDamage;
LeftUnitResult.ArrayResult[0].AttackDamage = _LeftUnitAttackDamage;
Squad Attacker = RightSquad;
Squad Defender = LeftSquad;
//Play battle theme.
if (Attacker.CurrentLeader.BattleTheme == null || Attacker.CurrentLeader.BattleThemeName != GameScreen.FMODSystem.sndActiveBGMName)
{
if (Attacker.CurrentLeader.BattleTheme != null)
{
GameScreen.FMODSystem.sndActiveBGM.Stop();
Attacker.CurrentLeader.BattleTheme.SetLoop(true);
Attacker.CurrentLeader.BattleTheme.PlayAsBGM();
GameScreen.FMODSystem.sndActiveBGMName = Attacker.CurrentLeader.BattleThemeName;
}
}
RightSquad.CurrentLeader.AttackIndex = 0;
if (!string.IsNullOrWhiteSpace(AttackingUnitWeaponName))
{
for (int A = 0; A < RightSquad.CurrentLeader.ListAttack.Count; ++A)
{
if (RightSquad.CurrentLeader.ListAttack[A].ItemName == AttackingUnitWeaponName)
{
RightSquad.CurrentLeader.AttackIndex = A;
}
}
}
LeftSquad.CurrentLeader.AttackIndex = 0;
if (!string.IsNullOrWhiteSpace(AttackingUnitWeaponName))
{
for (int A = 0; A < LeftSquad.CurrentLeader.ListAttack.Count; ++A)
{
if (LeftSquad.CurrentLeader.ListAttack[A].ItemName == DefendingUnitWeaponName)
{
LeftSquad.CurrentLeader.AttackIndex = A;
}
}
}
SquadBattleResult AttackingResult = Map.CalculateFinalHP(RightSquad, null, 0,
FormationChoices.Focused, LeftSquad, null, Map.TargetPlayerIndex, Map.TargetSquadIndex, true, true);
AttackingResult.ArrayResult[0].AttackMissed = false;
AttackingResult.ArrayResult[0].AttackDamage = AttackingUnitAttackDamage;
AttackingResult.ArrayResult[0].SetTarget(Map.TargetPlayerIndex, Map.TargetSquadIndex, 0, Map.TargetSquad.CurrentLeader);
AnimationScreen.AnimationUnitStats UnitStats = new AnimationScreen.AnimationUnitStats(RightSquad, LeftSquad, true);
if (IsCounterattack)
{
ListNextAnimationScreen = Map.GenerateNextAnimationScreens(RightSquad, new SupportSquadHolder(), LeftSquad, new SupportSquadHolder(), UnitStats,
AnimationScreen.BattleAnimationTypes.RightConteredByLeft, AttackingResult, out _, null, out _, null);
}
else
{
ListNextAnimationScreen = Map.GenerateNextAnimationScreens(RightSquad, new SupportSquadHolder(), LeftSquad, new SupportSquadHolder(), UnitStats,
AnimationScreen.BattleAnimationTypes.RightAttackLeft, AttackingResult, out _, null, out _, null);
}
Map.PushScreen(ListNextAnimationScreen[0]);
}
else
{
if (!Map.ListGameScreen.Contains(ListNextAnimationScreen[0]))
{
ListNextAnimationScreen.Remove(ListNextAnimationScreen[0]);
if (ListNextAnimationScreen.Count > 0)
{
Map.PushScreen(ListNextAnimationScreen[0]);
}
else
{
ExecuteEvent(this, 0);
IsEnded = true;
}
}
}
}
public void InitPlayerBattle(bool IsActiveSquadOnRight)
{
int FinalActivePlayerIndex = ActivePlayerIndex;
int FinalActiveSquadIndex = ActiveSquadIndex;
Squad FinalActiveSquad = ActiveSquad;
SupportSquadHolder FinalActiveSquadSupport = ActiveSquadSupport;
int FinalTargetPlayerIndex = TargetPlayerIndex;
int FinalTargetSquadIndex = TargetSquadIndex;
Squad FinalTargetSquad = TargetSquad;
SupportSquadHolder FinalTargetSquadSupport = TargetSquadSupport;
if (TargetSquad.CurrentLeader.Boosts.AttackFirstModifier && !ActiveSquad.CurrentLeader.Boosts.AttackFirstModifier)
{
FinalActivePlayerIndex = TargetPlayerIndex;
FinalActiveSquadIndex = TargetSquadIndex;
FinalActiveSquad = TargetSquad;
FinalActiveSquadSupport = TargetSquadSupport;
FinalTargetPlayerIndex = ActivePlayerIndex;
FinalTargetSquadIndex = ActiveSquadIndex;
FinalTargetSquad = ActiveSquad;
FinalTargetSquadSupport = ActiveSquadSupport;
}
bool ShowAnimation = Constants.ShowAnimation && FinalActiveSquad.CurrentLeader.CurrentAttack.GetAttackAnimations(Map.ActiveParser).Start.AnimationName != null;
ListNextAnimationScreen.Clear();
Map.NonDemoScreen.ListNonDemoBattleFrame.Clear();
if (Map.IsOfflineOrServer)
{
AttackingResult = Map.CalculateFinalHP(FinalActiveSquad, FinalActiveSquadSupport.ActiveSquadSupport, FinalActivePlayerIndex,
Map.BattleMenuOffenseFormationChoice, FinalTargetSquad, FinalTargetSquadSupport.ActiveSquadSupport,
FinalTargetPlayerIndex, FinalTargetSquadIndex, true, true);
DefendingResult = new SquadBattleResult(new BattleResult[1] {
new BattleResult()
});
}
else
{
Map.CalculateFinalHP(FinalActiveSquad, FinalActiveSquadSupport.ActiveSquadSupport, FinalActivePlayerIndex,
Map.BattleMenuOffenseFormationChoice, FinalTargetSquad, FinalTargetSquadSupport.ActiveSquadSupport,
FinalTargetPlayerIndex, FinalTargetSquadIndex, true, true);
}
AnimationScreen.AnimationUnitStats UnitStats = new AnimationScreen.AnimationUnitStats(FinalActiveSquad, FinalTargetSquad, IsActiveSquadOnRight);
AnimationBackground TargetSquadBackground = null;
AnimationBackground TargetSquadForeground = null;
if (ShowAnimation)
{
AnimationScreen.BattleAnimationTypes BattleAnimationType = AnimationScreen.BattleAnimationTypes.LeftAttackRight;
if (IsActiveSquadOnRight)
{
BattleAnimationType = AnimationScreen.BattleAnimationTypes.RightAttackLeft;
}
ListNextAnimationScreen.AddRange(Map.GenerateNextAnimationScreens(FinalActiveSquad, FinalActiveSquadSupport, FinalTargetSquad, FinalTargetSquadSupport, UnitStats, BattleAnimationType,
AttackingResult, out TargetSquadBackground, null, out TargetSquadForeground, null));
}
if (AttackingResult.ArrayResult[0].Target.ComputeRemainingHPAfterDamage(AttackingResult.ArrayResult[0].AttackDamage) > 0)
{
//Counter.
if (FinalTargetSquad.CurrentLeader.BattleDefenseChoice == Unit.BattleDefenseChoices.Attack)
{
if (Map.IsOfflineOrServer)
{
DefendingResult = Map.CalculateFinalHP(FinalTargetSquad, null, FinalTargetPlayerIndex,
Map.BattleMenuDefenseFormationChoice, FinalActiveSquad, null,
FinalActivePlayerIndex, FinalActiveSquadIndex, true, true);
}
else
{
Map.CalculateFinalHP(FinalTargetSquad, null, FinalTargetPlayerIndex,
Map.BattleMenuDefenseFormationChoice, FinalActiveSquad, null,
FinalActivePlayerIndex, FinalActiveSquadIndex, true, true);
}
if (ShowAnimation)
{
AnimationScreen.BattleAnimationTypes BattleAnimationType = AnimationScreen.BattleAnimationTypes.LeftConteredByRight;
if (IsActiveSquadOnRight)
{
BattleAnimationType = AnimationScreen.BattleAnimationTypes.RightConteredByLeft;
}
ListNextAnimationScreen.AddRange(Map.GenerateNextAnimationScreens(FinalActiveSquad, FinalActiveSquadSupport, FinalTargetSquad, FinalTargetSquadSupport, UnitStats,
BattleAnimationType, DefendingResult, out _, TargetSquadBackground, out _, TargetSquadForeground));
}
}
}
if (Map.IsClient)
{
if (ShowAnimation)
{
Map.PushScreen(ListNextAnimationScreen[0]);
ListNextAnimationScreen.RemoveAt(0);
ListNextAnimationScreen.Add(new EndBattleAnimationScreen(Map, FinalActiveSquad, FinalActiveSquadSupport, FinalActivePlayerIndex,
FinalTargetSquad, FinalTargetSquadSupport, FinalTargetPlayerIndex, AttackingResult, DefendingResult));
}
else
{
Map.NonDemoScreen.InitNonDemo(FinalActiveSquad, FinalActiveSquadSupport, FinalActivePlayerIndex, AttackingResult, Map.BattleMenuOffenseFormationChoice,
FinalTargetSquad, FinalTargetSquadSupport, FinalTargetPlayerIndex, DefendingResult, Map.BattleMenuDefenseFormationChoice, IsActiveSquadOnRight);
Map.NonDemoScreen.Alive = true;
Map.ListGameScreen.Insert(0, Map.NonDemoScreen);
}
}
//AttackingSquad Activations.
for (int U = 0; U < FinalActiveSquad.UnitsAliveInSquad; U++)
{
FinalActiveSquad[U].UpdateSkillsLifetime(SkillEffect.LifetimeTypeBattle);
}
//DefendingSquad Activations.
for (int U = 0; U < FinalTargetSquad.UnitsAliveInSquad; U++)
{
FinalTargetSquad[U].UpdateSkillsLifetime(SkillEffect.LifetimeTypeBattle);
}
Map.FinalizeMovement(FinalActiveSquad, (int)Map.GetTerrain(FinalActiveSquad).MovementCost);
FinalActiveSquad.EndTurn();
if (Map.IsClient)
{
bool HasAfterAttack = false;
ActionPanelDeathmatch AfterAttack = new ActionPanelMainMenu(Map, FinalActivePlayerIndex, FinalActiveSquadIndex);
if (FinalActiveSquad.CurrentLeader.Boosts.PostAttackModifier.Attack)
{
HasAfterAttack = true;
AfterAttack.AddChoiceToCurrentPanel(new ActionPanelAttackPart1(Map, FinalActivePlayerIndex, FinalActiveSquadIndex, FinalActiveSquad.CanMove));
}
if (FinalActiveSquad.CurrentLeader.Boosts.PostAttackModifier.Move)
{
HasAfterAttack = true;
Map.CursorPosition = FinalActiveSquad.Position;
AfterAttack.AddChoiceToCurrentPanel(new ActionPanelMovePart1(Map, FinalActivePlayerIndex, FinalActiveSquadIndex, FinalActiveSquad.Position, Map.CameraPosition, true));
}
if (HasAfterAttack)
{
AfterAttack.AddChoiceToCurrentPanel(new ActionPanelWait(Map, FinalActiveSquad));
ListActionMenuChoice.Add(AfterAttack);
}
}
}
