public bool ExecuteNextFrame(out RC.Common.RCPackage[] outgoingCmds)
{
TraceManager.WriteAllTrace("SIMULATOR_CALL:", TestConsoleTraceFilters.TEST_INFO);
TraceManager.WriteAllTrace(string.Format("Counter = {0}", this.counter), TestConsoleTraceFilters.TEST_INFO);
int currTime = (int)this.localTime.ElapsedMilliseconds;
TraceManager.WriteAllTrace(string.Format("TimeSinceLastFrame = {0}", (currTime - this.timeOfLastFrame)), TestConsoleTraceFilters.TEST_INFO);
this.avg.NewItem(currTime - this.timeOfLastFrame);
TraceManager.WriteAllTrace(string.Format("AvgTimeBetweenFrames = {0}", this.avg.Average), TestConsoleTraceFilters.TEST_INFO);
this.timeOfLastFrame = currTime;
this.counter++;
outgoingCmds = null;
RCThread.Sleep(35);
return(true);
}
public bool CreateFrameFinish(long timeSinceLastFrameFinish, long timeSinceThisFrameBegin, long timeSinceDrawFinish)
{
if (!this.formClosing.WaitOne(0))
{
if (timeSinceLastFrameFinish < 30)
{
int waitTime = (int)(30 - timeSinceLastFrameFinish);
RCThread.Sleep(waitTime);
}
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// The starting function of the connection manager thread.
/// </summary>
private void ConnectionManagerProc()
{
/// Create the necessary objects.
Stopwatch cycleStopWatch = new Stopwatch();
Stopwatch connAcceptStopWatch = new Stopwatch();
connAcceptStopWatch.Restart();
/// This call is only for callback the listener.
SendLineStateReports();
do
{
cycleStopWatch.Restart();
/// First we execute the tasks
ExecuteTasks();
/// Then we accept the next incoming connection if this is the time to do it.
if (connAcceptStopWatch.ElapsedMilliseconds > NetworkingSystemConstants.CONNECTION_ACCEPT_FREQUENCY)
{
List <LobbyLineState[]> reportsToSend = new List <LobbyLineState[]>();
lock (this.tasks)
{
/// Execute every tasks just before we accept the next connection. It is needed to
/// lock the tasks FIFO, because we want to be sure that the FIFO is empty when
/// a new connection is accepted.
ExecuteTasks(ref reportsToSend);
/// We can accept the next connection after we have processed all outgoing messages and the
/// FIFO is empty.
AcceptNextConnection(ref reportsToSend);
}
foreach (LobbyLineState[] report in reportsToSend)
{
SendLineStateReports(report);
}
connAcceptStopWatch.Restart();
}
/// Then we read and process all incoming messages.
ProcessIncomingMessages();
/// And finally we send ping messages if necessary.
for (int i = 0; i < this.connections.Length; i++)
{
if (this.connections[i].ConnectionState == LobbyConnectionState.Connected)
{
if (!this.connections[i].SendPingIfNecessary())
{
/// Error --> immediate shutdown.
this.connections[i].Shutdown();
this.connections[i].LineState = LobbyLineState.Opened; /// Keep it opened for other clients.
SendLineStateReports();
}
}
}
} while (!this.stopConnectionManagerThread.WaitOne(
Math.Max(NetworkingSystemConstants.SERVER_CONNECTION_MANAGER_CYCLE_TIME - (int)cycleStopWatch.ElapsedMilliseconds, 0)));
ExecuteTasks();
/// LobbyServer shutdown is initiated.
while (true)
{
/// Initiate disconnect to every clients.
for (int i = 0; i < this.connections.Length; i++)
{
if (this.connections[i].ConnectionState == LobbyConnectionState.Connected)
{
this.connections[i].BeginDisconnect();
}
else if (this.connections[i].ConnectionState == LobbyConnectionState.Disconnecting)
{
this.connections[i].ContinueDisconnect();
}
}
/// Wait for a while.
RCThread.Sleep(NetworkingSystemConstants.SERVER_CONNECTION_MANAGER_CYCLE_TIME);
/// Check if everybody has been disconnected or not.
bool connectedClientExists = false;
for (int i = 0; i < this.connections.Length; i++)
{
if (this.connections[i].ConnectionState != LobbyConnectionState.Disconnected)
{
connectedClientExists = true;
break;
}
}
/// If everybody has been disconnected we can finish the thread.
if (!connectedClientExists)
{
break;
}
}
}
/// <summary>
/// This is the starting function of the connection manager thread.
/// </summary>
private void ConnectionManagerProc()
{
Stopwatch stopWatch = new Stopwatch();
if (!this.connection.BeginConnectToTheServer(this.serverEndpoint))
{
/// Connection failed at the beginning --> Stop the connection manager thread.
this.connection.Shutdown();
if (this.Disposed != null)
{
this.Disposed(this);
}
this.listener.LobbyLost();
return;
}
do
{
stopWatch.Restart();
if (this.connection.ConnectionState == LobbyConnectionState.Connecting)
{
/// We must wait for the first line state report.
if (!ContinueConnectToTheServer())
{
/// There was an error, so finish the connection manager thread.
return;
}
}
else if (this.connection.ConnectionState == LobbyConnectionState.Connected)
{
/// Normal message processing.
if (!ProcessIncomingMessages())
{
/// Connection manager thread has to stop.
return;
}
/// Sending outgoing messages
if (!SendOutgoingMessages())
{
/// Connection manager thread has to stop.
return;
}
if (!this.connection.SendPingIfNecessary())
{
/// Connection manager thread has to stop.
this.connection.Shutdown();
if (this.Disposed != null)
{
this.Disposed(this);
}
this.listener.LobbyLost();
return;
}
}
else
{
/// Unexpected state --> FATAL ERROR
throw new NetworkingSystemException("Unexpected connection state!");
}
} while (!this.stopConnectionManagerThread.WaitOne(
Math.Max(NetworkingSystemConstants.CLIENT_CONNECTION_MANAGER_CYCLE_TIME - (int)stopWatch.ElapsedMilliseconds, 0)));
/// Send the remaining outgoing messages to the server.
SendOutgoingMessages();
/// LobbyClient shutdown is initiated.
while (true)
{
if (this.connection.ConnectionState == LobbyConnectionState.Connected)
{
/// Initiate disconnect from the server
this.connection.BeginDisconnect();
}
else if (this.connection.ConnectionState == LobbyConnectionState.Disconnecting)
{
if (this.connection.ContinueDisconnect())
{
/// Disconnect finished --> Stop the connection manager thread.
return;
}
}
/// Wait for a while.
RCThread.Sleep(NetworkingSystemConstants.CLIENT_CONNECTION_MANAGER_CYCLE_TIME);
}
}
