From 48d0f0d8cdbce01374bfb768da5f5241e04f637a Mon Sep 17 00:00:00 2001
From: rexim <reximkut@gmail.com>
Date: Thu, 10 Oct 2024 06:01:45 +0700
Subject: [PATCH] Move all the message verification functions to common

---
 client.c3   |  88 ++++++--------------------------------------------
 client.wasm | Bin 175324 -> 175324 bytes
 common.c3   |  91 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 server.c3   |  27 ++--------------
 server.wasm | Bin 86000 -> 86001 bytes
 5 files changed, 103 insertions(+), 103 deletions(-)

diff --git a/client.c3 b/client.c3
index 8517ad9..73cec24 100644
--- a/client.c3
+++ b/client.c3
@@ -452,14 +452,6 @@ fn void kill_all_items(Item[]* items) {
     }
 }
 
-fn ItemsCollectedBatchMessage*! verify_items_collected_batch_message(Message *message) {
-    if (message.byte_length < ItemsCollectedBatchMessage.sizeof) return MessageFault.INVALID?;
-    if ((message.byte_length - ItemsCollectedBatchMessage.sizeof)%int.sizeof != 0) return MessageFault.INVALID?;
-    ItemsCollectedBatchMessage* items_collected_batch_message = (ItemsCollectedBatchMessage*)message;
-    if (items_collected_batch_message.kind != MessageKind.ITEM_COLLECTED) return MessageFault.INVALID?;
-    return items_collected_batch_message;
-}
-
 fn bool apply_items_collected_batch_message(ItemsCollectedBatchMessage *message, Item[]* items) {
     usz count = (message.byte_length - ItemsCollectedBatchMessage.sizeof)/int.sizeof;
 
@@ -482,14 +474,6 @@ fn bool apply_items_collected_batch_message(ItemsCollectedBatchMessage *message,
     return true;
 }
 
-fn ItemsSpawnedBatchMessage*! verify_items_spawned_batch_message(Message *message) {
-    if (message.byte_length < ItemsSpawnedBatchMessage.sizeof) return MessageFault.INVALID?;
-    if ((message.byte_length - ItemsSpawnedBatchMessage.sizeof)%ItemSpawned.sizeof != 0) return MessageFault.INVALID?;
-    ItemsSpawnedBatchMessage* items_spawned_batch_message = (ItemsSpawnedBatchMessage*)message;
-    if (items_spawned_batch_message.kind != MessageKind.ITEM_SPAWNED) return MessageFault.INVALID?;
-    return items_spawned_batch_message;
-}
-
 fn bool apply_items_spawned_batch_message(ItemsSpawnedBatchMessage *message, Item[]* items) {
     usz count = (message.byte_length - ItemsCollectedBatchMessage.sizeof)/ItemSpawned.sizeof;
     for (usz i = 0; i < count; ++i) {
@@ -564,14 +548,6 @@ fn void update_bombs_on_client_side(SpritePool *sprite_pool, ParticlePool *parti
     }
 }
 
-fn BombsSpawnedBatchMessage*! verify_bombs_spawned_batch_message(Message *message) {
-    if (message.byte_length < BombsSpawnedBatchMessage.sizeof) return MessageFault.INVALID?;
-    if ((message.byte_length - BombsSpawnedBatchMessage.sizeof)%BombSpawned.sizeof != 0) return MessageFault.INVALID?;
-    BombsSpawnedBatchMessage* bombs_spawned_batch_message = (BombsSpawnedBatchMessage*)message;
-    if (bombs_spawned_batch_message.kind != MessageKind.BOMB_SPAWNED) return MessageFault.INVALID?;
-    return bombs_spawned_batch_message;
-}
-
 fn bool apply_bombs_spawned_batch_message(BombsSpawnedBatchMessage *message, Bombs *bombs) {
     usz count = (message.byte_length - BombsSpawnedBatchMessage.sizeof)/BombSpawned.sizeof;
     for (usz i = 0; i < count; ++i) {
@@ -593,14 +569,6 @@ fn bool apply_bombs_spawned_batch_message(BombsSpawnedBatchMessage *message, Bom
     return true;
 }
 
-fn BombsExplodedBatchMessage*! verify_bombs_exploded_batch_message(Message *message) {
-    if (message.byte_length < BombsExplodedBatchMessage.sizeof) return MessageFault.INVALID?;
-    if ((message.byte_length - BombsExplodedBatchMessage.sizeof)%BombExploded.sizeof != 0) return MessageFault.INVALID?;
-    BombsExplodedBatchMessage* bombs_exploded_batch_message = (BombsExplodedBatchMessage*)message;
-    if (bombs_exploded_batch_message.kind != MessageKind.BOMB_EXPLODED) return MessageFault.INVALID?;
-    return bombs_exploded_batch_message;
-}
-
 fn bool apply_bombs_exploded_batch_message(BombsExplodedBatchMessage *message, Bombs *bombs, ParticlePool *particle_pool) {
     usz count = (message.byte_length - BombsExplodedBatchMessage.sizeof)/BombExploded.sizeof;
     for (usz i = 0; i < count; ++i) {
@@ -645,13 +613,6 @@ const Control[*] CONTROL_KEYS = {
     {83, MOVING_BACKWARD},
 };
 
-fn HelloMessage*! verify_hello_message(Message *message) {
-    if (message.byte_length != HelloMessage.sizeof) return MessageFault.INVALID?;
-    HelloMessage* hello_message = (HelloMessage*)message;
-    if (hello_message.kind != HELLO) return MessageFault.INVALID?;
-    return hello_message;
-}
-
 fn bool apply_hello_message_to_me(HelloMessage *hello_message, Item[]* items) {
     // TODO: maybe we should reset everything (bombs, etc) on hello message
     // So to let the server recreate the world properly
@@ -665,14 +626,6 @@ fn bool apply_hello_message_to_me(HelloMessage *hello_message, Item[]* items) {
     return true;
 }
 
-fn PlayersJoinedBatchMessage*! verify_players_joined_batch_message(Message *message) {
-    if (message.byte_length < PlayersJoinedBatchMessage.sizeof) return MessageFault.INVALID?;
-    if ((message.byte_length - PlayersJoinedBatchMessage.sizeof)%PlayerStruct.sizeof != 0) return MessageFault.INVALID?;
-    PlayersJoinedBatchMessage* players_joined_batch_message = (PlayersJoinedBatchMessage*)message;
-    if (players_joined_batch_message.kind != PLAYER_JOINED) return MessageFault.INVALID?;
-    return players_joined_batch_message;
-}
-
 fn void apply_players_joined_batch_message(PlayersJoinedBatchMessage *message) {
     usz count = (message.byte_length - PlayersJoinedBatchMessage.sizeof)/PlayerStruct.sizeof;
     for (usz i = 0; i < count; ++i) {
@@ -703,14 +656,6 @@ fn void apply_players_joined_batch_message(PlayersJoinedBatchMessage *message) {
     }
 }
 
-fn PlayersLeftBatchMessage*! verify_players_left_batch_message(Message *message) {
-    if (message.byte_length < PlayersLeftBatchMessage.sizeof) return MessageFault.INVALID?;
-    if ((message.byte_length - PlayersLeftBatchMessage.sizeof)%uint.sizeof != 0) return MessageFault.INVALID?;
-    PlayersLeftBatchMessage* players_left_batch_message = (PlayersLeftBatchMessage*)message;
-    if (players_left_batch_message.kind != PLAYER_LEFT) return MessageFault.INVALID?;
-    return players_left_batch_message;
-}
-
 fn void apply_players_left_batch_message(PlayersLeftBatchMessage *message) {
     usz count = (message.byte_length - PlayersLeftBatchMessage.sizeof)/uint.sizeof;
     for (usz i = 0; i < count; ++i) {
@@ -718,14 +663,6 @@ fn void apply_players_left_batch_message(PlayersLeftBatchMessage *message) {
     }
 }
 
-fn PlayersMovingBatchMessage*! verify_players_moving_batch_message(Message *message) {
-    if (message.byte_length < PlayersMovingBatchMessage.sizeof) return MessageFault.INVALID?;
-    if ((message.byte_length - PlayersMovingBatchMessage.sizeof)%PlayerStruct.sizeof != 0) return MessageFault.INVALID?;
-    PlayersMovingBatchMessage* players_moving_batch_message = (PlayersMovingBatchMessage*)message;
-    if (players_moving_batch_message.kind != PLAYER_MOVING) return MessageFault.INVALID?;
-    return players_moving_batch_message;
-}
-
 fn bool apply_players_moving_batch_message(PlayersMovingBatchMessage *message) {
     usz count = (message.byte_length - PlayersMovingBatchMessage.sizeof)/PlayerStruct.sizeof;
     for (usz i = 0; i < count; ++i) {
@@ -887,13 +824,6 @@ fn void ping_server_if_needed() {
     }
 }
 
-fn PongMessage*! verify_pong_message(Message *message) {
-    if (message.byte_length != PongMessage.sizeof) return MessageFault.INVALID?;
-    PongMessage* pong_message = (PongMessage*)message;
-    if (pong_message.kind != PONG) return MessageFault.INVALID?;
-    return pong_message;
-}
-
 uint ping = 0;
 fn void process_pong_message(PongMessage *message) {
     ping = platform_now_msecs() - message.timestamp;
@@ -904,47 +834,47 @@ fn uint ping_msecs() @extern("ping_msecs") @wasm {
 }
 
 fn bool process_message(Message *unknown_message) @extern("process_message") @wasm {
-    if (try message = verify_hello_message(unknown_message)) {
+    if (try message = common::verify_hello_message(unknown_message)) {
         apply_hello_message_to_me(message, &common::items);
         return true;
     }
-    if (try message = verify_players_joined_batch_message(unknown_message)) {
+    if (try message = common::verify_players_joined_batch_message(unknown_message)) {
         apply_players_joined_batch_message(message);
         return true;
     }
-    if (try message = verify_players_left_batch_message(unknown_message)) {
+    if (try message = common::verify_players_left_batch_message(unknown_message)) {
         apply_players_left_batch_message(message);
         return true;
     }
-    if (try message = verify_players_moving_batch_message(unknown_message)) {
+    if (try message = common::verify_players_moving_batch_message(unknown_message)) {
         if (!apply_players_moving_batch_message(message)) {
             return false;
         }
         return true;
     }
-    if (try message = verify_pong_message(unknown_message)) {
+    if (try message = common::verify_pong_message(unknown_message)) {
         process_pong_message(message);
         return true;
     }
-    if (try message = verify_items_collected_batch_message(unknown_message)) {
+    if (try message = common::verify_items_collected_batch_message(unknown_message)) {
         if (!apply_items_collected_batch_message(message, &common::items)) {
             return false;
         }
         return true;
     }
-    if (try message = verify_items_spawned_batch_message(unknown_message)) {
+    if (try message = common::verify_items_spawned_batch_message(unknown_message)) {
         if (!apply_items_spawned_batch_message(message, &common::items)) {
             return false;
         }
         return true;
     }
-    if (try message = verify_bombs_spawned_batch_message(unknown_message)) {
+    if (try message = common::verify_bombs_spawned_batch_message(unknown_message)) {
         if (!apply_bombs_spawned_batch_message(message, &common::bombs)) {
             return false;
         }
         return true;
     }
-    if (try message = verify_bombs_exploded_batch_message(unknown_message)) {
+    if (try message = common::verify_bombs_exploded_batch_message(unknown_message)) {
         if (!apply_bombs_exploded_batch_message(message, &common::bombs, &particle_pool)) {
             return false;
         }
diff --git a/client.wasm b/client.wasm
index a3244befebc0f6a2ea0ad8f11e02b429802e574b..97eb2b4b655531598a33d3d5f88bc40b0b76a097 100755
GIT binary patch
delta 30
mcmca}lk3h+u7(!IElj#AnG7wq>#t<uU}iElo^H8@X)yr2R|=p2

delta 30
mcmca}lk3h+u7(!IElj#AnG6iJ>#t<uU}iEjoo=~?X)yr1%?g(Q

diff --git a/common.c3 b/common.c3
index 85f7b15..c7d3a2c 100644
--- a/common.c3
+++ b/common.c3
@@ -194,6 +194,14 @@ struct ItemsSpawnedBatchMessage @packed {
     ItemSpawned[*] items;
 }
 
+fn ItemsSpawnedBatchMessage*! verify_items_spawned_batch_message(Message *message) {
+    if (message.byte_length < ItemsSpawnedBatchMessage.sizeof) return MessageFault.INVALID?;
+    if ((message.byte_length - ItemsSpawnedBatchMessage.sizeof)%ItemSpawned.sizeof != 0) return MessageFault.INVALID?;
+    ItemsSpawnedBatchMessage* items_spawned_batch_message = (ItemsSpawnedBatchMessage*)message;
+    if (items_spawned_batch_message.kind != MessageKind.ITEM_SPAWNED) return MessageFault.INVALID?;
+    return items_spawned_batch_message;
+}
+
 fn ItemsSpawnedBatchMessage* reconstruct_state_of_items(Item[] *items) {
     usz itemsCount = 0;
     foreach (&item: *items) {
@@ -225,6 +233,14 @@ struct ItemsCollectedBatchMessage @packed {
     int[*] ids;
 }
 
+fn ItemsCollectedBatchMessage*! verify_items_collected_batch_message(Message *message) {
+    if (message.byte_length < ItemsCollectedBatchMessage.sizeof) return MessageFault.INVALID?;
+    if ((message.byte_length - ItemsCollectedBatchMessage.sizeof)%int.sizeof != 0) return MessageFault.INVALID?;
+    ItemsCollectedBatchMessage* items_collected_batch_message = (ItemsCollectedBatchMessage*)message;
+    if (items_collected_batch_message.kind != MessageKind.ITEM_COLLECTED) return MessageFault.INVALID?;
+    return items_collected_batch_message;
+}
+
 /// Bombs //////////////////////////////
 
 struct Bomb {
@@ -307,6 +323,14 @@ struct BombsSpawnedBatchMessage @packed {
     BombSpawned[*] bombs;
 }
 
+fn BombsSpawnedBatchMessage*! verify_bombs_spawned_batch_message(Message *message) {
+    if (message.byte_length < BombsSpawnedBatchMessage.sizeof) return MessageFault.INVALID?;
+    if ((message.byte_length - BombsSpawnedBatchMessage.sizeof)%BombSpawned.sizeof != 0) return MessageFault.INVALID?;
+    BombsSpawnedBatchMessage* bombs_spawned_batch_message = (BombsSpawnedBatchMessage*)message;
+    if (bombs_spawned_batch_message.kind != MessageKind.BOMB_SPAWNED) return MessageFault.INVALID?;
+    return bombs_spawned_batch_message;
+}
+
 struct BombExploded @packed {
     uint bombIndex;
     float x;
@@ -320,6 +344,14 @@ struct BombsExplodedBatchMessage @packed {
     BombExploded[*] bombs;
 }
 
+fn BombsExplodedBatchMessage*! verify_bombs_exploded_batch_message(Message *message) {
+    if (message.byte_length < BombsExplodedBatchMessage.sizeof) return MessageFault.INVALID?;
+    if ((message.byte_length - BombsExplodedBatchMessage.sizeof)%BombExploded.sizeof != 0) return MessageFault.INVALID?;
+    BombsExplodedBatchMessage* bombs_exploded_batch_message = (BombsExplodedBatchMessage*)message;
+    if (bombs_exploded_batch_message.kind != MessageKind.BOMB_EXPLODED) return MessageFault.INVALID?;
+    return bombs_exploded_batch_message;
+}
+
 /// Player //////////////////////////////
 
 enum Moving: char {
@@ -355,18 +387,42 @@ struct PlayersJoinedBatchMessage @packed {
     PlayerStruct[*] players;
 }
 
+fn PlayersJoinedBatchMessage*! verify_players_joined_batch_message(Message *message) {
+    if (message.byte_length < PlayersJoinedBatchMessage.sizeof) return MessageFault.INVALID?;
+    if ((message.byte_length - PlayersJoinedBatchMessage.sizeof)%PlayerStruct.sizeof != 0) return MessageFault.INVALID?;
+    PlayersJoinedBatchMessage* players_joined_batch_message = (PlayersJoinedBatchMessage*)message;
+    if (players_joined_batch_message.kind != PLAYER_JOINED) return MessageFault.INVALID?;
+    return players_joined_batch_message;
+}
+
 struct PlayersLeftBatchMessage @packed {
     uint byte_length;
     MessageKind kind;
     uint[*] ids;
 }
 
+fn PlayersLeftBatchMessage*! verify_players_left_batch_message(Message *message) {
+    if (message.byte_length < PlayersLeftBatchMessage.sizeof) return MessageFault.INVALID?;
+    if ((message.byte_length - PlayersLeftBatchMessage.sizeof)%uint.sizeof != 0) return MessageFault.INVALID?;
+    PlayersLeftBatchMessage* players_left_batch_message = (PlayersLeftBatchMessage*)message;
+    if (players_left_batch_message.kind != PLAYER_LEFT) return MessageFault.INVALID?;
+    return players_left_batch_message;
+}
+
 struct PlayersMovingBatchMessage @packed {
     uint byte_length;
     MessageKind kind;
     PlayerStruct[*] players;
 }
 
+fn PlayersMovingBatchMessage*! verify_players_moving_batch_message(Message *message) {
+    if (message.byte_length < PlayersMovingBatchMessage.sizeof) return MessageFault.INVALID?;
+    if ((message.byte_length - PlayersMovingBatchMessage.sizeof)%PlayerStruct.sizeof != 0) return MessageFault.INVALID?;
+    PlayersMovingBatchMessage* players_moving_batch_message = (PlayersMovingBatchMessage*)message;
+    if (players_moving_batch_message.kind != PLAYER_MOVING) return MessageFault.INVALID?;
+    return players_moving_batch_message;
+}
+
 struct HelloMessage @packed {
     uint byte_length;
     MessageKind kind;
@@ -377,12 +433,26 @@ struct HelloMessage @packed {
     char hue;
 }
 
+fn HelloMessage*! verify_hello_message(Message *message) {
+    if (message.byte_length != HelloMessage.sizeof) return MessageFault.INVALID?;
+    HelloMessage* hello_message = (HelloMessage*)message;
+    if (hello_message.kind != HELLO) return MessageFault.INVALID?;
+    return hello_message;
+}
+
 struct PongMessage @packed {
     uint byte_length;
     MessageKind kind;
     uint timestamp;
 }
 
+fn PongMessage*! verify_pong_message(Message *message) {
+    if (message.byte_length != PongMessage.sizeof) return MessageFault.INVALID?;
+    PongMessage* pong_message = (PongMessage*)message;
+    if (pong_message.kind != PONG) return MessageFault.INVALID?;
+    return pong_message;
+}
+
 struct AmmaMovingMessage @packed {
     uint byte_length;
     MessageKind kind;
@@ -390,17 +460,38 @@ struct AmmaMovingMessage @packed {
     char start;
 }
 
+fn AmmaMovingMessage*! verify_amma_moving_message(Message *message) {
+    if (message.byte_length != AmmaMovingMessage.sizeof) return MessageFault.INVALID?;
+    AmmaMovingMessage* amma_moving_message = (AmmaMovingMessage*)message;
+    if (amma_moving_message.kind != AMMA_MOVING) return MessageFault.INVALID?;
+    return amma_moving_message;
+}
+
 struct AmmaThrowingMessage @packed {
     uint byte_length;
     MessageKind kind;
 }
 
+fn AmmaThrowingMessage*! verify_amma_throwing_message(Message *message) {
+    if (message.byte_length != AmmaThrowingMessage.sizeof) return MessageFault.INVALID?;
+    AmmaThrowingMessage* amma_throwing_message = (AmmaThrowingMessage*)message;
+    if (amma_throwing_message.kind != AMMA_THROWING) return MessageFault.INVALID?;
+    return amma_throwing_message;
+}
+
 struct PingMessage {
     uint byte_length;
     MessageKind kind;
     uint timestamp;
 }
 
+fn PingMessage*! verify_ping_message(Message *message) {
+    if (message.byte_length != PingMessage.sizeof) return MessageFault.INVALID?;
+    PingMessage* ping_message = (PingMessage*)message;
+    if (ping_message.kind != PING) return MessageFault.INVALID?;
+    return ping_message;
+}
+
 fn void update_player(Player *player, Scene *scene, float delta_time) {
     Vector2 control_velocity = {0, 0};
     float angular_velocity = 0.0;
diff --git a/server.c3 b/server.c3
index 07c6e4d..2d62f39 100644
--- a/server.c3
+++ b/server.c3
@@ -369,42 +369,21 @@ fn void clear_intermediate_ids() {
     ping_ids.clear();
 }
 
-fn PingMessage*! verify_ping_message(Message *message) {
-    if (message.byte_length != PingMessage.sizeof) return MessageFault.INVALID?;
-    PingMessage* ping_message = (PingMessage*)message;
-    if (ping_message.kind != PING) return MessageFault.INVALID?;
-    return ping_message;
-}
-
-fn AmmaThrowingMessage*! verify_amma_throwing_message(Message *message) {
-    if (message.byte_length != AmmaThrowingMessage.sizeof) return MessageFault.INVALID?;
-    AmmaThrowingMessage* amma_throwing_message = (AmmaThrowingMessage*)message;
-    if (amma_throwing_message.kind != AMMA_THROWING) return MessageFault.INVALID?;
-    return amma_throwing_message;
-}
-
-fn AmmaMovingMessage*! verify_amma_moving_message(Message *message) {
-    if (message.byte_length != AmmaMovingMessage.sizeof) return MessageFault.INVALID?;
-    AmmaMovingMessage* amma_moving_message = (AmmaMovingMessage*)message;
-    if (amma_moving_message.kind != AMMA_MOVING) return MessageFault.INVALID?;
-    return amma_moving_message;
-}
-
 fn bool process_message_on_server(uint id, Message *unknown_message) @extern("process_message_on_server") @wasm {
     stats::inc_counter(MESSAGES_RECEIVED, 1);
     stats::messages_recieved_within_tick += 1;
     stats::inc_counter(BYTES_RECEIVED, unknown_message.byte_length);
     stats::bytes_received_within_tick += unknown_message.byte_length;
 
-    if (try message = verify_amma_moving_message(unknown_message)) {
+    if (try message = common::verify_amma_moving_message(unknown_message)) {
         player_update_moving(id, message);
         return true;
     }
-    if (try verify_amma_throwing_message(unknown_message)) {
+    if (try common::verify_amma_throwing_message(unknown_message)) {
         throw_bomb_on_server_side(id, &common::bombs);
         return true;
     }
-    if (try message = verify_ping_message(unknown_message)) {
+    if (try message = common::verify_ping_message(unknown_message)) {
         schedule_ping_for_player(id, message);
         return true;
     }
diff --git a/server.wasm b/server.wasm
index 5385b7b04a2512cf61e47adb19852537a824c00f..751cceec11a42d6498c5d504467a9b4c83964348 100755
GIT binary patch
delta 76
zcmV-S0JHz_p9S%s1%R{x@<JNV83b-&ZDjxq3v*?1c4cxdcVTmF0g@SX0Fl5Jw<1FU
il?a!>P5~GJG`G)70SE&EGclLhP65CII5L-;PXSdnZ5jsv

delta 94
zcmex3pY_9h)`l&NpPZ!5NwVZ6=B6_6a2KZ*m8BNxl_wVGGES5%VVHP8Y`c;(<5Ug_
xalK^Y_>@YZy3FMGqSW-v;u4@jOUvySycs!|nGDUQ-|}NTz+`4VeU3k4C;(e)AhrMi