internal override void Read(NetIncomingMessage Message)
{
Name = Message.ReadString();
if (!Guid.TryParse(Message.ReadString(), out CurrentConfigurationID)) {
throw new Exception("Unable to parse GUID for CurrentConfig in server info.");
}
}
public override void FromNetMsg(NetIncomingMessage netMsg)
{
// Here we assume that typeID was read before to determine which kind of message it was.
m_senderName = netMsg.ReadString();
m_group = netMsg.ReadString();
m_message = netMsg.ReadString();
}
internal override void Read(NetIncomingMessage Message)
{
base.Read(Message);
Language = (CodeLanguage)Enum.Parse(typeof(CodeLanguage), Message.ReadString());
Location = (CodeLocation)Enum.Parse(typeof(CodeLocation), Message.ReadString());
Source = Message.ReadString();
}
/// <summary>
/// Reads the transport into the contents of this type.
/// </summary>
public void ReadPayload(NetIncomingMessage message)
{
Identity = message.ReadString();
NovaId = message.ReadString();
PasswordHash = message.ReadString();
PublicEndPoint = message.ReadIPEndpoint();
PrivateEndPoint = message.ReadIPEndpoint();
}
public override void onclientrecieve(NetIncomingMessage message)
{
string id = message.ReadString();
string text = message.ReadString();
Console.WriteLine(text);
base.onclientrecieve(message);
}
public ConnectionMessage(NetIncomingMessage msg)
{
string encryptedUsername = msg.ReadString();
string encryptedPassword = msg.ReadString();
byte[] xUsername = Xor(Encoding.UTF8.GetBytes(encryptedUsername), EncryptionKey);
byte[] xPassword = Xor(Encoding.UTF8.GetBytes(encryptedPassword), EncryptionKey);
Username = Encoding.UTF8.GetChars(xUsername).ToString();
Password = Encoding.UTF8.GetChars(xPassword).ToString();
}
public void Decode(NetIncomingMessage im)
{
this.Username = im.ReadString();
this.Password = im.ReadString();
this.Color = ColorExtensions.ColorFromHSV(im.ReadInt16(), Client.IO.ColorSaturation / 255f, Client.IO.ColorValue / 255f);
if (Username.Length > Settings.MaxNameLength) //Clamp name length
Username = Username.Truncate(Settings.MaxNameLength);
}
public virtual S2C.Message.NotifySend NotifySend(NetIncomingMessage im)
{
Message.NotifySend data = new Message.NotifySend();
data.from_id = im.ReadString();
data.message = im.ReadString();
if(OnNotifySend != null) OnNotifySend(im, data);
return data;
}
public virtual C2S.Message.ReqSend ReqSend(NetIncomingMessage im)
{
Message.ReqSend data = new Message.ReqSend();
data.to_id = im.ReadString();
data.message = im.ReadString();
if(OnReqSend != null) OnReqSend(im, data);
return data;
}
public static PlayerInformation Read(NetIncomingMessage packet)
{
Byte slot = packet.ReadByte();
TeamType team = (TeamType)packet.ReadByte();
String callsign = packet.ReadString();
String tag = packet.ReadString();
return new PlayerInformation(slot, callsign, tag, team);
}
public override void onserverrecieve(NetIncomingMessage message)
{
var chat = PacketWriter.write<Packet_Chat>(NetEndpoint.SERVER);
chat.outgoingmessage.Write(message.ReadString());
chat.outgoingmessage.Write(message.ReadString());
chat.send();
base.onserverrecieve(message);
}
public virtual S2C.Message.ResSend ResSend(NetIncomingMessage im)
{
Message.ResSend data = new Message.ResSend();
data.ret = im.ReadInt16();
data.ret_message = im.ReadString();
data.to_id = im.ReadString();
if(OnResSend != null) OnResSend(im, data);
return data;
}
public override void OnDataReceived(NetIncomingMessage incMsg)
{
NetDataType type = (NetDataType)incMsg.ReadByte();
if (type == NetDataType.eDATA_REQUEST_LOGIN)
{
string accountName = incMsg.ReadString();
string password = incMsg.ReadString();
Login(accountName, password, incMsg.SenderConnection);
}
}
protected void IncomingChangeLevel(NetIncomingMessage msg)
{
string levelName = msg.ReadString();
string levelData = msg.ReadString();
double delayTime = double.Parse(msg.ReadString());
double recieveTime = msg.ReceiveTime / 1000;
double actualDelayTime = delayTime - recieveTime;
DownloadLevel(levelName, levelData);
OnChangedLevel(levelName, actualDelayTime);
}
public void Decode(NetIncomingMessage im)
{
this.ServerName = im.ReadString();
this.Description = im.ReadString();
this.Intro = im.ReadString();
this.Online = im.ReadByte();
int roomsLength = im.ReadByte();
for (int i = 0; i < roomsLength; i++)
{
Rooms.Add(new LobbySaveData(im.ReadString(), im.ReadInt16(), im.ReadString(), im.ReadByte(), im.ReadInt16(), im.ReadDouble()));
}
}
public void PopulateFromMsg(NetIncomingMessage msg)
{
m_serverName = msg.ReadString();
m_serverType = (NetServerType)msg.ReadByte();
m_serverInternalAdress = msg.ReadIPEndPoint();
m_serverExternalAdress = msg.SenderEndPoint;
m_currentNbPlayers = msg.ReadInt32();
m_maxPlayers = msg.ReadInt32();
m_NATtoken = msg.ReadString();
m_lastContact = DateTime.Now;
}
// TODO: Merge opcodes for move direction, something like that: Move(LookDirection)
void DataProcessing(NetIncomingMessage message, ref Client client)
{
switch (message.ReadByte())
{
case (byte)MessageType.ClientMessage.NeedMap:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Need map ! Let's give it to him :)");
ReceiveNeedMap(client);
break;
case (byte)MessageType.ClientMessage.MapSelection:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Has selected a map to play ! :)");
ReceiveMapSelection(client, message.ReadString());
break;
case (byte)MessageType.ClientMessage.Credentials:
ReceiveCredentials(client, message.ReadString(), message.ReadString());
break;
case (byte)MessageType.ClientMessage.Ready:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Ready message !");
ReceiveReady(client, message.ReadBoolean());
break;
case (byte)MessageType.ClientMessage.WantToStartGame:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] WantToStartGame message !");
ReceiveWantToStartGame();
break;
case (byte)MessageType.ClientMessage.HasMap:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] HasMap message !");
ReceiveHasMap(client);
break;
case (byte)MessageType.ClientMessage.MoveDown:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move down !");
ReceiveMovePlayer(client, LookDirection.Down);
break;
case (byte)MessageType.ClientMessage.MoveLeft:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move left !");
ReceiveMovePlayer(client, LookDirection.Left);
break;
case (byte)MessageType.ClientMessage.MoveRight:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move right !");
ReceiveMovePlayer(client, LookDirection.Right);
break;
case (byte)MessageType.ClientMessage.MoveUp:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to move up !");
ReceiveMovePlayer(client, LookDirection.Up);
break;
case (byte)MessageType.ClientMessage.Standing:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to stay here !");
ReceiveMovePlayer(client, LookDirection.Idle, message.ReadTime(client.ClientConnection, true));
break;
case (byte)MessageType.ClientMessage.PlaceBomb:
Program.Log.Info("[RECEIVE][Client #" + client.ClientId + "] Want to place bomb !");
ReceiveBombPlacing(client);
break;
}
}
public override void onclientrecieve(NetIncomingMessage message)
{
Client.print("info", "Recieve qb packet");
StopwatchUtil.startclient("qbpacket", "Building qb model");
int junk = message.ReadInt32();
QbModel model = new QbModel(message.ReadString());
int matrixcount = message.ReadInt32();
model.setmatrixcount((uint)matrixcount);
foreach (var m in model.matrices)
{
m.name = message.ReadString();
m.position = new OpenTK.Vector3(message.ReadFloat(), message.ReadFloat(), message.ReadFloat());
m.setsize((int)message.ReadFloat(), (int)message.ReadFloat(), (int)message.ReadFloat());
int colorcount = message.ReadInt32();
for (int i = 0; i < colorcount; i++)
{
m.GetColorIndex(message.ReadFloat(), message.ReadFloat(), message.ReadFloat());
}
int voxelcount = message.ReadInt32();
for (int i = 0; i < voxelcount; i++)
{
int colorindex = message.ReadInt32();
byte alphamask = message.ReadByte();
int x = message.ReadInt32();
int y = message.ReadInt32();
int z = message.ReadInt32();
m.voxels.GetOrAdd(m.GetHash(x, y, z), new Voxel((short)x, (short)y, (short)z, alphamask, (short)colorindex));
}
}
Client.OpenGLContextThread.Add(() =>
{
model.GenerateVertexBuffers();
model.FillVertexBuffers();
Singleton<QbManager>.INSTANCE.AddModel(model);
StopwatchUtil.stopclient("qbpacket", "End building qb model");
});
base.onclientrecieve(message);
}
public void Decode(NetIncomingMessage im)
{
this.Value = (ResultOfAttack) im.ReadInt32();
this.Text = im.ReadString();
this.Row = im.ReadInt32();
this.Col = im.ReadInt32();
}
public override void Read(NetIncomingMessage msg)
{
Id = msg.ReadUInt16();
int count = msg.ReadInt32();
for(int i = 0; i < count; ++i)
Cards.Add(msg.ReadString());
}
private void ReadData(AttributeTypeID Type, NetIncomingMessage Message)
{
switch(Type) {
case AttributeTypeID.Float:
Data = Message.ReadFloat();
break;
case AttributeTypeID.Int:
Data = Message.ReadInt32();
break;
case AttributeTypeID.List:
Console.WriteLine("AttributeSystem: List<> Type not supported on network sync");
break;
case AttributeTypeID.Long:
Data = Message.ReadInt64();
break;
case AttributeTypeID.Rectangle:
Data = Message.ReadRectangle();
break;
case AttributeTypeID.String:
Data = Message.ReadString();
break;
case AttributeTypeID.Vector2:
Data = Message.ReadVector2();
break;
case AttributeTypeID.Bool:
Data = Message.ReadBoolean();
break;
default:
Console.WriteLine("Invalid Attribute Type: {0}", Type.ToString());
break;
}
}
internal void Read(NetIncomingMessage Message)
{
if (!Guid.TryParse(Message.ReadString(), out TextureID)) {
throw new Exception("Failed to parse Guid in FSTextureReference");
}
Location = (BlockSide)Message.ReadInt32();
}
public void Read(NetIncomingMessage nim)
{
if (!Guid.TryParse(nim.ReadString(), out BlockTypeID)) {
throw new Exception("Failed to read GUID");
}
Level = nim.ReadInt32();
}
protected override void ReadData(NetIncomingMessage Message)
{
if (!Guid.TryParse(Message.ReadString(), out parent)) {
throw new Exception("Failed to pare parent for folder");
}
folder.Read(Message);
}
protected override void ReadData(NetIncomingMessage Message)
{
if (!Guid.TryParse(Message.ReadString(), out parent)) {
throw new Exception("Could not parse parent guid for block type");
}
blockType.Read(Message);
}
public void HandleData(NetIncomingMessage msg)
{
string data = msg.ReadString();
NetCommand[] commands = NetParser.Parse(data);
foreach (var command in commands)
{
switch (command.Type)
{
case 'a': // Add a new player into the mix
break;
case 'd': // deletes a player from the mix
break;
case 'i': // Intention update
Players[command.PlayerIndex].Movement.Intention = new Intention(data.Substring(2, 4));
break;
case 'r': // Refresh Player
string[] bits = command.Value.Split(',');
Players[command.PlayerIndex].Movement.Area.X = Int32.Parse(bits[0]);
Players[command.PlayerIndex].Movement.Area.Y = Int32.Parse(bits[1]);
break;
case 'c': // Chat Message
break;
case 'p': // Pushback
break;
}
}
}
public void Decode(NetIncomingMessage im)
{
this.Username = im.ReadString();
this.ID = im.ReadByte();
this.Me = im.ReadBoolean();
this.Color = new Color(im.ReadByte(), im.ReadByte(), im.ReadByte());
}
public override void onclientrecieve(NetIncomingMessage message)
{
int matrixid = message.ReadInt32();
string name = message.ReadString();
base.onclientrecieve(message);
}
private void Data(NetIncomingMessage inc)
{
var packetType = (PacketType) inc.ReadByte();
var gameRoom = GetGameRoomById(inc.ReadString());
var command = PacketFactory.GetCommand(packetType);
command.Run(_managerLogger, this,inc, null, gameRoom);
}
public void Decode(NetIncomingMessage im)
{
this.ID = im.ReadByte();
this.Message = im.ReadString();
if (Message.Length > Networking.Messages.ChatMessage.MaxLength)
Message= Message.Truncate(Networking.Messages.ChatMessage.MaxLength);
}
internal void ReceivedHandshake(NetMessageType tp, int ptr, int payloadLength)
{
m_peer.VerifyNetworkThread();
byte[] hail;
switch (tp)
{
case NetMessageType.Connect:
if (m_status == NetConnectionStatus.None)
{
// Whee! Server full has already been checked
bool ok = ValidateHandshakeData(ptr, payloadLength, out hail);
if (ok)
{
if (hail != null)
{
m_remoteHailMessage = m_peer.CreateIncomingMessage(NetIncomingMessageType.Data, hail);
m_remoteHailMessage.LengthBits = (hail.Length * 8);
}
else
{
m_remoteHailMessage = null;
}
if (m_peerConfiguration.IsMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval))
{
// ok, let's not add connection just yet
NetIncomingMessage appMsg = m_peer.CreateIncomingMessage(NetIncomingMessageType.ConnectionApproval, (m_remoteHailMessage == null ? 0 : m_remoteHailMessage.LengthBytes));
appMsg.m_senderConnection = this;
appMsg.m_senderEndpoint = this.m_remoteEndpoint;
if (m_remoteHailMessage != null)
{
appMsg.Write(m_remoteHailMessage.m_data, 0, m_remoteHailMessage.LengthBytes);
}
m_peer.ReleaseMessage(appMsg);
return;
}
SendConnectResponse(true);
}
return;
}
if (m_status == NetConnectionStatus.RespondedConnect)
{
// our ConnectResponse must have been lost
SendConnectResponse(true);
return;
}
m_peer.LogDebug("Unhandled Connect: " + tp + ", status is " + m_status + " length: " + payloadLength);
break;
case NetMessageType.ConnectResponse:
switch (m_status)
{
case NetConnectionStatus.InitiatedConnect:
// awesome
bool ok = ValidateHandshakeData(ptr, payloadLength, out hail);
if (ok)
{
if (hail != null)
{
m_remoteHailMessage = m_peer.CreateIncomingMessage(NetIncomingMessageType.Data, hail);
m_remoteHailMessage.LengthBits = (hail.Length * 8);
}
else
{
m_remoteHailMessage = null;
}
m_peer.AcceptConnection(this);
SendConnectionEstablished();
return;
}
break;
case NetConnectionStatus.RespondedConnect:
// hello, wtf?
break;
case NetConnectionStatus.Disconnecting:
case NetConnectionStatus.Disconnected:
case NetConnectionStatus.None:
// wtf? anyway, bye!
break;
case NetConnectionStatus.Connected:
// my ConnectionEstablished must have been lost, send another one
SendConnectionEstablished();
return;
}
break;
case NetMessageType.ConnectionEstablished:
switch (m_status)
{
case NetConnectionStatus.Connected:
// ok...
break;
case NetConnectionStatus.Disconnected:
case NetConnectionStatus.Disconnecting:
case NetConnectionStatus.None:
// too bad, almost made it
break;
case NetConnectionStatus.InitiatedConnect:
// weird, should have been ConnectResponse...
break;
case NetConnectionStatus.RespondedConnect:
// awesome
m_peer.AcceptConnection(this);
InitializePing();
SetStatus(NetConnectionStatus.Connected, "Connected to " + NetUtility.ToHexString(m_remoteUniqueIdentifier));
return;
}
break;
case NetMessageType.Disconnect:
// ouch
string reason = "Ouch";
try
{
NetIncomingMessage inc = m_peer.SetupReadHelperMessage(ptr, payloadLength);
reason = inc.ReadString();
}
catch
{
}
SetStatus(NetConnectionStatus.Disconnected, reason);
break;
default:
m_peer.LogDebug("Unhandled type during handshake: " + tp + " length: " + payloadLength);
break;
}
}
internal void ReceivedHandshake(double now, NetMessageType tp, int ptr, int payloadLength)
{
m_peer.VerifyNetworkThread();
byte[] hail;
switch (tp)
{
case NetMessageType.Connect:
if (m_status == NetConnectionStatus.ReceivedInitiation)
{
// Whee! Server full has already been checked
bool ok = ValidateHandshakeData(ptr, payloadLength, out hail);
if (ok)
{
if (hail != null)
{
m_remoteHailMessage = m_peer.CreateIncomingMessage(NetIncomingMessageType.Data, hail);
m_remoteHailMessage.LengthBits = (hail.Length * 8);
}
else
{
m_remoteHailMessage = null;
}
if (m_peerConfiguration.IsMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval))
{
// ok, let's not add connection just yet
NetIncomingMessage appMsg = m_peer.CreateIncomingMessage(NetIncomingMessageType.ConnectionApproval, (m_remoteHailMessage == null ? 0 : m_remoteHailMessage.LengthBytes));
appMsg.m_receiveTime = now;
appMsg.m_senderConnection = this;
appMsg.m_senderEndPoint = this.m_remoteEndPoint;
if (m_remoteHailMessage != null)
{
appMsg.Write(m_remoteHailMessage.m_data, 0, m_remoteHailMessage.LengthBytes);
}
SetStatus(NetConnectionStatus.RespondedAwaitingApproval, "Awaiting approval");
m_peer.ReleaseMessage(appMsg);
return;
}
SendConnectResponse((float)now, true);
}
return;
}
if (m_status == NetConnectionStatus.RespondedAwaitingApproval)
{
m_peer.LogWarning("Ignoring multiple Connect() most likely due to a delayed Approval");
return;
}
if (m_status == NetConnectionStatus.RespondedConnect)
{
// our ConnectResponse must have been lost
SendConnectResponse((float)now, true);
return;
}
m_peer.LogDebug("Unhandled Connect: " + tp + ", status is " + m_status + " length: " + payloadLength);
break;
case NetMessageType.ConnectResponse:
HandleConnectResponse(now, tp, ptr, payloadLength);
break;
case NetMessageType.ConnectionEstablished:
switch (m_status)
{
case NetConnectionStatus.Connected:
// ok...
break;
case NetConnectionStatus.Disconnected:
case NetConnectionStatus.Disconnecting:
case NetConnectionStatus.None:
// too bad, almost made it
break;
case NetConnectionStatus.ReceivedInitiation:
// uh, a little premature... ignore
break;
case NetConnectionStatus.InitiatedConnect:
// weird, should have been RespondedConnect...
break;
case NetConnectionStatus.RespondedConnect:
// awesome
NetIncomingMessage msg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
InitializeRemoteTimeOffset(msg.ReadSingle());
m_peer.AcceptConnection(this);
InitializePing();
SetStatus(NetConnectionStatus.Connected, "Connected to " + NetUtility.ToHexString(m_remoteUniqueIdentifier));
return;
}
break;
case NetMessageType.Disconnect:
// ouch
string reason = "Ouch";
try
{
NetIncomingMessage inc = m_peer.SetupReadHelperMessage(ptr, payloadLength);
reason = inc.ReadString();
}
catch
{
}
ExecuteDisconnect(reason, false);
break;
case NetMessageType.Discovery:
m_peer.HandleIncomingDiscoveryRequest(now, m_remoteEndPoint, ptr, payloadLength);
return;
case NetMessageType.DiscoveryResponse:
m_peer.HandleIncomingDiscoveryResponse(now, m_remoteEndPoint, ptr, payloadLength);
return;
case NetMessageType.Ping:
// silently ignore
return;
default:
m_peer.LogDebug("Unhandled type during handshake: " + tp + " length: " + payloadLength);
break;
}
}
// received a library message while Connected
internal void ReceivedLibraryMessage(NetMessageType tp, int ptr, int payloadLength)
{
double now = NetTime.Now;
switch (tp)
{
case NetMessageType.Connect:
m_peer.LogDebug("Received handshake message (" + tp + ") despite connection being in place");
break;
case NetMessageType.ConnectResponse:
// handshake message must have been lost
HandleConnectResponse(now, tp, ptr, payloadLength);
break;
case NetMessageType.ConnectionEstablished:
// do nothing, all's well
break;
case NetMessageType.LibraryError:
m_peer.ThrowOrLog("LibraryError received by ReceivedLibraryMessage; this usually indicates a malformed message");
break;
case NetMessageType.Disconnect:
NetIncomingMessage msg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
m_disconnectRequested = true;
m_disconnectMessage = msg.ReadString();
m_disconnectReqSendBye = false;
//ExecuteDisconnect(msg.ReadString(), false);
break;
case NetMessageType.Acknowledge:
for (int i = 0; i < payloadLength; i += 3)
{
NetMessageType acktp = (NetMessageType)m_peer.m_receiveBuffer[ptr++]; // netmessagetype
int seqNr = m_peer.m_receiveBuffer[ptr++];
seqNr |= (m_peer.m_receiveBuffer[ptr++] << 8);
// need to enqueue this and handle it in the netconnection heartbeat; so be able to send resends together with normal sends
m_queuedIncomingAcks.Enqueue(new NetTuple <NetMessageType, int>(acktp, seqNr));
}
break;
case NetMessageType.Ping:
int pingNr = m_peer.m_receiveBuffer[ptr++];
SendPong(pingNr);
break;
case NetMessageType.Pong:
NetIncomingMessage pmsg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
int pongNr = pmsg.ReadByte();
float remoteSendTime = pmsg.ReadSingle();
ReceivedPong(now, pongNr, remoteSendTime);
break;
case NetMessageType.ExpandMTURequest:
SendMTUSuccess(payloadLength);
break;
case NetMessageType.ExpandMTUSuccess:
if (m_peer.Configuration.AutoExpandMTU == false)
{
m_peer.LogDebug("Received ExpandMTURequest altho AutoExpandMTU is turned off!");
break;
}
NetIncomingMessage emsg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
int size = emsg.ReadInt32();
HandleExpandMTUSuccess(now, size);
break;
case NetMessageType.NatIntroduction:
// Unusual situation where server is actually already known, but got a nat introduction - oh well, lets handle it as usual
m_peer.HandleNatIntroduction(ptr);
break;
default:
m_peer.LogWarning("Connection received unhandled library message: " + tp);
break;
}
}
// received a library message while Connected
internal void ReceivedLibraryMessage(NetMessageType tp, int ptr, int payloadLength)
{
m_peer.VerifyNetworkThread();
float now = (float)NetTime.Now;
switch (tp)
{
case NetMessageType.Disconnect:
NetIncomingMessage msg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
ExecuteDisconnect(msg.ReadString(), false);
break;
case NetMessageType.Acknowledge:
for (int i = 0; i < payloadLength; i += 3)
{
NetMessageType acktp = (NetMessageType)m_peer.m_receiveBuffer[ptr++]; // netmessagetype
int seqNr = m_peer.m_receiveBuffer[ptr++];
seqNr |= (m_peer.m_receiveBuffer[ptr++] << 8);
// need to enqueue this and handle it in the netconnection heartbeat; so be able to send resends together with normal sends
m_queuedIncomingAcks.Enqueue(new NetTuple <NetMessageType, int>(acktp, seqNr));
}
break;
case NetMessageType.Ping:
int pingNr = m_peer.m_receiveBuffer[ptr++];
SendPong(pingNr);
break;
case NetMessageType.Pong:
NetIncomingMessage pmsg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
int pongNr = pmsg.ReadByte();
float remoteSendTime = pmsg.ReadSingle();
ReceivedPong(now, pongNr, remoteSendTime);
break;
case NetMessageType.ExpandMTURequest:
SendMTUSuccess(payloadLength);
break;
case NetMessageType.ExpandMTUSuccess:
NetIncomingMessage emsg = m_peer.SetupReadHelperMessage(ptr, payloadLength);
int size = emsg.ReadInt32();
HandleExpandMTUSuccess(now, size);
break;
case NetMessageType.NatIntroduction:
// Unusual situation where server is actually already known, but got a nat introduction - oh well, lets handle it as usual
m_peer.HandleNatIntroduction(ptr);
break;
case NetMessageType.ConnectResponse: // Lidgren bug fix -AR
// ConnectionEstablished (from handshake) must have been lost, send another one
m_peer.LogDebug("Resending ConnectionEstablished...");
SendConnectionEstablished();
break;
default:
m_peer.LogWarning("Connection received unhandled library message: " + tp);
break;
}
}
