/// <summary>
/// Process all incoming packets.
/// </summary>
public void ProcessPackets()
{
mMyTime = DateTime.UtcNow.Ticks / 10000;
// Request pings every so often, letting the server know we're still here.
if (mTcp.isConnected && mCanPing && mPingTime + 4000 < mMyTime)
{
mCanPing = false;
mPingTime = mMyTime;
BeginSend(Packet.RequestPing);
EndSend();
}
Buffer buffer = null;
bool keepGoing = true;
#if !UNITY_WEBPLAYER
IPEndPoint ip = null;
while (keepGoing && isActive && mUdp.ReceivePacket(out buffer, out ip))
{
mUdpIsUsable = true;
keepGoing = ProcessPacket(buffer, ip);
buffer.Recycle();
}
#endif
while (keepGoing && isActive && mTcp.ReceivePacket(out buffer))
{
keepGoing = ProcessPacket(buffer, null);
buffer.Recycle();
}
}
/// <summary>
/// Thread that will be processing incoming data.
/// </summary>
void ThreadFunction()
{
for (; ;)
{
#if !STANDALONE
if (TNManager.isPaused)
{
Thread.Sleep(500);
continue;
}
#endif
mTime = DateTime.UtcNow.Ticks / 10000;
// Cleanup a list of servers by removing expired entries
mList.Cleanup(mTime);
Buffer buffer;
IPEndPoint ip;
// Process incoming UDP packets
while (mUdp != null && mUdp.listeningPort != 0 && mUdp.ReceivePacket(out buffer, out ip))
{
try { ProcessPacket(buffer, ip); }
catch (System.Exception) { }
if (buffer != null)
{
buffer.Recycle();
buffer = null;
}
}
Thread.Sleep(1);
}
}
/// <summary>
/// Keep receiving incoming packets.
/// </summary>
void Update()
{
Buffer buffer;
IPEndPoint ip;
bool changed = false;
long time = System.DateTime.UtcNow.Ticks / 10000;
// Receive and process UDP packets one at a time
while (mUdp != null && mUdp.ReceivePacket(out buffer, out ip))
{
if (buffer.size > 0)
{
try
{
BinaryReader reader = buffer.BeginReading();
Packet response = (Packet)reader.ReadByte();
if (response == Packet.ResponseServerList)
{
isActive = true;
mNextSend = time + 3000;
knownServers.ReadFrom(reader, time);
knownServers.Cleanup(time);
changed = true;
}
else if (response == Packet.Error)
{
errorString = reader.ReadString();
Debug.LogWarning(errorString);
changed = true;
}
}
catch (System.Exception) { }
}
buffer.Recycle();
}
// Clean up old servers
if (knownServers.Cleanup(time))
{
changed = true;
}
// Trigger the listener callback
if (changed && onChange != null)
{
onChange();
}
else if (mNextSend < time && mUdp != null)
{
// Send out the update request
mNextSend = time + 3000;
mUdp.Send(mRequest, mRemoteAddress);
}
}
/// <summary>
/// Thread that will be processing incoming data.
/// </summary>
void ThreadFunction()
{
for (; ;)
{
Buffer buffer;
bool received = false;
mTime = DateTime.Now.Ticks / 10000;
IPEndPoint ip;
// Stop the listener if the port is 0 (MakePrivate() was called)
if (mListenerPort == 0)
{
if (mListener != null)
{
mListener.Stop();
mListener = null;
if (lobbyLink != null)
{
lobbyLink.Stop();
}
if (onShutdown != null)
{
onShutdown();
}
}
}
else
{
// Add all pending connections
while (mListener != null && mListener.Pending())
{
#if STANDALONE
TcpPlayer p = AddPlayer(mListener.AcceptSocket());
Console.WriteLine(p.address + " has connected");
#else
AddPlayer(mListener.AcceptSocket());
#endif
}
}
// Process datagrams first
while (mUdp.listeningPort != 0 && mUdp.ReceivePacket(out buffer, out ip))
{
if (buffer.size > 0)
{
TcpPlayer player = GetPlayer(ip);
if (player != null)
{
try
{
if (ProcessPlayerPacket(buffer, player, false))
{
received = true;
}
}
catch (System.Exception) { RemovePlayer(player); }
}
}
buffer.Recycle();
}
// Process player connections next
for (int i = 0; i < mPlayers.size;)
{
TcpPlayer player = mPlayers[i];
// Process up to 100 packets at a time
for (int b = 0; b < 100 && player.ReceivePacket(out buffer); ++b)
{
if (buffer.size > 0)
{
try
{
if (ProcessPlayerPacket(buffer, player, true))
{
received = true;
}
}
#if STANDALONE
catch (System.Exception ex)
{
Console.WriteLine("ERROR (ProcessPlayerPacket): " + ex.Message);
RemovePlayer(player);
}
#else
catch (System.Exception) { RemovePlayer(player); }
#endif
}
buffer.Recycle();
}
// Time out -- disconnect this player
if (player.stage == TcpProtocol.Stage.Connected)
{
// Up to 10 seconds can go without a single packet before the player is removed
if (player.lastReceivedTime + 10000 < mTime)
{
#if STANDALONE
Console.WriteLine(player.address + " has timed out");
#endif
RemovePlayer(player);
continue;
}
}
else if (player.lastReceivedTime + 2000 < mTime)
{
#if STANDALONE
Console.WriteLine(player.address + " has timed out");
#endif
RemovePlayer(player);
continue;
}
++i;
}
if (!received)
{
Thread.Sleep(1);
}
}
}
