reorder main loop

src/game.c

 #define HEALTH_OFFSET_Y -16
 #define POWER_OFFSET_Y 16
 
+static uint8_t pause_screen(void) {
+    uint8_t hiwater = SPR_NUM_START;
+    spr_draw(SPR_PAUSE, FLIP_NONE, 0, 0, 0, &hiwater);
+    hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
+
+    while (1) {
+        key_read();
+        if (key_pressed(J_START)) {
+            break;
+        } else if (key_pressed(J_SELECT)) {
+            return 1;
+        }
+        vsync();
+    }
+
+    return 0;
+}
+
 static void status(uint8_t health, uint8_t power, uint8_t *hiwater) NONBANKED {
     if (health > 0) {
         switch (health >> 6) {
             }
         }
 
-        int32_t prev_score = score;
-        int16_t damage = obj_act(&spd_x, &spd_y, &score);
-        if (damage > 0) {
-            if (health > damage) {
-                health -= damage;
-            } else if (health <= damage) {
-                health = 0;
-                show_explosion(power);
-                break;
-            }
-        } else if (damage < 0) {
-            health += -damage;
-            if (health > HEALTH_MAX) {
-                health = HEALTH_MAX;
-            }
-        }
-
-        if (score != prev_score) {
-            uint8_t x_off = win_game_draw(score);
-            move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
-        }
-
         // adjust speed down when not moving
         if (!(acc & ACC_X)) {
             if (spd_x != 0) {
         uint8_t redraw = (acc & ACC_R) || ((prev_acc & (ACC_X | ACC_Y)) != (acc & (ACC_X | ACC_Y)));
 
         if (key_pressed(J_START)) {
-            uint8_t hiwater = SPR_NUM_START;
-            spr_draw(SPR_PAUSE, FLIP_NONE, 0, 0, 0, &hiwater);
-            hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
-
-            while (1) {
-                key_read();
-                if (key_pressed(J_START)) {
-                    break;
-                } else if (key_pressed(J_SELECT)) {
-                    return score;
-                }
-                vsync();
+            if (pause_screen()) {
+                break;
             }
 
             // re-draw ship sprite
             hiwater = ship_hiwater;
         }
 
-        obj_draw(&hiwater);
+        int32_t prev_score = score;
+        int16_t damage = obj_do(&spd_x, &spd_y, &score, &hiwater);
+        if (damage > 0) {
+            if (health > damage) {
+                health -= damage;
+            } else if (health <= damage) {
+                health = 0;
+                show_explosion(power);
+                break;
+            }
+        } else if (damage < 0) {
+            health += -damage;
+            if (health > HEALTH_MAX) {
+                health = HEALTH_MAX;
+            }
+        }
+
         status(health >> HEALTH_SHIFT, power >> POWER_SHIFT, &hiwater);
 
         hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
 
         prev_acc = acc;
 
+        if (score != prev_score) {
+            uint8_t x_off = win_game_draw(score);
+            move_win(MINWNDPOSX + DEVICE_SCREEN_PX_WIDTH - x_off, MINWNDPOSY + DEVICE_SCREEN_PX_HEIGHT - 16);
+        }
+
         vsync();
     }
 

src/obj.c

 #include "obj.h"
 
 /*
- * sprite budget:
+ * sprite budget: TODO
  *
  * fixed:
- * ship: 4
- * thruster: 1
+ * ship: 4 + 5
+ * thruster: 1 - 1
  * health: 4
  * power: 4
- * --> 13 fixed
+ * --> 17 fixed
  *
- * hardware tiles: 40 - 13 = 27
+ * hardware tiles: 40 - 13 = 27 - 4 = 23
  *
  * dynamic:
  * shot: 1
     memset(objs, 0, sizeof(objs));
 }
 
-static uint8_t cnt_sprite(enum SPRITES sprite) NONBANKED {
-    uint8_t cnt = 0;
-    for (uint8_t i = 0; i < MAX_OBJ; i++) {
-        if (!objs[i].active) {
-            continue;
-        }
-        if (objs[i].sprite == sprite) {
-            cnt++;
-        }
-    }
-    return cnt;
-}
-
 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 {
     uint8_t obj_cnt = 0xFF;
     for (uint8_t i = 0; i < MAX_OBJ; i++) {
         return OBJ_LIST_FULL;
     }
 
-    if (((sprite == SPR_DARK) && (cnt_sprite(sprite) >= MAX_DARK))
-            || ((sprite == SPR_LIGHT) && (cnt_sprite(sprite) >= MAX_LIGHT))
-            || ((sprite == SPR_SHOT) && (cnt_sprite(sprite) >= MAX_SHOT))
-            || ((sprite == SPR_SHOT_DARK) && (cnt_sprite(sprite) >= MAX_SHOT_DARK))
-            || ((sprite == SPR_SHOT_LIGHT) && (cnt_sprite(sprite) >= MAX_SHOT_LIGHT))) {
-        return OBJ_TYPE_FULL;
-    }
-
     objs[obj_cnt].active = 1;
     objs[obj_cnt].sprite = sprite;
     objs[obj_cnt].off_x = off_x << POS_SCALE_OBJS;
     return OBJ_ADDED;
 }
 
-int16_t obj_act(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score) NONBANKED {
+int16_t obj_do(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score, uint8_t *hiwater) NONBANKED {
     int16_t damage = 0;
+
+    // initial speed
     int16_t spd_x = *spd_off_x;
     int16_t spd_y = *spd_off_y;
 
             continue;
         }
 
-        // handle collission
+        int abs_off_x = abs(objs[i].off_x);
+        int abs_off_y = abs(objs[i].off_y);
+
+        // handle collision
         switch (objs[i].sprite) {
             case SPR_DARK:
-                if ((abs(objs[i].off_x) <= GRAVITY_RANGE) && (abs(objs[i].off_y) <= GRAVITY_RANGE)) {
+                if ((abs_off_x <= GRAVITY_RANGE) && (abs_off_y <= GRAVITY_RANGE)) {
                     if (objs[i].off_x > 0) {
                         *spd_off_x += (GRAVITY_RANGE - objs[i].off_x) >> GRAVITY_SHIFT;
                     } else if (objs[i].off_x < 0) {
                     }
                 }
 
-                if ((abs(objs[i].off_x) <= DAMAGE_RANGE) && (abs(objs[i].off_y) <= DAMAGE_RANGE)) {
+                if ((abs_off_x <= DAMAGE_RANGE) && (abs_off_y <= DAMAGE_RANGE)) {
                     damage += DAMAGE_INC;
                 }
                 break;
 
             case SPR_LIGHT:
-                if ((abs(objs[i].off_x) <= GRAVITY_RANGE) && (abs(objs[i].off_y) <= GRAVITY_RANGE)) {
+                if ((abs_off_x <= GRAVITY_RANGE) && (abs_off_y <= GRAVITY_RANGE)) {
                     if (objs[i].off_x > 0) {
                         *spd_off_x -= (GRAVITY_RANGE - objs[i].off_x) >> GRAVITY_SHIFT;
                     } else if (objs[i].off_x < 0) {
                     }
                 }
 
-                if ((abs(objs[i].off_x) <= PICKUP_LARGE_RANGE) && (abs(objs[i].off_y) <= PICKUP_LARGE_RANGE)) {
+                if ((abs_off_x <= PICKUP_LARGE_RANGE) && (abs_off_y <= PICKUP_LARGE_RANGE)) {
                     damage -= HEALTH_MAX;
                 }
                 break;
 
             case SPR_SHOT_DARK:
-                if ((abs(objs[i].off_x) <= PICKUP_SMALL_RANGE) && (abs(objs[i].off_y) <= PICKUP_SMALL_RANGE)) {
+                if ((abs_off_x <= PICKUP_SMALL_RANGE) && (abs_off_y <= PICKUP_SMALL_RANGE)) {
                     (*score) -= SCORE_SMALL;
                     objs[i].active = 0;
                 }
                 break;
 
             case SPR_SHOT_LIGHT:
-                if ((abs(objs[i].off_x) <= PICKUP_SMALL_RANGE) && (abs(objs[i].off_y) <= PICKUP_SMALL_RANGE)) {
+                if ((abs_off_x <= PICKUP_SMALL_RANGE) && (abs_off_y <= PICKUP_SMALL_RANGE)) {
                     (*score) += SCORE_SMALL;
                     objs[i].active = 0;
                 }
             default:
                 break;
         }
+
+        spr_draw(objs[i].sprite, FLIP_NONE, objs[i].off_x >> POS_SCALE_OBJS, objs[i].off_y >> POS_SCALE_OBJS, 0, hiwater);
     }
 
     return damage;

src/obj.h

 enum OBJ_STATE {
     OBJ_ADDED = 0,
     OBJ_LIST_FULL,
-    OBJ_TYPE_FULL,
 };
 
 void obj_init(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_act(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score);
+int16_t obj_do(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score, uint8_t *hiwater);
 void obj_draw(uint8_t *hiwater);
 
 #endif // __OBJ_H__