public void Initalize()
{
Debug.Log("Creating Server");
_server = new Server(_packets.GetPacketData());
Registry = _server.Registry;
Initalized?.Invoke();
}
internal void ParsePacket(HeapByteBuf body, ushort packetId)
{
AbstractPacket packet = PacketRegistry.CreateInstance(packetId);
packet.ReadFrom(body);
this.HandlePacket(packet);
}
protected Client()
{
_proxyClients = new List <ReverseProxyClient>();
_readBuffer = new byte[BUFFER_SIZE];
_tempHeader = new byte[HEADER_SIZE];
AddTypesToSerializer(typeof(IMessage), PacketRegistry.GetPacketTypes(typeof(IMessage)).ToArray());
}
public NetContext()
{
Services = new NetServiceCollection();
Serializer = new DynamicSerializer();
Packets = new PacketRegistry();
IsLocked = false;
}
public static BasePacket ReceivePacket(this Socket socket, Direction direction)
{
Span <byte> intBuffer = stackalloc byte[sizeof(int)];
socket.Receive(intBuffer);
int packetId = BitConverter.ToInt32(intBuffer);
BasePacket packet = PacketRegistry.FromId(packetId, direction);
if (packet == null)
{
throw new Exception($"Packet with id 0x{packetId:x2} not registered!");
}
socket.Receive(intBuffer);
int dataLength = BitConverter.ToInt32(intBuffer);
byte[] packetDataBuffer = new byte[dataLength];
socket.Receive(packetDataBuffer);
MemoryStream memoryStream = new MemoryStream(packetDataBuffer, false);
packet.Read(new PacketDataReader(new BinaryReader(memoryStream)));
return(packet);
}
internal void ParsePacket(HeapByteBuf body)
{
ushort type = this.ParsingPacketId;
AbstractPacket packet = PacketRegistry.CreateInstance(type);
packet.ReadFrom(body);
this.HandlePacket(packet);
}
public EncryptedPacketWrapper(string jsonObject, string packetIdentifier, int packetId) : base(jsonObject, packetIdentifier, packetId)
{
StaticHandler.Core.Logger.Debug("Json Object is {0}", this.jsonObject);
ENCRYPT = true;
if (PacketRegistry.checkIfRegistered(packetIdentifier) == PacketRegistry.RegisteredReturnValues.NOT_IN_REGISTRY)
{
throw new InvalidOperationException("The packet trying to be wrapped is not registered. \"" + packetIdentifier + "\"");
}
}
/// <summary>
/// Constructor of the server, initializes variables.
/// </summary>
protected Server()
{
_clients = new List <Client>();
BufferManager = new PooledBufferManager(BUFFER_SIZE, 1)
{
ClearOnReturn = false
};
AddTypesToSerializer(typeof(IMessage), PacketRegistry.GetPacketTypes(typeof(IMessage)).ToArray());
}
public EncryptedPacketWrapper(EncryptedBytes jsonObject, Packet packet, int packetId) : base(jsonObject, packet?._PacketName, packetId)
{
StaticHandler.Core.Logger.Debug("Json Object is {0}", this.jsonObject);
ENCRYPT = true;
if (PacketRegistry.checkIfRegistered(packet) == PacketRegistry.RegisteredReturnValues.NOT_IN_REGISTRY)
{
throw new InvalidOperationException("The packet trying to be wrapped is not registered. \"" + packet.GetType().FullName + "\"");
}
}
private void OnServerInitalization()
{
PacketRegistry <ServerPacketHandler> r = _server.Registry;
PlayerJoinedID = r.GetID(PacketNames.PLAYER_JOINED);
PlayerRemovedID = r.GetID(PacketNames.PLAYER_REMOVED);
PlayerTransformUpdateID = r.GetID(PacketNames.PLAYER_TRANSFORM_UPDATE);
PlayerScoreID = r.GetID(PacketNames.PLAYER_SCORE);
PickupSpawnedID = r.GetID(PacketNames.PICKUP_SPAWNED);
PickupRemovedID = r.GetID(PacketNames.PICKUP_REMOVED);
}
public SocketPacketServer(PacketRegistry registry, IPEndPoint endPoint, Socket socket, uint bufferSize, NetContext context)
{
_registry = registry;
_endPoint = endPoint;
_socket = socket;
_bufferSize = bufferSize;
_connections = new List <NetworkConnection>();
Context = context;
ContextFactory = DotPacket.DefaultContextFactory;
}
public SocketPacketServer(PacketRegistry registry, string host, int port, NetContext context)
{
var address = Dns.GetHostEntry(host).AddressList[0];
_registry = registry;
_endPoint = new IPEndPoint(address, port);
_socket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
_bufferSize = DotPacket.DefaultBufferSize;
_connections = new List <NetworkConnection>();
Context = context;
ContextFactory = DotPacket.DefaultContextFactory;
}
public void Initalize()
{
if (_client != null)
{
Debug.Log("Destroying Old Client");
_client.Disconnected -= OnDisconnect;
}
Debug.Log("Creating Client");
_client = new Client(_packets.GetPacketData());
Registry = _client.Registry;
_client.Disconnected += OnDisconnect;
_client.ConnectionFinalized += OnConnectionFinalized;
Initalized?.Invoke();
}
public UnencryptedPacketWrapper(Packet packet, int packetId) : base(packet, packet?._PacketName, packetId)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
ENCRYPT = false;
if (PacketRegistry.checkIfRegistered(packet) == PacketRegistry.RegisteredReturnValues.NOT_IN_REGISTRY)
{
throw new InvalidOperationException("The packet trying to be wrapped is not registered. \"" +
packet.GetType().FullName + "\"");
}
}
public void PacketRegistry_RegisterMany_OrderConsistent()
{
registry.Register <TestPacket>();
registry.Register <TestPacket2>();
registry.Register <TestPacket3>();
registry.LockPackets();
PacketRegistry compare = new PacketRegistry();
compare.Register <TestPacket3>();
compare.Register <TestPacket2>();
compare.Register <TestPacket>();
compare.LockPackets();
Assert.AreEqual(registry.GetID <TestPacket>(), compare.GetID <TestPacket>());
Assert.AreEqual(registry.GetID <TestPacket2>(), compare.GetID <TestPacket2>());
Assert.AreEqual(registry.GetID <TestPacket3>(), compare.GetID <TestPacket3>());
}
/**
* Converts the JSON Object into it's former instance by providing the class name
*
* @param jsonObject
* @return
*/
public Tuple <Packet, int> getParsedObject(string packetIdentifier, string jsonObject, int packetId)
{
var aClass = PacketRegistry.getPacketClassFromRegistry(packetIdentifier);
try
{
return(new Tuple <Packet, int>(
jsonHandler.fromJson <Packet>(
jsonObject, aClass),
packetId));
}
catch (Exception e)
{
throw new ArgumentException(
"Attempting to parse packet " + packetIdentifier + " (" + aClass.Name + ") with string\n" +
jsonObject, e);
}
}
public NetworkConnection(
PacketRegistry registry,
IOStream stream,
NetContext globalContext,
ContextFactory contextFactory,
uint bufferSize
)
{
_registry = registry;
_stream = stream;
_in = new StreamReader(_stream, bufferSize);
_out = new StreamWriter(_stream, bufferSize);
_readLock = new ManualResetEvent(true);
_writeLock = new ManualResetEvent(true);
_queueLock = new ManualResetEvent(true);
_packetQueue = new List <object>();
Context = contextFactory(this, globalContext);
}
public PaceClient(TcpClient client)
{
TcpClient = client;
serializer = new Serializer(PacketRegistry.GetPacketTypes());
}
public PaceClient()
{
TcpClient = new TcpClient();
serializer = new Serializer(PacketRegistry.GetPacketTypes());
}
public void Initialize()
{
registry = new PacketRegistry();
}
public PaceServer()
{
PacketChannel = new PacketChannel();
ConnectedClients = new List <PaceClient>();
serializer = new Serializer(PacketRegistry.GetPacketTypes());
}
