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 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 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); }
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)); }
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; }