/// <summary>
/// Creates a network message by decoding a NetMessage
/// </summary>
/// <param name="msg">The NetMessage to be decoded</param>
public SpiderMessage(NetMessage msg)
{
//This is the exception we throw if something goes wrong
Exception e = new Exception("Could not read message");
byte[] contents = msg.ReadBytes(msg.Length);
type = (SpiderMessageType)contents[0];
int dataOffset = BitConverter.ToInt32(contents, 1);
label = Encoding.UTF8.GetString(contents, 1 + sizeof(int), dataOffset - 1 - sizeof(int));
senderIP = msg.Sender.RemoteEndpoint.Address;
connection = msg.Sender;
if (type == SpiderMessageType.Bytes) {
data = new byte[contents.Length - dataOffset];
for (int i = 0; i < contents.Length - dataOffset; i++) {
((byte[])data)[i] = contents[i + dataOffset];
}
}
else {
String tempData = Encoding.UTF8.GetString(contents, dataOffset, contents.Length - dataOffset);
switch (type) {
case SpiderMessageType.Double:
data = Convert.ToDouble(tempData);
break;
case SpiderMessageType.Int:
data = Convert.ToInt32(tempData);
break;
default:
data = tempData;
break;
}
}
}
// Broadcast a message to logged in players, except the id player (if id = -1, no player is ignored)
public void BroadcastMsgExcept(NetMessage msg, NetChannel channel, int id)
{
IDictionaryEnumerator en = PList.GetPlayerEnum();
while (en.MoveNext())
{
if (((Player)en.Value).Carac.ActorID != id)
Server.SendMessage(msg, ((Player)en.Value).Connection, channel);
}
}
/// <summary>
/// Reuses the string table index
/// </summary>
public int Rewrite(NetMessage msg, int idx, string str)
{
while (m_data.Count < idx - 1)
m_data.Add(null); // dummy values
m_data[idx] = str;
msg.Write(false);
msg.Write7BitEncodedUInt((uint)idx);
msg.Write(str);
return idx;
}
// Serialization / Deserialization
public NetMessage GetNetMessage()
{
MemoryStream s = new MemoryStream();
BinaryFormatter b = new BinaryFormatter();
b.Serialize(s, this);
// WAY TOO BIG !!
NetMessage netmsg = new NetMessage();
s.Capacity = (int)s.Length;
netmsg.Write(s.GetBuffer());
return netmsg;
}
void StatusChanged(object sender, NetStatusEventArgs e)
{
// e.Connection is the connection for which status changed
// e.Connectionn.Status is the new status
// e.Reason is a human readable reason for the status change
if (e.Connection.Status == NetConnectionStatus.Connected)
{
System.Console.WriteLine("Status: " + e.Connection.Status.ToString());
NetMessage outMsg = new NetMessage();
//Client.SendMessage(outMsg, NetChannel.ReliableUnordered); // <- for example
}
}
public int RelateToExpected(NetMessage msg)
{
int expected = m_expectedSequenceNumbers[(int)msg.SequenceChannel];
int diff = msg.SequenceNumber - expected;
if (diff == 0)
return 0; // early out
// is a message so far behind that it's actually wrapped and early?
if (diff < (NetConstants.EarlyArrivalWindowSize - NetConstants.NumSequenceNumbers))
diff += NetConstants.NumSequenceNumbers;
// is a message so far ahead that it's actually wrapped and late?
else if (diff > NetConstants.EarlyArrivalWindowSize)
diff -= NetConstants.NumSequenceNumbers;
return diff;
}
/// <summary>
/// Returns encoded index
/// </summary>
public int Write(NetMessage msg, string str)
{
int idx = m_data.IndexOf(str);
if (idx == -1)
{
idx = m_data.Count;
m_data.Add(str);
msg.Write(false);
msg.Write7BitEncodedUInt((uint)idx);
msg.Write(str);
return idx;
}
msg.Write(true);
msg.Write7BitEncodedUInt((uint)idx);
return idx;
}
public string Read(NetMessage msg)
{
bool encoded = msg.ReadBoolean();
int idx = (int)msg.Read7BitEncodedUInt();
string retval;
if (!encoded)
{
// insert into table
retval = msg.ReadString();
while(m_data.Count <= idx)
m_data.Add(null); // dummy values
m_data[idx] = retval;
return retval;
}
// look in table
if (m_data.Count <= idx)
return null;
return m_data[idx];
}
internal void HandlePong(double now, NetMessage pongMessage)
{
int nr = pongMessage.ReadByte(6);
if (nr != m_pingNrInProgress)
{
m_connection.Parent.Log.Warning("Pong received for wrong ping; received " + nr + " expecting " + m_pingNrInProgress);
return;
}
double roundtrip = now - m_lastSentPing;
// spike, or can we use this roundtrip?
double avgRT = pongMessage.Sender.AverageRoundtripTime;
if (roundtrip > avgRT * 2.0)
{
// must be spike
m_connection.Parent.Log.Verbose("Not adjusting clock due lag spike... (rt " + NetUtil.SecToMil(roundtrip) + " avg " + NetUtil.SecToMil(avgRT) + ")");
}
else
{
ushort val = pongMessage.ReadUInt16();
int curOffset = m_connection.RemoteClockOffset;
int foundOffset = NetTime.CalculateOffset(now, val, roundtrip);
int res = NetTime.MergeOffsets(curOffset, foundOffset);
int rtMillis = (int)(roundtrip * 1000.0);
if (res != curOffset)
{
//m_connection.Parent.Log.Verbose("Ping: " + rtMillis + " Local: " + NetTime.Encoded(now) + " CurOffset: " + curOffset + " Remote: " + val + " NewOffset: " + res + " (adjusted " + (res - curOffset) + ")");
m_connection.Parent.Log.Verbose("Roundtrip: " + rtMillis + " ms; Ajusted remote offset " + (res - curOffset) + " ms");
m_connection.RemoteClockOffset = res;
}
}
AddRoundtrip((float)roundtrip);
if (m_connection.Parent is NetServer)
{
// server is authorative on settings optimizing roundtrip numbers
m_connection.Configuration.OptimizeSettings(m_averageRoundtrip);
SendOptimizeInfo(m_averageRoundtrip);
}
return;
}
internal static void ReplyPong(NetMessage pingMessage, NetConnection connection)
{
byte nr = pingMessage.ReadByte(6);
NetMessage pong = new NetMessage(NetMessageType.PingPong, 3);
pong.Write(true); // means pong
pong.Write(false); // means NOT optimize info
pong.Write(nr, 6);
pong.WriteSendStamp();
connection.Parent.SendSingleMessageAtOnce(pong, connection, connection.RemoteEndpoint);
}
public void HandleMessage(NetMessage netmsg)
{
BBMessage msg;
// We received a message
Log.Debug("msg: " + netmsg);
try
{
msg = BBMessage.FromNetMessage(netmsg);
}
catch (Exception ex)
{
Log.Error("Deserialization error : " + ex.Message);
return;
}
Log.Debug("msg: " + System.Enum.GetName(typeof(BBMsgType), msg.MsgType));
switch (msg.MsgType)
{
case BBMsgType.NO_LOGIN:
OutputSystemText("Login refused ! Reason : " + msg.Param1, msg);
break;
case BBMsgType.OK_LOGIN:
OutputSystemText("Login accepted ! ID is : " + msg.PlayerCarac.ActorID, msg);
OurID = msg.PlayerCarac.ActorID;
PList.AddPlayer(msg.PlayerCarac, null, null);
this.OnUserConnection(msg.PlayerCarac, false);
break;
case BBMsgType.VDM:
this.MessageChat(msg, false);
if ((!string.IsNullOrEmpty(msg.Message)) && (msg.Param2))
this.OnVDMActivated();
break;
case BBMsgType.BASH:
this.MessageChat(msg, false);
if (!string.IsNullOrEmpty(msg.Message))
this.OnBASHActivated();
break;
case BBMsgType.PENDU:
this.MessageChat(msg, false);
if (msg.Param2)
this.OnStartPenduNewWord();
break;
case BBMsgType.CHAT:
this.MessageChat(msg, true);
break;
case BBMsgType.TYPING_MSG:
this.OnUserTyping(PList.GetPlayer(msg.ActorInfo.Id).Carac, msg.Conversation, msg.Param2);
break;
case BBMsgType.ADD_PLAYER:
// Add the player to our player list
PList.AddPlayer(msg.PlayerCarac, msg.ActorInfo, null);
this.OnUserConnection(msg.PlayerCarac, msg.Param2);
//MainForm.UserConnect(msg.PlayerCarac.Nick, msg.Param2);
if (msg.Param2 == true)
{
Log.Info("Player " + msg.PlayerCarac.Nick + " connected.");
}
break;
case BBMsgType.DEL_PLAYER:
Log.Info("Player " + PList.GetPlayer(msg.PlayerCarac.ActorID).Carac.Nick + " disconnected. Reason : " + msg.Param1);
//MainForm.UserDisconnect(PList.GetPlayer(msg.PlayerCarac.ActorID).Carac.Nick, msg.Param1);
this.OnUserDisconnection(PList.GetPlayer(msg.PlayerCarac.ActorID).Carac, msg.Param1);
PList.DelPlayer(msg.PlayerCarac.ActorID);
break;
case BBMsgType.ACTOR_SHOOT:
Shooted(msg);
break;
case BBMsgType.ACTOR_SHOOT_RESPONSE:
ShootResponsed(msg);
break;
case BBMsgType.KNOCK:
if (msg.Param3 == OurID)
this.OnUserKnocked();
OutputSystemText(PList.GetPlayer(msg.ActorInfo.Id).Carac.Nick + " knocked on " + PList.GetPlayer(msg.Param3).Carac.Nick + "'s door.", msg);
break;
case BBMsgType.COFFEE:
if (msg.Param3 == OurID)
this.OnUserCoffee();
//ShowInfoBalloon("Crying tears...", "Go Coffee...");
OutputSystemText(PList.GetPlayer(msg.ActorInfo.Id).Carac.Nick + " invites " + PList.GetPlayer(msg.Param3).Carac.Nick + " to go to coffee", msg);
break;
case BBMsgType.EAT:
if (msg.Param3 == OurID)
this.OnUserEat();
//ShowInfoBalloon("Hungry", "Go to eat...");
OutputSystemText(PList.GetPlayer(msg.ActorInfo.Id).Carac.Nick + " invites " + PList.GetPlayer(msg.Param3).Carac.Nick + " to go to eat", msg);
break;
case BBMsgType.JOIN_CONVERSATION:
// Add the player to our player list
if (this.IsPartOfConversation(msg.Conversation))
{
this.OnSendingSystemMessage("Player " + msg.PlayerCarac.Nick + " joined the conversation.", msg);
}
break;
case BBMsgType.LEAVE_CONVERSATION:
// Add the player to our player list
if (this.IsPartOfConversation(msg.Conversation))
{
this.OnSendingSystemMessage(PList.GetPlayer(msg.PlayerCarac.ActorID).Carac.Nick + " leaved the conversation.", msg);
}
break;
case BBMsgType.PRIVATE_MESSAGE:
{
if (this.IsPartOfConversation(msg.Conversation))
{
string nick;
Color color;
if (msg.ActorInfo.Id != -1)
{
nick = PList.GetPlayer(msg.ActorInfo.Id).Carac.Nick;
color = PList.GetPlayer(msg.ActorInfo.Id).Carac.TextColor;
}
else
{
nick = "";
color = Color.Black; // Whatever
}
this.OnSendingMessage(msg);
//MainForm.AppendChatMsgBBMessage(msg, msg.Param1, nick, color, msg.Conversation.ConversID.ToString());
// Notify the user
OnNotifyMessage();
}
break;
}
case BBMsgType.PRIVATE_CONVERSATION:
//ShowInfoBalloon("Conversation privée");
break;
}
}
private void SendInput(string Input)
{
if (client != null)
{
GameState++;
NetMessage msg = new NetMessage(); ;
msg.Write(Input);
//Sending the packet in Reliable is okay for this because its
//one packet, When sending lots and lots of data you need to
//set this to Unreliable. This will garentee it arrives but
//not in a sepcific order.
client.SendMessage(msg, NetChannel.Unreliable);
}
}
internal void ReceiveMessage(double now, NetMessage msg)
{
// reject duplicates and late sequenced messages
bool rejectMessage, ackMessage, withholdMessage;
m_sequenceHandler.AddSequence(msg, out rejectMessage, out ackMessage, out withholdMessage);
if (ackMessage)
{
if (m_unsentAcknowledges.Count <= 0)
m_forceExplicitAckTime = m_lastHeardFromRemote + Configuration.ForceExplicitAckDelay;
m_unsentAcknowledges.Enqueue(msg);
}
if (rejectMessage)
{
m_parent.Log.Debug("Message rejected: " + msg);
return;
}
if (withholdMessage)
{
//m_parent.Log.Debug("Message withheld: " + msg);
m_withheldMessages.Add(msg);
return;
}
ReleaseMessageToApplication(msg);
// enqueue any currently withheld messages?
int cnt = m_withheldMessages.Count;
if (cnt > 0)
{
WithheldChecking:
for (int i = 0; i < cnt; i++)
{
NetMessage withheld = m_withheldMessages[i];
if (withheld.SequenceChannel == msg.SequenceChannel)
{
if (m_sequenceHandler.RelateToExpected(withheld) == 0)
{
m_withheldMessages.Remove(withheld);
//m_receivedMessages.Enqueue(withheld);
ReleaseMessageToApplication(withheld);
// advance expected
m_sequenceHandler.AdvanceExpected(withheld.SequenceChannel, 1);
cnt = m_withheldMessages.Count;
goto WithheldChecking; // restart to check entire list
}
}
}
}
}
internal NetConnection(NetBase parent, IPEndPoint remote)
{
m_parent = parent;
m_remoteEndpoint = remote;
m_nextSequenceNumber = new ushort[NetConstants.NumSequenceChannels];
m_sequenceHandler = new NetSequenceHandler();
m_unsentMessages = new Queue<NetMessage>(10);
m_receivedMessages = new Queue<NetMessage>(10);
m_withheldMessages = new List<NetMessage>();
m_unsentAcknowledges = new Queue<NetMessage>(10);
m_lastHeardFromRemote = (float)NetTime.Now;
m_reusedAckMessage = new NetMessage(NetMessageType.Acknowledge, null);
m_savedReliableMessages = new List<NetMessage>[NetConstants.NumSequenceChannels];
Configuration = new NetConnectionConfiguration(this);
m_ping = new NetPing(this);
Statistics = new NetStatistics(this);
m_stringTable = new NetStringTable();
m_encryption = new NetEncryption();
if (parent.Configuration.UsesEncryption)
m_encryption.SetRSAKey(parent.Configuration.ServerPublicKeyBytes, parent.Configuration.ServerPrivateKeyBytes);
}
public bool Send(String msg)
{
NetMessage outMsg = new NetMessage();
outMsg.Write(msg);
return MMOServer.Server.SendMessage(outMsg, m_connection, NetChannel.ReliableUnordered);
}
void client_StatusChanged(object sender, NetStatusEventArgs e)
{
if (e.Connection.Status == NetConnectionStatus.Connected)
{
NetMessage msg = new NetMessage();
msg.Write("Hello Server! I Am Connected And Able To Communicate!");
client.SendMessage(msg, NetChannel.ReliableUnordered);
}
if (e.Connection.Status == NetConnectionStatus.Disconnected)
{
this.Window.Title = "We Were disconnected";
}
}
private void SendGameState(NetConnection Conn)
{
GameState++;
NetMessage msg = new NetMessage();
string Message = "P" + Player.Location.X + "," + Player.Location.Y;
Message = Message + "P";
foreach (Zombie Zombie in Zombies)
{
Message = Message + "Z" + Zombie.Location.X + "," + Zombie.Location.Y;
}
Message = Message + "P";
foreach (Bullet Bullet in Bullets)
{
Message = Message + "B" + Bullet.Location.X + "," + Bullet.Location.Y;
}
msg.Write(Message);
//Sending the packet in Reliable is okay for this because its
//one packet, When sending lots and lots of data you need to
//set this to Unreliable. This will garentee it arrives but
//not in a sepcific order.
server.SendMessage(msg, Conn, NetChannel.Unreliable);
}
private void ReleaseMessageToApplication(NetMessage msg)
{
//m_parent.Log.Debug("Releasing message: " + msg);
if (msg.m_type == NetMessageType.UserFragmented)
{
// fragmented; check id, check for completeness, withhold incomplete
int fragDataLen = msg.Length - 5;
byte fid = msg.m_buffer.Data[0];
int totalFragments = msg.m_buffer.Data[1] + (msg.m_buffer.Data[2] << 8);
int thisFragment = msg.m_buffer.Data[3] + (msg.m_buffer.Data[4] << 8);
if (totalFragments <= 0 || thisFragment >= totalFragments)
{
// just drop it
m_parent.Log.Warning("Bad message fragment; " + thisFragment + " of " + totalFragments);
return;
}
//m_parent.Log.Debug("Received fragment id " + fid + "; fragment " + thisFragment + " of " + totalFragments + " size: " + fragDataLen);
if (m_incompleteMessages[fid] == null)
{
//
// new fragments assembly detected
//
if (thisFragment == totalFragments - 1)
{
// Ouch! We received the LAST fragment FIRST, so we are unable
// to determine a correct splitsize...
return; // TODO FIX THIS
}
m_incompleteMessages[fid] = new NetMessage(NetMessageType.User, totalFragments * fragDataLen);
m_incompleteSplitSize[fid] = fragDataLen;
// clear next slot; we don't want any broken (by loss) fragmented unreliable message mess
// up the next assembly
int nextFid = (fid + 1) % 256;
m_incompleteMessages[nextFid] = null;
m_incompleteFragmentsReceived[nextFid] = 0;
m_incompleteTotalBytes[nextFid] = 0;
}
Buffer.BlockCopy(msg.m_buffer.Data, 5, m_incompleteMessages[fid].m_buffer.Data, thisFragment * m_incompleteSplitSize[fid], fragDataLen);
m_incompleteFragmentsReceived[fid]++;
m_incompleteTotalBytes[fid] += fragDataLen;
if (m_incompleteFragmentsReceived[fid] == totalFragments)
{
// Whee, it's complete! Pass it on to the application
NetConnection tmp = msg.Sender;
msg = m_incompleteMessages[fid];
msg.Sender = tmp;
msg.m_buffer.LengthBits = m_incompleteTotalBytes[fid] * 8;
m_incompleteMessages[fid] = null;
m_incompleteFragmentsReceived[fid] = 0;
m_incompleteTotalBytes[fid] = 0;
//m_parent.Log.Debug("Fragmented message complete!");
}
else
{
// not done yet
return;
}
}
m_receivedMessages.Enqueue(msg);
}
void server_StatusChanged(object sender, NetStatusEventArgs e)
{
if (e.Connection.Status == NetConnectionStatus.Connecting)
{
NetMessage msg = new NetMessage();
msg.Write("Hello Client, I See you are able to talk to me," +
" I Can Talk to you Too!");
//Sending the packet in Reliable is okay for this because its
//one packet, When sending lots and lots of data you need to
//set this to Unreliable. This will garentee it arrives but
//not in a sepcific order.
server.SendMessage(msg, e.Connection, NetChannel.ReliableUnordered);
}
if (e.Connection.Status == NetConnectionStatus.Disconnected)
{
this.Window.Title = "Client Has Disconnected to You";
}
}
internal void ReceiveAcknowledge(NetMessage msg)
{
// todo: optimize
int seqChan = (int)msg.SequenceChannel;
ushort seqNr = msg.SequenceNumber;
if (m_savedReliableMessages[seqChan] == null)
m_savedReliableMessages[seqChan] = new List<NetMessage>();
List<NetMessage> list = m_savedReliableMessages[seqChan];
foreach(NetMessage fm in list)
{
if (fm.SequenceNumber == seqNr)
{
if (MessageAcknowledged != null)
MessageAcknowledged(this, new NetMessageEventArgs(fm));
//m_parent.Log.Debug("Stored message acked and removed: " + msg.SequenceChannel + "|" + msg.SequenceNumber);
m_savedReliableMessages[seqChan].Remove(fm);
return;
}
}
m_parent.Log.Verbose("Failed to find " + msg.SequenceChannel + "|" + msg.SequenceNumber + " in saved list; probably double acked");
}
public void AddSequence(NetMessage msg, out bool rejectMessage, out bool ackMessage, out bool withholdMessage)
{
int seqChan = (int)msg.SequenceChannel;
int seqNr = msg.SequenceNumber;
ackMessage = (seqChan >= (int)NetChannel.ReliableUnordered);
int offset = seqChan * NetConstants.NumKeptDuplicateNumbers;
int end = offset + NetConstants.NumKeptDuplicateNumbers;
for (int i = offset; i < end; i++)
{
if (m_receivedSequences[i] == seqNr)
{
// duplicate
NetBase.CurrentContext.Log.Debug("Duplicate message " + msg + " detected and dropped; already contained in slot " + (i - offset));
rejectMessage = true;
withholdMessage = false;
return;
}
}
//NetBase.CurrentContext.Log.Verbose("Unique message " + msg + " found");
// not duplicate; add!
m_receivedSequences[offset + m_receivedPtr[seqChan]] = seqNr;
m_receivedPtr[seqChan]++;
if (m_receivedPtr[seqChan] >= NetConstants.NumKeptDuplicateNumbers)
m_receivedPtr[seqChan] = 0;
// unreliable?
if (msg.SequenceChannel == NetChannel.Unreliable)
{
rejectMessage = false;
withholdMessage = false;
return;
}
int rel = RelateToExpected(msg);
// sequenced?
if (seqChan >= (int)NetChannel.Sequenced1 && seqChan <= (int)NetChannel.Sequenced15)
{
// late messages rejected if sequenced
if (rel < 0)
{
NetBase.CurrentContext.Log.Debug("Late sequenced message " + msg.SequenceChannel + "|" + msg.SequenceNumber + " detected and dropped; expected " + m_expectedSequenceNumbers[seqChan] + " got " + msg.SequenceNumber);
rejectMessage = true;
}
else
{
m_expectedSequenceNumbers[seqChan] = (m_expectedSequenceNumbers[seqChan] + rel + 1) % NetConstants.NumSequenceNumbers;
rejectMessage = false;
}
withholdMessage = false;
return;
}
// reliable unordered?
if (msg.SequenceChannel == NetChannel.ReliableUnordered)
{
rejectMessage = false;
withholdMessage = false;
return;
}
// ordered
if (rel > 0)
{
// early
int expected = m_expectedSequenceNumbers[(int)msg.SequenceChannel];
//NetBase.CurrentContext.Log.Debug("Received early message (" + msg.SequenceChannel + "|" + msg.SequenceNumber + ", expecting " + expected + ")");
withholdMessage = true;
}
else if (rel == 0)
{
// on time!
AdvanceExpected(msg.SequenceChannel, 1);
withholdMessage = false;
}
else
{
// late, shouldn't happen!
int expected = m_expectedSequenceNumbers[(int)msg.SequenceChannel];
NetBase.CurrentContext.Log.Warning("Late ordered message " + msg + " received?! expecting " + expected + " received " + msg.SequenceNumber + " rel " + rel);
withholdMessage = true;
}
rejectMessage = false;
return;
}
public void AssignSequenceNumber(NetMessage msg, NetChannel channel)
{
if (msg == null)
throw new ArgumentNullException("msg");
int chanNr = (int)channel;
lock (m_nextSequenceNumber)
{
msg.SequenceChannel = channel;
msg.SequenceNumber = m_nextSequenceNumber[chanNr]++;
if (m_nextSequenceNumber[chanNr] >= NetConstants.NumSequenceNumbers)
m_nextSequenceNumber[chanNr] = 0;
}
return;
}
/// <summary>
/// Sends the given message using the given UDP delivery type. A client will send to the server, a server will broadcast.
/// </summary>
/// <param name="message">The message to be sent</param>
/// <param name="deliveryType">The UDP delivery type</param>
public void SendMessage(SpiderMessage message, NetChannel deliveryType)
{
NetMessage msg = new NetMessage();
msg.Write(message.ToByteArray());
spiderNet.SendMessage(msg, deliveryType);
}
internal void SendMessage(NetMessage msg, NetChannel channel)
{
if (msg.Length > m_parent.Configuration.MaximumTransmissionUnit)
{
// fragment large message
int totlen = msg.Length;
int splitSize = m_parent.Configuration.MaximumTransmissionUnit - 13; // todo: research this number
int numFragments = totlen / splitSize;
if (numFragments * splitSize < totlen)
numFragments++;
byte hdr1 = (byte)numFragments;
byte hdr2 = (byte)(numFragments >> 8);
int ptr = 0;
for (int i = 0; i < numFragments; i++)
{
int numBytes = msg.Length - ptr;
if (numBytes > splitSize)
numBytes = splitSize;
byte[] fragmentData = new byte[5 + numBytes];
fragmentData[0] = m_nextFragmentAssemblyId;
fragmentData[1] = hdr1;
fragmentData[2] = hdr2;
fragmentData[3] = (byte)i;
fragmentData[4] = (byte)(i >> 8);
Buffer.BlockCopy(msg.m_buffer.Data, ptr, fragmentData, 5, numBytes);
// send fragment
NetMessage fragment = new NetMessage(NetMessageType.UserFragmented, fragmentData);
SendMessage(fragment, channel);
ptr += numBytes;
}
//m_parent.Log.Debug("Sent " + numFragments + " fragments, " + splitSize + " bytes per fragment = " + totlen);
m_nextFragmentAssemblyId++;
return;
}
msg.SequenceChannel = channel;
AssignSequenceNumber(msg, channel);
m_unsentMessages.Enqueue(msg);
}
internal void SendOptimizeInfo(float roundtrip)
{
NetMessage ping = new NetMessage(NetMessageType.PingPong, 3);
ping.Write(false); // meaningless
ping.Write(true); // means optimize info
ping.Write7BitEncodedUInt((uint)(roundtrip * 1000.0f));
m_connection.SendMessage(ping, NetChannel.Unreliable);
}
public NetMessageEventArgs(NetMessage msg)
{
Message = msg;
}
internal void HandleOptimizeInfo(double now, NetMessage pongMessage)
{
float optimizeMillis = (float)pongMessage.Read7BitEncodedUInt();
m_connection.Configuration.OptimizeSettings(optimizeMillis / 1000.0f);
}
public void ClientHandleMSG(NetMessage msg)
{
string str = msg.ReadString();
if (str.StartsWith("P"))
{
RecievedGameState(str);
}
}
internal void SendPing(double now)
{
m_pingNrInProgress++;
if (m_pingNrInProgress > 63)
m_pingNrInProgress = 0;
NetMessage ping = new NetMessage(NetMessageType.PingPong, 1);
ping.Write(false); // means ping
ping.Write(false); // means NOT optimize info
ping.Write((byte)m_pingNrInProgress, 6);
m_connection.Parent.SendSingleMessageAtOnce(ping, m_connection, m_connection.RemoteEndpoint);
m_lastSentPing = now;
}
public void ServerHandleMSG(NetMessage msg)
{
string str = msg.ReadString();
MovePlayer(str);
}
