🐛 empty payload

Plugins

.github/workflows/main.yml

@@ -19,7 +19,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           tag_name: ${{ github.ref }}
-          release_name: Ragon.SimpleServer-${{ github.ref }}
+          release_name: Ragon.Relay-${{ github.ref }}
           prerelease: true
 
   build:
@@ -49,14 +49,14 @@ jobs:
       - name: Setup dotnet
         uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: 6.0.x
+          dotnet-version: 7.0.x
       - name: Build
         shell: bash
         run: |
-          release_name="Ragon.SimpleServer-${{ env.TAG }}-${{ matrix.target }}"
+          release_name="Ragon.Relay-${{ env.TAG }}-${{ matrix.target }}"
           
           # Build everything
-          dotnet publish Ragon.SimpleServer/Ragon.SimpleServer.csproj -c Release --runtime "${{ matrix.target }}" -p:PublishSingleFile=true -o "$release_name"
+          dotnet publish Ragon.Relay/Ragon.Relay.csproj -c Release --runtime "${{ matrix.target }}" -p:PublishSingleFile=true -o "$release_name"
           
           # Pack files        
           7z a -tzip "${release_name}.zip" "./${release_name}/*"
@@ -69,6 +69,6 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           upload_url: ${{ needs.release.outputs.upload_url }}
-          asset_path: Ragon.SimpleServer-${{ env.TAG }}-${{ matrix.target }}.zip
+          asset_path: Ragon.Relay-${{ env.TAG }}-${{ matrix.target }}.zip
-          asset_name: Ragon.SimpleServer-${{ env.TAG }}-${{ matrix.target }}.zip
+          asset_name: Ragon.Relay-${{ env.TAG }}-${{ matrix.target }}.zip
           asset_content_type: application/zip

.gitignore

@@ -4,3 +4,5 @@
 obj
 bin
 *.user
+*.dylib
+*.dll

LICENSE.md

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+	 

README.md

@@ -0,0 +1,31 @@
+<p align="center">
+  <img src="Images/ragon-logo.png" width="200" >
+</p>
+
+## Ragon Server
+
+Ragon is fully free, small and high perfomance room based game server with plugin based architecture.
+
+  <a href="https://www.ragon-server.com/docs/overview">Documentation</a>
+
+### Features:
+- Effective
+- Free
+- Lobby
+- Room based architecture
+- Сustomizable authorization
+- Сustomizable server-side logic via plugins with flexible API*(2)
+- No CCU limitations*(1)
+- No Room count limitations
+- Reliable UDP
+
+### Requirements
+- OSX, Windows, Linux(Ubuntu, Debian)
+- .NET 6.0
+
+### Dependencies
+* ENet-Sharp [v2.4.8]
+
+### Tips
+\* Limited to 4095 CCU by library ENet-Sharp (1)
+\* Non finally (2)

Ragon.Client.Property/Ragon.Client.Property.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Ragon.Client\Ragon.Client.csproj" />
+    </ItemGroup>
+
+</Project>

Ragon.Client.Property/Sources/RagonBool.cs

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client.Simulation
+{
+  [Serializable]
+  public class RagonBool : RagonProperty
+  {
+    public bool Value
+    {
+      get => _value;
+      set
+      {
+        _value = value;
+        
+        MarkAsChanged();
+      }
+    }
+
+    private bool _value;
+
+    public RagonBool(
+      bool initialValue,
+      bool invokeLocal = true,
+      int priority = 0
+    ) : base(priority, invokeLocal)
+    {
+      _value = initialValue;
+      SetFixedSize(1);
+    }
+
+    public override void Serialize(RagonBuffer buffer)
+    {
+      buffer.WriteBool(_value);
+    }
+
+    public override void Deserialize(RagonBuffer buffer)
+    {
+      _value = buffer.ReadBool();
+
+      InvokeChanged();
+    }
+  }
+}

Ragon.Client.Property/Sources/RagonFloat.cs

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client
+{
+  [Serializable]
+  public class RagonFloat : RagonProperty
+  {
+    public float Value
+    {
+      get => _value;
+      set
+      {
+        _value = value;
+
+        if (_value < _min)
+          _value = _min;
+        else if (_value > _max)
+          _value = _max;
+
+        MarkAsChanged();
+      }
+    }
+
+    private float _value;
+    private float _min;
+    private float _max;
+    private int _requiredBits;
+    private float _precision;
+    private uint _mask;
+
+    public RagonFloat(
+      float initialValue,
+      bool invokeLocal = true,
+      int priority = 0
+    ) : base(priority, invokeLocal)
+    {
+      _value = initialValue;
+      _min = -1024.0f;
+      _max = 1024.0f;
+      _precision = 0.01f;
+
+      _requiredBits = DeBruijn.Log2((uint)((_max - _min) * (1.0f / _precision) + 0.5f)) + 1;
+      _mask = (uint)((1L << _requiredBits) - 1);
+
+      SetFixedSize(_requiredBits);
+    }
+
+    public RagonFloat(
+      float initialValue,
+      float min = -1024.0f,
+      float max = 1024.0f,
+      float precision = 0.01f,
+      bool invokeLocal = true,
+      int priority = 0
+    ) : base(priority, invokeLocal)
+    {
+      _value = initialValue;
+      _min = min;
+      _max = max;
+      _precision = precision;
+
+      _requiredBits = DeBruijn.Log2((uint)((_max - _min) * (1.0f / _precision) + 0.5f)) + 1;
+      _mask = (uint)((1L << _requiredBits) - 1);
+
+      SetFixedSize(_requiredBits);
+    }
+
+    public override void Serialize(RagonBuffer buffer)
+    {
+      var compressedValue = (uint)((_value - _min) * (1f / _precision) + 0.5f) & _mask;
+      buffer.Write(compressedValue, _requiredBits);
+    }
+
+    public override void Deserialize(RagonBuffer buffer)
+    {
+      var compressedValue = buffer.Read(_requiredBits);
+      _value = compressedValue * _precision + _min;
+
+      if (_value < _min)
+        _value = _min;
+      else if (_value > _max)
+        _value = _max;
+      
+      InvokeChanged();
+    }
+  }
+}

Ragon.Client.Property/Sources/RagonInt.cs

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client.Simulation
+{
+  [Serializable]
+  public class RagonInt : RagonProperty
+  {
+    public int Value
+    {
+      get => _value;
+      set
+      {
+        _value = value;
+        MarkAsChanged();
+      }
+    }
+
+    private int _min;
+    private int _max;
+    private int _requiredBits;
+    private int _value;
+
+    public RagonInt(
+      int initialValue,
+      bool invokeLocal = true,
+      int priority = 0
+    ) : base(priority, invokeLocal)
+    {
+      _value = initialValue;
+      _min = -1000;
+      _max = 1000;
+
+      _max = Math.Max(Math.Abs(_min), Math.Abs(_max));
+      _requiredBits = Bits.Compute(_max);
+
+      SetFixedSize(_requiredBits);
+    }
+
+    public RagonInt(
+      int initialValue,
+      int min = -1000,
+      int max = 1000,
+      bool invokeLocal = true,
+      int priority = 0
+    ) : base(priority, invokeLocal)
+    {
+      _value = initialValue;
+      _min = min;
+      _max = max;
+
+      _requiredBits = Bits.Compute(_max);
+
+      SetFixedSize(_requiredBits);
+    }
+
+    public override void Serialize(RagonBuffer buffer)
+    {
+      uint compressedValue = (uint)((_value << 1) ^ (_value >> 31));
+      buffer.Write(compressedValue, _requiredBits);
+    }
+
+    public override void Deserialize(RagonBuffer buffer)
+    {
+      var compressedValue = buffer.Read(_requiredBits);
+      _value = (int)((compressedValue >> 1) ^ -(int)(compressedValue & 1));
+
+      InvokeChanged();
+    }
+  }
+}

Ragon.Client.Property/Sources/RagonString.cs

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using System.Text;
+using Ragon.Protocol;
+
+namespace Ragon.Client.Simulation
+{
+  [Serializable]
+  public class RagonString : RagonProperty
+  {
+    public string Value
+    {
+      get => _value;
+      set
+      {
+        _value = value;
+        
+        MarkAsChanged();
+      }
+    }
+
+    private string _value;
+    private readonly UTF8Encoding _utf8Encoding = new UTF8Encoding(false, true);
+    
+    public RagonString(
+      string initialValue,
+      bool invokeLocal = true,
+      int priority = 0
+    ) : base(priority, invokeLocal)
+    {
+      _value = initialValue;
+    }
+
+    public override void Serialize(RagonBuffer buffer)
+    {
+      var data = _utf8Encoding.GetBytes(_value);
+      var len = (uint) data.Length;
+      
+      buffer.Write(len, 16);
+      buffer.WriteBytes(data);
+    }
+
+    public override void Deserialize(RagonBuffer buffer)
+    {
+      var len = (int) buffer.Read(16);
+      var data = buffer.ReadBytes(len);
+      
+      _value = _utf8Encoding.GetString(data);
+      
+      InvokeChanged();
+    }
+  }
+}

Ragon.Client.Simulation/Program.cs

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Client.Simulation;
+
+var simulation = new Simulation();
+simulation.Start();

Ragon.Client.Simulation/Ragon.Client.Simulation.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net7.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Ragon.Client.Property\Ragon.Client.Property.csproj" />
+      <ProjectReference Include="..\Ragon.Client\Ragon.Client.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="ENet-CSharp" Version="2.4.8" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <None Update="libenet.dylib">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+    </ItemGroup>
+
+</Project>

Ragon.Client.Simulation/Sources/Game.cs

@@ -0,0 +1,112 @@
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client.Simulation;
+
+public class Game : IRagonListener
+{
+    private RagonFloat _health;
+    private RagonInt _points;
+    private RagonString _name;
+    private RagonEntity _entity;
+    private RagonClient _client;
+
+    public Game(RagonClient client)
+    {
+        _client = client;
+    }
+
+    public void OnConnected(RagonClient client)
+    {
+        RagonLog.Trace("Connected");
+        _client.Session.AuthorizeWithKey("defaultkey", "Player Eduard");
+    }
+
+    public void OnAuthorizationSuccess(RagonClient client, string playerId, string playerName)
+    {
+        RagonLog.Trace("Authorized");
+        client.Session.CreateOrJoin("Example", 1, 20);
+    }
+
+    public void OnAuthorizationFailed(RagonClient client, string message)
+    {
+        Console.WriteLine($"Authorization failed: {message}");
+    }
+
+    public void OnJoined(RagonClient client)
+    {
+        RagonLog.Trace("Joined");
+
+        _health = new RagonFloat(100.0f, false, 0);
+        _health.Changed += () => Console.WriteLine($"[Ragon Property] Health: {_health.Value}");
+
+        _points = new RagonInt(0, -1000, 1000, false, 0);
+        _points.Changed += () => Console.WriteLine($"[Ragon Property] Points: {_points.Value}");
+
+        _name = new RagonString("Edmand 000", false);
+        _name.Changed += () => Console.WriteLine($"[Ragon Property] Name: {_name.Value}");
+
+        _entity = new RagonEntity(12, 0);
+        _entity.State.AddProperty(_health);
+        _entity.State.AddProperty(_points);
+        _entity.State.AddProperty(_name);
+
+        client.Room.CreateEntity(_entity);
+    }
+
+    public void OnFailed(RagonClient client, string message)
+    {
+        RagonLog.Trace("Failed to join");
+    }
+
+    public void OnLeft(RagonClient client)
+    {
+        RagonLog.Trace("Left");
+    }
+
+    public void OnDisconnected(RagonClient client, RagonDisconnect ragonDisconnect)
+    {
+        RagonLog.Trace("Disconnected");
+    }
+
+    public void OnPlayerJoined(RagonClient client, RagonPlayer player)
+    {
+        RagonLog.Trace("Player joined");
+    }
+
+    public void OnPlayerLeft(RagonClient client, RagonPlayer player)
+    {
+        RagonLog.Trace("Player left");
+    }
+
+    public void OnOwnershipChanged(RagonClient client, RagonPlayer player)
+    {
+        RagonLog.Trace("Owner ship changed");
+    }
+
+    public void OnLevel(RagonClient client, string sceneName)
+    {
+        RagonLog.Trace($"New level: {sceneName}");
+
+        client.Room.SceneLoaded();
+    }
+
+    private float _timer = 0;
+
+    public void Update()
+    {
+        if (_client.Status != RagonStatus.ROOM)
+            return;
+
+        _timer += 1 / 60.0f;
+        if (_timer > 1)
+        {
+            _health.Value += 20.0f;
+            _points.Value += 10;
+            _name.Value = $"Edmand 00{_client.Room.Local.PeerId}";
+            Console.WriteLine($"{_health.Value} {_points.Value} {_name.Value}");
+            _timer = 0;
+        }
+    }
+}

Ragon.Client.Simulation/Sources/IO/RagonENetConnection.cs

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using ENet;
+using Ragon.Protocol;
+using Event = ENet.Event;
+using EventType = ENet.EventType;
+
+namespace Ragon.Client
+{
+  public class RagonENetConnection : INetworkConnection
+  {
+    public ushort Id { get; }
+    
+    public NetworkStatistics Statistics { get; private set; }
+    public INetworkChannel Reliable { get; private set; }
+    public INetworkChannel Unreliable { get; private set; }
+    
+    public Action<byte[]> OnData { get; set; }
+    public Action OnConnected { get; set; }
+    public Action<RagonDisconnect> OnDisconnected { get; set; }
+    public ulong BytesSent { get; }
+    public ulong BytesReceived { get; }
+    public int Ping { get; }
+
+    private static bool _libraryLoaded = false;
+    private Host _host;
+    private Peer _peer;
+    private Event _netEvent;
+    
+    public RagonENetConnection()
+    {
+      _host = new Host();
+      _host.Create();
+    }
+
+
+    public void Prepare()
+    {
+      if (!_libraryLoaded)
+      {
+        Library.Initialize();
+        _libraryLoaded = true;
+      }
+    }
+
+    public void Disconnect()
+    {
+      if (_peer.IsSet)
+        _peer.DisconnectNow(0);
+    }
+
+    public void Connect(string server, ushort port, uint protocol)
+    {
+      Address address = new Address();
+      address.SetHost(server);
+      address.Port = port;
+
+      _peer = _host.Connect(address, 2, protocol);
+      _peer.Timeout(32, 5000, 5000);
+    }
+
+    public void Update()
+    {
+      bool polled = false;
+      while (!polled)
+      {
+        if (_host.CheckEvents(out _netEvent) <= 0)
+        {
+          if (_host.Service(0, out _netEvent) <= 0)
+            break;
+
+          polled = true;
+        }
+
+        switch (_netEvent.Type)
+        {
+          case EventType.None:
+            break;
+          case EventType.Connect:
+            Statistics = new NetworkStatistics();
+            Reliable = new ENetReliableChannel(_netEvent.Peer, 0);
+            Unreliable = new ENetUnreliableChannel(_netEvent.Peer, 1);
+            
+            OnConnected?.Invoke();
+            break;
+          case EventType.Disconnect:
+            OnDisconnected?.Invoke(RagonDisconnect.SERVER);
+            break;
+          case EventType.Timeout:
+            OnDisconnected?.Invoke(RagonDisconnect.TIMEOUT);
+            break;
+          case EventType.Receive:
+            var data = new byte[_netEvent.Packet.Length];
+
+            _netEvent.Packet.CopyTo(data);
+            _netEvent.Packet.Dispose();
+
+            OnData?.Invoke(data);
+            break;
+        }
+      }
+    }
+
+    public void Dispose()
+    {
+      if (_host.IsSet)
+      {
+        _host?.Flush();
+        _host?.Dispose();
+      }
+
+      if (_libraryLoaded)
+        Library.Deinitialize();
+    }
+  }
+}

Ragon.Client.Simulation/Sources/IO/RagonENetReliableChannel.cs

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using ENet;
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public sealed class ENetReliableChannel : INetworkChannel
+{
+  private Peer _peer;
+  private byte _channelId;
+
+  public ENetReliableChannel(Peer peer, int channelId)
+  {
+    _peer = peer;
+    _channelId = (byte) channelId;
+  }
+
+  public void Send(byte[] data)
+  {
+    var newPacket = new Packet();
+    newPacket.Create(data, data.Length, PacketFlags.Reliable);
+    
+    _peer.Send(_channelId, ref newPacket);
+  }
+}

Ragon.Client.Simulation/Sources/IO/RagonENetUnreliableChannel.cs

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using ENet;
+
+namespace Ragon.Client;
+
+public sealed class ENetUnreliableChannel : INetworkChannel
+{
+  private Peer _peer;
+  private byte _channelId;
+
+  public ENetUnreliableChannel(Peer peer, int channelId)
+  {
+    _peer = peer;
+    _channelId = (byte) channelId;
+  }
+
+  public void Send(byte[] data)
+  {
+    var newPacket = new Packet();
+    newPacket.Create(data, data.Length, PacketFlags.None);
+    
+    _peer.Send(_channelId, ref newPacket);
+  }
+}

Ragon.Client.Simulation/Sources/IO/RagonNullConnection.cs

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using ENet;
+using Ragon.Protocol;
+using Event = ENet.Event;
+using EventType = ENet.EventType;
+
+namespace Ragon.Client
+{
+  public class RagonNullConnection : INetworkConnection
+  {
+    public ushort Id { get; }
+    
+    public NetworkStatistics Statistics { get; private set; }
+    public INetworkChannel Reliable { get; private set; }
+    public INetworkChannel Unreliable { get; private set; }
+    
+    public Action<byte[]> OnData { get; set; }
+    public Action OnConnected { get; set; }
+    public Action<RagonDisconnect> OnDisconnected { get; set; }
+    public ulong BytesSent { get; }
+    public ulong BytesReceived { get; }
+    public int Ping { get; }
+
+    private static bool _libraryLoaded = false;
+    private Host _host;
+    private Peer _peer;
+    private Event _netEvent;
+    
+    public RagonNullConnection()
+    {
+      _host = new Host();
+      _host.Create();
+    }
+
+
+    public void Prepare()
+    {
+      if (!_libraryLoaded)
+      {
+        Library.Initialize();
+        _libraryLoaded = true;
+      }
+    }
+
+    public void Disconnect()
+    {
+      if (_peer.IsSet)
+        _peer.DisconnectNow(0);
+    }
+
+    public void Connect(string server, ushort port, uint protocol)
+    {
+      Address address = new Address();
+      address.SetHost(server);
+      address.Port = port;
+
+      _peer = _host.Connect(address, 2, protocol);
+      _peer.Timeout(32, 5000, 5000);
+      
+      Statistics = new NetworkStatistics();
+      Reliable = new NullReliableChannel(_netEvent.Peer, 0);
+      Unreliable = new NullUnreliableChannel(_netEvent.Peer, 1);
+    }
+
+    public void Update()
+    {
+      bool polled = false;
+      while (!polled)
+      {
+        if (_host.CheckEvents(out _netEvent) <= 0)
+        {
+          if (_host.Service(0, out _netEvent) <= 0)
+            break;
+
+          polled = true;
+        }
+
+        switch (_netEvent.Type)
+        {
+          case EventType.None:
+            break;
+          case EventType.Connect:
+
+            OnConnected?.Invoke();
+            break;
+          case EventType.Disconnect:
+            OnDisconnected?.Invoke(RagonDisconnect.SERVER);
+            break;
+          case EventType.Timeout:
+            OnDisconnected?.Invoke(RagonDisconnect.TIMEOUT);
+            break;
+          case EventType.Receive:
+            var data = new byte[_netEvent.Packet.Length];
+
+            _netEvent.Packet.CopyTo(data);
+            _netEvent.Packet.Dispose();
+
+            OnData?.Invoke(data);
+            break;
+        }
+      }
+    }
+
+    public void Dispose()
+    {
+      if (_host.IsSet)
+      {
+        _host?.Flush();
+        _host?.Dispose();
+      }
+
+      if (_libraryLoaded)
+        Library.Deinitialize();
+    }
+  }
+}

Ragon.Client.Simulation/Sources/IO/RagonNullReliableChannel.cs

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using ENet;
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public sealed class NullReliableChannel : INetworkChannel
+{
+  private Peer _peer;
+  private byte _channelId;
+
+  public NullReliableChannel(Peer peer, int channelId)
+  {
+    _peer = peer;
+    _channelId = (byte) channelId;
+  }
+
+  public void Send(byte[] data)
+  {
+  
+  }
+}

Ragon.Client.Simulation/Sources/IO/RagonNullUnreliableChannel.cs

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using ENet;
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public sealed class NullUnreliableChannel : INetworkChannel
+{
+  private Peer _peer;
+  private byte _channelId;
+
+  public NullUnreliableChannel(Peer peer, int channelId)
+  {
+    _peer = peer;
+    _channelId = (byte) channelId;
+  }
+
+  public void Send(byte[] data)
+  {
+   
+  }
+}

Ragon.Client.Simulation/Sources/Player/PlayerPayload.cs

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client.Simulation.Sources;
+
+public class PlayerPayload : IRagonPayload
+{
+  public uint Name { get; set; }
+
+  public void Serialize(RagonBuffer buffer)
+  {
+    buffer.Write(Name, 16);
+  }
+
+  public void Deserialize(RagonBuffer buffer)
+  {
+    Name = buffer.Read(16);
+  }
+}

Ragon.Client.Simulation/Sources/Simulation.cs

@@ -0,0 +1,42 @@
+namespace Ragon.Client.Simulation;
+
+public class EntityListener : IRagonEntityListener
+{
+  public void OnEntityCreated(RagonEntity entity)
+  {
+    var health = new RagonFloat(100.0f, false, 0);
+    health.Value = 50;
+    health.Changed += () => Console.WriteLine($"[Ragon Property] Another Health: {health.Value}");
+
+    var points = new RagonInt(0, -1000, 1000, false, 0);
+    points.Changed += () => Console.WriteLine($"[Ragon Property] Anther Points: {points.Value}");
+
+    var name = new RagonString("Eduard", false);
+    name.Changed += () => Console.WriteLine($"[Ragon Property] Another Name: {name.Value}");
+
+    entity.State.AddProperty(health);
+    entity.State.AddProperty(points);
+    entity.State.AddProperty(name);
+  }
+}
+
+public class Simulation
+{
+  public void Start()
+  {
+    // INetworkConnection protocol = debug ? new RagonNullConnection() : new RagonENetConnection();
+    // var network = new RagonClient(protocol, new EntityListener(), 30);
+    // var game = new Game(network);
+    // network.AddListener(game);
+    // network.Connect("127.0.0.1", 5001, "1.0.0");
+    //   var dt = 1000 / 60.0f;
+    //   while (true)
+    //   {
+    //     game.Update();
+    //     network.Update(dt);
+    //     Thread.Sleep((int) dt);
+    //   }
+    //   
+    //   network.Disconnect();
+  }
+}

Ragon.Client/Ragon.Client.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.1</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <LangVersion>10</LangVersion>
+        <RootNamespace>Ragon.Client.Simulation</RootNamespace>
+        <Authors>Eduard Kargin (Edmand46)</Authors>
+    </PropertyGroup>
+
+    <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+      <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+      <DebugType>none</DebugType>
+      <OutputPath>/Users/edmand46/RagonProjects/ragon-oss-sdk/Assets/Ragon/Plugins/</OutputPath>
+    </PropertyGroup>
+
+    <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+      <OutputPath>/Users/edmand46/RagonProjects/ragon-unity-sdk/Assets/Ragon/Runtime/Plugins</OutputPath>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\Ragon.Protocol\Ragon.Protocol.csproj" />
+    </ItemGroup>
+
+</Project>

Ragon.Client/Sources/Compressor/FloatCompressor.cs

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client.Compressor;
+
+public class FloatCompressor
+{
+  public float Min { get; private set; }
+  public float Max { get; private set; }
+  public float Precision { get; private set; }
+  public int RequiredBits { get; private set; }
+  
+  private uint _mask;
+
+  public FloatCompressor(float min = -1024.0f, float max = 1024.0f, float precision = 0.01f)
+  {
+    Min = min;
+    Max = max;
+    Precision = precision;
+    RequiredBits = DeBruijn.Log2((uint)((Max - Min) * (1f / Precision) + 0.5f)) + 1;
+    
+    _mask = (uint)((1L << RequiredBits) - 1);
+  }
+
+  public uint Compress(float value)
+  {
+    return (uint)((value - Min) * 1f / Precision + 0.5f) & _mask;
+  }
+
+  public float Decompress(uint value)
+  {
+    var result = value * Precision + Min;
+
+    if (result < Min)
+      result = Min;
+    else if (result > Max)
+      result = Max;
+
+    return result;
+  }
+}

Ragon.Client/Sources/Compressor/IntCompressor.cs

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client.Compressor;
+
+public class IntCompressor
+{
+  public int Min { get; private set; }
+  public int Max { get; private set; }
+  public int RequiredBits { get; private set; }
+
+  public IntCompressor(int min = -1000, int max = 1000)
+  {
+    Min = min;
+    Max = max;
+    RequiredBits = Bits.Compute(Max);
+  }
+
+  public uint Compress(int value)
+  {
+    return (uint)((value << 1) ^ (value >> 31));;
+  }
+
+  public int Decompress(uint value)
+  {
+    return (int)((value >> 1) ^ -(int)(value & 1));
+  }
+}

Ragon.Client/Sources/Entity/RagonEntity.cs

@@ -0,0 +1,249 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client
+{
+  public sealed class RagonEntity
+  {
+    private delegate void OnEventDelegate(RagonPlayer player, RagonBuffer serializer);
+
+    private RagonClient _client;
+
+    public ushort Id { get; private set; }
+    public ushort Type { get; private set; }
+    public bool Replication { get; private set; }
+
+    public RagonAuthority Authority { get; private set; }
+    public RagonPlayer Owner { get; private set; }
+    public RagonEntityState State { get; private set; }
+
+    public bool IsAttached { get; private set; }
+    public bool HasAuthority { get; private set; }
+
+    public event Action<RagonEntity> Attached;
+    public event Action Detached;
+    public event Action<RagonPlayer, RagonPlayer> OwnershipChanged;
+
+    internal bool PropertiesChanged => _propertiesChanged;
+    internal ushort SceneId => _sceneId;
+
+    private ushort _sceneId;
+    private bool _propertiesChanged;
+
+    private RagonPayload _spawnPayload;
+    private RagonPayload _destroyPayload;
+
+    private Dictionary<int, OnEventDelegate> _events = new();
+    private Dictionary<int, Action<RagonPlayer, IRagonEvent>> _localEvents = new();
+
+    public RagonEntity(ushort type = 0, ushort sceneId = 0)
+    {
+      State = new RagonEntityState(this);
+      Type = type;
+
+      _sceneId = sceneId;
+    }
+
+    internal void Attach(RagonClient client, ushort entityId, ushort entityType, bool hasAuthority, RagonPlayer owner, RagonPayload payload)
+    {
+      Type = entityType;
+      Id = entityId;
+      Owner = owner;
+      IsAttached = true;
+      Replication = true;
+      HasAuthority = hasAuthority;
+
+      _client = client;
+      _spawnPayload = payload;
+
+      Attached?.Invoke(this);
+    }
+
+    internal void Detach(RagonPayload payload)
+    {
+      _destroyPayload = payload;
+
+      Detached?.Invoke();
+    }
+
+    internal T GetPayload<T>(RagonPayload data) where T : IRagonPayload, new()
+    {
+      var payload = new T();
+      if (data.Size <= 0) return payload;
+      
+      var buffer = new RagonBuffer();
+      
+      data.Write(buffer);
+      
+      payload.Deserialize(buffer);
+      
+      return payload;
+    }
+    
+    public void AttachPayload(IRagonPayload? payload)
+    {
+      if (payload == null) return;
+      
+      var buffer = new RagonBuffer();
+      payload.Serialize(buffer);
+
+      _spawnPayload = new RagonPayload();
+      _spawnPayload.Read(buffer);
+    } 
+
+    public T GetAttachPayload<T>() where T : IRagonPayload, new()
+    {
+      return GetPayload<T>(_spawnPayload);
+    }
+
+    public T GetDetachPayload<T>() where T : IRagonPayload, new()
+    {
+      return GetPayload<T>(_destroyPayload);
+    }
+
+    public void ReplicateEvent<TEvent>(TEvent evnt, RagonPlayer target, RagonReplicationMode replicationMode)
+      where TEvent : IRagonEvent, new()
+    {
+      if (!IsAttached)
+      {
+        RagonLog.Error("Entity not attached");
+        return;
+      }
+
+      var evntId = _client.Event.GetEventCode(evnt);
+      var buffer = _client.Buffer;
+
+      buffer.Clear();
+      buffer.WriteOperation(RagonOperation.REPLICATE_ENTITY_EVENT);
+      buffer.WriteUShort(Id);
+      buffer.WriteUShort(evntId);
+      buffer.WriteByte((byte)replicationMode);
+      buffer.WriteByte((byte)RagonTarget.Player);
+      buffer.WriteUShort(target.PeerId);
+
+      evnt.Serialize(buffer);
+
+      var sendData = buffer.ToArray();
+      _client.Reliable.Send(sendData);
+    }
+
+    public void ReplicateEvent<TEvent>(
+      TEvent evnt,
+      RagonTarget target = RagonTarget.All,
+      RagonReplicationMode replicationMode = RagonReplicationMode.Server)
+      where TEvent : IRagonEvent, new()
+    {
+      if (!IsAttached)
+      {
+        RagonLog.Error("Entity not attached");
+        return;
+      }
+
+      if (target != RagonTarget.ExceptOwner)
+      {
+        if (replicationMode == RagonReplicationMode.Local)
+        {
+          var eventCode = _client.Event.GetEventCode(evnt);
+          _localEvents[eventCode].Invoke(_client.Room.Local, evnt);
+          return;
+        }
+
+        if (replicationMode == RagonReplicationMode.LocalAndServer)
+        {
+          var eventCode = _client.Event.GetEventCode(evnt);
+          _localEvents[eventCode].Invoke(_client.Room.Local, evnt);
+        }
+      }
+
+      var evntId = _client.Event.GetEventCode(evnt);
+      var buffer = _client.Buffer;
+
+      buffer.Clear();
+      buffer.WriteOperation(RagonOperation.REPLICATE_ENTITY_EVENT);
+      buffer.WriteUShort(Id);
+      buffer.WriteUShort(evntId);
+      buffer.WriteByte((byte)replicationMode);
+      buffer.WriteByte((byte)target);
+
+      evnt.Serialize(buffer);
+
+      var sendData = buffer.ToArray();
+      _client.Reliable.Send(sendData);
+    }
+
+    public void OnEvent<TEvent>(Action<RagonPlayer, TEvent> callback) where TEvent : IRagonEvent, new()
+    {
+      var t = new TEvent();
+      var eventCode = _client.Event.GetEventCode(t);
+
+      if (_events.ContainsKey(eventCode))
+      {
+        _events.Remove(eventCode);
+        _localEvents.Remove(eventCode);
+
+        RagonLog.Warn($"Event already {eventCode} subscribed, removed old one!");
+      }
+
+      _localEvents.Add(eventCode, (player, eventData) => { callback.Invoke(player, (TEvent)eventData); });
+      _events.Add(eventCode, (player, serializer) =>
+      {
+        t.Deserialize(serializer);
+        callback.Invoke(player, t);
+      });
+    }
+
+    internal void Write(RagonBuffer buffer)
+    {
+      buffer.WriteUShort(Id);
+
+      State.WriteState(buffer);
+
+      _propertiesChanged = false;
+    }
+
+
+    internal void Read(RagonBuffer buffer)
+    {
+      State.ReadState(buffer);
+    }
+
+    internal void Event(ushort eventCode, RagonPlayer caller, RagonBuffer buffer)
+    {
+      if (_events.TryGetValue(eventCode, out var evnt))
+        evnt?.Invoke(caller, buffer);
+      else
+        RagonLog.Warn($"Handler event on entity {Id} with eventCode {eventCode} not defined");
+    }
+
+    internal void TrackChangedProperty(RagonProperty property)
+    {
+      _propertiesChanged = true;
+    }
+
+    public void OnOwnershipChanged(RagonPlayer player)
+    {
+      var prevOwner = Owner;
+
+      Owner = player;
+      HasAuthority = player.IsLocal;
+
+      OwnershipChanged?.Invoke(prevOwner, player);
+    }
+  }
+}

Ragon.Client/Sources/Entity/RagonEntityState.cs

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public sealed class RagonEntityState
+{
+  private List<RagonProperty> _properties;
+  private RagonEntity _entity;
+  
+  public RagonEntityState(RagonEntity entity)
+  {
+    _entity = entity;
+    _properties = new List<RagonProperty>(6);
+  }
+  
+  public void AddProperty(RagonProperty property)
+  {
+    _properties.Add(property);
+    
+    property.AssignEntity(_entity);
+  }
+  
+  internal void WriteInfo(RagonBuffer buffer)
+  {
+    buffer.WriteUShort((ushort)_properties.Count);
+    foreach (var property in _properties)
+    {
+      buffer.WriteBool(property.IsFixed);
+      buffer.WriteUShort((ushort)property.Size);
+    }
+  }
+  
+  internal void ReadState(RagonBuffer buffer)
+  {
+    foreach (var property in _properties)
+    {
+      var changed = buffer.ReadBool();
+      if (changed)
+        property.Read(buffer);
+    }
+  }
+
+  internal void WriteState(RagonBuffer buffer)
+  {
+    foreach (var prop in _properties)
+    {
+      if (prop.IsDirty)
+      {
+        buffer.WriteBool(true);
+        prop.Write(buffer);
+        prop.Flush();
+      }
+      else
+      {
+        prop.AddTick();
+        buffer.WriteBool(false);
+      }
+    }
+  }
+}

Ragon.Client/Sources/Entity/RagonPayload.cs

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public struct RagonPayload
+{
+  private readonly uint[] _data = new uint[128];
+  private readonly int _size = 0;
+
+  public RagonPayload(int capacity)
+  {
+    _size = capacity;
+  }
+  public int Size => _size;
+
+  public void Read(RagonBuffer buffer)
+  {
+    var readOnlySpan = _data.AsSpan();
+
+    buffer.ReadSpan(ref readOnlySpan, _size);
+  }
+
+  public void Write(RagonBuffer buffer)
+  {
+    ReadOnlySpan<uint> readOnlySpan = _data.AsSpan();
+
+    buffer.WriteSpan(ref readOnlySpan, _size);
+  }
+
+  public override string ToString()
+  {
+    return $"Payload Size: {_size}";
+  }
+}

Ragon.Client/Sources/Entity/RagonProperty.cs

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client
+{
+  [Serializable]
+  public class RagonProperty
+  {
+    public string Name => _name;
+    public RagonEntity Entity => _entity;
+
+    public event Action Changed;
+    public bool IsDirty => _dirty && _ticks >= _priority;
+    public bool IsFixed => _fixed;
+    public int Size => _size;
+
+    private RagonBuffer _propertyBuffer;
+    private RagonEntity _entity;    
+    private bool _dirty;
+    private int _size;
+    private int _ticks;
+    private int _priority;
+    private bool _fixed;
+    private string _name;
+
+    protected bool InvokeLocal;
+
+    protected RagonProperty(int priority, bool invokeLocal)
+    {
+      _size = 0;
+      _priority = priority;
+      _fixed = false;
+      _propertyBuffer = new RagonBuffer();
+      
+      InvokeLocal = invokeLocal;
+    }
+
+    public void SetName(string name)
+    {
+      _name = name;
+    }
+
+    protected void SetFixedSize(int size)
+    {
+      _size = size;
+      _fixed = true;
+    }
+
+    protected void InvokeChanged()
+    {
+      if (!InvokeLocal)
+        return;
+
+      Changed?.Invoke();
+    }
+
+    protected void MarkAsChanged()
+    {
+      InvokeChanged();
+
+      if (_dirty || _entity == null)
+        return;
+
+      _dirty = true;
+      _entity.TrackChangedProperty(this);
+    }
+
+    internal void Flush()
+    {
+      _dirty = false;
+      _ticks = 0;
+    }
+
+    internal void AddTick()
+    {
+      _ticks++;
+    }
+
+    internal void AssignEntity(RagonEntity ent)
+    {
+      _entity = ent;
+
+      Changed?.Invoke();
+    }
+
+    internal void Write(RagonBuffer buffer)
+    {
+      _propertyBuffer.Clear();
+      
+      if (_fixed)
+      {
+        Serialize(_propertyBuffer);
+        
+        buffer.FromBuffer(_propertyBuffer, _size);
+        return;
+      }
+
+      Serialize(_propertyBuffer);
+
+      var propertySize = (ushort) _propertyBuffer.WriteOffset;
+      buffer.WriteUShort(propertySize);;
+      buffer.FromBuffer(_propertyBuffer, propertySize);
+    }
+
+    internal void Read(RagonBuffer buffer)
+    {
+      _propertyBuffer.Clear();
+      
+      if (_fixed)
+      {
+        buffer.ToBuffer(_propertyBuffer, _size);
+        
+        Deserialize(_propertyBuffer);
+        return;
+      }
+      
+      var propSize = buffer.ReadUShort();
+      buffer.ToBuffer(_propertyBuffer, propSize);
+      Deserialize(_propertyBuffer);
+    }
+
+    public virtual void Serialize(RagonBuffer buffer)
+    {
+    }
+
+    public virtual void Deserialize(RagonBuffer buffer)
+    {
+    }
+  }
+}

Ragon.Client/Sources/Handler/AuthorizeFailedHandler.cs

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal class AuthorizeFailedHandler: Handler
+{
+  private readonly RagonListenerList _listenerList;
+  public AuthorizeFailedHandler(RagonListenerList list)
+  {
+    _listenerList = list;
+  }
+  
+  public void Handle(RagonBuffer buffer)
+  {
+    var message = buffer.ReadString();
+    _listenerList.OnAuthorizationFailed(message);
+  }
+}

Ragon.Client/Sources/Handler/AuthorizeSuccessHandler.cs

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal  class AuthorizeSuccessHandler: Handler
+{
+  private readonly RagonListenerList _listenerList;
+  
+  public AuthorizeSuccessHandler(RagonListenerList listenerList)
+  {
+    _listenerList = listenerList;
+  }
+  
+  public void Handle(RagonBuffer buffer)
+  {
+    var playerId = buffer.ReadString();
+    var playerName = buffer.ReadString();
+    var playerPayload = buffer.ReadString();
+
+    _listenerList.OnAuthorizationSuccess(playerId, playerName, playerPayload);
+  }
+}

Ragon.Client/Sources/Handler/EntityCreateHandler.cs

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal  class EntityCreateHandler : Handler
+{
+  private readonly RagonClient _client;
+  private readonly RagonPlayerCache _playerCache;
+  private readonly RagonEntityCache _entityCache;
+  
+  public EntityCreateHandler(
+    RagonClient client,
+    RagonPlayerCache playerCache,
+    RagonEntityCache entityCache
+  )
+  {
+    _client = client;
+    _entityCache = entityCache;
+    _playerCache = playerCache;
+  }
+
+  public void Handle(RagonBuffer buffer)
+  {
+    var attachId = buffer.ReadUShort();
+    var entityType = buffer.ReadUShort();
+    var entityId = buffer.ReadUShort();
+    var ownerId = buffer.ReadUShort();
+    var player = _playerCache.GetPlayerByPeer(ownerId);
+    var payload = new RagonPayload(buffer.Capacity);
+    payload.Read(buffer);
+
+    if (player == null)
+    {
+      RagonLog.Warn($"Owner {ownerId}|{player.Name} not found in players");
+      return;
+    }
+    
+    var hasAuthority = _playerCache.Local.Id == player.Id;
+    var entity = _entityCache.OnCreate(attachId, entityType, 0, entityId, hasAuthority);
+    entity.Attach(_client, entityId, entityType, hasAuthority, player, payload);
+  }
+}

Ragon.Client/Sources/Handler/EntityEventHandler.cs

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal class EntityEventHandler : Handler
+{
+    private readonly RagonClient _client;
+    private readonly RagonPlayerCache _playerCache;
+    private readonly RagonEntityCache _entityCache;
+
+    public EntityEventHandler(
+        RagonClient client,
+        RagonPlayerCache playerCache,
+        RagonEntityCache entityCache
+    )
+    {
+        _client = client;
+        _playerCache = playerCache;
+        _entityCache = entityCache;
+    }
+
+    public void Handle(RagonBuffer buffer)
+    {
+        var eventCode = buffer.ReadUShort();
+        var peerId = buffer.ReadUShort();
+        var executionMode = (RagonReplicationMode)buffer.ReadByte();
+        var entityId = buffer.ReadUShort();
+
+        var player = _playerCache.GetPlayerByPeer(peerId);
+        if (player == null)
+        {
+            RagonLog.Warn($"Player not found for event {eventCode}");
+            return;
+        }
+
+        if (player.IsLocal && executionMode == RagonReplicationMode.LocalAndServer)
+            return;
+
+        _entityCache.OnEvent(player, entityId, eventCode, buffer);
+    }
+}

Ragon.Client/Sources/Handler/EntityOwnershipHandler.cs

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal class EntityOwnershipHandler: Handler
+{
+  private readonly RagonListenerList _listenerList;
+  private readonly RagonPlayerCache _playerCache;
+  private readonly RagonEntityCache _entityCache;
+  
+  public EntityOwnershipHandler(
+    RagonListenerList listenerList,
+    RagonPlayerCache playerCache,
+    RagonEntityCache entityCache)
+  {
+    _listenerList = listenerList;
+    _playerCache = playerCache;
+    _entityCache = entityCache;
+  }
+  
+  public void Handle(RagonBuffer buffer)
+  {
+    var newOwnerId = buffer.ReadUShort();
+    var entities = buffer.ReadUShort();
+    
+    var player = _playerCache.GetPlayerByPeer(newOwnerId);
+    for (var i = 0; i < entities; i++)
+    {
+      var entityId = buffer.ReadUShort();
+      _entityCache.OnOwnershipChanged(player, entityId);
+      
+      RagonLog.Trace("Entity changed owner: " + entityId);
+    }
+  }
+}

Ragon.Client/Sources/Handler/EntityRemoveHandler.cs

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal  class EntityRemoveHandler: Handler
+{
+  private readonly RagonEntityCache _entityCache;
+  
+  public EntityRemoveHandler(RagonEntityCache entityCache)
+  {
+    _entityCache = entityCache;
+  }
+  
+  public void Handle(RagonBuffer buffer)
+  {
+    var entityId = buffer.ReadUShort();
+    var payload = new RagonPayload(buffer.Capacity);
+    payload.Read(buffer);
+    
+    _entityCache.OnDestroy(entityId, payload);
+  }
+}

Ragon.Client/Sources/Handler/EntityStateHandler.cs

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal class StateEntityHandler: Handler
+{
+  private readonly RagonEntityCache _entityCache;
+  
+  public StateEntityHandler(RagonEntityCache entityCache)
+  {
+    _entityCache = entityCache;
+  }
+  
+  public void Handle(RagonBuffer buffer)
+  {
+    var entitiesCount = buffer.ReadUShort();
+    for (var i = 0; i < entitiesCount; i++)
+    {
+      var entityId = buffer.ReadUShort();
+      _entityCache.OnState(entityId, buffer);
+    }
+  }
+}

Ragon.Client/Sources/Handler/Handler.cs

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public interface Handler
+{
+  public void Handle(RagonBuffer buffer);
+}

Ragon.Client/Sources/Handler/JoinFailedHandler.cs

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal  class JoinFailedHandler: Handler
+{
+  private readonly RagonListenerList _listenerList;
+  
+  public JoinFailedHandler(RagonListenerList listenerList)
+  {
+    _listenerList = listenerList;
+  }
+  
+  public void Handle(RagonBuffer buffer)
+  {
+    var message = buffer.ReadString();
+    _listenerList.OnFailed(message);
+  }
+}

Ragon.Client/Sources/Handler/JoinSuccessHandler.cs

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public struct RagonRoomInformation
+{
+  public RagonRoomInformation(string roomId, string playerId, string ownerId, ushort min, ushort max)
+  {
+    RoomId = roomId;
+    PlayerId = playerId;
+    OwnerId = ownerId;
+    Min = min;
+    Max = max;
+  }
+
+  public string RoomId { get; private set; }
+  public string PlayerId { get; private set; }
+  public string OwnerId { get; private set; }
+  public ushort Min { get; private set; }
+  public ushort Max { get; private set; }
+}
+
+internal class JoinSuccessHandler : Handler
+{
+  private readonly RagonListenerList _listenerList;
+  private readonly RagonPlayerCache _playerCache;
+  private readonly RagonEntityCache _entityCache;
+  private readonly RagonClient _client;
+  private readonly RagonBuffer _buffer;
+
+  public JoinSuccessHandler(
+    RagonClient client,
+    RagonBuffer buffer,
+    RagonListenerList listenerList,
+    RagonPlayerCache playerCache,
+    RagonEntityCache entityCache
+  )
+  {
+    _buffer = buffer;
+    _client = client;
+    _listenerList = listenerList;
+    _entityCache = entityCache;
+    _playerCache = playerCache;
+  }
+
+  public void Handle(RagonBuffer buffer)
+  {
+    var roomId = buffer.ReadString();
+    var localId = buffer.ReadString();
+    var ownerId = buffer.ReadString();
+    var min = buffer.ReadUShort();
+    var max = buffer.ReadUShort();
+    var map = buffer.ReadString();
+
+    var scene = new RagonScene(_client, _playerCache, _entityCache);
+    var roomInfo = new RagonRoomInformation(roomId, localId, ownerId, min, max);
+    var room = new RagonRoom(_client, _entityCache, _playerCache, roomInfo, scene);
+
+    _playerCache.SetOwnerAndLocal(ownerId, localId);
+    _client.AssignRoom(room);
+    _listenerList.OnLevel(map);
+  }
+}

Ragon.Client/Sources/Handler/LeaveRoomHandler.cs

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal  class LeaveRoomHandler : Handler
+{
+  private readonly RagonClient _client;
+  private readonly RagonListenerList _listenerList;
+  private readonly RagonEntityCache _entityCache;
+  
+  public LeaveRoomHandler(
+    RagonClient client,
+    RagonListenerList listenerList,
+    RagonEntityCache entityCache)
+  {
+    _client = client;
+    _listenerList = listenerList;
+    _entityCache = entityCache;
+  }
+
+  public void Handle(RagonBuffer buffer)
+  {    
+    _listenerList.OnLeft();
+    _entityCache.Cleanup();
+    _client.Room.Cleanup();
+  }
+}

Ragon.Client/Sources/Handler/LoadSceneHandler.cs

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal class SceneLoadHandler: Handler
+{
+  private readonly RagonClient _client;
+  private readonly RagonListenerList _listenerList;
+  
+  public SceneLoadHandler(
+    RagonClient ragonClient,
+    RagonListenerList listenerList
+    )
+  {
+    _client = ragonClient;
+    _listenerList = listenerList;
+  }
+  
+  public void Handle(RagonBuffer buffer)
+  {
+    var sceneName = buffer.ReadString();
+    var room = _client.Room;
+    
+    room.Cleanup();
+    
+    _listenerList.OnLevel(sceneName);
+  }
+}

Ragon.Client/Sources/Handler/OwnershipRoomHandler.cs

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal  class OwnershipRoomHandler: Handler
+{
+  private readonly RagonListenerList _listenerList;
+  private readonly RagonPlayerCache _playerCache;
+  private readonly RagonEntityCache _entityCache;
+  
+  public OwnershipRoomHandler(
+    RagonListenerList listenerList,
+    RagonPlayerCache playerCache,
+    RagonEntityCache entityCache)
+  {
+    _listenerList = listenerList;
+    _playerCache = playerCache;
+    _entityCache = entityCache;
+  }
+  
+  public void Handle(RagonBuffer buffer)
+  {
+    var newOwnerId = buffer.ReadUShort();
+    var player = _playerCache.GetPlayerByPeer(newOwnerId);
+
+    _playerCache.OnOwnershipChanged(newOwnerId);
+    _listenerList.OnOwnershipChanged(player);
+  }
+}

Ragon.Client/Sources/Handler/PlayerJoinHandler.cs

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal class PlayerJoinHandler : Handler
+{
+  private RagonPlayerCache _playerCache;
+  private RagonListenerList _listenerList;
+
+  public PlayerJoinHandler(
+    RagonPlayerCache playerCache,
+    RagonListenerList listenerList
+  )
+  {
+    _playerCache = playerCache;
+    _listenerList = listenerList;
+  }
+
+  public void Handle(RagonBuffer buffer)
+  {
+    var playerPeerId = buffer.ReadUShort();
+    var playerId = buffer.ReadString();
+    var playerName = buffer.ReadString();
+
+    _playerCache.AddPlayer(playerPeerId, playerId, playerName);
+
+    var player = _playerCache.GetPlayerById(playerId);
+    if (player != null)
+      _listenerList.OnPlayerJoined(player);
+    else
+      RagonLog.Trace($"[Joined] {playerId}");
+  }
+}

Ragon.Client/Sources/Handler/PlayerLeftHandler.cs

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal class PlayerLeftHandler : Handler
+{
+  private RagonPlayerCache _playerCache;
+  private RagonEntityCache _entityCache;
+  private RagonListenerList _listenerList;
+
+  public PlayerLeftHandler(
+    RagonEntityCache entityCache,
+    RagonPlayerCache playerCache,
+    RagonListenerList listenerList
+  )
+  {
+    _entityCache = entityCache;
+    _playerCache = playerCache;
+    _listenerList = listenerList;
+  }
+
+  public void Handle(RagonBuffer buffer)
+  {
+    var playerId = buffer.ReadString();
+    var player = _playerCache.GetPlayerById(playerId);
+    if (player != null)
+    {
+      _playerCache.RemovePlayer(playerId);
+      _listenerList.OnPlayerLeft(player);
+
+      var entities = buffer.ReadUShort();
+      var toDeleteIds = new ushort[entities];
+      for (var i = 0; i < entities; i++)
+      {
+        var entityId = buffer.ReadUShort();
+        toDeleteIds[i] = entityId;
+      }
+
+      foreach (var id in toDeleteIds)
+        _entityCache.OnDestroy(id, new RagonPayload());
+    }
+  }
+}

Ragon.Client/Sources/Handler/SnapshotHandler.cs

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using System.Diagnostics;
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+internal class SnapshotHandler : Handler
+{
+  private RagonClient _client;
+  private RagonListenerList _listenerList;
+  private RagonEntityCache _entityCache;
+  private RagonPlayerCache _playerCache;
+
+  public SnapshotHandler(
+    RagonClient ragonClient,
+    RagonListenerList listenerList,
+    RagonEntityCache entityCache,
+    RagonPlayerCache playerCache
+  )
+  {
+    _client = ragonClient;
+    _listenerList = listenerList;
+    _entityCache = entityCache;
+    _playerCache = playerCache;
+  }
+
+  public void Handle(RagonBuffer buffer)
+  {
+    var playersCount = buffer.ReadUShort();
+    RagonLog.Trace("Players: " + playersCount);
+    for (var i = 0; i < playersCount; i++)
+    {
+      var playerPeerId = buffer.ReadUShort();
+      var playerId = buffer.ReadString();
+      var playerName = buffer.ReadString();
+
+      _playerCache.AddPlayer(playerPeerId, playerId, playerName);
+    }
+    var dynamicEntities = buffer.ReadUShort();
+    RagonLog.Trace("Dynamic Entities: " + dynamicEntities);
+    for (var i = 0; i < dynamicEntities; i++)
+    {
+      var entityType = buffer.ReadUShort();
+      var entityId = buffer.ReadUShort();
+      var ownerPeerId = buffer.ReadUShort();
+      var payloadSize = buffer.ReadUShort();
+      var player = _playerCache.GetPlayerByPeer(ownerPeerId);
+      
+      var payload = new RagonPayload(payloadSize);
+      payload.Read(buffer);
+
+      var hasAuthority = _playerCache.Local.Id == player.Id;
+      var entity = _entityCache.OnCreate(0, entityType, 0, entityId, hasAuthority);
+      
+      entity.Read(buffer);
+      entity.Attach(_client, entityId, entityType, hasAuthority, player, payload);
+    }
+
+    var staticEntities = buffer.ReadUShort();
+    RagonLog.Trace("Scene Entities: " + staticEntities);
+    for (var i = 0; i < staticEntities; i++)
+    {
+      var entityType = buffer.ReadUShort();
+      var entityId = buffer.ReadUShort();
+      var staticId = buffer.ReadUShort();
+      var ownerPeerId = buffer.ReadUShort();
+      var payloadSize = buffer.ReadUShort();
+      var player = _playerCache.GetPlayerByPeer(ownerPeerId);
+      
+      var payload = new RagonPayload(payloadSize);
+      payload.Read(buffer);
+
+      var hasAuthority = _playerCache.Local.Id == player.Id;
+      var entity = _entityCache.OnCreate(0, entityType, staticId, entityId, hasAuthority);
+      
+      entity.Read(buffer);
+      entity.Attach(_client, entityId, entityType, hasAuthority, player, payload);
+    }
+    
+    _listenerList.OnJoined();
+  }
+}

Ragon.Client/Sources/IO/INetworkChannel.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface INetworkChannel
+{
+  void Send(byte[] data);
+}

Ragon.Client/Sources/IO/INetworkConnection.cs

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public interface INetworkConnection: IRagonConnection
+{
+    public INetworkChannel Reliable { get; }
+    public INetworkChannel Unreliable { get; }
+    public Action<byte[]> OnData { get; set; }
+    public Action OnConnected { get; set; }
+    public Action<RagonDisconnect> OnDisconnected { get; set; }
+    public ulong BytesSent { get; }
+    public  ulong BytesReceived { get; }
+    public int Ping { get;  }
+    public void Prepare();
+    public void Connect(string address, ushort port, uint protocol);
+    public void Disconnect();
+    public void Update();
+    public void Dispose();
+}

Ragon.Client/Sources/IO/NetworkStatistics.cs

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+namespace Ragon.Client;
+
+public class NetworkStatistics
+{
+  private const double Interval = 1.0d;
+  private double _upstreamBandwidth = 0d;
+  private double _downstreamBandwidth = 0d;
+  private double _time = 0d;
+  private ulong _upstreamData = 0;
+  private ulong _downstreamData = 0;
+  private ulong _sent = 0;
+  private ulong _received = 0;
+  private int _ping;
+
+  public int Ping => _ping;
+  public double UpstreamBandwidth => _upstreamBandwidth;
+  public double DownstreamBandwidth => _downstreamBandwidth;
+  
+  public void Update(ulong sent, ulong received, int ping, float dt)
+  {
+    _sent = sent;
+    _received = received;
+    _ping = ping;
+    
+    _time += dt;
+    if (_time >= Interval)
+    {
+      if (_upstreamData > 0)
+      {
+        _upstreamData = _sent - _upstreamData;
+        _upstreamBandwidth = (_upstreamData / _time) / 1000 ;
+      }
+
+      if (_downstreamData > 0)
+      {
+        _downstreamData = _received - _downstreamData;
+        _downstreamBandwidth = (_downstreamData / _time) / 1000;
+      }
+
+      _upstreamData = _sent;
+      _downstreamData = _received;
+      _time -= Interval;
+    }
+  }
+}

Ragon.Client/Sources/IRagonConnection.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonConnection
+{
+ 
+}

Ragon.Client/Sources/IRagonEntityListener.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonEntityListener
+{
+  public void OnEntityCreated(RagonEntity entity);
+}

Ragon.Client/Sources/IRagonEvent.cs

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client
+{
+  public interface IRagonEvent: IRagonSerializable
+  {
+    
+  }
+}

Ragon.Client/Sources/IRagonPayload.cs

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client
+{
+  public interface IRagonPayload: IRagonSerializable
+  {
+    
+  }
+}

Ragon.Client/Sources/IRagonSceneCollector.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonSceneCollector
+{
+  public RagonEntity[] Collect();
+}

Ragon.Client/Sources/Listener/IRagonAuthorizationListener.cs

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+namespace Ragon.Client;
+
+public interface IRagonAuthorizationListener
+{
+  void OnAuthorizationSuccess(RagonClient client, string playerId, string playerName);
+  void OnAuthorizationFailed(RagonClient client, string message);
+}

Ragon.Client/Sources/Listener/IRagonConnectionListener.cs

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public interface IRagonConnectionListener
+{
+  void OnConnected(RagonClient client);
+  void OnDisconnected(RagonClient client, RagonDisconnect reason);
+}

Ragon.Client/Sources/Listener/IRagonFailedListener.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonFailedListener
+{
+  void OnFailed(RagonClient client, string message);
+}

Ragon.Client/Sources/Listener/IRagonJoinListener.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonJoinListener
+{
+  void OnJoined(RagonClient client);
+}

Ragon.Client/Sources/Listener/IRagonLeftListener.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonLeftListener
+{
+  void OnLeft(RagonClient client);
+}

Ragon.Client/Sources/Listener/IRagonLevelListener.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonLevelListener
+{
+  void OnLevel(RagonClient client, string sceneName);
+}

Ragon.Client/Sources/Listener/IRagonListener.cs

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client
+{
+  public interface IRagonListener : 
+    IRagonAuthorizationListener, 
+    IRagonConnectionListener, 
+    IRagonFailedListener,
+    IRagonJoinListener, 
+    IRagonLeftListener, 
+    IRagonLevelListener, 
+    IRagonOwnershipChangedListener,
+    IRagonPlayerJoinListener, 
+    IRagonPlayerLeftListener
+  {
+  }
+}

Ragon.Client/Sources/Listener/IRagonOwnershipChangedListener.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonOwnershipChangedListener
+{
+  void OnOwnershipChanged(RagonClient client, RagonPlayer player);
+}

Ragon.Client/Sources/Listener/IRagonPlayerJoinListener.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonPlayerJoinListener
+{
+  void OnPlayerJoined(RagonClient client, RagonPlayer player);
+}

Ragon.Client/Sources/Listener/IRagonPlayerLeftListener.cs

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public interface IRagonPlayerLeftListener
+{
+  void OnPlayerLeft(RagonClient client, RagonPlayer player);
+}

Ragon.Client/Sources/Log/IRagonLogger.cs

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client
+{
+  public interface IRagonLogger
+  {
+    public void Warn(string message);
+    public void Trace(string message);
+    public void Info(string message);
+    public void Error(string message);
+  }
+}

Ragon.Client/Sources/Log/Loggers/RagonConsoleLogger.cs

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client
+{
+  public class RagonConsoleLogger: IRagonLogger
+  {
+    public void Warn(string message)
+    {
+     Console.WriteLine($"[WARN] {message}"); 
+    }
+    
+    public void Trace(string message)
+    {
+      Console.WriteLine($"[TRACE] {message}");
+    }
+    
+    public void Info(string message)
+    {
+      Console.WriteLine($"[INFO] {message}");
+    }
+    
+    public void Error(string message)
+    {
+      Console.WriteLine($"[ERROR] {message}");
+    }
+  }
+}

Ragon.Client/Sources/Log/RagonLog.cs

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client
+{
+  public class RagonLog
+  {
+    private static IRagonLogger _ragonLogger;
+    static RagonLog() => _ragonLogger = new RagonConsoleLogger();
+    public static void Set(IRagonLogger logger) => _ragonLogger = logger;
+    public static void Warn(string message) => _ragonLogger.Warn(message);
+    public static void Trace(string message) => _ragonLogger.Trace(message);
+    public static void Info(string message) => _ragonLogger.Info(message);
+    public static void Error(string message) => _ragonLogger.Error(message);
+  }
+}

Ragon.Client/Sources/Log/RagonLogLevel.cs

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public enum RagonLogLevel
+{
+  ALL,
+  CONNECTION,
+  STATE,
+  EVENT,
+  ROOM,
+}

Ragon.Client/Sources/RagonClient.cs

@@ -0,0 +1,221 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client
+{
+  public sealed class RagonClient
+  {
+    private readonly INetworkConnection _connection;
+    private IRagonEntityListener _entityListener;
+    private IRagonSceneCollector _sceneCollector;
+    private Handler[] _handlers;
+    private RagonBuffer _readBuffer;
+    private RagonBuffer _writeBuffer;
+    private RagonRoom _room;
+    private RagonSession _session;
+    private RagonListenerList _listenerList;
+    private RagonPlayerCache _playerCache;
+    private RagonEntityCache _entityCache;
+    private RagonEventCache _eventCache;
+    private RagonStatus _status;
+    private NetworkStatistics _stats;
+
+    private float _replicationRate = 0;
+    private float _replicationTime = 0;
+
+    public IRagonConnection Connection => _connection;
+    public RagonStatus Status => _status;
+    public RagonSession Session => _session;
+    public RagonEventCache Event => _eventCache;
+    public RagonEntityCache Entity => _entityCache;
+    public NetworkStatistics Statistics => _stats;
+    public RagonRoom Room => _room;
+
+    internal RagonBuffer Buffer => _writeBuffer;
+    internal INetworkChannel Reliable => _connection.Reliable;
+    internal INetworkChannel Unreliable => _connection.Unreliable;
+
+    #region PUBLIC
+
+    public RagonClient(INetworkConnection connection, int rate)
+    {
+      _connection = connection;
+      _connection.OnData += OnData;
+      _connection.OnConnected += OnConnected;
+      _connection.OnDisconnected += OnDisconnected;
+      
+      _listenerList = new RagonListenerList(this);
+      
+      _replicationRate = (1000.0f / rate) / 1000.0f;
+      _replicationTime = 0;
+
+      _eventCache = new RagonEventCache();
+      _stats = new NetworkStatistics();
+      _status = RagonStatus.DISCONNECTED;
+    }
+
+
+    public void Configure(IRagonSceneCollector sceneCollector)
+    {
+      _sceneCollector = sceneCollector;
+    }
+
+    public void Configure(IRagonEntityListener listener)
+    {
+      _entityListener = listener;
+    }
+    
+    public void Connect(string address, ushort port, string protocol)
+    {
+      if (_sceneCollector == null)
+      {
+        RagonLog.Error("Scene collector is not defined!");
+        return;
+      }
+
+      if (_entityListener == null)
+      {
+        RagonLog.Error("Entity Listener is not defined!");
+        return;
+      }
+      
+      _writeBuffer = new RagonBuffer();
+      _readBuffer = new RagonBuffer();
+      _session = new RagonSession(this, _readBuffer);
+
+      _playerCache = new RagonPlayerCache();
+      _entityCache = new RagonEntityCache(this, _playerCache, _entityListener, _sceneCollector);
+
+      _handlers = new Handler[byte.MaxValue];
+      _handlers[(byte)RagonOperation.AUTHORIZED_SUCCESS] = new AuthorizeSuccessHandler(_listenerList);
+      _handlers[(byte)RagonOperation.AUTHORIZED_FAILED] = new AuthorizeFailedHandler(_listenerList);
+      _handlers[(byte)RagonOperation.JOIN_SUCCESS] = new JoinSuccessHandler(this, _readBuffer, _listenerList, _playerCache, _entityCache);
+      _handlers[(byte)RagonOperation.JOIN_FAILED] = new JoinFailedHandler(_listenerList);
+      _handlers[(byte)RagonOperation.LEAVE_ROOM] = new LeaveRoomHandler(this, _listenerList, _entityCache);
+      _handlers[(byte)RagonOperation.OWNERSHIP_ROOM_CHANGED] = new OwnershipRoomHandler(_listenerList, _playerCache, _entityCache);
+      _handlers[(byte)RagonOperation.OWNERSHIP_ENTITY_CHANGED] = new EntityOwnershipHandler(_listenerList, _playerCache, _entityCache);
+      _handlers[(byte)RagonOperation.PLAYER_JOINED] = new PlayerJoinHandler(_playerCache, _listenerList);
+      _handlers[(byte)RagonOperation.PLAYER_LEAVED] = new PlayerLeftHandler(_entityCache, _playerCache, _listenerList);
+      _handlers[(byte)RagonOperation.LOAD_SCENE] = new SceneLoadHandler(this, _listenerList);
+      _handlers[(byte)RagonOperation.CREATE_ENTITY] = new EntityCreateHandler(this, _playerCache, _entityCache);
+      _handlers[(byte)RagonOperation.REMOVE_ENTITY] = new EntityRemoveHandler(_entityCache);
+      _handlers[(byte)RagonOperation.REPLICATE_ENTITY_STATE] = new StateEntityHandler(_entityCache);
+      _handlers[(byte)RagonOperation.REPLICATE_ENTITY_EVENT] = new EntityEventHandler(this, _playerCache, _entityCache);
+      _handlers[(byte)RagonOperation.SNAPSHOT] = new SnapshotHandler(this, _listenerList, _entityCache, _playerCache);
+
+      var protocolRaw = RagonVersion.Parse(protocol);
+      _connection.Connect(address, port, protocolRaw);
+    }
+
+    public void Disconnect()
+    {
+      _status = RagonStatus.DISCONNECTED;
+      _room.Cleanup();
+      _connection.Disconnect();
+      
+      OnDisconnected(RagonDisconnect.MANUAL);
+    }
+
+    public void Update(float dt)
+    {
+      if (_status != RagonStatus.DISCONNECTED)
+      {
+        _replicationTime += dt;
+        if (_replicationTime >= _replicationRate)
+        {
+          _entityCache.WriteState(_readBuffer);
+          _replicationTime = 0;
+        }
+
+        _stats.Update(_connection.BytesSent, _connection.BytesReceived, _connection.Ping, dt);
+      }
+
+      _connection.Update();
+    }
+
+    public void Dispose()
+    {
+      _status = RagonStatus.DISCONNECTED;
+      _connection.Disconnect();
+      _connection.Dispose();
+    }
+
+    public void AddListener(IRagonListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonAuthorizationListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonConnectionListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonFailedListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonJoinListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonLeftListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonLevelListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonOwnershipChangedListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonPlayerJoinListener listener) => _listenerList.Add(listener);
+    public void AddListener(IRagonPlayerLeftListener listener) => _listenerList.Add(listener);
+
+    public void RemoveListener(IRagonListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonAuthorizationListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonConnectionListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonFailedListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonJoinListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonLeftListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonLevelListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonOwnershipChangedListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonPlayerJoinListener listener) => _listenerList.Remove(listener);
+    public void RemoveListener(IRagonPlayerLeftListener listener) => _listenerList.Remove(listener);
+    
+    #endregion
+
+    #region INTERNAL
+
+    internal void AssignRoom(RagonRoom room)
+    {
+      _room = room;
+      _status = RagonStatus.ROOM;
+    }
+
+    #endregion
+
+    #region PRIVATE
+
+    private void OnConnected()
+    {
+      RagonLog.Trace("Connected");
+
+      _listenerList.OnConnected();
+      _status = RagonStatus.CONNECTED;
+    }
+
+    private void OnDisconnected(RagonDisconnect reason)
+    {
+      RagonLog.Trace($"Disconnected: {reason}");
+
+      _listenerList.OnDisconnected(reason);
+      _status = RagonStatus.DISCONNECTED;
+    }
+
+    public void OnData(byte[] data)
+    {
+      _readBuffer.Clear();
+      _readBuffer.FromArray(data);
+
+      var operation = _readBuffer.ReadByte();
+      _handlers[operation].Handle(_readBuffer);
+    }
+
+    #endregion
+  }
+}

Ragon.Client/Sources/RagonEntityCache.cs

@@ -0,0 +1,255 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public sealed class RagonEntityCache
+{
+  private readonly List<RagonEntity> _entityList = new();
+  private readonly Dictionary<uint, RagonEntity> _entityMap = new();
+  private readonly Dictionary<uint, RagonEntity> _pendingEntities = new();
+  private readonly Dictionary<uint, RagonEntity> _sceneEntities = new();
+
+  private readonly RagonClient _client;
+  private readonly IRagonEntityListener _entityListener;
+  private readonly IRagonSceneCollector _sceneCollector;
+  private readonly RagonPlayerCache _playerCache;
+
+  private int _localEntitiesCounter = 0;
+
+  public RagonEntityCache(
+    RagonClient client,
+    RagonPlayerCache playerCache,
+    IRagonEntityListener listener,
+    IRagonSceneCollector sceneCollector
+  )
+  {
+    _client = client;
+    _entityListener = listener;
+    _sceneCollector = sceneCollector;
+    _playerCache = playerCache;
+  }
+
+  public bool TryGetEntity(ushort id, out RagonEntity entity)
+  {
+    return _entityMap.TryGetValue(id, out entity);
+  }
+
+  public void Create(RagonEntity entity, IRagonPayload? spawnPayload)
+  {
+    var attachId = (ushort)(_playerCache.Local.PeerId + _localEntitiesCounter++);
+    var buffer = _client.Buffer;
+
+    buffer.Clear();
+    buffer.WriteOperation(RagonOperation.CREATE_ENTITY);
+    buffer.WriteUShort(attachId);
+    buffer.WriteUShort(entity.Type);
+    buffer.WriteByte((byte)entity.Authority);
+
+    entity.State.WriteInfo(buffer);
+
+    spawnPayload?.Serialize(buffer);
+
+    _pendingEntities.Add(attachId, entity);
+
+    var sendData = buffer.ToArray();
+    _client.Reliable.Send(sendData);
+  }
+
+  public void Transfer(RagonEntity entity, RagonPlayer player)
+  {
+    var buffer = _client.Buffer;
+
+    buffer.Clear();
+    buffer.WriteOperation(RagonOperation.TRANSFER_ENTITY_OWNERSHIP);
+    buffer.WriteUShort(entity.Id);
+    buffer.WriteUShort(player.PeerId);
+
+    var sendData = buffer.ToArray();
+    _client.Reliable.Send(sendData);
+  }
+
+  public void Destroy(RagonEntity entity, IRagonPayload? destroyPayload)
+  {
+    if (!entity.IsAttached)
+    {
+      RagonLog.Warn("Can't destroy object, he is not created");
+      return;
+    }
+
+    var buffer = _client.Buffer;
+
+    buffer.Clear();
+    buffer.WriteOperation(RagonOperation.REMOVE_ENTITY);
+    buffer.WriteUShort(entity.Id);
+
+    destroyPayload?.Serialize(buffer);
+
+    var sendData = buffer.ToArray();
+    _client.Reliable.Send(sendData);
+  }
+
+  internal void WriteState(RagonBuffer buffer)
+  {
+    var changedEntities = 0u;
+
+    buffer.Clear();
+    buffer.WriteOperation(RagonOperation.REPLICATE_ENTITY_STATE);
+
+    var offset = buffer.WriteOffset;
+    buffer.Write(0, 16);
+
+    foreach (var ent in _entityList)
+    {
+      if (!ent.IsAttached ||
+          !ent.Replication ||
+          !ent.PropertiesChanged) continue;
+
+      ent.Write(buffer);
+
+      changedEntities++;
+    }
+
+    if (changedEntities <= 0) return;
+
+    buffer.Write(changedEntities, 16, offset);
+
+    var data = buffer.ToArray();
+    _client.Unreliable.Send(data);
+  }
+
+  internal void WriteScene(RagonBuffer buffer)
+  {
+    _sceneEntities.Clear();
+
+    var entities = _sceneCollector.Collect();
+    buffer.WriteUShort((ushort)entities.Length);
+    foreach (var entity in entities)
+    {
+      buffer.WriteUShort(entity.Type);
+      buffer.WriteByte((byte)entity.Authority);
+      buffer.WriteUShort(entity.SceneId);
+
+      entity.State.WriteInfo(buffer);
+
+      _sceneEntities.Add(entity.SceneId, entity);
+    }
+  }
+
+  internal void CacheScene()
+  {
+    _sceneEntities.Clear();
+
+    var entities = _sceneCollector.Collect();
+    foreach (var entity in entities)
+      _sceneEntities.Add(entity.SceneId, entity);
+  }
+
+  internal void Cleanup()
+  {
+    var payload = new RagonPayload();
+    foreach (var ent in _entityList)
+      ent.Detach(payload);
+
+    _entityMap.Clear();
+    _entityList.Clear();
+  }
+
+  internal RagonEntity OnCreate(ushort attachId, ushort entityType, ushort sceneId, ushort entityId, bool hasAuthority)
+  {
+    if (sceneId > 0)
+    {
+      if (_sceneEntities.TryGetValue(sceneId, out var entity))
+      {
+        _entityMap.Add(entityId, entity);
+
+        if (hasAuthority)
+          _entityList.Add(entity);
+
+        return entity;
+      }
+    }
+
+    if (_pendingEntities.Remove(attachId, out var existsEntity))
+    {
+      _entityMap.Add(entityId, existsEntity);
+
+      if (hasAuthority)
+        _entityList.Add(existsEntity);
+
+      return existsEntity;
+    }
+    else
+    {
+      var entity = new RagonEntity(entityType, sceneId);
+
+      _entityMap.Add(entityId, entity);
+
+      if (hasAuthority)
+        _entityList.Add(entity);
+
+      _entityListener.OnEntityCreated(entity);
+
+      return entity;
+    }
+  }
+
+
+  internal void OnDestroy(ushort entityId, RagonPayload payload)
+  {
+    if (_entityMap.Remove(entityId, out var ragonEntity))
+    {
+      _entityList.Remove(ragonEntity);
+
+      ragonEntity.Detach(payload);
+    }
+  }
+
+  internal void OnState(ushort entityId, RagonBuffer buffer)
+  {
+    if (_entityMap.TryGetValue(entityId, out var entity))
+      entity.Read(buffer);
+    else
+      RagonLog.Warn($"Entity {entityId} not found!");
+  }
+
+  internal void OnEvent(RagonPlayer player, ushort entityId, ushort eventCode, RagonBuffer buffer)
+  {
+    if (_entityMap.TryGetValue(entityId, out var entity))
+      entity.Event(eventCode, player, buffer);
+    else
+      RagonLog.Warn($"Entity {entityId} not found!");
+  }
+
+  internal void OnOwnershipChanged(RagonPlayer player, ushort entityId)
+  {
+    if (_entityMap.TryGetValue(entityId, out var entity))
+    {
+      if (player.IsLocal)
+        _entityList.Add(entity);
+      else
+        _entityList.Remove(entity);
+      
+      entity.OnOwnershipChanged(player);
+    }
+    else
+    {
+      RagonLog.Warn($"Entity {entityId} not found!");
+    }
+  }
+}

Ragon.Client/Sources/RagonEventCache.cs

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public class RagonEventCache
+{
+  private readonly Dictionary<Type, ushort> _eventsRegistryByType = new();
+  private readonly HashSet<ushort> _codes = new();
+  private readonly HashSet<Type> _types = new();
+  private ushort _eventIdGenerator = 0;
+
+  public ushort GetEventCode<TEvent>(TEvent _) where TEvent : IRagonEvent
+  {
+    var type = typeof(TEvent);
+    if (!_eventsRegistryByType.TryGetValue(type, out var eventCode))
+    {
+      RagonLog.Error($"Event with type {type} not registered");
+      return 0;
+    }
+    return eventCode;
+  }
+
+  public void Register<T>() where T : IRagonEvent, new()
+  {
+    var type = typeof(T);
+    if (_types.Contains(type))
+    {
+      RagonLog.Trace($"[Ragon] Event already registered: {type.Name}");
+      return;
+    }
+
+    RagonLog.Trace($"[Ragon] Registered Event: {type.Name} - {_eventIdGenerator}");
+
+    _eventsRegistryByType.Add(type, _eventIdGenerator);
+    _codes.Add(_eventIdGenerator);
+    _types.Add(type);
+    
+    _eventIdGenerator++;
+  }
+
+  public void Register<T>(ushort evntCode) where T : IRagonEvent, new()
+  {
+    var type = typeof(T);
+    if (_codes.Contains(evntCode) || _types.Contains(type))
+    {
+      RagonLog.Warn($"[Ragon] Event already registered: {type.Name} - {evntCode}");
+      return;
+    }
+
+    RagonLog.Trace($"[Ragon] Registered Event: {type.Name} - {evntCode}");
+
+    _codes.Add(evntCode);
+    _types.Add(type);
+    _eventsRegistryByType.Add(type, evntCode);
+  }
+
+  public T Create<T>() where T : IRagonEvent, new()
+  {
+    return new T();
+  }
+}

Ragon.Client/Sources/RagonListenerList.cs

@@ -0,0 +1,221 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client
+{
+  internal class RagonListenerList
+  {
+    private readonly RagonClient _client;
+    private readonly List<IRagonAuthorizationListener> _authorizationListeners = new();
+    private readonly List<IRagonConnectionListener> _connectionListeners = new();
+    private readonly List<IRagonFailedListener> _failedListeners = new();
+    private readonly List<IRagonJoinListener> _joinListeners = new();
+    private readonly List<IRagonLeftListener> _leftListeners = new();
+    private readonly List<IRagonLevelListener> _levelListeners = new();
+    private readonly List<IRagonOwnershipChangedListener> _ownershipChangedListeners = new();
+    private readonly List<IRagonPlayerJoinListener> _playerJoinListeners = new();
+    private readonly List<IRagonPlayerLeftListener> _playerLeftListeners = new();
+    
+    public RagonListenerList(RagonClient client)
+    {
+      _client = client;
+    }
+    
+    public void Add(IRagonListener listener)
+    {
+      _authorizationListeners.Add(listener);
+      _connectionListeners.Add(listener);
+      _failedListeners.Add(listener);
+      _joinListeners.Add(listener);
+      _leftListeners.Add(listener);
+      _levelListeners.Add(listener);
+      _ownershipChangedListeners.Add(listener);
+      _playerJoinListeners.Add(listener);
+      _playerLeftListeners.Add(listener);
+    }
+
+    public void Remove(IRagonListener listener)
+    {
+      _authorizationListeners.Remove(listener);
+      _connectionListeners.Remove(listener);
+      _failedListeners.Remove(listener);
+      _joinListeners.Remove(listener);
+      _leftListeners.Remove(listener);
+      _levelListeners.Remove(listener);
+      _ownershipChangedListeners.Remove(listener);
+      _playerJoinListeners.Remove(listener);
+      _playerLeftListeners.Remove(listener);
+    }
+    
+    public void Add(IRagonAuthorizationListener listener)
+    {
+      _authorizationListeners.Add(listener);
+    }
+    
+    public void Add(IRagonConnectionListener listener)
+    {
+      _connectionListeners.Add(listener);
+    }
+    
+    public void Add(IRagonFailedListener listener)
+    {
+      _failedListeners.Add(listener);
+    }
+    
+    public void Add(IRagonJoinListener listener)
+    {
+      _joinListeners.Add(listener);
+    }
+    
+    public void Add(IRagonLeftListener  listener)
+    {
+      _leftListeners.Add(listener);
+    }
+    
+    public void Add(IRagonLevelListener  listener)
+    {
+      _levelListeners.Add(listener);
+    }
+    
+    public void Add(IRagonOwnershipChangedListener  listener)
+    {
+      _ownershipChangedListeners.Add(listener);
+    }
+
+    public void Add(IRagonPlayerJoinListener  listener)
+    {
+      _playerJoinListeners.Add(listener);
+    }
+    
+    public void Add(IRagonPlayerLeftListener  listener)
+    {
+      _playerLeftListeners.Add(listener);
+    }
+
+    public void Remove(IRagonAuthorizationListener listener)
+    {
+      _authorizationListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonConnectionListener listener)
+    {
+      _connectionListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonFailedListener listener)
+    {
+      _failedListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonJoinListener listener)
+    {
+      _joinListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonLeftListener  listener)
+    {
+      _leftListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonLevelListener  listener)
+    {
+      _levelListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonOwnershipChangedListener  listener)
+    {
+      _ownershipChangedListeners.Remove(listener);
+    }
+
+    public void Remove(IRagonPlayerJoinListener  listener)
+    {
+      _playerJoinListeners.Remove(listener);
+    }
+    
+    public void Remove(IRagonPlayerLeftListener  listener)
+    {
+      _playerLeftListeners.Remove(listener);
+    }
+
+    public void OnAuthorizationSuccess(string playerId, string playerName, string payload)
+    {
+      foreach (var listener in _authorizationListeners)
+        listener.OnAuthorizationSuccess(_client, playerId, playerName);
+    }
+    
+    public void OnAuthorizationFailed(string message)
+    {
+      foreach (var listener in _authorizationListeners)
+        listener.OnAuthorizationFailed(_client, message);
+    }
+    
+    public void OnLeft()
+    {
+      foreach (var listener in _leftListeners)
+        listener.OnLeft(_client);
+    }
+
+    public void OnFailed(string message)
+    {
+      foreach (var listener in _failedListeners)
+        listener.OnFailed(_client, message);
+    }
+
+    public void OnOwnershipChanged(RagonPlayer player)
+    {
+      foreach (var listener in _ownershipChangedListeners)
+        listener.OnOwnershipChanged(_client, player);
+    }
+
+    public void OnPlayerLeft(RagonPlayer player)
+    {
+      foreach (var listener in _playerLeftListeners)
+        listener.OnPlayerLeft(_client, player);
+    }
+
+    public void OnPlayerJoined(RagonPlayer player)
+    {
+      foreach (var listener in _playerJoinListeners)
+        listener.OnPlayerJoined(_client, player);
+    }
+
+    public void OnLevel(string sceneName)
+    {
+      foreach (var listener in _levelListeners)
+        listener.OnLevel(_client, sceneName);
+    }
+
+    public void OnJoined()
+    {
+      foreach (var listener in _joinListeners)
+        listener.OnJoined(_client);
+    }
+
+    public void OnConnected()
+    {
+      foreach (var listener in _connectionListeners)
+        listener.OnConnected(_client);
+    }
+
+    public void OnDisconnected(RagonDisconnect disconnect)
+    {
+      foreach (var listener in _connectionListeners)
+        listener.OnDisconnected(_client, disconnect);
+    }
+  }
+}

Ragon.Client/Sources/RagonPlayer.cs

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client
+{
+  [Serializable]
+  public class RagonPlayer
+  {
+    public string Id { get; private set; }
+    public string Name { get; set; }
+    public ushort PeerId { get; set; }
+    public bool IsRoomOwner { get; set; }
+    public bool IsLocal { get; set; }
+    
+    public RagonPlayer(ushort peerId, string playerId, string name, bool isRoomOwner, bool isLocal)
+    {
+      PeerId = peerId;
+      IsRoomOwner = isRoomOwner;
+      IsLocal = isLocal;
+      Name = name;
+      Id = playerId;
+    } 
+  }
+}

Ragon.Client/Sources/RagonPlayerCache.cs

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client;
+
+public sealed class RagonPlayerCache
+{
+  private readonly List<RagonPlayer> _players = new();
+  private readonly Dictionary<string, RagonPlayer> _playersById = new();
+  private readonly Dictionary<ushort, RagonPlayer> _playersByConnection = new();
+
+  public IReadOnlyList<RagonPlayer> Players => _players;
+  public RagonPlayer Owner { get; private set; }
+  public RagonPlayer Local { get; private set; }
+  public bool IsRoomOwner => _ownerId == _localId;
+  
+  public RagonPlayer? GetPlayerById(string playerId) => _playersById[playerId];
+  public RagonPlayer? GetPlayerByPeer(ushort peerId) => _playersByConnection[peerId];
+
+  private string _ownerId;
+  private string _localId;
+
+  public void SetOwnerAndLocal(string ownerId, string localId)
+  {
+    _ownerId = ownerId;
+    _localId = localId;
+  }
+
+  public void AddPlayer(ushort peerId, string playerId, string playerName)
+  {
+    if (_playersById.ContainsKey(playerId))
+      return;
+
+    var isOwner = playerId == _ownerId;
+    var isLocal = playerId == _localId;
+
+    RagonLog.Trace($"Added player {peerId}|{playerId}|{playerName} IsOwner: {isOwner} isLocal: {isLocal}");
+
+    var player = new RagonPlayer(peerId, playerId, playerName, isOwner, isLocal);
+
+    if (player.IsLocal)
+      Local = player;
+
+    if (player.IsRoomOwner)
+      Owner = player;
+
+    _players.Add(player);
+    _playersById.Add(player.Id, player);
+    _playersByConnection.Add(player.PeerId, player);
+  }
+
+  public void RemovePlayer(string playerId)
+  {
+    if (_playersById.Remove(playerId, out var player))
+    {
+      _players.Remove(player);
+      _playersByConnection.Remove(player.PeerId);
+    }
+  }
+
+  public void OnOwnershipChanged(ushort playerPeerId)
+  {
+    foreach (var player in _players)
+    {
+      if (player.PeerId == playerPeerId)
+      {
+        Owner = player;
+        Owner.IsRoomOwner = true;
+      }
+    }
+  }
+
+
+  public void Cleanup()
+  {
+    _players.Clear();
+    _playersByConnection.Clear();
+    _playersById.Clear();
+  }
+}

Ragon.Client/Sources/RagonRoom.cs

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client
+{
+  public class RagonRoom
+  {
+    private RagonClient _client;
+    private RagonScene _scene;
+    private RagonEntityCache _entityCache;
+    private RagonPlayerCache _playerCache;
+    private RagonRoomInformation _information;
+
+    public string Id => _information.RoomId;
+    public int MinPlayers => _information.Min;
+    public int MaxPlayers => _information.Max;
+
+    public IReadOnlyList<RagonPlayer> Players => _playerCache.Players;
+    public RagonPlayer Local => _playerCache.Local;
+    public RagonPlayer Owner => _playerCache.Owner;
+    
+    public RagonRoom(RagonClient client,
+      RagonEntityCache entityCache,
+      RagonPlayerCache playerCache,
+      RagonRoomInformation information,
+      RagonScene scene)
+    {
+      _client = client;
+      _information = information;
+      _entityCache = entityCache;
+      _playerCache = playerCache;
+      _scene = scene;
+    }
+
+    internal void Cleanup()
+    {
+      _entityCache.Cleanup();
+      _playerCache.Cleanup();
+    }
+
+    public void LoadScene(string map) => _scene.Load(map);
+    public void SceneLoaded() => _scene.SceneLoaded();
+
+    public void CreateEntity(RagonEntity entity) => CreateEntity(entity, null);
+    public void CreateEntity(RagonEntity entity, IRagonPayload? payload) => _entityCache.Create(entity, payload);
+    public void TransferEntity(RagonEntity entity, RagonPlayer player) => _entityCache.Transfer(entity, player);
+
+    public void DestroyEntity(RagonEntity entityId) => DestroyEntity(entityId, null);
+    public void DestroyEntity(RagonEntity entityId, IRagonPayload? payload) => _entityCache.Destroy(entityId, payload);
+  }
+}

Ragon.Client/Sources/RagonScene.cs

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client;
+
+public class RagonScene
+{
+  private readonly RagonClient _client;
+  private readonly RagonEntityCache _entityCache;
+  private readonly RagonPlayerCache _playerCache;
+  
+  public RagonScene(RagonClient client, RagonPlayerCache playerCache, RagonEntityCache entityCache)
+  {
+    _client = client;
+    _playerCache = playerCache;
+    _entityCache = entityCache;
+  }
+
+  internal void Load(string map)
+  {
+    var buffer = _client.Buffer;
+    
+    buffer.Clear();
+    buffer.WriteOperation(RagonOperation.LOAD_SCENE);
+    buffer.WriteString(map);
+
+    var sendData = buffer.ToArray();
+    _client.Reliable.Send(sendData);
+  }
+
+  internal void SceneLoaded()
+  {
+    var buffer = _client.Buffer;
+    
+    buffer.Clear();
+    buffer.WriteOperation(RagonOperation.SCENE_LOADED);
+
+    if (_playerCache.IsRoomOwner)
+      _entityCache.WriteScene(buffer);
+    else
+      _entityCache.CacheScene();
+    
+    var sendData = buffer.ToArray();
+    _client.Reliable.Send(sendData);
+  }
+}

Ragon.Client/Sources/RagonSession.cs

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using Ragon.Protocol;
+
+namespace Ragon.Client
+{
+  public class RagonSession
+  {
+    private readonly RagonClient _client;
+    private readonly RagonBuffer _buffer;
+    
+    public RagonSession(RagonClient client, RagonBuffer buffer)
+    {
+      _client = client;
+      _buffer = buffer;
+    }
+
+    public void CreateOrJoin(string map, int minPlayers, int maxPlayers)
+    {
+      var parameters = new RagonRoomParameters() {Map = map, Min = minPlayers, Max = maxPlayers};
+      CreateOrJoin(parameters);
+    }
+    
+    public void CreateOrJoin(RagonRoomParameters parameters)
+    {
+      _buffer.Clear();
+      _buffer.WriteOperation(RagonOperation.JOIN_OR_CREATE_ROOM);
+
+      parameters.Serialize(_buffer);
+
+      var sendData = _buffer.ToArray();
+      _client.Reliable.Send(sendData);
+    }
+
+    public void Create(string map, int minPlayers, int maxPlayers)
+    {
+      Create(null, new RagonRoomParameters() {Map = map, Min = minPlayers, Max = maxPlayers});
+    }
+
+    public void Create(string roomId, string map, int minPlayers, int maxPlayers)
+    {
+      Create(roomId, new RagonRoomParameters() {Map = map, Min = minPlayers, Max = maxPlayers});
+    }
+    
+    public  void Create(string roomId, RagonRoomParameters parameters)
+    {
+      _buffer.Clear();
+      _buffer.WriteOperation(RagonOperation.CREATE_ROOM);
+
+      if (roomId != null)
+      {
+        _buffer.WriteBool(true);
+        _buffer.WriteString(roomId);
+      }
+      else
+      {
+        _buffer.WriteBool(false);
+      }
+
+      parameters.Serialize(_buffer);
+
+      var sendData = _buffer.ToArray();
+      _client.Reliable.Send(sendData);
+    }
+    
+    public  void Leave()
+    {
+      var sendData = new[] {(byte) RagonOperation.LEAVE_ROOM};
+      _client.Reliable.Send(sendData);
+    }
+
+    public  void Join(string roomId)
+    {
+      _buffer.Clear();
+      _buffer.WriteOperation(RagonOperation.JOIN_ROOM);
+      _buffer.WriteString(roomId);
+
+      var sendData = _buffer.ToArray();
+      _client.Reliable.Send(sendData);
+    }
+
+    public  void AuthorizeWithKey(string key, string playerName, string payload = "")
+    {
+      _buffer.Clear();
+      _buffer.WriteOperation(RagonOperation.AUTHORIZE);
+      _buffer.WriteString(key);
+      _buffer.WriteString(playerName);
+      _buffer.WriteString(payload);
+
+      var sendData = _buffer.ToArray();
+      _client.Reliable.Send(sendData);
+    }
+    
+  }
+}

Ragon.Client/Sources/RagonStatus.cs

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Ragon.Client
+{
+  public enum RagonStatus
+  {
+    DISCONNECTED,
+    CONNECTED,
+    ROOM,
+    LOBBY,
+  }
+}

Ragon.Client/Sources/Utils/CompressorExtension.cs

@@ -0,0 +1,27 @@
+using Ragon.Client.Compressor;
+using Ragon.Protocol;
+
+namespace Ragon.Client.Utils;
+
+public static class CompressorExtension
+{
+  public static float Read(this FloatCompressor compressor, RagonBuffer buffer)
+  {
+    return compressor.Decompress(buffer.Read(compressor.RequiredBits));
+  }
+
+  public static void Write(this FloatCompressor compressor, RagonBuffer buffer, float value)
+  {
+    buffer.Write(compressor.Compress(value), compressor.RequiredBits);
+  }
+  
+  public static float Read(this IntCompressor compressor, RagonBuffer buffer)
+  {
+    return compressor.Decompress(buffer.Read(compressor.RequiredBits));
+  }
+
+  public static void Write(this IntCompressor compressor, RagonBuffer buffer, int value)
+  {
+    buffer.Write(compressor.Compress(value), compressor.RequiredBits);
+  }
+}

Ragon.Common/External/DisruptorUnity3d/RingBuffer.cs

@@ -1,275 +0,0 @@
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace DisruptorUnity3d
-{
-    /// <summary>
-    /// Implementation of the Disruptor pattern
-    /// </summary>
-    /// <typeparam name="T">the type of item to be stored</typeparam>
-    public class RingBuffer<T>
-    {
-        private readonly T[] _entries;
-        private readonly int _modMask;
-        private Volatile.PaddedLong _consumerCursor = new Volatile.PaddedLong();
-        private Volatile.PaddedLong _producerCursor = new Volatile.PaddedLong();
-
-        /// <summary>
-        /// Creates a new RingBuffer with the given capacity
-        /// </summary>
-        /// <param name="capacity">The capacity of the buffer</param>
-        /// <remarks>Only a single thread may attempt to consume at any one time</remarks>
-        public RingBuffer(int capacity)
-        {
-            capacity = NextPowerOfTwo(capacity);
-            _modMask = capacity - 1;
-            _entries = new T[capacity];
-        }
-
-        /// <summary>
-        /// The maximum number of items that can be stored
-        /// </summary>
-        public int Capacity
-        {
-            get { return _entries.Length; }
-        }
-
-        public T this[long index]
-        {
-            get { unchecked { return _entries[index & _modMask]; } }
-            set { unchecked { _entries[index & _modMask] = value; } }
-        }
-
-        /// <summary>
-        /// Removes an item from the buffer.
-        /// </summary>
-        /// <returns>The next available item</returns>
-        public T Dequeue()
-        {
-            var next = _consumerCursor.ReadAcquireFence() + 1;
-            while (_producerCursor.ReadAcquireFence() < next) // makes sure we read the data from _entries after we have read the producer cursor
-            {
-                Thread.SpinWait(1);
-            }
-            var result = this[next];
-            _consumerCursor.WriteReleaseFence(next); // makes sure we read the data from _entries before we update the consumer cursor
-            return result;
-        }
-
-        /// <summary>
-        /// Attempts to remove an items from the queue
-        /// </summary>
-        /// <param name="obj">the items</param>
-        /// <returns>True if successful</returns>
-        public bool TryDequeue(out T obj)
-        {
-            var next = _consumerCursor.ReadAcquireFence() + 1;
-
-            if (_producerCursor.ReadAcquireFence() < next)
-            {
-                obj = default(T);
-                return false;
-            }
-            obj = Dequeue();
-            return true;
-        }
-
-        /// <summary>
-        /// Add an item to the buffer
-        /// </summary>
-        /// <param name="item"></param>
-        public void Enqueue(T item)
-        {
-            var next = _producerCursor.ReadAcquireFence() + 1;
-
-            long wrapPoint = next - _entries.Length;
-            long min = _consumerCursor.ReadAcquireFence(); 
-
-            while (wrapPoint > min)
-            {
-                min = _consumerCursor.ReadAcquireFence();
-                Thread.SpinWait(1);
-            }
-
-            this[next] = item;
-            _producerCursor.WriteReleaseFence(next); // makes sure we write the data in _entries before we update the producer cursor
-        }
-
-        /// <summary>
-        /// The number of items in the buffer
-        /// </summary>
-        /// <remarks>for indicative purposes only, may contain stale data</remarks>
-        public int Count { get { return (int)(_producerCursor.ReadFullFence() - _consumerCursor.ReadFullFence()); } }
-
-        private static int NextPowerOfTwo(int x)
-        {
-            var result = 2;
-            while (result < x)
-            {
-                result <<= 1;
-            }
-            return result;
-        }
-
-
-    }
-    public static class Volatile
-    {
-        private const int CacheLineSize = 64;
-
-        [StructLayout(LayoutKind.Explicit, Size = CacheLineSize * 2)]
-        public struct PaddedLong
-        {
-            [FieldOffset(CacheLineSize)]
-            private long _value;
-
-            /// <summary>
-            /// Create a new <see cref="PaddedLong"/> with the given initial value.
-            /// </summary>
-            /// <param name="value">Initial value</param>
-            public PaddedLong(long value)
-            {
-                _value = value;
-            }
-
-            /// <summary>
-            /// Read the value without applying any fence
-            /// </summary>
-            /// <returns>The current value</returns>
-            public long ReadUnfenced()
-            {
-                return _value;
-            }
-
-            /// <summary>
-            /// Read the value applying acquire fence semantic
-            /// </summary>
-            /// <returns>The current value</returns>
-            public long ReadAcquireFence()
-            {
-                var value = _value;
-                Thread.MemoryBarrier();
-                return value;
-            }
-
-            /// <summary>
-            /// Read the value applying full fence semantic
-            /// </summary>
-            /// <returns>The current value</returns>
-            public long ReadFullFence()
-            {
-                Thread.MemoryBarrier();
-                return _value;
-            }
-
-            /// <summary>
-            /// Read the value applying a compiler only fence, no CPU fence is applied
-            /// </summary>
-            /// <returns>The current value</returns>
-            [MethodImpl(MethodImplOptions.NoOptimization)]
-            public long ReadCompilerOnlyFence()
-            {
-                return _value;
-            }
-
-            /// <summary>
-            /// Write the value applying release fence semantic
-            /// </summary>
-            /// <param name="newValue">The new value</param>
-            public void WriteReleaseFence(long newValue)
-            {
-                Thread.MemoryBarrier();
-                _value = newValue;
-            }
-
-            /// <summary>
-            /// Write the value applying full fence semantic
-            /// </summary>
-            /// <param name="newValue">The new value</param>
-            public void WriteFullFence(long newValue)
-            {
-                Thread.MemoryBarrier();
-                _value = newValue;
-            }
-
-            /// <summary>
-            /// Write the value applying a compiler fence only, no CPU fence is applied
-            /// </summary>
-            /// <param name="newValue">The new value</param>
-            [MethodImpl(MethodImplOptions.NoOptimization)]
-            public void WriteCompilerOnlyFence(long newValue)
-            {
-                _value = newValue;
-            }
-
-            /// <summary>
-            /// Write without applying any fence
-            /// </summary>
-            /// <param name="newValue">The new value</param>
-            public void WriteUnfenced(long newValue)
-            {
-                _value = newValue;
-            }
-
-            /// <summary>
-            /// Atomically set the value to the given updated value if the current value equals the comparand
-            /// </summary>
-            /// <param name="newValue">The new value</param>
-            /// <param name="comparand">The comparand (expected value)</param>
-            /// <returns></returns>
-            public bool AtomicCompareExchange(long newValue, long comparand)
-            {
-                return Interlocked.CompareExchange(ref _value, newValue, comparand) == comparand;
-            }
-
-            /// <summary>
-            /// Atomically set the value to the given updated value
-            /// </summary>
-            /// <param name="newValue">The new value</param>
-            /// <returns>The original value</returns>
-            public long AtomicExchange(long newValue)
-            {
-                return Interlocked.Exchange(ref _value, newValue);
-            }
-
-            /// <summary>
-            /// Atomically add the given value to the current value and return the sum
-            /// </summary>
-            /// <param name="delta">The value to be added</param>
-            /// <returns>The sum of the current value and the given value</returns>
-            public long AtomicAddAndGet(long delta)
-            {
-                return Interlocked.Add(ref _value, delta);
-            }
-
-            /// <summary>
-            /// Atomically increment the current value and return the new value
-            /// </summary>
-            /// <returns>The incremented value.</returns>
-            public long AtomicIncrementAndGet()
-            {
-                return Interlocked.Increment(ref _value);
-            }
-
-            /// <summary>
-            /// Atomically increment the current value and return the new value
-            /// </summary>
-            /// <returns>The decremented value.</returns>
-            public long AtomicDecrementAndGet()
-            {
-                return Interlocked.Decrement(ref _value);
-            }
-
-            /// <summary>
-            /// Returns the string representation of the current value.
-            /// </summary>
-            /// <returns>the string representation of the current value.</returns>
-            public override string ToString()
-            {
-                var value = ReadFullFence();
-                return value.ToString();
-            }
-        }
-    }
-}

Ragon.Common/External/NetStack.Buffers/ArrayPool.cs

@@ -1,69 +0,0 @@
-/*
- *  Copyright (c) 2018 Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System.Threading;
-using System.Runtime.CompilerServices;
-
-namespace NetStack.Buffers {
-	public abstract class ArrayPool<T> {
-		#if NET_4_6 || NET_STANDARD_2_0
-			private static ArrayPool<T> s_sharedInstance = null;
-		#else
-			private static volatile ArrayPool<T> s_sharedInstance = null;
-		#endif
-
-		public static ArrayPool<T> Shared {
-			#if NET_4_6 || NET_STANDARD_2_0
-				[MethodImpl(256)]
-				get {
-					return Volatile.Read(ref s_sharedInstance) ?? EnsureSharedCreated();
-				}
-			#else
-				[MethodImpl(256)]
-				get {
-					return s_sharedInstance ?? EnsureSharedCreated();
-				}
-			#endif
-		}
-
-		#pragma warning disable 420
-
-		[MethodImpl(MethodImplOptions.NoInlining)]
-		private static ArrayPool<T> EnsureSharedCreated() {
-			Interlocked.CompareExchange(ref s_sharedInstance, Create(), null);
-
-			return s_sharedInstance;
-		}
-
-		public static ArrayPool<T> Create() {
-			return new DefaultArrayPool<T>();
-		}
-
-		public static ArrayPool<T> Create(int maxArrayLength, int maxArraysPerBucket) {
-			return new DefaultArrayPool<T>(maxArrayLength, maxArraysPerBucket);
-		}
-
-		public abstract T[] Rent(int minimumLength);
-
-		public abstract void Return(T[] array, bool clearArray = false);
-	}
-}

Ragon.Common/External/NetStack.Buffers/ArrayPoolEventSource.cs

@@ -1,82 +0,0 @@
-/*
- *  Copyright (c) 2018 Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System;
-
-#if ENABLE_MONO || ENABLE_IL2CPP
-	using UnityEngine;
-#endif
-
-namespace NetStack.Buffers {
-	internal sealed class ArrayPoolEventSource {
-		#if NETSTACK_BUFFERS_LOG
-			internal static readonly ArrayPoolEventSource EventLog = new ArrayPoolEventSource();
-
-			internal enum BufferAllocatedReason : int {
-				Pooled,
-				OverMaximumSize,
-				PoolExhausted
-			}
-
-			internal void BufferAllocated(int bufferId, int bufferSize, int poolId, int bucketId, BufferAllocatedReason reason) {
-				var message = "Buffer allocated (Buffer ID: " + bufferId + ", Buffer size: " + bufferSize + ", Pool ID: " + poolId + ", Bucket ID: " + bucketId + ", Reason: " + reason + ")";
-
-				if (reason == BufferAllocatedReason.Pooled)
-					Log.Info("Buffers", message);
-				else
-					Log.Warning("Buffers", message);
-			}
-
-			internal void BufferRented(int bufferId, int bufferSize, int poolId, int bucketId) {
-				Log.Info("Buffers", "Buffer rented (Buffer ID: " + bufferId + ", Buffer size: " + bufferSize + ", Pool ID: " + poolId + ", Bucket ID: " + bucketId + ")");
-			}
-
-			internal void BufferReturned(int bufferId, int bufferSize, int poolId) {
-				Log.Info("Buffers", "Buffer returned (Buffer ID: " + bufferId + ", Buffer size: " + bufferSize + ", Pool ID: " + poolId + ")");
-			}
-		#endif
-	}
-
-	internal static class Log {
-		private static string Output(string module, string message) {
-			return DateTime.Now.ToString("[HH:mm:ss]") + " [NetStack." + module + "] " + message;
-		}
-
-		public static void Info(string module, string message) {
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				Debug.Log(Output(module, message));
-			#else
-				Console.WriteLine(Output(module, message));
-			#endif
-		}
-
-		public static void Warning(string module, string message) {
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				Debug.LogWarning(Output(module, message));
-			#else
-				Console.ForegroundColor = ConsoleColor.Yellow;
-				Console.WriteLine(Output(module, message));
-				Console.ResetColor();
-			#endif
-		}
-	}
-}

Ragon.Common/External/NetStack.Buffers/DefaultArrayPool.cs

@@ -1,134 +0,0 @@
-/*
- *  Copyright (c) 2018 Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System;
-
-namespace NetStack.Buffers {
-	internal sealed partial class DefaultArrayPool<T> : ArrayPool<T> {
-		private const int DefaultMaxArrayLength = 1024 * 1024;
-		private const int DefaultMaxNumberOfArraysPerBucket = 50;
-		private static T[] s_emptyArray;
-		private readonly Bucket[] _buckets;
-
-		internal DefaultArrayPool() : this(DefaultMaxArrayLength, DefaultMaxNumberOfArraysPerBucket) { }
-
-		internal DefaultArrayPool(int maxArrayLength, int maxArraysPerBucket) {
-			if (maxArrayLength <= 0)
-				throw new ArgumentOutOfRangeException("maxArrayLength");
-
-			if (maxArraysPerBucket <= 0)
-				throw new ArgumentOutOfRangeException("maxArraysPerBucket");
-
-			const int MinimumArrayLength = 0x10, MaximumArrayLength = 0x40000000;
-
-			if (maxArrayLength > MaximumArrayLength)
-				maxArrayLength = MaximumArrayLength;
-			else if (maxArrayLength < MinimumArrayLength)
-				maxArrayLength = MinimumArrayLength;
-
-			int poolId = Id;
-			int maxBuckets = Utilities.SelectBucketIndex(maxArrayLength);
-			var buckets = new Bucket[maxBuckets + 1];
-
-			for (int i = 0; i < buckets.Length; i++) {
-				buckets[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, poolId);
-			}
-
-			_buckets = buckets;
-		}
-
-		private int Id {
-			get {
-				return GetHashCode();
-			}
-		}
-
-		public override T[] Rent(int minimumLength) {
-			if (minimumLength < 0)
-				throw new ArgumentOutOfRangeException("minimumLength");
-			else if (minimumLength == 0)
-				return s_emptyArray ?? (s_emptyArray = new T[0]);
-
-			#if NETSTACK_BUFFERS_LOG
-				var log = ArrayPoolEventSource.EventLog;
-			#endif
-
-			T[] buffer = null;
-			int index = Utilities.SelectBucketIndex(minimumLength);
-
-			if (index < _buckets.Length) {
-				const int MaxBucketsToTry = 2;
-
-				int i = index;
-
-				do {
-					buffer = _buckets[i].Rent();
-
-					if (buffer != null) {
-						#if NETSTACK_BUFFERS_LOG
-							log.BufferRented(buffer.GetHashCode(), buffer.Length, Id, _buckets[i].Id);
-						#endif
-
-						return buffer;
-					}
-				}
-
-				while (++i < _buckets.Length && i != index + MaxBucketsToTry);
-
-				buffer = new T[_buckets[index]._bufferLength];
-			} else {
-				buffer = new T[minimumLength];
-			}
-
-			#if NETSTACK_BUFFERS_LOG
-				int bufferId = buffer.GetHashCode(), bucketId = -1;
-
-				log.BufferRented(bufferId, buffer.Length, Id, bucketId);
-				log.BufferAllocated(bufferId, buffer.Length, Id, bucketId, index >= _buckets.Length ? ArrayPoolEventSource.BufferAllocatedReason.OverMaximumSize : ArrayPoolEventSource.BufferAllocatedReason.PoolExhausted);
-			#endif
-
-			return buffer;
-		}
-
-		public override void Return(T[] array, bool clearArray = false) {
-			if (array == null)
-				throw new ArgumentNullException("array");
-			else if (array.Length == 0)
-				return;
-
-			int bucket = Utilities.SelectBucketIndex(array.Length);
-
-			if (bucket < _buckets.Length) {
-				if (clearArray)
-					Array.Clear(array, 0, array.Length);
-
-				_buckets[bucket].Return(array);
-			}
-
-			#if NETSTACK_BUFFERS_LOG
-				var log = ArrayPoolEventSource.EventLog;
-
-				log.BufferReturned(array.GetHashCode(), array.Length, Id);
-			#endif
-		}
-	}
-}

Ragon.Common/External/NetStack.Buffers/DefaultArrayPoolBucket.cs

@@ -1,151 +0,0 @@
-/*
- *  Copyright (c) 2018 Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System;
-using System.Diagnostics;
-using System.Threading;
-
-namespace NetStack.Buffers {
-	internal sealed partial class DefaultArrayPool<T> : ArrayPool<T> {
-		private sealed class Bucket {
-			internal readonly int _bufferLength;
-			private readonly T[][] _buffers;
-			#if NETSTACK_BUFFERS_LOG
-				private readonly int _poolId;
-			#endif
-			#if NET_4_6 || NET_STANDARD_2_0
-				private SpinLock _lock;
-			#else
-				private object _lock;
-			#endif
-			private int _index;
-
-			internal Bucket(int bufferLength, int numberOfBuffers, int poolId) {
-				#if NET_4_6 || NET_STANDARD_2_0
-					_lock = new SpinLock();
-				#else
-					_lock = new Object();
-				#endif
-				_buffers = new T[numberOfBuffers][];
-				_bufferLength = bufferLength;
-
-				#if NETSTACK_BUFFERS_LOG
-					_poolId = poolId;
-				#endif
-			}
-
-			#if NET_4_6 || NET_STANDARD_2_0
-				internal int Id => GetHashCode();
-			#else
-				internal int Id {
-					get {
-						return GetHashCode();
-					}
-				}
-			#endif
-
-			internal T[] Rent() {
-				T[][] buffers = _buffers;
-				T[] buffer = null;
-				bool allocateBuffer = false;
-
-				#if NET_4_6 || NET_STANDARD_2_0
-					bool lockTaken = false;
-
-					try {
-						_lock.Enter(ref lockTaken);
-
-						if (_index < buffers.Length) {
-							buffer = buffers[_index];
-							buffers[_index++] = null;
-							allocateBuffer = buffer == null;
-						}
-					}
-
-					finally {
-						if (lockTaken)
-							_lock.Exit(false);
-					}
-				#else
-					try {
-						Monitor.Enter(_lock);
-
-						if (_index < buffers.Length) {
-							buffer = buffers[_index];
-							buffers[_index++] = null;
-							allocateBuffer = buffer == null;
-						}
-					}
-
-					finally {
-						Monitor.Exit(_lock);
-					}
-				#endif
-
-				if (allocateBuffer) {
-					buffer = new T[_bufferLength];
-
-					#if NETSTACK_BUFFERS_LOG
-						var log = ArrayPoolEventSource.EventLog;
-
-						log.BufferAllocated(buffer.GetHashCode(), _bufferLength, _poolId, Id, ArrayPoolEventSource.BufferAllocatedReason.Pooled);
-					#endif
-				}
-
-				return buffer;
-			}
-
-			internal void Return(T[] array) {
-				if (array.Length != _bufferLength)
-					throw new ArgumentException("BufferNotFromPool", "array");
-
-				#if NET_4_6 || NET_STANDARD_2_0
-					bool lockTaken = false;
-
-					try {
-						_lock.Enter(ref lockTaken);
-
-						if (_index != 0)
-							_buffers[--_index] = array;
-
-					}
-
-					finally	{
-						if (lockTaken)
-							_lock.Exit(false);
-					}
-				#else
-					try {
-						Monitor.Enter(_lock);
-
-						if (_index != 0)
-							_buffers[--_index] = array;
-					}
-
-					finally {
-						Monitor.Exit(_lock);
-					}
-				#endif
-			}
-		}
-	}
-}

Ragon.Common/External/NetStack.Buffers/Utilities.cs

@@ -1,84 +0,0 @@
-/*
- *  Copyright (c) 2018 Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-#if ENABLE_MONO || ENABLE_IL2CPP
-	using UnityEngine.Assertions;
-#endif
-
-namespace NetStack.Buffers {
-	internal static class Utilities {
-		[MethodImpl(256)]
-		internal static int SelectBucketIndex(int bufferSize) {
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				Assert.IsTrue(bufferSize > 0);
-			#else
-				Debug.Assert(bufferSize > 0);
-			#endif
-
-			uint bitsRemaining = ((uint)bufferSize - 1) >> 4;
-			int poolIndex = 0;
-
-			if (bitsRemaining > 0xFFFF) {
-				bitsRemaining >>= 16;
-				poolIndex = 16;
-			}
-
-			if (bitsRemaining > 0xFF) {
-				bitsRemaining >>= 8;
-				poolIndex += 8;
-			}
-
-			if (bitsRemaining > 0xF) {
-				bitsRemaining >>= 4;
-				poolIndex += 4;
-			}
-
-			if (bitsRemaining > 0x3) {
-				bitsRemaining >>= 2;
-				poolIndex += 2;
-			}
-
-			if (bitsRemaining > 0x1) {
-				bitsRemaining >>= 1;
-				poolIndex += 1;
-			}
-
-			return poolIndex + (int)bitsRemaining;
-		}
-
-		[MethodImpl(256)]
-		internal static int GetMaxSizeForBucket(int binIndex) {
-			int maxSize = 16 << binIndex;
-
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				Assert.IsTrue(maxSize >= 0);
-			#else
-				Debug.Assert(maxSize >= 0);
-			#endif
-
-			return maxSize;
-		}
-	}
-}

Ragon.Common/External/NetStack.Quantization/BoundedRange.cs

@@ -1,184 +0,0 @@
-/*
- *  Copyright (c) 2018 Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System;
-using System.Runtime.CompilerServices;
-
-#if !(ENABLE_MONO || ENABLE_IL2CPP)
-	using System.Numerics;
-#else
-	using UnityEngine;
-#endif
-
-namespace NetStack.Quantization {
-	public struct QuantizedVector2 {
-		public uint x;
-		public uint y;
-
-		public QuantizedVector2(uint x, uint y) {
-			this.x = x;
-			this.y = y;
-		}
-	}
-
-	public struct QuantizedVector3 {
-		public uint x;
-		public uint y;
-		public uint z;
-
-		public QuantizedVector3(uint x, uint y, uint z) {
-			this.x = x;
-			this.y = y;
-			this.z = z;
-		}
-	}
-
-	public struct QuantizedVector4 {
-		public uint x;
-		public uint y;
-		public uint z;
-		public uint w;
-
-		public QuantizedVector4(uint x, uint y, uint z, uint w) {
-			this.x = x;
-			this.y = y;
-			this.z = z;
-			this.w = w;
-		}
-	}
-
-	public static class DeBruijn {
-		public static readonly int[] Lookup = new int[32] {
-			0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
-			8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31
-		};
-	}
-
-	public class BoundedRange {
-		private readonly float minValue;
-		private readonly float maxValue;
-		private readonly float precision;
-		private readonly int requiredBits;
-		private readonly uint mask;
-
-		public BoundedRange(float minValue, float maxValue, float precision) {
-			this.minValue = minValue;
-			this.maxValue = maxValue;
-			this.precision = precision;
-
-			requiredBits = Log2((uint)((maxValue - minValue) * (1.0f / precision) + 0.5f)) + 1;
-			mask = (uint)((1L << requiredBits) - 1);
-		}
-
-		private int Log2(uint value) {
-			value |= value >> 1;
-			value |= value >> 2;
-			value |= value >> 4;
-			value |= value >> 8;
-			value |= value >> 16;
-
-			return DeBruijn.Lookup[(value * 0x07C4ACDDU) >> 27];
-		}
-
-		[MethodImpl(256)]
-		public uint Quantize(float value) {
-			if (value < minValue)
-				value = minValue;
-			else if (value > maxValue)
-				value = maxValue;
-
-			return (uint)((float)((value - minValue) * (1f / precision)) + 0.5f) & mask;
-		}
-
-		[MethodImpl(256)]
-		public float Dequantize(uint data) {
-			float adjusted = ((float)data * precision) + minValue;
-
-			if (adjusted < minValue)
-				adjusted = minValue;
-			else if (adjusted > maxValue)
-				adjusted = maxValue;
-
-			return adjusted;
-		}
-
-		public static QuantizedVector2 Quantize(Vector2 vector2, BoundedRange[] boundedRange) {
-			QuantizedVector2 data = default(QuantizedVector2);
-
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				data.x = boundedRange[0].Quantize(vector2.x);
-				data.y = boundedRange[1].Quantize(vector2.y);
-			#else
-				data.x = boundedRange[0].Quantize(vector2.X);
-				data.y = boundedRange[1].Quantize(vector2.Y);
-			#endif
-
-			return data;
-		}
-
-		public static QuantizedVector3 Quantize(Vector3 vector3, BoundedRange[] boundedRange) {
-			QuantizedVector3 data = default(QuantizedVector3);
-
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				data.x = boundedRange[0].Quantize(vector3.x);
-				data.y = boundedRange[1].Quantize(vector3.y);
-				data.z = boundedRange[2].Quantize(vector3.z);
-			#else
-				data.x = boundedRange[0].Quantize(vector3.X);
-				data.y = boundedRange[1].Quantize(vector3.Y);
-				data.z = boundedRange[2].Quantize(vector3.Z);
-			#endif
-
-			return data;
-		}
-
-		public static QuantizedVector4 Quantize(Vector4 vector4, BoundedRange[] boundedRange) {
-			QuantizedVector4 data = default(QuantizedVector4);
-
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				data.x = boundedRange[0].Quantize(vector4.x);
-				data.y = boundedRange[1].Quantize(vector4.y);
-				data.z = boundedRange[2].Quantize(vector4.z);
-				data.w = boundedRange[3].Quantize(vector4.w);
-			#else
-				data.x = boundedRange[0].Quantize(vector4.X);
-				data.y = boundedRange[1].Quantize(vector4.Y);
-				data.z = boundedRange[2].Quantize(vector4.Z);
-				data.w = boundedRange[3].Quantize(vector4.W);
-			#endif
-
-			return data;
-		}
-
-		public static Vector2 Dequantize(QuantizedVector2 data, BoundedRange[] boundedRange) {
-			return new Vector2(boundedRange[0].Dequantize(data.x), boundedRange[1].Dequantize(data.y));
-		}
-
-		public static Vector3 Dequantize(QuantizedVector3 data, BoundedRange[] boundedRange) {
-			return new Vector3(boundedRange[0].Dequantize(data.x), boundedRange[1].Dequantize(data.y), boundedRange[2].Dequantize(data.z));
-		}
-
-		public static Vector4 Dequantize(QuantizedVector4 data, BoundedRange[] boundedRange) {
-			return new Vector4(boundedRange[0].Dequantize(data.x), boundedRange[1].Dequantize(data.y), boundedRange[2].Dequantize(data.z), boundedRange[3].Dequantize(data.w));
-		}
-	}
-}

Ragon.Common/External/NetStack.Quantization/HalfPrecision.cs

@@ -1,117 +0,0 @@
-/*
- *  Copyright (c) 2018 Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-namespace NetStack.Quantization {
-	public static class HalfPrecision {
-		[StructLayout(LayoutKind.Explicit)]
-		private struct Values {
-			[FieldOffset(0)]
-			public float f;
-			[FieldOffset(0)]
-			public int i;
-			[FieldOffset(0)]
-			public uint u;
-		}
-
-		[MethodImpl(256)]
-		public static ushort Quantize(float value) {
-			var values = new Values {
-				f = value
-			};
-
-			return Quantize(values.i);
-		}
-
-		public static ushort Quantize(int value) {
-			int s = (value >> 16) & 0x00008000;
-			int e = ((value >> 23) & 0X000000FF) - (127 - 15);
-			int m = value & 0X007FFFFF;
-
-			if (e <= 0) {
-				if (e < -10)
-					return (ushort)s;
-
-				m = m | 0x00800000;
-
-				int t = 14 - e;
-				int a = (1 << (t - 1)) - 1;
-				int b = (m >> t) & 1;
-
-				m = (m + a + b) >> t;
-
-				return (ushort)(s | m);
-			}
-
-			if (e == 0XFF - (127 - 15)) {
-				if (m == 0)
-					return (ushort)(s | 0X7C00);
-
-				m >>= 13;
-
-				return (ushort)(s | 0X7C00 | m | ((m == 0) ? 1 : 0));
-			}
-
-			m = m + 0X00000FFF + ((m >> 13) & 1);
-
-			if ((m & 0x00800000) != 0) {
-				m = 0;
-				e++;
-			}
-
-			if (e > 30)
-				return (ushort)(s | 0X7C00);
-
-			return (ushort)(s | (e << 10) | (m >> 13));
-		}
-
-		public static float Dequantize(ushort value) {
-			uint result;
-			uint mantissa = (uint)(value & 1023);
-			uint exponent = 0XFFFFFFF2;
-
-			if ((value & -33792) == 0) {
-				if (mantissa != 0) {
-					while ((mantissa & 1024) == 0) {
-						exponent--;
-						mantissa = mantissa << 1;
-					}
-
-					mantissa &= 0XFFFFFBFF;
-					result = ((uint)((((uint)value & 0x8000) << 16) | ((exponent + 127) << 23))) | (mantissa << 13);
-				} else {
-					result = (uint)((value & 0x8000) << 16);
-				}
-			} else {
-				result = ((((uint)value & 0x8000) << 16) | ((((((uint)value >> 10) & 0X1F) - 15) + 127) << 23)) | (mantissa << 13);
-			}
-
-			var values = new Values {
-				u = result
-			};
-
-			return values.f;
-		}
-	}
-}

Ragon.Common/External/NetStack.Quantization/SmallestThree.cs

@@ -1,223 +0,0 @@
-/*
- *  Copyright (c) 2020 Stanislav Denisov, Maxim Munning, Davin Carten
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System;
-
-#if !(ENABLE_MONO || ENABLE_IL2CPP)
-	using System.Numerics;
-#else
-	using UnityEngine;
-#endif
-
-namespace NetStack.Quantization {
-	public struct QuantizedQuaternion {
-		public uint m;
-		public uint a;
-		public uint b;
-		public uint c;
-
-		public QuantizedQuaternion(uint m, uint a, uint b, uint c) {
-			this.m = m;
-			this.a = a;
-			this.b = b;
-			this.c = c;
-		}
-	}
-
-	public static class SmallestThree {
-		private const float smallestThreeUnpack = 0.70710678118654752440084436210485f + 0.0000001f;
-		private const float smallestThreePack = 1.0f / smallestThreeUnpack;
-
-		public static QuantizedQuaternion Quantize(Quaternion quaternion, int bitsPerElement = 12) {
-			float halfRange = (1 << bitsPerElement - 1);
-			float packer = smallestThreePack * halfRange;
-			float maxValue = float.MinValue;
-			bool signMinus = false;
-			uint m = 0;
-			uint a = 0;
-			uint b = 0;
-			uint c = 0;
-
-			for (uint i = 0; i <= 3; i++) {
-				float element = 0.0f;
-				float abs = 0.0f;
-
-				switch (i) {
-					#if ENABLE_MONO || ENABLE_IL2CPP
-						case 0:
-							element = quaternion.x;
-
-							break;
-
-						case 1:
-							element = quaternion.y;
-
-							break;
-
-						case 2:
-							element = quaternion.z;
-
-							break;
-
-						case 3:
-							element = quaternion.w;
-
-							break;
-					#else
-						case 0:
-							element = quaternion.X;
-
-							break;
-
-						case 1:
-							element = quaternion.Y;
-
-							break;
-
-						case 2:
-							element = quaternion.Z;
-
-							break;
-
-						case 3:
-							element = quaternion.W;
-
-							break;
-					#endif
-				}
-
-				abs = Math.Abs(element);
-
-				if (abs > maxValue) {
-					signMinus = (element < 0.0f);
-					m = i;
-					maxValue = abs;
-				}
-			}
-
-			float af = 0.0f;
-			float bf = 0.0f;
-			float cf = 0.0f;
-
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				switch (m) {
-					case 0:
-						af = quaternion.y;
-						bf = quaternion.z;
-						cf = quaternion.w;
-
-						break;
-					case 1:
-						af = quaternion.x;
-						bf = quaternion.z;
-						cf = quaternion.w;
-
-						break;
-					case 2:
-						af = quaternion.x;
-						bf = quaternion.y;
-						cf = quaternion.w;
-
-						break;
-					default:
-						af = quaternion.x;
-						bf = quaternion.y;
-						cf = quaternion.z;
-
-						break;
-				}
-			#else
-				switch (m) {
-					case 0:
-						af = quaternion.Y;
-						bf = quaternion.Z;
-						cf = quaternion.W;
-
-						break;
-					case 1:
-						af = quaternion.X;
-						bf = quaternion.Z;
-						cf = quaternion.W;
-
-						break;
-					case 2:
-						af = quaternion.X;
-						bf = quaternion.Y;
-						cf = quaternion.W;
-
-						break;
-					default:
-						af = quaternion.X;
-						bf = quaternion.Y;
-						cf = quaternion.Z;
-
-						break;
-				}
-			#endif
-
-			if (signMinus) {
-				a = (uint)((-af * packer) + halfRange);
-				b = (uint)((-bf * packer) + halfRange);
-				c = (uint)((-cf * packer) + halfRange);
-			} else {
-				a = (uint)((af * packer) + halfRange);
-				b = (uint)((bf * packer) + halfRange);
-				c = (uint)((cf * packer) + halfRange);
-			}
-
-			return new QuantizedQuaternion(m, a, b, c);
-		}
-
-		public static Quaternion Dequantize(QuantizedQuaternion data, int bitsPerElement = 12) {
-   			int halfRange = (1 << bitsPerElement - 1);
-			float unpacker = smallestThreeUnpack * (1.0f / halfRange);
-			uint m = data.m;
-			int ai = (int)data.a;
-			int bi = (int)data.b;
-			int ci = (int)data.c;
-
-			ai -= halfRange;
-			bi -= halfRange;
-			ci -= halfRange;
-
-			float a = ai * unpacker;
-			float b = bi * unpacker;
-			float c = ci * unpacker;
-
-			float d = (float)Math.Sqrt(1.0f - ((a * a) + (b * b) + (c * c)));
-
-			switch (m) {
-				case 0:
-					return new Quaternion(d, a, b, c);
-
-				case 1:
-					return new Quaternion(a, d, b, c);
-
-				case 2:
-					return new Quaternion(a, b, d, c);
-
-				default:
-					return new Quaternion(a, b, c, d);
-			}
-		}
-	}
-}

Ragon.Common/External/NetStack.Serialization/BitBuffer.cs

@@ -1,546 +0,0 @@
-/*
- *  Copyright (c) 2018 Stanislav Denisov, Maxim Munnig
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-/*
- *  Copyright (c) 2018 Alexander Shoulson
- *
- *  This software is provided 'as-is', without any express or implied
- *  warranty. In no event will the authors be held liable for any damages
- *  arising from the use of this software.
- *  Permission is granted to anyone to use this software for any purpose,
- *  including commercial applications, and to alter it and redistribute it
- *  freely, subject to the following restrictions:
- *
- *  1. The origin of this software must not be misrepresented; you must not
- *     claim that you wrote the original software. If you use this software
- *     in a product, an acknowledgment in the product documentation would be
- *     appreciated but is not required.
- *  2. Altered source versions must be plainly marked as such, and must not be
- *     misrepresented as being the original software.
- *  3. This notice may not be removed or altered from any source distribution.
- */
-
-using System;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Text;
-
-#if ENABLE_MONO || ENABLE_IL2CPP
-	using UnityEngine.Assertions;
-#endif
-
-namespace NetStack.Serialization {
-	public class BitBuffer {
-		private const int defaultCapacity = 375; // 375 * 4 = 1500 bytes
-		private const int stringLengthBits = 8;
-		private const int stringLengthMax = (1 << stringLengthBits) - 1; // 255
-		private const int bitsASCII = 7;
-		private const int growFactor = 2;
-		private const int minGrow = 1;
-		private int readPosition;
-		private int nextPosition;
-		private uint[] chunks;
-
-		public BitBuffer(int capacity = defaultCapacity) {
-			readPosition = 0;
-			nextPosition = 0;
-			chunks = new uint[capacity];
-		}
-
-		public int Length {
-			get {
-				return ((nextPosition - 1) >> 3) + 1;
-			}
-		}
-
-		public bool IsFinished {
-			get {
-				return nextPosition == readPosition;
-			}
-		}
-
-		[MethodImpl(256)]
-		public void Clear() {
-			readPosition = 0;
-			nextPosition = 0;
-		}
-
-		[MethodImpl(256)]
-		public BitBuffer Add(int numBits, uint value) {
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				Assert.IsFalse(numBits < 0); // Pushing negative bits
-				Assert.IsFalse(numBits > 32); // Pushing too many bits
-			#else
-				Debug.Assert(!(numBits < 0));
-				Debug.Assert(!(numBits > 32));
-			#endif
-
-			int index = nextPosition >> 5;
-			int used = nextPosition & 0x0000001F;
-
-			if ((index + 1) >= chunks.Length)
-				ExpandArray();
-
-			ulong chunkMask = ((1UL << used) - 1);
-			ulong scratch = chunks[index] & chunkMask;
-			ulong result = scratch | ((ulong)value << used);
-
-			chunks[index] = (uint)result;
-			chunks[index + 1] = (uint)(result >> 32);
-			nextPosition += numBits;
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public uint Read(int numBits) {
-			uint result = Peek(numBits);
-
-			readPosition += numBits;
-
-			return result;
-		}
-
-		[MethodImpl(256)]
-		public uint Peek(int numBits) {
-			#if ENABLE_MONO || ENABLE_IL2CPP
-				Assert.IsFalse(numBits < 0); // Pushing negative bits
-				Assert.IsFalse(numBits > 32); // Pushing too many bits
-			#else
-				Debug.Assert(!(numBits < 0));
-				Debug.Assert(!(numBits > 32));
-			#endif
-
-			int index = readPosition >> 5;
-			int used = readPosition & 0x0000001F;
-
-			ulong chunkMask = ((1UL << numBits) - 1) << used;
-			ulong scratch = (ulong)chunks[index];
-
-			if ((index + 1) < chunks.Length)
-				scratch |= (ulong)chunks[index + 1] << 32;
-
-			ulong result = (scratch & chunkMask) >> used;
-
-			return (uint)result;
-		}
-
-		public int ToArray(byte[] data) {
-			Add(1, 1);
-
-			int numChunks = (nextPosition >> 5) + 1;
-			int length = data.Length;
-
-			for (int i = 0; i < numChunks; i++) {
-				int dataIdx = i * 4;
-				uint chunk = chunks[i];
-
-				if (dataIdx < length)
-					data[dataIdx] = (byte)(chunk);
-
-				if (dataIdx + 1 < length)
-					data[dataIdx + 1] = (byte)(chunk >> 8);
-
-				if (dataIdx + 2 < length)
-					data[dataIdx + 2] = (byte)(chunk >> 16);
-
-				if (dataIdx + 3 < length)
-					data[dataIdx + 3] = (byte)(chunk >> 24);
-			}
-
-			return Length;
-		}
-
-		public void FromArray(byte[] data, int length) {
-			int numChunks = (length / 4) + 1;
-
-			if (chunks.Length < numChunks)
-				chunks = new uint[numChunks];
-
-			for (int i = 0; i < numChunks; i++) {
-				int dataIdx = i * 4;
-				uint chunk = 0;
-
-				if (dataIdx < length)
-					chunk = (uint)data[dataIdx];
-
-				if (dataIdx + 1 < length)
-					chunk = chunk | (uint)data[dataIdx + 1] << 8;
-
-				if (dataIdx + 2 < length)
-					chunk = chunk | (uint)data[dataIdx + 2] << 16;
-
-				if (dataIdx + 3 < length)
-					chunk = chunk | (uint)data[dataIdx + 3] << 24;
-
-				chunks[i] = chunk;
-			}
-
-			int positionInByte = FindHighestBitPosition(data[length - 1]);
-
-			nextPosition = ((length - 1) * 8) + (positionInByte - 1);
-			readPosition = 0;
-		}
-
-		#if NETSTACK_SPAN
-			public int ToSpan(ref Span<byte> data) {
-				Add(1, 1);
-
-				int numChunks = (nextPosition >> 5) + 1;
-				int length = data.Length;
-
-				for (int i = 0; i < numChunks; i++) {
-					int dataIdx = i * 4;
-					uint chunk = chunks[i];
-
-					if (dataIdx < length)
-						data[dataIdx] = (byte)(chunk);
-
-					if (dataIdx + 1 < length)
-						data[dataIdx + 1] = (byte)(chunk >> 8);
-
-					if (dataIdx + 2 < length)
-						data[dataIdx + 2] = (byte)(chunk >> 16);
-
-					if (dataIdx + 3 < length)
-						data[dataIdx + 3] = (byte)(chunk >> 24);
-				}
-
-				return Length;
-			}
-
-			public void FromSpan(ref ReadOnlySpan<byte> data, int length) {
-				int numChunks = (length / 4) + 1;
-
-				if (chunks.Length < numChunks)
-					chunks = new uint[numChunks];
-
-				for (int i = 0; i < numChunks; i++) {
-					int dataIdx = i * 4;
-					uint chunk = 0;
-
-					if (dataIdx < length)
-						chunk = (uint)data[dataIdx];
-
-					if (dataIdx + 1 < length)
- 						chunk = chunk | (uint)data[dataIdx + 1] << 8;
-
-					if (dataIdx + 2 < length)
-						chunk = chunk | (uint)data[dataIdx + 2] << 16;
-
-					if (dataIdx + 3 < length)
-						chunk = chunk | (uint)data[dataIdx + 3] << 24;
-
-					chunks[i] = chunk;
-				}
-
-				int positionInByte = FindHighestBitPosition(data[length - 1]);
-
-				nextPosition = ((length - 1) * 8) + (positionInByte - 1);
-				readPosition = 0;
-			}
-		#endif
-
-		[MethodImpl(256)]
-		public BitBuffer AddBool(bool value) {
-			Add(1, value ? 1U : 0U);
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public bool ReadBool() {
-			return Read(1) > 0;
-		}
-
-		[MethodImpl(256)]
-		public bool PeekBool() {
-			return Peek(1) > 0;
-		}
-
-		[MethodImpl(256)]
-		public BitBuffer AddByte(byte value) {
-			Add(8, value);
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public byte ReadByte() {
-			return (byte)Read(8);
-		}
-
-		[MethodImpl(256)]
-		public byte PeekByte() {
-			return (byte)Peek(8);
-		}
-
-		[MethodImpl(256)]
-		public BitBuffer AddShort(short value) {
-			AddInt(value);
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public short ReadShort() {
-			return (short)ReadInt();
-		}
-
-		[MethodImpl(256)]
-		public short PeekShort() {
-			return (short)PeekInt();
-		}
-
-		[MethodImpl(256)]
-		public BitBuffer AddUShort(ushort value) {
-			AddUInt(value);
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public ushort ReadUShort() {
-			return (ushort)ReadUInt();
-		}
-
-		[MethodImpl(256)]
-		public ushort PeekUShort() {
-			return (ushort)PeekUInt();
-		}
-
-		[MethodImpl(256)]
-		public BitBuffer AddInt(int value) {
-			uint zigzag = (uint)((value << 1) ^ (value >> 31));
-
-			AddUInt(zigzag);
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public int ReadInt() {
-			uint value = ReadUInt();
-			int zagzig = (int)((value >> 1) ^ (-(int)(value & 1)));
-
-			return zagzig;
-		}
-
-		[MethodImpl(256)]
-		public int PeekInt() {
-			uint value = PeekUInt();
-			int zagzig = (int)((value >> 1) ^ (-(int)(value & 1)));
-
-			return zagzig;
-		}
-
-		[MethodImpl(256)]
-		public BitBuffer AddUInt(uint value) {
-			uint buffer = 0x0u;
-
-			do {
-				buffer = value & 0x7Fu;
-				value >>= 7;
-
-				if (value > 0)
-					buffer |= 0x80u;
-
-				Add(8, buffer);
-			}
-
-			while (value > 0);
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public uint ReadUInt() {
-			uint buffer = 0x0u;
-			uint value = 0x0u;
-			int shift = 0;
-
-			do {
-				buffer = Read(8);
-
-				value |= (buffer & 0x7Fu) << shift;
-				shift += 7;
-			}
-
-			while ((buffer & 0x80u) > 0);
-
-			return value;
-		}
-
-		[MethodImpl(256)]
-		public uint PeekUInt() {
-			int tempPosition = readPosition;
-			uint value = ReadUInt();
-
-			readPosition = tempPosition;
-
-			return value;
-		}
-
-		[MethodImpl(256)]
-		public BitBuffer AddLong(long value) {
-			AddInt((int)(value & uint.MaxValue));
-			AddInt((int)(value >> 32));
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public long ReadLong() {
-			int low = ReadInt();
-			int high = ReadInt();
-			long value = high;
-
-			return value << 32 | (uint)low;
-		}
-
-		[MethodImpl(256)]
-		public long PeekLong() {
-			int tempPosition = readPosition;
-			long value = ReadLong();
-
-			readPosition = tempPosition;
-
-			return value;
-		}
-
-		[MethodImpl(256)]
-		public BitBuffer AddULong(ulong value) {
-			AddUInt((uint)(value & uint.MaxValue));
-			AddUInt((uint)(value >> 32));
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public ulong ReadULong() {
-			uint low = ReadUInt();
-			uint high = ReadUInt();
-
-			return (ulong)high << 32 | low;
-		}
-
-		[MethodImpl(256)]
-		public ulong PeekULong() {
-			int tempPosition = readPosition;
-			ulong value = ReadULong();
-
-			readPosition = tempPosition;
-
-			return value;
-		}
-
-		[MethodImpl(256)]
-		public BitBuffer AddString(string value) {
-			if (value == null)
-				throw new ArgumentNullException("value");
-
-			uint length = (uint)value.Length;
-
-			if (length > stringLengthMax) {
-				length = (uint)stringLengthMax;
-
-				throw new ArgumentOutOfRangeException("value length exceeded");
-			}
-
-			Add(stringLengthBits, length);
-
-			for (int i = 0; i < length; i++) {
-				Add(bitsASCII, ToASCII(value[i]));
-			}
-
-			return this;
-		}
-
-		[MethodImpl(256)]
-		public string ReadString() {
-			StringBuilder builder = new StringBuilder();
-			uint length = Read(stringLengthBits);
-
-			for (int i = 0; i < length; i++) {
-				builder.Append((char)Read(bitsASCII));
-			}
-
-			return builder.ToString();
-		}
-
-		public override string ToString() {
-			StringBuilder builder = new StringBuilder();
-
-			for (int i = chunks.Length - 1; i >= 0; i--) {
-				builder.Append(Convert.ToString(chunks[i], 2).PadLeft(32, '0'));
-			}
-
-			StringBuilder spaced = new StringBuilder();
-
-			for (int i = 0; i < builder.Length; i++) {
-				spaced.Append(builder[i]);
-
-				if (((i + 1) % 8) == 0)
-					spaced.Append(" ");
-			}
-
-			return spaced.ToString();
-		}
-
-		private void ExpandArray() {
-			int newCapacity = (chunks.Length * growFactor) + minGrow;
-			uint[] newChunks = new uint[newCapacity];
-
-			Array.Copy(chunks, newChunks, chunks.Length);
-			chunks = newChunks;
-		}
-
-		[MethodImpl(256)]
-		private static int FindHighestBitPosition(byte data) {
-			int shiftCount = 0;
-
-			while (data > 0) {
-				data >>= 1;
-				shiftCount++;
-			}
-
-			return shiftCount;
-		}
-
-		private static byte ToASCII(char character) {
-			byte value = 0;
-
-			try {
-				value = Convert.ToByte(character);
-			}
-
-			catch (OverflowException) {
-				throw new Exception("Cannot convert to ASCII: " + character);
-			}
-
-			if (value > 127)
-				throw new Exception("Cannot convert to ASCII: " + character);
-
-			return value;
-		}
-	}
-}

Ragon.Common/External/NetStack.Threading/ArrayQueue.cs

@@ -1,150 +0,0 @@
-/*
- *  Copyright (c) 2019 Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace NetStack.Threading {
-	[StructLayout(LayoutKind.Explicit, Size = 192)]
-	public sealed class ArrayQueue {
-		[FieldOffset(0)]
-		private readonly Entry[] _array;
-		[FieldOffset(8)]
-		private readonly int _arrayMask;
-		[FieldOffset(64)]
-		private int _enqueuePosition;
-		[FieldOffset(128)]
-		private int _dequeuePosition;
-
-		public int Count {
-			get {
-				return _enqueuePosition - _dequeuePosition;
-			}
-		}
-
-		public ArrayQueue(int capacity) {
-			if (capacity < 2)
-				throw new ArgumentException("Queue size should be greater than or equal to two");
-
-			if ((capacity & (capacity - 1)) != 0)
-				throw new ArgumentException("Queue size should be a power of two");
-
-			_arrayMask = capacity - 1;
-			_array = new Entry[capacity];
-			_enqueuePosition = 0;
-			_dequeuePosition = 0;
-		}
-
-		public void Enqueue(object item) {
-			while (true) {
-				if (TryEnqueue(item))
-					break;
-
-				Thread.SpinWait(1);
-			}
-		}
-
-		public bool TryEnqueue(object item) {
-			var array = _array;
-			var position = _enqueuePosition;
-			var index = position & _arrayMask;
-
-			if (array[index].IsSet != 0)
-				return false;
-
-			array[index].element = item;
-			array[index].IsSet = 1;
-
-			#if NET_4_6 || NET_STANDARD_2_0
-				Volatile.Write(ref _enqueuePosition, position + 1);
-			#else
-				Thread.MemoryBarrier();
-				_enqueuePosition = position + 1;
-			#endif
-
-			return true;
-		}
-
-		public object Dequeue() {
-			while (true) {
-				object element;
-
-				if (TryDequeue(out element))
-					return element;
-			}
-		}
-
-		public bool TryDequeue(out object result) {
-			var array = _array;
-			var position = _dequeuePosition;
-			var index = position & _arrayMask;
-
-			if (array[index].IsSet == 0) {
-				result = default(object);
-
-				return false;
-			}
-
-			result = array[index].element;
-			array[index].element = default(object);
-			array[index].IsSet = 0;
-
-			#if NET_4_6 || NET_STANDARD_2_0
-				Volatile.Write(ref _dequeuePosition, position + 1);
-			#else
-				Thread.MemoryBarrier();
-				_dequeuePosition = position + 1;
-			#endif
-
-			return true;
-		}
-
-		[StructLayout(LayoutKind.Explicit, Size = 16)]
-		private struct Entry {
-			[FieldOffset(0)]
-			private int isSet;
-			[FieldOffset(8)]
-			internal object element;
-
-			internal int IsSet {
-				get {
-					#if NET_4_6 || NET_STANDARD_2_0
-						return Volatile.Read(ref isSet);
-					#else
-						Thread.MemoryBarrier();
-						return isSet;
-					#endif
-				}
-
-				set {
-					#if NET_4_6 || NET_STANDARD_2_0
-						Volatile.Write(ref isSet, value);
-					#else
-						Thread.MemoryBarrier();
-						isSet = value;
-					#endif
-				}
-			}
-		}
-	}
-}

Ragon.Common/External/NetStack.Threading/ConcurrentBuffer.cs

@@ -1,153 +0,0 @@
-/*
- *  Copyright (c) 2018 Alexander Nikitin, Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace NetStack.Threading {
-	[StructLayout(LayoutKind.Explicit, Size = 192)]
-	public sealed class ConcurrentBuffer {
-		[FieldOffset(0)]
-		private readonly Cell[] _buffer;
-		[FieldOffset(8)]
-		private readonly int _bufferMask;
-		[FieldOffset(64)]
-		private int _enqueuePosition;
-		[FieldOffset(128)]
-		private int _dequeuePosition;
-
-		public int Count {
-			get {
-				return _enqueuePosition - _dequeuePosition;
-			}
-		}
-
-		public ConcurrentBuffer(int bufferSize) {
-			if (bufferSize < 2)
-				throw new ArgumentException("Buffer size should be greater than or equal to two");
-
-			if ((bufferSize & (bufferSize - 1)) != 0)
-				throw new ArgumentException("Buffer size should be a power of two");
-
-			_bufferMask = bufferSize - 1;
-			_buffer = new Cell[bufferSize];
-
-			for (var i = 0; i < bufferSize; i++) {
-				_buffer[i] = new Cell(i, null);
-			}
-
-			_enqueuePosition = 0;
-			_dequeuePosition = 0;
-		}
-
-		public void Enqueue(object item) {
-			while (true) {
-				if (TryEnqueue(item))
-					break;
-
-				Thread.SpinWait(1);
-			}
-		}
-
-		public bool TryEnqueue(object item) {
-			do {
-				var buffer = _buffer;
-				var position = _enqueuePosition;
-				var index = position & _bufferMask;
-				var cell = buffer[index];
-
-				if (cell.Sequence == position && Interlocked.CompareExchange(ref _enqueuePosition, position + 1, position) == position) {
-					buffer[index].Element = item;
-
-					#if NET_4_6 || NET_STANDARD_2_0
-						Volatile.Write(ref buffer[index].Sequence, position + 1);
-					#else
-						Thread.MemoryBarrier();
-						buffer[index].Sequence = position + 1;
-					#endif
-
-					return true;
-				}
-
-				if (cell.Sequence < position)
-					return false;
-			}
-
-			while (true);
-		}
-
-		public object Dequeue() {
-			while (true) {
-				object element;
-
-				if (TryDequeue(out element))
-					return element;
-			}
-		}
-
-		public bool TryDequeue(out object result) {
-			do {
-				var buffer = _buffer;
-				var bufferMask = _bufferMask;
-				var position = _dequeuePosition;
-				var index = position & bufferMask;
-				var cell = buffer[index];
-
-				if (cell.Sequence == position + 1 && Interlocked.CompareExchange(ref _dequeuePosition, position + 1, position) == position) {
-					result = cell.Element;
-					buffer[index].Element = null;
-
-					#if NET_4_6 || NET_STANDARD_2_0
-						Volatile.Write(ref buffer[index].Sequence, position + bufferMask + 1);
-					#else
-						Thread.MemoryBarrier();
-						buffer[index].Sequence = position + bufferMask + 1;
-					#endif
-
-					return true;
-				}
-
-				if (cell.Sequence < position + 1) {
-					result = default(object);
-
-					return false;
-				}
-			}
-
-			while (true);
-		}
-
-		[StructLayout(LayoutKind.Explicit, Size = 16)]
-		private struct Cell {
-			[FieldOffset(0)]
-			public int Sequence;
-			[FieldOffset(8)]
-			public object Element;
-
-			public Cell(int sequence, object element) {
-				Sequence = sequence;
-				Element = element;
-			}
-		}
-	}
-}

Ragon.Common/External/NetStack.Threading/ConcurrentPool.cs

@@ -1,173 +0,0 @@
-/*
- *  Copyright (c) 2018 Virgile Bello, Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System;
-using System.Threading;
-
-namespace NetStack.Threading {
-	public sealed class ConcurrentPool<T> where T : class {
-		#if NET_4_6 || NET_STANDARD_2_0
-			private SpinLock _lock;
-		#else
-			private object _lock;
-		#endif
-		private readonly Func<T> _factory;
-		private Segment _head;
-		private Segment _tail;
-
-		public ConcurrentPool(int capacity, Func<T> factory) {
-			#if NET_4_6 || NET_STANDARD_2_0
-				_lock = new SpinLock();
-			#else
-				_lock = new Object();
-			#endif
-			_head = _tail = new Segment(capacity);
-			_factory = factory;
-		}
-
-		public T Acquire() {
-			while (true) {
-				var localHead = _head;
-				var count = localHead.Count;
-
-				if (count == 0) {
-					if (localHead.Next != null) {
-						#if NET_4_6 || NET_STANDARD_2_0
-							bool lockTaken = false;
-
-							try {
-								_lock.Enter(ref lockTaken);
-
-								if (_head.Next != null && _head.Count == 0)
-									_head = _head.Next;
-							}
-
-							finally {
-								if (lockTaken)
-									_lock.Exit(false);
-							}
-						#else
-							try {
-								Monitor.Enter(_lock);
-
-								if (_head.Next != null && _head.Count == 0)
-									_head = _head.Next;
-							}
-
-							finally {
-								Monitor.Exit(_lock);
-							}
-						#endif
-					} else {
-						return _factory();
-					}
-				} else if (Interlocked.CompareExchange(ref localHead.Count, count - 1, count) == count) {
-					var localLow = Interlocked.Increment(ref localHead.Low) - 1;
-					var index = localLow & localHead.Mask;
-					T item;
-					#if NET_4_6 || NET_STANDARD_2_0
-						var spinWait = new SpinWait();
-					#endif
-
-					while ((item = Interlocked.Exchange(ref localHead.Items[index], null)) == null) {
-						#if NET_4_6 || NET_STANDARD_2_0
-							spinWait.SpinOnce();
-						#else
-							Thread.SpinWait(1);
-						#endif
-					}
-
-					return item;
-				}
-			}
-		}
-
-		public void Release(T item) {
-			while (true) {
-				var localTail = _tail;
-				var count = localTail.Count;
-
-				if (count == localTail.Items.Length) {
-					#if NET_4_6 || NET_STANDARD_2_0
-						bool lockTaken = false;
-
-						try {
-							_lock.Enter(ref lockTaken);
-
-							if (_tail.Next == null && count == _tail.Items.Length)
-								_tail = _tail.Next = new Segment(_tail.Items.Length << 1);
-						}
-
-						finally {
-							if (lockTaken)
-								_lock.Exit(false);
-						}
-					#else
-						try {
-							Monitor.Enter(_lock);
-
-							if (_tail.Next == null && count == _tail.Items.Length)
-								_tail = _tail.Next = new Segment(_tail.Items.Length << 1);
-						}
-
-						finally {
-							Monitor.Exit(_lock);
-						}
-					#endif
-				} else if (Interlocked.CompareExchange(ref localTail.Count, count + 1, count) == count) {
-					var localHigh = Interlocked.Increment(ref localTail.High) - 1;
-					var index = localHigh & localTail.Mask;
-					#if NET_4_6 || NET_STANDARD_2_0
-						var spinWait = new SpinWait();
-					#endif
-
-					while (Interlocked.CompareExchange(ref localTail.Items[index], item, null) != null) {
-						#if NET_4_6 || NET_STANDARD_2_0
-							spinWait.SpinOnce();
-						#else
-							Thread.SpinWait(1);
-						#endif
-					}
-
-					return;
-				}
-			}
-		}
-
-		private class Segment {
-			public readonly T[] Items;
-			public readonly int Mask;
-			public int Low;
-			public int High;
-			public int Count;
-			public Segment Next;
-
-			public Segment(int size) {
-				if (size <= 0 || ((size & (size - 1)) != 0))
-					throw new ArgumentOutOfRangeException("Segment size must be power of two");
-
-				Items = new T[size];
-				Mask = size - 1;
-			}
-		}
-	}
-}

Ragon.Common/External/NetStack.Unsafe/Memory.cs

@@ -1,63 +0,0 @@
-/*
- *  Copyright (c) 2018 Stanislav Denisov
- *
- *  Permission is hereby granted, free of charge, to any person obtaining a copy
- *  of this software and associated documentation files (the "Software"), to deal
- *  in the Software without restriction, including without limitation the rights
- *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- *  copies of the Software, and to permit persons to whom the Software is
- *  furnished to do so, subject to the following conditions:
- *
- *  The above copyright notice and this permission notice shall be included in all
- *  copies or substantial portions of the Software.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- *  SOFTWARE.
- */
-
-using System;
-using System.Runtime.CompilerServices;
-
-namespace NetStack.Unsafe {
-	#if NET_4_6 || NET_STANDARD_2_0
-		public static class Memory {
-			[MethodImpl(256)]
-			public static unsafe void Copy(IntPtr source, int sourceOffset, byte[] destination, int destinationOffset, int length) {
-				if (length > 0) {
-					fixed (byte* destinationPointer = &destination[destinationOffset]) {
-						byte* sourcePointer = (byte*)source + sourceOffset;
-
-						Buffer.MemoryCopy(sourcePointer, destinationPointer, length, length);
-					}
-				}
-			}
-
-			[MethodImpl(256)]
-			public static unsafe void Copy(byte[] source, int sourceOffset, IntPtr destination, int destinationOffset, int length) {
-				if (length > 0) {
-					fixed (byte* sourcePointer = &source[sourceOffset]) {
-						byte* destinationPointer = (byte*)destination + destinationOffset;
-
-						Buffer.MemoryCopy(sourcePointer, destinationPointer, length, length);
-					}
-				}
-			}
-
-			[MethodImpl(256)]
-			public static unsafe void Copy(byte[] source, int sourceOffset, byte[] destination, int destinationOffset, int length) {
-				if (length > 0) {
-					fixed (byte* sourcePointer = &source[sourceOffset]) {
-						fixed (byte* destinationPointer = &destination[destinationOffset]) {
-							Buffer.MemoryCopy(sourcePointer, destinationPointer, length, length);
-						}
-					}
-				}
-			}
-		}
-	#endif
-}

Ragon.Common/Protocol/RagonAuthority.cs

@@ -1,8 +0,0 @@
-namespace Ragon.Common
-{
-  public enum RagonAuthority: byte
-  {
-    OWNER_ONLY,
-    ALL,
-  }
-}

Ragon.Common/Protocol/RagonOperation.cs

@@ -1,31 +0,0 @@
-namespace Ragon.Common
-{
-  public enum RagonOperation: byte
-  {
-    AUTHORIZE,
-    AUTHORIZED_SUCCESS,
-    AUTHORIZED_FAILED,
-    
-    JOIN_OR_CREATE_ROOM,
-    JOIN_ROOM,
-    LEAVE_ROOM,
-    OWNERSHIP_CHANGED,
-    JOIN_SUCCESS,
-    JOIN_FAILED,
-    
-    LOAD_SCENE,
-    SCENE_IS_LOADED,
-
-    PLAYER_JOINED,
-    PLAYER_LEAVED,
-    
-    CREATE_ENTITY,
-    DESTROY_ENTITY,
-    
-    SNAPSHOT,
-    
-    REPLICATE_ENTITY_STATE,
-    REPLICATE_ENTITY_EVENT,
-    REPLICATE_EVENT,
-  }
-}

Ragon.Common/Protocol/RagonSerializable.cs

@@ -1,10 +0,0 @@
-using NetStack.Serialization;
-
-namespace Ragon.Common
-{
-  public interface IRagonSerializable
-  {
-    public void Serialize(BitBuffer buffer);
-    public void Deserialize(BitBuffer buffer);
-  }
-}

Ragon.Common/Protocol/RagonSerializer.cs

@@ -1,200 +0,0 @@
-using System;
-using System.Runtime.CompilerServices;
-using System.Text;
-
-
-namespace Ragon.Common
-{
-
-  public class RagonSerializer
-  {
-    private byte[] _data;
-    private int _offset;
-    private int _size;
-    public int Lenght => _offset;
-    public int Size => _size - _offset;
-    
-    public RagonSerializer(int capacity = 256)
-    {
-      _data = new byte[capacity];
-      _offset = 0;
-      _size = 0;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WriteByte(byte value)
-    {
-      ResizeIfNeed(1);
-      
-      _data[_offset] = value;
-      _offset += 1;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public byte ReadByte()
-    {
-      var value = _data[_offset];
-      _offset += 1;
-      return value;
-    }
-    
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WriteInt(int value)
-    {
-      ResizeIfNeed(4);
-      
-      _data[_offset] = (byte) (value & 0x00FF);
-      _data[_offset + 1] = (byte) ((value & 0xFF00) >> 8);
-      _data[_offset + 2] = (byte) ((value & 0xFF00) >> 16);
-      _data[_offset + 3] = (byte) ((value & 0xFF00) >> 24);
-      _offset += 4;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public int ReadInt()
-    {
-      var value = _data[_offset] + (_data[_offset + 1] << 8) + (_data[_offset + 2] << 16) + (_data[_offset + 3] << 24);
-      _offset += 4;
-      return value;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WriteString(string value)
-    {
-      var stringRaw = Encoding.UTF8.GetBytes(value).AsSpan();
-      ResizeIfNeed(2 + stringRaw.Length);
-      
-      WriteUShort((ushort) stringRaw.Length);
-      var data = _data.AsSpan().Slice(_offset, stringRaw.Length);
-      stringRaw.CopyTo(data);
-      _offset += stringRaw.Length;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public string ReadString()
-    {
-      var lenght = ReadUShort();
-      var stringRaw = _data.AsSpan().Slice(_offset, lenght);
-      var str = Encoding.UTF8.GetString(stringRaw);
-      _offset += lenght;
-      return str;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public ReadOnlySpan<byte> ReadData(int lenght)
-    {
-      var data = _data.AsSpan();
-      var payloadData = data.Slice(_offset, lenght);
-      
-      _offset += payloadData.Length;
-      return payloadData;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WriteData(ref ReadOnlySpan<byte> payload)
-    {
-      ResizeIfNeed(payload.Length);
-      
-      var data = _data.AsSpan();
-      var payloadData = data.Slice(_offset, payload.Length);
-
-      payload.CopyTo(payloadData);
-      _offset += payload.Length;
-    }
-    
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public Span<byte> GetWritableData(int lenght)
-    {
-      ResizeIfNeed(lenght);
-      
-      var data = _data.AsSpan();
-      var payloadData = data.Slice(_offset, lenght);
-
-      _offset += lenght;
-      return payloadData;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WriteOperation(RagonOperation ragonOperation)
-    {
-      ResizeIfNeed(1);
-      
-      _data[_offset] = (byte) ragonOperation;
-      _offset += 1;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public RagonOperation ReadOperation()
-    {
-      var op = (RagonOperation) _data[_offset];
-      _offset += 1;
-      return op;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public void WriteUShort(ushort value)
-    {
-      ResizeIfNeed(2);
-      
-      _data[_offset] = (byte) (value & 0x00FF);
-      _data[_offset + 1] = (byte) ((value & 0xFF00) >> 8);
-      _offset += 2;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public ushort ReadUShort()
-    {
-      var value = (ushort) (_data[_offset] + (_data[_offset + 1] << 8));
-      _offset += 2;
-      return value;
-    }
-
-    public void Clear()
-    {
-      _offset = 0;
-      _size = 0;
-    }
-
-    public void ToSpan(ref Span<byte> data)
-    {
-      var span = _data.AsSpan();
-      var dataSpan = span.Slice(0, _offset);
-      dataSpan.CopyTo(data);
-    }
-
-    public void FromSpan(ref ReadOnlySpan<byte> data)
-    {
-      Clear();
-      ResizeIfNeed(data.Length);
-      var dataSpan = _data.AsSpan();
-      data.CopyTo(dataSpan);
-      _size = data.Length;
-    }
-    
-    public void FromArray(byte[] data)
-    {
-      Clear();
-      ResizeIfNeed(data.Length);
-      Buffer.BlockCopy(data, 0, _data, 0, _offset);
-      _size = data.Length;
-    }
-
-    
-    public byte[] ToArray()
-    {
-      var bytes = new byte[_offset];
-      Buffer.BlockCopy(_data, 0, bytes, 0, _offset);
-      return bytes;
-    }
-
-    private void ResizeIfNeed(int lenght)
-    {
-      if (_offset + lenght < _data.Length)
-        return;
-      
-      var newData = new byte[_data.Length * 4 + lenght];
-      Buffer.BlockCopy(_data, 0, newData, 0, _data.Length);
-      _data = newData;
-    }
-  }
-}

Ragon.Protocol/Ragon.Protocol.csproj

@@ -4,6 +4,15 @@
         <ImplicitUsings>disable</ImplicitUsings>
         <Nullable>disable</Nullable>
         <LangVersion>8</LangVersion>
+        <RootNamespace>Ragon.Common</RootNamespace>
+        <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+        <Version>1.2.4-rc</Version>
+        <Title>Ragon.Protocol</Title>
+        <Copyright>Eduard Kargin</Copyright>
+        <PackageProjectUrl>https://ragon-server.com</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/edmand46/Ragon</RepositoryUrl>
+        <RepositoryType>Source</RepositoryType>
+        <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
         <TargetFramework>netstandard2.1</TargetFramework>
     </PropertyGroup>
 
@@ -16,10 +25,7 @@
 
     <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
       <OutputPath></OutputPath>
-      <DefineConstants>TRACE;NETSTACK_SPAN</DefineConstants>
+      <DefineConstants>TRACE;</DefineConstants>
+      <DebugType>none</DebugType>
     </PropertyGroup>
-
-    <ItemGroup>
-      <Folder Include="External" />
-    </ItemGroup>
 </Project>

Ragon.Protocol/Sources/RagonAuthority.cs

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+namespace Ragon.Protocol
+{
+  public enum RagonAuthority: byte
+  {
+    None,
+    OwnerOnly,
+    All,
+  }
+}

Ragon.Protocol/Sources/RagonBuffer.cs

@@ -0,0 +1,438 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ *  Copyright (c) 2018 Stanislav Denisov, Maxim Munnig
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining a copy
+ *  of this software and associated documentation files (the "Software"), to deal
+ *  in the Software without restriction, including without limitation the rights
+ *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ *  copies of the Software, and to permit persons to whom the Software is
+ *  furnished to do so, subject to the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be included in all
+ *  copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ *  SOFTWARE.
+ */
+
+/*
+ *  Copyright (c) 2018 Alexander Shoulson
+ *
+ *  This software is provided 'as-is', without any express or implied
+ *  warranty. In no event will the authors be held liable for any damages
+ *  arising from the use of this software.
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented; you must not
+ *     claim that you wrote the original software. If you use this software
+ *     in a product, an acknowledgment in the product documentation would be
+ *     appreciated but is not required.
+ *  2. Altered source versions must be plainly marked as such, and must not be
+ *     misrepresented as being the original software.
+ *  3. This notice may not be removed or altered from any source distribution.
+ */
+
+
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace Ragon.Protocol
+{
+  public class RagonBuffer
+  {
+    private int _read;
+    private int _write;
+    private uint[] _buckets;
+    private readonly UTF8Encoding _utf8Encoding = new UTF8Encoding(false, true);
+
+    public int ReadOffset => _read;
+    public int WriteOffset => _write;
+    public int Length => ((_write - 1) >> 3) + 1;
+    public int Capacity => _write - _read;
+
+    public RagonBuffer(int capacity = 128)
+    {
+      _buckets = new uint[capacity];
+      _read = 0;
+      _write = 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteBool(bool value)
+    {
+      Write(value ? 1u : 0u, 1);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public bool ReadBool()
+    {
+      return Read(1) == 1u;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteByte(byte value)
+    {
+      Write(value, 8);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public byte ReadByte()
+    {
+      return (byte)Read(8);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteOperation(RagonOperation operation)
+    {
+      Write((byte)operation, 8);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public RagonOperation ReadOperation()
+    {
+      return (RagonOperation)Read(8);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteFloat(float value, float min, float max, float precision)
+    {
+      var requiredBits = DeBruijn.Log2((uint)((max - min) * (1.0f / precision) + 0.5f)) + 1;
+      var mask = (uint)((1L << requiredBits) - 1);
+      var compressedValue = (uint)((value - min) * (1f / precision) + 0.5f) & mask;
+
+      Write(compressedValue, requiredBits);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public float ReadFloat(float min, float max, float precision)
+    {
+      var requiredBits = DeBruijn.Log2((uint)((max - min) * (1.0f / precision) + 0.5f)) + 1;
+      var compressedValue = Read(requiredBits);
+
+      float adjusted = compressedValue * precision + min;
+
+      if (adjusted < min)
+        adjusted = min;
+      else if (adjusted > max)
+        adjusted = max;
+
+      return adjusted;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteInt(int value, int min, int max)
+    {
+      var maxValue = Math.Max(Math.Abs(min), Math.Abs(max));
+      var requiredBits = Bits.Compute(maxValue);
+      uint compressedValue = (uint)((value << 1) ^ (value >> 31));
+
+      Write(compressedValue, requiredBits);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public int ReadInt(int min, int max)
+    {
+      var maxValue = Math.Max(Math.Abs(min), Math.Abs(max));
+      var requiredBits = Bits.Compute(maxValue);
+      var compressedValue = Read(requiredBits);
+      var value = (int)((compressedValue >> 1) ^ (-(int)(compressedValue & 1)));
+
+      return value;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteUShort(ushort value)
+    {
+      Write(value, 16);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ushort ReadUShort()
+    {
+      return (ushort)Read(16);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteString(string str)
+    {
+      var data = _utf8Encoding.GetBytes(str);
+      var len = (uint)data.Length;
+      Write(len, 16);
+      WriteBytes(data);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public string ReadString()
+    {
+      var len = (int)Read(16);
+      var data = ReadBytes(len);
+      var str = _utf8Encoding.GetString(data);
+      return str;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public uint Read(int numBits, int offset)
+    {
+      var currentBucketIndex = offset >> 5;
+      var used = offset & 0x0000001F;
+
+      var chunkMask = ((1UL << numBits) - 1) << used;
+      var scratch = (ulong)_buckets[currentBucketIndex];
+
+      if (currentBucketIndex + 1 < _buckets.Length)
+        scratch |= (ulong)_buckets[currentBucketIndex + 1] << 32;
+
+      var result = (scratch & chunkMask) >> used;
+
+      return (uint)result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Write(uint value, int numBits, int offset)
+    {
+      Debug.Assert(!(numBits < 0));
+      Debug.Assert(!(numBits > 32));
+
+      var index = offset >> 5;
+      var used = offset & 0x0000001F;
+
+      var valueMask = (1UL << numBits) - 1;
+      var prepared = (value & valueMask) << used;
+      var scratch = _buckets[index] | (ulong)_buckets[index + 1] << 32;
+      var result = scratch | prepared;
+
+      _buckets[index] = (uint)result;
+      _buckets[index + 1] = (uint)(result >> 32);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void Write(uint value, int numBits = 16)
+    {
+      Debug.Assert(!(numBits < 0));
+      Debug.Assert(!(numBits > 32));
+
+      var currentBucketIndex = _write >> 5;
+      var used = _write & 0x0000001F;
+      var mask = (1UL << used) - 1;
+      var scratch = _buckets[currentBucketIndex] & mask;
+      var result = scratch | ((ulong)value << used);
+
+      if (currentBucketIndex + 1 >= _buckets.Length)
+        Resize(1);
+      
+      _buckets[currentBucketIndex] = (uint)result;
+      _buckets[currentBucketIndex + 1] = (uint)(result >> 32);
+
+      _write += numBits;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public uint Read(int numBits = 16)
+    {
+      var currentBucketIndex = _read >> 5;
+      var used = _read & 0x0000001F;
+
+      var chunkMask = ((1UL << numBits) - 1) << used;
+      var scratch = (ulong)_buckets[currentBucketIndex];
+
+      if (currentBucketIndex + 1 < _buckets.Length)
+        scratch |= (ulong)_buckets[currentBucketIndex + 1] << 32;
+
+      var result = (scratch & chunkMask) >> used;
+
+      _read += numBits;
+
+      return (uint)result;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [Obsolete("Do not use this method, will be removed")]
+    public void WriteBytes(byte[] data)
+    {
+      var len = data.Length;
+      for (int i = 0; i < len; i++)
+        Write(data[i], 8);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [Obsolete("Do not use this method, will be removed")]
+    public byte[] ReadBytes(int lenght)
+    {
+      var data = new byte[lenght];
+      for (int i = 0; i < lenght; i++)
+        data[i] = (byte)Read(8);
+
+      return data;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ReadSpan(ref Span<uint> data, int size)
+    {
+      var used = _read & 0x0000001F;
+      var index = _read >> 5;
+      var limit = (size + 32 - 1) / 32;
+      var capacity = size;
+      
+      for (int i = 0; i < limit; i++)
+      {
+        var dataSize = capacity > 32 ? 32 : capacity;
+        var mask = (1UL << dataSize) - 1;
+        var bucketRaw = (ulong)_buckets[index];
+        if (index + 1 < _buckets.Length)
+          bucketRaw |= (ulong)_buckets[index + 1] << 32;
+      
+        var bucket = bucketRaw >> used;
+        var result = bucket & mask;
+      
+        data[i] = (uint)result;
+        if (i + 1 < data.Length)
+          data[i + 1] = (uint)(result >> 32);
+      
+        index += 1;
+        capacity -= dataSize;
+      }
+      
+      _read += size;
+    }
+    
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void WriteSpan(ref ReadOnlySpan<uint> data, int size)
+    {
+      var used = _write & 0x0000001F;
+      var index = _write >> 5;
+      var limit = (size + 32 - 1) / 32;
+
+      if (index + limit >= _buckets.Length)
+        Resize(size);
+      
+      for (var i = 0; i < limit; i += 1)
+      {
+        var prepared = (ulong) data[i] << used;
+        var mask = (1UL << used) - 1;
+        var scratch = _buckets[index] & mask;
+        var result = scratch | prepared;
+      
+        _buckets[index] = (uint)result;
+        _buckets[index + 1] = (uint)(result >> 32);
+      
+        index += 1;
+      }
+      
+      _write += size;
+    }
+
+    public void Clear()
+    {
+      _read = 0;
+      _write = 0;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void FromBuffer(RagonBuffer buffer, int size)
+    {
+      ReadOnlySpan<uint> data = buffer._buckets.AsSpan();
+      WriteSpan(ref data, size);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public void ToBuffer(RagonBuffer buffer, int size)
+    {
+      var data = buffer._buckets.AsSpan();
+      ReadSpan(ref data, size);
+    }
+    
+    public void FromArray(byte[] data)
+    {
+      var length = data.Length;
+      var bucketsCount = length / 4 + 1;
+
+      if (_buckets.Length < bucketsCount)
+        _buckets = new uint[bucketsCount];
+
+      for (var i = 0; i < bucketsCount; i++)
+      {
+        var dataIdx = i * 4;
+        var bucket = 0u;
+
+        if (dataIdx < length)
+          bucket = data[dataIdx];
+
+        if (dataIdx + 1 < length)
+          bucket |= (uint)data[dataIdx + 1] << 8;
+
+        if (dataIdx + 2 < length)
+          bucket |= (uint)data[dataIdx + 2] << 16;
+
+        if (dataIdx + 3 < length)
+          bucket |= (uint)data[dataIdx + 3] << 24;
+
+        _buckets[i] = bucket;
+      }
+
+      int positionInByte = Bits.FindBitPosition(data[length - 1]);
+
+      _write = ((length - 1) * 8) + positionInByte;
+      _read = 0;
+    }
+
+    public byte[] ToArray()
+    {
+      var data = new byte[Length];
+      int bucketsCount = (_write >> 5) + 1;
+      int length = data.Length;
+
+      for (int i = 0; i < bucketsCount; i++)
+      {
+        int dataIdx = i * 4;
+        uint bucket = _buckets[i];
+
+        if (dataIdx < length)
+          data[dataIdx] = (byte)(bucket);
+
+        if (dataIdx + 1 < length)
+          data[dataIdx + 1] = (byte)(bucket >> 8);
+
+        if (dataIdx + 2 < length)
+          data[dataIdx + 2] = (byte)(bucket >> 16);
+
+        if (dataIdx + 3 < length)
+          data[dataIdx + 3] = (byte)(bucket >> 24);
+      }
+
+      return data;
+    }
+
+    private void Resize(int capacity)
+    {
+      var buckets = new uint[_buckets.Length * 2 + capacity];
+      Array.Copy(_buckets, buckets, _buckets.Length);
+      _buckets = buckets;
+    }
+  }
+}

Ragon.Protocol/Sources/RagonDisconnect.cs

@@ -0,0 +1,9 @@
+namespace Ragon.Protocol
+{
+  public enum RagonDisconnect
+  {
+    MANUAL,
+    TIMEOUT,
+    SERVER,
+  }
+}

Ragon.Protocol/Sources/RagonOperation.cs

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+namespace Ragon.Protocol
+{
+  public enum RagonOperation: byte
+  {
+    AUTHORIZE,
+    AUTHORIZED_SUCCESS,
+    AUTHORIZED_FAILED,
+    JOIN_OR_CREATE_ROOM,
+    CREATE_ROOM,
+    JOIN_ROOM,
+    LEAVE_ROOM,
+    OWNERSHIP_ENTITY_CHANGED,
+    OWNERSHIP_ROOM_CHANGED,
+    JOIN_SUCCESS,
+    JOIN_FAILED,
+    LOAD_SCENE,
+    SCENE_LOADED,
+    PLAYER_JOINED,
+    PLAYER_LEAVED,
+    CREATE_ENTITY,
+    REMOVE_ENTITY,
+    SNAPSHOT,
+    REPLICATE_ENTITY_STATE,
+    REPLICATE_ENTITY_EVENT,
+    TRANSFER_ROOM_OWNERSHIP,
+    TRANSFER_ENTITY_OWNERSHIP,
+  }
+}

Ragon.Protocol/Sources/RagonReplicationMode.cs

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2023 Eduard Kargin <kargin.eduard@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+namespace Ragon.Protocol
+{
+  public enum RagonReplicationMode: byte
+  {
+    Local,
+    Server,
+    LocalAndServer,
+    Buffered,
+  }
+}