add spawning code. causes bank0 overflow, so put score code in BANKED. but crashes. why?!

src/game.c

     int32_t score = 0;
 
     obj_init();
-
-    // TODO remove
-    obj_add(SPR_LIGHT, 64, 64, 0, 0);
-    obj_add(SPR_DARK, -64, -64, 0, 0);
-    obj_add(SPR_SHOT_LIGHT, 32, 32, 0, 0);
-    obj_add(SPR_SHOT_DARK, -32, -32, 0, 0);
+    //obj_spawn();
 
     win_init(0);
     uint8_t x_off = win_game_draw(score);

src/main.c

         move_win(MINWNDPOSX, MINWNDPOSY);
     } else {
         // initially show the top 1 scores
-        int32_t low = score_lowest(0).score;
-        int32_t high = score_highest(0).score;
-        win_splash_draw(-low, high);
+        //int32_t low = score_lowest(0).score;
+        //int32_t high = score_highest(0).score;
+        //win_splash_draw(-low, high);
 
         move_win(MINWNDPOSX, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - (8 * 4));
     }

src/obj.c

 #include <stdint.h>
 #include <string.h>
 #include <stdlib.h>
+#include <rand.h>
 
 #include "gb/hardware.h"
 #include "sprites.h"
 
 #define DESPAWN_RANGE (250 << POS_SCALE_OBJS)
 
+#define PLACEMENT_DISTANCE 42
+
 struct obj {
     uint8_t active;
     enum SPRITES sprite;
 };
 
 static struct obj objs[MAX_OBJ];
+static uint8_t obj_cnt[SPRITE_COUNT];
 
 void obj_init(void) NONBANKED {
     memset(objs, 0, sizeof(objs));
+    memset(obj_cnt, 0, sizeof(obj_cnt));
+}
+
+static uint8_t is_too_close(int8_t x, int8_t y, uint8_t n, int8_t *x_c, int8_t *y_c) NONBANKED {
+    for (uint8_t i = 0; i < n; i++) {
+        int dst_x = abs(x_c[i] - x);
+        int dst_y = abs(y_c[i] - y);
+        if ((dst_x < PLACEMENT_DISTANCE) && (dst_y < PLACEMENT_DISTANCE)) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static void generate_coords(uint8_t n, int8_t *x_c, int8_t *y_c) NONBANKED {
+    int8_t x = 0;
+    int8_t y = 0;
+
+    do {
+        x = arand();
+        y = arand();
+    } while (is_too_close(x, y, n, x_c, y_c));
+
+    x_c[n] = x;
+    y_c[n] = y;
+}
+
+void obj_spawn(void) NONBANKED {
+    int8_t x_coords[MAX_DARK + MAX_LIGHT + MAX_SHOT_DARK + MAX_SHOT_LIGHT];
+    int8_t y_coords[MAX_DARK + MAX_LIGHT + MAX_SHOT_DARK + MAX_SHOT_LIGHT];
+    memset(x_coords, 0, sizeof(x_coords));
+    memset(y_coords, 0, sizeof(y_coords));
+
+    for (uint8_t i = 0; i < MAX_DARK; i++) {
+        uint8_t n = i;
+        generate_coords(n, x_coords, y_coords);
+        obj_add(SPR_DARK, x_coords[n], y_coords[n], 0, 0);
+    }
+    for (uint8_t i = 0; i < MAX_LIGHT; i++) {
+        uint8_t n = MAX_DARK + i;
+        generate_coords(n, x_coords, y_coords);
+        obj_add(SPR_LIGHT, x_coords[n], y_coords[n], 0, 0);
+    }
+    for (uint8_t i = 0; i < MAX_SHOT_DARK; i++) {
+        uint8_t n = MAX_DARK + MAX_LIGHT + i;
+        generate_coords(n, x_coords, y_coords);
+        obj_add(SPR_SHOT_DARK, x_coords[n], y_coords[n], 0, 0);
+    }
+    for (uint8_t i = 0; i < MAX_SHOT_LIGHT; i++) {
+        uint8_t n = MAX_DARK + MAX_LIGHT + MAX_SHOT_LIGHT + i;
+        generate_coords(n, x_coords, y_coords);
+        obj_add(SPR_SHOT_LIGHT, x_coords[n], y_coords[n], 0, 0);
+    }
 }
 
 enum OBJ_STATE obj_add(enum SPRITES sprite, int16_t off_x, int16_t off_y, int16_t spd_x, int16_t spd_y) NONBANKED {

src/obj.h

 };
 
 void obj_init(void);
+void obj_spawn(void);
 enum OBJ_STATE obj_add(enum SPRITES sprite, int16_t off_x, int16_t off_y, int16_t spd_x, int16_t spd_y);
 int16_t obj_do(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score, uint8_t *hiwater);
 

src/score.ba0.c

  * See <http://www.gnu.org/licenses/>.
  */
 
-#include <gbdk/platform.h>
 #include <string.h>
 
 #include "score.h"
-#include "gb/gb.h"
 
 static struct scores scores[SCORE_NUM * 2];
 static uint32_t scores_crc;
     //{ .name = NAME('d', 'j', '.'), .score = -10000 },
 };
 
-uint16_t convert_name(char a, char b, char c) NONBANKED {
+uint16_t convert_name(char a, char b, char c) BANKED {
     // convert to lowercase
     if ((a >= 'A') && (a <= 'Z')) a = a - 'A' + 'a';
     if ((b >= 'A') && (b <= 'Z')) b = b - 'A' + 'a';
     return (a << 10) | (b << 5) | c;
 }
 
-static uint32_t calc_crc(void) NONBANKED {
+static uint32_t calc_crc(void) BANKED {
     const uint8_t *d = (const uint8_t *)scores;
 
     uint32_t c = 0xFFFFFFFF;
     return ~c;
 }
 
-static uint8_t check_crc(void) NONBANKED {
+static uint8_t check_crc(void) BANKED {
     return (calc_crc() == scores_crc) ? 1 : 0;
 }
 
     scores_crc = calc_crc();
 }
 
-static uint8_t score_pos(int32_t score) NONBANKED {
+static uint8_t score_pos(int32_t score) BANKED {
     if (score > 0) {
         for (uint8_t i = 0; i < SCORE_NUM; i++) {
             if (score > scores[i].score) {
     return 0xFF;
 }
 
-uint8_t score_ranking(int32_t score) NONBANKED {
+uint8_t score_ranking(int32_t score) BANKED {
     ENABLE_RAM;
     SWITCH_RAM(0);
 
     return r;
 }
 
-void score_add(struct scores score) NONBANKED {
+void score_add(struct scores score) BANKED {
     ENABLE_RAM;
     SWITCH_RAM(0);
 
     DISABLE_RAM;
 }
 
-struct scores score_highest(uint8_t off) NONBANKED {
+struct scores score_highest(uint8_t off) BANKED {
     ENABLE_RAM;
     SWITCH_RAM(0);
 
     return r;
 }
 
-struct scores score_lowest(uint8_t off) NONBANKED {
+struct scores score_lowest(uint8_t off) BANKED {
     ENABLE_RAM;
     SWITCH_RAM(0);
 
     return r;
 }
 
-void score_reset(void) NONBANKED {
+void score_reset(void) BANKED {
     ENABLE_RAM;
     SWITCH_RAM(0);
     score_init();

src/score.h

 #ifndef __SCORE_H__
 #define __SCORE_H__
 
+#include <gbdk/platform.h>
 #include <stdint.h>
 
 #define SCORE_NUM 5
     int32_t score;
 };
 
-uint16_t convert_name(char a, char b, char c);
-uint8_t score_ranking(int32_t score);
-void score_add(struct scores score);
-struct scores score_highest(uint8_t off);
-struct scores score_lowest(uint8_t off);
-void score_reset(void);
+uint16_t convert_name(char a, char b, char c) BANKED;
+uint8_t score_ranking(int32_t score) BANKED;
+void score_add(struct scores score) BANKED;
+struct scores score_highest(uint8_t off) BANKED;
+struct scores score_lowest(uint8_t off) BANKED;
+void score_reset(void) BANKED;
 
 BANKREF_EXTERN(score)