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

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