public ConnectedClientDataMsg OnClientConnected(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
ConnectedClientDataMsg msg = VRage.Serialization.MySerializer.CreateAndRead <ConnectedClientDataMsg>(m_receiveStream);
return(msg);
}
/// <summary>
/// Processes state sync sent by server.
/// </summary>
public void ProcessStateSync(MyPacket packet)
{
LastMessageFromServer = DateTime.UtcNow;
// Simulated packet loss
// if (MyRandom.Instance.NextFloat() > 0.3f) return;
m_receiveStream.ResetRead(packet);
bool isStreaming = m_receiveStream.ReadBool();
m_lastStateSyncPacketId = m_receiveStream.ReadByte();
try
{
while (m_receiveStream.BytePosition < m_receiveStream.ByteLength)
{
NetworkId networkID = m_receiveStream.ReadNetworkId();
IMyStateGroup obj = GetObjectByNetworkId(networkID) as IMyStateGroup;
if (obj == null)
{
if (isStreaming == false)
{
Debug.Fail("IMyStateGroup not found by NetworkId");
break;
}
else
{
return;
}
}
if (isStreaming && obj.GroupType != StateGroupEnum.Streamining)
{
Debug.Fail("group type mismatch !");
MyLog.Default.WriteLine("received streaming flag but group is not streaming !");
return;
}
if (!isStreaming && obj.GroupType == StateGroupEnum.Streamining)
{
Debug.Fail("group type mismatch !");
MyLog.Default.WriteLine("received non streaming flag but group wants to stream !");
return;
}
var pos = m_receiveStream.BytePosition;
NetProfiler.Begin(obj.GetType().Name);
obj.Serialize(m_receiveStream, ClientState.EndpointId, 0, m_lastStateSyncPacketId, 0);
NetProfiler.End(m_receiveStream.ByteLength - pos);
if (!m_acks.Contains(m_lastStateSyncPacketId))
{
m_acks.Add(m_lastStateSyncPacketId);
}
}
}
catch (BitStreamException)
{
}
}
public void ProcessReplicationCreate(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
TypeId typeId = m_receiveStream.ReadTypeId();
NetworkId networkID = m_receiveStream.ReadNetworkId();
byte groupCount = m_receiveStream.ReadByte();
var pendingReplicable = new MyPendingReplicable();
for (int i = 0; i < groupCount; i++)
{
var id = m_receiveStream.ReadNetworkId();
pendingReplicable.StateGroupIds.Add(id);
}
Type type = GetTypeByTypeId(typeId);
IMyReplicable replicable = (IMyReplicable)Activator.CreateInstance(type);
pendingReplicable.DebugObject = replicable;
pendingReplicable.IsStreaming = false;
m_pendingReplicables.Add(networkID, pendingReplicable);
replicable.OnLoad(m_receiveStream, (loaded) => SetReplicableReady(networkID, replicable, loaded));
}
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);
}
}
public void ReceiveWorld(MyPacket packet)
{
MyObjectBuilder_World world;
MyObjectBuilderSerializer.DeserializeGZippedXML <MyObjectBuilder_World>(new MemoryStream(MySerializer.CreateAndRead <byte[]>(packet.BitStream, null)), out world);
MyJoinGameHelper.WorldReceived(world, MyMultiplayer.Static);
}
/// <summary>
/// Processes state sync sent by server.
/// </summary>
public void ProcessStateSync(MyPacket packet)
{
// Simulated packet loss
// if (MyRandom.Instance.NextFloat() > 0.05f) return;
m_receiveStream.ResetRead(packet);
m_lastStateSyncPacketId = m_receiveStream.ReadByte();
while (m_receiveStream.BytePosition < m_receiveStream.ByteLength)
{
NetworkId networkID = m_receiveStream.ReadNetworkId();
IMyNetObject obj = GetObjectByNetworkId(networkID);
var pos = m_receiveStream.BytePosition;
NetProfiler.Begin(obj.GetType().Name);
Debug.Assert(obj != null && obj is IMyStateGroup, "IMyStateGroup not found by NetworkId");
((IMyStateGroup)obj).Serialize(m_receiveStream, null, m_lastStateSyncPacketId, 0);
NetProfiler.End(m_receiveStream.ByteLength - pos);
}
if (!m_acks.Contains(m_lastStateSyncPacketId))
{
m_acks.Add(m_lastStateSyncPacketId);
}
}
public void Serialize()
{
var packet = new MyPacket();
packet.foo = 14;
packet.bar = 44;
// TODO : endian
var bytes = packet.Serialize();
byte[] expected = new byte[] {
14,0,0,0, 44,0,0,0
};
var offset = Marshal.SizeOf<Packet>();
for (var i = offset; i < bytes.Length; i++)
{
Console.Write(bytes[i].ToString() + " ");
}
Console.WriteLine();
for(var i = offset; i < bytes.Length; i++)
{
Assert.AreEqual(
expected[i - offset],
bytes[i]);
}
}
public ChatMsg OnChatMessage(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
ChatMsg msg = VRage.Serialization.MySerializer.CreateAndRead <ChatMsg>(m_receiveStream);
return(msg);
}
public JoinResultMsg OnJoinResult(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
JoinResultMsg msg = VRage.Serialization.MySerializer.CreateAndRead <JoinResultMsg>(m_receiveStream);
return(msg);
}
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);
}
}
}
//Wysyla wiadomość gdy zestawimy polaczenie
public void SendMessage(IPAddress Destination, string dCapacity, string payload)
{
try
{
Predicate <Connections> isCurrentConnection = c => c.Destination == Destination.ToString();
Connections connection = connections.Find(isCurrentConnection);
MyPacket packet = new MyPacket(payload, OutPort, Destination.ToString(), IPAddress.ToString(), connection.slotWindow);
//packet.Port = OutPort;
//packet.Payload = payload;
//packet.DestinationAddress = IPAddress.Parse(Destination);
//packet.SourceAddress = IPAddress;D
mySocket.Send(packet);
NewLog($"Send message {packet.Payload} on port {packet.Port} FirstSlot: {connection.slotWindow.FirstSlot} NumberOfSlots: {connection.slotWindow.NumberofSlots}", window, "Pink");
}
catch (Exception e)
{
NewLog($"SendMessage EXCEPTION: {e}", window, "Pink");
foreach (var c in connections)
{
NewLog($"connections {c.Destination} {c.slotWindow.FirstSlot} {c.slotWindow.NumberofSlots}", window, "Pink");
}
}
//await Task.Delay(TimeSpan.FromMilliseconds(10000));
}
private unsafe void ProcessMessage(MyPacket p)
{
HandlerId id;
Action <MyPacket> action;
id.messageId = (MyMessageId)p.BitStream.ReadByte(8);
id.receiverIndex = p.BitStream.ReadByte(8);
if (((ulong)id.messageId) < this.m_thisFrameTraffic.Length)
{
int *numPtr1 = (int *)ref this.m_thisFrameTraffic[(int)id.messageId];
numPtr1[0] += p.BitStream.ByteLength;
}
p.Sender = new Endpoint(p.Sender.Id, id.receiverIndex);
if (!this.m_handlers.TryGetValue(id, out action))
{
HandlerId key = new HandlerId {
messageId = id.messageId,
receiverIndex = 0xff
};
this.m_handlers.TryGetValue(key, out action);
}
if (action == null)
{
p.Return();
}
else
{
MyStatsGraph.Begin(MyEnum <MyMessageId> .GetName(id.messageId), 0x7fffffff, "ProcessMessage", 0xe2, @"E:\Repo1\Sources\Sandbox.Game\Engine\Multiplayer\MyTransportLayer.cs");
action(p);
MyStatsGraph.End(new float?((float)p.BitStream.ByteLength), 0f, "", "{0} B", null, "ProcessMessage", 0xe4, @"E:\Repo1\Sources\Sandbox.Game\Engine\Multiplayer\MyTransportLayer.cs");
}
}
public ServerBattleDataMsg OnWorldBattleData(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
ServerBattleDataMsg msg = VRage.Serialization.MySerializer.CreateAndRead <ServerBattleDataMsg>(m_receiveStream);
return(msg);
}
private void OnWorldData(MyPacket packet)
{
ServerDataMsg msg = base.ReplicationLayer.OnWorldData(packet);
this.OnServerData(ref msg);
packet.Return();
}
private void OnJoinResult(MyPacket packet)
{
JoinResultMsg msg = base.ReplicationLayer.OnJoinResult(packet);
this.OnUserJoined(ref msg);
packet.Return();
}
void OnReplicationCreate(MyPacket packet)
{
while (MyEntities.HasEntitiesToDelete())
{
MyEntities.DeleteRememberedEntities();
}
ReplicationLayer.ProcessReplicationCreate(packet);
}
private void OnClientConnected(MyPacket packet)
{
Sync.ClientConnected(packet.Sender.Id.Value);
ConnectedClientDataMsg msg = base.ReplicationLayer.OnClientConnected(packet);
this.OnConnectedClient(ref msg);
packet.Return();
}
public void HeaderSize()
{
var packet = new MyPacket();
Assert.AreEqual(
Packet.headerSize + sizeof(int) * 2,
Marshal.SizeOf<MyPacket>());
}
private unsafe void ClientConnected(MyPacket packet)
{
Sync.ClientConnected(packet.Sender.Id.Value);
ConnectedClientDataMsg msg = base.ReplicationLayer.OnClientConnected(packet);
ConnectedClientDataMsg *msgPtr1 = (ConnectedClientDataMsg *)ref msg;
this.OnConnectedClient(ref (ConnectedClientDataMsg) ref msgPtr1, msg.SteamID);
packet.Return();
}
public void ProcessReplicationDestroy(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
NetworkId networkID = m_receiveStream.ReadNetworkId();
MyPendingReplicable pendingReplicable;
if (!m_pendingReplicables.TryGetValue(networkID, out pendingReplicable)) // When it wasn't in pending replicables, it's already active and in scene, destroy it
{
IMyReplicable replicable = (IMyReplicable)GetObjectByNetworkId(networkID);
// Debug.Assert(replicable != null, "Client received ReplicationDestroy, but object no longer exists (removed locally?)");
if (replicable != null)
{
using (m_tmpGroups)
{
var streamable = replicable as IMyStreamableReplicable;
if (streamable != null && streamable.NeedsToBeStreamed)
{
m_tmpGroups.Add(streamable.GetStreamingStateGroup());
}
replicable.GetStateGroups(m_tmpGroups);
foreach (var g in m_tmpGroups)
{
if (g == null)
{
continue;
}
if (g != replicable)
{
RemoveNetworkedObject(g);
}
g.Destroy();
}
}
RemoveNetworkedObject(replicable);
replicable.OnDestroy();
}
}
else
{
m_pendingReplicables.Remove(networkID);
if (pendingReplicable.IsStreaming)
{
IMyStateGroup group = (IMyStateGroup)GetObjectByNetworkId(pendingReplicable.StreamingGroupId);
if (group != null)
{
RemoveNetworkedObject(group);
group.Destroy();
}
}
m_eventBuffer.RemoveEvents(networkID);
}
}
public void SetByteで値を設定してgetByteで取得する()
{
//setUp
var sut = new MyPacket();
const byte expected = (byte) 0xfd;
sut.SetByte(expected, 20);
//exercise
var actual = sut.GetByte(20,1);
//verify
Assert.That(actual, Is.EqualTo(expected));
}
private void OnServerStateSync(MyPacket packet)
{
byte item = packet.BitStream.ReadByte(8);
if (!packet.BitStream.ReadBool() && !this.m_acks.Contains(item))
{
this.m_acks.Add(item);
}
this.m_lastStateSyncPacketId = item;
packet.Return();
}
public void SetIntで値を設定してgetIntで取得する()
{
//setUp
var sut = new MyPacket();
const int expected = 12345678;
sut.SetUInt(expected, 20);
//exercise
var actual = sut.GetUInt(20);
//verify
Assert.That(actual, Is.EqualTo(expected));
}
private void ControlMessageReceived(MyPacket p)
{
ITransportCallback callback;
MyControlMessageEnum enum2 = (MyControlMessageEnum)((byte)p.ByteStream.ReadUShort());
if (this.m_controlMessageHandlers.TryGetValue((int)enum2, out callback))
{
callback.Receive(p.ByteStream, p.Sender.Id.Value);
}
p.Return();
}
private bool arePacketsTheSame(MyPacket a, MyPacket b)
{
if (a.SourceIP.Equals(b.SourceIP) && a.DestIP.Equals(b.DestIP) && a.Checksum.Equals(b.Checksum) && a.Time.Equals(b.Time) && a.Length.Equals(b.Length))
{
return(true);
}
else
{
return(false);
}
}
public void SetLongで値を設定してgetLongで取得する()
{
//setUp
var sut = new MyPacket();
const ulong expected = (long) 3333;
sut.SetULong(expected, 20);
//exercise
var actual = sut.GetULong(20);
//verify
Assert.That(actual, Is.EqualTo(expected));
}
public void SetShortで値を設定してgetShortで取得する()
{
//setUp
var sut = new MyPacket();
//short expected = (short) 0xff01;
const ushort expected = 0x1f01;
sut.SetUShort(expected, 20);
//exercise
var actual = sut.GetUShort(20);
//verify
Assert.That(actual, Is.EqualTo(expected));
}
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();
}
public void SetIntで値を設定してgetIntで取得する()
{
//setUp
var sut = new MyPacket();
const int expected = 12345678;
sut.SetUInt(expected, 20);
//exercise
var actual = sut.GetUInt(20);
//verify
Assert.That(actual, Is.EqualTo(expected));
}
public void SetByteで値を設定してgetByteで取得する()
{
//setUp
var sut = new MyPacket();
const byte expected = (byte)0xfd;
sut.SetByte(expected, 20);
//exercise
var actual = sut.GetByte(20, 1);
//verify
Assert.That(actual, Is.EqualTo(expected));
}
public void SetLongで値を設定してgetLongで取得する()
{
//setUp
var sut = new MyPacket();
const ulong expected = (long)3333;
sut.SetULong(expected, 20);
//exercise
var actual = sut.GetULong(20);
//verify
Assert.That(actual, Is.EqualTo(expected));
}
public void ReceivePlayerData(MyPacket packet)
{
PlayerDataMsg msg = this.ReplicationLayer.OnPlayerData(packet);
if ((MySession.Static != null) || (msg.ClientSteamId == Sync.MyId))
{
MySession.Static.Players.OnInitialPlayerCreated(msg.ClientSteamId, msg.PlayerSerialId, msg.IdentityId, msg.DisplayName, msg.BuildColors, msg.RealPlayer, msg.NewIdentity);
}
else
{
packet.BitStream.SetBitPositionRead(0);
base.SyncLayer.TransportLayer.AddMessageToBuffer(packet);
}
}
private bool packetIsGoodForFilter(MyPacket myP)
{
//tu tzeba czyscic filterTextBox.Text i bd dzialac
switch (filterComboBox.SelectedValue.ToString())
{
case "Adres źródłowy MAC":
if (myP.SourceMac == filterTextBox.Text)
{
return(true);
}
else
{
return(false);
}
case "Adres docelowy MAC":
if (myP.DestMac == filterTextBox.Text)
{
return(true);
}
else
{
return(false);
}
case "Adres źródłowy IP":
if (myP.SourceIP == filterTextBox.Text)
{
return(true);
}
else
{
return(false);
}
case "Adres docelowy IP":
if (myP.DestIP == filterTextBox.Text)
{
return(true);
}
else
{
return(false);
}
default:
return(false);
}
}
public void SetShortで値を設定してgetShortで取得する()
{
//setUp
var sut = new MyPacket();
//short expected = (short) 0xff01;
const ushort expected = 0x1f01;
sut.SetUShort(expected, 20);
//exercise
var actual = sut.GetUShort(20);
//verify
Assert.That(actual, Is.EqualTo(expected));
}
public void SetBytesで値を設定してgetBytesで取得する()
{
//setUp
var sut = new MyPacket();
var expected = new byte[Max - 20];
for (var i = 0; i < Max - 20; i++){
expected[i] = (byte) i;
}
sut.SetBytes(expected, 20);
//exercise
var actual = sut.GetBytes(20, Max - 20);
//verify
Assert.That(actual, Is.EqualTo(expected));
}
internal void AddPacketToView(MyPacket tempPacket)
{
var listItem = new ListViewItem()
{
Text = tempPacket.PacketType
};
AddSubItem(listItem, "From", tempPacket.SourceAddress + ":"
+ tempPacket.SourcePort);
AddSubItem(listItem, "To", tempPacket.DestinationAddress + ":"
+ tempPacket.DestinationPort);
AddSubItem(listItem, "Message", tempPacket.PacketMessage);
_target.AddListViewItem(listItem);
}
public MyPacket RoutePacket(MyPacket packet, TablesInNode getTables, NetworkNodeWindow window)
{
Window = window;
RoutingTables = getTables;
MyPacket routedPacket = null;
int tableCount = getTables.SlTable.Records.Count;
int portIn = packet.Port;
int modType = packet.Performance;
int startingSlot = packet.Frequency;
int slotNr = packet.Bandwith;
int endFor = slotNr + startingSlot;
for (int i = 0; i < tableCount; i++)
{
NewLog($"count {portIn} ::::{getTables.SlTable.Records[i].PortIn}", Window);
if (portIn == getTables.SlTable.Records[i].PortIn)
{
NewLog($"wszedl {portIn} ::::{getTables.SlTable.Records[i].PortIn}", Window);
//for (int z = startingSlot; z < endFor; z++)
//{
// getTables.SlTable.SlotsTable[z] = startingSlot;
//}
//getTables.SlTable.Records[i].IsUsed = true;
//getTables.SlTable.Records[i].ModNumber = modType;
//getTables.SlTable.Records[i].FirstSlotID = startingSlot;
packet.Port = getTables.SlTable.Records[i].PortOut;
NewLog($"wszedl csoic ::::{getTables.SlTable.Records[i].PortOut}", Window);
routedPacket = packet;
break;
}
}
NewLog($"countfsdjsj ::::{routedPacket.Port}", Window);
if (routedPacket == null)
{
NewLog("Pakiet odrzucony, brak odpowiedniego rekordu", Window);
return(null);
}
return(routedPacket);
}
public static void ResetRead(this BitStream stream, MyPacket packet)
{
stream.ResetRead(packet.Data, packet.PayloadOffset, packet.PayloadLength * 8);
}
/// <summary>
/// Processes state sync sent by server.
/// </summary>
public void ProcessStateSync(MyPacket packet)
{
// Simulated packet loss
// if (MyRandom.Instance.NextFloat() > 0.05f) return;
m_receiveStream.ResetRead(packet);
m_lastStateSyncPacketId = m_receiveStream.ReadByte();
while (m_receiveStream.BytePosition < m_receiveStream.ByteLength)
{
NetworkId networkID = m_receiveStream.ReadNetworkId();
IMyNetObject obj = GetObjectByNetworkId(networkID);
var pos = m_receiveStream.BytePosition;
NetProfiler.Begin(obj.GetType().Name);
Debug.Assert(obj != null && obj is IMyStateGroup, "IMyStateGroup not found by NetworkId");
((IMyStateGroup)obj).Serialize(m_receiveStream, null, m_lastStateSyncPacketId, 0);
NetProfiler.End(m_receiveStream.ByteLength - pos);
}
if (!m_acks.Contains(m_lastStateSyncPacketId))
{
m_acks.Add(m_lastStateSyncPacketId);
}
}
public void ProcessReplicationCreate(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
TypeId typeId = m_receiveStream.ReadTypeId();
NetworkId networkID = m_receiveStream.ReadNetworkId();
byte groupCount = m_receiveStream.ReadByte();
var pendingReplicable = new MyPendingReplicable();
for (int i = 0; i < groupCount; i++)
{
var id = m_receiveStream.ReadNetworkId();
pendingReplicable.StateGroupIds.Add(id);
}
Type type = GetTypeByTypeId(typeId);
IMyReplicable replicable = (IMyReplicable)Activator.CreateInstance(type);
pendingReplicable.DebugObject = replicable;
m_pendingReplicables.Add(networkID, pendingReplicable);
replicable.OnLoad(m_receiveStream, () => SetReplicableReady(networkID, replicable));
}
public void ProcessReplicationDestroy(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
NetworkId networkID = m_receiveStream.ReadNetworkId();
if (!m_pendingReplicables.Remove(networkID)) // When it wasn't in pending replicables, it's already active and in scene, destroy it
{
IMyReplicable replicable = (IMyReplicable)GetObjectByNetworkId(networkID);
using (m_tmpGroups)
{
replicable.GetStateGroups(m_tmpGroups);
foreach (var g in m_tmpGroups)
{
if (g != replicable)
RemoveNetworkedObject(g);
}
}
RemoveNetworkedObject(replicable);
replicable.OnDestroy();
}
}
public void ProcessServerData(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
SerializeTypeTable(m_receiveStream);
m_hasTypeTable = true;
}
public void ReplicableReady(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
var networkId = m_receiveStream.ReadNetworkId();
bool loaded = m_receiveStream.ReadBool();
Debug.Assert(m_clientStates.ContainsKey(packet.Sender), "Client data not found");
// Client left can be received in another channel (e.g. through lobby), so it may happen that it comes before this packet
ClientData clientData;
if (m_clientStates.TryGetValue(packet.Sender, out clientData))
{
var replicable = GetObjectByNetworkId(networkId) as IMyReplicable;
MyReplicableClientData replicableClientData;
if (replicable != null && !loaded)
{
RemoveForClient(replicable, packet.Sender, clientData, false);
}
else if (replicable != null && clientData.Replicables.TryGetValue(replicable, out replicableClientData))
{
// Replicable can be destroyed for client or destroyed completely at this point
Debug.Assert(replicableClientData.IsPending == true, "Replicable ready from client, but it's not pending for client");
replicableClientData.IsPending = false;
replicableClientData.IsStreaming = false;
foreach (var child in m_replicables.GetChildren(replicable))
{
AddForClient(child, packet.Sender, clientData, replicableClientData.Priority,false);
}
m_tmp.Clear();
foreach (var forcedReplicable in clientData.ForcedReplicables)
{
if (forcedReplicable.Value == replicable)
{
m_tmp.Add(forcedReplicable.Key);
if (!clientData.Replicables.ContainsKey(forcedReplicable.Key) && m_replicableGroups.ContainsKey(forcedReplicable.Key))
{
AddForClient(forcedReplicable.Key,packet.Sender, clientData, 0,true);
}
}
}
foreach (var replicableToRemove in m_tmp)
{
clientData.ForcedReplicables.Remove(replicableToRemove);
}
m_tmp.Clear();
}
// Check if this replicable was blocked, if yes than remove from blocking list.
if (replicable != null)
this.ProcessBlocker(replicable, packet.Sender, clientData, null);
}
}
public void OnClientUpdate(MyPacket packet)
{
ClientData clientData;
if (!m_clientStates.TryGetValue(packet.Sender, out clientData))
return; // Unknown client, probably kicked
if (m_processedClients.Contains(packet.Sender))
{
return;
}
m_processedClients.Add(packet.Sender);
m_receiveStream.ResetRead(packet);
// Read last state sync packet id
clientData.LastStateSyncPacketId = m_receiveStream.ReadByte();
// Read ACKs
byte count = m_receiveStream.ReadByte();
for (int i = 0; i < count; i++)
{
OnAck(m_receiveStream.ReadByte(), clientData);
}
byte firstDropId, lastDropId;
if (clientData.WaitingForReset)
{
// Client wasn't sending ACKs for long time (m_outOfOrderResetProtection = 64)
// Set new packet id
// Mark everything except 64 packets before new packed id as FAIL
clientData.StateSyncPacketId = (byte)(clientData.LastStateSyncPacketId + m_outOfOrderResetProtection);
firstDropId = (byte)(clientData.StateSyncPacketId + 1);
lastDropId = (byte)(firstDropId - m_outOfOrderResetProtection);
clientData.WaitingForReset = false;
}
else
{
// Process not delivered ACKs (m_outOfOrderAcceptThreshold = 6)
// LastReceivedAckId - 6 ... StateSyncPacketId is waiting for ACK
// StateSyncPacketId + 1 ... LastReceivedAckId - 7 is FAIL
firstDropId = (byte)(clientData.StateSyncPacketId + 1); // Intentional overflow
lastDropId = (byte)(clientData.LastReceivedAckId - m_outOfOrderAcceptThreshold); // Intentional overflow
}
for (byte i = firstDropId; i != lastDropId; i++) // Intentional overflow
{
RaiseAck(clientData, i, false);
}
// Read client state
clientData.State.Serialize(m_receiveStream);
}
public void ReplicableReady(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
var networkId = m_receiveStream.ReadNetworkId();
Debug.Assert(m_clientStates.ContainsKey(packet.Sender), "Client data not found");
ClientData clientData = m_clientStates[packet.Sender];
var replicable = GetObjectByNetworkId(networkId) as IMyReplicable;
// Replicable can be destroyed for client or destroyed completely at this point
MyReplicableClientData replicableClientData;
if (replicable != null && clientData.Replicables.TryGetValue(replicable, out replicableClientData))
{
Debug.Assert(replicableClientData.IsPending == true, "Replicable ready from client, but it's not pending for client");
replicableClientData.IsPending = false;
}
}
public void OnClientUpdate(MyPacket packet)
{
Debug.Assert(m_clientStates.ContainsKey(packet.Sender), "Client entry not found, client should be already joined at this point");
var clientData = m_clientStates[packet.Sender];
m_receiveStream.ResetRead(packet);
// Read last state sync packet id
clientData.LastStateSyncPacketId = m_receiveStream.ReadByte();
// Read ACKs
byte count = m_receiveStream.ReadByte();
for (int i = 0; i < count; i++)
{
OnAck(m_receiveStream.ReadByte(), clientData);
}
byte firstDropId, lastDropId;
if (clientData.WaitingForReset)
{
// Client wasn't sending ACKs for long time (m_outOfOrderResetProtection = 64)
// Set new packet id
// Mark everything except 64 packets before new packed id as FAIL
clientData.StateSyncPacketId = (byte)(clientData.LastStateSyncPacketId + m_outOfOrderResetProtection);
firstDropId = (byte)(clientData.StateSyncPacketId + 1);
lastDropId = (byte)(firstDropId - m_outOfOrderResetProtection);
clientData.WaitingForReset = false;
}
else
{
// Process not delivered ACKs (m_outOfOrderAcceptThreshold = 6)
// LastReceivedAckId - 6 ... StateSyncPacketId is waiting for ACK
// StateSyncPacketId + 1 ... LastReceivedAckId - 7 is FAIL
firstDropId = (byte)(clientData.StateSyncPacketId + 1); // Intentional overflow
lastDropId = (byte)(clientData.LastReceivedAckId - m_outOfOrderAcceptThreshold); // Intentional overflow
}
for (byte i = firstDropId; i != lastDropId; i++) // Intentional overflow
{
RaiseAck(clientData, i, false);
}
// Read client state
clientData.State.Serialize(m_receiveStream);
}
public void ProcessReplicationDestroy(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
NetworkId networkID = m_receiveStream.ReadNetworkId();
MyPendingReplicable pendingReplicable;
if (!m_pendingReplicables.TryGetValue(networkID, out pendingReplicable)) // When it wasn't in pending replicables, it's already active and in scene, destroy it
{
IMyReplicable replicable = (IMyReplicable)GetObjectByNetworkId(networkID);
// Debug.Assert(replicable != null, "Client received ReplicationDestroy, but object no longer exists (removed locally?)");
if (replicable != null)
{
using (m_tmpGroups)
{
var streamable = replicable as IMyStreamableReplicable;
if (streamable != null && streamable.NeedsToBeStreamed)
{
m_tmpGroups.Add(streamable.GetStreamingStateGroup());
}
replicable.GetStateGroups(m_tmpGroups);
foreach (var g in m_tmpGroups)
{
if (g == null)
{
continue;
}
if (g != replicable)
RemoveNetworkedObject(g);
g.Destroy();
}
}
RemoveNetworkedObject(replicable);
replicable.OnDestroy();
}
}
else
{
m_pendingReplicables.Remove(networkID);
if (pendingReplicable.IsStreaming)
{
IMyStateGroup group = (IMyStateGroup)GetObjectByNetworkId(pendingReplicable.StreamingGroupId);
if (group != null)
{
RemoveNetworkedObject(group);
group.Destroy();
}
}
m_eventBuffer.RemoveEvents(networkID);
}
}
public void ProcessReplicationCreateBegin(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
TypeId typeId = m_receiveStream.ReadTypeId();
NetworkId networkID = m_receiveStream.ReadNetworkId();
byte groupCount = m_receiveStream.ReadByte();
var pendingReplicable = new MyPendingReplicable();
for (int i = 0; i < groupCount; i++)
{
var id = m_receiveStream.ReadNetworkId();
pendingReplicable.StateGroupIds.Add(id);
}
Type type = GetTypeByTypeId(typeId);
IMyReplicable replicable = (IMyReplicable)Activator.CreateInstance(type);
pendingReplicable.DebugObject = replicable;
m_pendingReplicables.Add(networkID, pendingReplicable);
var ids = pendingReplicable.StateGroupIds;
using (m_tmpGroups)
{
IMyStreamableReplicable streamable = replicable as IMyStreamableReplicable;
if (streamable != null)
{
pendingReplicable.IsStreaming = true;
var group = streamable.GetStreamingStateGroup();
m_tmpGroups.Add(group);
}
for (int i = 0; i < m_tmpGroups.Count; i++)
{
if (m_tmpGroups[i] != replicable)
{
AddNetworkObjectClient(ids[i], m_tmpGroups[i]);
pendingReplicable.StreamingGroupId = ids[i];
}
}
}
replicable.OnLoadBegin(m_receiveStream, (loaded) => SetReplicableReady(networkID, replicable, loaded));
}
/// <summary>
/// Processes state sync sent by server.
/// </summary>
public void ProcessStateSync(MyPacket packet)
{
LastMessageFromServer = DateTime.UtcNow;
// Simulated packet loss
// if (MyRandom.Instance.NextFloat() > 0.3f) return;
m_receiveStream.ResetRead(packet);
bool isStreaming = m_receiveStream.ReadBool();
m_lastStateSyncPacketId = m_receiveStream.ReadByte();
try
{
while (m_receiveStream.BytePosition < m_receiveStream.ByteLength)
{
NetworkId networkID = m_receiveStream.ReadNetworkId();
IMyStateGroup obj = GetObjectByNetworkId(networkID) as IMyStateGroup;
if (obj == null)
{
if (isStreaming == false)
{
Debug.Fail("IMyStateGroup not found by NetworkId");
break;
}
else
{
return;
}
}
if (isStreaming && obj.GroupType != StateGroupEnum.Streamining)
{
Debug.Fail("group type mismatch !");
MyLog.Default.WriteLine("received streaming flag but group is not streaming !");
return;
}
if (!isStreaming && obj.GroupType == StateGroupEnum.Streamining)
{
Debug.Fail("group type mismatch !");
MyLog.Default.WriteLine("received non streaming flag but group wants to stream !");
return;
}
var pos = m_receiveStream.BytePosition;
NetProfiler.Begin(obj.GetType().Name);
obj.Serialize(m_receiveStream, ClientState.EndpointId, 0, m_lastStateSyncPacketId, 0);
NetProfiler.End(m_receiveStream.ByteLength - pos);
if (!m_acks.Contains(m_lastStateSyncPacketId))
{
m_acks.Add(m_lastStateSyncPacketId);
}
}
}
catch (BitStreamException)
{
}
}
public JoinResultMsg OnJoinResult(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
JoinResultMsg msg = VRage.Serialization.MySerializer.CreateAndRead<JoinResultMsg>(m_receiveStream);
return msg;
}
public ServerBattleDataMsg OnWorldBattleData(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
ServerBattleDataMsg msg = VRage.Serialization.MySerializer.CreateAndRead<ServerBattleDataMsg>(m_receiveStream);
return msg;
}
public ChatMsg OnChatMessage(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
ChatMsg msg = VRage.Serialization.MySerializer.CreateAndRead<ChatMsg>(m_receiveStream);
return msg;
}
public ConnectedClientDataMsg OnClientConnected(MyPacket packet)
{
m_receiveStream.ResetRead(packet);
ConnectedClientDataMsg msg = VRage.Serialization.MySerializer.CreateAndRead<ConnectedClientDataMsg>(m_receiveStream);
return msg;
}
