reformat and cleanup code

BattleBitAPI/Common/Arguments/OnPlayerKillArguments.cs

@@ -1,18 +1,16 @@
 using System.Numerics;
-using CommunityServerAPI.BattleBitAPI.Server;
 
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public struct OnPlayerKillArguments<TPlayer> where TPlayer : Player<TPlayer>
 {
-    public struct OnPlayerKillArguments<TPlayer> where TPlayer : Player<TPlayer>
+    public TPlayer Killer;
-    {
+    public Vector3 KillerPosition;
-        public TPlayer Killer;
-        public Vector3 KillerPosition;
 
-        public TPlayer Victim;
+    public TPlayer Victim;
-        public Vector3 VictimPosition;
+    public Vector3 VictimPosition;
 
-        public string KillerTool;
+    public string KillerTool;
-        public PlayerBody BodyPart;
+    public PlayerBody BodyPart;
-        public ReasonOfDamage SourceOfDamage;
+    public ReasonOfDamage SourceOfDamage;
-    }
+}
-}

BattleBitAPI/Common/Arguments/OnPlayerSpawnArguments.cs

@@ -1,50 +1,51 @@
 using System.Numerics;
+using Stream = BattleBitAPI.Common.Serialization.Stream;
 
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public struct OnPlayerSpawnArguments
 {
-    public struct OnPlayerSpawnArguments
+    public PlayerSpawningPosition RequestedPoint;
-    {
+    public PlayerLoadout Loadout;
-        public PlayerSpawningPosition RequestedPoint;
+    public PlayerWearings Wearings;
-        public PlayerLoadout Loadout;
+    public Vector3 SpawnPosition;
-        public PlayerWearings Wearings;
+    public Vector3 LookDirection;
-        public Vector3 SpawnPosition;
+    public PlayerStand SpawnStand;
-        public Vector3 LookDirection;
+    public float SpawnProtection;
-        public PlayerStand SpawnStand;
-        public float SpawnProtection;
 
-        public void Write(Common.Serialization.Stream ser)
+    public void Write(Stream ser)
-        {
+    {
-            ser.Write((byte)RequestedPoint);
+        ser.Write((byte)RequestedPoint);
-            Loadout.Write(ser);
+        Loadout.Write(ser);
-            Wearings.Write(ser);
+        Wearings.Write(ser);
-            ser.Write(SpawnPosition.X);
+        ser.Write(SpawnPosition.X);
-            ser.Write(SpawnPosition.Y);
+        ser.Write(SpawnPosition.Y);
-            ser.Write(SpawnPosition.Z);
+        ser.Write(SpawnPosition.Z);
-            ser.Write(LookDirection.X);
+        ser.Write(LookDirection.X);
-            ser.Write(LookDirection.Y);
+        ser.Write(LookDirection.Y);
-            ser.Write(LookDirection.Z);
+        ser.Write(LookDirection.Z);
-            ser.Write((byte)SpawnStand);
+        ser.Write((byte)SpawnStand);
-            ser.Write(SpawnProtection);
+        ser.Write(SpawnProtection);
-        }
-        public void Read(Common.Serialization.Stream ser)
-        {
-            RequestedPoint = (PlayerSpawningPosition)ser.ReadInt8();
-            Loadout.Read(ser);
-            Wearings.Read(ser);
-            SpawnPosition = new Vector3()
-            {
-                X = ser.ReadFloat(),
-                Y = ser.ReadFloat(),
-                Z = ser.ReadFloat()
-            };
-            LookDirection = new Vector3()
-            {
-                X = ser.ReadFloat(),
-                Y = ser.ReadFloat(),
-                Z = ser.ReadFloat()
-            };
-            SpawnStand = (PlayerStand)ser.ReadInt8();
-            SpawnProtection = ser.ReadFloat();
-        }
     }
-}
+
+    public void Read(Stream ser)
+    {
+        RequestedPoint = (PlayerSpawningPosition)ser.ReadInt8();
+        Loadout.Read(ser);
+        Wearings.Read(ser);
+        SpawnPosition = new Vector3
+        {
+            X = ser.ReadFloat(),
+            Y = ser.ReadFloat(),
+            Z = ser.ReadFloat()
+        };
+        LookDirection = new Vector3
+        {
+            X = ser.ReadFloat(),
+            Y = ser.ReadFloat(),
+            Z = ser.ReadFloat()
+        };
+        SpawnStand = (PlayerStand)ser.ReadInt8();
+        SpawnProtection = ser.ReadFloat();
+    }
+}

BattleBitAPI/Common/Arguments/PlayerJoiningArgument.cs

@@ -1,18 +1,17 @@
-using System;
+using Stream = BattleBitAPI.Common.Serialization.Stream;
 
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public class PlayerJoiningArguments
 {
-    public class PlayerJoiningArguments
+    public Squads Squad;
-    {
+    public PlayerStats Stats;
-        public PlayerStats Stats;
+    public Team Team;
-        public Team Team;
-        public Squads Squad;
 
-        public void Write(BattleBitAPI.Common.Serialization.Stream ser)
+    public void Write(Stream ser)
-        {
+    {
-            this.Stats.Write(ser);
+        Stats.Write(ser);
-            ser.Write((byte)this.Team);
+        ser.Write((byte)Team);
-            ser.Write((byte)this.Squad);
+        ser.Write((byte)Squad);
-        }
     }
-}
+}

BattleBitAPI/Common/Conts.cs

@@ -1,44 +1,47 @@
-namespace CommunityServerAPI.BattleBitAPI
+namespace CommunityServerAPI.BattleBitAPI;
+
+public static class Const
 {
-    public static class Const
+    // ---- Networking ---- 
-    {
+    /// <summary>
-        // ---- Networking ---- 
+    ///     Maximum data size for a single package. 4MB is default.
-        /// <summary>
+    /// </summary>
-        /// Maximum data size for a single package. 4MB is default.
+    public const int MaxNetworkPackageSize = 1024 * 1024 * 4; //4mb
-        /// </summary>
+
-        public const int MaxNetworkPackageSize = 1024 * 1024 * 4;//4mb
+    /// <summary>
-        /// <summary>
+    ///     How long should server/client wait until connection is determined as timed out when no packages is being sent for
-        /// How long should server/client wait until connection is determined as timed out when no packages is being sent for long time.
+    ///     long time.
-        /// </summary>
+    /// </summary>
-        public const int NetworkTimeout = 60 * 1000;//60 seconds
+    public const int NetworkTimeout = 60 * 1000; //60 seconds
-        /// <summary>
+
-        /// How frequently client/server will send keep alive to each other when no message is being sent to each other for a while.
+    /// <summary>
-        /// </summary>
+    ///     How frequently client/server will send keep alive to each other when no message is being sent to each other for a
-        public const int NetworkKeepAlive = 5 * 1000;//15 seconds
+    ///     while.
-        /// <summary>
+    /// </summary>
-        /// How long server/client will wait other side to send their hail/initial package. In miliseconds.
+    public const int NetworkKeepAlive = 5 * 1000; //15 seconds
-        /// </summary>
+
+    /// <summary>
+    ///     How long server/client will wait other side to send their hail/initial package. In miliseconds.
+    /// </summary>
 #if DEBUG
-        public const int HailConnectTimeout = 20 * 1000;
+    public const int HailConnectTimeout = 20 * 1000;
 #else
-        public const int HailConnectTimeout = 2 * 1000;
+    public const int HailConnectTimeout = 2 * 1000;
 #endif
 
-        // ---- Server Fields ---- 
+    // ---- Server Fields ---- 
-        public const int MinServerNameLength = 5;
+    public const int MinServerNameLength = 5;
-        public const int MaxServerNameLength = 400;
+    public const int MaxServerNameLength = 400;
 
-        public const int MinGamemodeNameLength = 2;
+    public const int MinGamemodeNameLength = 2;
-        public const int MaxGamemodeNameLength = 12;
+    public const int MaxGamemodeNameLength = 12;
 
-        public const int MinMapNameLength = 2;
+    public const int MinMapNameLength = 2;
-        public const int MaxMapNameLength = 36;
+    public const int MaxMapNameLength = 36;
 
-        public const int MinLoadingScreenTextLength = 0;
+    public const int MinLoadingScreenTextLength = 0;
-        public const int MaxLoadingScreenTextLength = 1024 * 8;
+    public const int MaxLoadingScreenTextLength = 1024 * 8;
 
-        public const int MinServerRulesTextLength = 0;
+    public const int MinServerRulesTextLength = 0;
-        public const int MaxServerRulesTextLength = 1024 * 8;
+    public const int MaxServerRulesTextLength = 1024 * 8;
-
+}
-    }
-}

BattleBitAPI/Common/Data/Attachment.cs

@@ -1,74 +1,76 @@
-using BattleBitAPI.Common;
+namespace BattleBitAPI.Common;
-using System;
 
-namespace BattleBitAPI.Common
+public class Attachment : IEquatable<string>, IEquatable<Attachment>
 {
-    public class Attachment : IEquatable<string>, IEquatable<Attachment>
+    public Attachment(string name, AttachmentType attachmentType)
     {
-        public string Name { get; private set; }
+        Name = name;
-        public AttachmentType AttachmentType { get; private set; }
+        AttachmentType = attachmentType;
-        public Attachment(string name, AttachmentType attachmentType)
-        {
-            Name = name;
-            AttachmentType = attachmentType;
-        }
-
-        public override string ToString()
-        {
-            return this.Name;
-        }
-        public bool Equals(string other)
-        {
-            if (other == null)
-                return false;
-            return this.Name.Equals(other);
-        }
-        public bool Equals(Attachment other)
-        {
-            if (other == null)
-                return false;
-            return this.Name.Equals(other.Name);
-        }
-
-        public static bool operator ==(string left, Attachment right)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
-        public static bool operator !=(string left, Attachment right)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
-        public static bool operator ==(Attachment right, string left)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
-        public static bool operator !=(Attachment right, string left)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
     }
-}
+
+    public string Name { get; }
+    public AttachmentType AttachmentType { get; private set; }
+
+    public bool Equals(Attachment other)
+    {
+        if (other == null)
+            return false;
+        return Name.Equals(other.Name);
+    }
+
+    public bool Equals(string other)
+    {
+        if (other == null)
+            return false;
+        return Name.Equals(other);
+    }
+
+    public override string ToString()
+    {
+        return Name;
+    }
+
+    public static bool operator ==(string left, Attachment right)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator !=(string left, Attachment right)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator ==(Attachment right, string left)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator !=(Attachment right, string left)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+}

BattleBitAPI/Common/Data/Gadget.cs

@@ -1,69 +1,74 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public class Gadget : IEquatable<string>, IEquatable<Gadget>
 {
-    public class Gadget : IEquatable<string>, IEquatable<Gadget>
+    public Gadget(string name)
     {
-        public string Name { get; private set; }
+        Name = name;
-        public Gadget(string name)
-        {
-            Name = name;
-        }
-
-        public override string ToString()
-        {
-            return this.Name;
-        }
-        public bool Equals(string other)
-        {
-            if (other == null)
-                return false;
-            return this.Name.Equals(other);
-        }
-        public bool Equals(Gadget other)
-        {
-            if (other == null)
-                return false;
-            return this.Name.Equals(other.Name);
-        }
-
-        public static bool operator ==(string left, Gadget right)
-        {
-            bool leftNull = object.ReferenceEquals(left,null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
-        public static bool operator !=(string left, Gadget right)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
-        public static bool operator ==(Gadget right, string left)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
-        public static bool operator !=(Gadget right, string left)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
     }
-}
+
+    public string Name { get; }
+
+    public bool Equals(Gadget other)
+    {
+        if (other == null)
+            return false;
+        return Name.Equals(other.Name);
+    }
+
+    public bool Equals(string other)
+    {
+        if (other == null)
+            return false;
+        return Name.Equals(other);
+    }
+
+    public override string ToString()
+    {
+        return Name;
+    }
+
+    public static bool operator ==(string left, Gadget right)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator !=(string left, Gadget right)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator ==(Gadget right, string left)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator !=(Gadget right, string left)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+}

BattleBitAPI/Common/Data/Gadgets.cs

@@ -1,76 +1,73 @@
 using System.Reflection;
 
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public static class Gadgets
 {
-    public static class Gadgets
+    // ----- Private Variables ----- 
+    private static readonly Dictionary<string, Gadget> mGadgets;
+
+    // ----- Public Variables ----- 
+    public static readonly Gadget Bandage = new("Bandage");
+    public static readonly Gadget Binoculars = new("Binoculars");
+    public static readonly Gadget RangeFinder = new("Range Finder");
+    public static readonly Gadget RepairTool = new("Repair Tool");
+    public static readonly Gadget C4 = new("C4");
+    public static readonly Gadget Claymore = new("Claymore");
+    public static readonly Gadget M320SmokeGrenadeLauncher = new("M320 Smoke Grenade Launcher");
+    public static readonly Gadget SmallAmmoKit = new("Small Ammo Kit");
+    public static readonly Gadget AntiPersonnelMine = new("Anti Personnel Mine");
+    public static readonly Gadget AntiVehicleMine = new("Anti Vehicle Mine");
+    public static readonly Gadget MedicKit = new("Medic Kit");
+    public static readonly Gadget Rpg7HeatExplosive = new("Rpg7 Heat Explosive");
+    public static readonly Gadget RiotShield = new("Riot Shield");
+    public static readonly Gadget FragGrenade = new("Frag Grenade");
+    public static readonly Gadget ImpactGrenade = new("Impact Grenade");
+    public static readonly Gadget AntiVehicleGrenade = new("Anti Vehicle Grenade");
+    public static readonly Gadget SmokeGrenadeBlue = new("Smoke Grenade Blue");
+    public static readonly Gadget SmokeGrenadeGreen = new("Smoke Grenade Green");
+    public static readonly Gadget SmokeGrenadeRed = new("Smoke Grenade Red");
+    public static readonly Gadget SmokeGrenadeWhite = new("Smoke Grenade White");
+    public static readonly Gadget Flare = new("Flare");
+    public static readonly Gadget SledgeHammer = new("Sledge Hammer");
+    public static readonly Gadget AdvancedBinoculars = new("Advanced Binoculars");
+    public static readonly Gadget Mdx201 = new("Mdx 201");
+    public static readonly Gadget BinoSoflam = new("Bino Soflam");
+    public static readonly Gadget HeavyAmmoKit = new("Heavy Ammo Kit");
+    public static readonly Gadget Rpg7Pgo7Tandem = new("Rpg7 Pgo7 Tandem");
+    public static readonly Gadget Rpg7Pgo7HeatExplosive = new("Rpg7 Pgo7 Heat Explosive");
+    public static readonly Gadget Rpg7Pgo7Fragmentation = new("Rpg7 Pgo7 Fragmentation");
+    public static readonly Gadget Rpg7Fragmentation = new("Rpg7 Fragmentation");
+    public static readonly Gadget GrapplingHook = new("Grappling Hook");
+    public static readonly Gadget AirDrone = new("Air Drone");
+    public static readonly Gadget Flashbang = new("Flashbang");
+    public static readonly Gadget Pickaxe = new("Pickaxe");
+    public static readonly Gadget SuicideC4 = new("SuicideC4");
+    public static readonly Gadget SledgeHammerSkinA = new("Sledge Hammer SkinA");
+    public static readonly Gadget SledgeHammerSkinB = new("Sledge Hammer SkinB");
+    public static readonly Gadget SledgeHammerSkinC = new("Sledge Hammer SkinC");
+    public static readonly Gadget PickaxeIronPickaxe = new("Pickaxe IronPickaxe");
+
+    // ----- Init ----- 
+    static Gadgets()
     {
-        // ----- Private Variables ----- 
+        var members = typeof(Gadgets).GetMembers(BindingFlags.Public | BindingFlags.Static);
-        private static Dictionary<string, Gadget> mGadgets;
+        mGadgets = new Dictionary<string, Gadget>(members.Length);
-
+        foreach (var memberInfo in members)
-        // ----- Public Variables ----- 
+            if (memberInfo.MemberType == MemberTypes.Field)
-        public static readonly Gadget Bandage = new Gadget("Bandage");
-        public static readonly Gadget Binoculars = new Gadget("Binoculars");
-        public static readonly Gadget RangeFinder = new Gadget("Range Finder");
-        public static readonly Gadget RepairTool = new Gadget("Repair Tool");
-        public static readonly Gadget C4 = new Gadget("C4");
-        public static readonly Gadget Claymore = new Gadget("Claymore");
-        public static readonly Gadget M320SmokeGrenadeLauncher = new Gadget("M320 Smoke Grenade Launcher");
-        public static readonly Gadget SmallAmmoKit = new Gadget("Small Ammo Kit");
-        public static readonly Gadget AntiPersonnelMine = new Gadget("Anti Personnel Mine");
-        public static readonly Gadget AntiVehicleMine = new Gadget("Anti Vehicle Mine");
-        public static readonly Gadget MedicKit = new Gadget("Medic Kit");
-        public static readonly Gadget Rpg7HeatExplosive = new Gadget("Rpg7 Heat Explosive");
-        public static readonly Gadget RiotShield = new Gadget("Riot Shield");
-        public static readonly Gadget FragGrenade = new Gadget("Frag Grenade");
-        public static readonly Gadget ImpactGrenade = new Gadget("Impact Grenade");
-        public static readonly Gadget AntiVehicleGrenade = new Gadget("Anti Vehicle Grenade");
-        public static readonly Gadget SmokeGrenadeBlue = new Gadget("Smoke Grenade Blue");
-        public static readonly Gadget SmokeGrenadeGreen = new Gadget("Smoke Grenade Green");
-        public static readonly Gadget SmokeGrenadeRed = new Gadget("Smoke Grenade Red");
-        public static readonly Gadget SmokeGrenadeWhite = new Gadget("Smoke Grenade White");
-        public static readonly Gadget Flare = new Gadget("Flare");
-        public static readonly Gadget SledgeHammer = new Gadget("Sledge Hammer");
-        public static readonly Gadget AdvancedBinoculars = new Gadget("Advanced Binoculars");
-        public static readonly Gadget Mdx201 = new Gadget("Mdx 201");
-        public static readonly Gadget BinoSoflam = new Gadget("Bino Soflam");
-        public static readonly Gadget HeavyAmmoKit = new Gadget("Heavy Ammo Kit");
-        public static readonly Gadget Rpg7Pgo7Tandem = new Gadget("Rpg7 Pgo7 Tandem");
-        public static readonly Gadget Rpg7Pgo7HeatExplosive = new Gadget("Rpg7 Pgo7 Heat Explosive");
-        public static readonly Gadget Rpg7Pgo7Fragmentation = new Gadget("Rpg7 Pgo7 Fragmentation");
-        public static readonly Gadget Rpg7Fragmentation = new Gadget("Rpg7 Fragmentation");
-        public static readonly Gadget GrapplingHook = new Gadget("Grappling Hook");
-        public static readonly Gadget AirDrone = new Gadget("Air Drone");
-        public static readonly Gadget Flashbang = new Gadget("Flashbang");
-        public static readonly Gadget Pickaxe = new Gadget("Pickaxe");
-        public static readonly Gadget SuicideC4 = new Gadget("SuicideC4");
-        public static readonly Gadget SledgeHammerSkinA = new Gadget("Sledge Hammer SkinA");
-        public static readonly Gadget SledgeHammerSkinB = new Gadget("Sledge Hammer SkinB");
-        public static readonly Gadget SledgeHammerSkinC = new Gadget("Sledge Hammer SkinC");
-        public static readonly Gadget PickaxeIronPickaxe = new Gadget("Pickaxe IronPickaxe");
-
-        // ----- Public Calls ----- 
-        public static bool TryFind(string name, out Gadget item)
-        {
-            return mGadgets.TryGetValue(name, out item);
-        }
-
-        // ----- Init ----- 
-        static Gadgets()
-        {
-            var members = typeof(Gadgets).GetMembers(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
-            mGadgets = new Dictionary<string, Gadget>(members.Length);
-            foreach (var memberInfo in members)
             {
-                if (memberInfo.MemberType == System.Reflection.MemberTypes.Field)
+                var field = (FieldInfo)memberInfo;
+                if (field.FieldType == typeof(Gadget))
                 {
-                    var field = ((FieldInfo)memberInfo);
+                    var gad = (Gadget)field.GetValue(null);
-                    if (field.FieldType == typeof(Gadget))
+                    mGadgets.Add(gad.Name, gad);
-                    {
-                        var gad = (Gadget)field.GetValue(null);
-                        mGadgets.Add(gad.Name, gad);
-                    }
                 }
             }
-        }
     }
-}
+
+    // ----- Public Calls ----- 
+    public static bool TryFind(string name, out Gadget item)
+    {
+        return mGadgets.TryGetValue(name, out item);
+    }
+}

BattleBitAPI/Common/Data/Map.cs

@@ -1,69 +1,74 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public class Map : IEquatable<string>, IEquatable<Map>
 {
-    public class Map : IEquatable<string>, IEquatable<Map>
+    public Map(string name)
     {
-        public string Name { get; private set; }
+        Name = name;
-        public Map(string name)
-        {
-            Name = name;
-        }
-
-        public override string ToString()
-        {
-            return this.Name;
-        }
-        public bool Equals(string other)
-        {
-            if (other == null)
-                return false;
-            return this.Name.Equals(other);
-        }
-        public bool Equals(Map other)
-        {
-            if (other == null)
-                return false;
-            return this.Name.Equals(other.Name);
-        }
-
-        public static bool operator ==(string left, Map right)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
-        public static bool operator !=(string left, Map right)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
-        public static bool operator ==(Map right, string left)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
-        public static bool operator !=(Map right, string left)
-        {
-            bool leftNull = object.ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
-            if (leftNull && rightNull)
-                return true;
-            if (leftNull || rightNull)
-                return false;
-            return right.Name.Equals(left);
-        }
     }
-}
+
+    public string Name { get; }
+
+    public bool Equals(Map other)
+    {
+        if (other == null)
+            return false;
+        return Name.Equals(other.Name);
+    }
+
+    public bool Equals(string other)
+    {
+        if (other == null)
+            return false;
+        return Name.Equals(other);
+    }
+
+    public override string ToString()
+    {
+        return Name;
+    }
+
+    public static bool operator ==(string left, Map right)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator !=(string left, Map right)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator ==(Map right, string left)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator !=(Map right, string left)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+}

BattleBitAPI/Common/Data/PlayerLoadout.cs

@@ -1,348 +1,364 @@
-namespace BattleBitAPI.Common
+using Stream = BattleBitAPI.Common.Serialization.Stream;
+
+namespace BattleBitAPI.Common;
+
+public struct PlayerLoadout
 {
-    public struct PlayerLoadout
+    public WeaponItem PrimaryWeapon;
+    public WeaponItem SecondaryWeapon;
+    public string FirstAidName;
+    public string LightGadgetName;
+    public string HeavyGadgetName;
+    public string ThrowableName;
+
+    public byte PrimaryExtraMagazines;
+    public byte SecondaryExtraMagazines;
+    public byte FirstAidExtra;
+    public byte LightGadgetExtra;
+    public byte HeavyGadgetExtra;
+    public byte ThrowableExtra;
+
+    public Gadget FirstAid
     {
-        public WeaponItem PrimaryWeapon;
+        get
-        public WeaponItem SecondaryWeapon;
-        public string FirstAidName;
-        public string LightGadgetName;
-        public string HeavyGadgetName;
-        public string ThrowableName;
-
-        public byte PrimaryExtraMagazines;
-        public byte SecondaryExtraMagazines;
-        public byte FirstAidExtra;
-        public byte LightGadgetExtra;
-        public byte HeavyGadgetExtra;
-        public byte ThrowableExtra;
-
-        public Gadget FirstAid
         {
-            get
+            if (Gadgets.TryFind(FirstAidName, out var gadget))
-            {
+                return gadget;
-                if (Gadgets.TryFind(FirstAidName, out var gadget))
+            return null;
-                    return gadget;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.FirstAidName = "none";
-                else
-                    this.FirstAidName = value.Name;
-            }
         }
-        public Gadget LightGadget
+        set
         {
-            get
+            if (value == null)
-            {
+                FirstAidName = "none";
-                if (Gadgets.TryFind(LightGadgetName, out var gadget))
+            else
-                    return gadget;
+                FirstAidName = value.Name;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.LightGadgetName = "none";
-                else
-                    this.LightGadgetName = value.Name;
-            }
-        }
-        public Gadget HeavyGadget
-        {
-            get
-            {
-                if (Gadgets.TryFind(HeavyGadgetName, out var gadget))
-                    return gadget;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.HeavyGadgetName = "none";
-                else
-                    this.HeavyGadgetName = value.Name;
-            }
-        }
-        public Gadget Throwable
-        {
-            get
-            {
-                if (Gadgets.TryFind(ThrowableName, out var gadget))
-                    return gadget;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.ThrowableName = "none";
-                else
-                    this.ThrowableName = value.Name;
-            }
-        }
-
-        public bool HasGadget(Gadget gadget)
-        {
-            if (this.FirstAid == gadget)
-                return true;
-            if (this.LightGadget == gadget)
-                return true;
-            if (this.HeavyGadget == gadget)
-                return true;
-            if (this.Throwable == gadget)
-                return true;
-            return false;
-        }
-
-        public void Write(Common.Serialization.Stream ser)
-        {
-            this.PrimaryWeapon.Write(ser);
-            this.SecondaryWeapon.Write(ser);
-            ser.WriteStringItem(this.FirstAidName);
-            ser.WriteStringItem(this.LightGadgetName);
-            ser.WriteStringItem(this.HeavyGadgetName);
-            ser.WriteStringItem(this.ThrowableName);
-
-            ser.Write(this.PrimaryExtraMagazines);
-            ser.Write(this.SecondaryExtraMagazines);
-            ser.Write(this.FirstAidExtra);
-            ser.Write(this.LightGadgetExtra);
-            ser.Write(this.HeavyGadgetExtra);
-            ser.Write(this.ThrowableExtra);
-        }
-        public void Read(Common.Serialization.Stream ser)
-        {
-            this.PrimaryWeapon.Read(ser);
-            this.SecondaryWeapon.Read(ser);
-            ser.TryReadString(out this.FirstAidName);
-            ser.TryReadString(out this.LightGadgetName);
-            ser.TryReadString(out this.HeavyGadgetName);
-            ser.TryReadString(out this.ThrowableName);
-
-            this.PrimaryExtraMagazines = ser.ReadInt8();
-            this.SecondaryExtraMagazines = ser.ReadInt8();
-            this.FirstAidExtra = ser.ReadInt8();
-            this.LightGadgetExtra = ser.ReadInt8();
-            this.HeavyGadgetExtra = ser.ReadInt8();
-            this.ThrowableExtra = ser.ReadInt8();
         }
     }
-    public struct WeaponItem
+
+    public Gadget LightGadget
     {
-        public string ToolName;
+        get
-        public string MainSightName;
+        {
-        public string TopSightName;
+            if (Gadgets.TryFind(LightGadgetName, out var gadget))
-        public string CantedSightName;
+                return gadget;
-        public string BarrelName;
+            return null;
-        public string SideRailName;
+        }
-        public string UnderRailName;
+        set
-        public string BoltActionName;
+        {
-        public byte SkinIndex;
+            if (value == null)
-        public byte MagazineIndex;
+                LightGadgetName = "none";
+            else
+                LightGadgetName = value.Name;
+        }
+    }
 
-        public Weapon Tool
+    public Gadget HeavyGadget
+    {
+        get
         {
-            get
+            if (Gadgets.TryFind(HeavyGadgetName, out var gadget))
-            {
+                return gadget;
-                if (Weapons.TryFind(ToolName, out var weapon))
+            return null;
-                    return weapon;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.ToolName = "none";
-                else
-                    this.ToolName = value.Name;
-            }
         }
-        public Attachment MainSight
+        set
         {
-            get
+            if (value == null)
-            {
+                HeavyGadgetName = "none";
-                if (Attachments.TryFind(MainSightName, out var attachment))
+            else
-                    return attachment;
+                HeavyGadgetName = value.Name;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.MainSightName = "none";
-                else
-                    this.MainSightName = value.Name;
-            }
-        }
-        public Attachment TopSight
-        {
-            get
-            {
-                if (Attachments.TryFind(TopSightName, out var attachment))
-                    return attachment;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.TopSightName = "none";
-                else
-                    this.TopSightName = value.Name;
-            }
-        }
-        public Attachment CantedSight
-        {
-            get
-            {
-                if (Attachments.TryFind(CantedSightName, out var attachment))
-                    return attachment;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.CantedSightName = "none";
-                else
-                    this.CantedSightName = value.Name;
-            }
-        }
-        public Attachment Barrel
-        {
-            get
-            {
-                if (Attachments.TryFind(BarrelName, out var attachment))
-                    return attachment;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.BarrelName = "none";
-                else
-                    this.BarrelName = value.Name;
-            }
-        }
-        public Attachment SideRail
-        {
-            get
-            {
-                if (Attachments.TryFind(SideRailName, out var attachment))
-                    return attachment;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.SideRailName = "none";
-                else
-                    this.SideRailName = value.Name;
-            }
-        }
-        public Attachment UnderRail
-        {
-            get
-            {
-                if (Attachments.TryFind(UnderRailName, out var attachment))
-                    return attachment;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.UnderRailName = "none";
-                else
-                    this.UnderRailName = value.Name;
-            }
-        }
-        public Attachment BoltAction
-        {
-            get
-            {
-                if (Attachments.TryFind(BoltActionName, out var attachment))
-                    return attachment;
-                return null;
-            }
-            set
-            {
-                if (value == null)
-                    this.BoltActionName = "none";
-                else
-                    this.BoltActionName = value.Name;
-            }
         }
+    }
 
-        public bool HasAttachment(Attachment attachment)
+    public Gadget Throwable
+    {
+        get
         {
-            switch (attachment.AttachmentType)
+            if (Gadgets.TryFind(ThrowableName, out var gadget))
-            {
+                return gadget;
-                case AttachmentType.MainSight:
+            return null;
-                    return this.MainSight == attachment;
-                case AttachmentType.TopSight:
-                    return this.TopSight == attachment;
-                case AttachmentType.CantedSight:
-                    return this.CantedSight == attachment;
-                case AttachmentType.Barrel:
-                    return this.Barrel == attachment;
-                case AttachmentType.UnderRail:
-                    return this.Barrel == attachment;
-                case AttachmentType.SideRail:
-                    return this.SideRail == attachment;
-                case AttachmentType.Bolt:
-                    return this.BoltAction == attachment;
-            }
-            return false;
         }
-        public void SetAttachment(Attachment attachment)
+        set
         {
-            switch (attachment.AttachmentType)
+            if (value == null)
-            {
+                ThrowableName = "none";
-                case AttachmentType.MainSight:
+            else
-                    this.MainSight = attachment;
+                ThrowableName = value.Name;
-                    break;
-                case AttachmentType.TopSight:
-                    this.TopSight = attachment;
-                    break;
-                case AttachmentType.CantedSight:
-                    this.CantedSight = attachment;
-                    break;
-                case AttachmentType.Barrel:
-                    this.Barrel = attachment;
-                    break;
-                case AttachmentType.UnderRail:
-                    this.Barrel = attachment;
-                    break;
-                case AttachmentType.SideRail:
-                    this.SideRail = attachment;
-                    break;
-                case AttachmentType.Bolt:
-                    this.BoltAction = attachment;
-                    break;
-            }
         }
+    }
 
-        public void Write(Common.Serialization.Stream ser)
+    public bool HasGadget(Gadget gadget)
-        {
+    {
-            ser.WriteStringItem(this.ToolName);
+        if (FirstAid == gadget)
-            ser.WriteStringItem(this.MainSightName);
+            return true;
-            ser.WriteStringItem(this.TopSightName);
+        if (LightGadget == gadget)
-            ser.WriteStringItem(this.CantedSightName);
+            return true;
-            ser.WriteStringItem(this.BarrelName);
+        if (HeavyGadget == gadget)
-            ser.WriteStringItem(this.SideRailName);
+            return true;
-            ser.WriteStringItem(this.UnderRailName);
+        if (Throwable == gadget)
-            ser.WriteStringItem(this.BoltActionName);
+            return true;
-            ser.Write(this.SkinIndex);
+        return false;
-            ser.Write(this.MagazineIndex);
+    }
-        }
+
-        public void Read(Common.Serialization.Stream ser)
+    public void Write(Stream ser)
-        {
+    {
-            ser.TryReadString(out this.ToolName);
+        PrimaryWeapon.Write(ser);
-            ser.TryReadString(out this.MainSightName);
+        SecondaryWeapon.Write(ser);
-            ser.TryReadString(out this.TopSightName);
+        ser.WriteStringItem(FirstAidName);
-            ser.TryReadString(out this.CantedSightName);
+        ser.WriteStringItem(LightGadgetName);
-            ser.TryReadString(out this.BarrelName);
+        ser.WriteStringItem(HeavyGadgetName);
-            ser.TryReadString(out this.SideRailName);
+        ser.WriteStringItem(ThrowableName);
-            ser.TryReadString(out this.UnderRailName);
+
-            ser.TryReadString(out this.BoltActionName);
+        ser.Write(PrimaryExtraMagazines);
-            this.SkinIndex = ser.ReadInt8();
+        ser.Write(SecondaryExtraMagazines);
-            this.MagazineIndex = ser.ReadInt8();
+        ser.Write(FirstAidExtra);
-        }
+        ser.Write(LightGadgetExtra);
+        ser.Write(HeavyGadgetExtra);
+        ser.Write(ThrowableExtra);
+    }
+
+    public void Read(Stream ser)
+    {
+        PrimaryWeapon.Read(ser);
+        SecondaryWeapon.Read(ser);
+        ser.TryReadString(out FirstAidName);
+        ser.TryReadString(out LightGadgetName);
+        ser.TryReadString(out HeavyGadgetName);
+        ser.TryReadString(out ThrowableName);
+
+        PrimaryExtraMagazines = ser.ReadInt8();
+        SecondaryExtraMagazines = ser.ReadInt8();
+        FirstAidExtra = ser.ReadInt8();
+        LightGadgetExtra = ser.ReadInt8();
+        HeavyGadgetExtra = ser.ReadInt8();
+        ThrowableExtra = ser.ReadInt8();
     }
 }
+
+public struct WeaponItem
+{
+    public string ToolName;
+    public string MainSightName;
+    public string TopSightName;
+    public string CantedSightName;
+    public string BarrelName;
+    public string SideRailName;
+    public string UnderRailName;
+    public string BoltActionName;
+    public byte SkinIndex;
+    public byte MagazineIndex;
+
+    public Weapon Tool
+    {
+        get
+        {
+            if (Weapons.TryFind(ToolName, out var weapon))
+                return weapon;
+            return null;
+        }
+        set
+        {
+            if (value == null)
+                ToolName = "none";
+            else
+                ToolName = value.Name;
+        }
+    }
+
+    public Attachment MainSight
+    {
+        get
+        {
+            if (Attachments.TryFind(MainSightName, out var attachment))
+                return attachment;
+            return null;
+        }
+        set
+        {
+            if (value == null)
+                MainSightName = "none";
+            else
+                MainSightName = value.Name;
+        }
+    }
+
+    public Attachment TopSight
+    {
+        get
+        {
+            if (Attachments.TryFind(TopSightName, out var attachment))
+                return attachment;
+            return null;
+        }
+        set
+        {
+            if (value == null)
+                TopSightName = "none";
+            else
+                TopSightName = value.Name;
+        }
+    }
+
+    public Attachment CantedSight
+    {
+        get
+        {
+            if (Attachments.TryFind(CantedSightName, out var attachment))
+                return attachment;
+            return null;
+        }
+        set
+        {
+            if (value == null)
+                CantedSightName = "none";
+            else
+                CantedSightName = value.Name;
+        }
+    }
+
+    public Attachment Barrel
+    {
+        get
+        {
+            if (Attachments.TryFind(BarrelName, out var attachment))
+                return attachment;
+            return null;
+        }
+        set
+        {
+            if (value == null)
+                BarrelName = "none";
+            else
+                BarrelName = value.Name;
+        }
+    }
+
+    public Attachment SideRail
+    {
+        get
+        {
+            if (Attachments.TryFind(SideRailName, out var attachment))
+                return attachment;
+            return null;
+        }
+        set
+        {
+            if (value == null)
+                SideRailName = "none";
+            else
+                SideRailName = value.Name;
+        }
+    }
+
+    public Attachment UnderRail
+    {
+        get
+        {
+            if (Attachments.TryFind(UnderRailName, out var attachment))
+                return attachment;
+            return null;
+        }
+        set
+        {
+            if (value == null)
+                UnderRailName = "none";
+            else
+                UnderRailName = value.Name;
+        }
+    }
+
+    public Attachment BoltAction
+    {
+        get
+        {
+            if (Attachments.TryFind(BoltActionName, out var attachment))
+                return attachment;
+            return null;
+        }
+        set
+        {
+            if (value == null)
+                BoltActionName = "none";
+            else
+                BoltActionName = value.Name;
+        }
+    }
+
+    public bool HasAttachment(Attachment attachment)
+    {
+        switch (attachment.AttachmentType)
+        {
+            case AttachmentType.MainSight:
+                return MainSight == attachment;
+            case AttachmentType.TopSight:
+                return TopSight == attachment;
+            case AttachmentType.CantedSight:
+                return CantedSight == attachment;
+            case AttachmentType.Barrel:
+                return Barrel == attachment;
+            case AttachmentType.UnderRail:
+                return Barrel == attachment;
+            case AttachmentType.SideRail:
+                return SideRail == attachment;
+            case AttachmentType.Bolt:
+                return BoltAction == attachment;
+        }
+
+        return false;
+    }
+
+    public void SetAttachment(Attachment attachment)
+    {
+        switch (attachment.AttachmentType)
+        {
+            case AttachmentType.MainSight:
+                MainSight = attachment;
+                break;
+            case AttachmentType.TopSight:
+                TopSight = attachment;
+                break;
+            case AttachmentType.CantedSight:
+                CantedSight = attachment;
+                break;
+            case AttachmentType.Barrel:
+                Barrel = attachment;
+                break;
+            case AttachmentType.UnderRail:
+                Barrel = attachment;
+                break;
+            case AttachmentType.SideRail:
+                SideRail = attachment;
+                break;
+            case AttachmentType.Bolt:
+                BoltAction = attachment;
+                break;
+        }
+    }
+
+    public void Write(Stream ser)
+    {
+        ser.WriteStringItem(ToolName);
+        ser.WriteStringItem(MainSightName);
+        ser.WriteStringItem(TopSightName);
+        ser.WriteStringItem(CantedSightName);
+        ser.WriteStringItem(BarrelName);
+        ser.WriteStringItem(SideRailName);
+        ser.WriteStringItem(UnderRailName);
+        ser.WriteStringItem(BoltActionName);
+        ser.Write(SkinIndex);
+        ser.Write(MagazineIndex);
+    }
+
+    public void Read(Stream ser)
+    {
+        ser.TryReadString(out ToolName);
+        ser.TryReadString(out MainSightName);
+        ser.TryReadString(out TopSightName);
+        ser.TryReadString(out CantedSightName);
+        ser.TryReadString(out BarrelName);
+        ser.TryReadString(out SideRailName);
+        ser.TryReadString(out UnderRailName);
+        ser.TryReadString(out BoltActionName);
+        SkinIndex = ser.ReadInt8();
+        MagazineIndex = ser.ReadInt8();
+    }
+}

BattleBitAPI/Common/Data/PlayerStats.cs

@@ -1,326 +1,342 @@
-namespace BattleBitAPI.Common
+using Stream = BattleBitAPI.Common.Serialization.Stream;
+
+namespace BattleBitAPI.Common;
+
+public class PlayerStats
 {
-    public class PlayerStats
+    public byte[] Achievements;
+
+    public bool IsBanned;
+    public PlayerProgess Progress = new();
+    public Roles Roles;
+    public byte[] Selections;
+    public byte[] ToolProgress;
+
+    public PlayerStats()
     {
-        public PlayerStats() { }
+    }
-        public PlayerStats(byte[] data) { Load(data); }
 
-        public bool IsBanned;
+    public PlayerStats(byte[] data)
-        public Roles Roles;
+    {
-        public PlayerProgess Progress = new PlayerProgess();
+        Load(data);
-        public byte[] ToolProgress;
+    }
-        public byte[] Achievements;
-        public byte[] Selections;
 
-        public void Write(Common.Serialization.Stream ser)
+    public void Write(Stream ser)
+    {
+        ser.Write(IsBanned);
+        ser.Write((ulong)Roles);
+
+        Progress.Write(ser);
+
+        if (ToolProgress != null)
         {
-            ser.Write(this.IsBanned);
+            ser.Write((ushort)ToolProgress.Length);
-            ser.Write((ulong)this.Roles);
+            ser.Write(ToolProgress, 0, ToolProgress.Length);
-
-            Progress.Write(ser);
-
-            if (ToolProgress != null)
-            {
-                ser.Write((ushort)ToolProgress.Length);
-                ser.Write(ToolProgress, 0, ToolProgress.Length);
-            }
-            else
-            {
-                ser.Write((ushort)0);
-            }
-
-            if (Achievements != null)
-            {
-                ser.Write((ushort)Achievements.Length);
-                ser.Write(Achievements, 0, Achievements.Length);
-            }
-            else
-            {
-                ser.Write((ushort)0);
-            }
-
-            if (Selections != null)
-            {
-                ser.Write((ushort)Selections.Length);
-                ser.Write(Selections, 0, Selections.Length);
-            }
-            else
-            {
-                ser.Write((ushort)0);
-            }
         }
-        public void Read(Common.Serialization.Stream ser)
+        else
         {
-            this.IsBanned = ser.ReadBool();
+            ser.Write((ushort)0);
-            this.Roles = (Roles)ser.ReadUInt64();
-
-            this.Progress.Read(ser);
-
-            int size = ser.ReadInt16();
-            this.ToolProgress = ser.ReadByteArray(size);
-
-            size = ser.ReadInt16();
-            this.Achievements = ser.ReadByteArray(size);
-
-            size = ser.ReadInt16();
-            this.Selections = ser.ReadByteArray(size);
         }
 
-        public byte[] SerializeToByteArray()
+        if (Achievements != null)
         {
-            using (var ser = Common.Serialization.Stream.Get())
+            ser.Write((ushort)Achievements.Length);
-            {
+            ser.Write(Achievements, 0, Achievements.Length);
-                Write(ser);
-                return ser.AsByteArrayData();
-            }
         }
-        public void Load(byte[] data)
+        else
         {
-            var ser = new Common.Serialization.Stream()
+            ser.Write((ushort)0);
-            {
-                Buffer = data,
-                InPool = false,
-                ReadPosition = 0,
-                WritePosition = data.Length,
-            };
-            Read(ser);
         }
 
-        public class PlayerProgess
+        if (Selections != null)
         {
-            private const uint ParamCount = 42;
+            ser.Write((ushort)Selections.Length);
-
+            ser.Write(Selections, 0, Selections.Length);
-            public uint KillCount;
+        }
-            public uint LeaderKills;
+        else
-            public uint AssaultKills;
+        {
-            public uint MedicKills;
+            ser.Write((ushort)0);
-            public uint EngineerKills;
-            public uint SupportKills;
-            public uint ReconKills;
-            public uint DeathCount;
-            public uint WinCount;
-            public uint LoseCount;
-            public uint FriendlyShots;
-            public uint FriendlyKills;
-            public uint Revived;
-            public uint RevivedTeamMates;
-            public uint Assists;
-            public uint Prestige;
-            public uint Rank;
-            public uint EXP;
-            public uint ShotsFired;
-            public uint ShotsHit;
-            public uint Headshots;
-            public uint ObjectivesComplated;
-            public uint HealedHPs;
-            public uint RoadKills;
-            public uint Suicides;
-            public uint VehiclesDestroyed;
-            public uint VehicleHPRepaired;
-            public uint LongestKill;
-            public uint PlayTimeSeconds;
-            public uint LeaderPlayTime;
-            public uint AssaultPlayTime;
-            public uint MedicPlayTime;
-            public uint EngineerPlayTime;
-            public uint SupportPlayTime;
-            public uint ReconPlayTime;
-            public uint LeaderScore;
-            public uint AssaultScore;
-            public uint MedicScore;
-            public uint EngineerScore;
-            public uint SupportScore;
-            public uint ReconScore;
-            public uint TotalScore;
-
-            public void Write(Common.Serialization.Stream ser)
-            {
-                ser.Write(ParamCount);
-                {
-                    ser.Write(KillCount);
-                    ser.Write(LeaderKills);
-                    ser.Write(AssaultKills);
-                    ser.Write(MedicKills);
-                    ser.Write(EngineerKills);
-                    ser.Write(SupportKills);
-                    ser.Write(ReconKills);
-                    ser.Write(DeathCount);
-                    ser.Write(WinCount);
-                    ser.Write(LoseCount);
-                    ser.Write(FriendlyShots);
-                    ser.Write(FriendlyKills);
-                    ser.Write(Revived);
-                    ser.Write(RevivedTeamMates);
-                    ser.Write(Assists);
-                    ser.Write(Prestige);
-                    ser.Write(Rank);
-                    ser.Write(EXP);
-                    ser.Write(ShotsFired);
-                    ser.Write(ShotsHit);
-                    ser.Write(Headshots);
-                    ser.Write(ObjectivesComplated);
-                    ser.Write(HealedHPs);
-                    ser.Write(RoadKills);
-                    ser.Write(Suicides);
-                    ser.Write(VehiclesDestroyed);
-                    ser.Write(VehicleHPRepaired);
-                    ser.Write(LongestKill);
-                    ser.Write(PlayTimeSeconds);
-                    ser.Write(LeaderPlayTime);
-                    ser.Write(AssaultPlayTime);
-                    ser.Write(MedicPlayTime);
-                    ser.Write(EngineerPlayTime);
-                    ser.Write(SupportPlayTime);
-                    ser.Write(ReconPlayTime);
-                    ser.Write(LeaderScore);
-                    ser.Write(AssaultScore);
-                    ser.Write(MedicScore);
-                    ser.Write(EngineerScore);
-                    ser.Write(SupportScore);
-                    ser.Write(ReconScore);
-                    ser.Write(TotalScore);
-                }
-            }
-            public void Read(Common.Serialization.Stream ser)
-            {
-                Reset();
-
-                uint mParamCount = ser.ReadUInt32();
-                int maxReadPosition = ser.ReadPosition + (int)(mParamCount * 4);
-                {
-                    bool canRead() => ser.ReadPosition < maxReadPosition;
-                    if (canRead())
-                        this.KillCount = ser.ReadUInt32();
-                    if (canRead())
-                        this.LeaderKills = ser.ReadUInt32();
-                    if (canRead())
-                        this.AssaultKills = ser.ReadUInt32();
-                    if (canRead())
-                        this.MedicKills = ser.ReadUInt32();
-                    if (canRead())
-                        this.EngineerKills = ser.ReadUInt32();
-                    if (canRead())
-                        this.SupportKills = ser.ReadUInt32();
-                    if (canRead())
-                        this.ReconKills = ser.ReadUInt32();
-                    if (canRead())
-                        this.DeathCount = ser.ReadUInt32();
-                    if (canRead())
-                        this.WinCount = ser.ReadUInt32();
-                    if (canRead())
-                        this.LoseCount = ser.ReadUInt32();
-                    if (canRead())
-                        this.FriendlyShots = ser.ReadUInt32();
-                    if (canRead())
-                        this.FriendlyKills = ser.ReadUInt32();
-                    if (canRead())
-                        this.Revived = ser.ReadUInt32();
-                    if (canRead())
-                        this.RevivedTeamMates = ser.ReadUInt32();
-                    if (canRead())
-                        this.Assists = ser.ReadUInt32();
-                    if (canRead())
-                        this.Prestige = ser.ReadUInt32();
-                    if (canRead())
-                        this.Rank = ser.ReadUInt32();
-                    if (canRead())
-                        this.EXP = ser.ReadUInt32();
-                    if (canRead())
-                        this.ShotsFired = ser.ReadUInt32();
-                    if (canRead())
-                        this.ShotsHit = ser.ReadUInt32();
-                    if (canRead())
-                        this.Headshots = ser.ReadUInt32();
-                    if (canRead())
-                        this.ObjectivesComplated = ser.ReadUInt32();
-                    if (canRead())
-                        this.HealedHPs = ser.ReadUInt32();
-                    if (canRead())
-                        this.RoadKills = ser.ReadUInt32();
-                    if (canRead())
-                        this.Suicides = ser.ReadUInt32();
-                    if (canRead())
-                        this.VehiclesDestroyed = ser.ReadUInt32();
-                    if (canRead())
-                        this.VehicleHPRepaired = ser.ReadUInt32();
-                    if (canRead())
-                        this.LongestKill = ser.ReadUInt32();
-                    if (canRead())
-                        this.PlayTimeSeconds = ser.ReadUInt32();
-                    if (canRead())
-                        this.LeaderPlayTime = ser.ReadUInt32();
-                    if (canRead())
-                        this.AssaultPlayTime = ser.ReadUInt32();
-                    if (canRead())
-                        this.MedicPlayTime = ser.ReadUInt32();
-                    if (canRead())
-                        this.EngineerPlayTime = ser.ReadUInt32();
-                    if (canRead())
-                        this.SupportPlayTime = ser.ReadUInt32();
-                    if (canRead())
-                        this.ReconPlayTime = ser.ReadUInt32();
-                    if (canRead())
-                        this.LeaderScore = ser.ReadUInt32();
-                    if (canRead())
-                        this.AssaultScore = ser.ReadUInt32();
-                    if (canRead())
-                        this.MedicScore = ser.ReadUInt32();
-                    if (canRead())
-                        this.EngineerScore = ser.ReadUInt32();
-                    if (canRead())
-                        this.SupportScore = ser.ReadUInt32();
-                    if (canRead())
-                        this.ReconScore = ser.ReadUInt32();
-                    if (canRead())
-                        this.TotalScore = ser.ReadUInt32();
-                }
-                ser.ReadPosition = maxReadPosition;
-            }
-            public void Reset()
-            {
-                KillCount = 0;
-                LeaderKills = 0;
-                AssaultKills = 0;
-                MedicKills = 0;
-                EngineerKills = 0;
-                SupportKills = 0;
-                ReconKills = 0;
-                DeathCount = 0;
-                WinCount = 0;
-                LoseCount = 0;
-                FriendlyShots = 0;
-                FriendlyKills = 0;
-                Revived = 0;
-                RevivedTeamMates = 0;
-                Assists = 0;
-                Prestige = 0;
-                Rank = 0;
-                EXP = 0;
-                ShotsFired = 0;
-                ShotsHit = 0;
-                Headshots = 0;
-                ObjectivesComplated = 0;
-                HealedHPs = 0;
-                RoadKills = 0;
-                Suicides = 0;
-                VehiclesDestroyed = 0;
-                VehicleHPRepaired = 0;
-                LongestKill = 0;
-                PlayTimeSeconds = 0;
-                LeaderPlayTime = 0;
-                AssaultPlayTime = 0;
-                MedicPlayTime = 0;
-                EngineerPlayTime = 0;
-                SupportPlayTime = 0;
-                ReconPlayTime = 0;
-                LeaderScore = 0;
-                AssaultScore = 0;
-                MedicScore = 0;
-                EngineerScore = 0;
-                SupportScore = 0;
-                ReconScore = 0;
-                TotalScore = 0;
-            }
         }
     }
-}
+
+    public void Read(Stream ser)
+    {
+        IsBanned = ser.ReadBool();
+        Roles = (Roles)ser.ReadUInt64();
+
+        Progress.Read(ser);
+
+        int size = ser.ReadInt16();
+        ToolProgress = ser.ReadByteArray(size);
+
+        size = ser.ReadInt16();
+        Achievements = ser.ReadByteArray(size);
+
+        size = ser.ReadInt16();
+        Selections = ser.ReadByteArray(size);
+    }
+
+    public byte[] SerializeToByteArray()
+    {
+        using (var ser = Stream.Get())
+        {
+            Write(ser);
+            return ser.AsByteArrayData();
+        }
+    }
+
+    public void Load(byte[] data)
+    {
+        var ser = new Stream
+        {
+            Buffer = data,
+            InPool = false,
+            ReadPosition = 0,
+            WritePosition = data.Length
+        };
+        Read(ser);
+    }
+
+    public class PlayerProgess
+    {
+        private const uint ParamCount = 42;
+        public uint AssaultKills;
+        public uint AssaultPlayTime;
+        public uint AssaultScore;
+        public uint Assists;
+        public uint DeathCount;
+        public uint EngineerKills;
+        public uint EngineerPlayTime;
+        public uint EngineerScore;
+        public uint EXP;
+        public uint FriendlyKills;
+        public uint FriendlyShots;
+        public uint Headshots;
+        public uint HealedHPs;
+
+        public uint KillCount;
+        public uint LeaderKills;
+        public uint LeaderPlayTime;
+        public uint LeaderScore;
+        public uint LongestKill;
+        public uint LoseCount;
+        public uint MedicKills;
+        public uint MedicPlayTime;
+        public uint MedicScore;
+        public uint ObjectivesComplated;
+        public uint PlayTimeSeconds;
+        public uint Prestige;
+        public uint Rank;
+        public uint ReconKills;
+        public uint ReconPlayTime;
+        public uint ReconScore;
+        public uint Revived;
+        public uint RevivedTeamMates;
+        public uint RoadKills;
+        public uint ShotsFired;
+        public uint ShotsHit;
+        public uint Suicides;
+        public uint SupportKills;
+        public uint SupportPlayTime;
+        public uint SupportScore;
+        public uint TotalScore;
+        public uint VehicleHPRepaired;
+        public uint VehiclesDestroyed;
+        public uint WinCount;
+
+        public void Write(Stream ser)
+        {
+            ser.Write(ParamCount);
+            {
+                ser.Write(KillCount);
+                ser.Write(LeaderKills);
+                ser.Write(AssaultKills);
+                ser.Write(MedicKills);
+                ser.Write(EngineerKills);
+                ser.Write(SupportKills);
+                ser.Write(ReconKills);
+                ser.Write(DeathCount);
+                ser.Write(WinCount);
+                ser.Write(LoseCount);
+                ser.Write(FriendlyShots);
+                ser.Write(FriendlyKills);
+                ser.Write(Revived);
+                ser.Write(RevivedTeamMates);
+                ser.Write(Assists);
+                ser.Write(Prestige);
+                ser.Write(Rank);
+                ser.Write(EXP);
+                ser.Write(ShotsFired);
+                ser.Write(ShotsHit);
+                ser.Write(Headshots);
+                ser.Write(ObjectivesComplated);
+                ser.Write(HealedHPs);
+                ser.Write(RoadKills);
+                ser.Write(Suicides);
+                ser.Write(VehiclesDestroyed);
+                ser.Write(VehicleHPRepaired);
+                ser.Write(LongestKill);
+                ser.Write(PlayTimeSeconds);
+                ser.Write(LeaderPlayTime);
+                ser.Write(AssaultPlayTime);
+                ser.Write(MedicPlayTime);
+                ser.Write(EngineerPlayTime);
+                ser.Write(SupportPlayTime);
+                ser.Write(ReconPlayTime);
+                ser.Write(LeaderScore);
+                ser.Write(AssaultScore);
+                ser.Write(MedicScore);
+                ser.Write(EngineerScore);
+                ser.Write(SupportScore);
+                ser.Write(ReconScore);
+                ser.Write(TotalScore);
+            }
+        }
+
+        public void Read(Stream ser)
+        {
+            Reset();
+
+            var mParamCount = ser.ReadUInt32();
+            var maxReadPosition = ser.ReadPosition + (int)(mParamCount * 4);
+            {
+                bool canRead()
+                {
+                    return ser.ReadPosition < maxReadPosition;
+                }
+
+                if (canRead())
+                    KillCount = ser.ReadUInt32();
+                if (canRead())
+                    LeaderKills = ser.ReadUInt32();
+                if (canRead())
+                    AssaultKills = ser.ReadUInt32();
+                if (canRead())
+                    MedicKills = ser.ReadUInt32();
+                if (canRead())
+                    EngineerKills = ser.ReadUInt32();
+                if (canRead())
+                    SupportKills = ser.ReadUInt32();
+                if (canRead())
+                    ReconKills = ser.ReadUInt32();
+                if (canRead())
+                    DeathCount = ser.ReadUInt32();
+                if (canRead())
+                    WinCount = ser.ReadUInt32();
+                if (canRead())
+                    LoseCount = ser.ReadUInt32();
+                if (canRead())
+                    FriendlyShots = ser.ReadUInt32();
+                if (canRead())
+                    FriendlyKills = ser.ReadUInt32();
+                if (canRead())
+                    Revived = ser.ReadUInt32();
+                if (canRead())
+                    RevivedTeamMates = ser.ReadUInt32();
+                if (canRead())
+                    Assists = ser.ReadUInt32();
+                if (canRead())
+                    Prestige = ser.ReadUInt32();
+                if (canRead())
+                    Rank = ser.ReadUInt32();
+                if (canRead())
+                    EXP = ser.ReadUInt32();
+                if (canRead())
+                    ShotsFired = ser.ReadUInt32();
+                if (canRead())
+                    ShotsHit = ser.ReadUInt32();
+                if (canRead())
+                    Headshots = ser.ReadUInt32();
+                if (canRead())
+                    ObjectivesComplated = ser.ReadUInt32();
+                if (canRead())
+                    HealedHPs = ser.ReadUInt32();
+                if (canRead())
+                    RoadKills = ser.ReadUInt32();
+                if (canRead())
+                    Suicides = ser.ReadUInt32();
+                if (canRead())
+                    VehiclesDestroyed = ser.ReadUInt32();
+                if (canRead())
+                    VehicleHPRepaired = ser.ReadUInt32();
+                if (canRead())
+                    LongestKill = ser.ReadUInt32();
+                if (canRead())
+                    PlayTimeSeconds = ser.ReadUInt32();
+                if (canRead())
+                    LeaderPlayTime = ser.ReadUInt32();
+                if (canRead())
+                    AssaultPlayTime = ser.ReadUInt32();
+                if (canRead())
+                    MedicPlayTime = ser.ReadUInt32();
+                if (canRead())
+                    EngineerPlayTime = ser.ReadUInt32();
+                if (canRead())
+                    SupportPlayTime = ser.ReadUInt32();
+                if (canRead())
+                    ReconPlayTime = ser.ReadUInt32();
+                if (canRead())
+                    LeaderScore = ser.ReadUInt32();
+                if (canRead())
+                    AssaultScore = ser.ReadUInt32();
+                if (canRead())
+                    MedicScore = ser.ReadUInt32();
+                if (canRead())
+                    EngineerScore = ser.ReadUInt32();
+                if (canRead())
+                    SupportScore = ser.ReadUInt32();
+                if (canRead())
+                    ReconScore = ser.ReadUInt32();
+                if (canRead())
+                    TotalScore = ser.ReadUInt32();
+            }
+            ser.ReadPosition = maxReadPosition;
+        }
+
+        public void Reset()
+        {
+            KillCount = 0;
+            LeaderKills = 0;
+            AssaultKills = 0;
+            MedicKills = 0;
+            EngineerKills = 0;
+            SupportKills = 0;
+            ReconKills = 0;
+            DeathCount = 0;
+            WinCount = 0;
+            LoseCount = 0;
+            FriendlyShots = 0;
+            FriendlyKills = 0;
+            Revived = 0;
+            RevivedTeamMates = 0;
+            Assists = 0;
+            Prestige = 0;
+            Rank = 0;
+            EXP = 0;
+            ShotsFired = 0;
+            ShotsHit = 0;
+            Headshots = 0;
+            ObjectivesComplated = 0;
+            HealedHPs = 0;
+            RoadKills = 0;
+            Suicides = 0;
+            VehiclesDestroyed = 0;
+            VehicleHPRepaired = 0;
+            LongestKill = 0;
+            PlayTimeSeconds = 0;
+            LeaderPlayTime = 0;
+            AssaultPlayTime = 0;
+            MedicPlayTime = 0;
+            EngineerPlayTime = 0;
+            SupportPlayTime = 0;
+            ReconPlayTime = 0;
+            LeaderScore = 0;
+            AssaultScore = 0;
+            MedicScore = 0;
+            EngineerScore = 0;
+            SupportScore = 0;
+            ReconScore = 0;
+            TotalScore = 0;
+        }
+    }
+}

BattleBitAPI/Common/Data/PlayerWearings.cs

@@ -1,43 +1,45 @@
-namespace BattleBitAPI.Common
+using Stream = BattleBitAPI.Common.Serialization.Stream;
-{
-    public struct PlayerWearings
-    {
-        public string Head;
-        public string Chest;
-        public string Belt;
-        public string Backbag;
-        public string Eye;
-        public string Face;
-        public string Hair;
-        public string Skin;
-        public string Uniform;
-        public string Camo;
 
-        public void Write(Common.Serialization.Stream ser)
+namespace BattleBitAPI.Common;
-        {
+
-            ser.WriteStringItem(this.Head);
+public struct PlayerWearings
-            ser.WriteStringItem(this.Chest);
+{
-            ser.WriteStringItem(this.Belt);
+    public string Head;
-            ser.WriteStringItem(this.Backbag);
+    public string Chest;
-            ser.WriteStringItem(this.Eye);
+    public string Belt;
-            ser.WriteStringItem(this.Face);
+    public string Backbag;
-            ser.WriteStringItem(this.Hair);
+    public string Eye;
-            ser.WriteStringItem(this.Skin);
+    public string Face;
-            ser.WriteStringItem(this.Uniform);
+    public string Hair;
-            ser.WriteStringItem(this.Camo);
+    public string Skin;
-        }
+    public string Uniform;
-        public void Read(Common.Serialization.Stream ser)
+    public string Camo;
-        {
+
-            ser.TryReadString(out this.Head);
+    public void Write(Stream ser)
-            ser.TryReadString(out this.Chest);
+    {
-            ser.TryReadString(out this.Belt);
+        ser.WriteStringItem(Head);
-            ser.TryReadString(out this.Backbag);
+        ser.WriteStringItem(Chest);
-            ser.TryReadString(out this.Eye);
+        ser.WriteStringItem(Belt);
-            ser.TryReadString(out this.Face);
+        ser.WriteStringItem(Backbag);
-            ser.TryReadString(out this.Hair);
+        ser.WriteStringItem(Eye);
-            ser.TryReadString(out this.Skin);
+        ser.WriteStringItem(Face);
-            ser.TryReadString(out this.Uniform);
+        ser.WriteStringItem(Hair);
-            ser.TryReadString(out this.Camo);
+        ser.WriteStringItem(Skin);
-        }
+        ser.WriteStringItem(Uniform);
+        ser.WriteStringItem(Camo);
     }
-}
+
+    public void Read(Stream ser)
+    {
+        ser.TryReadString(out Head);
+        ser.TryReadString(out Chest);
+        ser.TryReadString(out Belt);
+        ser.TryReadString(out Backbag);
+        ser.TryReadString(out Eye);
+        ser.TryReadString(out Face);
+        ser.TryReadString(out Hair);
+        ser.TryReadString(out Skin);
+        ser.TryReadString(out Uniform);
+        ser.TryReadString(out Camo);
+    }
+}

BattleBitAPI/Common/Data/Weapon.cs

@@ -1,73 +1,76 @@
-using System;
+namespace BattleBitAPI.Common;
 
-namespace BattleBitAPI.Common
+public class Weapon : IEquatable<string>, IEquatable<Weapon>
 {
-    public class Weapon : IEquatable<string>, IEquatable<Weapon>
+    public Weapon(string name, WeaponType weaponType)
     {
-        public string Name { get; private set; }
+        Name = name;
-        public WeaponType WeaponType { get; private set; }
+        WeaponType = weaponType;
-        public Weapon(string name, WeaponType weaponType)
+    }
-        {
-            Name = name;
-            WeaponType = weaponType;
-        }
 
-        public override string ToString()
+    public string Name { get; }
-        {
+    public WeaponType WeaponType { get; private set; }
-            return this.Name;
-        }
-        public bool Equals(string other)
-        {
-            if (other == null)
-                return false;
-            return this.Name.Equals(other);
-        }
-        public bool Equals(Weapon other)
-        {
-            if (other == null)
-                return false;
-            return this.Name.Equals(other.Name);
-        }
 
-        public static bool operator ==(string left, Weapon right)
+    public bool Equals(string other)
-        {
+    {
-            bool leftNull = object.ReferenceEquals(left, null);
+        if (other == null)
-            bool rightNull = object.ReferenceEquals(right, null);
+            return false;
-            if (leftNull && rightNull)
+        return Name.Equals(other);
-                return true;
+    }
-            if (leftNull || rightNull)
+
-                return false;
+    public bool Equals(Weapon other)
-            return right.Name.Equals(left);
+    {
-        }
+        if (other == null)
-        public static bool operator !=(string left, Weapon right)
+            return false;
-        {
+        return Name.Equals(other.Name);
-            bool leftNull = object.ReferenceEquals(left, null);
+    }
-            bool rightNull = object.ReferenceEquals(right, null);
+
-            if (leftNull && rightNull)
+    public override string ToString()
-                return true;
+    {
-            if (leftNull || rightNull)
+        return Name;
-                return false;
+    }
-            return right.Name.Equals(left);
+
-        }
+    public static bool operator ==(string left, Weapon right)
-        public static bool operator ==(Weapon right, string left)
+    {
-        {
+        var leftNull = ReferenceEquals(left, null);
-            bool leftNull = object.ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
-            bool rightNull = object.ReferenceEquals(right, null);
+        if (leftNull && rightNull)
-            if (leftNull && rightNull)
+            return true;
-                return true;
+        if (leftNull || rightNull)
-            if (leftNull || rightNull)
+            return false;
-                return false;
+        return right.Name.Equals(left);
-            return right.Name.Equals(left);
+    }
-        }
+
-        public static bool operator !=(Weapon right, string left)
+    public static bool operator !=(string left, Weapon right)
-        {
+    {
-            bool leftNull = object.ReferenceEquals(left, null);
+        var leftNull = ReferenceEquals(left, null);
-            bool rightNull = object.ReferenceEquals(right, null);
+        var rightNull = ReferenceEquals(right, null);
-            if (leftNull && rightNull)
+        if (leftNull && rightNull)
-                return true;
+            return true;
-            if (leftNull || rightNull)
+        if (leftNull || rightNull)
-                return false;
+            return false;
-            return right.Name.Equals(left);
+        return right.Name.Equals(left);
-        }
+    }
+
+    public static bool operator ==(Weapon right, string left)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
+    }
+
+    public static bool operator !=(Weapon right, string left)
+    {
+        var leftNull = ReferenceEquals(left, null);
+        var rightNull = ReferenceEquals(right, null);
+        if (leftNull && rightNull)
+            return true;
+        if (leftNull || rightNull)
+            return false;
+        return right.Name.Equals(left);
     }
 }

BattleBitAPI/Common/Datasets/Attachments.cs

@@ -1,127 +1,124 @@
 using System.Reflection;
 
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public static class Attachments
 {
-    public static class Attachments
+    // ----- Private Variables ----- 
+    private static readonly Dictionary<string, Attachment> mAttachments;
+
+    // ----- Barrels ----- 
+    public static readonly Attachment Basic = new("Basic", AttachmentType.Barrel);
+    public static readonly Attachment Compensator = new("Compensator", AttachmentType.Barrel);
+    public static readonly Attachment Heavy = new("Heavy", AttachmentType.Barrel);
+    public static readonly Attachment LongBarrel = new("Long_Barrel", AttachmentType.Barrel);
+    public static readonly Attachment MuzzleBreak = new("Muzzle_Break", AttachmentType.Barrel);
+    public static readonly Attachment Ranger = new("Ranger", AttachmentType.Barrel);
+    public static readonly Attachment SuppressorLong = new("Suppressor_Long", AttachmentType.Barrel);
+    public static readonly Attachment SuppressorShort = new("Suppressor_Short", AttachmentType.Barrel);
+    public static readonly Attachment Tactical = new("Tactical", AttachmentType.Barrel);
+    public static readonly Attachment FlashHider = new("Flash_Hider", AttachmentType.Barrel);
+    public static readonly Attachment Osprey9 = new("Osprey_9", AttachmentType.Barrel);
+    public static readonly Attachment DGN308 = new("DGN-308", AttachmentType.Barrel);
+    public static readonly Attachment VAMB762 = new("VAMB-762", AttachmentType.Barrel);
+    public static readonly Attachment SDN6762 = new("SDN-6_762", AttachmentType.Barrel);
+    public static readonly Attachment NT4556 = new("NT-4_556", AttachmentType.Barrel);
+
+    // ----- Canted Sights ----- 
+    public static readonly Attachment Ironsight = new("Ironsight", AttachmentType.CantedSight);
+    public static readonly Attachment CantedRedDot = new("Canted_Red_Dot", AttachmentType.CantedSight);
+    public static readonly Attachment FYouCanted = new("FYou_Canted", AttachmentType.CantedSight);
+    public static readonly Attachment HoloDot = new("Holo_Dot", AttachmentType.CantedSight);
+
+    // ----- Scope ----- 
+    public static readonly Attachment _6xScope = new("6x_Scope", AttachmentType.MainSight);
+    public static readonly Attachment _8xScope = new("8x_Scope", AttachmentType.MainSight);
+    public static readonly Attachment _15xScope = new("15x_Scope", AttachmentType.MainSight);
+    public static readonly Attachment _20xScope = new("20x_Scope", AttachmentType.MainSight);
+    public static readonly Attachment PTR40Hunter = new("PTR-40_Hunter", AttachmentType.MainSight);
+    public static readonly Attachment _1P78 = new("1P78", AttachmentType.MainSight);
+    public static readonly Attachment Acog = new("Acog", AttachmentType.MainSight);
+    public static readonly Attachment M125 = new("M_125", AttachmentType.MainSight);
+    public static readonly Attachment Prisma = new("Prisma", AttachmentType.MainSight);
+    public static readonly Attachment Slip = new("Slip", AttachmentType.MainSight);
+    public static readonly Attachment PistolDeltaSight = new("Pistol_Delta_Sight", AttachmentType.MainSight);
+    public static readonly Attachment PistolRedDot = new("Pistol_Red_Dot", AttachmentType.MainSight);
+    public static readonly Attachment AimComp = new("Aim_Comp", AttachmentType.MainSight);
+    public static readonly Attachment Holographic = new("Holographic", AttachmentType.MainSight);
+    public static readonly Attachment Kobra = new("Kobra", AttachmentType.MainSight);
+    public static readonly Attachment OKP7 = new("OKP7", AttachmentType.MainSight);
+    public static readonly Attachment PKAS = new("PK-AS", AttachmentType.MainSight);
+    public static readonly Attachment RedDot = new("Red_Dot", AttachmentType.MainSight);
+    public static readonly Attachment Reflex = new("Reflex", AttachmentType.MainSight);
+    public static readonly Attachment Strikefire = new("Strikefire", AttachmentType.MainSight);
+    public static readonly Attachment Razor = new("Razor", AttachmentType.MainSight);
+    public static readonly Attachment Flir = new("Flir", AttachmentType.MainSight);
+    public static readonly Attachment Echo = new("Echo", AttachmentType.MainSight);
+    public static readonly Attachment TRI4X32 = new("TRI4X32", AttachmentType.MainSight);
+    public static readonly Attachment FYouSight = new("FYou_Sight", AttachmentType.MainSight);
+    public static readonly Attachment HoloPK120 = new("Holo_PK-120", AttachmentType.MainSight);
+    public static readonly Attachment Pistol8xScope = new("Pistol_8x_Scope", AttachmentType.MainSight);
+    public static readonly Attachment BurrisAR332 = new("BurrisAR332", AttachmentType.MainSight);
+    public static readonly Attachment HS401G5 = new("HS401G5", AttachmentType.MainSight);
+
+    // ----- Top Scope ----- 
+    public static readonly Attachment DeltaSightTop = new("Delta_Sight_Top", AttachmentType.TopSight);
+    public static readonly Attachment RedDotTop = new("Red_Dot_Top", AttachmentType.TopSight);
+    public static readonly Attachment CRedDotTop = new("C_Red_Dot_Top", AttachmentType.TopSight);
+    public static readonly Attachment FYouTop = new("FYou_Top", AttachmentType.TopSight);
+
+    // ----- Under Rails ----- 
+    public static readonly Attachment AngledGrip = new("Angled_Grip", AttachmentType.UnderRail);
+    public static readonly Attachment Bipod = new("Bipod", AttachmentType.UnderRail);
+    public static readonly Attachment VerticalGrip = new("Vertical_Grip", AttachmentType.UnderRail);
+    public static readonly Attachment StubbyGrip = new("Stubby_Grip", AttachmentType.UnderRail);
+    public static readonly Attachment StabilGrip = new("Stabil_Grip", AttachmentType.UnderRail);
+    public static readonly Attachment VerticalSkeletonGrip = new("Vertical_Skeleton_Grip", AttachmentType.UnderRail);
+    public static readonly Attachment FABDTFG = new("FAB-DTFG", AttachmentType.UnderRail);
+    public static readonly Attachment MagpulAngled = new("Magpul_Angled", AttachmentType.UnderRail);
+    public static readonly Attachment BCMGunFighter = new("BCM-Gun_Fighter", AttachmentType.UnderRail);
+    public static readonly Attachment ShiftShortAngledGrip = new("Shift_Short_Angled_Grip", AttachmentType.UnderRail);
+    public static readonly Attachment SE5Grip = new("SE-5_Grip", AttachmentType.UnderRail);
+    public static readonly Attachment RK6Foregrip = new("RK-6_Foregrip", AttachmentType.UnderRail);
+    public static readonly Attachment HeraCQRFront = new("HeraCQR_Front", AttachmentType.UnderRail);
+    public static readonly Attachment B25URK = new("B-25URK", AttachmentType.UnderRail);
+    public static readonly Attachment VTACUVGTacticalGrip = new("VTAC_UVG_TacticalGrip", AttachmentType.UnderRail);
+
+    // ----- Side Rails ----- 
+    public static readonly Attachment Flashlight = new("Flashlight", AttachmentType.SideRail);
+    public static readonly Attachment Rangefinder = new("Rangefinder", AttachmentType.SideRail);
+    public static readonly Attachment Redlaser = new("Redlaser", AttachmentType.SideRail);
+    public static readonly Attachment TacticalFlashlight = new("Tactical_Flashlight", AttachmentType.SideRail);
+    public static readonly Attachment Greenlaser = new("Greenlaser", AttachmentType.SideRail);
+    public static readonly Attachment Searchlight = new("Searchlight", AttachmentType.SideRail);
+
+    // ----- Bolts ----- 
+    public static readonly Attachment BoltActionA = new("Bolt_Action_A", AttachmentType.Bolt);
+    public static readonly Attachment BoltActionB = new("Bolt_Action_B", AttachmentType.Bolt);
+    public static readonly Attachment BoltActionC = new("Bolt_Action_C", AttachmentType.Bolt);
+    public static readonly Attachment BoltActionD = new("Bolt_Action_D", AttachmentType.Bolt);
+    public static readonly Attachment BoltActionE = new("Bolt_Action_E", AttachmentType.Bolt);
+
+    // ----- Init ----- 
+    static Attachments()
     {
-        // ----- Private Variables ----- 
+        var members = typeof(Attachments).GetMembers(BindingFlags.Public | BindingFlags.Static);
-        private static Dictionary<string, Attachment> mAttachments;
+        mAttachments = new Dictionary<string, Attachment>(members.Length);
-
+        foreach (var memberInfo in members)
-        // ----- Barrels ----- 
+            if (memberInfo.MemberType == MemberTypes.Field)
-        public static readonly Attachment Basic = new Attachment("Basic", AttachmentType.Barrel);
-        public static readonly Attachment Compensator = new Attachment("Compensator", AttachmentType.Barrel);
-        public static readonly Attachment Heavy = new Attachment("Heavy", AttachmentType.Barrel);
-        public static readonly Attachment LongBarrel = new Attachment("Long_Barrel", AttachmentType.Barrel);
-        public static readonly Attachment MuzzleBreak = new Attachment("Muzzle_Break", AttachmentType.Barrel);
-        public static readonly Attachment Ranger = new Attachment("Ranger", AttachmentType.Barrel);
-        public static readonly Attachment SuppressorLong = new Attachment("Suppressor_Long", AttachmentType.Barrel);
-        public static readonly Attachment SuppressorShort = new Attachment("Suppressor_Short", AttachmentType.Barrel);
-        public static readonly Attachment Tactical = new Attachment("Tactical", AttachmentType.Barrel);
-        public static readonly Attachment FlashHider = new Attachment("Flash_Hider", AttachmentType.Barrel);
-        public static readonly Attachment Osprey9 = new Attachment("Osprey_9", AttachmentType.Barrel);
-        public static readonly Attachment DGN308 = new Attachment("DGN-308", AttachmentType.Barrel);
-        public static readonly Attachment VAMB762 = new Attachment("VAMB-762", AttachmentType.Barrel);
-        public static readonly Attachment SDN6762 = new Attachment("SDN-6_762", AttachmentType.Barrel);
-        public static readonly Attachment NT4556 = new Attachment("NT-4_556", AttachmentType.Barrel);
-
-        // ----- Canted Sights ----- 
-        public static readonly Attachment Ironsight = new Attachment("Ironsight", AttachmentType.CantedSight);
-        public static readonly Attachment CantedRedDot = new Attachment("Canted_Red_Dot", AttachmentType.CantedSight);
-        public static readonly Attachment FYouCanted = new Attachment("FYou_Canted", AttachmentType.CantedSight);
-        public static readonly Attachment HoloDot = new Attachment("Holo_Dot", AttachmentType.CantedSight);
-
-        // ----- Scope ----- 
-        public static readonly Attachment _6xScope = new Attachment("6x_Scope", AttachmentType.MainSight);
-        public static readonly Attachment _8xScope = new Attachment("8x_Scope", AttachmentType.MainSight);
-        public static readonly Attachment _15xScope = new Attachment("15x_Scope", AttachmentType.MainSight);
-        public static readonly Attachment _20xScope = new Attachment("20x_Scope", AttachmentType.MainSight);
-        public static readonly Attachment PTR40Hunter = new Attachment("PTR-40_Hunter", AttachmentType.MainSight);
-        public static readonly Attachment _1P78 = new Attachment("1P78", AttachmentType.MainSight);
-        public static readonly Attachment Acog = new Attachment("Acog", AttachmentType.MainSight);
-        public static readonly Attachment M125 = new Attachment("M_125", AttachmentType.MainSight);
-        public static readonly Attachment Prisma = new Attachment("Prisma", AttachmentType.MainSight);
-        public static readonly Attachment Slip = new Attachment("Slip", AttachmentType.MainSight);
-        public static readonly Attachment PistolDeltaSight = new Attachment("Pistol_Delta_Sight", AttachmentType.MainSight);
-        public static readonly Attachment PistolRedDot = new Attachment("Pistol_Red_Dot", AttachmentType.MainSight);
-        public static readonly Attachment AimComp = new Attachment("Aim_Comp", AttachmentType.MainSight);
-        public static readonly Attachment Holographic = new Attachment("Holographic", AttachmentType.MainSight);
-        public static readonly Attachment Kobra = new Attachment("Kobra", AttachmentType.MainSight);
-        public static readonly Attachment OKP7 = new Attachment("OKP7", AttachmentType.MainSight);
-        public static readonly Attachment PKAS = new Attachment("PK-AS", AttachmentType.MainSight);
-        public static readonly Attachment RedDot = new Attachment("Red_Dot", AttachmentType.MainSight);
-        public static readonly Attachment Reflex = new Attachment("Reflex", AttachmentType.MainSight);
-        public static readonly Attachment Strikefire = new Attachment("Strikefire", AttachmentType.MainSight);
-        public static readonly Attachment Razor = new Attachment("Razor", AttachmentType.MainSight);
-        public static readonly Attachment Flir = new Attachment("Flir", AttachmentType.MainSight);
-        public static readonly Attachment Echo = new Attachment("Echo", AttachmentType.MainSight);
-        public static readonly Attachment TRI4X32 = new Attachment("TRI4X32", AttachmentType.MainSight);
-        public static readonly Attachment FYouSight = new Attachment("FYou_Sight", AttachmentType.MainSight);
-        public static readonly Attachment HoloPK120 = new Attachment("Holo_PK-120", AttachmentType.MainSight);
-        public static readonly Attachment Pistol8xScope = new Attachment("Pistol_8x_Scope", AttachmentType.MainSight);
-        public static readonly Attachment BurrisAR332 = new Attachment("BurrisAR332", AttachmentType.MainSight);
-        public static readonly Attachment HS401G5 = new Attachment("HS401G5", AttachmentType.MainSight);
-
-        // ----- Top Scope ----- 
-        public static readonly Attachment DeltaSightTop = new Attachment("Delta_Sight_Top", AttachmentType.TopSight);
-        public static readonly Attachment RedDotTop = new Attachment("Red_Dot_Top", AttachmentType.TopSight);
-        public static readonly Attachment CRedDotTop = new Attachment("C_Red_Dot_Top", AttachmentType.TopSight);
-        public static readonly Attachment FYouTop = new Attachment("FYou_Top", AttachmentType.TopSight);
-
-        // ----- Under Rails ----- 
-        public static readonly Attachment AngledGrip = new Attachment("Angled_Grip", AttachmentType.UnderRail);
-        public static readonly Attachment Bipod = new Attachment("Bipod", AttachmentType.UnderRail);
-        public static readonly Attachment VerticalGrip = new Attachment("Vertical_Grip", AttachmentType.UnderRail);
-        public static readonly Attachment StubbyGrip = new Attachment("Stubby_Grip", AttachmentType.UnderRail);
-        public static readonly Attachment StabilGrip = new Attachment("Stabil_Grip", AttachmentType.UnderRail);
-        public static readonly Attachment VerticalSkeletonGrip = new Attachment("Vertical_Skeleton_Grip", AttachmentType.UnderRail);
-        public static readonly Attachment FABDTFG = new Attachment("FAB-DTFG", AttachmentType.UnderRail);
-        public static readonly Attachment MagpulAngled = new Attachment("Magpul_Angled", AttachmentType.UnderRail);
-        public static readonly Attachment BCMGunFighter = new Attachment("BCM-Gun_Fighter", AttachmentType.UnderRail);
-        public static readonly Attachment ShiftShortAngledGrip = new Attachment("Shift_Short_Angled_Grip", AttachmentType.UnderRail);
-        public static readonly Attachment SE5Grip = new Attachment("SE-5_Grip", AttachmentType.UnderRail);
-        public static readonly Attachment RK6Foregrip = new Attachment("RK-6_Foregrip", AttachmentType.UnderRail);
-        public static readonly Attachment HeraCQRFront = new Attachment("HeraCQR_Front", AttachmentType.UnderRail);
-        public static readonly Attachment B25URK = new Attachment("B-25URK", AttachmentType.UnderRail);
-        public static readonly Attachment VTACUVGTacticalGrip = new Attachment("VTAC_UVG_TacticalGrip", AttachmentType.UnderRail);
-
-        // ----- Side Rails ----- 
-        public static readonly Attachment Flashlight = new Attachment("Flashlight", AttachmentType.SideRail);
-        public static readonly Attachment Rangefinder = new Attachment("Rangefinder", AttachmentType.SideRail);
-        public static readonly Attachment Redlaser = new Attachment("Redlaser", AttachmentType.SideRail);
-        public static readonly Attachment TacticalFlashlight = new Attachment("Tactical_Flashlight", AttachmentType.SideRail);
-        public static readonly Attachment Greenlaser = new Attachment("Greenlaser", AttachmentType.SideRail);
-        public static readonly Attachment Searchlight = new Attachment("Searchlight", AttachmentType.SideRail);
-
-        // ----- Bolts ----- 
-        public static readonly Attachment BoltActionA = new Attachment("Bolt_Action_A", AttachmentType.Bolt);
-        public static readonly Attachment BoltActionB = new Attachment("Bolt_Action_B", AttachmentType.Bolt);
-        public static readonly Attachment BoltActionC = new Attachment("Bolt_Action_C", AttachmentType.Bolt);
-        public static readonly Attachment BoltActionD = new Attachment("Bolt_Action_D", AttachmentType.Bolt);
-        public static readonly Attachment BoltActionE = new Attachment("Bolt_Action_E", AttachmentType.Bolt);
-
-        // ----- Public Calls ----- 
-        public static bool TryFind(string name, out Attachment item)
-        {
-            return mAttachments.TryGetValue(name, out item);
-        }
-
-        // ----- Init ----- 
-        static Attachments()
-        {
-            var members = typeof(Attachments).GetMembers(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
-            mAttachments = new Dictionary<string, Attachment>(members.Length);
-            foreach (var memberInfo in members)
             {
-                if (memberInfo.MemberType == System.Reflection.MemberTypes.Field)
+                var field = (FieldInfo)memberInfo;
+                if (field.FieldType == typeof(Attachment))
                 {
-                    var field = ((FieldInfo)memberInfo);
+                    var att = (Attachment)field.GetValue(null);
-                    if (field.FieldType == typeof(Attachment))
+                    mAttachments.Add(att.Name, att);
-                    {
-                        var att = (Attachment)field.GetValue(null);
-                        mAttachments.Add(att.Name, att);
-                    }
                 }
             }
-        }
     }
-}
+
+    // ----- Public Calls ----- 
+    public static bool TryFind(string name, out Attachment item)
+    {
+        return mAttachments.TryGetValue(name, out item);
+    }
+}

BattleBitAPI/Common/Datasets/Weapons.cs

@@ -1,82 +1,78 @@
-using Microsoft.VisualBasic;
+using System.Reflection;
-using System.Reflection;
 
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public static class Weapons
 {
-    public static class Weapons
+    // ----- Private Variables ----- 
+    private static readonly Dictionary<string, Weapon> mWeapons;
+
+    // ----- Public Variables ----- 
+    public static readonly Weapon ACR = new("ACR", WeaponType.Rifle);
+    public static readonly Weapon AK15 = new("AK15", WeaponType.Rifle);
+    public static readonly Weapon AK74 = new("AK74", WeaponType.Rifle);
+    public static readonly Weapon G36C = new("G36C", WeaponType.Rifle);
+    public static readonly Weapon HoneyBadger = new("Honey Badger", WeaponType.PersonalDefenseWeapon_PDW);
+    public static readonly Weapon KrissVector = new("Kriss Vector", WeaponType.SubmachineGun_SMG);
+    public static readonly Weapon L86A1 = new("L86A1", WeaponType.LightSupportGun_LSG);
+    public static readonly Weapon L96 = new("L96", WeaponType.SniperRifle);
+    public static readonly Weapon M4A1 = new("M4A1", WeaponType.Rifle);
+    public static readonly Weapon M9 = new("M9", WeaponType.Pistol);
+    public static readonly Weapon M110 = new("M110", WeaponType.DMR);
+    public static readonly Weapon M249 = new("M249", WeaponType.LightMachineGun_LMG);
+    public static readonly Weapon MK14EBR = new("MK14 EBR", WeaponType.DMR);
+    public static readonly Weapon MK20 = new("MK20", WeaponType.DMR);
+    public static readonly Weapon MP7 = new("MP7", WeaponType.SubmachineGun_SMG);
+    public static readonly Weapon PP2000 = new("PP2000", WeaponType.SubmachineGun_SMG);
+    public static readonly Weapon SCARH = new("SCAR-H", WeaponType.Rifle);
+    public static readonly Weapon SSG69 = new("SSG 69", WeaponType.SniperRifle);
+    public static readonly Weapon SV98 = new("SV-98", WeaponType.SniperRifle);
+    public static readonly Weapon UMP45 = new("UMP-45", WeaponType.SubmachineGun_SMG);
+    public static readonly Weapon Unica = new("Unica", WeaponType.HeavyPistol);
+    public static readonly Weapon USP = new("USP", WeaponType.Pistol);
+    public static readonly Weapon AsVal = new("As Val", WeaponType.Carbine);
+    public static readonly Weapon AUGA3 = new("AUG A3", WeaponType.Rifle);
+    public static readonly Weapon DesertEagle = new("Desert Eagle", WeaponType.HeavyPistol);
+    public static readonly Weapon FAL = new("FAL", WeaponType.Rifle);
+    public static readonly Weapon Glock18 = new("Glock 18", WeaponType.AutoPistol);
+    public static readonly Weapon M200 = new("M200", WeaponType.SniperRifle);
+    public static readonly Weapon MP443 = new("MP 443", WeaponType.Pistol);
+    public static readonly Weapon FAMAS = new("FAMAS", WeaponType.Rifle);
+    public static readonly Weapon MP5 = new("MP5", WeaponType.SubmachineGun_SMG);
+    public static readonly Weapon P90 = new("P90", WeaponType.PersonalDefenseWeapon_PDW);
+    public static readonly Weapon MSR = new("MSR", WeaponType.SniperRifle);
+    public static readonly Weapon PP19 = new("PP19", WeaponType.SubmachineGun_SMG);
+    public static readonly Weapon SVD = new("SVD", WeaponType.DMR);
+    public static readonly Weapon Rem700 = new("Rem700", WeaponType.SniperRifle);
+    public static readonly Weapon SG550 = new("SG550", WeaponType.Rifle);
+    public static readonly Weapon Groza = new("Groza", WeaponType.PersonalDefenseWeapon_PDW);
+    public static readonly Weapon HK419 = new("HK419", WeaponType.Rifle);
+    public static readonly Weapon ScorpionEVO = new("ScorpionEVO", WeaponType.Carbine);
+    public static readonly Weapon Rsh12 = new("Rsh12", WeaponType.HeavyPistol);
+    public static readonly Weapon MG36 = new("MG36", WeaponType.LightSupportGun_LSG);
+    public static readonly Weapon AK5C = new("AK5C", WeaponType.Rifle);
+    public static readonly Weapon Ultimax100 = new("Ultimax100", WeaponType.LightMachineGun_LMG);
+
+    // ----- Init ----- 
+    static Weapons()
     {
-        // ----- Private Variables ----- 
+        var members = typeof(Weapons).GetMembers(BindingFlags.Public | BindingFlags.Static);
-        private static Dictionary<string, Weapon> mWeapons;
+        mWeapons = new Dictionary<string, Weapon>(members.Length);
-
+        foreach (var memberInfo in members)
-        // ----- Public Variables ----- 
+            if (memberInfo.MemberType == MemberTypes.Field)
-        public readonly static Weapon ACR = new Weapon("ACR", WeaponType.Rifle);
-        public readonly static Weapon AK15 = new Weapon("AK15", WeaponType.Rifle);
-        public readonly static Weapon AK74 = new Weapon("AK74", WeaponType.Rifle);
-        public readonly static Weapon G36C = new Weapon("G36C", WeaponType.Rifle);
-        public readonly static Weapon HoneyBadger = new Weapon("Honey Badger", WeaponType.PersonalDefenseWeapon_PDW);
-        public readonly static Weapon KrissVector = new Weapon("Kriss Vector", WeaponType.SubmachineGun_SMG);
-        public readonly static Weapon L86A1 = new Weapon("L86A1", WeaponType.LightSupportGun_LSG);
-        public readonly static Weapon L96 = new Weapon("L96", WeaponType.SniperRifle);
-        public readonly static Weapon M4A1 = new Weapon("M4A1", WeaponType.Rifle);
-        public readonly static Weapon M9 = new Weapon("M9", WeaponType.Pistol);
-        public readonly static Weapon M110 = new Weapon("M110", WeaponType.DMR);
-        public readonly static Weapon M249 = new Weapon("M249", WeaponType.LightMachineGun_LMG);
-        public readonly static Weapon MK14EBR = new Weapon("MK14 EBR", WeaponType.DMR);
-        public readonly static Weapon MK20 = new Weapon("MK20", WeaponType.DMR);
-        public readonly static Weapon MP7 = new Weapon("MP7", WeaponType.SubmachineGun_SMG);
-        public readonly static Weapon PP2000 = new Weapon("PP2000", WeaponType.SubmachineGun_SMG);
-        public readonly static Weapon SCARH = new Weapon("SCAR-H", WeaponType.Rifle);
-        public readonly static Weapon SSG69 = new Weapon("SSG 69", WeaponType.SniperRifle);
-        public readonly static Weapon SV98 = new Weapon("SV-98", WeaponType.SniperRifle);
-        public readonly static Weapon UMP45 = new Weapon("UMP-45", WeaponType.SubmachineGun_SMG);
-        public readonly static Weapon Unica = new Weapon("Unica", WeaponType.HeavyPistol);
-        public readonly static Weapon USP = new Weapon("USP", WeaponType.Pistol);
-        public readonly static Weapon AsVal = new Weapon("As Val", WeaponType.Carbine);
-        public readonly static Weapon AUGA3 = new Weapon("AUG A3", WeaponType.Rifle);
-        public readonly static Weapon DesertEagle = new Weapon("Desert Eagle", WeaponType.HeavyPistol);
-        public readonly static Weapon FAL = new Weapon("FAL", WeaponType.Rifle);
-        public readonly static Weapon Glock18 = new Weapon("Glock 18", WeaponType.AutoPistol);
-        public readonly static Weapon M200 = new Weapon("M200", WeaponType.SniperRifle);
-        public readonly static Weapon MP443 = new Weapon("MP 443", WeaponType.Pistol);
-        public readonly static Weapon FAMAS = new Weapon("FAMAS", WeaponType.Rifle);
-        public readonly static Weapon MP5 = new Weapon("MP5", WeaponType.SubmachineGun_SMG);
-        public readonly static Weapon P90 = new Weapon("P90", WeaponType.PersonalDefenseWeapon_PDW);
-        public readonly static Weapon MSR = new Weapon("MSR", WeaponType.SniperRifle);
-        public readonly static Weapon PP19 = new Weapon("PP19", WeaponType.SubmachineGun_SMG);
-        public readonly static Weapon SVD = new Weapon("SVD", WeaponType.DMR);
-        public readonly static Weapon Rem700 = new Weapon("Rem700", WeaponType.SniperRifle);
-        public readonly static Weapon SG550 = new Weapon("SG550", WeaponType.Rifle);
-        public readonly static Weapon Groza = new Weapon("Groza", WeaponType.PersonalDefenseWeapon_PDW);
-        public readonly static Weapon HK419 = new Weapon("HK419", WeaponType.Rifle);
-        public readonly static Weapon ScorpionEVO = new Weapon("ScorpionEVO", WeaponType.Carbine);
-        public readonly static Weapon Rsh12 = new Weapon("Rsh12", WeaponType.HeavyPistol);
-        public readonly static Weapon MG36 = new Weapon("MG36", WeaponType.LightSupportGun_LSG);
-        public readonly static Weapon AK5C = new Weapon("AK5C", WeaponType.Rifle);
-        public readonly static Weapon Ultimax100 = new Weapon("Ultimax100", WeaponType.LightMachineGun_LMG);
-
-        // ----- Public Calls ----- 
-        public static bool TryFind(string name, out Weapon item)
-        {
-            return mWeapons.TryGetValue(name, out item);
-        }
-
-        // ----- Init ----- 
-        static Weapons()
-        {
-            var members = typeof(Weapons).GetMembers(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Static);
-            mWeapons = new Dictionary<string, Weapon>(members.Length);
-            foreach (var memberInfo in members)
             {
-                if (memberInfo.MemberType == System.Reflection.MemberTypes.Field)
+                var field = (FieldInfo)memberInfo;
+                if (field.FieldType == typeof(Weapon))
                 {
-                    var field = ((FieldInfo)memberInfo);
+                    var wep = (Weapon)field.GetValue(null);
-                    if (field.FieldType == typeof(Weapon))
+                    mWeapons.Add(wep.Name, wep);
-                    {
-                        var wep = (Weapon)field.GetValue(null);
-                        mWeapons.Add(wep.Name, wep);
-                    }
                 }
             }
-        }
     }
-}
+
+    // ----- Public Calls ----- 
+    public static bool TryFind(string name, out Weapon item)
+    {
+        return mWeapons.TryGetValue(name, out item);
+    }
+}

BattleBitAPI/Common/Enums/AttachmentType.cs

@@ -1,13 +1,12 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum AttachmentType
 {
-    public enum AttachmentType
+    MainSight,
-    {
+    TopSight,
-        MainSight,
+    CantedSight,
-        TopSight,
+    Barrel,
-        CantedSight,
+    UnderRail,
-        Barrel,
+    SideRail,
-        UnderRail,
+    Bolt
-        SideRail,
+}
-        Bolt,
-    }
-}

BattleBitAPI/Common/Enums/ChatChannel.cs

@@ -1,9 +1,8 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum ChatChannel
 {
-    public enum ChatChannel
+    AllChat,
-    {
+    TeamChat,
-        AllChat, 
+    SquadChat
-        TeamChat, 
+}
-        SquadChat
-    }
-}

BattleBitAPI/Common/Enums/DamageReason.cs

@@ -1,27 +1,20 @@
-using System;
+namespace BattleBitAPI.Common;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
-namespace BattleBitAPI.Common
+public enum ReasonOfDamage : byte
 {
-    public enum ReasonOfDamage : byte
+    Server = 0,
-    {
+    Weapon = 1,
-        Server = 0,
+    Bleeding = 2,
-        Weapon = 1,
+    Fall = 3,
-        Bleeding = 2,
+    HelicopterBlade = 4,
-        Fall = 3,
+    VehicleExplosion = 5,
-        HelicopterBlade = 4,
+    Explosion = 6,
-        VehicleExplosion = 5,
+    vehicleRunOver = 7,
-        Explosion = 6,
+    BuildingCollapsing = 8,
-        vehicleRunOver = 7,
+    SledgeHammer = 9,
-        BuildingCollapsing = 8,
+    TreeFall = 10,
-        SledgeHammer = 9,
+    CountAsKill = 11,
-        TreeFall = 10,
+    Suicide = 12,
-        CountAsKill = 11,
+    HelicopterCrash = 13,
-        Suicide = 12,
+    BarbedWire = 14
-        HelicopterCrash = 13,
+}
-        BarbedWire = 14,
-    }
-}

BattleBitAPI/Common/Enums/GameRole.cs

@@ -1,7 +1,11 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum GameRole
 {
-    public enum GameRole
+    Assault = 0,
-    {
+    Medic = 1,
-        Assault = 0, Medic = 1, Support = 2, Engineer = 3, Recon = 4, Leader = 5
+    Support = 2,
-    }
+    Engineer = 3,
-}
+    Recon = 4,
+    Leader = 5
+}

BattleBitAPI/Common/Enums/GameState.cs

@@ -1,10 +1,9 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum GameState : byte
 {
-    public enum GameState : byte
+    WaitingForPlayers = 0,
-    {
+    CountingDown = 1,
-        WaitingForPlayers = 0,
+    Playing = 2,
-        CountingDown = 1,
+    EndingGame = 3
-        Playing = 2,
+}
-        EndingGame = 3
-    }
-}

BattleBitAPI/Common/Enums/LeaningSide.cs

@@ -1,7 +1,8 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum LeaningSide
 {
-    public enum LeaningSide
+    Left,
-    {
+    None,
-        Left, None, Right
+    Right
-    }
+}
-}

BattleBitAPI/Common/Enums/LoadoutIndex.cs

@@ -1,12 +1,11 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum LoadoutIndex : byte
 {
-    public enum LoadoutIndex : byte
+    Primary = 0,
-    {
+    Secondary = 1,
-        Primary = 0, 
+    FirstAid = 2,
-        Secondary = 1, 
+    LightGadget = 3,
-        FirstAid = 2, 
+    HeavyGadget = 4,
-        LightGadget = 3, 
+    Throwable = 5
-        HeavyGadget = 4, 
+}
-        Throwable = 5,
-    }
-}

BattleBitAPI/Common/Enums/MapDayNight.cs

@@ -1,8 +1,7 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum MapDayNight : byte
 {
-    public enum MapDayNight : byte
+    Day = 0,
-    {
+    Night = 1
-        Day = 0,
+}
-        Night = 1,
-    }
-}

BattleBitAPI/Common/Enums/MapSize.cs

@@ -1,12 +1,11 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum MapSize : byte
 {
-    public enum MapSize : byte
+    None = 0,
-    {
+    _8v8 = 8,
-        None = 0,
+    _16vs16 = 16,
-        _8v8=8,
+    _32vs32 = 32,
-        _16vs16 = 16,
+    _64vs64 = 64,
-        _32vs32 = 32,
+    _127vs127 = 90
-        _64vs64 = 64,
+}
-        _127vs127 = 90,
-    }
-}

BattleBitAPI/Common/Enums/PlayerBody.cs

@@ -1,15 +1,13 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
-{
-    public enum PlayerBody : byte
-    {
-        None = 0,
-        Head = 2,
-        Neck = 3,
-        Shoulder = 4,
-        Arm = 5,
-        Leg = 6,
-        Foot = 7,
-        Chest = 10,
-    }
 
-}
+public enum PlayerBody : byte
+{
+    None = 0,
+    Head = 2,
+    Neck = 3,
+    Shoulder = 4,
+    Arm = 5,
+    Leg = 6,
+    Foot = 7,
+    Chest = 10
+}

BattleBitAPI/Common/Enums/PlayerSpawningPoint.cs

@@ -1,7 +1,10 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum PlayerSpawningPosition : byte
 {
-    public enum PlayerSpawningPosition : byte
+    SpawnAtPoint,
-    {
+    SpawnAtRally,
-        SpawnAtPoint, SpawnAtRally, SpawnAtFriend, SpawnAtVehicle, Null
+    SpawnAtFriend,
-    }
+    SpawnAtVehicle,
-}
+    Null
+}

BattleBitAPI/Common/Enums/PlayerStand.cs

@@ -1,7 +1,8 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum PlayerStand : byte
 {
-    public enum PlayerStand : byte
+    Standing = 0,
-    {
+    Crouching = 1,
-        Standing = 0, Crouching = 1, Proning = 2
+    Proning = 2
-    }
+}
-}

BattleBitAPI/Common/Enums/ReportReason.cs

@@ -1,23 +1,22 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum ReportReason
 {
-    public enum ReportReason
+    Cheating_WallHack = 0,
-    {
+    Cheating_Aimbot = 1,
-        Cheating_WallHack = 0,
+    Cheating_Speedhack = 2,
-        Cheating_Aimbot = 1,
-        Cheating_Speedhack = 2,
 
-        Racism_Discrimination_Text = 3,
+    Racism_Discrimination_Text = 3,
-        Racism_Discrimination_Voice = 4,
+    Racism_Discrimination_Voice = 4,
 
-        Spamming_Text = 5,
+    Spamming_Text = 5,
-        Spamming_Voice = 6,
+    Spamming_Voice = 6,
 
-        Bad_Language_Text = 7,
+    Bad_Language_Text = 7,
-        Bad_Language_Voice = 8,
+    Bad_Language_Voice = 8,
 
-        Griefing = 9,
+    Griefing = 9,
-        Exploiting = 10,
+    Exploiting = 10,
-        OtherToxicBehaviour = 11,
+    OtherToxicBehaviour = 11,
-        UserProfileNamePicture = 12,
+    UserProfileNamePicture = 12
-    }
+}
-}

BattleBitAPI/Common/Enums/Roles.cs

@@ -1,12 +1,11 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
-{
-    public enum Roles : ulong
-    {
-        None = 0,
 
-        Admin = 1 << 0,
+public enum Roles : ulong
-        Moderator = 1 << 1,
+{
-        Special = 1 << 2,
+    None = 0,
-        Vip = 1 << 3,
+
-    }
+    Admin = 1 << 0,
-}
+    Moderator = 1 << 1,
+    Special = 1 << 2,
+    Vip = 1 << 3
+}

BattleBitAPI/Common/Enums/Squads.cs

@@ -1,72 +1,71 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
-{
-    public enum Squads
-    {
-        NoSquad = 0,
 
-        Alpha = 1,
+public enum Squads
-        Bravo = 2,
+{
-        Charlie = 3,
+    NoSquad = 0,
-        Delta = 4,
+
-        Echo = 5,
+    Alpha = 1,
-        Foxtrot = 6,
+    Bravo = 2,
-        Golf = 7,
+    Charlie = 3,
-        Hotel = 8,
+    Delta = 4,
-        India = 9,
+    Echo = 5,
-        Juliett = 10,
+    Foxtrot = 6,
-        Kilo = 11,
+    Golf = 7,
-        Lima = 12,
+    Hotel = 8,
-        Mike = 13,
+    India = 9,
-        November = 14,
+    Juliett = 10,
-        Oscar = 15,
+    Kilo = 11,
-        Papa = 16,
+    Lima = 12,
-        Quebec = 17,
+    Mike = 13,
-        Romeo = 18,
+    November = 14,
-        Sierra = 19,
+    Oscar = 15,
-        Tango = 20,
+    Papa = 16,
-        Uniform = 21,
+    Quebec = 17,
-        Whiskey = 22,
+    Romeo = 18,
-        Xray = 23,
+    Sierra = 19,
-        Yankee = 24,
+    Tango = 20,
-        Zulu = 25,
+    Uniform = 21,
-        Ash = 26,
+    Whiskey = 22,
-        Baker = 27,
+    Xray = 23,
-        Cast = 28,
+    Yankee = 24,
-        Diver = 29,
+    Zulu = 25,
-        Eagle = 30,
+    Ash = 26,
-        Fisher = 31,
+    Baker = 27,
-        George = 32,
+    Cast = 28,
-        Hanover = 33,
+    Diver = 29,
-        Ice = 34,
+    Eagle = 30,
-        Jake = 35,
+    Fisher = 31,
-        King = 36,
+    George = 32,
-        Lash = 37,
+    Hanover = 33,
-        Mule = 38,
+    Ice = 34,
-        Neptune = 39,
+    Jake = 35,
-        Ostend = 40,
+    King = 36,
-        Page = 41,
+    Lash = 37,
-        Quail = 42,
+    Mule = 38,
-        Raft = 43,
+    Neptune = 39,
-        Scout = 44,
+    Ostend = 40,
-        Tare = 45,
+    Page = 41,
-        Unit = 46,
+    Quail = 42,
-        William = 47,
+    Raft = 43,
-        Xaintrie = 48,
+    Scout = 44,
-        Yoke = 49,
+    Tare = 45,
-        Zebra = 50,
+    Unit = 46,
-        Ace = 51,
+    William = 47,
-        Beer = 52,
+    Xaintrie = 48,
-        Cast2 = 53,
+    Yoke = 49,
-        Duff = 54,
+    Zebra = 50,
-        Edward = 55,
+    Ace = 51,
-        Freddy = 56,
+    Beer = 52,
-        Gustav = 57,
+    Cast2 = 53,
-        Henry = 58,
+    Duff = 54,
-        Ivar = 59,
+    Edward = 55,
-        Jazz = 60,
+    Freddy = 56,
-        Key = 61,
+    Gustav = 57,
-        Lincoln = 62,
+    Henry = 58,
-        Mary = 63,
+    Ivar = 59,
-        Nora = 64
+    Jazz = 60,
-    }
+    Key = 61,
-}
+    Lincoln = 62,
+    Mary = 63,
+    Nora = 64
+}

BattleBitAPI/Common/Enums/Team.cs

@@ -1,9 +1,8 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum Team : byte
 {
-    public enum Team : byte
+    TeamA = 0,
-    {
+    TeamB = 1,
-        TeamA = 0, 
+    None = 2
-        TeamB = 1,
+}
-        None = 2
-    }
-}

BattleBitAPI/Common/Enums/WeaponType.cs

@@ -1,17 +1,16 @@
-namespace BattleBitAPI.Common
+namespace BattleBitAPI.Common;
+
+public enum WeaponType
 {
-    public enum WeaponType : int
+    Rifle,
-    {
+    DMR,
-        Rifle,
+    SniperRifle,
-        DMR,
+    LightSupportGun_LSG,
-        SniperRifle,
+    LightMachineGun_LMG,
-        LightSupportGun_LSG,
+    SubmachineGun_SMG,
-        LightMachineGun_LMG,
+    Pistol,
-        SubmachineGun_SMG,
+    AutoPistol,
-        Pistol,
+    HeavyPistol,
-        AutoPistol,
+    Carbine,
-        HeavyPistol,
+    PersonalDefenseWeapon_PDW
-        Carbine,
+}
-        PersonalDefenseWeapon_PDW,
-    }
-}

BattleBitAPI/Common/Extentions/Extentions.cs

@@ -1,39 +1,79 @@
 using System.Net;
 using System.Net.Sockets;
+using Stream = BattleBitAPI.Common.Serialization.Stream;
 
-namespace BattleBitAPI.Common.Extentions
+namespace BattleBitAPI.Common.Extentions;
+
+public static class Extentions
 {
-    public static class Extentions
+    public static long TickCount
     {
-        public static long TickCount
+        get
         {
-            get
-            {
 #if NETCOREAPP
-                return System.Environment.TickCount64;
+            return Environment.TickCount64;
 #else
                 return (long)Environment.TickCount;
 #endif
-            }
         }
-        public unsafe static uint ToUInt(this IPAddress address)
+    }
-        {
+
+    public static uint ToUInt(this IPAddress address)
+    {
 #if NETCOREAPP
-            return BitConverter.ToUInt32(address.GetAddressBytes());
+        return BitConverter.ToUInt32(address.GetAddressBytes());
 #else
         return BitConverter.ToUInt32(address.GetAddressBytes(), 0);
 #endif
+    }
+
+    public static void SafeClose(this TcpClient client)
+    {
+        try
+        {
+            client.Close();
+        }
+        catch
+        {
         }
 
-        public static void SafeClose(this TcpClient client)
+        try
         {
-            try { client.Close(); } catch { }
+            client.Dispose();
-            try { client.Dispose(); } catch { }
         }
-        public static async Task<int> Read(this NetworkStream networkStream, Serialization.Stream outputStream, int size, CancellationToken token = default)
+        catch
         {
-            int read = 0;
+        }
-            int readUntil = outputStream.WritePosition + size;
+    }
+
+    public static async Task<int> Read(this NetworkStream networkStream, Stream outputStream, int size, CancellationToken token = default)
+    {
+        var read = 0;
+        var readUntil = outputStream.WritePosition + size;
+
+        //Ensure we have space.
+        outputStream.EnsureWriteBufferSize(size);
+
+        //Continue reading until we have the package.
+        while (outputStream.WritePosition < readUntil)
+        {
+            var sizeToRead = readUntil - outputStream.WritePosition;
+            var received = await networkStream.ReadAsync(outputStream.Buffer, outputStream.WritePosition, sizeToRead, token);
+            if (received <= 0)
+                throw new Exception("NetworkStream was closed.");
+
+            read += received;
+            outputStream.WritePosition += received;
+        }
+
+        return read;
+    }
+
+    public static async Task<bool> TryRead(this NetworkStream networkStream, Stream outputStream, int size, CancellationToken token = default)
+    {
+        try
+        {
+            var readUntil = outputStream.WritePosition + size;
 
             //Ensure we have space.
             outputStream.EnsureWriteBufferSize(size);
@@ -41,42 +81,18 @@ namespace BattleBitAPI.Common.Extentions
             //Continue reading until we have the package.
             while (outputStream.WritePosition < readUntil)
             {
-                int sizeToRead = readUntil - outputStream.WritePosition;
+                var sizeToRead = readUntil - outputStream.WritePosition;
-                int received = await networkStream.ReadAsync(outputStream.Buffer, outputStream.WritePosition, sizeToRead, token);
+                var received = await networkStream.ReadAsync(outputStream.Buffer, outputStream.WritePosition, sizeToRead, token);
                 if (received <= 0)
                     throw new Exception("NetworkStream was closed.");
-
-                read += received;
                 outputStream.WritePosition += received;
             }
 
-            return read;
+            return true;
         }
-        public static async Task<bool> TryRead(this NetworkStream networkStream, Serialization.Stream outputStream, int size, CancellationToken token = default)
+        catch
         {
-            try
+            return false;
-            {
-                int readUntil = outputStream.WritePosition + size;
-
-                //Ensure we have space.
-                outputStream.EnsureWriteBufferSize(size);
-
-                //Continue reading until we have the package.
-                while (outputStream.WritePosition < readUntil)
-                {
-                    int sizeToRead = readUntil - outputStream.WritePosition;
-                    int received = await networkStream.ReadAsync(outputStream.Buffer, outputStream.WritePosition, sizeToRead, token);
-                    if (received <= 0)
-                        throw new Exception("NetworkStream was closed.");
-                    outputStream.WritePosition += received;
-                }
-
-                return true;
-            }
-            catch
-            {
-                return false;
-            }
         }
     }
-}
+}

BattleBitAPI/Common/Serialization/IStreamSerializble.cs

@@ -1,8 +1,7 @@
-namespace BattleBitAPI.Common.Serialization
+namespace BattleBitAPI.Common.Serialization;
+
+public interface IStreamSerializable
 {
-    public interface IStreamSerializable
+    void Read(Stream ser);
-    {
+    void Write(Stream ser);
-        void Read(Stream ser);
+}
-        void Write(Stream ser);
-    }
-}

BattleBitAPI/Common/Threading/ThreadSafe.cs

@@ -1,70 +1,79 @@
-using System;
+namespace BattleBitAPI.Common.Threading;
-using System.Collections.Generic;
 
-namespace BattleBitAPI.Common.Threading
+public class ThreadSafe<T>
 {
-    public class ThreadSafe<T>
+    private readonly ReaderWriterLockSlim mLock;
+    public T Value;
+
+    public ThreadSafe(T value)
     {
-        private System.Threading.ReaderWriterLockSlim mLock;
+        Value = value;
-        public T Value;
+        mLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+    }
 
-        public ThreadSafe(T value)
+    public SafeWriteHandle GetWriteHandle()
+    {
+        return new SafeWriteHandle(mLock);
+    }
+
+    public SafeReadHandle GetReadHandle()
+    {
+        return new SafeReadHandle(mLock);
+    }
+
+    /// <summary>
+    ///     Swaps current value with new value and returns old one.
+    /// </summary>
+    /// <param name="newValue"></param>
+    /// <returns>Old value</returns>
+    public T SwapValue(T newValue)
+    {
+        using (new SafeWriteHandle(mLock))
         {
-            this.Value = value;
+            var oldValue = Value;
-            this.mLock = new System.Threading.ReaderWriterLockSlim(System.Threading.LockRecursionPolicy.SupportsRecursion);
+            Value = newValue;
-        }
+            return oldValue;
-
-        public SafeWriteHandle GetWriteHandle() => new SafeWriteHandle(this.mLock);
-        public SafeReadHandle GetReadHandle() => new SafeReadHandle(this.mLock);
-
-        /// <summary>
-        /// Swaps current value with new value and returns old one.
-        /// </summary>
-        /// <param name="newValue"></param>
-        /// <returns>Old value</returns>
-        public T SwapValue(T newValue)
-        {
-            using (new SafeWriteHandle(this.mLock))
-            {
-                var oldValue = this.Value;
-                this.Value = newValue;
-                return oldValue;
-            }
         }
     }
-    public class SafeWriteHandle : System.IDisposable
+}
-    {
-        private System.Threading.ReaderWriterLockSlim mLock;
-        private bool mDisposed;
-        public SafeWriteHandle(System.Threading.ReaderWriterLockSlim mLock)
-        {
-            this.mLock = mLock;
-            mLock.EnterWriteLock();
-        }
-        public void Dispose()
-        {
-            if (mDisposed)
-                return;
-            mDisposed = true;
-            mLock.ExitWriteLock();
-        }
-    }
-    public class SafeReadHandle : System.IDisposable
-    {
-        private System.Threading.ReaderWriterLockSlim mLock;
-        private bool mDisposed;
-        public SafeReadHandle(System.Threading.ReaderWriterLockSlim mLock)
-        {
-            this.mLock = mLock;
-            mLock.EnterReadLock();
-        }
-        public void Dispose()
-        {
-            if (mDisposed)
-                return;
-            mDisposed = true;
 
-            mLock.ExitReadLock();
+public class SafeWriteHandle : IDisposable
-        }
+{
+    private bool mDisposed;
+    private readonly ReaderWriterLockSlim mLock;
+
+    public SafeWriteHandle(ReaderWriterLockSlim mLock)
+    {
+        this.mLock = mLock;
+        mLock.EnterWriteLock();
+    }
+
+    public void Dispose()
+    {
+        if (mDisposed)
+            return;
+        mDisposed = true;
+        mLock.ExitWriteLock();
+    }
+}
+
+public class SafeReadHandle : IDisposable
+{
+    private bool mDisposed;
+    private readonly ReaderWriterLockSlim mLock;
+
+    public SafeReadHandle(ReaderWriterLockSlim mLock)
+    {
+        this.mLock = mLock;
+        mLock.EnterReadLock();
+    }
+
+    public void Dispose()
+    {
+        if (mDisposed)
+            return;
+        mDisposed = true;
+
+        mLock.ExitReadLock();
     }
 }

BattleBitAPI/Networking/NetworkCommuncation.cs

@@ -1,42 +0,0 @@
-namespace BattleBitAPI.Networking
-{
-    public enum NetworkCommuncation : byte
-    {
-        None = 0,
-        Hail = 1,
-        Accepted = 2,
-        Denied = 3,
-
-        ExecuteCommand = 10,
-        SendPlayerStats = 11,
-        SpawnPlayer = 12,
-        SetNewRoomSettings = 13,
-        RespondPlayerMessage = 14,
-        SetNewRoundState = 15,
-        SetPlayerWeapon = 16,
-        SetPlayerGadget = 17,
-
-        PlayerConnected = 50,
-        PlayerDisconnected = 51,
-        OnPlayerTypedMessage = 52,
-        OnAPlayerDownedAnotherPlayer = 53,
-        OnPlayerJoining = 54,
-        SavePlayerStats = 55,
-        OnPlayerAskingToChangeRole = 56,
-        OnPlayerChangedRole = 57,
-        OnPlayerJoinedASquad = 58,
-        OnPlayerLeftSquad = 59,
-        OnPlayerChangedTeam = 60,
-        OnPlayerRequestingToSpawn = 61,
-        OnPlayerReport = 62,
-        OnPlayerSpawn = 63,
-        OnPlayerDie = 64,
-        NotifyNewMapRotation = 65,
-        NotifyNewGamemodeRotation = 66,
-        NotifyNewRoundState = 67,
-        OnPlayerAskingToChangeTeam = 68,
-        GameTick = 69,
-        OnPlayerGivenUp = 70,
-        OnPlayerRevivedAnother = 71,
-    }
-}

BattleBitAPI/Networking/NetworkCommunication.cs

@@ -0,0 +1,41 @@
+namespace BattleBitAPI.Networking;
+
+public enum NetworkCommunication : byte
+{
+    None = 0,
+    Hail = 1,
+    Accepted = 2,
+    Denied = 3,
+
+    ExecuteCommand = 10,
+    SendPlayerStats = 11,
+    SpawnPlayer = 12,
+    SetNewRoomSettings = 13,
+    RespondPlayerMessage = 14,
+    SetNewRoundState = 15,
+    SetPlayerWeapon = 16,
+    SetPlayerGadget = 17,
+
+    PlayerConnected = 50,
+    PlayerDisconnected = 51,
+    OnPlayerTypedMessage = 52,
+    OnAPlayerDownedAnotherPlayer = 53,
+    OnPlayerJoining = 54,
+    SavePlayerStats = 55,
+    OnPlayerAskingToChangeRole = 56,
+    OnPlayerChangedRole = 57,
+    OnPlayerJoinedASquad = 58,
+    OnPlayerLeftSquad = 59,
+    OnPlayerChangedTeam = 60,
+    OnPlayerRequestingToSpawn = 61,
+    OnPlayerReport = 62,
+    OnPlayerSpawn = 63,
+    OnPlayerDie = 64,
+    NotifyNewMapRotation = 65,
+    NotifyNewGamemodeRotation = 66,
+    NotifyNewRoundState = 67,
+    OnPlayerAskingToChangeTeam = 68,
+    GameTick = 69,
+    OnPlayerGivenUp = 70,
+    OnPlayerRevivedAnother = 71
+}

BattleBitAPI/Server/Internal/GamemodeRotation.cs

@@ -1,66 +1,80 @@
-using BattleBitAPI.Common;
+namespace BattleBitAPI.Server;
-using CommunityServerAPI.BattleBitAPI.Server;
 
-namespace BattleBitAPI.Server
+public class GamemodeRotation<TPlayer> where TPlayer : Player<TPlayer>
 {
-    public class GamemodeRotation<TPlayer> where TPlayer : Player<TPlayer>
+    private readonly GameServer<TPlayer>.Internal mResources;
+
+    public GamemodeRotation(GameServer<TPlayer>.Internal resources)
     {
-        private GameServer<TPlayer>.Internal mResources;
+        mResources = resources;
-        public GamemodeRotation(GameServer<TPlayer>.Internal resources)
+    }
-        {
-            mResources = resources;
-        }
 
-        public IEnumerable<string> GetGamemodeRotation()
+    public IEnumerable<string> GetGamemodeRotation()
-        {
+    {
-            lock (mResources._GamemodeRotation)
+        lock (mResources._GamemodeRotation)
-                return new List<string>(mResources._GamemodeRotation);
-        }
-        public bool InRotation(string gamemode)
-        {
-            lock (mResources._GamemodeRotation)
-                return mResources._GamemodeRotation.Contains(gamemode);
-        }
-        public bool RemoveFromRotation(string gamemode)
-        {
-            lock (mResources._GamemodeRotation)
-                if (!mResources._GamemodeRotation.Remove(gamemode))
-                    return false;
-            mResources.IsDirtyGamemodeRotation = true;
-            return true;
-        }
-        public bool AddToRotation(string gamemode)
-        {
-            lock (mResources._GamemodeRotation)
-                if (!mResources._GamemodeRotation.Add(gamemode))
-                    return false;
-            mResources.IsDirtyGamemodeRotation = true;
-            return true;
-        }
-        public void SetRotation(params string[] gamemodes)
-        {
-            lock (mResources._GamemodeRotation)
-            {
-                mResources._GamemodeRotation.Clear();
-                foreach (var item in gamemodes)
-                    mResources._GamemodeRotation.Add(item);
-            }
-            mResources.IsDirtyGamemodeRotation = true;
-        }
-        public void ClearRotation()
-        {
-            lock (mResources._GamemodeRotation)
-            {
-                if (mResources._GamemodeRotation.Count == 0)
-                    return;
-
-                mResources._GamemodeRotation.Clear();
-            }
-            mResources.IsDirtyGamemodeRotation = true;
-        }
-
-        public void Reset()
         {
+            return new List<string>(mResources._GamemodeRotation);
         }
     }
-}
+
+    public bool InRotation(string gamemode)
+    {
+        lock (mResources._GamemodeRotation)
+        {
+            return mResources._GamemodeRotation.Contains(gamemode);
+        }
+    }
+
+    public bool RemoveFromRotation(string gamemode)
+    {
+        lock (mResources._GamemodeRotation)
+        {
+            if (!mResources._GamemodeRotation.Remove(gamemode))
+                return false;
+        }
+
+        mResources.IsDirtyGamemodeRotation = true;
+        return true;
+    }
+
+    public bool AddToRotation(string gamemode)
+    {
+        lock (mResources._GamemodeRotation)
+        {
+            if (!mResources._GamemodeRotation.Add(gamemode))
+                return false;
+        }
+
+        mResources.IsDirtyGamemodeRotation = true;
+        return true;
+    }
+
+    public void SetRotation(params string[] gamemodes)
+    {
+        lock (mResources._GamemodeRotation)
+        {
+            mResources._GamemodeRotation.Clear();
+            foreach (var item in gamemodes)
+                mResources._GamemodeRotation.Add(item);
+        }
+
+        mResources.IsDirtyGamemodeRotation = true;
+    }
+
+    public void ClearRotation()
+    {
+        lock (mResources._GamemodeRotation)
+        {
+            if (mResources._GamemodeRotation.Count == 0)
+                return;
+
+            mResources._GamemodeRotation.Clear();
+        }
+
+        mResources.IsDirtyGamemodeRotation = true;
+    }
+
+    public void Reset()
+    {
+    }
+}

BattleBitAPI/Server/Internal/MapRotation.cs

@@ -1,71 +1,86 @@
-using CommunityServerAPI.BattleBitAPI.Server;
+namespace BattleBitAPI.Server;
 
-namespace BattleBitAPI.Server
+public class MapRotation<TPlayer> where TPlayer : Player<TPlayer>
 {
-    public class MapRotation<TPlayer> where TPlayer : Player<TPlayer>
+    private readonly GameServer<TPlayer>.Internal mResources;
+
+    public MapRotation(GameServer<TPlayer>.Internal resources)
     {
-        private GameServer<TPlayer>.Internal mResources;
+        mResources = resources;
-        public MapRotation(GameServer<TPlayer>.Internal resources)
+    }
-        {
-            mResources = resources;
-        }
 
-        public IEnumerable<string> GetMapRotation()
+    public IEnumerable<string> GetMapRotation()
-        {
+    {
-            lock (mResources._MapRotation)
+        lock (mResources._MapRotation)
-                return new List<string>(mResources._MapRotation);
-        }
-        public bool InRotation(string map)
-        {
-            map = map.ToUpperInvariant();
-
-            lock (mResources._MapRotation)
-                return mResources._MapRotation.Contains(map);
-        }
-        public bool RemoveFromRotation(string map)
-        {
-            map = map.ToUpperInvariant();
-
-            lock (mResources._MapRotation)
-                if (!mResources._MapRotation.Remove(map))
-                    return false;
-            mResources.IsDirtyMapRotation = true;
-            return true;
-        }
-        public bool AddToRotation(string map)
-        {
-            map = map.ToUpperInvariant();
-
-            lock (mResources._MapRotation)
-                if (!mResources._MapRotation.Add(map))
-                    return false;
-            mResources.IsDirtyMapRotation = true;
-            return true;
-        }
-        public void SetRotation(params string[] maps)
-        {
-            lock (mResources._MapRotation)
-            {
-                mResources._MapRotation.Clear();
-                foreach (var item in maps)
-                    mResources._MapRotation.Add(item);
-            }
-            mResources.IsDirtyMapRotation = true;
-        }
-        public void ClearRotation()
-        {
-            lock (mResources._MapRotation)
-            {
-                if (mResources._MapRotation.Count == 0)
-                    return;
-
-                mResources._MapRotation.Clear();
-            }
-            mResources.IsDirtyMapRotation = true;
-        }
-
-        public void Reset()
         {
+            return new List<string>(mResources._MapRotation);
         }
     }
-}
+
+    public bool InRotation(string map)
+    {
+        map = map.ToUpperInvariant();
+
+        lock (mResources._MapRotation)
+        {
+            return mResources._MapRotation.Contains(map);
+        }
+    }
+
+    public bool RemoveFromRotation(string map)
+    {
+        map = map.ToUpperInvariant();
+
+        lock (mResources._MapRotation)
+        {
+            if (!mResources._MapRotation.Remove(map))
+                return false;
+        }
+
+        mResources.IsDirtyMapRotation = true;
+        return true;
+    }
+
+    public bool AddToRotation(string map)
+    {
+        map = map.ToUpperInvariant();
+
+        lock (mResources._MapRotation)
+        {
+            if (!mResources._MapRotation.Add(map))
+                return false;
+        }
+
+        mResources.IsDirtyMapRotation = true;
+        return true;
+    }
+
+    public void SetRotation(params string[] maps)
+    {
+        lock (mResources._MapRotation)
+        {
+            mResources._MapRotation.Clear();
+            foreach (var item in maps)
+                mResources._MapRotation.Add(item);
+        }
+
+        mResources.IsDirtyMapRotation = true;
+    }
+
+    public void ClearRotation()
+    {
+        lock (mResources._MapRotation)
+        {
+            if (mResources._MapRotation.Count == 0)
+                return;
+
+            mResources._MapRotation.Clear();
+        }
+
+        mResources.IsDirtyMapRotation = true;
+    }
+
+    public void Reset()
+    {
+    }
+}

BattleBitAPI/Server/Internal/PlayerModifications.cs

@@ -1,28 +1,28 @@
-namespace BattleBitAPI.Server
+namespace BattleBitAPI.Server;
-{
-    public class PlayerModifications<TPlayer> where TPlayer : Player<TPlayer>
-    {
-        private Player<TPlayer>.Internal @internal;
-        public PlayerModifications(Player<TPlayer>.Internal @internal)
-        {
-            this.@internal = @internal;
-        }
 
-        public float RunningSpeedMultiplier { get; set; }
+public class PlayerModifications<TPlayer> where TPlayer : Player<TPlayer>
-        public float ReceiveDamageMultiplier { get; set; }
+{
-        public float GiveDamageMultiplier { get; set; }
+    private Player<TPlayer>.Internal @internal;
-        public float JumpHeightMultiplier { get; set; }
+
-        public float FallDamageMultiplier { get; set; }
+    public PlayerModifications(Player<TPlayer>.Internal @internal)
-        public float ReloadSpeedMultiplier { get; set; }
+    {
-        public bool CanUseNightVision { get; set; }
+        this.@internal = @internal;
-        public bool HasCollision { get; set; }
-        public float DownTimeGiveUpTime { get; set; }
-        public bool AirStrafe { get; set; }
-        public bool CanSpawn { get; set; }
-        public bool CanSpectate { get; set; }
-        public bool IsTextChatMuted { get; set; }
-        public bool IsVoiceChatMuted { get; set; }
-        public float RespawnTime { get; set; }
-        public bool CanRespawn { get; set; }
     }
-}
+
+    public float RunningSpeedMultiplier { get; set; }
+    public float ReceiveDamageMultiplier { get; set; }
+    public float GiveDamageMultiplier { get; set; }
+    public float JumpHeightMultiplier { get; set; }
+    public float FallDamageMultiplier { get; set; }
+    public float ReloadSpeedMultiplier { get; set; }
+    public bool CanUseNightVision { get; set; }
+    public bool HasCollision { get; set; }
+    public float DownTimeGiveUpTime { get; set; }
+    public bool AirStrafe { get; set; }
+    public bool CanSpawn { get; set; }
+    public bool CanSpectate { get; set; }
+    public bool IsTextChatMuted { get; set; }
+    public bool IsVoiceChatMuted { get; set; }
+    public float RespawnTime { get; set; }
+    public bool CanRespawn { get; set; }
+}

BattleBitAPI/Server/Internal/RoundSettings.cs

@@ -1,69 +1,69 @@
 using BattleBitAPI.Common;
-using CommunityServerAPI.BattleBitAPI.Server;
 
-namespace BattleBitAPI.Server
+namespace BattleBitAPI.Server;
+
+public class RoundSettings<TPlayer> where TPlayer : Player<TPlayer>
 {
-    public class RoundSettings<TPlayer> where TPlayer : Player<TPlayer>
+    private readonly GameServer<TPlayer>.Internal mResources;
+
+    public RoundSettings(GameServer<TPlayer>.Internal resources)
     {
-        private GameServer<TPlayer>.Internal mResources;
+        mResources = resources;
-        public RoundSettings(GameServer<TPlayer>.Internal resources)
+    }
-        {
-            mResources = resources;
-        }
 
-        public GameState State
+    public GameState State => mResources._RoundSettings.State;
-        {
-            get => this.mResources._RoundSettings.State;
-        }
-        public double TeamATickets
-        {
-            get => this.mResources._RoundSettings.TeamATickets;
-            set
-            {
-                this.mResources._RoundSettings.TeamATickets = value;
-                this.mResources.IsDirtyRoundSettings = true;
-            }
-        }
-        public double TeamBTickets
-        {
-            get => this.mResources._RoundSettings.TeamBTickets;
-            set
-            {
-                this.mResources._RoundSettings.TeamBTickets = value;
-                this.mResources.IsDirtyRoundSettings = true;
-            }
-        }
-        public double MaxTickets
-        {
-            get => this.mResources._RoundSettings.MaxTickets;
-            set
-            {
-                this.mResources._RoundSettings.MaxTickets = value;
-                this.mResources.IsDirtyRoundSettings = true;
-            }
-        }
-        public int PlayersToStart
-        {
-            get => this.mResources._RoundSettings.PlayersToStart;
-            set
-            {
-                this.mResources._RoundSettings.PlayersToStart = value;
-                this.mResources.IsDirtyRoundSettings = true;
-            }
-        }
-        public int SecondsLeft
-        {
-            get => this.mResources._RoundSettings.SecondsLeft;
-            set
-            {
-                this.mResources._RoundSettings.SecondsLeft = value;
-                this.mResources.IsDirtyRoundSettings = true;
-            }
-        }
 
-        public void Reset()
+    public double TeamATickets
+    {
+        get => mResources._RoundSettings.TeamATickets;
+        set
         {
-
+            mResources._RoundSettings.TeamATickets = value;
+            mResources.IsDirtyRoundSettings = true;
         }
     }
-}
+
+    public double TeamBTickets
+    {
+        get => mResources._RoundSettings.TeamBTickets;
+        set
+        {
+            mResources._RoundSettings.TeamBTickets = value;
+            mResources.IsDirtyRoundSettings = true;
+        }
+    }
+
+    public double MaxTickets
+    {
+        get => mResources._RoundSettings.MaxTickets;
+        set
+        {
+            mResources._RoundSettings.MaxTickets = value;
+            mResources.IsDirtyRoundSettings = true;
+        }
+    }
+
+    public int PlayersToStart
+    {
+        get => mResources._RoundSettings.PlayersToStart;
+        set
+        {
+            mResources._RoundSettings.PlayersToStart = value;
+            mResources.IsDirtyRoundSettings = true;
+        }
+    }
+
+    public int SecondsLeft
+    {
+        get => mResources._RoundSettings.SecondsLeft;
+        set
+        {
+            mResources._RoundSettings.SecondsLeft = value;
+            mResources.IsDirtyRoundSettings = true;
+        }
+    }
+
+    public void Reset()
+    {
+    }
+}

BattleBitAPI/Server/Internal/ServerSettings.cs

@@ -1,91 +1,95 @@
-using CommunityServerAPI.BattleBitAPI.Server;
+namespace BattleBitAPI.Server;
 
-namespace BattleBitAPI.Server
+public class ServerSettings<TPlayer> where TPlayer : Player<TPlayer>
 {
-    public class ServerSettings<TPlayer> where TPlayer : Player<TPlayer>
+    private readonly GameServer<TPlayer>.Internal mResources;
+
+    public ServerSettings(GameServer<TPlayer>.Internal resources)
     {
-        private GameServer<TPlayer>.Internal mResources;
+        mResources = resources;
-        public ServerSettings(GameServer<TPlayer>.Internal resources)
+    }
-        {
-            mResources = resources;
-        }
 
-        public float DamageMultiplier
+    public float DamageMultiplier
+    {
+        get => mResources._RoomSettings.DamageMultiplier;
+        set
         {
-            get => mResources._RoomSettings.DamageMultiplier;
+            mResources._RoomSettings.DamageMultiplier = value;
-            set
+            mResources.IsDirtyRoomSettings = true;
-            {
-                mResources._RoomSettings.DamageMultiplier = value;
-                mResources.IsDirtyRoomSettings = true;
-            }
-        }
-        public bool BleedingEnabled
-        {
-            get => mResources._RoomSettings.BleedingEnabled;
-            set
-            {
-                mResources._RoomSettings.BleedingEnabled = value;
-                mResources.IsDirtyRoomSettings = true;
-            }
-        }
-        public bool StamineEnabled
-        {
-            get => mResources._RoomSettings.StaminaEnabled;
-            set
-            {
-                mResources._RoomSettings.StaminaEnabled = value;
-                mResources.IsDirtyRoomSettings = true;
-            }
-        }
-        public bool FriendlyFireEnabled
-        {
-            get => mResources._RoomSettings.FriendlyFireEnabled;
-            set
-            {
-                mResources._RoomSettings.FriendlyFireEnabled = value;
-                mResources.IsDirtyRoomSettings = true;
-            }
-        }
-        public bool OnlyWinnerTeamCanVote
-        {
-            get => mResources._RoomSettings.OnlyWinnerTeamCanVote;
-            set
-            {
-                mResources._RoomSettings.OnlyWinnerTeamCanVote = value;
-                mResources.IsDirtyRoomSettings = true;
-            }
-        }
-        public bool HitMarkersEnabled
-        {
-            get => mResources._RoomSettings.HitMarkersEnabled;
-            set
-            {
-                mResources._RoomSettings.HitMarkersEnabled = value;
-                mResources.IsDirtyRoomSettings = true;
-            }
-        }
-        public bool PointLogEnabled
-        {
-            get => mResources._RoomSettings.PointLogEnabled;
-            set
-            {
-                mResources._RoomSettings.PointLogEnabled = value;
-                mResources.IsDirtyRoomSettings = true;
-            }
-        }
-        public bool SpectatorEnabled
-        {
-            get => mResources._RoomSettings.SpectatorEnabled;
-            set
-            {
-                mResources._RoomSettings.SpectatorEnabled = value;
-                mResources.IsDirtyRoomSettings = true;
-            }
-        }
-
-        public void Reset()
-        {
-
         }
     }
-}
+
+    public bool BleedingEnabled
+    {
+        get => mResources._RoomSettings.BleedingEnabled;
+        set
+        {
+            mResources._RoomSettings.BleedingEnabled = value;
+            mResources.IsDirtyRoomSettings = true;
+        }
+    }
+
+    public bool StamineEnabled
+    {
+        get => mResources._RoomSettings.StaminaEnabled;
+        set
+        {
+            mResources._RoomSettings.StaminaEnabled = value;
+            mResources.IsDirtyRoomSettings = true;
+        }
+    }
+
+    public bool FriendlyFireEnabled
+    {
+        get => mResources._RoomSettings.FriendlyFireEnabled;
+        set
+        {
+            mResources._RoomSettings.FriendlyFireEnabled = value;
+            mResources.IsDirtyRoomSettings = true;
+        }
+    }
+
+    public bool OnlyWinnerTeamCanVote
+    {
+        get => mResources._RoomSettings.OnlyWinnerTeamCanVote;
+        set
+        {
+            mResources._RoomSettings.OnlyWinnerTeamCanVote = value;
+            mResources.IsDirtyRoomSettings = true;
+        }
+    }
+
+    public bool HitMarkersEnabled
+    {
+        get => mResources._RoomSettings.HitMarkersEnabled;
+        set
+        {
+            mResources._RoomSettings.HitMarkersEnabled = value;
+            mResources.IsDirtyRoomSettings = true;
+        }
+    }
+
+    public bool PointLogEnabled
+    {
+        get => mResources._RoomSettings.PointLogEnabled;
+        set
+        {
+            mResources._RoomSettings.PointLogEnabled = value;
+            mResources.IsDirtyRoomSettings = true;
+        }
+    }
+
+    public bool SpectatorEnabled
+    {
+        get => mResources._RoomSettings.SpectatorEnabled;
+        set
+        {
+            mResources._RoomSettings.SpectatorEnabled = value;
+            mResources.IsDirtyRoomSettings = true;
+        }
+    }
+
+    public void Reset()
+    {
+    }
+}

BattleBitAPI/Server/Player.cs

@@ -1,364 +1,395 @@
-using BattleBitAPI.Common;
+using System.Net;
-using BattleBitAPI.Server;
-using System.Net;
 using System.Numerics;
+using BattleBitAPI.Common;
+using BattleBitAPI.Server;
+using Stream = BattleBitAPI.Common.Serialization.Stream;
 
-namespace BattleBitAPI
+namespace BattleBitAPI;
+
+public class Player<TPlayer> where TPlayer : Player<TPlayer>
 {
-    public class Player<TPlayer> where TPlayer : Player<TPlayer>
+    private Internal mInternal;
+
+    // ---- Variables ----
+    public ulong SteamID => mInternal.SteamID;
+    public string Name => mInternal.Name;
+    public IPAddress IP => mInternal.IP;
+    public GameServer<TPlayer> GameServer => mInternal.GameServer;
+
+    public GameRole Role
     {
-        private Internal mInternal;
+        get => mInternal.Role;
-
+        set
-        // ---- Variables ----
-        public ulong SteamID => mInternal.SteamID;
-        public string Name => mInternal.Name;
-        public IPAddress IP => mInternal.IP;
-        public GameServer<TPlayer> GameServer => mInternal.GameServer;
-        public GameRole Role
         {
-            get => mInternal.Role;
+            if (value == mInternal.Role)
-            set
+                return;
-            {
+            SetNewRole(value);
-                if (value == mInternal.Role)
-                    return;
-                SetNewRole(value);
-            }
-        }
-        public Team Team
-        {
-            get => mInternal.Team;
-            set
-            {
-                if (mInternal.Team != value)
-                    ChangeTeam(value);
-            }
-        }
-        public Squads Squad
-        {
-            get => mInternal.Squad;
-            set
-            {
-                if (value == mInternal.Squad)
-                    return;
-                if (value == Squads.NoSquad)
-                    KickFromSquad();
-                else
-                    JoinSquad(value);
-            }
-        }
-        public bool InSquad => mInternal.Squad != Squads.NoSquad;
-        public int PingMs => mInternal.PingMs;
-
-        public float HP => mInternal.HP;
-        public bool IsAlive => mInternal.HP >= 0f;
-        public bool IsUp => mInternal.HP > 0f;
-        public bool IsDown => mInternal.HP == 0f;
-        public bool IsDead => mInternal.HP == -1f;
-
-        public Vector3 Position
-        {
-            get => mInternal.Position;
-            set => Teleport(value);
-        }
-        public PlayerStand StandingState => mInternal.Standing;
-        public LeaningSide LeaningState => mInternal.Leaning;
-        public LoadoutIndex CurrentLoadoutIndex => mInternal.CurrentLoadoutIndex;
-        public bool InVehicle => mInternal.InVehicle;
-        public bool IsBleeding => mInternal.IsBleeding;
-        public PlayerLoadout CurrentLoadout => mInternal.CurrentLoadout;
-        public PlayerWearings CurrentWearings => mInternal.CurrentWearings;
-        public PlayerModifications<TPlayer> Modifications => mInternal.Modifications;
-
-        // ---- Events ----
-        public virtual void OnCreated()
-        {
-
-        }
-
-        public virtual async Task OnConnected()
-        {
-
-        }
-        public virtual async Task OnSpawned()
-        {
-
-        }
-        public virtual async Task OnDowned()
-        {
-
-        }
-        public virtual async Task OnGivenUp()
-        {
-
-        }
-        public virtual async Task OnRevivedByAnotherPlayer()
-        {
-
-        }
-        public virtual async Task OnRevivedAnotherPlayer()
-        {
-
-        }
-        public virtual async Task OnDied()
-        {
-
-        }
-        public virtual async Task OnChangedTeam()
-        {
-
-        }
-        public virtual async Task OnChangedRole(GameRole newRole)
-        {
-
-        }
-        public virtual async Task OnJoinedSquad(Squads newSquad)
-        {
-
-        }
-        public virtual async Task OnLeftSquad(Squads oldSquad)
-        {
-
-        }
-        public virtual async Task OnDisconnected()
-        {
-
-        }
-
-        // ---- Functions ----
-        public void Kick(string reason = "")
-        {
-            GameServer.Kick(this, reason);
-        }
-        public void Kill()
-        {
-            GameServer.Kill(this);
-        }
-        public void ChangeTeam()
-        {
-            GameServer.ChangeTeam(this);
-        }
-        public void ChangeTeam(Team team)
-        {
-            GameServer.ChangeTeam(this, team);
-        }
-        public void KickFromSquad()
-        {
-            GameServer.KickFromSquad(this);
-        }
-        public void JoinSquad(Squads targetSquad)
-        {
-            GameServer.JoinSquad(this, targetSquad);
-        }
-        public void DisbandTheSquad()
-        {
-            GameServer.DisbandPlayerCurrentSquad(this);
-        }
-        public void PromoteToSquadLeader()
-        {
-            GameServer.PromoteSquadLeader(this);
-        }
-        public void WarnPlayer(string msg)
-        {
-            GameServer.WarnPlayer(this, msg);
-        }
-        public void Message(string msg)
-        {
-            GameServer.MessageToPlayer(this, msg);
-        }
-        public void Message(string msg, float fadeoutTime)
-        {
-            GameServer.MessageToPlayer(this, msg, fadeoutTime);
-        }
-        public void SetNewRole(GameRole role)
-        {
-            GameServer.SetRoleTo(this, role);
-        }
-        public void Teleport(Vector3 target)
-        {
-
-        }
-        public void SpawnPlayer(PlayerLoadout loadout, PlayerWearings wearings, Vector3 position, Vector3 lookDirection, PlayerStand stand, float spawnProtection)
-        {
-            GameServer.SpawnPlayer(this, loadout, wearings, position, lookDirection, stand, spawnProtection);
-        }
-        public void SetHP(float newHP)
-        {
-            GameServer.SetHP(this, newHP);
-        }
-        public void GiveDamage(float damage)
-        {
-            GameServer.GiveDamage(this, damage);
-        }
-        public void Heal(float hp)
-        {
-            GameServer.Heal(this, hp);
-        }
-        public void SetRunningSpeedMultiplier(float value)
-        {
-            GameServer.SetRunningSpeedMultiplier(this, value);
-        }
-        public void SetReceiveDamageMultiplier(float value)
-        {
-            GameServer.SetReceiveDamageMultiplier(this, value);
-        }
-        public void SetGiveDamageMultiplier(float value)
-        {
-            GameServer.SetGiveDamageMultiplier(this, value);
-        }
-        public void SetJumpMultiplier(float value)
-        {
-            GameServer.SetJumpMultiplier(this, value);
-        }
-        public void SetFallDamageMultiplier(float value)
-        {
-            GameServer.SetFallDamageMultiplier(this, value);
-        }
-        public void SetPrimaryWeapon(WeaponItem item, int extraMagazines, bool clear = false)
-        {
-            GameServer.SetPrimaryWeapon(this, item, extraMagazines, clear);
-        }
-        public void SetSecondaryWeapon(WeaponItem item, int extraMagazines, bool clear = false)
-        {
-            GameServer.SetSecondaryWeapon(this, item, extraMagazines, clear);
-        }
-        public void SetFirstAidGadget(string item, int extra, bool clear = false)
-        {
-            GameServer.SetFirstAid(this, item, extra, clear);
-        }
-        public void SetLightGadget(string item, int extra, bool clear = false)
-        {
-            GameServer.SetLightGadget(this, item, extra, clear);
-        }
-        public void SetHeavyGadget(string item, int extra, bool clear = false)
-        {
-            GameServer.SetHeavyGadget(this, item, extra, clear);
-        }
-        public void SetThrowable(string item, int extra, bool clear = false)
-        {
-            GameServer.SetThrowable(this, item, extra, clear);
-        }
-
-        // ---- Static ----
-        public static TPlayer CreateInstance<TPlayer>(Player<TPlayer>.Internal @internal) where TPlayer : Player<TPlayer>
-        {
-            TPlayer player = (TPlayer)Activator.CreateInstance(typeof(TPlayer));
-            player.mInternal = @internal;
-            return player;
-        }
-
-        // ---- Overrides ----
-        public override string ToString()
-        {
-            return Name + " (" + SteamID + ")";
-        }
-
-        // ---- Internal ----
-        public class Internal
-        {
-            public ulong SteamID;
-            public string Name;
-            public IPAddress IP;
-            public GameServer<TPlayer> GameServer;
-            public GameRole Role;
-            public Team Team;
-            public Squads Squad;
-            public int PingMs = 999;
-
-            public bool IsAlive;
-            public float HP;
-            public Vector3 Position;
-            public PlayerStand Standing;
-            public LeaningSide Leaning;
-            public LoadoutIndex CurrentLoadoutIndex;
-            public bool InVehicle;
-            public bool IsBleeding;
-            public PlayerLoadout CurrentLoadout;
-            public PlayerWearings CurrentWearings;
-
-            public mPlayerModifications _Modifications;
-            public PlayerModifications<TPlayer> Modifications;
-
-            public Internal()
-            {
-                this.Modifications = new PlayerModifications<TPlayer>(this);
-                this._Modifications = new mPlayerModifications();
-            }
-
-            public void OnDie()
-            {
-                IsAlive = false;
-                HP = -1f;
-                Position = default;
-                Standing = PlayerStand.Standing;
-                Leaning = LeaningSide.None;
-                CurrentLoadoutIndex = LoadoutIndex.Primary;
-                InVehicle = false;
-                IsBleeding = false;
-                CurrentLoadout = new PlayerLoadout();
-                CurrentWearings = new PlayerWearings();
-            }
-        }
-        public class mPlayerModifications
-        {
-            public float RunningSpeedMultiplier = 1f;
-            public float ReceiveDamageMultiplier = 1f;
-            public float GiveDamageMultiplier = 1f;
-            public float JumpHeightMultiplier = 1f;
-            public float FallDamageMultiplier = 1f;
-            public float ReloadSpeedMultiplier = 1f;
-            public bool CanUseNightVision = true;
-            public bool HasCollision = false;
-            public float DownTimeGiveUpTime = 60f;
-            public bool AirStrafe = true;
-            public bool CanSpawn = true;
-            public bool CanSpectate = true;
-            public bool IsTextChatMuted = false;
-            public bool IsVoiceChatMuted = false;
-            public float RespawnTime = 10f;
-            public bool CanRespawn = true;
-
-            public bool IsDirtyFlag = false;
-            public void Write(BattleBitAPI.Common.Serialization.Stream ser)
-            {
-                ser.Write(this.RunningSpeedMultiplier);
-                ser.Write(this.ReceiveDamageMultiplier);
-                ser.Write(this.GiveDamageMultiplier);
-                ser.Write(this.JumpHeightMultiplier);
-                ser.Write(this.FallDamageMultiplier);
-                ser.Write(this.ReloadSpeedMultiplier);
-                ser.Write(this.CanUseNightVision);
-                ser.Write(this.HasCollision);
-                ser.Write(this.DownTimeGiveUpTime);
-                ser.Write(this.AirStrafe);
-                ser.Write(this.CanSpawn);
-                ser.Write(this.CanSpectate);
-                ser.Write(this.IsTextChatMuted);
-                ser.Write(this.IsVoiceChatMuted);
-                ser.Write(this.RespawnTime);
-                ser.Write(this.CanRespawn);
-            }
-            public void Read(BattleBitAPI.Common.Serialization.Stream ser)
-            {
-                this.RunningSpeedMultiplier = ser.ReadFloat();
-                if (this.RunningSpeedMultiplier <= 0f)
-                    this.RunningSpeedMultiplier = 0.01f;
-
-                this.ReceiveDamageMultiplier = ser.ReadFloat();
-                this.GiveDamageMultiplier = ser.ReadFloat();
-                this.JumpHeightMultiplier = ser.ReadFloat();
-                this.FallDamageMultiplier = ser.ReadFloat();
-                this.ReloadSpeedMultiplier = ser.ReadFloat();
-                this.CanUseNightVision = ser.ReadBool();
-                this.HasCollision = ser.ReadBool();
-                this.DownTimeGiveUpTime = ser.ReadFloat();
-                this.AirStrafe = ser.ReadBool();
-                this.CanSpawn = ser.ReadBool();
-                this.CanSpectate = ser.ReadBool();
-                this.IsTextChatMuted = ser.ReadBool();
-                this.IsVoiceChatMuted = ser.ReadBool();
-                this.RespawnTime = ser.ReadFloat();
-                this.CanRespawn = ser.ReadBool();
-            }
         }
     }
-}
+
+    public Team Team
+    {
+        get => mInternal.Team;
+        set
+        {
+            if (mInternal.Team != value)
+                ChangeTeam(value);
+        }
+    }
+
+    public Squads Squad
+    {
+        get => mInternal.Squad;
+        set
+        {
+            if (value == mInternal.Squad)
+                return;
+            if (value == Squads.NoSquad)
+                KickFromSquad();
+            else
+                JoinSquad(value);
+        }
+    }
+
+    public bool InSquad => mInternal.Squad != Squads.NoSquad;
+    public int PingMs => mInternal.PingMs;
+
+    public float HP => mInternal.HP;
+    public bool IsAlive => mInternal.HP >= 0f;
+    public bool IsUp => mInternal.HP > 0f;
+    public bool IsDown => mInternal.HP == 0f;
+    public bool IsDead => mInternal.HP == -1f;
+
+    public Vector3 Position
+    {
+        get => mInternal.Position;
+        set => Teleport(value);
+    }
+
+    public PlayerStand StandingState => mInternal.Standing;
+    public LeaningSide LeaningState => mInternal.Leaning;
+    public LoadoutIndex CurrentLoadoutIndex => mInternal.CurrentLoadoutIndex;
+    public bool InVehicle => mInternal.InVehicle;
+    public bool IsBleeding => mInternal.IsBleeding;
+    public PlayerLoadout CurrentLoadout => mInternal.CurrentLoadout;
+    public PlayerWearings CurrentWearings => mInternal.CurrentWearings;
+    public PlayerModifications<TPlayer> Modifications => mInternal.Modifications;
+
+    // ---- Events ----
+    public virtual void OnCreated()
+    {
+    }
+
+    public virtual async Task OnConnected()
+    {
+    }
+
+    public virtual async Task OnSpawned()
+    {
+    }
+
+    public virtual async Task OnDowned()
+    {
+    }
+
+    public virtual async Task OnGivenUp()
+    {
+    }
+
+    public virtual async Task OnRevivedByAnotherPlayer()
+    {
+    }
+
+    public virtual async Task OnRevivedAnotherPlayer()
+    {
+    }
+
+    public virtual async Task OnDied()
+    {
+    }
+
+    public virtual async Task OnChangedTeam()
+    {
+    }
+
+    public virtual async Task OnChangedRole(GameRole newRole)
+    {
+    }
+
+    public virtual async Task OnJoinedSquad(Squads newSquad)
+    {
+    }
+
+    public virtual async Task OnLeftSquad(Squads oldSquad)
+    {
+    }
+
+    public virtual async Task OnDisconnected()
+    {
+    }
+
+    // ---- Functions ----
+    public void Kick(string reason = "")
+    {
+        GameServer.Kick(this, reason);
+    }
+
+    public void Kill()
+    {
+        GameServer.Kill(this);
+    }
+
+    public void ChangeTeam()
+    {
+        GameServer.ChangeTeam(this);
+    }
+
+    public void ChangeTeam(Team team)
+    {
+        GameServer.ChangeTeam(this, team);
+    }
+
+    public void KickFromSquad()
+    {
+        GameServer.KickFromSquad(this);
+    }
+
+    public void JoinSquad(Squads targetSquad)
+    {
+        GameServer.JoinSquad(this, targetSquad);
+    }
+
+    public void DisbandTheSquad()
+    {
+        GameServer.DisbandPlayerCurrentSquad(this);
+    }
+
+    public void PromoteToSquadLeader()
+    {
+        GameServer.PromoteSquadLeader(this);
+    }
+
+    public void WarnPlayer(string msg)
+    {
+        GameServer.WarnPlayer(this, msg);
+    }
+
+    public void Message(string msg)
+    {
+        GameServer.MessageToPlayer(this, msg);
+    }
+
+    public void Message(string msg, float fadeoutTime)
+    {
+        GameServer.MessageToPlayer(this, msg, fadeoutTime);
+    }
+
+    public void SetNewRole(GameRole role)
+    {
+        GameServer.SetRoleTo(this, role);
+    }
+
+    public void Teleport(Vector3 target)
+    {
+    }
+
+    public void SpawnPlayer(PlayerLoadout loadout, PlayerWearings wearings, Vector3 position, Vector3 lookDirection, PlayerStand stand, float spawnProtection)
+    {
+        GameServer.SpawnPlayer(this, loadout, wearings, position, lookDirection, stand, spawnProtection);
+    }
+
+    public void SetHP(float newHP)
+    {
+        GameServer.SetHP(this, newHP);
+    }
+
+    public void GiveDamage(float damage)
+    {
+        GameServer.GiveDamage(this, damage);
+    }
+
+    public void Heal(float hp)
+    {
+        GameServer.Heal(this, hp);
+    }
+
+    public void SetRunningSpeedMultiplier(float value)
+    {
+        GameServer.SetRunningSpeedMultiplier(this, value);
+    }
+
+    public void SetReceiveDamageMultiplier(float value)
+    {
+        GameServer.SetReceiveDamageMultiplier(this, value);
+    }
+
+    public void SetGiveDamageMultiplier(float value)
+    {
+        GameServer.SetGiveDamageMultiplier(this, value);
+    }
+
+    public void SetJumpMultiplier(float value)
+    {
+        GameServer.SetJumpMultiplier(this, value);
+    }
+
+    public void SetFallDamageMultiplier(float value)
+    {
+        GameServer.SetFallDamageMultiplier(this, value);
+    }
+
+    public void SetPrimaryWeapon(WeaponItem item, int extraMagazines, bool clear = false)
+    {
+        GameServer.SetPrimaryWeapon(this, item, extraMagazines, clear);
+    }
+
+    public void SetSecondaryWeapon(WeaponItem item, int extraMagazines, bool clear = false)
+    {
+        GameServer.SetSecondaryWeapon(this, item, extraMagazines, clear);
+    }
+
+    public void SetFirstAidGadget(string item, int extra, bool clear = false)
+    {
+        GameServer.SetFirstAid(this, item, extra, clear);
+    }
+
+    public void SetLightGadget(string item, int extra, bool clear = false)
+    {
+        GameServer.SetLightGadget(this, item, extra, clear);
+    }
+
+    public void SetHeavyGadget(string item, int extra, bool clear = false)
+    {
+        GameServer.SetHeavyGadget(this, item, extra, clear);
+    }
+
+    public void SetThrowable(string item, int extra, bool clear = false)
+    {
+        GameServer.SetThrowable(this, item, extra, clear);
+    }
+
+    // ---- Static ----
+    public static TPlayer CreateInstance<TPlayer>(Player<TPlayer>.Internal @internal) where TPlayer : Player<TPlayer>
+    {
+        var player = (TPlayer)Activator.CreateInstance(typeof(TPlayer));
+        player.mInternal = @internal;
+        return player;
+    }
+
+    // ---- Overrides ----
+    public override string ToString()
+    {
+        return Name + " (" + SteamID + ")";
+    }
+
+    // ---- Internal ----
+    public class Internal
+    {
+        public mPlayerModifications _Modifications;
+        public PlayerLoadout CurrentLoadout;
+        public LoadoutIndex CurrentLoadoutIndex;
+        public PlayerWearings CurrentWearings;
+        public GameServer<TPlayer> GameServer;
+        public float HP;
+        public bool InVehicle;
+        public IPAddress IP;
+
+        public bool IsAlive;
+        public bool IsBleeding;
+        public LeaningSide Leaning;
+        public PlayerModifications<TPlayer> Modifications;
+        public string Name;
+        public int PingMs = 999;
+        public Vector3 Position;
+        public GameRole Role;
+        public Squads Squad;
+        public PlayerStand Standing;
+        public ulong SteamID;
+        public Team Team;
+
+        public Internal()
+        {
+            Modifications = new PlayerModifications<TPlayer>(this);
+            _Modifications = new mPlayerModifications();
+        }
+
+        public void OnDie()
+        {
+            IsAlive = false;
+            HP = -1f;
+            Position = default;
+            Standing = PlayerStand.Standing;
+            Leaning = LeaningSide.None;
+            CurrentLoadoutIndex = LoadoutIndex.Primary;
+            InVehicle = false;
+            IsBleeding = false;
+            CurrentLoadout = new PlayerLoadout();
+            CurrentWearings = new PlayerWearings();
+        }
+    }
+
+    public class mPlayerModifications
+    {
+        public bool AirStrafe = true;
+        public bool CanRespawn = true;
+        public bool CanSpawn = true;
+        public bool CanSpectate = true;
+        public bool CanUseNightVision = true;
+        public float DownTimeGiveUpTime = 60f;
+        public float FallDamageMultiplier = 1f;
+        public float GiveDamageMultiplier = 1f;
+        public bool HasCollision;
+
+        public bool IsDirtyFlag = false;
+        public bool IsTextChatMuted;
+        public bool IsVoiceChatMuted;
+        public float JumpHeightMultiplier = 1f;
+        public float ReceiveDamageMultiplier = 1f;
+        public float ReloadSpeedMultiplier = 1f;
+        public float RespawnTime = 10f;
+        public float RunningSpeedMultiplier = 1f;
+
+        public void Write(Stream ser)
+        {
+            ser.Write(RunningSpeedMultiplier);
+            ser.Write(ReceiveDamageMultiplier);
+            ser.Write(GiveDamageMultiplier);
+            ser.Write(JumpHeightMultiplier);
+            ser.Write(FallDamageMultiplier);
+            ser.Write(ReloadSpeedMultiplier);
+            ser.Write(CanUseNightVision);
+            ser.Write(HasCollision);
+            ser.Write(DownTimeGiveUpTime);
+            ser.Write(AirStrafe);
+            ser.Write(CanSpawn);
+            ser.Write(CanSpectate);
+            ser.Write(IsTextChatMuted);
+            ser.Write(IsVoiceChatMuted);
+            ser.Write(RespawnTime);
+            ser.Write(CanRespawn);
+        }
+
+        public void Read(Stream ser)
+        {
+            RunningSpeedMultiplier = ser.ReadFloat();
+            if (RunningSpeedMultiplier <= 0f)
+                RunningSpeedMultiplier = 0.01f;
+
+            ReceiveDamageMultiplier = ser.ReadFloat();
+            GiveDamageMultiplier = ser.ReadFloat();
+            JumpHeightMultiplier = ser.ReadFloat();
+            FallDamageMultiplier = ser.ReadFloat();
+            ReloadSpeedMultiplier = ser.ReadFloat();
+            CanUseNightVision = ser.ReadBool();
+            HasCollision = ser.ReadBool();
+            DownTimeGiveUpTime = ser.ReadFloat();
+            AirStrafe = ser.ReadBool();
+            CanSpawn = ser.ReadBool();
+            CanSpectate = ser.ReadBool();
+            IsTextChatMuted = ser.ReadBool();
+            IsVoiceChatMuted = ser.ReadBool();
+            RespawnTime = ser.ReadFloat();
+            CanRespawn = ser.ReadBool();
+        }
+    }
+}

BattleBitAPI/Storage/DiskStorage.cs

@@ -1,41 +1,45 @@
 using BattleBitAPI.Common;
 
-namespace BattleBitAPI.Storage
+namespace BattleBitAPI.Storage;
+
+public class DiskStorage : IPlayerStatsDatabase
 {
-    public class DiskStorage : IPlayerStatsDatabase
+    private readonly string mDirectory;
+
+    public DiskStorage(string directory)
     {
-        private string mDirectory;
+        var info = new DirectoryInfo(directory);
-        public DiskStorage(string directory)
+        if (!info.Exists)
-        {
+            info.Create();
-            var info = new DirectoryInfo(directory);
-            if (!info.Exists)
-                info.Create();
 
-            this.mDirectory = info.FullName + Path.DirectorySeparatorChar;
+        mDirectory = info.FullName + Path.DirectorySeparatorChar;
-        }
+    }
 
-        public async Task<PlayerStats> GetPlayerStatsOf(ulong steamID)
+    public async Task<PlayerStats> GetPlayerStatsOf(ulong steamID)
-        {
+    {
-            var file = this.mDirectory + steamID + ".data";
+        var file = mDirectory + steamID + ".data";
-            if (File.Exists(file))
+        if (File.Exists(file))
-            {
-                try
-                {
-                    var data = await File.ReadAllBytesAsync(file);
-                    return new PlayerStats(data);
-                }
-                catch { }
-            }
-            return null;
-        }
-        public async Task SavePlayerStatsOf(ulong steamID, PlayerStats stats)
-        {
-            var file = this.mDirectory + steamID + ".data";
             try
             {
-                await File.WriteAllBytesAsync(file, stats.SerializeToByteArray());
+                var data = await File.ReadAllBytesAsync(file);
+                return new PlayerStats(data);
             }
-            catch { }
+            catch
+            {
+            }
+
+        return null;
+    }
+
+    public async Task SavePlayerStatsOf(ulong steamID, PlayerStats stats)
+    {
+        var file = mDirectory + steamID + ".data";
+        try
+        {
+            await File.WriteAllBytesAsync(file, stats.SerializeToByteArray());
+        }
+        catch
+        {
         }
     }
-}
+}

BattleBitAPI/Storage/IPlayerStatsDatabase.cs

@@ -1,10 +1,9 @@
 using BattleBitAPI.Common;
 
-namespace BattleBitAPI.Storage
+namespace BattleBitAPI.Storage;
+
+public interface IPlayerStatsDatabase
 {
-    public interface IPlayerStatsDatabase
+    public Task<PlayerStats> GetPlayerStatsOf(ulong steamID);
-    {
+    public Task SavePlayerStatsOf(ulong steamID, PlayerStats stats);
-        public Task<PlayerStats> GetPlayerStatsOf(ulong steamID);
+}
-        public Task SavePlayerStatsOf(ulong steamID, PlayerStats stats);
-    }
-}

Program.cs

@@ -1,28 +1,26 @@
 using BattleBitAPI;
 using BattleBitAPI.Common;
 using BattleBitAPI.Server;
-using System.Threading.Channels;
-using System.Xml;
 
-class Program
+internal class Program
 {
-    static void Main(string[] args)
+    private static void Main(string[] args)
     {
         var listener = new ServerListener<MyPlayer, MyGameServer>();
         listener.Start(29294);
 
         Thread.Sleep(-1);
     }
-
-
 }
-class MyPlayer : Player<MyPlayer>
+
+internal class MyPlayer : Player<MyPlayer>
 {
     public override async Task OnConnected()
     {
     }
 }
-class MyGameServer : GameServer<MyPlayer>
+
+internal class MyGameServer : GameServer<MyPlayer>
 {
     public override async Task OnConnected()
     {
@@ -36,28 +34,34 @@ class MyGameServer : GameServer<MyPlayer>
     {
         await Console.Out.WriteLineAsync("Connected: " + player);
     }
+
     public override async Task OnPlayerSpawned(MyPlayer player)
     {
         await Console.Out.WriteLineAsync("Spawned: " + player);
     }
+
     public override async Task OnAPlayerDownedAnotherPlayer(OnPlayerKillArguments<MyPlayer> args)
     {
         await Console.Out.WriteLineAsync("Downed: " + args.Victim);
     }
+
     public override async Task OnPlayerGivenUp(MyPlayer player)
     {
         await Console.Out.WriteLineAsync("Giveup: " + player);
     }
+
     public override async Task OnPlayerDied(MyPlayer player)
     {
         await Console.Out.WriteLineAsync("Died: " + player);
     }
+
     public override async Task OnAPlayerRevivedAnotherPlayer(MyPlayer from, MyPlayer to)
     {
         await Console.Out.WriteLineAsync(from + " revived " + to);
     }
+
     public override async Task OnPlayerDisconnected(MyPlayer player)
     {
         await Console.Out.WriteLineAsync("Disconnected: " + player);
     }
-}
+}