public void SendGameOver(GameOverMessage message)
{
// Disable async receive
StopDataReceiveLoop();
while (!_receivingDataEnd)
{
Thread.Sleep(0);
}
byte[] gameoverData = Util.SerializeUpdate(message);
_socket.Send(gameoverData);
IClientUpdate response = null;
while (!(response is ClientStatusUpdate && (response as ClientStatusUpdate).Update == ClientUpdate.GameOverOk))
{
byte[] buffer = new byte[512];
try
{
_socket.Receive(buffer);
}
catch (SocketException e)
{
break;
}
response = GetUpdate(buffer, 0, buffer.Length);
}
Console.WriteLine("Game over received OK");
}
/// <summary>
/// Socket receive callback
/// </summary>
/// <param name="ar"></param>
private void SocketReceive(IAsyncResult ar)
{
if (!_receivingData)
{
_socket.EndReceive(ar);
Console.WriteLine("Unhooked async receive");
_receivingDataEnd = true;
return;
}
AsyncReceive recObject = (AsyncReceive)ar.AsyncState;
try
{
int bytesRead = _socket.EndReceive(ar);
// There's more data in the socket
if (bytesRead > 0)
{
IClientUpdate update = GetUpdate(recObject.Buffer, 0, recObject.Buffer.Length);
_dataReceived(this, update);
// Get rest of the data
_socket.BeginReceive(recObject.Buffer, 0, AsyncReceive.BufferSize, SocketFlags.None, new AsyncCallback(SocketReceive), recObject);
}
else
{
// Prepare for new receive
recObject = new AsyncReceive();
_socket.BeginReceive(recObject.Buffer, 0, AsyncReceive.BufferSize, SocketFlags.None, new AsyncCallback(SocketReceive), recObject);
}
}
catch (SocketException ex)
{
Console.WriteLine("Receive error: " + ex.Message);
return;
}
catch (ObjectDisposedException ex)
{
Console.WriteLine("Receive error: " + ex.Message);
return;
}
}
public void CheckReady()
{
try
{
_socket.Blocking = false;
_socket.Send(new byte[1], 0, 0);
_socket.Blocking = true;
if (!_socket.Connected)
{
State = ClientState.Defunct;
return;
}
}
catch (SocketException e)
{
if (!e.NativeErrorCode.Equals(10035))
{
State = ClientState.Defunct;
return;
}
}
if (State != ClientState.WaitingForReady)
{
return;
}
if (_socket.Available > 0)
{
byte[] buffer = new byte[512];
_socket.Receive(buffer);
IClientUpdate update = GetUpdate(buffer, 0, buffer.Length);
if (update is ClientStatusUpdate && ((ClientStatusUpdate)update).Update == ClientUpdate.Ready)
{
State = ClientState.WaitingForStart;
_socket.Blocking = true;
Console.WriteLine("Received ready from " + LocalPlayer.Color);
}
}
}
private void ClientDataReceived(Client client, IClientUpdate update)
{
// Don't process input from dead players
if (client.LocalPlayer.Dead)
{
return;
}
if (update is ClientPositionUpdate)
{
ClientPositionUpdate posUpdate = (ClientPositionUpdate)update;
client.LocalPlayer.X = posUpdate.X;
client.LocalPlayer.Y = posUpdate.Y;
client.LocalPlayer.Direction = posUpdate.Direction;
client.LocalPlayer.Moving = posUpdate.Moving;
}
else if (update is ClientBombSet)
{
SetBomb(client, (ClientBombSet)update);
}
else if (update is ClientStatusUpdate)
{
ClientStatusUpdate statusUpdate = (ClientStatusUpdate)update;
if (statusUpdate.Update == ClientUpdate.BombTrigger && client.LocalPlayer.ManualTrigger)
{
lock (_bombs)
{
_bombs.ForEach(bomb =>
{
if (bomb.OwnerColor == client.LocalPlayer.Color)
{
bomb.Trigger();
}
});
}
}
}
}
/// <summary>
/// Sends level data to the client with local player type
/// </summary>
/// <param name="map"></param>
public void SendMap(Map map)
{
Console.WriteLine("Sending map data...");
// Serialize the map
byte[] mapData = Util.SerializeUpdate(map);
byte[] buffer = new byte[512];
try
{
_socket.Send(mapData);
// Wait for confirmation
_socket.Receive(buffer);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
State = ClientState.Defunct;
return;
}
IClientUpdate response = GetUpdate(buffer, 0, 512);
if (response is ClientStatusUpdate && ((ClientStatusUpdate)response).Update == ClientUpdate.MapOk)
{
// Send player information
SendPlayerInfo(_player);
// Map was sent, change state
State = ClientState.WaitingForReady;
}
else
{
Console.WriteLine("Invalid map response from client!");
State = ClientState.Defunct;
}
}
/// <summary>
/// Send information about a player to the client
/// </summary>
/// <param name="player"></param>
public void SendPlayerInfo(Player player)
{
byte[] buffer = new byte[512];
try
{
byte[] playerData = Util.SerializeUpdate(player);
_socket.Send(playerData);
// Wait for confirmation
_socket.Receive(buffer);
}
catch (SocketException ex)
{
Console.WriteLine("Error while sending player info: " + ex.Message);
}
IClientUpdate response = GetUpdate(buffer, 0, buffer.Length);
if (response is ClientStatusUpdate && ((ClientStatusUpdate)response).Update == ClientUpdate.PlayerInfoOk)
{
Console.WriteLine("Player info sent OK");
}
}
