Skip to content

Commit 48d0f0d

Browse files
reximrexim
committed
Move all the message verification functions to common
1 parent badce2e commit 48d0f0d

File tree

5 files changed

+103
-103
lines changed

5 files changed

+103
-103
lines changed

‎client.c3

Lines changed: 9 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -452,14 +452,6 @@ fn void kill_all_items(Item[]* items) {
452452
}
453453
}
454454

455-
fn ItemsCollectedBatchMessage*! verify_items_collected_batch_message(Message *message) {
456-
if (message.byte_length < ItemsCollectedBatchMessage.sizeof) return MessageFault.INVALID?;
457-
if ((message.byte_length - ItemsCollectedBatchMessage.sizeof)%int.sizeof != 0) return MessageFault.INVALID?;
458-
ItemsCollectedBatchMessage* items_collected_batch_message = (ItemsCollectedBatchMessage*)message;
459-
if (items_collected_batch_message.kind != MessageKind.ITEM_COLLECTED) return MessageFault.INVALID?;
460-
return items_collected_batch_message;
461-
}
462-
463455
fn bool apply_items_collected_batch_message(ItemsCollectedBatchMessage *message, Item[]* items) {
464456
usz count = (message.byte_length - ItemsCollectedBatchMessage.sizeof)/int.sizeof;
465457

@@ -482,14 +474,6 @@ fn bool apply_items_collected_batch_message(ItemsCollectedBatchMessage *message,
482474
return true;
483475
}
484476

485-
fn ItemsSpawnedBatchMessage*! verify_items_spawned_batch_message(Message *message) {
486-
if (message.byte_length < ItemsSpawnedBatchMessage.sizeof) return MessageFault.INVALID?;
487-
if ((message.byte_length - ItemsSpawnedBatchMessage.sizeof)%ItemSpawned.sizeof != 0) return MessageFault.INVALID?;
488-
ItemsSpawnedBatchMessage* items_spawned_batch_message = (ItemsSpawnedBatchMessage*)message;
489-
if (items_spawned_batch_message.kind != MessageKind.ITEM_SPAWNED) return MessageFault.INVALID?;
490-
return items_spawned_batch_message;
491-
}
492-
493477
fn bool apply_items_spawned_batch_message(ItemsSpawnedBatchMessage *message, Item[]* items) {
494478
usz count = (message.byte_length - ItemsCollectedBatchMessage.sizeof)/ItemSpawned.sizeof;
495479
for (usz i = 0; i < count; ++i) {
@@ -564,14 +548,6 @@ fn void update_bombs_on_client_side(SpritePool *sprite_pool, ParticlePool *parti
564548
}
565549
}
566550

567-
fn BombsSpawnedBatchMessage*! verify_bombs_spawned_batch_message(Message *message) {
568-
if (message.byte_length < BombsSpawnedBatchMessage.sizeof) return MessageFault.INVALID?;
569-
if ((message.byte_length - BombsSpawnedBatchMessage.sizeof)%BombSpawned.sizeof != 0) return MessageFault.INVALID?;
570-
BombsSpawnedBatchMessage* bombs_spawned_batch_message = (BombsSpawnedBatchMessage*)message;
571-
if (bombs_spawned_batch_message.kind != MessageKind.BOMB_SPAWNED) return MessageFault.INVALID?;
572-
return bombs_spawned_batch_message;
573-
}
574-
575551
fn bool apply_bombs_spawned_batch_message(BombsSpawnedBatchMessage *message, Bombs *bombs) {
576552
usz count = (message.byte_length - BombsSpawnedBatchMessage.sizeof)/BombSpawned.sizeof;
577553
for (usz i = 0; i < count; ++i) {
@@ -593,14 +569,6 @@ fn bool apply_bombs_spawned_batch_message(BombsSpawnedBatchMessage *message, Bom
593569
return true;
594570
}
595571

596-
fn BombsExplodedBatchMessage*! verify_bombs_exploded_batch_message(Message *message) {
597-
if (message.byte_length < BombsExplodedBatchMessage.sizeof) return MessageFault.INVALID?;
598-
if ((message.byte_length - BombsExplodedBatchMessage.sizeof)%BombExploded.sizeof != 0) return MessageFault.INVALID?;
599-
BombsExplodedBatchMessage* bombs_exploded_batch_message = (BombsExplodedBatchMessage*)message;
600-
if (bombs_exploded_batch_message.kind != MessageKind.BOMB_EXPLODED) return MessageFault.INVALID?;
601-
return bombs_exploded_batch_message;
602-
}
603-
604572
fn bool apply_bombs_exploded_batch_message(BombsExplodedBatchMessage *message, Bombs *bombs, ParticlePool *particle_pool) {
605573
usz count = (message.byte_length - BombsExplodedBatchMessage.sizeof)/BombExploded.sizeof;
606574
for (usz i = 0; i < count; ++i) {
@@ -645,13 +613,6 @@ const Control[*] CONTROL_KEYS = {
645613
{83, MOVING_BACKWARD},
646614
};
647615

648-
fn HelloMessage*! verify_hello_message(Message *message) {
649-
if (message.byte_length != HelloMessage.sizeof) return MessageFault.INVALID?;
650-
HelloMessage* hello_message = (HelloMessage*)message;
651-
if (hello_message.kind != HELLO) return MessageFault.INVALID?;
652-
return hello_message;
653-
}
654-
655616
fn bool apply_hello_message_to_me(HelloMessage *hello_message, Item[]* items) {
656617
// TODO: maybe we should reset everything (bombs, etc) on hello message
657618
// 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) {
665626
return true;
666627
}
667628

668-
fn PlayersJoinedBatchMessage*! verify_players_joined_batch_message(Message *message) {
669-
if (message.byte_length < PlayersJoinedBatchMessage.sizeof) return MessageFault.INVALID?;
670-
if ((message.byte_length - PlayersJoinedBatchMessage.sizeof)%PlayerStruct.sizeof != 0) return MessageFault.INVALID?;
671-
PlayersJoinedBatchMessage* players_joined_batch_message = (PlayersJoinedBatchMessage*)message;
672-
if (players_joined_batch_message.kind != PLAYER_JOINED) return MessageFault.INVALID?;
673-
return players_joined_batch_message;
674-
}
675-
676629
fn void apply_players_joined_batch_message(PlayersJoinedBatchMessage *message) {
677630
usz count = (message.byte_length - PlayersJoinedBatchMessage.sizeof)/PlayerStruct.sizeof;
678631
for (usz i = 0; i < count; ++i) {
@@ -703,29 +656,13 @@ fn void apply_players_joined_batch_message(PlayersJoinedBatchMessage *message) {
703656
}
704657
}
705658

706-
fn PlayersLeftBatchMessage*! verify_players_left_batch_message(Message *message) {
707-
if (message.byte_length < PlayersLeftBatchMessage.sizeof) return MessageFault.INVALID?;
708-
if ((message.byte_length - PlayersLeftBatchMessage.sizeof)%uint.sizeof != 0) return MessageFault.INVALID?;
709-
PlayersLeftBatchMessage* players_left_batch_message = (PlayersLeftBatchMessage*)message;
710-
if (players_left_batch_message.kind != PLAYER_LEFT) return MessageFault.INVALID?;
711-
return players_left_batch_message;
712-
}
713-
714659
fn void apply_players_left_batch_message(PlayersLeftBatchMessage *message) {
715660
usz count = (message.byte_length - PlayersLeftBatchMessage.sizeof)/uint.sizeof;
716661
for (usz i = 0; i < count; ++i) {
717662
other_players.remove(message.ids[i]);
718663
}
719664
}
720665

721-
fn PlayersMovingBatchMessage*! verify_players_moving_batch_message(Message *message) {
722-
if (message.byte_length < PlayersMovingBatchMessage.sizeof) return MessageFault.INVALID?;
723-
if ((message.byte_length - PlayersMovingBatchMessage.sizeof)%PlayerStruct.sizeof != 0) return MessageFault.INVALID?;
724-
PlayersMovingBatchMessage* players_moving_batch_message = (PlayersMovingBatchMessage*)message;
725-
if (players_moving_batch_message.kind != PLAYER_MOVING) return MessageFault.INVALID?;
726-
return players_moving_batch_message;
727-
}
728-
729666
fn bool apply_players_moving_batch_message(PlayersMovingBatchMessage *message) {
730667
usz count = (message.byte_length - PlayersMovingBatchMessage.sizeof)/PlayerStruct.sizeof;
731668
for (usz i = 0; i < count; ++i) {
@@ -887,13 +824,6 @@ fn void ping_server_if_needed() {
887824
}
888825
}
889826

890-
fn PongMessage*! verify_pong_message(Message *message) {
891-
if (message.byte_length != PongMessage.sizeof) return MessageFault.INVALID?;
892-
PongMessage* pong_message = (PongMessage*)message;
893-
if (pong_message.kind != PONG) return MessageFault.INVALID?;
894-
return pong_message;
895-
}
896-
897827
uint ping = 0;
898828
fn void process_pong_message(PongMessage *message) {
899829
ping = platform_now_msecs() - message.timestamp;
@@ -904,47 +834,47 @@ fn uint ping_msecs() @extern("ping_msecs") @wasm {
904834
}
905835

906836
fn bool process_message(Message *unknown_message) @extern("process_message") @wasm {
907-
if (try message = verify_hello_message(unknown_message)) {
837+
if (try message = common::verify_hello_message(unknown_message)) {
908838
apply_hello_message_to_me(message, &common::items);
909839
return true;
910840
}
911-
if (try message = verify_players_joined_batch_message(unknown_message)) {
841+
if (try message = common::verify_players_joined_batch_message(unknown_message)) {
912842
apply_players_joined_batch_message(message);
913843
return true;
914844
}
915-
if (try message = verify_players_left_batch_message(unknown_message)) {
845+
if (try message = common::verify_players_left_batch_message(unknown_message)) {
916846
apply_players_left_batch_message(message);
917847
return true;
918848
}
919-
if (try message = verify_players_moving_batch_message(unknown_message)) {
849+
if (try message = common::verify_players_moving_batch_message(unknown_message)) {
920850
if (!apply_players_moving_batch_message(message)) {
921851
return false;
922852
}
923853
return true;
924854
}
925-
if (try message = verify_pong_message(unknown_message)) {
855+
if (try message = common::verify_pong_message(unknown_message)) {
926856
process_pong_message(message);
927857
return true;
928858
}
929-
if (try message = verify_items_collected_batch_message(unknown_message)) {
859+
if (try message = common::verify_items_collected_batch_message(unknown_message)) {
930860
if (!apply_items_collected_batch_message(message, &common::items)) {
931861
return false;
932862
}
933863
return true;
934864
}
935-
if (try message = verify_items_spawned_batch_message(unknown_message)) {
865+
if (try message = common::verify_items_spawned_batch_message(unknown_message)) {
936866
if (!apply_items_spawned_batch_message(message, &common::items)) {
937867
return false;
938868
}
939869
return true;
940870
}
941-
if (try message = verify_bombs_spawned_batch_message(unknown_message)) {
871+
if (try message = common::verify_bombs_spawned_batch_message(unknown_message)) {
942872
if (!apply_bombs_spawned_batch_message(message, &common::bombs)) {
943873
return false;
944874
}
945875
return true;
946876
}
947-
if (try message = verify_bombs_exploded_batch_message(unknown_message)) {
877+
if (try message = common::verify_bombs_exploded_batch_message(unknown_message)) {
948878
if (!apply_bombs_exploded_batch_message(message, &common::bombs, &particle_pool)) {
949879
return false;
950880
}

‎client.wasm

0 Bytes
Binary file not shown.

‎common.c3

Lines changed: 91 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -194,6 +194,14 @@ struct ItemsSpawnedBatchMessage @packed {
194194
ItemSpawned[*] items;
195195
}
196196

197+
fn ItemsSpawnedBatchMessage*! verify_items_spawned_batch_message(Message *message) {
198+
if (message.byte_length < ItemsSpawnedBatchMessage.sizeof) return MessageFault.INVALID?;
199+
if ((message.byte_length - ItemsSpawnedBatchMessage.sizeof)%ItemSpawned.sizeof != 0) return MessageFault.INVALID?;
200+
ItemsSpawnedBatchMessage* items_spawned_batch_message = (ItemsSpawnedBatchMessage*)message;
201+
if (items_spawned_batch_message.kind != MessageKind.ITEM_SPAWNED) return MessageFault.INVALID?;
202+
return items_spawned_batch_message;
203+
}
204+
197205
fn ItemsSpawnedBatchMessage* reconstruct_state_of_items(Item[] *items) {
198206
usz itemsCount = 0;
199207
foreach (&item: *items) {
@@ -225,6 +233,14 @@ struct ItemsCollectedBatchMessage @packed {
225233
int[*] ids;
226234
}
227235

236+
fn ItemsCollectedBatchMessage*! verify_items_collected_batch_message(Message *message) {
237+
if (message.byte_length < ItemsCollectedBatchMessage.sizeof) return MessageFault.INVALID?;
238+
if ((message.byte_length - ItemsCollectedBatchMessage.sizeof)%int.sizeof != 0) return MessageFault.INVALID?;
239+
ItemsCollectedBatchMessage* items_collected_batch_message = (ItemsCollectedBatchMessage*)message;
240+
if (items_collected_batch_message.kind != MessageKind.ITEM_COLLECTED) return MessageFault.INVALID?;
241+
return items_collected_batch_message;
242+
}
243+
228244
/// Bombs //////////////////////////////
229245

230246
struct Bomb {
@@ -307,6 +323,14 @@ struct BombsSpawnedBatchMessage @packed {
307323
BombSpawned[*] bombs;
308324
}
309325

326+
fn BombsSpawnedBatchMessage*! verify_bombs_spawned_batch_message(Message *message) {
327+
if (message.byte_length < BombsSpawnedBatchMessage.sizeof) return MessageFault.INVALID?;
328+
if ((message.byte_length - BombsSpawnedBatchMessage.sizeof)%BombSpawned.sizeof != 0) return MessageFault.INVALID?;
329+
BombsSpawnedBatchMessage* bombs_spawned_batch_message = (BombsSpawnedBatchMessage*)message;
330+
if (bombs_spawned_batch_message.kind != MessageKind.BOMB_SPAWNED) return MessageFault.INVALID?;
331+
return bombs_spawned_batch_message;
332+
}
333+
310334
struct BombExploded @packed {
311335
uint bombIndex;
312336
float x;
@@ -320,6 +344,14 @@ struct BombsExplodedBatchMessage @packed {
320344
BombExploded[*] bombs;
321345
}
322346

347+
fn BombsExplodedBatchMessage*! verify_bombs_exploded_batch_message(Message *message) {
348+
if (message.byte_length < BombsExplodedBatchMessage.sizeof) return MessageFault.INVALID?;
349+
if ((message.byte_length - BombsExplodedBatchMessage.sizeof)%BombExploded.sizeof != 0) return MessageFault.INVALID?;
350+
BombsExplodedBatchMessage* bombs_exploded_batch_message = (BombsExplodedBatchMessage*)message;
351+
if (bombs_exploded_batch_message.kind != MessageKind.BOMB_EXPLODED) return MessageFault.INVALID?;
352+
return bombs_exploded_batch_message;
353+
}
354+
323355
/// Player //////////////////////////////
324356

325357
enum Moving: char {
@@ -355,18 +387,42 @@ struct PlayersJoinedBatchMessage @packed {
355387
PlayerStruct[*] players;
356388
}
357389

390+
fn PlayersJoinedBatchMessage*! verify_players_joined_batch_message(Message *message) {
391+
if (message.byte_length < PlayersJoinedBatchMessage.sizeof) return MessageFault.INVALID?;
392+
if ((message.byte_length - PlayersJoinedBatchMessage.sizeof)%PlayerStruct.sizeof != 0) return MessageFault.INVALID?;
393+
PlayersJoinedBatchMessage* players_joined_batch_message = (PlayersJoinedBatchMessage*)message;
394+
if (players_joined_batch_message.kind != PLAYER_JOINED) return MessageFault.INVALID?;
395+
return players_joined_batch_message;
396+
}
397+
358398
struct PlayersLeftBatchMessage @packed {
359399
uint byte_length;
360400
MessageKind kind;
361401
uint[*] ids;
362402
}
363403

404+
fn PlayersLeftBatchMessage*! verify_players_left_batch_message(Message *message) {
405+
if (message.byte_length < PlayersLeftBatchMessage.sizeof) return MessageFault.INVALID?;
406+
if ((message.byte_length - PlayersLeftBatchMessage.sizeof)%uint.sizeof != 0) return MessageFault.INVALID?;
407+
PlayersLeftBatchMessage* players_left_batch_message = (PlayersLeftBatchMessage*)message;
408+
if (players_left_batch_message.kind != PLAYER_LEFT) return MessageFault.INVALID?;
409+
return players_left_batch_message;
410+
}
411+
364412
struct PlayersMovingBatchMessage @packed {
365413
uint byte_length;
366414
MessageKind kind;
367415
PlayerStruct[*] players;
368416
}
369417

418+
fn PlayersMovingBatchMessage*! verify_players_moving_batch_message(Message *message) {
419+
if (message.byte_length < PlayersMovingBatchMessage.sizeof) return MessageFault.INVALID?;
420+
if ((message.byte_length - PlayersMovingBatchMessage.sizeof)%PlayerStruct.sizeof != 0) return MessageFault.INVALID?;
421+
PlayersMovingBatchMessage* players_moving_batch_message = (PlayersMovingBatchMessage*)message;
422+
if (players_moving_batch_message.kind != PLAYER_MOVING) return MessageFault.INVALID?;
423+
return players_moving_batch_message;
424+
}
425+
370426
struct HelloMessage @packed {
371427
uint byte_length;
372428
MessageKind kind;
@@ -377,30 +433,65 @@ struct HelloMessage @packed {
377433
char hue;
378434
}
379435

436+
fn HelloMessage*! verify_hello_message(Message *message) {
437+
if (message.byte_length != HelloMessage.sizeof) return MessageFault.INVALID?;
438+
HelloMessage* hello_message = (HelloMessage*)message;
439+
if (hello_message.kind != HELLO) return MessageFault.INVALID?;
440+
return hello_message;
441+
}
442+
380443
struct PongMessage @packed {
381444
uint byte_length;
382445
MessageKind kind;
383446
uint timestamp;
384447
}
385448

449+
fn PongMessage*! verify_pong_message(Message *message) {
450+
if (message.byte_length != PongMessage.sizeof) return MessageFault.INVALID?;
451+
PongMessage* pong_message = (PongMessage*)message;
452+
if (pong_message.kind != PONG) return MessageFault.INVALID?;
453+
return pong_message;
454+
}
455+
386456
struct AmmaMovingMessage @packed {
387457
uint byte_length;
388458
MessageKind kind;
389459
Moving direction;
390460
char start;
391461
}
392462

463+
fn AmmaMovingMessage*! verify_amma_moving_message(Message *message) {
464+
if (message.byte_length != AmmaMovingMessage.sizeof) return MessageFault.INVALID?;
465+
AmmaMovingMessage* amma_moving_message = (AmmaMovingMessage*)message;
466+
if (amma_moving_message.kind != AMMA_MOVING) return MessageFault.INVALID?;
467+
return amma_moving_message;
468+
}
469+
393470
struct AmmaThrowingMessage @packed {
394471
uint byte_length;
395472
MessageKind kind;
396473
}
397474

475+
fn AmmaThrowingMessage*! verify_amma_throwing_message(Message *message) {
476+
if (message.byte_length != AmmaThrowingMessage.sizeof) return MessageFault.INVALID?;
477+
AmmaThrowingMessage* amma_throwing_message = (AmmaThrowingMessage*)message;
478+
if (amma_throwing_message.kind != AMMA_THROWING) return MessageFault.INVALID?;
479+
return amma_throwing_message;
480+
}
481+
398482
struct PingMessage {
399483
uint byte_length;
400484
MessageKind kind;
401485
uint timestamp;
402486
}
403487

488+
fn PingMessage*! verify_ping_message(Message *message) {
489+
if (message.byte_length != PingMessage.sizeof) return MessageFault.INVALID?;
490+
PingMessage* ping_message = (PingMessage*)message;
491+
if (ping_message.kind != PING) return MessageFault.INVALID?;
492+
return ping_message;
493+
}
494+
404495
fn void update_player(Player *player, Scene *scene, float delta_time) {
405496
Vector2 control_velocity = {0, 0};
406497
float angular_velocity = 0.0;

0 commit comments

Comments
 (0)