private void ProcessMessage(byte[] data, int dataSize, ulong sender, TimeSpan timestamp)
{
Debug.Assert(data.Length >= dataSize, "Wrong size");
MyMessageId id = (MyMessageId)data[0];
MyPacket p = new MyPacket();
p.Data = data;
p.PayloadOffset = 1; // First byte is message id
p.PayloadLength = dataSize - p.PayloadOffset;
p.Sender = new VRage.Network.EndpointId(sender);
p.Timestamp = timestamp;
Action <MyPacket> handler;
if (m_handlers.TryGetValue(id, out handler))
{
ProfilerShort.Begin(MyEnum <MyMessageId> .GetName(id));
NetProfiler.Begin(MyEnum <MyMessageId> .GetName(id));
handler(p);
NetProfiler.End(p.PayloadLength);
ProfilerShort.End();
}
else
{
Debug.Fail("No handler for message type: " + id);
}
}
private void HandleMessage(MyPacket p)
{
int bitPosition = p.BitStream.BitPosition;
MyMessageId id = (MyMessageId)p.BitStream.ReadByte(8);
if (id == MyMessageId.FLUSH)
{
this.ClearBuffer();
p.Return();
}
else
{
p.BitStream.SetBitPositionRead(bitPosition);
if ((this.IsBuffering && ((id != MyMessageId.JOIN_RESULT) && ((id != MyMessageId.WORLD_DATA) && (id != MyMessageId.WORLD)))) && (id != MyMessageId.PLAYER_DATA))
{
this.m_buffer.Add(p);
}
else
{
this.ProfilePacketStatistics(true);
MyStatsGraph.Begin("Live data", 0, "HandleMessage", 0xc5, @"E:\Repo1\Sources\Sandbox.Game\Engine\Multiplayer\MyTransportLayer.cs");
this.ProcessMessage(p);
float?bytesTransfered = null;
MyStatsGraph.End(bytesTransfered, 0f, "", "{0} B", null, "HandleMessage", 0xc7, @"E:\Repo1\Sources\Sandbox.Game\Engine\Multiplayer\MyTransportLayer.cs");
this.ProfilePacketStatistics(false);
}
}
}
public void SendMessage(MyMessageId id, IPacketData data, bool reliable, List <EndpointId> endpoints, byte index = 0)
{
MyNetworkWriter.MyPacketDescriptor packet = this.InitSendStream(EndpointId.Null, reliable ? MyP2PMessageEnum.ReliableWithBuffering : MyP2PMessageEnum.Unreliable, id, index);
packet.Recipients.AddRange(endpoints);
packet.Data = data;
MyNetworkWriter.SendPacket(packet);
}
public void Unregister(MyMessageId messageId, byte receiverIndex)
{
HandlerId key = new HandlerId {
messageId = messageId,
receiverIndex = receiverIndex
};
this.m_handlers.Remove(key);
}
public void Register(MyMessageId messageId, byte receiverIndex, Action <MyPacket> handler)
{
HandlerId key = new HandlerId {
messageId = messageId,
receiverIndex = receiverIndex
};
this.m_handlers.Add(key, handler);
}
public unsafe void SendMessage(MyMessageId id, BitStream stream, bool reliable, EndpointId endpoint)
{
m_sendStream.Position = 0;
m_sendStream.WriteByte((byte)id);
if (stream != null)
{
m_sendStream.WriteNoAlloc((byte *)(void *)stream.DataPointer, 0, stream.BytePosition);
}
SendMessage(m_sendStream, reliable ? P2PMessageEnum.ReliableWithBuffering : P2PMessageEnum.Unreliable, endpoint.Value, m_channel);
}
private void ProcessMessage(byte[] data, int dataSize, ulong sender, MyTimeSpan timestamp, MyTimeSpan receivedTime)
{
Debug.Assert(data.Length >= dataSize, "Wrong size");
MyMessageId id = (MyMessageId)data[0];
if (id == MyMessageId.CLIENT_CONNNECTED)
{
MyNetworkClient player;
if (Sync.Layer != null && Sync.Layer.Clients != null)
{
bool playerFound = Sync.Layer.Clients.TryGetClient(sender, out player);
if (!playerFound)
{
Sync.Layer.Clients.AddClient(sender);
}
}
}
MyPacket p = new MyPacket
{
Data = data,
// First byte is message id
PayloadOffset = 1,
PayloadLength = dataSize - 1,
Sender = new VRage.Network.EndpointId(sender),
Timestamp = timestamp,
ReceivedTime = receivedTime
};
Action <MyPacket> handler;
if (m_handlers.TryGetValue(id, out handler))
{
ProfilerShort.Begin(MyEnum <MyMessageId> .GetName(id));
NetProfiler.Begin(MyEnum <MyMessageId> .GetName(id));
handler(p);
NetProfiler.End(p.PayloadLength);
ProfilerShort.End();
}
else
{
Debug.Fail("No handler for message type: " + id);
}
}
private void HandleMessage(byte[] data, int dataSize, ulong sender, MyTimeSpan timestamp, MyTimeSpan receivedTime)
{
if (dataSize < sizeof(byte)) // This would cause crash, message has to contain at least MyMessageId
{
return;
}
ProfilerShort.Begin("Handle message");
if (sender != Sync.MyId)
{
ByteCountReceived += dataSize;
}
MyMessageId id = (MyMessageId)data[0];
LogStats(ReceiveStats, "", dataSize, 1, P2PMessageEnum.Reliable);
m_thisFrameTraffic[(int)id] += dataSize;
if (id == MyMessageId.OLD_GAME_EVENT_FLUSH) // Flush buffer
{
if (m_buffer != null)
{
m_buffer.Clear();
}
}
else if (IsBuffering && id != MyMessageId.JOIN_RESULT && id != MyMessageId.WORLD_DATA && id != MyMessageId.WORLD_BATTLE_DATA) // Buffer event
{
var buff = new Buffer();
buff.Sender = sender;
buff.Data = new byte[dataSize];
Array.Copy(data, buff.Data, dataSize);
buff.ReceivedTime = MyTimeSpan.FromTicks(Stopwatch.GetTimestamp());
m_buffer.Add(buff);
}
else // Process event
{
NetProfiler.Begin("Live data", 0);
ProcessMessage(data, dataSize, sender, timestamp, receivedTime);
NetProfiler.End();
}
ProfilerShort.End();
}
public unsafe void SendMessage(MyMessageId id, BitStream stream, bool reliable, EndpointId endpoint,
byte index = 0)
{
var sendStream = _sendStreamCache.Value;
var channel = _transportChannel(TransportLayer);
var mode = reliable ? MyP2PMessageEnum.ReliableWithBuffering : MyP2PMessageEnum.Unreliable;
if (reliable && stream != null)
{
byte b = (byte)(stream.BytePosition / _sizeMtr + 1);
for (int i = 0; i < b; i++)
{
sendStream.Position = 0L;
sendStream.WriteByte((byte)id);
sendStream.WriteByte(index);
sendStream.WriteByte(i == 0 ? b : (byte)0);
int num = i * (_sizeMtr - 3);
int num2 = _sizeMtr - 3;
if (num + num2 > stream.BytePosition)
{
num2 = stream.BytePosition - num;
}
sendStream.WriteNoAlloc((byte *)stream.DataPointer.ToPointer(), num, num2);
_transportSendMessage(TransportLayer, sendStream, mode, endpoint.Value, channel);
}
return;
}
sendStream.Position = 0L;
sendStream.WriteByte((byte)id);
sendStream.WriteByte(index);
sendStream.WriteByte(1);
if (stream != null)
{
sendStream.WriteNoAlloc((byte *)stream.DataPointer.ToPointer(), 0, stream.BytePosition);
}
_transportSendMessage(TransportLayer, sendStream, mode, endpoint.Value, channel);
}
private void HandleMessage(byte[] data, int dataSize, ulong sender, TimeSpan timestamp)
{
if (dataSize < sizeof(byte)) // This would cause crash, message has to contain at least MyMessageId
{
return;
}
ProfilerShort.Begin("Handle message");
if (sender != Sync.MyId)
{
ByteCountReceived += dataSize;
}
MyMessageId id = (MyMessageId)data[0];
m_thisFrameTraffic[(int)id] += dataSize;
if (id == MyMessageId.OLD_GAME_EVENT_FLUSH) // Flush buffer
{
if (m_buffer != null)
{
m_buffer.Clear();
}
}
else if (IsBuffering) // Buffer event
{
var buff = new Buffer();
buff.Sender = sender;
buff.Data = new byte[dataSize];
Array.Copy(data, buff.Data, dataSize);
m_buffer.Add(buff);
}
else // Process event
{
NetProfiler.Begin("Live data", 0);
ProcessMessage(data, dataSize, sender, timestamp);
NetProfiler.End();
}
ProfilerShort.End();
}
public void Unregister(MyMessageId messageId)
{
m_handlers.Remove(messageId);
}
public void Register(MyMessageId messageId, Action <MyPacket> handler)
{
m_handlers.Add(messageId, handler);
}
public bool IsRegistered(MyMessageId messageId)
{
return(m_handlers.ContainsKey(messageId));
}
private MyNetworkWriter.MyPacketDescriptor InitSendStream(EndpointId endpoint, MyP2PMessageEnum msgType, MyMessageId msgId, byte index = 0)
{
MyNetworkWriter.MyPacketDescriptor descriptor1 = MyNetworkWriter.GetPacketDescriptor(endpoint, msgType, this.m_channel);
descriptor1.Header.WriteByte((byte)msgId);
descriptor1.Header.WriteByte(index);
return(descriptor1);
}
public void SendMessage(MyMessageId id, IPacketData data, bool reliable, EndpointId endpoint, byte index = 0)
{
MyNetworkWriter.MyPacketDescriptor packet = this.InitSendStream(endpoint, reliable ? MyP2PMessageEnum.ReliableWithBuffering : MyP2PMessageEnum.Unreliable, id, index);
packet.Data = data;
MyNetworkWriter.SendPacket(packet);
}
