public void ReceivePacket(TCPToolkit.Packet packet, int playerID)
{
IdentificationMessage identification = Serializable.CreateFromBytes <IdentificationMessage>(packet.Data.ArraySegment());
if (identification != null)
{
lock (m_lock)
{
if (!m_clientCharacters.ContainsKey(playerID)) // it's a new player
{
AddNewPlayer(playerID);
}
#if DEBUG_LOG
Debug.Log("Received TCP connection request from player (ID " + playerID + ")");
#endif // DEBUG_LOG
ServerSuccessfulConnectMessage serverSuccessPing = new ServerSuccessfulConnectMessage();
m_TCPServer.Send(serverSuccessPing.GetBytes(), playerID);
}
return;
}
OnLobbyEnteredMessage lobbyEnter = Serializable.CreateFromBytes <OnLobbyEnteredMessage>(packet.Data.ArraySegment());
if (lobbyEnter != null)
{
lock (m_lock)
{
if (m_clientCharacters.ContainsKey(playerID))
{
Debug.Log("Adding character " + lobbyEnter.CharacterID.Value + " to player " + playerID);
m_clientCharacters[playerID] = lobbyEnter.CharacterID;
BroadcastPlayerList();
}
}
return;
}
ClientReadyMessage ready = IConvertible.CreateFromBytes <ClientReadyMessage>(packet.Data.ArraySegment());
if (ready != null && m_readyClients.ContainsKey(playerID))
{
Debug.Log("Client " + playerID + " is ready to receive world.");
m_readyClients[playerID] = true;
return;
}
if (m_awaitingClientLoadWorld)
{
ClientWorldLoadedMessage clientWorldLoaded = IConvertible.CreateFromBytes <ClientWorldLoadedMessage>(packet.Data.ArraySegment());
if (clientWorldLoaded != null)
{
m_readyClients.Remove(playerID);
}
}
}
public void ReceivePacket(TCPToolkit.Packet packet)
{
ServerSuccessfulConnectMessage serverSuccessPing = common.serialization.IConvertible.CreateFromBytes <ServerSuccessfulConnectMessage>(packet.Data.ArraySegment());
if (serverSuccessPing != null)
{
m_waitingOnTCPResponse = false;
#if DEBUG_LOG
Debug.Log("Received TCP connection confirmation.");
#endif // DEBUG_LOG
}
}
public void ReceivePacket(TCPToolkit.Packet packet, int playerID)
{
// if we receive ID message from player (who's trying to reconnect)
// ...
IdentificationMessage identification = Serializable.CreateFromBytes <IdentificationMessage>(packet.Data.ArraySegment());
if (identification != null)
{
#if DEBUG_LOG
Debug.Log("Player " + playerID + " successfully connected and identified. Rejoining.");
#endif // DEBUG_LOG
m_connectedClients[playerID] = true;
}
}
private void ReceivingThread(object streamSourcePair)
{
NetworkStream stream = ((Tuple <NetworkStream, IPEndPoint>)streamSourcePair).Item1;
IPEndPoint source = ((Tuple <NetworkStream, IPEndPoint>)streamSourcePair).Item2;
#if DEBUG_LOG
Debug.Log("Starting reception from " + source.ToString());
#endif // DEBUG_LOG
if (!stream.CanRead)
{
return;
}
int bytesRead = 0;
byte[] bytes = new byte[DATA_BUFFER_SIZE];
int lastPacketEnd = 0;
int bufferOffset = 0;
int totalPacketBytes = 0;
bool readyToReadPacket = true;
stream.ReadTimeout = m_connectionTimeoutInMS;
while (!m_exitSignal && m_activeEndpoints[source] && bufferOffset >= 0)
{
if (readyToReadPacket)
{
bytesRead = 0;
totalPacketBytes = 0;
readyToReadPacket = false;
}
// read from stream until we read a full packet
try
{
bytesRead += stream.Read(bytes, bufferOffset % DATA_BUFFER_SIZE, DATA_BUFFER_SIZE - bufferOffset);
}
catch (IOException ex)
{
Debug.Log(ex.Message);
m_activeEndpoints[source] = false;
return;
}
if (bytesRead > 0)
{
TCPToolkit.Packet packet = TCPToolkit.Packet.FirstPacketFromBytes(bytes);
lock (m_lock)
{
m_endpointLastTimeSeen[source] = 0;
}
while (packet != null && totalPacketBytes < bytesRead)
{
int playerID = packet.PlayerID;
if (!m_clientEndpoints.ContainsKey(playerID))
{
// we have a new client
AddNewClient(playerID, source);
}
else
{
// we replace the previous endpoint
UpdateClientEndpoint(playerID, source);
}
readyToReadPacket = true;
lastPacketEnd = packet.RawBytes.Length;
totalPacketBytes += lastPacketEnd;
// broadcast reception to listeners
if (packet.Data.Length > 0) // if it's not a keep-alive packet
{
lock (m_lock)
{
foreach (ITCPServerReceiver receiver in m_receivers)
{
receiver.ReceivePacket(packet, playerID);
}
}
}
packet = TCPToolkit.Packet.FirstPacketFromBytes(bytes.ArrayFrom(totalPacketBytes));
}
// on a un restant de bytes
// we shift
bufferOffset = bytesRead - totalPacketBytes;
for (int i = 0; i < bufferOffset; i++)
{
bytes[i] = bytes[i + totalPacketBytes];
}
}
try
{
Task.Delay(50, new CancellationToken(m_exitSignal || !m_activeEndpoints[source])).Wait();
}
catch (AggregateException ex)
{
#if DEBUG_LOG
Debug.Log(ex.Message);
#endif // DEBUG_LOG
}
}
}
public void ReceivePacket(TCPToolkit.Packet packet)
{
// empty for now
}
private void ReceivingThread(object streamObj)
{
NetworkStream stream = (NetworkStream)streamObj;
if (!stream.CanRead)
{
return;
}
int bytesRead = 0;
byte[] bytes = new byte[DATA_BUFFER_SIZE];
int lastPacketEnd = 0;
byte[] packetBytes = new byte[0];
int bufferOffset = 0;
int totalPacketBytes = 0;
bool readyToReadPacket = true;
stream.ReadTimeout = m_connectionTimeoutInMS;
while (!m_exitSignal && m_activeEndpoint && bufferOffset >= 0)
{
if (readyToReadPacket)
{
bytesRead = 0;
totalPacketBytes = 0;
readyToReadPacket = false;
}
// read from stream until we read a full packet
try
{
bytesRead += stream.Read(bytes, bufferOffset % DATA_BUFFER_SIZE, DATA_BUFFER_SIZE - bufferOffset);
}
catch (IOException ex)
{
Debug.Log(ex.Message);
return;
}
if (bytesRead > 0)
{
TCPToolkit.Packet packet = TCPToolkit.Packet.FirstPacketFromBytes(bytes);
lock (m_lock)
{
m_endpointLastTimeSeen = 0;
}
while (packet != null && totalPacketBytes < bytesRead)
{
readyToReadPacket = true;
lastPacketEnd = packet.RawBytes.Length;
totalPacketBytes += lastPacketEnd;
// broadcast reception to listeners
if (packet.Data.Length > 0) // if it's not a keep-alive packet
{
lock (m_lock)
{
m_iteratingTroughReceivers = true;
foreach (ITCPClientReceiver receiver in m_receivers)
{
receiver.ReceivePacket(packet);
}
m_iteratingTroughReceivers = false;
}
}
packet = TCPToolkit.Packet.FirstPacketFromBytes(bytes.ArrayFrom(totalPacketBytes));
}
// on a un restant de bytes
// we shift
bufferOffset = bytesRead - totalPacketBytes;
for (int i = 0; i < bufferOffset; i++)
{
bytes[i] = bytes[i + totalPacketBytes];
}
}
try
{
Task.Delay(50, new CancellationToken(m_exitSignal || !m_activeEndpoint)).Wait();
}
catch (AggregateException ex)
{
#if DEBUG_LOG
Debug.Log(ex.Message);
#endif // DEBUG_LOG
}
}
#if DEBUG_LOG
Debug.Log("State at client receiving thread exit : Active endpoint ? " + m_activeEndpoint.ToString() + ", Exit signal ?" + m_exitSignal + ", Buffer offset :" + bufferOffset);
#endif // DEBUG_LOG
}
