pixel resolution status bars. also start with scoring and pickups.

src/game.c

 #include <gbdk/platform.h>
 #include <gbdk/metasprites.h>
 #include <rand.h>
-#include <stdint.h>
 
 #include "maps.h"
 #include "obj.h"
     if (health > 0) {
         switch (health >> 6) {
             case 3:
-                spr_draw(SPR_HEALTH, FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 24, hiwater);
+                spr_draw(SPR_HEALTH_1 + (((health >> 6) == 3) ? ((health >> 3) & 7) : 7),
+                         FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 24, hiwater);
             case 2:
-                spr_draw(SPR_HEALTH, FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 16, hiwater);
+                spr_draw(SPR_HEALTH_1 + (((health >> 6) == 2) ? ((health >> 3) & 7) : 7),
+                         FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 16, hiwater);
             case 1:
-                spr_draw(SPR_HEALTH, FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 8, hiwater);
+                spr_draw(SPR_HEALTH_1 + (((health >> 6) == 1) ? ((health >> 3) & 7) : 7),
+                         FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 8, hiwater);
             case 0:
-                spr_draw(SPR_HEALTH, FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 0, hiwater);
+                spr_draw(SPR_HEALTH_1 + (((health >> 6) == 0) ? ((health >> 3) & 7) : 7),
+                         FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 0, hiwater);
         }
     }
 
     if (power > 0) {
         switch (power >> 6) {
             case 3:
-                spr_draw(SPR_POWER, FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 0, hiwater);
+                spr_draw(SPR_POWER_1 + (((power >> 6) == 3) ? ((power >> 3) & 7) : 7),
+                         FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 0, hiwater);
             case 2:
-                spr_draw(SPR_POWER, FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 8, hiwater);
+                spr_draw(SPR_POWER_1 + (((power >> 6) == 2) ? ((power >> 3) & 7) : 7),
+                         FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 8, hiwater);
             case 1:
-                spr_draw(SPR_POWER, FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 16, hiwater);
+                spr_draw(SPR_POWER_1 + (((power >> 6) == 1) ? ((power >> 3) & 7) : 7),
+                         FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 16, hiwater);
             case 0:
-                spr_draw(SPR_POWER, FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 24, hiwater);
+                spr_draw(SPR_POWER_1 + (((power >> 6) == 0) ? ((power >> 3) & 7) : 7),
+                         FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 24, hiwater);
         }
     }
 }
 
-void game(void) {
+int32_t game(void) {
     disable_interrupts();
     DISPLAY_OFF;
     map_game();
     uint8_t ship_hiwater = 0;
     uint16_t health = HEALTH_MAX;
     uint16_t power = POWER_MAX;
+    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_DARK, -32, 0, 0, 0);
+    //obj_add(SPR_DARK, -32, 0, 0, 0);
     obj_add(SPR_SHOT_LIGHT, 32, 32, 0, 0);
     obj_add(SPR_SHOT_DARK, -32, -32, 0, 0);
 
             }
         }
 
-        uint8_t damage = obj_act(&spd_x, &spd_y);
-        if (health > damage) {
-            health -= damage;
-        } else if (health < damage) {
-            health = 0;
-
-            // TODO
+        int16_t damage = obj_act(&spd_x, &spd_y, &score);
+        if (damage > 0) {
+            if (health > damage) {
+                health -= damage;
+            } else if (health <= damage) {
+                health = 0;
+                break;
+            }
+        } else if (damage < 0) {
+            health += -damage;
+            if (health > HEALTH_MAX) {
+                health = HEALTH_MAX;
+            }
         }
 
         // adjust speed down when not moving
 
         vsync();
     }
+
+    return score;
 }

src/game.h

 #ifndef __GAME_H__
 #define __GAME_H__
 
+#include <stdint.h>
+
 #define SPEED_INC 1
 #define SPEED_DEC 1
 
 
 #define SHOT_SPEED 23
 
-void game(void);
+int32_t game(void);
 
 #endif // __GAME_H__

src/main.c

 #include <gbdk/platform.h>
 #include <gbdk/metasprites.h>
 #include <rand.h>
-#include <stdint.h>
 
 #include "maps.h"
 #include "obj.h"
     seed |= ((uint16_t)DIV_REG) << 8;
     initarand(seed);
 
-    game();
+    while (1) {
+        int32_t score = game();
+        // TODO
+    }
 }

src/obj.c

     return OBJ_ADDED;
 }
 
-uint8_t obj_act(int16_t *spd_off_x, int16_t *spd_off_y) {
-    uint8_t damage = 0;
+#define PICKUP_SMALL_RANGE (10 << POS_SCALE_OBJS)
+#define PICKUP_LARGE_RANGE (16 << POS_SCALE_OBJS)
+
+int16_t obj_act(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score) {
+    int16_t damage = 0;
 
     for (uint8_t i = 0; i < MAX_OBJ; i++) {
         if (!objs[i].active) {
         }
 
         switch (objs[i].sprite) {
-            case SPR_DARK: {
+            case SPR_DARK:
                 if ((abs(objs[i].off_x) <= GRAVITY_RANGE) && (abs(objs[i].off_y) <= GRAVITY_RANGE)) {
                     if (objs[i].off_x > 0) {
                         *spd_off_x += (GRAVITY_RANGE - objs[i].off_x) >> GRAVITY_SHIFT;
                 if ((abs(objs[i].off_x) <= DAMAGE_RANGE) && (abs(objs[i].off_y) <= DAMAGE_RANGE)) {
                     damage += DAMAGE_INC;
                 }
-            } break;
+                break;
+
+            case SPR_LIGHT:
+                // TODO
+                if ((abs(objs[i].off_x) <= PICKUP_LARGE_RANGE) && (abs(objs[i].off_y) <= PICKUP_LARGE_RANGE)) {
+                    damage -= 1;
+                }
+                break;
+
+            case SPR_SHOT_DARK:
+                if ((abs(objs[i].off_x) <= PICKUP_SMALL_RANGE) && (abs(objs[i].off_y) <= PICKUP_SMALL_RANGE)) {
+                    (*score)--;
+                    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)) {
+                    (*score)++;
+                    objs[i].active = 0;
+                }
+                break;
 
             default:
                 break;

src/obj.h

 
 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);
-uint8_t obj_act(int16_t *spd_off_x, int16_t *spd_off_y);
+int16_t obj_act(int16_t *spd_off_x, int16_t *spd_off_y, int32_t *score);
 void obj_draw(int16_t spd_x, int16_t spd_y, uint8_t *hiwater);
 
 #endif // __OBJ_H__

src/sprites.c

 #include "light.h"
 #include "dark.h"
 #include "shoot.h"
-#include "health.h"
+#include "bar_1.h"
+#include "bar_2.h"
+#include "bar_3.h"
+#include "bar_4.h"
+#include "bar_5.h"
+#include "bar_6.h"
+#include "bar_7.h"
+#include "bar_8.h"
 
 // Metasprite tiles are loaded into VRAM starting at tile number 0
 #define TILE_NUM_START 0
 };
 
 static struct sprites metasprites[SPRITE_COUNT] = {
-    {
+    { // SPR_SHIP_0
         .ms = rockshp_0_metasprites,
         .ti = rockshp_0_tiles,
         .pa = rockshp_0_palettes,
         .pa_i = OAMF_CGB_PAL0,
         .cnt = rockshp_0_TILE_COUNT,
         .off = TILE_NUM_START
-    }, {
+    },
+    { // SPR_SHIP_90
         .ms = rockshp_90_metasprites,
         .ti = rockshp_90_tiles,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL0,
         .cnt = rockshp_90_TILE_COUNT,
         .off = TILE_NUM_START
-    }, {
+    },
+    { // SPR_THRUST_0
         .ms = thrust_0_metasprites,
         .ti = thrust_0_tiles,
         .pa = thrust_0_palettes,
         .pa_i = OAMF_CGB_PAL1,
         .cnt = thrust_0_TILE_COUNT,
         .off = TILE_NUM_START
-    }, {
+    },
+    { // SPR_THRUST_90
         .ms = thrust_90_metasprites,
         .ti = thrust_90_tiles,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL1,
         .cnt = thrust_90_TILE_COUNT,
         .off = TILE_NUM_START
-    }, {
+    },
+    { // SPR_LIGHT
         .ms = light_metasprites,
         .ti = light_tiles,
         .pa = light_palettes,
         .pa_i = OAMF_CGB_PAL2,
         .cnt = light_TILE_COUNT,
         .off = TILE_NUM_START
-    }, {
+    },
+    { // SPR_DARK
         .ms = dark_metasprites,
         .ti = dark_tiles,
         .pa = dark_palettes,
         .pa_i = OAMF_CGB_PAL3,
         .cnt = dark_TILE_COUNT,
         .off = TILE_NUM_START
-    }, {
+    },
+    { // SPR_SHOT
         .ms = shoot_metasprites,
         .ti = shoot_tiles,
         .pa = shoot_palettes,
         .pa_i = OAMF_CGB_PAL4,
         .cnt = shoot_TILE_COUNT,
         .off = TILE_NUM_START
-    }, {
+    },
+    { // SPR_SHOT_LIGHT
         .ms = shoot_metasprites,
         .ti = shoot_tiles,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL2,
         .cnt = shoot_TILE_COUNT,
         .off = SPR_SHOT
-    }, {
+    },
+    { // SPR_SHOT_DARK
         .ms = shoot_metasprites,
         .ti = shoot_tiles,
         .pa = NULL,
         .pa_i = OAMF_CGB_PAL3,
         .cnt = shoot_TILE_COUNT,
         .off = SPR_SHOT
-    }, {
-        .ms = health_metasprites,
-        .ti = health_tiles,
-        .pa = health_palettes,
+    },
+    { // SPR_HEALTH_1
+        .ms = bar_1_metasprites,
+        .ti = bar_1_tiles,
+        .pa = bar_1_palettes,
         .pa_i = OAMF_CGB_PAL5,
-        .cnt = health_TILE_COUNT,
+        .cnt = bar_1_TILE_COUNT,
         .off = TILE_NUM_START
-    }, {
-        .ms = health_metasprites,
-        .ti = health_tiles,
+    },
+    { // SPR_HEALTH_2
+        .ms = bar_2_metasprites,
+        .ti = bar_2_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL5,
+        .cnt = bar_2_TILE_COUNT,
+        .off = TILE_NUM_START
+    },
+    { // SPR_HEALTH_3
+        .ms = bar_3_metasprites,
+        .ti = bar_3_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL5,
+        .cnt = bar_3_TILE_COUNT,
+        .off = TILE_NUM_START
+    },
+    { // SPR_HEALTH_4
+        .ms = bar_4_metasprites,
+        .ti = bar_4_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL5,
+        .cnt = bar_4_TILE_COUNT,
+        .off = TILE_NUM_START
+    },
+    { // SPR_HEALTH_5
+        .ms = bar_5_metasprites,
+        .ti = bar_5_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL5,
+        .cnt = bar_5_TILE_COUNT,
+        .off = TILE_NUM_START
+    },
+    { // SPR_HEALTH_6
+        .ms = bar_6_metasprites,
+        .ti = bar_6_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL5,
+        .cnt = bar_6_TILE_COUNT,
+        .off = TILE_NUM_START
+    },
+    { // SPR_HEALTH_7
+        .ms = bar_7_metasprites,
+        .ti = bar_7_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL5,
+        .cnt = bar_7_TILE_COUNT,
+        .off = TILE_NUM_START
+    },
+    { // SPR_HEALTH_8
+        .ms = bar_8_metasprites,
+        .ti = bar_8_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL5,
+        .cnt = bar_8_TILE_COUNT,
+        .off = TILE_NUM_START
+    },
+    { // SPR_POWER_1
+        .ms = bar_1_metasprites,
+        .ti = bar_1_tiles,
         .pa = power_palettes,
         .pa_i = OAMF_CGB_PAL6,
-        .cnt = health_TILE_COUNT,
-        .off = SPR_HEALTH
-    }
+        .cnt = bar_1_TILE_COUNT,
+        .off = SPR_HEALTH_1
+    },
+    { // SPR_POWER_2
+        .ms = bar_2_metasprites,
+        .ti = bar_2_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL6,
+        .cnt = bar_2_TILE_COUNT,
+        .off = SPR_HEALTH_2
+    },
+    { // SPR_POWER_3
+        .ms = bar_3_metasprites,
+        .ti = bar_3_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL6,
+        .cnt = bar_3_TILE_COUNT,
+        .off = SPR_HEALTH_3
+    },
+    { // SPR_POWER_4
+        .ms = bar_4_metasprites,
+        .ti = bar_4_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL6,
+        .cnt = bar_4_TILE_COUNT,
+        .off = SPR_HEALTH_4
+    },
+    { // SPR_POWER_5
+        .ms = bar_5_metasprites,
+        .ti = bar_5_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL6,
+        .cnt = bar_5_TILE_COUNT,
+        .off = SPR_HEALTH_5
+    },
+    { // SPR_POWER_6
+        .ms = bar_6_metasprites,
+        .ti = bar_6_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL6,
+        .cnt = bar_6_TILE_COUNT,
+        .off = SPR_HEALTH_6
+    },
+    { // SPR_POWER_7
+        .ms = bar_7_metasprites,
+        .ti = bar_7_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL6,
+        .cnt = bar_7_TILE_COUNT,
+        .off = SPR_HEALTH_7
+    },
+    { // SPR_POWER_8
+        .ms = bar_8_metasprites,
+        .ti = bar_8_tiles,
+        .pa = NULL,
+        .pa_i = OAMF_CGB_PAL6,
+        .cnt = bar_8_TILE_COUNT,
+        .off = SPR_HEALTH_8
+    },
 };
 
 void spr_init(void) {

src/sprites.h

     SPR_SHOT,
     SPR_SHOT_LIGHT,
     SPR_SHOT_DARK,
-    SPR_HEALTH,
-    SPR_POWER,
+    SPR_HEALTH_1,
+    SPR_HEALTH_2,
+    SPR_HEALTH_3,
+    SPR_HEALTH_4,
+    SPR_HEALTH_5,
+    SPR_HEALTH_6,
+    SPR_HEALTH_7,
+    SPR_HEALTH_8,
+    SPR_POWER_1,
+    SPR_POWER_2,
+    SPR_POWER_3,
+    SPR_POWER_4,
+    SPR_POWER_5,
+    SPR_POWER_6,
+    SPR_POWER_7,
+    SPR_POWER_8,
 
     SPRITE_COUNT
 };