private void CenterCameraOnSpeaker()
{
List <SpeakerPriority> ListSpeakerPriority = GetSpeakerPriorities();
CenterOnSquadCutscene CenterCamera = new CenterOnSquadCutscene(null, Map, new Microsoft.Xna.Framework.Vector3());
foreach (SpeakerPriority ActiveSpeaker in ListSpeakerPriority)
{
if (ActiveSpeaker.PriorityType == SpeakerPriority.PriorityTypes.Character)
{
foreach (Player ActivePlayer in Map.ListPlayer)
{
foreach (Squad ActiveSquad in ActivePlayer.ListSquad)
{
for (int U = 0; U < ActiveSquad.UnitsInSquad; ++U)
{
foreach (Character ActiveCharacter in ActiveSquad.At(U).ArrayCharacterActive)
{
if (ActiveCharacter.FullName == ActiveSpeaker.Name)
{
Map.PushScreen(new CenterOnSquadCutscene(null, Map, ActiveSquad.Position));
return;
}
}
}
}
}
}
else if (ActiveSpeaker.PriorityType == SpeakerPriority.PriorityTypes.Location)
{
string[] ArrayPosition = ActiveSpeaker.Name.Split(new string[] { ":" }, StringSplitOptions.RemoveEmptyEntries);
float X = float.Parse(ArrayPosition[0]);
float Y = float.Parse(ArrayPosition[1]);
float Z = 0;
if (ArrayPosition.Length > 2)
{
Z = float.Parse(ArrayPosition[2]);
}
Map.PushScreen(new CenterOnSquadCutscene(null, Map, new Microsoft.Xna.Framework.Vector3(X, Y, Z)));
return;
}
else if (ActiveSpeaker.PriorityType == SpeakerPriority.PriorityTypes.ID)
{
foreach (Player ActivePlayer in Map.ListPlayer)
{
foreach (Squad ActiveSquad in ActivePlayer.ListSquad)
{
uint RealID = uint.Parse(ActiveSpeaker.Name);
if (ActiveSquad.ID == RealID)
{
Map.PushScreen(new CenterOnSquadCutscene(null, Map, ActiveSquad.Position));
return;
}
}
}
}
}
}
private void CastTargetableSkill(SquadBehaviour target)
{
ActiveSquad.InitializeSkill();
var targetableSkill = ActiveSquad.Unit.Skill as ITargetable <SquadBehaviour>;
if (targetableSkill != null)
{
targetableSkill.Target = target;
ActiveSquad.Unit.Skill.Cast();
}
}
public override byte[] GetSnapshotData()
{
ByteWriter BW = new ByteWriter();
BW.AppendInt32(ListAllPlayer.Count);
foreach (Player ActivePlayer in ListAllPlayer)
{
BW.AppendString(ActivePlayer.ConnectionID);
BW.AppendString(ActivePlayer.Name);
BW.AppendInt32(ActivePlayer.Team);
BW.AppendBoolean(ActivePlayer.IsPlayerControlled);
BW.AppendByte(ActivePlayer.Color.R);
BW.AppendByte(ActivePlayer.Color.G);
BW.AppendByte(ActivePlayer.Color.B);
BW.AppendByte(ActivePlayer.LocalPlayerIndex);
BW.AppendInt32(ActivePlayer.ListSquad.Count);
foreach (Squad ActiveSquad in ActivePlayer.ListSquad)
{
BW.AppendFloat(ActiveSquad.X);
BW.AppendFloat(ActiveSquad.Y);
BW.AppendFloat(ActiveSquad.Z);
BW.AppendBoolean(ActiveSquad.IsPlayerControlled);
BW.AppendInt32(ActiveSquad.UnitsInSquad);
for (int U = 0; U < ActiveSquad.UnitsInSquad; ++U)
{
Unit ActiveUnit = ActiveSquad.At(U);
BW.AppendString(ActiveUnit.UnitTypeName);
BW.AppendString(ActiveUnit.RelativePath);
BW.AppendInt32(ActiveUnit.ArrayCharacterActive.Length);
for (int C = 0; C < ActiveUnit.ArrayCharacterActive.Length; ++C)
{
BW.AppendString(ActiveUnit.ArrayCharacterActive[C].FullName);
}
}
}
}
BW.AppendString(BattleMapPath);
byte[] Data = BW.GetBytes();
BW.ClearWriteBuffer();
return(Data);
}
public override bool CanActivatePassive()
{
if (Context.EffectOwnerCharacter != Context.EffectOwnerUnit.Pilot)
{
return(false);
}
foreach (Player ActivePlayer in Context.Map.ListPlayer)
{
foreach (Squad ActiveSquad in ActivePlayer.ListSquad)
{
float X1 = Context.EffectOwnerSquad.X;
float Y1 = Context.EffectOwnerSquad.Y;
float X2 = ActiveSquad.X;
float Y2 = ActiveSquad.Y;
for (int U = 0; U < ActiveSquad.UnitsAliveInSquad; ++U)
{
Unit ActiveUnit = ActiveSquad.At(U);
foreach (Character ActiveCharacter in ActiveUnit.ArrayCharacterActive)
{
if (ActiveCharacter.Name == _CharacterName)
{
int Distance = 0;
if (IncludeDiagonals)
{
Distance = (int)Math.Ceiling(Math.Sqrt(Math.Pow(X2 - X1, 2) + Math.Pow(Y2 - Y1, 2)));
}
else
{
Distance = (int)((X2 - X1) + (Y2 - Y1));
}
if (Distance < DistanceToEnemy)
{
return(true);
}
}
}
}
}
}
return(false);
}
public override void Update(GameTime gameTime)
{
foreach (Player ActivePlayer in Map.ListPlayer)
{
foreach (Core.Units.Squad ActiveSquad in ActivePlayer.ListSquad)
{
if (ListTerrainDamageLocation.Contains(new Vector2(ActiveSquad.Position.X, ActiveSquad.Position.Y)))
{
for (int U = 0; U < ActiveSquad.UnitsAliveInSquad; ++U)
{
ActiveSquad[U].DamageUnit(_Damage);
}
ActiveSquad.UpdateSquad();
}
}
}
ExecuteEvent(this, 0);
IsEnded = true;
}
protected override void DoWrite(OnlineWriter WriteBuffer)
{
WriteBuffer.AppendByte(ActivePlayer.LocalPlayerIndex);
WriteBuffer.AppendInt32(ActivePlayer.Inventory.ActiveLoadout.ListSquad.Count);
foreach (Squad ActiveSquad in ActivePlayer.Inventory.ActiveLoadout.ListSquad)
{
WriteBuffer.AppendInt32(ActiveSquad.UnitsInSquad);
for (int U = 0; U < ActiveSquad.UnitsInSquad; ++U)
{
Unit ActiveUnit = ActiveSquad.At(U);
WriteBuffer.AppendString(ActiveUnit.UnitTypeName);
WriteBuffer.AppendString(ActiveUnit.RelativePath);
WriteBuffer.AppendInt32(ActiveUnit.ArrayCharacterActive.Length);
for (int C = 0; C < ActiveUnit.ArrayCharacterActive.Length; ++C)
{
WriteBuffer.AppendString(ActiveUnit.ArrayCharacterActive[C].FullName);
}
}
}
}
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 SaveTemporaryMap()
{
FileStream FS = new FileStream("TempSave.sav", FileMode.Create, FileAccess.Write);
BinaryWriter BW = new BinaryWriter(FS);
BW.Write(BattleMapPath);
BW.Write(typeof(DeathmatchMap).AssemblyQualifiedName);
BW.Write(DicMapVariables.Count);
foreach (KeyValuePair <string, double> Variables in DicMapVariables)
{
BW.Write(Variables.Key);
BW.Write(Variables.Value);
}
BW.Write(CursorPosition.X);
BW.Write(CursorPosition.Y);
BW.Write(CameraPosition.X);
BW.Write(CameraPosition.Y);
BW.Write(ActivePlayerIndex);
BW.Write(GameMode);
BW.Write(GameTurn);
BW.Write(VictoryCondition);
BW.Write(LossCondition);
BW.Write(SkillPoint);
BW.Write(sndBattleThemeName);
BW.Write(FMODSystem.sndActiveBGMName);
BW.Write(FMODSystem.GetPosition(FMODSystem.sndActiveBGM));
BW.Write(ListPlayer.Count);
foreach (Player ActivePlayer in ListPlayer)
{
BW.Write(ActivePlayer.Name);
BW.Write(ActivePlayer.PlayerType);
BW.Write(ActivePlayer.IsHuman);
BW.Write(ActivePlayer.Team);
BW.Write(ActivePlayer.Color.R);
BW.Write(ActivePlayer.Color.G);
BW.Write(ActivePlayer.Color.B);
BW.Write(ActivePlayer.ListSquad.Count);
foreach (Squad ActiveSquad in ActivePlayer.ListSquad)
{
BW.Write(ActiveSquad.ID);
BW.Write(ActiveSquad.CanMove);
BW.Write(ActiveSquad.ActionsRemaining);
BW.Write(ActiveSquad.X);
BW.Write(ActiveSquad.Y);
BW.Write(ActiveSquad.Z);
BW.Write(ActiveSquad.SquadName);
int UnitInSquad = ActiveSquad.UnitsInSquad;
BW.Write(UnitInSquad);
BW.Write(ActiveSquad.CurrentLeaderIndex);
BW.Write(ActiveSquad.CurrentWingmanAIndex);
BW.Write(ActiveSquad.CurrentWingmanBIndex);
for (int U = 0; U < UnitInSquad; ++U)
{
ActiveSquad.At(U).QuickSave(BW);
}
//List of Attacked Teams.
BW.Write(ActiveSquad.ListAttackedTeam.Count);
for (int U = 0; U < ActiveSquad.ListAttackedTeam.Count; ++U)
{
BW.Write(ActiveSquad.ListAttackedTeam[U]);
}
}
}
BW.Write(ListMapScript.Count);
for (int S = 0; S < ListMapScript.Count; S++)
{
ListMapScript[S].Save(BW);
}
FS.Close();
BW.Close();
}
public override void SaveTemporaryMap()
{
FileStream FS = new FileStream("User Data/Saves/TempSave.sav", FileMode.Create, FileAccess.Write);
BinaryWriter BW = new BinaryWriter(FS);
BW.Write(BattleMapPath);
BW.Write(typeof(DeathmatchMap).AssemblyQualifiedName);
DataScreen.SaveProgression(BW, PlayerRoster);
BW.Write(DicMapVariables.Count);
foreach (KeyValuePair <string, double> Variables in DicMapVariables)
{
BW.Write(Variables.Key);
BW.Write(Variables.Value);
}
BW.Write(CursorPosition.X);
BW.Write(CursorPosition.Y);
BW.Write(CameraPosition.X);
BW.Write(CameraPosition.Y);
BW.Write(ActivePlayerIndex);
BW.Write(GameTurn);
BW.Write(VictoryCondition);
BW.Write(LossCondition);
BW.Write(SkillPoint);
BW.Write(ListBackground.Count);
for (int B = 0; B < ListBackground.Count; ++B)
{
BW.Write(ListBackground[B].AnimationFullPath);
}
BW.Write(ListForeground.Count);
for (int F = 0; F < ListForeground.Count; ++F)
{
BW.Write(ListForeground[F].AnimationFullPath);
}
BW.Write(sndBattleThemeName);
BW.Write(FMODSystem.sndActiveBGMName);
BW.Write(FMODSystem.GetPosition(FMODSystem.sndActiveBGM));
BW.Write(ListPlayer.Count);
foreach (Player ActivePlayer in ListPlayer)
{
BW.Write(ActivePlayer.Name);
BW.Write(ActivePlayer.OnlinePlayerType);
BW.Write(ActivePlayer.IsPlayerControlled);
BW.Write(ActivePlayer.Team);
BW.Write(ActivePlayer.Color.R);
BW.Write(ActivePlayer.Color.G);
BW.Write(ActivePlayer.Color.B);
BW.Write(ActivePlayer.ListSquad.Count);
foreach (Squad ActiveSquad in ActivePlayer.ListSquad)
{
BW.Write(ActiveSquad.ID);
BW.Write(ActiveSquad.CanMove);
BW.Write(ActiveSquad.ActionsRemaining);
BW.Write(ActiveSquad.X);
BW.Write(ActiveSquad.Y);
BW.Write(ActiveSquad.Z);
BW.Write(ActiveSquad.SquadName);
BW.Write(ActiveSquad.CurrentMovement);
BW.Write(ActiveSquad.IsFlying);
BW.Write(ActiveSquad.IsUnderTerrain);
BW.Write(ActiveSquad.IsPlayerControlled);
if (ActiveSquad.SquadAI == null || ActiveSquad.SquadAI.Path == null)
{
BW.Write(string.Empty);
}
else
{
BW.Write(ActiveSquad.SquadAI.Path);
}
int UnitsInSquad = ActiveSquad.UnitsInSquad;
BW.Write(UnitsInSquad);
BW.Write(ActiveSquad.CurrentLeaderIndex);
BW.Write(ActiveSquad.CurrentWingmanAIndex);
BW.Write(ActiveSquad.CurrentWingmanBIndex);
for (int U = 0; U < UnitsInSquad; ++U)
{
ActiveSquad.At(U).QuickSave(BW);
}
//List of Attacked Teams.
BW.Write(ActiveSquad.ListAttackedTeam.Count);
for (int U = 0; U < ActiveSquad.ListAttackedTeam.Count; ++U)
{
BW.Write(ActiveSquad.ListAttackedTeam[U]);
}
}
}
for (int P = 0; P < ListPlayer.Count; P++)
{
for (int S = 0; S < ListPlayer[P].ListSquad.Count; S++)
{
if (!ListPlayer[P].ListSquad[S].IsDead)
{
for (int U = 0; U < ListPlayer[P].ListSquad[S].UnitsInSquad; ++U)
{
for (int C = 0; C < ListPlayer[P].ListSquad[S].At(U).ArrayCharacterActive.Length; C++)
{
Character ActiveCharacter = ListPlayer[P].ListSquad[S].At(U).ArrayCharacterActive[C];
ActiveCharacter.Effects.QuickSave(BW);
}
}
}
}
}
BW.Write(ListMapScript.Count);
for (int S = 0; S < ListMapScript.Count; S++)
{
ListMapScript[S].Save(BW);
}
FS.Close();
BW.Close();
}
public override void Load(byte[] ArrayGameData)
{
ByteReader BR = new ByteReader(ArrayGameData);
int ListCharacterCount = BR.ReadInt32();
for (int P = 0; P < ListCharacterCount; ++P)
{
string PlayerID = BR.ReadString();
string PlayerName = BR.ReadString();
int PlayerTeam = BR.ReadInt32();
bool IsPlayerControlled = BR.ReadBoolean();
Color PlayerColor = Color.FromNonPremultiplied(BR.ReadByte(), BR.ReadByte(), BR.ReadByte(), 255);
byte LocalPlayerIndex = BR.ReadByte();
Player NewPlayer;
if (PlayerManager.OnlinePlayerID == PlayerID)
{
NewPlayer = new Player(PlayerManager.ListLocalPlayer[LocalPlayerIndex]);
NewPlayer.Team = PlayerTeam;
NewPlayer.Color = PlayerColor;
AddLocalCharacter(NewPlayer);
//NewPlayer.InputManagerHelper = new PlayerRobotInputManager();
//NewPlayer.UpdateControls(GameplayTypes.MouseAndKeyboard);
}
else
{
NewPlayer = new Player(PlayerName, "Online", true, true, PlayerTeam, PlayerColor);
NewPlayer.LocalPlayerIndex = LocalPlayerIndex;
ListAllPlayer.Add(NewPlayer);
}
NewPlayer.IsPlayerControlled = IsPlayerControlled;
NewPlayer.Inventory.ActiveLoadout.ListSquad.Clear();
int ArraySquadLength = BR.ReadInt32();
for (int S = 0; S < ArraySquadLength; ++S)
{
float SquadX = BR.ReadFloat();
float SquadY = BR.ReadFloat();
float SquadZ = BR.ReadFloat();
bool SquadIsPlayerControlled = BR.ReadBoolean();
int UnitsInSquad = BR.ReadInt32();
Unit[] ArrayNewUnit = new Unit[UnitsInSquad];
for (int U = 0; U < UnitsInSquad; ++U)
{
string UnitTypeName = BR.ReadString();
string RelativePath = BR.ReadString();
ArrayNewUnit[U] = PlayerManager.DicUnitType[UnitTypeName].FromFile(RelativePath, Content, PlayerManager.DicRequirement, PlayerManager.DicEffect, PlayerManager.DicAutomaticSkillTarget);
int ArrayCharacterLength = BR.ReadInt32();
ArrayNewUnit[U].ArrayCharacterActive = new Character[UnitsInSquad];
for (int C = 0; C < ArrayCharacterLength; ++C)
{
string CharacterPath = BR.ReadString();
ArrayNewUnit[U].ArrayCharacterActive[C] = new Character(CharacterPath, Content, PlayerManager.DicRequirement, PlayerManager.DicEffect, PlayerManager.DicAutomaticSkillTarget, PlayerManager.DicManualSkillTarget);
ArrayNewUnit[U].ArrayCharacterActive[C].Level = 1;
}
}
Unit Leader = ArrayNewUnit[0];
Unit WingmanA = null;
if (UnitsInSquad > 1)
{
WingmanA = ArrayNewUnit[1];
}
Unit WingmanB = null;
if (UnitsInSquad > 2)
{
WingmanB = ArrayNewUnit[2];
}
Squad NewSquad = new Squad("", Leader, WingmanA, WingmanB);
NewSquad.SetPosition(new Vector3(SquadX, SquadY, SquadZ));
NewSquad.IsPlayerControlled = SquadIsPlayerControlled;
NewPlayer.Inventory.ActiveLoadout.ListSquad.Add(NewSquad);
}
}
BattleMapPath = BR.ReadString();
Load();
for (int P = 0; P < ListPlayer.Count; P++)
{
Player ActivePlayer = ListPlayer[P];
foreach (Squad ActiveSquad in ActivePlayer.Inventory.ActiveLoadout.ListSquad)
{
ActiveSquad.ReloadSkills(DicUnitType, DicRequirement, DicEffect, DicAutomaticSkillTarget, DicManualSkillTarget);
SpawnSquad(P, ActiveSquad, 0, ActiveSquad.Position, (int)ActiveSquad.Position.Z);
}
}
Init();
TogglePreview(true);
BR.Clear();
}
