private void Send(IPBEPacket packet)
{
if (_client.IsConnected)
{
_client.Send(packet);
}
}
private void SinglePlayerBattle_OnNewEvent(PBEBattle battle, IPBEPacket packet)
{
if (!ProcessPacket(packet))
{
Thread.Sleep(WaitMilliseconds);
}
}
private PBEBattle(EndianBinaryReader r)
{
ushort version = r.ReadUInt16();
Settings = new PBESettings(r);
Settings.MakeReadOnly();
BattleFormat = r.ReadEnum <PBEBattleFormat>();
Teams = new PBETeams(this);
int numEvents = r.ReadInt32();
for (int i = 0; i < numEvents; i++)
{
IPBEPacket packet = PBEPacketProcessor.CreatePacket(this, r.ReadBytes(r.ReadUInt16()));
switch (packet)
{
case PBEWinnerPacket wp:
{
Winner = wp.WinningTeam;
break;
}
}
Events.Add(packet);
}
BattleState = PBEBattleState.Ended;
OnStateChanged?.Invoke(this);
}
public static PBEBattle LoadReplay(string path)
{
byte[] fileBytes = File.ReadAllBytes(path);
using (var s = new MemoryStream(fileBytes))
using (var r = new EndianBinaryReader(s))
{
byte[] hash;
using (var md5 = MD5.Create())
{
hash = md5.ComputeHash(fileBytes, 0, fileBytes.Length - 16);
}
for (int i = 0; i < 16; i++)
{
if (hash[i] != fileBytes[fileBytes.Length - 16 + i])
{
throw new InvalidDataException();
}
}
ushort version = r.ReadUInt16();
PBEBattle b = null;
int numEvents = r.ReadInt32();
for (int i = 0; i < numEvents; i++)
{
IPBEPacket packet = PBEPacketProcessor.CreatePacket(b, r.ReadBytes(r.ReadUInt16()));
if (packet is PBEBattlePacket bp)
{
b = new PBEBattle(bp);
}
b.Events.Add(packet);
}
b.BattleState = PBEBattleState.Ended;
b.OnStateChanged?.Invoke(b);
return(b);
}
}
private void OnPacketReceived(object sender, IPBEPacket packet)
{
Debug.WriteLine($"Packet received (\"{packet.GetType().Name}\")");
switch (packet)
{
case PBEMatchCancelledPacket _:
{
BattleView.AddMessage("Match cancelled!", messageBox: false);
break;
}
case PBEPlayerJoinedPacket pjp:
{
int id = pjp.BattleId;
if (pjp.IsMe)
{
BattleId = id;
if (id < 2)
{
Team = Battle.Teams[id];
ShowRawValues0 = id == 0;
ShowRawValues1 = id == 1;
}
}
else
{
BattleView.AddMessage(string.Format("{0} joined the game.", pjp.TrainerName), messageBox: false);
}
if (id < 2)
{
Battle.Teams[id].TrainerName = pjp.TrainerName;
}
Send(new PBEResponsePacket());
break;
}
case PBEPartyRequestPacket _:
{
Send(new PBEPartyResponsePacket(_teamShell));
break;
}
case PBEActionsRequestPacket _:
case PBESwitchInRequestPacket _:
case PBEWinnerPacket _:
{
Battle.Events.Add(packet);
StartPacketThread();
Send(new PBEResponsePacket());
break;
}
default:
{
Battle.Events.Add(packet);
Send(new PBEResponsePacket());
break;
}
}
}
protected override bool ProcessPacket(IPBEPacket packet)
{
switch (packet)
{
case PBEActionsRequestPacket arp:
{
PBETrainer t = arp.Trainer;
if (t == Trainer)
{
_ = new ActionsBuilder(BattleView, Trainer, OnActionsReady);
}
else
{
CreateBattleThread(GetAI(t).CreateActions);
}
return(true);
}
case PBESwitchInRequestPacket sirp:
{
PBETrainer t = sirp.Trainer;
if (t == Trainer)
{
_ = new SwitchesBuilder(BattleView, sirp.Amount, OnSwitchesReady);
}
else
{
CreateBattleThread(GetAI(t).CreateSwitches);
}
return(true);
}
}
return(base.ProcessPacket(packet));
}
private void Battle_OnNewEvent(PBEBattle battle, IPBEPacket packet)
{
try
{
switch (packet)
{
case PBEActionsRequestPacket arp:
{
GetAI(arp.Trainer).CreateActions();
break;
}
case PBESwitchInRequestPacket sirp:
{
GetAI(sirp.Trainer).CreateSwitches();
break;
}
case PBETurnBeganPacket tbp:
{
Console.SetOut(_oldWriter);
DateTime time = DateTime.Now;
Console.WriteLine($"Emulating turn {tbp.TurnNumber}... ({time.Hour:D2}:{time.Minute:D2}:{time.Second:D2}:{time.Millisecond:D3})");
Console.SetOut(_writer);
break;
}
}
}
catch (Exception e)
{
CatchException(e);
}
}
private void SendTo(IEnumerable <Player> players, IPBEPacket packet)
{
foreach (Player p in players)
{
p.Send(packet);
}
}
public static PBEBattle LoadReplay(string path)
{
byte[] fileBytes = File.ReadAllBytes(path);
using (var s = new MemoryStream(fileBytes))
using (var r = new EndianBinaryReader(s, encoding: EncodingType.UTF16))
{
byte[] hash;
using (var md5 = MD5.Create())
{
hash = md5.ComputeHash(fileBytes, 0, fileBytes.Length - 16);
}
for (int i = 0; i < 16; i++)
{
if (hash[i] != fileBytes[fileBytes.Length - 16 + i])
{
throw new InvalidDataException();
}
}
ushort version = r.ReadUInt16(); // Unused for now
int seed = r.ReadInt32(); // Unused for now
PBEBattle b = null;
int numEvents = r.ReadInt32();
for (int i = 0; i < numEvents; i++)
{
IPBEPacket packet = PBEPacketProcessor.CreatePacket(b, r.ReadBytes(r.ReadUInt16()));
if (packet is PBEBattlePacket bp)
{
b = new PBEBattle(bp);
}
else if (packet is PBEWildPkmnAppearedPacket wpap)
{
PBETrainer wildTrainer = b.Teams[1].Trainers[0];
foreach (PBEPkmnAppearedInfo info in wpap.Pokemon)
{
PBEBattlePokemon pkmn = wildTrainer.TryGetPokemon(info.Pokemon);
// Process disguise and position now
pkmn.FieldPosition = info.FieldPosition;
if (info.IsDisguised)
{
pkmn.Status2 |= PBEStatus2.Disguised;
pkmn.KnownCaughtBall = info.CaughtBall;
pkmn.KnownGender = info.Gender;
pkmn.KnownNickname = info.Nickname;
pkmn.KnownShiny = info.Shiny;
pkmn.KnownSpecies = info.Species;
pkmn.KnownForm = info.Form;
IPBEPokemonData pData = PBEDataProvider.Instance.GetPokemonData(info);
pkmn.KnownType1 = pData.Type1;
pkmn.KnownType2 = pData.Type2;
}
b.ActiveBattlers.Add(pkmn);
}
}
b.Events.Add(packet);
}
b.BattleState = PBEBattleState.Ended;
return(b);
}
}
public void Send(IPBEPacket packet)
{
byte[] data = packet.Data.ToArray();
if (_encryption is not null)
{
data = _encryption.Encrypt(data);
}
PBENetworkUtils.Send(data, Socket);
}
public void Send(IPBEPacket packet)
{
if (Client.IsConnected)
{
Debug.WriteLine($"Packet sent ({BattleId} {TrainerName} \"{packet.GetType().Name}\")");
resetEvent.Reset();
Client.Send(packet);
}
}
public void SendToAll(IPBEPacket packet)
{
lock (_connectedClients)
{
foreach (PBEServerClient client in _connectedClients)
{
client.Send(packet);
}
}
}
private void OnPacketReceived(object sender, IPBEPacket packet)
{
// TODO: Kick players who are sending broken packets or sending too many
Type type = packet.GetType();
Debug.WriteLine($"Packet received ({BattleId} {TrainerName} \"{type.Name}\")");
if (_packetType != null && type.Equals(_packetType))
{
_packetType = null;
switch (packet)
{
case PBELegalPartyResponsePacket lprp:
{
Console.WriteLine($"Received party ({BattleId} {TrainerName})");
if (!Server.Settings.Equals(lprp.Party.Settings))
{
Console.WriteLine("Party does not have matching settings!");
Console.WriteLine("\tServer: \"{0}\"", Server.Settings);
Console.WriteLine("\tParty: \"{0}\"", lprp.Party.Settings);
}
else
{
_party = lprp.Party;
resetEvent.Set();
}
break;
}
case PBEPartyResponsePacket prp:
{
Console.WriteLine($"Received party ({BattleId} {TrainerName})");
_party = prp.Party;
resetEvent.Set();
break;
}
default: resetEvent.Set(); break;
}
}
else if (_actionType != null && (type.Equals(_actionType) || type.Equals(typeof(PBEFleeResponsePacket))))
{
_actionType = null;
switch (packet)
{
case PBEActionsResponsePacket arp: Server.ActionsSubmitted(this, arp.Actions); break;
case PBEFleeResponsePacket _: Server.FleeSubmitted(this); break;
case PBESwitchInResponsePacket sirp: Server.SwitchesSubmitted(this, sirp.Switches); break;
default: throw new ArgumentOutOfRangeException(nameof(packet));
}
}
}
private void SinglePlayerBattle_OnNewEvent(PBEBattle battle, IPBEPacket packet)
{
ProcessPacket(packet);
if (_pauseBattleThread)
{
try
{
Thread.Sleep(Timeout.Infinite);
}
catch (ThreadInterruptedException) { }
}
}
public void Send(IPBEPacket packet)
{
if (!IsConnected)
{
throw new InvalidOperationException("Socket not connected.");
}
byte[] data = packet.Data.ToArray();
if (_encryption is not null)
{
data = _encryption.Encrypt(data);
}
PBENetworkUtils.Send(data, _socket);
}
public void Send(IPBEPacket packet)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
byte[] data = packet.Data.ToArray();
if (_encryption != null)
{
data = _encryption.Encrypt(data);
}
PBENetworkUtils.Send(data, Socket);
}
protected override bool ProcessPacket(IPBEPacket packet)
{
switch (packet)
{
case PBEMovePPChangedPacket mpcp:
{
PBEBattlePokemon moveUser = mpcp.MoveUserTrainer.TryGetPokemon(mpcp.MoveUser);
moveUser.Moves[mpcp.Move].PP -= mpcp.AmountReduced;
break;
}
}
return(base.ProcessPacket(packet));
}
protected override bool ProcessPacket(IPBEPacket packet)
{
switch (packet)
{
case PBEMovePPChangedPacket mpcp:
{
PBEBattlePokemon moveUser = mpcp.MoveUserTrainer.GetPokemon(mpcp.MoveUser);
moveUser.Moves[mpcp.Move] !.PP -= mpcp.AmountReduced;
break;
}
case PBEActionsRequestPacket _:
case PBESwitchInRequestPacket _: return(true);
}
return(base.ProcessPacket(packet));
}
private static void Battle_OnNewEvent(PBEBattle battle, IPBEPacket packet)
{
try
{
switch (packet)
{
case PBEActionsRequestPacket arp:
{
PBETeam team = arp.Team;
PBETurnAction[] actions = PBEAI.CreateActions(team);
if (!PBEBattle.AreActionsValid(team, actions))
{
throw new Exception($"{team.TrainerName}'s AI created invalid actions!");
}
PBEBattle.SelectActionsIfValid(team, actions);
break;
}
case PBESwitchInRequestPacket sirp:
{
PBETeam team = sirp.Team;
PBESwitchIn[] switches = PBEAI.CreateSwitches(team);
if (!PBEBattle.AreSwitchesValid(team, switches))
{
throw new Exception($"{team.TrainerName}'s AI created invalid switches!");
}
PBEBattle.SelectSwitchesIfValid(team, switches);
break;
}
case PBETurnBeganPacket tbp:
{
Console.SetOut(_oldWriter);
DateTime time = DateTime.Now;
Console.WriteLine($"Emulating turn {tbp.TurnNumber}... ({time.Hour:D2}:{time.Minute:D2}:{time.Second:D2}:{time.Millisecond:D3})");
Console.SetOut(_writer);
break;
}
}
}
catch (Exception e)
{
CatchException(e);
}
}
protected override bool ProcessPacket(IPBEPacket packet)
{
switch (packet)
{
case PBEMovePPChangedPacket mpcp:
{
PBEBattlePokemon moveUser = mpcp.MoveUserTrainer.TryGetPokemon(mpcp.MoveUser);
if (moveUser.Trainer == Trainer)
{
moveUser.Moves[mpcp.Move].PP -= mpcp.AmountReduced;
}
break;
}
case PBEActionsRequestPacket arp:
{
if (arp.Trainer == Trainer)
{
ActionsLoop(true);
}
else if (Trainer == null || Trainer.NumConsciousPkmn == 0) // Spectators/KO'd
{
BattleView.AddMessage("Waiting for players...", messageLog: false);
}
return(true);
}
case PBESwitchInRequestPacket sirp:
{
PBETrainer t = sirp.Trainer;
t.SwitchInsRequired = sirp.Amount;
if (t == Trainer)
{
_switchesRequired = sirp.Amount;
SwitchesLoop(true);
}
else if (_switchesRequired == 0) // No need to switch/Spectators/KO'd
{
BattleView.AddMessage("Waiting for players...", messageLog: false);
}
return(true);
}
}
return(base.ProcessPacket(packet));
}
protected override bool ProcessPacket(IPBEPacket packet)
{
switch (packet)
{
case PBEActionsRequestPacket arp:
{
PBETrainer t = arp.Trainer;
if (t == Trainer)
{
ActionsLoop(true);
}
else
{
new Thread(t.CreateAIActions)
{
Name = ThreadName
}.Start();
}
return(true);
}
case PBESwitchInRequestPacket sirp:
{
PBETrainer t = sirp.Trainer;
if (t == Trainer)
{
_switchesRequired = sirp.Amount;
SwitchesLoop(true);
}
else
{
new Thread(t.CreateAISwitches)
{
Name = ThreadName
}.Start();
}
return(true);
}
}
return(base.ProcessPacket(packet));
}
protected override bool ProcessPacket(IPBEPacket packet)
{
switch (packet)
{
case PBEActionsRequestPacket arp:
{
PBETrainer t = arp.Trainer;
if (t == Trainer)
{
ActionsLoop(true);
}
else
{
new Thread(() => PBEBattle.SelectActionsIfValid(t, PBEAI.CreateActions(t)))
{
Name = "Battle Thread"
}.Start();
}
return(true);
}
case PBESwitchInRequestPacket sirp:
{
PBETrainer t = sirp.Trainer;
if (t == Trainer)
{
_switchesRequired = sirp.Amount;
SwitchesLoop(true);
}
else
{
new Thread(() => PBEBattle.SelectSwitchesIfValid(t, PBEAI.CreateSwitches(t)))
{
Name = "Battle Thread"
}.Start();
}
return(true);
}
}
return(base.ProcessPacket(packet));
}
private void OnPacketReceived(object sender, IPBEPacket packet)
{
Debug.WriteLine($"Packet received ({BattleId} \"{packet.GetType().Name}\")");
resetEvent.Set();
if (BattleId < 2)
{
switch (packet)
{
case PBEActionsResponsePacket arp:
{
Server.ActionsSubmitted(this, arp.Actions);
break;
}
case PBEPartyResponsePacket prp:
{
Console.WriteLine($"Received team from {TrainerName}!");
if (!submittedTeam)
{
submittedTeam = true;
PBETeamShell s = prp.TeamShell;
Server.PartySubmitted(this, s);
s.Dispose();
}
else
{
Console.WriteLine("Team submitted multiple times!");
}
break;
}
case PBESwitchInResponsePacket sirp:
{
Server.SwitchesSubmitted(this, sirp.Switches);
break;
}
}
}
// TODO: Kick players who are sending bogus packets or sending too many
}
private void OnPacketReceived(object sender, IPBEPacket packet)
{
Debug.WriteLine($"Connecting... received \"{packet.GetType().Name}\"");
switch (packet)
{
case PBEMatchCancelledPacket _:
{
_action.Invoke(null);
break;
}
case PBEPartyRequestPacket prp:
{
_battleId = prp.BattleId;
if (prp.RequireLegal)
{
Send(new PBELegalPartyResponsePacket(_party));
}
else
{
Send(new PBEPartyResponsePacket(_party));
}
break;
}
case PBEBattlePacket bp:
{
_client.Disconnected -= OnDisconnected;
_client.Error -= OnError;
_client.PacketReceived -= OnPacketReceived;
_action.Invoke(Tuple.Create(_client, bp, _battleId));
// Response will be sent in NetworkClient constructor so the server doesn't send packets between threads
break;
}
default: throw new ArgumentOutOfRangeException(nameof(packet));
}
}
private void OnPacketReceived(object sender, IPBEPacket packet)
{
Debug.WriteLine($"{Name} received \"{packet.GetType().Name}\"");
switch (packet)
{
case PBEMatchCancelledPacket _:
{
BattleView.AddMessage("Match cancelled!", messageBox: false);
break;
}
case PBEPlayerJoinedPacket pjp:
{
BattleView.AddMessage(string.Format("{0} joined the game.", pjp.TrainerName), messageBox: false);
Send(new PBEResponsePacket());
break;
}
case PBEActionsRequestPacket _:
case PBESwitchInRequestPacket _:
case PBEWinnerPacket _:
{
Battle.Events.Add(packet);
Send(new PBEResponsePacket());
StartPacketThread();
break;
}
default:
{
BattleView.AddMessage("Communicating...", messageLog: false);
Battle.Events.Add(packet);
Send(new PBEResponsePacket());
break;
}
}
}
private void SendToAll(IPBEPacket packet)
{
SendTo(_readyPlayers.Values.ToArray(), packet);
}
private bool ProcessPacket(IPBEPacket packet)
{
switch (packet)
{
case PBEMoveLockPacket _:
case PBEMovePPChangedPacket _:
case PBEIllusionPacket _:
case PBETransformPacket _:
case PBEBattlePacket _:
case PBETurnBeganPacket _: return(true);
case PBEActionsRequestPacket arp:
{
PBETrainer t = arp.Trainer;
if (t == _trainer)
{
ActionsLoop(true);
}
else
{
new Thread(() => PBEBattle.SelectActionsIfValid(t, PBEAI.CreateActions(t)))
{
Name = ThreadName
}.Start();
}
return(true);
}
case PBESwitchInRequestPacket sirp:
{
PBETrainer t = sirp.Trainer;
if (t == _trainer)
{
_switchesRequired = sirp.Amount;
SwitchesLoop(true);
}
else
{
new Thread(() => PBEBattle.SelectSwitchesIfValid(t, PBEAI.CreateSwitches(t)))
{
Name = ThreadName
}.Start();
}
return(true);
}
/*case PBEPkmnFaintedPacket pfp:
* {
* PBEBattlePokemon pokemon = pfp.PokemonTrainer.TryGetPokemon(pfp.Pokemon);
* BattleView.Field.HidePokemon(pokemon, pfp.OldPosition);
* break;
* }
* case PBEPkmnFormChangedPacket pfcp:
* {
* PBEBattlePokemon pokemon = pfcp.PokemonTrainer.TryGetPokemon(pfcp.Pokemon);
* BattleView.Field.UpdatePokemon(pokemon, false, true);
* break;
* }
* case PBEPkmnHPChangedPacket phcp:
* {
* PBEBattlePokemon pokemon = phcp.PokemonTrainer.TryGetPokemon(phcp.Pokemon);
* BattleView.Field.UpdatePokemon(pokemon, true, false);
* break;
* }
* case PBEPkmnSwitchInPacket psip:
* {
* if (!psip.Forced)
* {
* foreach (PBEPkmnSwitchInPacket.PBESwitchInInfo info in psip.SwitchIns)
* {
* BattleView.Field.ShowPokemon(psip.Trainer.TryGetPokemon(info.Pokemon));
* }
* }
* break;
* }
* case PBEPkmnSwitchOutPacket psop:
* {
* PBEBattlePokemon pokemon = psop.PokemonTrainer.TryGetPokemon(psop.Pokemon);
* BattleView.Field.HidePokemon(pokemon, psop.OldPosition);
* break;
* }
* case PBEStatus1Packet s1p:
* {
* PBEBattlePokemon status1Receiver = s1p.Status1ReceiverTrainer.TryGetPokemon(s1p.Status1Receiver);
* BattleView.Field.UpdatePokemon(status1Receiver, true, false);
* break;
* }
* case PBEStatus2Packet s2p:
* {
* PBEBattlePokemon status2Receiver = s2p.Status2ReceiverTrainer.TryGetPokemon(s2p.Status2Receiver);
* switch (s2p.Status2)
* {
* case PBEStatus2.Airborne: BattleView.Field.UpdatePokemon(status2Receiver, false, true); break;
* case PBEStatus2.Disguised:
* {
* switch (s2p.StatusAction)
* {
* case PBEStatusAction.Ended: BattleView.Field.UpdatePokemon(status2Receiver, true, true); break;
* }
* break;
* }
* case PBEStatus2.ShadowForce: BattleView.Field.UpdatePokemon(status2Receiver, false, true); break;
* case PBEStatus2.Substitute:
* {
* switch (s2p.StatusAction)
* {
* case PBEStatusAction.Added:
* case PBEStatusAction.Ended: BattleView.Field.UpdatePokemon(status2Receiver, false, true); break;
* }
* break;
* }
* case PBEStatus2.Transformed:
* {
* switch (s2p.StatusAction)
* {
* case PBEStatusAction.Added: BattleView.Field.UpdatePokemon(status2Receiver, false, true); break;
* }
* break;
* }
* case PBEStatus2.Underground: BattleView.Field.UpdatePokemon(status2Receiver, false, true); break;
* case PBEStatus2.Underwater: BattleView.Field.UpdatePokemon(status2Receiver, false, true); break;
* }
* break;
* }
* case PBEWeatherPacket wp:
* {
* switch (wp.WeatherAction)
* {
* case PBEWeatherAction.Added:
* case PBEWeatherAction.Ended: BattleView.Field.UpdateWeather(); break;
* case PBEWeatherAction.CausedDamage: break;
* }
* break;
* }
* case PBEAutoCenterPacket acp:
* {
* PBEBattlePokemon pokemon0 = acp.Pokemon0Trainer.TryGetPokemon(acp0.Pokemon0);
* PBEBattlePokemon pokemon1 = acp.Pokemon1Trainer.TryGetPokemon(acp1.Pokemon1);
* BattleView.Field.MovePokemon(pokemon0, acp.Pokemon0OldPosition);
* BattleView.Field.MovePokemon(pokemon1, acp.Pokemon1OldPosition);
* break;
* }*/
}
string message = PBEBattle.GetDefaultMessage(_battle, packet, userTrainer: _trainer);
if (string.IsNullOrEmpty(message))
{
return(true);
}
AddMessage(message);
return(false);
}
protected override bool ProcessPacket(IPBEPacket packet)
{
switch (packet)
{
case PBEMovePPChangedPacket mpcp:
{
PBEBattlePokemon moveUser = mpcp.MoveUserTrainer.GetPokemon(mpcp.MoveUser);
if (moveUser.Trainer == Trainer)
{
moveUser.Moves[mpcp.Move] !.PP -= mpcp.AmountReduced;
}
break;
}
case PBEActionsRequestPacket arp:
{
if (arp.Trainer == Trainer)
{
_ = new ActionsBuilder(BattleView, Trainer, OnActionsReady);
}
else if (Trainer is null || Trainer.NumConsciousPkmn == 0) // Spectators/KO'd
{
BattleView.AddMessage("Waiting for players...", messageLog: false);
}
return(true);
}
case PBESwitchInRequestPacket sirp:
{
PBETrainer t = sirp.Trainer;
t.SwitchInsRequired = sirp.Amount;
if (t == Trainer)
{
_ = new SwitchesBuilder(BattleView, sirp.Amount, OnSwitchesReady);
}
else if (BattleView.Actions.SwitchesBuilder?.SwitchesRequired == 0) // No need to switch/Spectators/KO'd
{
BattleView.AddMessage("Waiting for players...", messageLog: false);
}
return(true);
}
case PBEPkmnFaintedPacket_Hidden pfph:
{
bool ret = base.ProcessPacket(packet); // Process before removal
PBEBattlePokemon pokemon = pfph.PokemonTrainer.GetPokemon(pfph.OldPosition);
Battle.ActiveBattlers.Remove(pokemon);
pokemon.FieldPosition = PBEFieldPosition.None;
PBETrainer.Remove(pokemon);
return(ret);
}
case PBEPkmnFormChangedPacket_Hidden pfcph:
{
PBEBattlePokemon pokemon = pfcph.PokemonTrainer.GetPokemon(pfcph.Pokemon);
pokemon.HPPercentage = pfcph.NewHPPercentage;
pokemon.KnownAbility = pfcph.NewKnownAbility;
pokemon.KnownForm = pfcph.NewForm;
pokemon.KnownType1 = pfcph.NewType1;
pokemon.KnownType2 = pfcph.NewType2;
pokemon.KnownWeight = pfcph.NewWeight;
break;
}
case PBEPkmnHPChangedPacket_Hidden phcph:
{
PBEBattlePokemon pokemon = phcph.PokemonTrainer.GetPokemon(phcph.Pokemon);
pokemon.HPPercentage = phcph.NewHPPercentage;
break;
}
case PBEPkmnSwitchInPacket_Hidden psiph:
{
foreach (PBEPkmnSwitchInPacket_Hidden.PBEPkmnSwitchInInfo info in psiph.SwitchIns)
{
_ = new PBEBattlePokemon(psiph.Trainer, info);
}
break;
}
case PBEPkmnSwitchOutPacket_Hidden psoph:
{
bool ret = base.ProcessPacket(packet); // Process before removal
PBEBattlePokemon pokemon = psoph.PokemonTrainer.GetPokemon(psoph.OldPosition);
Battle.ActiveBattlers.Remove(pokemon);
PBETrainer.Remove(pokemon);
return(ret);
}
case PBEReflectTypePacket_Hidden rtph:
{
PBEBattlePokemon user = rtph.UserTrainer.GetPokemon(rtph.User);
PBEBattlePokemon target = rtph.TargetTrainer.GetPokemon(rtph.Target);
user.Type1 = user.KnownType1 = target.KnownType1; // Set Type1 and Type2 so Transform works
user.Type2 = user.KnownType2 = target.KnownType2;
break;
}
case PBEWildPkmnAppearedPacket wpap:
{
PBETrainer wildTrainer = Battle.Teams[1].Trainers[0];
foreach (PBEPkmnAppearedInfo info in wpap.Pokemon)
{
PBEBattlePokemon pokemon = wildTrainer.GetPokemon(info.Pokemon);
pokemon.FieldPosition = info.FieldPosition;
Battle.ActiveBattlers.Add(pokemon);
}
break;
}
case PBEWildPkmnAppearedPacket_Hidden wpaph:
{
foreach (PBEWildPkmnAppearedPacket_Hidden.PBEWildPkmnInfo info in wpaph.Pokemon)
{
_ = new PBEBattlePokemon(Battle, info);
}
break;
}
}
return(base.ProcessPacket(packet));
}
internal void FirePacketReceived(IPBEPacket packet)
{
PacketReceived?.Invoke(this, packet);
}
private void BattleEventHandler(PBEBattle battle, IPBEPacket packet)
{
void SendOriginalPacketToTeamOwnerAndEveryoneElseGetsAPacketWithHiddenInfo(IPBEPacket realPacket, IPBEPacket hiddenInfo, byte teamOwnerId)
{
_spectatorPackets.Add(hiddenInfo);
Player teamOwner = _battlers[teamOwnerId];
teamOwner.Send(realPacket);
if (!teamOwner.WaitForResponse())
{
return;
}
foreach (Player player in _readyPlayers.Values.Except(new[] { teamOwner }))
{
player.Send(hiddenInfo);
if (!player.WaitForResponse() && player.BattleId < 2)
{
return;
}
}
}
switch (packet)
{
case PBEMoveLockPacket mlp:
{
Player teamOwner = _battlers[mlp.MoveUserTeam.Id];
teamOwner.Send(mlp);
if (!teamOwner.WaitForResponse())
{
return;
}
break;
}
case PBEPkmnFaintedPacket pfp:
{
SendOriginalPacketToTeamOwnerAndEveryoneElseGetsAPacketWithHiddenInfo(pfp, pfp.MakeHidden(), pfp.PokemonTeam.Id);
break;
}
case PBEPkmnFormChangedPacket pfcp:
{
SendOriginalPacketToTeamOwnerAndEveryoneElseGetsAPacketWithHiddenInfo(pfcp, pfcp.MakeHidden(), pfcp.PokemonTeam.Id);
break;
}
case PBEPkmnHPChangedPacket phcp:
{
SendOriginalPacketToTeamOwnerAndEveryoneElseGetsAPacketWithHiddenInfo(phcp, phcp.MakeHidden(), phcp.PokemonTeam.Id);
break;
}
case PBEPkmnSwitchInPacket psip:
{
SendOriginalPacketToTeamOwnerAndEveryoneElseGetsAPacketWithHiddenInfo(psip, psip.MakeHidden(), psip.Team.Id);
break;
}
case PBEPkmnSwitchOutPacket psop:
{
SendOriginalPacketToTeamOwnerAndEveryoneElseGetsAPacketWithHiddenInfo(psop, psop.MakeHidden(), psop.PokemonTeam.Id);
break;
}
case PBETransformPacket tp:
{
if (tp.UserTeam.Id == 0 || tp.TargetTeam.Id == 0)
{
_battlers[0].Send(tp);
if (!_battlers[0].WaitForResponse())
{
return;
}
}
if (tp.UserTeam.Id == 1 || tp.TargetTeam.Id == 1)
{
_battlers[1].Send(tp);
if (!_battlers[1].WaitForResponse())
{
return;
}
}
break;
}
case PBEActionsRequestPacket _:
{
_state = ServerState.WaitingForActions;
_spectatorPackets.Add(packet);
foreach (Player player in _readyPlayers.Values.ToArray())
{
player.Send(packet);
}
_resetEvent.Set();
break;
}
case PBEAutoCenterPacket acp:
{
PBEAutoCenterPacket team0 = acp.MakeHidden(false, true);
PBEAutoCenterPacket team1 = acp.MakeHidden(true, false);
PBEAutoCenterPacket spectators = acp.MakeHidden(true, true);
_spectatorPackets.Add(spectators);
_battlers[0].Send(team0);
if (!_battlers[0].WaitForResponse())
{
return;
}
_battlers[1].Send(team1);
if (!_battlers[1].WaitForResponse())
{
return;
}
foreach (Player player in _readyPlayers.Values.Except(_battlers))
{
player.Send(spectators);
player.WaitForResponse();
}
break;
}
case PBETeamPacket tp:
{
Player teamOwner = _battlers[tp.Team.Id];
teamOwner.Send(tp);
if (!teamOwner.WaitForResponse())
{
return;
}
break;
}
case PBESwitchInRequestPacket _:
{
_state = ServerState.WaitingForSwitchIns;
_spectatorPackets.Add(packet);
SendToAll(packet);
_resetEvent.Set();
break;
}
default:
{
_spectatorPackets.Add(packet);
foreach (Player player in _readyPlayers.Values.ToArray())
{
player.Send(packet);
if (!player.WaitForResponse() && player.BattleId < 2)
{
return;
}
}
break;
}
}
}
