fix(server): use arrays instead of integer dictionaries

DanielMcAssey · Jan 12, 2025 · fe01e8f · fe01e8f
1 parent 69031f1
commit fe01e8f
Show file tree

Hide file tree

Showing 8 changed files with 42 additions and 52 deletions.
diff --git a/GLOKON.Baiters.Core/BaitersServer.cs b/GLOKON.Baiters.Core/BaitersServer.cs
@@ -203,7 +203,7 @@ public void RemoveActor(long actorId)
             {
                 ["actor_id"] = actorId,
                 ["action"] = "queue_free",
-                ["params"] = new Dictionary<int, object>(),
+                ["params"] = Array.Empty<object>(),
             }, DataChannel.GameState);
 
             _actors.TryRemove(actorId, out _);
@@ -243,7 +243,7 @@ public void SendLetter(ulong toSteamId, string header, string body, string closi
                     ["closing"] = closing,
                     ["user"] = user,
                     ["letter_id"] = new Random().Next(),
-                    ["items"] = new Dictionary<int, object>(),
+                    ["items"] = Array.Empty<object>(),
                 },
             }, DataChannel.GameState, toSteamId);
         }
@@ -401,22 +401,16 @@ protected void HandleNetworkPacket(ulong sender, byte[] data, DataChannel channe
 
         protected void SendWebLobbyPacket(ulong? steamId = null)
         {
-            Dictionary<int, object> usersInServer = new()
-            {
-                [0] = (long)ServerId,
-            };
-
-            int userIndex = usersInServer.Count; // Start at 1 as server user is 0
+            List<long> usersInServer = [(long)ServerId];
 
             foreach (var player in _players)
             {
-                usersInServer[userIndex] = (long)player.Key;
-                userIndex++;
+                usersInServer.Add((long)player.Key);
             }
 
             SendPacket(new("receive_weblobby")
             {
-                ["weblobby"] = usersInServer
+                ["weblobby"] = usersInServer.ToArray(),
             }, DataChannel.GameState, steamId);
         }
 

diff --git a/GLOKON.Baiters.Core/Models/Actor/ChalkCanvas.cs b/GLOKON.Baiters.Core/Models/Actor/ChalkCanvas.cs
@@ -13,32 +13,28 @@ public void Draw(Vector2 position, int color)
             ChalkPoints[position] = color;
         }
 
-        public Dictionary<int, object> GetPacket()
+        public Array GetPacket()
         {
-            Dictionary<int, object> packet = [];
-            ulong imageIndex = 0;
+            Array packet = Array.CreateInstance(typeof(object), ChalkPoints.Count);
+            int imageIndex = 0;
 
             foreach (var position in ChalkPoints.Keys)
             {
-                Dictionary<int, object> packetPart = [];
-
-                packetPart[0] = position;
-                packetPart[1] = ChalkPoints[position];
-                packet[(int)imageIndex] = packetPart; // Potential integer overflow here, does it matter?
+                packet.SetValue(new object[] { position, ChalkPoints[position] }, imageIndex);
                 imageIndex++;
             }
 
             return packet;
         }
 
-        public void UpdateFromPacket(Dictionary<int, object> packet)
+        public void UpdateFromPacket(Array packet)
         {
-            foreach (var rawPacketPart in packet.Values)
+            foreach (var rawPacketPart in packet)
             {
-                var packetPart = (Dictionary<int, object>)rawPacketPart;
-                var pktPosition = (Vector2)packetPart[0];
+                var packetPart = (Array)rawPacketPart;
+                var pktPosition = (Vector2)(packetPart.GetValue(0) ?? Vector2.Zero);
                 var position = new Vector2((int)Math.Round(pktPosition.X), (int)Math.Round(pktPosition.Y));
-                ChalkPoints[position] = (int)packetPart[1];
+                ChalkPoints[position] = (int)(packetPart.GetValue(1) ?? 0);
             }
         }
     }

diff --git a/GLOKON.Baiters.Core/Packets/Handlers/ActorActionHandler.cs b/GLOKON.Baiters.Core/Packets/Handlers/ActorActionHandler.cs
@@ -11,11 +11,11 @@ public void Handle(ulong sender, Packet data)
             switch ((string)data["action"])
             {
                 case "_sync_create_bubble":
-                    string chatMssage = (string)((Dictionary<int, object>)data["params"])[0];
+                    string chatMssage = (string)(((Array)data["params"]).GetValue(0) ?? -1);
                     server.OnPlayerChat(sender, chatMssage);
                     break;
                 case "_wipe_actor":
-                    long wipeActorId = (long)((Dictionary<int, object>)data["params"])[0];
+                    long wipeActorId = (long)(((Array)data["params"]).GetValue(0) ?? -1);
                     if (server.TryGetActor(wipeActorId, out var actor) && actor != null)
                     {
                         if (ActorType.ServerOnly.Contains(actor.Type))

diff --git a/GLOKON.Baiters.Core/Packets/Handlers/ChalkPacketHandler.cs b/GLOKON.Baiters.Core/Packets/Handlers/ChalkPacketHandler.cs
@@ -22,7 +22,7 @@ public void Handle(ulong sender, Packet data)
                 server.AddActor(canvasId, canvas);
             }
 
-            canvas.UpdateFromPacket((Dictionary<int, object>)data["data"]);
+            canvas.UpdateFromPacket((Array)data["data"]);
         }
     }
 }
diff --git a/GLOKON.Baiters.Core/Packets/Handlers/NewPlayerJoinHandler.cs b/GLOKON.Baiters.Core/Packets/Handlers/NewPlayerJoinHandler.cs
@@ -38,34 +38,33 @@ private async Task SendChalkPacketsAsync(ulong steamId)
                 foreach (KeyValuePair<long, Actor> actor in server.GetActorsByType(ActorType.ChalkCanvas))
                 {
                     ChalkCanvas canvas = (ChalkCanvas)actor.Value;
-                    Dictionary<int, object> chalkPkt = canvas.GetPacket();
 
                     // split the dictionary into chunks of 100
-                    List<Dictionary<int, object>> chunks = [];
-                    Dictionary<int, object> chunk = [];
+                    List<object[]> chunks = [];
+                    List<object> chunk = [];
 
-                    int i = 0;
-                    foreach (var kvp in chalkPkt)
+                    int chunkIndex = 0;
+                    foreach (var chalkData in canvas.GetPacket())
                     {
-                        if (i >= 1000)
+                        if (chunkIndex >= 1000)
                         {
-                            chunks.Add(chunk);
-                            chunk = [];
-                            i = 0;
+                            chunks.Add(chunk.ToArray());
+                            chunk.Clear();
+                            chunkIndex = 0;
                         }
 
-                        chunk.Add(i, kvp.Value);
-                        i++;
+                        chunk.Add(chalkData);
+                        chunkIndex++;
                     }
 
-                    chunks.Add(chunk);
+                    chunks.Add(chunk.ToArray());
 
-                    for (int index = 0; index < chunks.Count; index++)
+                    foreach (var chunkToSend in chunks)
                     {
                         server.SendPacket(new("chalk_packet")
                         {
                             ["canvas_id"] = actor.Key,
-                            ["data"] = chunks[index],
+                            ["data"] = chunkToSend,
                         }, DataChannel.Chalk, steamId);
                         await Task.Delay(10);
                     }

diff --git a/GLOKON.Baiters.Core/Packets/Handlers/RequestActorsHandler.cs b/GLOKON.Baiters.Core/Packets/Handlers/RequestActorsHandler.cs
@@ -12,7 +12,7 @@ public void Handle(ulong sender, Packet data)
                 server.SendActor(actor.Key, actor.Value, sender);
                 server.SendPacket(new("actor_request_send")
                 {
-                    ["list"] = new Dictionary<int, object>(),
+                    ["list"] = Array.Empty<object>(),
                 }, DataChannel.GameState, sender);
             }
         }

diff --git a/GLOKON.Baiters.GodotInterop/GodotReader.cs b/GLOKON.Baiters.GodotInterop/GodotReader.cs
@@ -142,16 +142,16 @@ private static string ReadString(BinaryReader reader)
             return stringValue;
         }
 
-        private static Dictionary<int, object> ReadArray(BinaryReader reader)
+        private static Array ReadArray(BinaryReader reader)
         {
-            Dictionary<int, object> array = [];
-
             int elementCount = (int)reader.ReadUInt32();
             elementCount &= 0x7FFFFFFF;
 
+            Array array = Array.CreateInstance(typeof(object), elementCount);
+
             for (int i = 0; i < elementCount; i++)
             {
-                array[i] = ReadNext(reader);
+                array.SetValue(ReadNext(reader), i);
             }
 
             return array;

diff --git a/GLOKON.Baiters.GodotInterop/GodotWriter.cs b/GLOKON.Baiters.GodotInterop/GodotWriter.cs
@@ -64,8 +64,8 @@ private static void WriteVariant(object packet, BinaryWriter writer)
                 case bool pktBool:
                     Write(pktBool, writer);
                     break;
-                case Dictionary<int, object> pktIntDict:
-                    Write(pktIntDict, writer);
+                case Array pktArray:
+                    Write(pktArray, writer);
                     break;
                 case Vector3 pktVect3:
                     Write(pktVect3, writer);
@@ -144,14 +144,15 @@ private static void Write(string packet, BinaryWriter writer)
             }
         }
 
-        private static void Write(Dictionary<int, object> packet, BinaryWriter writer)
+        private static void Write(Array packet, BinaryWriter writer)
         {
+
             Write(GodotTypes.Array, writer);
-            writer.Write(BitConverter.GetBytes((uint)packet.Count));
+            writer.Write(BitConverter.GetBytes((uint)packet.Length));
 
-            for (int i = 0; i < packet.Count; i++)
+            foreach (var item in packet)
             {
-                WriteVariant(packet[i], writer);
+                WriteVariant(item, writer);
             }
         }