public static void Update()
{
timeout.Restart();
if (Connection != null)
{
Connection.ReadMessages(Messages);
while (Messages.Count != 0 && timeout.ElapsedMilliseconds < TimeoutMilliseconds)
{
NetIncomingMessage msg = Messages[0];
Messages.RemoveAt(0);
Message.Handle(msg);
}
}
}
public void Update(GameTime gameTime)
{
nextSendUpdates = NetTime.Now;
var listOfIncomingMessages = new List <NetIncomingMessage>();
var nMessages = peer.ReadMessages(listOfIncomingMessages);
foreach (var message in listOfIncomingMessages)
{
sentDataGametime = gameTime.ElapsedGameTime.TotalMilliseconds;
//RECIEVE DATA
switch (message.MessageType)
{
case NetIncomingMessageType.DiscoveryRequest:
// Create a response and write some example data to it
NetOutgoingMessage response = peer.CreateMessage();
response.Write(NetworkHelper.GetCurrentIPAddress());
// Send the response to the sender of the request
peer.SendDiscoveryResponse(response, message.SenderEndPoint);
break;
case NetIncomingMessageType.DiscoveryResponse:
Console.WriteLine("Found server at " + message.SenderEndPoint + " name: " + message.ReadString());
break;
case NetIncomingMessageType.Data:
Console.WriteLine("Incoming game-data");
//Recieves data and puts it in the networkInputComponent for the remote player entity
if (remotePlayerEntity != null)
{
var transformComponent = ComponentManager.Instance.GetComponentOfEntity <TransformComponent>(remotePlayerEntity);
//Console.WriteLine(transformComponent.Position.ToString());
var velocityComponent = ComponentManager.Instance.GetComponentOfEntity <VelocityComponent>(remotePlayerEntity);
var posx = message.ReadFloat();
var posy = message.ReadFloat();
var posz = message.ReadFloat();
var velx = message.ReadFloat();
var vely = message.ReadFloat();
var velz = message.ReadFloat();
velocityComponent.Velocity = new Vector3(velx, vely, velz);
transformComponent.Position = new Vector3(posx, posy, posz);
}
break;
case NetIncomingMessageType.StatusChanged:
// handle connection status messages
NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
if (status == NetConnectionStatus.RespondedConnect)
{
Console.WriteLine(NetUtility.ToHexString(message.SenderConnection.RemoteUniqueIdentifier) + " responded to connection!");
}
if (status == NetConnectionStatus.Connected)
{
Console.WriteLine(NetUtility.ToHexString(message.SenderConnection.RemoteUniqueIdentifier) + " connected, yay!");
}
if (status == NetConnectionStatus.Disconnecting)
{
Console.WriteLine(message.SenderConnection.RemoteUniqueIdentifier + " disconnected!");
//should we shut down th server if the client disconnects?
peer.Shutdown("bye!");
}
break;
case NetIncomingMessageType.DebugMessage:
// handle debug messages
// (only received when compiled in DEBUG mode)
Console.WriteLine(message.ReadString());
break;
/* .. */
default:
Console.WriteLine("unhandled message with type: "
+ message.MessageType);
break;
}
}
/********************************************************************************************************/
/*********************************************SEND DATA**************************************************/
/********************************************************************************************************/
currentTime = NetTime.Now;
if (currentTime > nextSendUpdates)
{
foreach (NetConnection player in peer.Connections)
{
NetOutgoingMessage om = peer.CreateMessage();
//sends data over the network to the host/client
var transformComponent = ComponentManager.Instance.GetComponentOfEntity <TransformComponent>(localPlayerEntity);
var velocityComponent = ComponentManager.Instance.GetComponentOfEntity <VelocityComponent>(localPlayerEntity);
om.Write(transformComponent.Position.X);
om.Write(transformComponent.Position.Y);
om.Write(transformComponent.Position.Z);
om.Write(velocityComponent.Velocity.X);
om.Write(velocityComponent.Velocity.Y);
om.Write(velocityComponent.Velocity.Z);
peer.SendMessage(om, player, NetDeliveryMethod.UnreliableSequenced);
if (runDiagnostics)
{
Diagnostics(om, gameTime);
}
}
//send data 30 times per second
nextSendUpdates += (1.0 / 30.0);
}
if (nMessages > 0)
{
Console.WriteLine(nMessages + " incoming messages!");
}
}
// Update is called once per frame
virtual public void Update()
{
// See if the network connection has been created
if (connection == null)
{
return;
}
float initialTime = Time.realtimeSinceStartup;
double netTime = GetTime();
int statusMessages = 0;
int dataMessages = 0;
int connectionMessages = 0;
int debugMessage = 0;
int warningMessages = 0;
int errorMessages = 0;
int otherMessages = 0;
// Read any new messages from the network
List <NetIncomingMessage> msg = new List <NetIncomingMessage>();
int msgCount = connection.ReadMessages(msg);
for (int i = 0; i < msgCount; i++)
{
switch (msg[i].MessageType)
{
// See https://code.google.com/p/lidgren-network-gen3/wiki/IncomingMessageTypes
case NetIncomingMessageType.StatusChanged:
statusMessages++;
HandleMessage_StatusChanged(msg[i]);
break;
case NetIncomingMessageType.Data:
dataMessages++;
HandleMessage_Data(msg[i]);
break;
case NetIncomingMessageType.ConnectionApproval:
connectionMessages++;
HandleMessage_ConnectionApproval(msg[i]);
break;
case NetIncomingMessageType.ConnectionLatencyUpdated:
connectionMessages++;
HandleMessage_ConnectionLatencyUpdated(msg[i]);
break;
// Error/Warning messages
case NetIncomingMessageType.DebugMessage:
debugMessage++;
HandleMessage_DebugMessage(msg[i]);
break;
case NetIncomingMessageType.VerboseDebugMessage:
debugMessage++;
HandleMessage_VerboseDebugMessage(msg[i]);
break;
case NetIncomingMessageType.WarningMessage:
warningMessages++;
HandleMessage_WarningMessage(msg[i]);
break;
case NetIncomingMessageType.ErrorMessage:
errorMessages++;
HandleMessage_ErrorMessage(msg[i]);
break;
// Messages types we shouldn't have to deal with
case NetIncomingMessageType.Error:
case NetIncomingMessageType.UnconnectedData:
case NetIncomingMessageType.DiscoveryRequest:
case NetIncomingMessageType.DiscoveryResponse:
case NetIncomingMessageType.NatIntroductionSuccess:
case NetIncomingMessageType.Receipt:
default:
otherMessages++;
Debug.LogError("Unhandled network message type: " + msg[i].MessageType);
break;
}
connection.Recycle(msg[i]);
}
float deltaTime = (Time.realtimeSinceStartup - initialTime);
int messagesProcessed = statusMessages + dataMessages + connectionMessages + debugMessage + warningMessages + errorMessages + otherMessages;
if (messagesProcessed >= 100 || deltaTime > 1.0f)
{
Debug.Log(GetTime() + ": NetTime:" + netTime + " " + messagesProcessed + " network messages proccessed in " + (Time.realtimeSinceStartup - initialTime).ToString() + " seconds" +
"\n\t statusMessages: " + statusMessages +
"\n\t dataMessages: " + dataMessages +
"\n\t connectionMessages: " + connectionMessages +
"\n\t debugMessage: " + debugMessage +
"\n\t warningMessages: " + warningMessages +
"\n\t errorMessages: " + errorMessages +
"\n\t otherMessages: " + otherMessages
);
}
}
