send and recv fuctions for networking now explicitly tied to NetMsgType

src/common/networking.c

@@ -7,51 +7,25 @@
 #include "networking.h"
 
 static const uint8_t fb = 0xfb;
-static const uint8_t fe = 0xfe;
 
-void PaddleChangeDirMsg_encode(const PaddleChangeDirMsg *const msg, uint8_t *buf, const size_t buf_size) {
-    if (buf_size < sizeof(PaddleChangeDirMsg)) {
-        LOG_FATALF("Buffer size too small (%zu), %zu required.", buf_size, sizeof(PaddleChangeDirMsg));
+static size_t NetMsgType_to_buf_size(const NetMsgType type) {
+    switch (type) {
+    case NET_MSG_PADDLE_CHANGE_DIR:
+        return sizeof(PaddleChangeDirMsg);
+    case NET_MSG_PADDLE_POS:
+        return sizeof(PaddlePosMsg);
+    default:
+        LOG_FATALF("Invalid msg type: %u", type);
     }
-
-    memcpy(buf, msg, sizeof(PaddleChangeDirMsg));
-}
-
-PaddleChangeDirMsg PaddleChangeDir_decode(const uint8_t *buf, const size_t buf_size) {
-    if (buf_size < sizeof(PaddleChangeDirMsg)) {
-        LOG_FATALF("Buffer size too small (%zu), %zu required.", buf_size, sizeof(PaddleChangeDirMsg));
-    }
-
-    PaddleChangeDirMsg msg = { 0 };
-    memcpy(&msg, buf, sizeof(PaddleChangeDirMsg));
-
-    return msg;
 }
 
-void PaddlePosMsg_encode(const PaddlePosMsg *const msg, uint8_t *buf, const size_t buf_size) {
-    if (buf_size < sizeof(PaddlePosMsg)) {
-        LOG_FATALF("Buffer size too small (%zu), %zu required.", buf_size, sizeof(PaddlePosMsg));
-    }
+// buf is a pointer to one of the packed *Msg structs from networking.h
+void send_msg(FILE *s, const NetMsgType type, const uint8_t *const buf) {
+    const size_t buf_size = NetMsgType_to_buf_size(type);
 
-    memcpy(buf, msg, buf_size);
-}
-
-PaddlePosMsg PaddlePosMsg_decode(const uint8_t *buf, const size_t buf_size) {
-    if (buf_size < sizeof(PaddlePosMsg)) {
-        LOG_FATALF("Buffer size too small (%zu), %zu required.", buf_size, sizeof(PaddlePosMsg));
-    }
-    PaddlePosMsg msg = { 0 };
-    memcpy(&msg, buf, sizeof(PaddlePosMsg));
-    return msg;
-}
-
-void send_msg(FILE *s, const uint8_t *const buf, const size_t buf_size) {
     uint8_t *buf_cpy = (uint8_t *) malloc(sizeof(uint8_t) * buf_size);
     memcpy(buf_cpy, buf, buf_size);
     for (uint8_t *p = buf_cpy; p < buf_cpy + buf_size; p++) {
-        // if (*p == fb || *p == fe) {
-        //     *p += SEND_FRAME_MANGLE;
-        // }
         if (*p == fb) {
             *p += SEND_FRAME_MANGLE;
         }
@@ -60,15 +34,12 @@ void send_msg(FILE *s, const uint8_t *const buf, const size_t buf_size) {
     if (fwrite(&fb, sizeof(fb), 1, s) < 1) {
         LOG_FATAL("[send_msg] Failed to write fb");
     }
-    if (fwrite(&buf_size, sizeof(buf_size), 1, s) < 1) {
-        LOG_FATAL("[send_msg] Failed to write msg_len");
+    if (fwrite(&type, sizeof(NetMsgType), 1, s) < 1) {
+        LOG_FATAL("[send_msg] Failed to write msg type");
     }
     if (fwrite(buf_cpy, buf_size, 1, s) < 1) {
         LOG_FATAL("[send_msg] Failed to write msg");
     }
-    // if (fwrite(&fe, sizeof(fe), 1, s) < 1) {
-    //     LOG_FATAL("[send_msg] Failed to write fe");
-    // }
     if (fflush(s) != 0) {
         LOG_FATAL("[send_msg] Failed to flush stream");
     }
@@ -95,39 +66,36 @@ static bool recv_until_fb_or_empty_buf(FILE *s) {
     }
 }
 
-bool recv_msg(FILE *s, uint8_t *const buf, const size_t buf_size) {
-    bool found_fb = recv_until_fb_or_empty_buf(s);
+bool recv_msg_type(FILE *s, NetMsgType *const type) {
+    const bool found_fb = recv_until_fb_or_empty_buf(s);
     if (!found_fb) {
         return false;
     }
-
-    size_t msg_len;
-    if (fread(&msg_len, sizeof(msg_len), 1, s) < 1) {
-        LOG_FATAL("[recv_msg] Failed to read msg_len");
+    if (fread(type, sizeof(NetMsgType), 1, s) < 1) {
+        LOG_FATAL("[recv_msg] Failed to read msg type");
     }
 
-    if (buf_size < msg_len) {
-        LOG_FATALF("[recv_msg] Buffer too small. msg_len: %zu, buf_size: %zu", msg_len, buf_size);
+    switch (*type) {
+    case NET_MSG_PADDLE_CHANGE_DIR:
+    case NET_MSG_PADDLE_POS:
+        break;
+    default:
+        LOG_FATALF("[recv_msg_type] Invalid msg type: %u", type);
     }
-    if (fread(buf, buf_size, 1, s) < 1) {
+
+    return type;
+}
+
+// buf is a pointer to one of the packed *Msg structs from networking.h
+void recv_msg(FILE *s, const NetMsgType type, uint8_t *const buf) {
+    const size_t msg_len = NetMsgType_to_buf_size(type);
+
+    if (fread(buf, msg_len, 1, s) < 1) {
         LOG_FATAL("[recv_msg] Failed to read msg");
     }
-    for (uint8_t *p = buf; p < buf + buf_size; p++) {
-        // if (*p == fb + SEND_FRAME_MANGLE || *p == fe + SEND_FRAME_MANGLE) {
-        //     *p += RECV_FRAME_MANGLE;
-        // }
+    for (uint8_t *p = buf; p < buf + msg_len; p++) {
         if (*p == fb + SEND_FRAME_MANGLE) {
             *p += RECV_FRAME_MANGLE;
         }
     }
-
-    // uint8_t _fe;
-    // if (fread(&_fe, sizeof(_fe), 1, s) < 1) {
-    //     LOG_FATAL("[recv_msg] Failed to read _fe");
-    // }
-    // if (_fe != fe) {
-    //     return false;
-    // }
-
-    return true;
 }

src/common/networking.h

@@ -8,7 +8,7 @@
 #define SEND_FRAME_MANGLE ((uint8_t) 10)
 #define RECV_FRAME_MANGLE (-(SEND_FRAME_MANGLE))
 
-typedef enum {
+typedef enum : uint8_t {
     NET_MSG_PADDLE_CHANGE_DIR,
     NET_MSG_PADDLE_POS
 } NetMsgType;
@@ -24,9 +24,16 @@ typedef struct [[gnu::packed]] {
     uint8_t player1; // bool
 } PaddlePosMsg;
 
-void PaddleChangeDirMsg_encode(const PaddleChangeDirMsg *const msg, uint8_t *const buf, const size_t buf_size);
-PaddleChangeDirMsg PaddleChangeDir_decode(const uint8_t *buf, const size_t buf_size);
-void PaddlePosMsg_encode(const PaddlePosMsg *const msg, uint8_t *buf, const size_t buf_size);
-PaddlePosMsg PaddlePosMsg_decode(const uint8_t *buf, const size_t buf_size);
-void send_msg(FILE *s, const uint8_t *const buf, const size_t buf_size);
-bool recv_msg(FILE *s, uint8_t *const buf, const size_t buf_size);
+typedef struct [[gnu::packed]] {
+    float pos_x;
+    float pos_y;
+    float w;
+    float h;
+    float dirv_x;
+    float dirv_y;
+    float speed;
+} MovingObjectMsg;
+
+void send_msg(FILE *s, const NetMsgType type, const uint8_t *const buf);
+bool recv_msg_type(FILE *s, NetMsgType *const type);
+void recv_msg(FILE *s, const NetMsgType type, uint8_t *const buf);

src/game/MultiPlayer.c

@@ -106,14 +106,13 @@ void MultiPlayer_tick(MultiPlayer *const mp, const double delta) {
             .player1 = (uint8_t) true
         };
 
-        uint8_t buf[sizeof(PaddleChangeDirMsg)];
-        PaddleChangeDirMsg_encode(&msg, buf, sizeof(PaddleChangeDirMsg));
-        send_msg(mp->conn_s, buf, sizeof(PaddleChangeDirMsg));
+        send_msg(mp->conn_s, NET_MSG_PADDLE_CHANGE_DIR, (uint8_t *) &msg);
     }
 
-    uint8_t res_buf[sizeof(PaddlePosMsg)];
-    if (recv_msg(mp->conn_s, res_buf, sizeof(res_buf))) {
-        const PaddlePosMsg msg = PaddlePosMsg_decode(res_buf, sizeof(res_buf));
+    NetMsgType msg_type;
+    if (recv_msg_type(mp->conn_s, &msg_type)) {
+        PaddlePosMsg msg;
+        recv_msg(mp->conn_s, msg_type, (uint8_t *) &msg);
         vec2 pos = { msg.pos_x, msg.pos_y };
         const bool player1 = (bool) msg.player1;
         printf("Got msg from server: player1: %d, pos: (%.2lf, %.2lf)\n", player1, pos[0], pos[1]);
@@ -121,20 +120,6 @@ void MultiPlayer_tick(MultiPlayer *const mp, const double delta) {
         mp->state.paddle_l.pos[0] = pos[0];
         mp->state.paddle_l.pos[1] = pos[1];
     }
-    // size_t items_read = fread(res_buf, sizeof(res_buf), 1, mp->conn_s);
-    // if (items_read < 1) {
-    //     if (errno != EWOULDBLOCK) {
-    //         LOG_FATALF("Failed to receive from server: (%d) %s", errno, strerror(errno));
-    //     }
-    // } else {
-    //     const PaddlePosMsg msg = PaddlePosMsg_decode(res_buf, sizeof(res_buf));
-    //     vec2 pos = { msg.pos_x, msg.pos_y };
-    //     const bool player1 = (bool) msg.player1;
-    //     printf("Got msg from server: player1: %d, pos: (%.2lf, %.2lf)\n", player1, pos[0], pos[1]);
-    //     glmc_vec2_copy(pos, mp->state.paddle_l.pos);
-    //     mp->state.paddle_l.pos[0] = pos[0];
-    //     mp->state.paddle_l.pos[1] = pos[1];
-    // }
 
     GameState_update(&mp->state, delta);
     GameShapes_update(&mp->shapes, &mp->state, mp->screen_w, mp->screen_h);

src/game/pong.c

@@ -22,7 +22,7 @@ int main() {
     se_fps_lock_set_fps(60);
     se_font_load(FONT_PATH, 0, 48);
 
-    se_clear_color(0.0f, 0.0f, 0.0f, 1.0f);
+    se_clear_color(0.1f, 0.1f, 0.1f, 1.0f);
 
     MainMenu mm = MainMenu_alloc(screen_w, screen_h);
     SinglePlayer sp;

src/server/server.c

@@ -27,7 +27,11 @@ static FILE *p2_conn = nullptr;
 
 static ServerState server_state = SS_LOBBY;
 
+static GameState game_state;
+
 static void server_lobby(const int sock) {
+    game_state = GameState_new(game_default_params, false);
+
     int player1 = accept(sock, nullptr, nullptr);
     if (player1 == -1) {
         LOG_FATALF("accept failed: %s", strerror(errno));
@@ -58,8 +62,6 @@ static void server_lobby(const int sock) {
 }
 
 static void server_game() {
-    GameState state = GameState_new(game_default_params, false);
-
     se_fps_lock_set_fps(60);
 
     double last_frame_time_s = 0.0;
@@ -69,30 +71,33 @@ static void server_game() {
         se_fps_lock_frame_start_s(current_time_s);
 
         // Player input
-        uint8_t buf[sizeof(PaddleChangeDirMsg)];
-        if (recv_msg(p1_conn, buf, sizeof(buf))) {
-            PaddleChangeDirMsg msg = PaddleChangeDir_decode(buf, sizeof(buf));
-            SEDirection dir = (SEDirection) msg.dir;
-            bool player1 = (bool) msg.player1;
-            if (player1) {
-                const char *dir_str = dir == SE_UP ? "UP" : (dir == SE_DOWN ? "DOWN" : (dir == SE_NONE ? "NONE" : "INVALID"));
-                printf("Player 1 moves paddle to direction: %s\n", dir_str);
-                GameState_paddle_l_change_dir(&state, dir);
-                PaddlePosMsg res_msg = {
-                    .pos_x = state.paddle_l.pos[0],
-                    .pos_y = state.paddle_l.pos[1],
-                    .player1 = (uint8_t) true
-                };
-                uint8_t res_buf[sizeof(PaddlePosMsg)];
-                PaddlePosMsg_encode(&res_msg, res_buf, sizeof(res_buf));
-                send_msg(p1_conn, res_buf, sizeof(res_buf));
-            } else {
-                printf("Message was not from player1\n");
+        NetMsgType msg_type;
+        if (recv_msg_type(p1_conn, &msg_type)) {
+            switch (msg_type) {
+            case NET_MSG_PADDLE_CHANGE_DIR:
+                PaddleChangeDirMsg msg;
+                recv_msg(p1_conn, msg_type, (uint8_t *) &msg);
+                SEDirection dir = (SEDirection) msg.dir;
+                bool player1 = (bool) msg.player1;
+                if (player1) {
+                    const char *dir_str = dir == SE_UP ? "UP" : (dir == SE_DOWN ? "DOWN" : (dir == SE_NONE ? "NONE" : "INVALID"));
+                    printf("Player 1 moves paddle to direction: %s\n", dir_str);
+                    GameState_paddle_l_change_dir(&game_state, dir);
+                    PaddlePosMsg res_msg = {
+                        .pos_x = game_state.paddle_l.pos[0],
+                        .pos_y = game_state.paddle_l.pos[1],
+                        .player1 = (uint8_t) true
+                    };
+                    send_msg(p1_conn, NET_MSG_PADDLE_POS, (uint8_t *) &res_msg);
+                } else {
+                    printf("Message was not from player1\n");
+                }
+                break;
             }
         }
 
         // Tick
-        GameState_update(&state, delta);
+        GameState_update(&game_state, delta);
 
         // Player output