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, 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);
}
private void OnReplicationCreate(MyPacket packet)
{
packet.BitStream.ReadTypeId();
NetworkId networkId = packet.BitStream.ReadNetworkId();
MyPacketDataBitStreamBase bitStreamPacketData = MyNetworkWriter.GetBitStreamPacketData();
bitStreamPacketData.Stream.WriteNetworkId(networkId);
bitStreamPacketData.Stream.WriteBool(true);
bitStreamPacketData.Stream.Terminate();
this.SendReplicableReady(bitStreamPacketData);
packet.Return();
}
protected void SendControlMessage <T>(ulong user, ref T message, bool reliable = true) where T : struct
{
ITransportCallback callback;
MyControlMessageEnum enum2;
this.m_controlMessageTypes.TryGetValue(typeof(T), out enum2);
this.m_controlMessageHandlers.TryGetValue((int)enum2, out callback);
MyControlMessageCallback <T> callback2 = (MyControlMessageCallback <T>)callback;
if (MySyncLayer.CheckSendPermissions(user, callback2.Permission))
{
MyNetworkWriter.MyPacketDescriptor packet = MyNetworkWriter.GetPacketDescriptor(new EndpointId(user), reliable ? MyP2PMessageEnum.ReliableWithBuffering : MyP2PMessageEnum.Unreliable, 0);
packet.Header.WriteUShort((ushort)enum2);
callback2.Write(packet.Header, ref message);
MyNetworkWriter.SendPacket(packet);
}
}
private void SendUpdate()
{
MyPacketDataBitStreamBase bitStreamPacketData = MyNetworkWriter.GetBitStreamPacketData();
BitStream stream = bitStreamPacketData.Stream;
stream.WriteByte(this.m_lastStateSyncPacketId, 8);
stream.WriteByte((byte)this.m_acks.Count, 8);
foreach (byte num2 in this.m_acks)
{
stream.WriteByte(num2, 8);
}
stream.Terminate();
this.m_acks.Clear();
this.SendClientAcks(bitStreamPacketData);
bitStreamPacketData = MyNetworkWriter.GetBitStreamPacketData();
stream = bitStreamPacketData.Stream;
this.m_clientPacketId = (byte)(this.m_clientPacketId + 1);
stream.WriteByte(this.m_clientPacketId, 8);
stream.WriteDouble(MyTimeSpan.FromTicks(Stopwatch.GetTimestamp()).Milliseconds);
stream.WriteDouble(0.0);
this.m_clientState.Serialize(stream, false);
stream.Terminate();
this.SendClientUpdate(bitStreamPacketData);
}
public MyPacketDataBitStreamBase GetBitStreamPacketData() => MyNetworkWriter.GetBitStreamPacketData();
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);
}
public void SendFlush(ulong sendTo)
{
MyNetworkWriter.SendPacket(this.InitSendStream(new EndpointId(sendTo), MyP2PMessageEnum.ReliableWithBuffering, MyMessageId.FLUSH, 0));
}
