You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
355 lines
14 KiB
355 lines
14 KiB
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using UnityEngine;
|
|
|
|
namespace Networking.Architecture {
|
|
|
|
|
|
public class Packet : IDisposable {
|
|
private List<byte> _buffer;
|
|
|
|
private bool _disposed;
|
|
private byte[] _readableBuffer;
|
|
private int _readPos;
|
|
|
|
/// <summary>Creates a new empty packet (without an ID).</summary>
|
|
public Packet() {
|
|
_buffer = new List<byte>(); // Initialize buffer
|
|
_readPos = 0; // Set readPos to 0
|
|
}
|
|
|
|
/// <summary>Creates a new packet with a given ID. Used for sending.</summary>
|
|
/// <param name="packetTypeId">The packetType ID.</param>
|
|
/// <param name="packetActionId">The packetAction ID.</param>
|
|
public Packet(int packetTypeId, int packetActionId) {
|
|
_buffer = new List<byte>(); // Initialize buffer
|
|
_readPos = 0; // Set readPos to 0
|
|
|
|
Write(packetTypeId); // Write packet ids to the buffer
|
|
Write(packetActionId);
|
|
}
|
|
|
|
/// <summary>Creates a packet from which data can be read. Used for receiving.</summary>
|
|
/// <param name="data">The bytes to add to the packet.</param>
|
|
public Packet(byte[] data) {
|
|
_buffer = new List<byte>(); // Initialize buffer
|
|
_readPos = 0; // Set readPos to 0
|
|
|
|
SetBytes(data);
|
|
}
|
|
|
|
public void Dispose() {
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
private void Dispose(bool disposing) {
|
|
if (_disposed)
|
|
return;
|
|
if (disposing) {
|
|
_buffer = null;
|
|
_readableBuffer = null;
|
|
_readPos = 0;
|
|
}
|
|
|
|
_disposed = true;
|
|
}
|
|
|
|
#region Functions
|
|
/// <summary>Sets the packet's content and prepares it to be read.</summary>
|
|
/// <param name="data">The bytes to add to the packet.</param>
|
|
public void SetBytes(byte[] data) {
|
|
Write(data);
|
|
_readableBuffer = _buffer.ToArray();
|
|
}
|
|
|
|
/// <summary>Inserts the length of the packet's content at the start of the buffer.</summary>
|
|
public void WriteLength() {
|
|
_buffer.InsertRange(0, BitConverter.GetBytes(_buffer.Count)); // Insert the byte length of the packet at the very beginning
|
|
}
|
|
|
|
/// <summary>Inserts the given int at the start of the buffer.</summary>
|
|
/// <param name="value">The int to insert.</param>
|
|
public void InsertInt(int value) {
|
|
_buffer.InsertRange(0, BitConverter.GetBytes(value)); // Insert the int at the start of the buffer
|
|
}
|
|
|
|
/// <summary>Gets the packet's content in array form.</summary>
|
|
public byte[] ToArray() {
|
|
_readableBuffer = _buffer.ToArray();
|
|
return _readableBuffer;
|
|
}
|
|
|
|
/// <summary>Gets the length of the packet's content.</summary>
|
|
public int Length() {
|
|
return _buffer.Count; // Return the length of buffer
|
|
}
|
|
|
|
/// <summary>Gets the length of the unread data contained in the packet.</summary>
|
|
public int UnreadLength() {
|
|
return Length() - _readPos; // Return the remaining length (unread)
|
|
}
|
|
|
|
/// <summary>Resets the packet instance to allow it to be reused.</summary>
|
|
/// <param name="shouldReset">Whether or not to reset the packet.</param>
|
|
public void Reset(bool shouldReset = true) {
|
|
if (shouldReset) {
|
|
_buffer.Clear(); // Clear buffer
|
|
_readableBuffer = null;
|
|
_readPos = 0; // Reset readPos
|
|
} else {
|
|
_readPos -= 4; // "Unread" the last read int
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Write Data
|
|
/// <summary>Adds a byte to the packet.</summary>
|
|
/// <param name="value">The byte to add.</param>
|
|
public void Write(byte value) {
|
|
_buffer.Add(value);
|
|
}
|
|
|
|
/// <summary>Adds an array of bytes to the packet.</summary>
|
|
/// <param name="value">The byte array to add.</param>
|
|
public void Write(IEnumerable<byte> value) {
|
|
_buffer.AddRange(value);
|
|
}
|
|
|
|
/// <summary>Adds a short to the packet.</summary>
|
|
/// <param name="value">The short to add.</param>
|
|
public void Write(short value) {
|
|
_buffer.AddRange(BitConverter.GetBytes(value));
|
|
}
|
|
|
|
/// <summary>Adds an int to the packet.</summary>
|
|
/// <param name="value">The int to add.</param>
|
|
public void Write(int value) {
|
|
_buffer.AddRange(BitConverter.GetBytes(value));
|
|
}
|
|
|
|
/// <summary>Adds a long to the packet.</summary>
|
|
/// <param name="value">The long to add.</param>
|
|
public void Write(long value) {
|
|
_buffer.AddRange(BitConverter.GetBytes(value));
|
|
}
|
|
|
|
/// <summary>Adds a float to the packet.</summary>
|
|
/// <param name="value">The float to add.</param>
|
|
public void Write(float value) {
|
|
_buffer.AddRange(BitConverter.GetBytes(value));
|
|
}
|
|
|
|
/// <summary>Adds a bool to the packet.</summary>
|
|
/// <param name="value">The bool to add.</param>
|
|
public void Write(bool value) {
|
|
_buffer.AddRange(BitConverter.GetBytes(value));
|
|
}
|
|
|
|
/// <summary>Adds a string to the packet.</summary>
|
|
/// <param name="value">The string to add.</param>
|
|
public void Write(string value) {
|
|
Write(value.Length); // Add the length of the string to the packet
|
|
_buffer.AddRange(Encoding.ASCII.GetBytes(value)); // Add the string itself
|
|
}
|
|
|
|
/// <summary>Adds a Vector3 to the packet.</summary>
|
|
/// <param name="value">The Vector3 to add.</param>
|
|
public void Write(Vector3 value) {
|
|
Write(value.x);
|
|
Write(value.y);
|
|
Write(value.z);
|
|
}
|
|
|
|
/// <summary>Adds a Quaternion to the packet.</summary>
|
|
/// <param name="value">The Quaternion to add.</param>
|
|
public void Write(Quaternion value) {
|
|
Write(value.x);
|
|
Write(value.y);
|
|
Write(value.z);
|
|
Write(value.w);
|
|
}
|
|
#endregion
|
|
|
|
//#region Read Data
|
|
/// <summary>Reads a byte from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public byte ReadByte(bool moveReadPos = true) {
|
|
if (_buffer.Count > _readPos) {
|
|
// If there are unread bytes
|
|
var value = _readableBuffer[_readPos]; // Get the byte at readPos' position
|
|
if (moveReadPos)
|
|
// If _moveReadPos is true
|
|
_readPos += 1; // Increase readPos by 1
|
|
return value; // Return the byte
|
|
}
|
|
|
|
throw new Exception("Could not read value of type 'byte'!");
|
|
}
|
|
|
|
/// <summary>Reads an array of bytes from the packet.</summary>
|
|
/// <param name="length">The length of the byte array.</param>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public byte[] ReadBytes(int length, bool moveReadPos = true) {
|
|
if (_buffer.Count > _readPos) {
|
|
// If there are unread bytes
|
|
var value = _buffer.GetRange(_readPos, length).ToArray(); // Get the bytes at readPos' position with a range of _length
|
|
if (moveReadPos)
|
|
// If _moveReadPos is true
|
|
_readPos += length; // Increase readPos by _length
|
|
return value; // Return the bytes
|
|
}
|
|
|
|
throw new Exception("Could not read value of type 'byte[]'!");
|
|
}
|
|
|
|
/// <summary>Reads a short from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public short ReadShort(bool moveReadPos = true) {
|
|
if (_buffer.Count > _readPos) {
|
|
// If there are unread bytes
|
|
var value = BitConverter.ToInt16(_readableBuffer, _readPos); // Convert the bytes to a short
|
|
if (moveReadPos)
|
|
// If _moveReadPos is true and there are unread bytes
|
|
_readPos += 2; // Increase readPos by 2
|
|
return value; // Return the short
|
|
}
|
|
|
|
throw new Exception("Could not read value of type 'short'!");
|
|
}
|
|
|
|
/// <summary>Reads an int from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public int ReadInt(bool moveReadPos = true) {
|
|
if (_buffer.Count > _readPos) {
|
|
// If there are unread bytes
|
|
var value = BitConverter.ToInt32(_readableBuffer, _readPos); // Convert the bytes to an int
|
|
if (moveReadPos)
|
|
// If _moveReadPos is true
|
|
_readPos += 4; // Increase readPos by 4
|
|
return value; // Return the int
|
|
}
|
|
|
|
throw new Exception("Could not read value of type 'int'!");
|
|
}
|
|
|
|
/// <summary>Reads a long from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public long ReadLong(bool moveReadPos = true) {
|
|
if (_buffer.Count > _readPos) {
|
|
// If there are unread bytes
|
|
var value = BitConverter.ToInt64(_readableBuffer, _readPos); // Convert the bytes to a long
|
|
if (moveReadPos)
|
|
// If _moveReadPos is true
|
|
_readPos += 8; // Increase readPos by 8
|
|
return value; // Return the long
|
|
}
|
|
|
|
throw new Exception("Could not read value of type 'long'!");
|
|
}
|
|
|
|
/// <summary>Reads a float from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public float ReadFloat(bool moveReadPos = true) {
|
|
if (_buffer.Count > _readPos) {
|
|
// If there are unread bytes
|
|
var value = BitConverter.ToSingle(_readableBuffer, _readPos); // Convert the bytes to a float
|
|
if (moveReadPos)
|
|
// If _moveReadPos is true
|
|
_readPos += 4; // Increase readPos by 4
|
|
return value; // Return the float
|
|
}
|
|
|
|
throw new Exception("Could not read value of type 'float'!");
|
|
}
|
|
|
|
/// <summary>Reads a bool from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public bool ReadBool(bool moveReadPos = true) {
|
|
if (_buffer.Count > _readPos) {
|
|
// If there are unread bytes
|
|
var value = BitConverter.ToBoolean(_readableBuffer, _readPos); // Convert the bytes to a bool
|
|
if (moveReadPos)
|
|
// If _moveReadPos is true
|
|
_readPos += 1; // Increase readPos by 1
|
|
return value; // Return the bool
|
|
}
|
|
|
|
throw new Exception("Could not read value of type 'bool'!");
|
|
}
|
|
|
|
/// <summary>Reads a string from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public string ReadString(bool moveReadPos = true) {
|
|
try {
|
|
var length = ReadInt(); // Get the length of the string
|
|
var value = Encoding.ASCII.GetString(_readableBuffer, _readPos, length); // Convert the bytes to a string
|
|
if (moveReadPos && value.Length > 0)
|
|
// If _moveReadPos is true string is not empty
|
|
_readPos += length; // Increase readPos by the length of the string
|
|
return value; // Return the string
|
|
} catch {
|
|
throw new Exception("Could not read value of type 'string'!");
|
|
}
|
|
}
|
|
|
|
/// <summary>Reads a Vector3 from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public Vector3 ReadVector3(bool moveReadPos = true) {
|
|
return new Vector3(ReadFloat(moveReadPos), ReadFloat(moveReadPos), ReadFloat(moveReadPos));
|
|
}
|
|
|
|
/// <summary>Reads a Quaternion from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public Quaternion ReadQuaternion(bool moveReadPos = true) {
|
|
return new Quaternion(ReadFloat(moveReadPos), ReadFloat(moveReadPos), ReadFloat(moveReadPos), ReadFloat(moveReadPos));
|
|
}
|
|
|
|
/// <summary>Reads a Room from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public Room ReadRoom(bool moveReadPos = true) {
|
|
var id = ReadString(moveReadPos);
|
|
var name = ReadString(moveReadPos);
|
|
var isLocked = ReadBool(moveReadPos);
|
|
var leaderId = ReadInt(moveReadPos);
|
|
var maxPlayers = ReadInt(moveReadPos);
|
|
var currentPlayers = ReadInt(moveReadPos);
|
|
var players = new Dictionary<int, string>();
|
|
for (var i = 0; i < currentPlayers; i++) {
|
|
var clientId = ReadInt(moveReadPos);
|
|
var clientName = ReadString(moveReadPos);
|
|
players.Add(clientId, clientName);
|
|
}
|
|
|
|
return new Room(id, name, leaderId, maxPlayers) {
|
|
IsLocked = isLocked,
|
|
Players = players
|
|
};
|
|
}
|
|
|
|
/// <summary>Reads ClientProperties from the packet.</summary>
|
|
/// <param name="moveReadPos">Whether or not to move the buffer's read position.</param>
|
|
public Dictionary<int, Room.ClientProperties> ReadClientProperties(bool moveReadPos = true) {
|
|
var clientPropertiesMap = new Dictionary<int, Room.ClientProperties>();
|
|
|
|
int propCount = ReadInt(moveReadPos);
|
|
for (int i = 0; i < propCount; i++) {
|
|
var clientId = ReadInt(moveReadPos);
|
|
|
|
var isLeader = ReadBool(moveReadPos);
|
|
var isReady = ReadBool(moveReadPos);
|
|
var colorId = ReadInt(moveReadPos);
|
|
clientPropertiesMap.Add(clientId, new Room.ClientProperties {
|
|
IsLeader = isLeader,
|
|
IsReady = isReady,
|
|
ColorId = colorId
|
|
});
|
|
}
|
|
|
|
return clientPropertiesMap;
|
|
}
|
|
|
|
//#endregion
|
|
}
|
|
}
|
|
|