byte[] Serialize <T>(NetworkPacket <T> packet, uint objectId)
{
PacketHeader header = new PacketHeader();
UserPacketHeader userHeader = new UserPacketHeader();
MemoryStream stream = new MemoryStream();
header.protocolId = 0;
header.packetType = packet.packetType;
if (packet.packetType == PacketType.User)
{
userHeader.packetType = packet.userPacketType;
userHeader.senderId = NetworkManager.Instance.clientId;
userHeader.objectId = objectId;
}
header.Serialize(stream);
userHeader.Serialize(stream);
packet.Serialize(stream);
stream.Close();
return(stream.ToArray());
}
byte[] Serialize <T>(OrderedNetworkPacket <T> packet, uint objectId, uint id)
{
PacketHeader header = new PacketHeader();
UserPacketHeader userHeader = new UserPacketHeader();
MemoryStream stream = new MemoryStream();
header.protocolId = 0;
header.packetType = packet.packetType;
if (packet.packetType == PacketType.User)
{
userHeader.packetType = packet.userPacketType;
userHeader.senderId = NetworkManager.Instance.clientId;
userHeader.objectId = objectId;
}
header.Serialize(stream);
userHeader.Serialize(stream);
packet.Serialize(stream, id);// igual que Serialize normal, pero se agrega un paquete con el ID
stream.Close();
return(stream.ToArray());
}
private byte[] SerializePacket <T>(NetworkPacket <T> networkPacket, uint senderId, uint objectId)
{
PacketHeader packetHeader = new PacketHeader();
MemoryStream stream = new MemoryStream();
packetHeader.packetType = networkPacket.packetType;
packetHeader.Serialize(stream);
if ((PacketType)networkPacket.packetType == PacketType.User)
{
GamePacket <T> gamePacket = networkPacket as GamePacket <T>;
UserPacketHeader userPacketHeader = new UserPacketHeader();
userPacketHeader.id = currentPacketId++;
userPacketHeader.senderId = senderId;
userPacketHeader.objectId = objectId;
userPacketHeader.packetType = gamePacket.userPacketType;
userPacketHeader.Serialize(stream);
}
networkPacket.Serialize(stream);
stream.Close();
return(stream.ToArray());
}
byte[] Serialize <T>(NetworkPacket <T> packet, uint objectId = 0, uint senderId = 0)
{
PacketHeader header = new PacketHeader();
MemoryStream stream = new MemoryStream();
header.protocolId = 0;
header.packetType = packet.packetType;
header.Serialize(stream);
if (packet.packetType == (ushort)PacketType.User)
{
UserPacketHeader userHeader = new UserPacketHeader();
userHeader.packetType = packet.userPacketType;
userHeader.packetId = currentPacketId++;
//userHeader.senderId = ConnectionManager.Instance.clientId;
userHeader.senderId = senderId;
userHeader.objectId = objectId;
userHeader.Serialize(stream);
}
packet.Serialize(stream);
stream.Close();
return(stream.ToArray());
}
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 byte[] Serialize(SerializablePacket packet, int objectId = 0)
{
PacketHeader header = new PacketHeader();
MemoryStream memoryStream = new MemoryStream();
header.protocolId = currentPacketId;
header.type = packet.packetType;
header.Serialize(memoryStream);
Debug.Log("Serialize: " + header.type);
if (header.type == PacketType.User)
{
UserPacketHeader userHeader = new UserPacketHeader();
userHeader.id = currentPacketId;
userHeader.clientId = NetworkManager.Instance.clientId;
userHeader.objectId = objectId;
userHeader.userType = packet.userType;
userHeader.Serialize(memoryStream);
}
packet.Serialize(memoryStream);
memoryStream.Close();
return(memoryStream.ToArray());
}
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());
}
