void RaiseSpecificPacketEvents()
{
while (!abort)
{
while (SpecificPacketQueue.Count > 0)
{
PackageEventArgs pea = SpecificPacketQueue.Dequeue();
try
{
string methodName = pea.ReceivedPacket.PacketType.ToString() + "Received";
Type t = this.GetType();
if (t.GetEvent(methodName) != null)
{
var eventDelegate = (MulticastDelegate)t.GetField(methodName, BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this);
OnEvent(eventDelegate as EventHandler <PackageEventArgs>, pea);
//if (eventDelegate != null)
//{
// foreach (var handler in eventDelegate.GetInvocationList())
// {
// try
// {
// //This code is to make the raising of the event threadsafe with the UI thread.
// ISynchronizeInvoke syncInvoke = handler.Target as ISynchronizeInvoke;
// if (syncInvoke != null && syncInvoke.InvokeRequired)
// {
// syncInvoke.BeginInvoke(handler, new object[] { this, pea });
// }
// else
// {
// handler.Method.Invoke(handler.Target, new object[] { this, pea });
// }
// }
// catch (Exception ex)
// {
// RaiseExceptionEncountered(ex, pea.ID);
// }
// }
//}
}
else
{
OnEvent(UndefinedPacketReceived, pea);
}
}
catch (Exception e)
{
RaiseExceptionEncountered(e, pea.ID);
}
}
if (!abort)
{
mreSpecificPacketReceived.Reset();
mreSpecificPacketReceived.WaitOne();
}
}
}
protected virtual void OnEvent(EventHandler <PackageEventArgs> handler, PackageEventArgs e)
{
if (handler != null)
{
foreach (EventHandler <PackageEventArgs> singleCast in handler.GetInvocationList())
{
ISynchronizeInvoke syncInvoke = singleCast.Target as ISynchronizeInvoke;
try
{
//This code is to make the raising of the event threadsafe with the UI thread.
if (syncInvoke != null && syncInvoke.InvokeRequired)
{
syncInvoke.BeginInvoke(singleCast, new object[] { this, e });
}
else
{
singleCast(this, e);
}
}
catch (Exception ex)
{
if (e != null)
{
RaiseExceptionEncountered(ex, e.ID);
}
else
{
RaiseExceptionEncountered(ex, Guid.Empty);
}
}
}
}
}
void connector_GameStartPacketReceived(object sender, PackageEventArgs e)
{
GameInProgress = true;
//View.GameStarted();
StartReady2Timer();
}
void QueueToPacketProcessor()
{
System.Threading.ThreadStart start = new ThreadStart(RaisePackageReceived);
RaisePackageReceivedThread = new Thread(start);
RaisePackageReceivedThread.Start();
start = new ThreadStart(RaiseSpecificPacketEvents);
RaiseSpecificPackageReceivedThread = new Thread(start);
RaiseSpecificPackageReceivedThread.Start();
do
{
lock (ProcessQueue)
{
while (ProcessQueue.Count > 0)
{
KeyValuePair <byte[], Guid> que = ProcessQueue.Dequeue();
byte[] byteArray = que.Key;
try
{
Packet p = new Packet(byteArray);
PackageEventArgs pea = new PackageEventArgs(p, que.Value);
if (PackageReceived != null)
{
PackageReceivedQueue.Enqueue(pea);
mrePacketReceived.Set();
}
SpecificPacketQueue.Enqueue(pea);
mreSpecificPacketReceived.Set();
}
catch (Exception ex)
{
RaiseExceptionEncountered(ex, que.Value);
}
if (abort)
{
break;
}
}
}
if (!abort)
{
mreListener.Reset();
mreListener.WaitOne();
}
} while (!abort);
}
void connector_GamesMessagePacketReceived(object sender, PackageEventArgs e)
{
//GameStart and GameOver are all that matter.
if (e != null && e.ReceivedPacket != null)
{
GameMessagePacket p = e.ReceivedPacket.Package as GameMessagePacket;
if (p != null)
{
if (p.SubPacketType == GameMessageSubPacketType.GameOverSubPacket)
{
GameInProgress = !GameInProgress;
if (GameInProgress)
{
//View.GameStarted();
StartReady2Timer();
}
else
{
//View.GameEnded();
StopReady2Timer();
}
}
if (p.SubPacketType == GameMessageSubPacketType.SimulationEndSubPacket)
{
GameInProgress = false;
//View.SimulationEnded();
}
if (p.SubPacketType == GameMessageSubPacketType.AllShipSettingsSubPacket)
{
AllShipSettingsSubPacket allships = p.SubPacket as AllShipSettingsSubPacket;
if (allships != null && allships.Ships != null && !shipSelected)
{
//Currently only selects first Ship (Artemis)
SelectStationAndReady();
//View.GetShipSelection(allships.Ships.ToArray<PlayerShip>());
}
}
}
}
}
void conn_ShipActionPacket2Received(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void conn_UndefinedPacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void conn_StationStatusPacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void conn_CommsIncomingPacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void ServerProcessor_AudioCommandPacketReceived(object sender, PackageEventArgs e)
{
if (AudioCommandPacketReceived != null)
{
AudioCommandPacketReceived(this, GetProxyPacketEventArgs(e).Value);
}
}
void conn_IncomingAudioPacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void conn_EngGridUpdatePacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void ServerProcessor_DestroyObjectPacketReceived(object sender, PackageEventArgs e)
{
if (DestroyObjectPacketReceived != null)
{
DestroyObjectPacketReceived(this, GetProxyPacketEventArgs(e).Value);
}
}
void ServerProcessor_EngGridUpdatePacketReceived(object sender, PackageEventArgs e)
{
if (EngGridUpdatePacketReceived != null)
{
EngGridUpdatePacketReceived(this, GetProxyPacketEventArgs(e).Value);
}
}
static void EnqueuePacket(Queue<PackageEventArgs> que, PackageEventArgs pea, ManualResetEvent mre)
{
_log.InfoFormat("Queuing Packet {0} for processing.", pea.ReceivedPacket.PacketType.ToString());
que.Enqueue(pea);
mre.Set();
}
void QueueToPacketProcessor()
{
do
{
lock (ProcessQueue)
{
mreListener.WaitOne();
while (ProcessQueue.Count > 0)
{
KeyValuePair<Stream, Guid> que = ProcessQueue.Dequeue();
if (que.Key != null)
{
try
{
Packet p = new Packet(que.Key);
if (p != null)
{
_log.InfoFormat("Processing packet: {0}, for connection {1}", p.PacketType.ToString(), que.Value.ToString());
PackageEventArgs pea = new PackageEventArgs(p, que.Value);
EnqueueReceivedPacket(pea);
if (p.ConversionException != null)
{
if (CrashOnException)
{
throw new InvalidPacketException(p.ConversionException);
}
else
{
RaiseExceptionEncountered(p.ConversionException, que.Value);
}
}
if (p.Package != null)
{
ReadOnlyCollection<Exception> packetErrors = p.Package.GetErrors();
if (packetErrors.Count > 0)
{
foreach (Exception e in packetErrors)
{
RaiseExceptionEncountered(e, que.Value);
}
}
}
EnqueueSpecificPacket(pea);
}
else
{
}
}
catch (Exception ex)
{
if (!abort)
{
if (CrashOnException)
{
throw new InvalidPacketException(ex);
}
else
{
RaiseExceptionEncountered(ex, que.Value);
}
}
}
}
if (abort)
{
break;
}
}
}
if (!abort)
{
mreListener.Reset();
}
} while (!abort);
}
void EnqueueReceivedPacket(PackageEventArgs pea)
{
if (PackageReceived != null)
{
EnqueuePacket(PackageReceivedQueue, pea, mrePacketReceived);
}
}
//void ProcessSpecificPacket(object state)
//{
// PackageEventArgs pea = state as PackageEventArgs;
// if (pea != null)
// {
// string methodName = pea.ReceivedPacket.PacketType.ToString() + "Received";
// Type t = this.GetType();
// var eventDelegate = (MulticastDelegate)t.GetField(methodName, BindingFlags.Instance | BindingFlags.NonPublic).GetValue(this);
// OnEvent(eventDelegate as EventHandler<PackageEventArgs>, pea);
// }
//}
#endregion
void EnqueueSpecificPacket(PackageEventArgs pea)
{
EnqueuePacket(SpecificPacketQueue, pea, mreSpecificPacketReceived);
}
protected virtual void OnEvent(EventHandler<PackageEventArgs> handler, PackageEventArgs e)
{
if (handler != null)
{
foreach (EventHandler<PackageEventArgs> singleCast in handler.GetInvocationList())
{
ISynchronizeInvoke syncInvoke = singleCast.Target as ISynchronizeInvoke;
try
{
//This code is to make the raising of the event threadsafe with the UI thread.
if (syncInvoke != null && syncInvoke.InvokeRequired)
{
syncInvoke.BeginInvoke(singleCast, new object[] { this, e });
}
else
{
_log.InfoFormat("Invoking event {0}", singleCast.Method.Name);
singleCast(this, e);
}
}
catch (Exception ex)
{
if (CrashOnException)
{
throw new PacketProcessingException(ex);
}
else
{
if (e != null)
{
RaiseExceptionEncountered(ex, e.ID);
}
else
{
RaiseExceptionEncountered(ex, Guid.Empty);
}
}
}
}
}
}
void conn_PackageReceived(object sender, PackageEventArgs e)
{
//AddPacket(e.ReceivedPacket);
}
void connector_ObjectStatusUpdatePacketReceived(object sender, PackageEventArgs e)
{
if (GameInProgress)
{
if (e != null)
{
if (e.ReceivedPacket != null)
{
ObjectStatusUpdatePacket objectStat = e.ReceivedPacket.Package as ObjectStatusUpdatePacket;
if (objectStat != null)
{
if (objectStat.SubPacketType == ObjectStatusUpdateSubPacketType.MainPlayerUpdateSubPacket)
{
MainPlayerUpdateSubPacket mainPlayer = objectStat.SubPacket as MainPlayerUpdateSubPacket;
if (mainPlayer != null)
{
// || mainPlayer.ShipNumber == null
if (mainPlayer.RedAlert != null && ((mainPlayer.ShipNumber != null && mainPlayer.ShipNumber == (SelectedShip + 1))))
{
redAlertEnabled = Convert.ToBoolean(mainPlayer.RedAlert.Value);
//View.RedAlertEnabled = redAlertEnabled;
}
// || mainPlayer.ShipNumber == null
if (mainPlayer.ShieldState != null && ((mainPlayer.ShipNumber != null && mainPlayer.ShipNumber == (SelectedShip + 1))))
{
shieldsRaised = Convert.ToBoolean(mainPlayer.ShieldState.Value);
//View.ShieldsRaised = shieldsRaised;
if (shieldsRaised && ShieldsMustBeDown)
{
SendDropShields();
}
}
}
}
}
}
}
}
}
void conn_ObjectStatusUpdatePacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void ServerProcessor_GameMessagePacketReceived(object sender, PackageEventArgs e)
{
if (GameMessagePacketReceived != null)
{
GameMessagePacketReceived(this, GetProxyPacketEventArgs(e).Value);
}
}
void conn_GamesMessagePacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void ServerProcessor_IntelPacketReceived(object sender, PackageEventArgs e)
{
if (IntelPacketReceived != null)
{
IntelPacketReceived(this, GetProxyPacketEventArgs(e).Value);
}
}
void conn_DestroyObjectPacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void conn_UnknownPacket1Received(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void conn_AudioCommandPacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void ServerProcessor_CommsIncomingPacketReceived(object sender, PackageEventArgs e)
{
if (CommsIncomingPacketReceived != null)
{
CommsIncomingPacketReceived(this, GetProxyPacketEventArgs(e).Value);
}
}
void connector_StationStatusPacketReceived(object sender, PackageEventArgs e)
{
}
//Yeah--all events could have subscribed to the same routine.
// But, I might want to do something in my tests specific to certain packets later.
void conn_WelcomePacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void conn_VersionPacketReceived(object sender, PackageEventArgs e)
{
AddPacket(e.ReceivedPacket);
}
void ServerProcessor_ObjectStatusUpdatePacketReceived(object sender, PackageEventArgs e)
{
if (ObjectStatusUpdatePacketReceived != null)
{
ObjectStatusUpdatePacketReceived(this, GetProxyPacketEventArgs(e).Value);
}
}
