public bool shouldUpdate(double delta)
{
double currentTime = TimeSource.clockTime();
if (currentTime >= myNextUpdate)
{
myNextUpdate = currentTime + myUpdateFrequency;
return(true);
}
return(false);
}
void handleClient(object client)
{
TcpClient tcpClient = (TcpClient)client;
//2MB buffers, should help with overflow conditions
tcpClient.ReceiveBufferSize = 1024 * 1024 * 20;
tcpClient.SendBufferSize = 1024 * 1024 * 20;
NetworkStream clientStream = tcpClient.GetStream();
ConcurrentQueue <Event> myEventQueue = new ConcurrentQueue <Event>();
myClientQueues.Add(myEventQueue);
if (onClientConnected != null)
{
onClientConnected(tcpClient);
}
byte[] header = new byte[1000];
byte[] tempBuffer = new byte[4096];
byte[] messageBuffer;
Int32 bytesRead;
while (myShouldQuit == false)
{
bytesRead = 0;
try
{
double readTime = TimeSource.currentTime() + 0.25; //poll socket for 1/4 a second before giving up
while (clientStream.DataAvailable == true && TimeSource.clockTime() < readTime)
{
//blocks until a client sends a message, then just read the size of the message
bytesRead = clientStream.Read(header, 0, 4);
Int32 msgSize = BitConverter.ToInt32(header, 0);
if (msgSize == Int32.MaxValue) //this is a shutdown request
{
break;
}
if (msgSize > (1024 * 64)) // a reasonable number
{
throw new Exception("Message received is too big");
}
messageBuffer = new byte[msgSize];
int bytesReceived = bytesRead;
//copy the size of the message into the buffer, since this is important for decoding
Array.Copy(header, 0, messageBuffer, 0, bytesReceived);
//read the rest of this message
while (bytesReceived < msgSize)
{
int bytesToRead = 0;
if ((msgSize - bytesReceived) > 4096)
{
bytesReceived = 4096;
}
else
{
bytesToRead = msgSize - bytesReceived;
}
bytesRead = clientStream.Read(tempBuffer, 0, bytesToRead);
Array.Copy(tempBuffer, 0, messageBuffer, bytesReceived, bytesRead);
bytesReceived += bytesRead;
}
//we got it all, so decode it, and send it off
Event e = Event.decode(ref messageBuffer);
bool filtered = false;
if (filterReceiveEvent != null)
{
if (filterReceiveEvent(e, tcpClient) == true)
{
filtered = true;
}
}
if (filtered == false)
{
if (receivedEvent != null)
{
receivedEvent(e, tcpClient);
}
}
}
}
catch
{
//a socket error has occurred
break;
}
//send any waiting messages
double writeTime = TimeSource.currentTime() + 0.25;
Event evt = null;
while (myEventQueue.TryDequeue(out evt) == true && TimeSource.clockTime() < writeTime)
{
bool filtered = false;
if (filterSendEvent != null)
{
filtered = filterSendEvent(evt, tcpClient);
}
if (filtered == false)
{
try
{
if (sendingEvent != null)
{
sendingEvent(evt, tcpClient);
}
//Debug.print("Fullfilled request for chunk: {0}", tr.chunkId);
byte[] msg = evt.encode();
clientStream.Write(msg, 0, msg.Length);
clientStream.Flush();
}
catch
{
//a socket error has occurred
break;
}
}
}
//the client has disconnected from the server
if (tcpClient.Connected == false)
{
break;
}
Thread.Sleep(1);
}
tcpClient.Close();
}
public bool tick(double minSeconds, double maxSeconds)
{
processedMessages = 0;
double startTime = TimeSource.clockTime();
double minTime = minSeconds == -1.0 ? startTime : startTime + minSeconds;
double maxTime = maxSeconds == -1.0 ? startTime + 1000000.0 : startTime + maxSeconds;
myIsTicking = true;
//determine number of messages to process for this frame
int count = myEventQueue.Count;
int runningTasks = 0;
//keep looping if we have time
while (TimeSource.currentTime() < maxTime && processedMessages < count)
{
Event e;
//no message available, sleep until min time is met
if (!myEventQueue.TryDequeue(out e))
{
break;
}
processedMessages++;
//is it time to process this event (i.e enough delay has passed)
if (TimeSource.currentTime() - e.timeStamp < e.delay)
{
//still has time left, put it back on the queue
myEventQueue.Enqueue(e);
continue;
}
EventResult res = dispatchEvent(e);
}
//wait for running tasks to finish
while (runningTasks > 0)
{
System.Threading.Thread.Sleep(0);
}
myIsTicking = false;
//handle any changes that may have occurred during event processing
//can't do this during event processing since it may invalidate
//iterators
EventListenerInfo eli;
while (myPendingAdds.TryDequeue(out eli))
{
registerEvent(eli.eventName);
myRootEventListener.addEventListener(eli.func, eli.eventName);
}
while (myPendingRemoves.TryDequeue(out eli))
{
myRootEventListener.removeEventListener(eli.func, eli.eventName);
}
//sleep for the rest of the time
double now = TimeSource.clockTime();
if (now < minTime)
{
double sleepTime = minTime - now;
Thread.Sleep((int)(sleepTime * 1000.0f));
}
return(true);
}
