public void Reset() { reliablePacketHeader = default; userPacketHeader = default; stream = default; receptionCallback = default; }
public void OnReceiveData(byte[] data, IPEndPoint iPEndPoint) { MemoryStream memoryStream = new MemoryStream(data); PacketWithCrc packetWithCrc = new PacketWithCrc(); packetWithCrc.Deserialize(memoryStream); memoryStream.Close(); if (crc32.IsDataCorrupted(packetWithCrc.data, packetWithCrc.crc)) { UnityEngine.Debug.LogError("Received corrupted data from " + iPEndPoint); return; } memoryStream = new MemoryStream(packetWithCrc.data); PacketHeader packetHeader = new PacketHeader(); packetHeader.Deserialize(memoryStream); if ((PacketType)packetHeader.packetTypeID == PacketType.User) { UserPacketHeader userPacketHeader = new UserPacketHeader(); userPacketHeader.Deserialize(memoryStream); ReliablePacketHeader reliablePacketHeader = new ReliablePacketHeader(); reliablePacketHeader.Deserialize(memoryStream); ProcessReliablePacketReceived(reliablePacketHeader); InvokeCallback(userPacketHeader, memoryStream); } else { NetworkManager.Instance.OnReceivePacket(iPEndPoint, (PacketType)packetHeader.packetTypeID, memoryStream); } memoryStream.Close(); }
void ProcessReceivedAcknowledgeInfo(ReliablePacketHeader reliablePacketHeader, uint senderID) { int ackBits = reliablePacketHeader.AckBits; int pendingIndex = -1; int i = 1; do { if ((ackBits & 1) != 0) { pendingIndex = Array.FindIndex(packetsPendingAck[senderID], ppa => ppa.packetID == reliablePacketHeader.Acknowledge); if (pendingIndex != -1) { packetsPendingAck[senderID][pendingIndex].Reset(); } } ackBits >>= 1; i++; } while (ackBits != 0); pendingIndex = -1; pendingIndex = Array.FindIndex(packetsPendingAck[senderID], ppa => ppa.packetID == reliablePacketHeader.Acknowledge); if (pendingIndex != -1) { packetsPendingAck[senderID][pendingIndex].Reset(); } }
public byte[] SerializePacket <T>(NetworkPacket <T> networkPacket, uint senderID = 0, uint objectID = 0, ReliablePacketHeader reliablePacketHeader = null) { byte[] data = null; PacketWrapper packetWrapper = new PacketWrapper(); MemoryStream memoryStream = new MemoryStream(); PacketHeader packetHeader = new PacketHeader(); packetHeader.ProtocolID = ProtocolID; packetHeader.PacketTypeIndex = networkPacket.PacketTypeIndex; packetHeader.Serialize(memoryStream); if ((PacketType)networkPacket.PacketTypeIndex == PacketType.User) { UserNetworkPacket <T> userNetworkPacket = networkPacket as UserNetworkPacket <T>; UserPacketHeader userPacketHeader = new UserPacketHeader(); userPacketHeader.UserPacketTypeIndex = userNetworkPacket.UserPacketTypeIndex; userPacketHeader.SenderID = senderID; userPacketHeader.ObjectID = objectID; userPacketHeader.Reliable = (reliablePacketHeader != null); userPacketHeader.Serialize(memoryStream); if (reliablePacketHeader != null) { reliablePacketHeader.Serialize(memoryStream); } } networkPacket.Serialize(memoryStream); memoryStream.Close(); data = memoryStream.ToArray(); packetWrapper.Crc = crcCalculator.ComputeCrc32(data); packetWrapper.PacketData = data; memoryStream = new MemoryStream(); packetWrapper.Serialize(memoryStream); memoryStream.Close(); data = memoryStream.ToArray(); return(data); }
private void ProcessReliablePacketReceived(ReliablePacketHeader reliablePacketHeader) { if (enablePacketLossSimulation && UnityEngine.Random.Range(0, 100) < porcentageOfPacketLossSimulation) { UnityEngine.Debug.Log("Packet lost simulation"); return; } if (reliablePacketHeader.sequence > remoteSequence) { remoteSequence = reliablePacketHeader.sequence; } if (!sequenceNumbersReceived.Contains(reliablePacketHeader.sequence)) { sequenceNumbersReceived.Enqueue(reliablePacketHeader.sequence); } if (sequenceNumbersReceived.Count > numberOfBitsInAck) { sequenceNumbersReceived.Dequeue(); } int ackBits = reliablePacketHeader.ackBitfield; //UnityEngine.Debug.Log("Ackbits received: " + Convert.ToString(ackBits, 2)); for (int i = 0; i < numberOfBitsInAck; i++) { if ((ackBits & (1 << i)) != 0) { int packetSequenceToAck = (int)(reliablePacketHeader.ack - i); //UnityEngine.Debug.Log("Bit at position " + i + " is set."); //UnityEngine.Debug.Log("Acknowledging packet sequence " + packetSequenceToAck); if (packetsPendingToBeAcked.ContainsKey((uint)packetSequenceToAck)) { //UnityEngine.Debug.Log("Removin packet Nro." + packetSequenceToAck + " from pending list"); packetsPendingToBeAcked.Remove((uint)packetSequenceToAck); } } } }
public void ReceiveData(byte[] data, IPEndPoint ipEndPoint) { MemoryStream memoryStream = null; PacketHeader packetHeader = null; UserPacketHeader userPacketHeader = null; ReliablePacketHeader reliablePacketHeader = null; if (DeserializePacket(data, out memoryStream, out packetHeader, ref userPacketHeader, ref reliablePacketHeader)) { if (packetHeader.ProtocolID == ProtocolID) { if (userPacketHeader != null) { if (userPacketHeader.Reliable) { Action <ushort, uint, Stream> processCallback = GetPacketReceptionCallback(userPacketHeader.ObjectID); PacketReliabilityManager.Instance.ProcessReceivedStream(memoryStream, userPacketHeader, reliablePacketHeader, processCallback); } else { InvokeReceptionCallback(userPacketHeader.ObjectID, userPacketHeader.UserPacketTypeIndex, userPacketHeader.SenderID, memoryStream); } } else { systemPacketReceptionCallback?.Invoke(packetHeader.PacketTypeIndex, ipEndPoint, memoryStream); } if (userPacketHeader == null || !userPacketHeader.Reliable) { memoryStream.Close(); } } } }
bool DeserializePacket(byte[] data, out MemoryStream memoryStream, out PacketHeader packetHeader, ref UserPacketHeader userPacketHeader, ref ReliablePacketHeader reliablePacketHeader) { bool isFaultless; PacketWrapper packetWrapper = new PacketWrapper(); memoryStream = new MemoryStream(data); packetHeader = new PacketHeader(); packetWrapper.Deserialize(memoryStream); memoryStream.Close(); isFaultless = crcCalculator.PerformCrcCheck(packetWrapper.PacketData, packetWrapper.Crc); if (isFaultless) { memoryStream = new MemoryStream(packetWrapper.PacketData); packetHeader.Deserialize(memoryStream); if ((PacketType)packetHeader.PacketTypeIndex == PacketType.User) { userPacketHeader = new UserPacketHeader(); userPacketHeader.Deserialize(memoryStream); if (userPacketHeader.Reliable) { reliablePacketHeader = new ReliablePacketHeader(); reliablePacketHeader.Deserialize(memoryStream); } } } return(isFaultless); }
public void SendPacket <T>(NetworkPacket <T> networkPacket, uint senderID, uint objectID) { foreach (uint recipientID in packetsPendingAck.Keys) { ReliablePacketHeader reliablePacketHeader = new ReliablePacketHeader(); MemoryStream memoryStream = new MemoryStream(); PacketPendingAck packetPendingAck; byte[] dataToSend; int packetID = currentPacketIDs[recipientID]++; reliablePacketHeader.PacketID = packetID; reliablePacketHeader.Acknowledge = acknowledges[recipientID]; reliablePacketHeader.AckBits = ackBits[recipientID]; dataToSend = PacketsManager.Instance.SerializePacket(networkPacket, senderID, objectID, reliablePacketHeader); packetPendingAck.recipientID = recipientID; packetPendingAck.packetID = packetID; packetPendingAck.packetData = dataToSend; packetsPendingAck[recipientID][packetID % AckBitsCount] = packetPendingAck; SendDataToDestination(dataToSend, recipientID); } }
public void ProcessReceivedStream(Stream stream, UserPacketHeader userPacketHeader, ReliablePacketHeader reliablePacketHeader, Action <ushort, uint, Stream> processCallback) { uint senderID = (UdpNetworkManager.Instance.IsServer) ? userPacketHeader.SenderID : 0; if (reliablePacketHeader.PacketID >= nextExpectedIDs[senderID]) { if (reliablePacketHeader.PacketID > acknowledges[senderID]) { acknowledges[senderID] = reliablePacketHeader.PacketID; } receivedPacketIDs[senderID][reliablePacketHeader.PacketID % AckBitsCount] = reliablePacketHeader.PacketID; UpdateAcknowledgeBits(senderID); int packetIndex = reliablePacketHeader.PacketID % AckBitsCount; packetsPendingProcess[senderID][packetIndex].reliablePacketHeader = reliablePacketHeader; packetsPendingProcess[senderID][packetIndex].userPacketHeader = userPacketHeader; packetsPendingProcess[senderID][packetIndex].stream = stream; packetsPendingProcess[senderID][packetIndex].receptionCallback = processCallback; if (reliablePacketHeader.PacketID == nextExpectedIDs[senderID]) { while (packetsPendingProcess[senderID][packetIndex].stream != null) { processCallback(packetsPendingProcess[senderID][packetIndex].userPacketHeader.UserPacketTypeIndex, packetsPendingProcess[senderID][packetIndex].userPacketHeader.SenderID, packetsPendingProcess[senderID][packetIndex].stream); packetsPendingProcess[senderID][packetIndex].stream.Close(); packetsPendingProcess[senderID][packetIndex].Reset(); packetIndex = (packetIndex + 1) % AckBitsCount; nextExpectedIDs[senderID]++; } } ProcessReceivedAcknowledgeInfo(reliablePacketHeader, senderID); } }
public byte[] SerializePacket <T>(NetworkPacket <T> packetToSerialize, bool isReliable = false, uint objectID = 0) { MemoryStream memoryStream = new MemoryStream(); PacketHeader packetHeader = new PacketHeader(); packetHeader.packetTypeID = (uint)packetToSerialize.type; packetHeader.Serialize(memoryStream); if (packetToSerialize.type == PacketType.User) { UserPacketHeader userPacketHeader = new UserPacketHeader(); userPacketHeader.packetTypeID = packetToSerialize.userPacketTypeID; userPacketHeader.packetID = localSequence; userPacketHeader.senderID = NetworkManager.Instance.clientID; userPacketHeader.objectID = objectID; userPacketHeader.isReliable = isReliable; userPacketHeader.Serialize(memoryStream); ReliablePacketHeader reliablePacketHeader = new ReliablePacketHeader(); reliablePacketHeader.sequence = localSequence; reliablePacketHeader.ack = remoteSequence; //UnityEngine.Debug.Log("Setting up ackbits for packet Nro." + localSequence); ackBitfields = 0; for (int i = 0; i <= numberOfBitsInAck; i++) { if (sequenceNumbersReceived.Contains((uint)(remoteSequence - i))) { //UnityEngine.Debug.Log("Sequence number is contained: " + (int)(expectedSequence - i)); ackBitfields |= 1 << i; } } //UnityEngine.Debug.Log("Ackbits to send: " + Convert.ToString(ackBitfields, 2)); reliablePacketHeader.ackBitfield = ackBitfields; reliablePacketHeader.Serialize(memoryStream); } packetToSerialize.Serialize(memoryStream); PacketWithCrc packetWithCrc = new PacketWithCrc(); packetWithCrc.crc = crc32.CalculateCrc(memoryStream.ToArray()); packetWithCrc.byteLength = memoryStream.ToArray().Length; packetWithCrc.data = memoryStream.ToArray(); memoryStream.Close(); memoryStream = new MemoryStream(); packetWithCrc.Serialize(memoryStream); memoryStream.Close(); if (isReliable) { if (!packetsPendingToBeAcked.ContainsKey(localSequence)) { packetsPendingToBeAcked.Add(localSequence, memoryStream.ToArray()); } } return(memoryStream.ToArray()); }