multiplayer packet structs

src/game.c

         key_read();
 
         if (mode != GM_SINGLE) {
-            mp_handle();
+            if (mp_handle()) {
+                // TODO
+                //mp_new_state();
+            }
         }
 
         enum ACCELERATION acc = 0;

src/gbprinter.c

     static uint8_t map_buff[2 * DEVICE_SCREEN_WIDTH];
     static uint8_t tile_buff[2 * DEVICE_SCREEN_WIDTH * 16];
 
+    uint8_t r = PRN_STATUS_OK;
+
     for (int y = 0; y < DEVICE_SCREEN_HEIGHT; y += 2) {
         for (int y2 = 0; y2 < 2; y2++) {
             for (int x = 0; x < DEVICE_SCREEN_WIDTH; x++) {
                 : fill_bkg_rect(0, y + y2, DEVICE_SCREEN_WIDTH, 1, 0);
         }
 
-        gbprinter_print_image(map_buff, tile_buff, 0, DEVICE_SCREEN_WIDTH, 2,
-                              (y == (DEVICE_SCREEN_HEIGHT - 2)) ? 1 : 0);
+        r = gbprinter_print_image(map_buff, tile_buff, 0, DEVICE_SCREEN_WIDTH, 2,
+                                  (y == (DEVICE_SCREEN_HEIGHT - 2)) ? 1 : 0);
+        if (r != PRN_STATUS_OK) {
+            break;
+        }
     }
+
+    return r;
 }

src/maps.c

 }
 
 void map_dbg_reset(void) NONBANKED {
+#ifndef WRAP_BG
     uint16_t camera_x = abs_x >> POS_SCALE_BG;
     uint16_t camera_y = abs_y >> POS_SCALE_BG;
     uint8_t map_pos_x = camera_x >> 3;
                 attr);
         }
     }
+#endif // ! WRAP_BG
 }
 
 void map_move(int16_t delta_x, int16_t delta_y) NONBANKED {

src/multiplayer.c

 
 #define RETRANSMIT_TIME 200
 
+#define PKT_TYPE_PLAYER 0x00
+#define PKT_TYPE_SHOT 0x01
+
+struct mp_header {
+    uint8_t type;
+};
+
+struct mp_packet {
+    struct mp_header header;
+    union {
+        struct mp_player_state player;
+        struct mp_shot_state shot;
+    } data;
+};
+
+#define PKT_SIZE_PLAYER (sizeof(struct mp_player_state) + sizeof(struct mp_header))
+#define PKT_SIZE_SHOT (sizeof(struct mp_shot_state) + sizeof(struct mp_header))
+
 enum mp_state {
     MP_M_SEND = 0,
     MP_M_WAIT = 1,
 static uint16_t next_t = 0;
 static uint8_t our_turn = 0;
 
+static uint8_t *data = NULL;
+static uint8_t remaining = 0;
+
+static uint8_t rx_buff[sizeof(struct mp_packet)] = {0};
+static uint8_t rx_len = 0;
+
 uint8_t mp_connection_status = 0;
 
+static inline void Tx(uint8_t x) {
+    SB_REG = x;
+    SC_REG = SIOF_XFER_START | SIOF_CLOCK_INT;
+}
+
+static inline void Rx(uint8_t x) {
+    SB_REG = x;
+    SC_REG = SIOF_XFER_START | SIOF_CLOCK_EXT;
+}
+
+static inline void tx_rx(uint8_t x) {
+    our_turn ? Tx(x) : Rx(x);
+}
+
+static inline void transmit(struct mp_packet *pkt) {
+
+}
+
+static inline uint8_t transmitting(void) {
+    return SC_REG & SIOF_XFER_START;
+}
+
 uint8_t mp_master_ready(void) BANKED {
     switch (state) {
         case MP_M_SEND:
-            SB_REG = MASTER_HELLO;
-            SC_REG = SIOF_XFER_START | SIOF_CLOCK_INT;
+            Tx(MASTER_HELLO);
             next_t = timer_get() + RETRANSMIT_TIME;
             mp_connection_status++;
             state = MP_M_WAIT;
             break;
 
         case MP_M_WAIT:
-            if (!(SC_REG & SIOF_XFER_START)) {
+            if (!transmitting()) {
                 if (SB_REG == SLAVE_HELLO) {
-                    SB_REG = SLAVE_HELLO;
-                    SC_REG = SIOF_XFER_START | SIOF_CLOCK_EXT;
+                    Rx(SLAVE_HELLO);
                     next_t = timer_get() + RETRANSMIT_TIME;
                     mp_connection_status++;
                     state = MP_M_REPLY;
             break;
 
         case MP_M_REPLY:
-            if (!(SC_REG & SIOF_XFER_START)) {
+            if (!transmitting()) {
                 if (SB_REG == MASTER_HELLO) {
                     return 1;
                 } else {
 
 void mp_master_start(void) BANKED {
     our_turn = 1;
+    remaining = 0;
+    next_t = timer_get() + RETRANSMIT_TIME;
+
     game(GM_MULTI);
+
     state = 0;
 }
 
 uint8_t mp_slave_ready(void) BANKED {
     switch (state) {
         case MP_S_START:
-            SB_REG = SLAVE_HELLO;
-            SC_REG = SIOF_XFER_START | SIOF_CLOCK_EXT;
+            Rx(SLAVE_HELLO);
             next_t = timer_get() + RETRANSMIT_TIME;
             mp_connection_status++;
             state = MP_S_WAIT;
             break;
 
         case MP_S_WAIT:
-            if (!(SC_REG & SIOF_XFER_START)) {
+            if (!transmitting()) {
                 if (SB_REG == MASTER_HELLO) {
-                    SB_REG = MASTER_HELLO;
-                    SC_REG = SIOF_XFER_START | SIOF_CLOCK_INT;
+                    Tx(MASTER_HELLO);
                     next_t = timer_get() + RETRANSMIT_TIME;
                     mp_connection_status++;
                     state = MP_S_REPLY;
             break;
 
         case MP_S_REPLY:
-            if (!(SC_REG & SIOF_XFER_START)) {
+            if (!transmitting()) {
                 if (SB_REG == SLAVE_HELLO) {
                     return 1;
                 }
 
 void mp_slave_start(void) BANKED {
     our_turn = 0;
+    remaining = 0;
+    next_t = timer_get() + RETRANSMIT_TIME;
+
     game(GM_MULTI);
+
     state = 0;
 }
 
-void mp_handle(void) BANKED {
+uint8_t mp_handle(void) BANKED {
+    if ((our_turn) && (timer_get() >= next_t) && data && (remaining > 0)) {
+        if (rx_len < sizeof(struct mp_packet)) {
+            rx_buff[rx_len++] = SB_REG;
+        }
+        tx_rx(*(data++));
+        remaining--;
+    } else if ((!our_turn) && (!transmitting()) && data && (remaining > 0)) {
+        if (rx_len < sizeof(struct mp_packet)) {
+            rx_buff[rx_len++] = SB_REG;
+        }
+        tx_rx(*(data++));
+        remaining--;
+    }
+
+    return our_turn && (remaining == 0);
+}
+
+void mp_new_state(struct mp_player_state *state) BANKED {
+    // TODO
+}
 
+void mp_add_shot(struct mp_shot_state *state) BANKED {
+    // TODO
 }

src/multiplayer.h

 #include <gbdk/platform.h>
 #include <stdint.h>
 
+#include "sprites.h"
+
+struct mp_player_state {
+    int8_t pos_x, pos_y;
+    int8_t spd_x, spd_y;
+    enum SPRITE_ROT rot;
+};
+
+struct mp_shot_state {
+    int8_t pos_x, pos_y;
+    int8_t spd_x, spd_y;
+};
+
 uint8_t mp_master_ready(void) BANKED;
 void mp_master_start(void) BANKED;
 
 uint8_t mp_slave_ready(void) BANKED;
 void mp_slave_start(void) BANKED;
 
-void mp_handle(void) BANKED;
+uint8_t mp_handle(void) BANKED;
+
+void mp_new_state(struct mp_player_state *state) BANKED;
+void mp_add_shot(struct mp_shot_state *state) BANKED;
 
 extern uint8_t mp_connection_status;