private void ReadFromMemory(object state)
{
lock (_memoryTimerLock)
{
var timer = state as Timer;
if (timer != _memoryTimer || _memoryTimer == null)
{
return;
}
var spideyData = MemoryScanner.ReadSpideyData();
var levelData = MemoryScanner.ReadLevelData();
var message = SpideyUdpMessage.CreateSpidermanMessage(_myInfo.Number, spideyData, levelData);
foreach (var udpClient in udpWebSwing)
{
udpClient.Send(message, message.Length);
}
var spideyLevel = SpideyLevels.GetSpideyLevel(levelData);
var location = spideyLevel.Name.TrimEnd();
_onLocationUpdate.Report(new ConnectedPlayerInformation(_myInfo.Number, location));
_udpBase.MyLastLocation = location;
}
}
private void FindPlayerInMemory(object state)
{
lock (_startupTimerLock)
{
var timer = state as Timer;
if (timer != _startupTimer || _startupTimer == null)
{
return;
}
string error;
if (!MemoryScanner.GetMemoryAddresses(out error, _spideyWindow.Handle))
{
Invoke(new Action(() => { MessageBox.Show(error); }));
return;
}
StopStartupTimer();
}
Invoke(new Action(() =>
{
SetLoadStatus(LoadStatus.Ready);
btnHost.Enabled = true;
btnJoin.Enabled = true;
}));
}
protected override void OnHandleDestroyed(EventArgs e)
{
StopStartupTimer();
StopMemoryTimer();
_spideyWindow = null;
// TODO - figure out why I can't just call .Wait() here and await inside Stop()
// It seems to wait forever even though the task completes
if (_udpClient != null)
{
_udpClient.Stop();
}
if (_udpServer != null)
{
_udpServer.Stop();
}
if (_tcpClient != null)
{
_tcpClient.Stop();
}
if (_tcpServer != null)
{
_tcpServer.Stop();
}
MemoryScanner.CloseDosBoxHandle();
base.OnHandleDestroyed(e);
}
private async Task HandleNewConnections(IProgress <ConnectedPlayerInformation> onConnected, string myName, CancellationTokenSource listenCancelToken)
{
var tcpServer = new TcpListener(IPAddress.Any, _port);
var tcpClients = new List <TcpConnectedPlayer>();
try
{
tcpServer.Start();
byte playerNumber = 1;
while (!listenCancelToken.IsCancellationRequested)
{
var client = await tcpServer.AcceptTcpClientAsync().WithWaitCancellation(listenCancelToken.Token);
if (listenCancelToken.IsCancellationRequested)
{
break;
}
if (client == null)
{
continue;
}
var player = new TcpConnectedPlayer();
var reader = new StreamReader(client.GetStream());
var writer = new StreamWriter(client.GetStream());
var messageType = Convert.ToByte(reader.ReadLine());
if (messageType != SpideyTcpMessage.SPIDEY_SENSE)
{
break;
}
SpideyTcpMessage.ParseSpideySenseMessage(reader, out string playerName);
++playerNumber;
player.Client = client;
player.Reader = reader;
player.Writer = writer;
player.PlayerInformation = new ConnectedPlayerInformation(playerNumber, playerName);
onConnected.Report(player.PlayerInformation);
SpideyTcpMessage.SendTinglingMessage(writer, myName, playerNumber);
foreach (var tcpClient in tcpClients)
{
SpideyTcpMessage.SendPlayerInfoMessage(writer, tcpClient.PlayerInformation.Number, tcpClient.PlayerInformation.Data);
SpideyTcpMessage.SendPlayerInfoMessage(tcpClient.Writer, player.PlayerInformation.Number, player.PlayerInformation.Data);
}
tcpClients.Add(player);
}
}
catch (OperationCanceledException)
{
}
catch (Exception ex)
{
// TODO - log it
throw ex;
}
finally
{
if (_gameStarted)
{
MemoryScanner.PrepSpideyData(tcpClients.Count);
foreach (var tcpClient in tcpClients)
{
foreach (var playerEndpoint in _mapPlayerEndpoints)
{
if (playerEndpoint.Key == tcpClient.PlayerInformation.Number)
{
continue;
}
SpideyTcpMessage.SendUdpInfoMessage(tcpClient.Writer, playerEndpoint.Key, playerEndpoint.Value);
}
SpideyTcpMessage.SendStartMessage(tcpClient.Writer);
}
}
foreach (var tcpClient in tcpClients)
{
tcpClient.Reader.Close();
tcpClient.Writer.Close();
tcpClient.Client.Close();
}
tcpServer.Stop();
}
}
