add explosion sprites and convert individual bar sprites to one. load explosion palettes dynamically.

Makefile

 ROMU := $(GBDK_HOME)/bin/romusage
 GB_EMU := gearboy
 
-LCCFLAGS := -Wa-l -Wl-m -Wp-MMD
+LCCFLAGS := -Wa-l -Wl-m -Wp-MMD # -Wf--opt-code-speed
 LCCFLAGS += -I$(BUILD_DIR)/$(DATA_DIR)
 LCCFLAGS += -Wm"-yn Duality" -Wm-yt0x1A -Wm-yoA -Wm-ya16 -Wm-yc
 LCCFLAGS += -autobank -Wb-ext=.rel -Wb-v -Wf-bo255
 	,$(if $(findstring _fnt,$<), \
 		@echo "Converting font $<" && \
 		$(PNGA) $< -o $@ -spr8x8 -sw 16 -sh 16 -map -noflip \
+	,$(if $(findstring _spr8,$<), \
+		@echo "Converting 8x8 sprite $<" && \
+		$(PNGA) $< -o $@ -spr8x8 -sw 8 -sh 8 -noflip \
+	,$(if $(findstring _spr16,$<), \
+		@echo "Converting 16x16 sprite $<" && \
+		$(PNGA) $< -o $@ -spr8x8 -sw 16 -sh 16 -noflip \
 	,                                     \
 		@echo "Converting tile $<" && \
 		$(PNGA) $< -o $@ -spr8x8      \
-	))
+	))))
 
 $(BUILD_DIR)/%.o: %.c $(SPRITES)
 	@mkdir -p $(@D)

src/game.c

     if (health > 0) {
         switch (health >> 6) {
             case 3:
-                spr_draw(SPR_HEALTH_1 + (((health >> 6) == 3) ? ((health >> 3) & 7) : 7),
-                         FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 24, 0, hiwater);
+                spr_draw(SPR_HEALTH, FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 24,
+                         ((health >> 6) == 3) ? 7 - ((health >> 3) & 7) : 0, hiwater);
             case 2:
-                spr_draw(SPR_HEALTH_1 + (((health >> 6) == 2) ? ((health >> 3) & 7) : 7),
-                         FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 16, 0, hiwater);
+                spr_draw(SPR_HEALTH, FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 16,
+                         ((health >> 6) == 2) ? 7 - ((health >> 3) & 7) : 0, hiwater);
             case 1:
-                spr_draw(SPR_HEALTH_1 + (((health >> 6) == 1) ? ((health >> 3) & 7) : 7),
-                         FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 8, 0, hiwater);
+                spr_draw(SPR_HEALTH, FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 8,
+                         ((health >> 6) == 1) ? 7 - ((health >> 3) & 7) : 0, hiwater);
             case 0:
-                spr_draw(SPR_HEALTH_1 + (((health >> 6) == 0) ? ((health >> 3) & 7) : 7),
-                         FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 0, 0, hiwater);
+                spr_draw(SPR_HEALTH, FLIP_X, BAR_OFFSET_X, HEALTH_OFFSET_Y - 0,
+                         ((health >> 6) == 0) ? 7 - ((health >> 3) & 7) : 0, hiwater);
         }
     }
 
     if (power > 0) {
         switch (power >> 6) {
             case 3:
-                spr_draw(SPR_POWER_1 + (((power >> 6) == 3) ? ((power >> 3) & 7) : 7),
-                         FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 0, 0, hiwater);
+                spr_draw(SPR_POWER, FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 0,
+                         ((power >> 6) == 3) ? 7 - ((power >> 3) & 7) : 0, hiwater);
             case 2:
-                spr_draw(SPR_POWER_1 + (((power >> 6) == 2) ? ((power >> 3) & 7) : 7),
-                         FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 8, 0, hiwater);
+                spr_draw(SPR_POWER, FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 8,
+                         ((power >> 6) == 2) ? 7 - ((power >> 3) & 7) : 0, hiwater);
             case 1:
-                spr_draw(SPR_POWER_1 + (((power >> 6) == 1) ? ((power >> 3) & 7) : 7),
-                         FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 16, 0, hiwater);
+                spr_draw(SPR_POWER, FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 16,
+                         ((power >> 6) == 1) ? 7 - ((power >> 3) & 7) : 0, hiwater);
             case 0:
-                spr_draw(SPR_POWER_1 + (((power >> 6) == 0) ? ((power >> 3) & 7) : 7),
-                         FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 24, 0, hiwater);
+                spr_draw(SPR_POWER, FLIP_X, BAR_OFFSET_X, POWER_OFFSET_Y + 24,
+                         ((power >> 6) == 0) ? 7 - ((power >> 3) & 7) : 0, hiwater);
         }
     }
 }
 
+static void show_explosion(uint16_t power) {
+    for (uint8_t n = 0; n < (4 * 4); n++) {
+        uint8_t hiwater = SPR_NUM_START;
+        spr_draw(SPR_EXPL, FLIP_NONE, 0, 0, n >> 2, &hiwater);
+
+        // can't draw objects, we used the pallettes for the explosion
+        //obj_draw(0, 0, &hiwater);
+
+        status(0, power >> POWER_SHIFT, &hiwater);
+        hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
+        vsync();
+    }
+}
+
 int32_t game(void) NONBANKED {
     disable_interrupts();
     DISPLAY_OFF;
     map_game();
     SHOW_BKG;
+    spr_init_pal();
     SHOW_SPRITES;
     SPRITES_8x8;
 
                 health -= damage;
             } else if (health <= damage) {
                 health = 0;
+                show_explosion(power);
                 break;
             }
         } else if (damage < 0) {

src/main.c

     HIDE_WIN;
 
     hide_sprites_range(SPR_NUM_START, MAX_HARDWARE_SPRITES);
-    win_score_clear(is_black);
+    win_score_clear(is_black ? 1 : 0);
 
     move_win(MINWNDPOSX, MINWNDPOSY);
     SHOW_WIN;
     disable_interrupts();
     DISPLAY_OFF;
     map_title();
+    move_bkg(0, 0);
     SHOW_BKG;
+    spr_init_pal();
     SHOW_SPRITES;
     SPRITES_8x8;
 
     }
 }
 
-uint16_t ask_name(void) NONBANKED {
+uint16_t ask_name(int32_t score) NONBANKED {
     disable_interrupts();
     DISPLAY_OFF;
     map_title();
+    move_bkg(0, 0);
     SHOW_BKG;
+    spr_init_pal();
     SHOW_SPRITES;
     SPRITES_8x8;
 
     hide_sprites_range(SPR_NUM_START, MAX_HARDWARE_SPRITES);
 
+    win_init(1);
+    win_name(score);
+
     // TODO ask for name
 
     move_win(MINWNDPOSX, MINWNDPOSY);
         int32_t score = game();
 
         if (score_ranking(score)) {
-            uint16_t name = ask_name();
+            uint16_t name = ask_name(score);
             struct scores s = { .name = name, .score = score };
             score_add(s);
         }

src/maps.c

     uint8_t n = 0;
     while (*s) {
         char c = *(s++);
-        if ((c >= 'A') && (c <= 'Z')) c = c - 'A' + 'a';
-        if ((c < 'a') || (c > 'z')) c = 'x';
+        if ((c >= 'A') && (c <= 'Z')) {
+            c = c - 'A' + 'a';
+        }
+        if ((c < 'a') || (c > 'z')) {
+            n++;
+            continue;
+        }
         character(c - 'a', n++, x_off, y_off, is_black);
     }
 }
     number(is_black ? -score.score : score.score, 7, 4 + off * 3, is_black);
 }
 
+void win_name(int32_t score) NONBANKED {
+    SWITCH_ROM(BANK(title_map));
+    set_win_based(0, 0,
+                  title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H,
+                  title_map_map, 0, title_map_MAP_ATTRIBUTES);
+
+    str("score", 10 - 5, 1, score < 0);
+    number(score, 0xFF, 3, score < 0);
+
+    str("enter", 10 - 5, 6, score < 0);
+    str("name", 10 - 4, 8, score < 0);
+
+    // placeholder
+    str("aaa", 10 - 3, 12, score < 0);
+
+    str("start ok", 10 - 8, 16, score < 0);
+}
+
 uint8_t win_game_draw(int32_t score) NONBANKED {
     fill_win(0, 0, 10, 2, fnt_off + numbers_fnt_TILE_COUNT, 0x81);
 

src/maps.h

 void win_splash_draw(int32_t lowest, int32_t highest);
 void win_score_clear(uint8_t is_black);
 void win_score_draw(struct scores score, uint8_t off, uint8_t is_black);
+void win_name(int32_t score);
 uint8_t win_game_draw(int32_t score);
 
 #endif // __MAPS_H__

src/sprite_data.c

 #include "light.h"
 #include "dark.h"
 #include "shoot.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"
+#include "bar_spr8.h"
+#include "expl_spr16.h"
 
 const palette_color_t power_palettes[4] = {
   //RGB8(  0,  0,  0), RGB8(240,  0,  0), RGB8(196,  0,  0), RGB8(116,  0,  0)
 struct sprites metasprites[SPRITE_COUNT] = {
     { // SPR_SHIP_0
         .ms = rockshp_0_metasprites,
+        .ms_n = ARR_LEN(rockshp_0_metasprites),
         .ti = rockshp_0_tiles,
         .pa = rockshp_0_palettes,
+        .pa_n = rockshp_0_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL0,
         .cnt = rockshp_0_TILE_COUNT,
         .off = TILE_NUM_START,
     },
     { // SPR_SHIP_90
         .ms = rockshp_90_metasprites,
+        .ms_n = ARR_LEN(rockshp_90_metasprites),
         .ti = rockshp_90_tiles,
         .pa = NULL,
+        .pa_n = rockshp_90_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL0,
         .cnt = rockshp_90_TILE_COUNT,
         .off = TILE_NUM_START,
     },
     { // SPR_THRUST_0
         .ms = thrust_0_metasprites,
+        .ms_n = ARR_LEN(thrust_0_metasprites),
         .ti = thrust_0_tiles,
         .pa = thrust_0_palettes,
+        .pa_n = thrust_0_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL1,
         .cnt = thrust_0_TILE_COUNT,
         .off = TILE_NUM_START,
     },
     { // SPR_THRUST_90
         .ms = thrust_90_metasprites,
+        .ms_n = ARR_LEN(thrust_90_metasprites),
         .ti = thrust_90_tiles,
         .pa = NULL,
+        .pa_n = thrust_90_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL1,
         .cnt = thrust_90_TILE_COUNT,
         .off = TILE_NUM_START,
     },
     { // SPR_LIGHT
         .ms = light_metasprites,
+        .ms_n = ARR_LEN(light_metasprites),
         .ti = light_tiles,
         .pa = light_palettes,
+        .pa_n = light_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL2,
         .cnt = light_TILE_COUNT,
         .off = TILE_NUM_START,
     },
     { // SPR_DARK
         .ms = dark_metasprites,
+        .ms_n = ARR_LEN(dark_metasprites),
         .ti = dark_tiles,
         .pa = dark_palettes,
+        .pa_n = dark_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL3,
         .cnt = dark_TILE_COUNT,
         .off = TILE_NUM_START,
     },
     { // SPR_SHOT
         .ms = shoot_metasprites,
+        .ms_n = ARR_LEN(shoot_metasprites),
         .ti = shoot_tiles,
         .pa = shoot_palettes,
+        .pa_n = shoot_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL4,
         .cnt = shoot_TILE_COUNT,
         .off = TILE_NUM_START,
     },
     { // SPR_SHOT_LIGHT
         .ms = shoot_metasprites,
+        .ms_n = ARR_LEN(shoot_metasprites),
         .ti = shoot_tiles,
         .pa = NULL,
+        .pa_n = shoot_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL2,
         .cnt = shoot_TILE_COUNT,
         .off = SPR_SHOT,
     },
     { // SPR_SHOT_DARK
         .ms = shoot_metasprites,
+        .ms_n = ARR_LEN(shoot_metasprites),
         .ti = shoot_tiles,
         .pa = NULL,
+        .pa_n = shoot_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL3,
         .cnt = shoot_TILE_COUNT,
         .off = SPR_SHOT,
         .bank = BANK(shoot),
     },
-    { // SPR_HEALTH_1
-        .ms = bar_1_metasprites,
-        .ti = bar_1_tiles,
-        .pa = bar_1_palettes,
+    { // SPR_HEALTH
+        .ms = bar_spr8_metasprites,
+        .ms_n = ARR_LEN(bar_spr8_metasprites),
+        .ti = bar_spr8_tiles,
+        .pa = bar_spr8_palettes,
+        .pa_n = bar_spr8_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL5,
-        .cnt = bar_1_TILE_COUNT,
+        .cnt = bar_spr8_TILE_COUNT,
         .off = TILE_NUM_START,
-        .bank = BANK(bar_1),
+        .bank = BANK(bar_spr8),
     },
-    { // 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,
-        .bank = BANK(bar_2),
-    },
-    { // 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,
-        .bank = BANK(bar_3),
-    },
-    { // 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,
-        .bank = BANK(bar_4),
-    },
-    { // 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,
-        .bank = BANK(bar_5),
-    },
-    { // 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,
-        .bank = BANK(bar_6),
-    },
-    { // 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,
-        .bank = BANK(bar_7),
-    },
-    { // 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,
-        .bank = BANK(bar_8),
-    },
-    { // SPR_POWER_1
-        .ms = bar_1_metasprites,
-        .ti = bar_1_tiles,
+    { // SPR_POWER
+        .ms = bar_spr8_metasprites,
+        .ms_n = ARR_LEN(bar_spr8_metasprites),
+        .ti = bar_spr8_tiles,
         .pa = power_palettes,
+        .pa_n = bar_spr8_PALETTE_COUNT,
         .pa_i = OAMF_CGB_PAL6,
-        .cnt = bar_1_TILE_COUNT,
-        .off = SPR_HEALTH_1,
-        .bank = BANK(bar_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,
-        .bank = BANK(bar_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,
-        .bank = BANK(bar_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,
-        .bank = BANK(bar_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,
-        .bank = BANK(bar_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,
-        .bank = BANK(bar_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,
-        .bank = BANK(bar_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,
-        .bank = BANK(bar_8),
+        .cnt = bar_spr8_TILE_COUNT,
+        .off = SPR_HEALTH,
+        .bank = BANK(bar_spr8),
+    },
+    { // SPR_EXPL
+        .ms = expl_spr16_metasprites,
+        .ms_n = ARR_LEN(expl_spr16_metasprites),
+        .ti = expl_spr16_tiles,
+        .pa = expl_spr16_palettes,
+        .pa_n = expl_spr16_PALETTE_COUNT,
+        .pa_i = OAMF_CGB_PAL0 | PALETTE_DYNAMIC_LOAD,
+        .cnt = expl_spr16_TILE_COUNT,
+        .off = TILE_NUM_START,
+        .bank = BANK(expl_spr16),
     }
 };

src/sprite_data.h

 // Metasprite tiles are loaded into VRAM starting at tile number 0
 #define TILE_NUM_START 0
 
+#define PALETTE_DYNAMIC_LOAD 0xF0
+#define PALETTE_NO_FLAGS 0x0F
+
+#define ARR_LEN(x) (sizeof(x) / sizeof(x[0]))
+
 struct sprites {
     const metasprite_t * const * ms;
+    uint8_t ms_n;
     const uint8_t * ti;
     const palette_color_t * pa;
+    uint8_t pa_n;
     uint8_t pa_i;
     uint8_t cnt;
     uint8_t off;

src/sprites.c

     for (uint8_t i = 0; i < SPRITE_COUNT; i++) {
         SWITCH_ROM(metasprites[i].bank);
 
-        if (metasprites[i].pa != NULL) {
-            set_sprite_palette(metasprites[i].pa_i, 1, metasprites[i].pa);
-        }
-
         if (metasprites[i].off == TILE_NUM_START) {
             metasprites[i].off = off;
             off += metasprites[i].cnt;
     }
 }
 
+void spr_init_pal(void) NONBANKED {
+    for (uint8_t i = 0; i < SPRITE_COUNT; i++) {
+        SWITCH_ROM(metasprites[i].bank);
+
+        if ((metasprites[i].pa != NULL) && (!(metasprites[i].pa_i & 0xF0))) {
+            set_sprite_palette(metasprites[i].pa_i, metasprites[i].pa_n, metasprites[i].pa);
+        }
+    }
+}
+
 void spr_draw(enum SPRITES sprite, enum SPRITE_FLIP flip,
               int8_t x_off, int8_t y_off, uint8_t frame,
               uint8_t *hiwater) NONBANKED {
     SWITCH_ROM(metasprites[sprite].bank);
 
+    if (frame >= metasprites[sprite].ms_n) {
+        frame = 0;
+    }
+
+    if (metasprites[sprite].pa_i & PALETTE_DYNAMIC_LOAD) {
+        uint8_t pa_i = frame;
+        if (pa_i >= metasprites[sprite].pa_n) {
+            pa_i = 0;
+        }
+
+        // used for explosion. just overwrite our fist four palettes. we dont need them at the end of the game.
+        set_sprite_palette((metasprites[sprite].pa_i & PALETTE_NO_FLAGS) + pa_i, 1, metasprites[sprite].pa + (pa_i * 1));
+    }
+
     switch (flip) {
         case FLIP_Y:
             *hiwater += move_metasprite_flipy(
                     metasprites[sprite].ms[frame], metasprites[sprite].off,
-                    metasprites[sprite].pa_i, *hiwater,
+                    metasprites[sprite].pa_i & PALETTE_NO_FLAGS, *hiwater,
                     DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
                     DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
             break;
         case FLIP_XY:
             *hiwater += move_metasprite_flipxy(
                     metasprites[sprite].ms[frame], metasprites[sprite].off,
-                    metasprites[sprite].pa_i, *hiwater,
+                    metasprites[sprite].pa_i & PALETTE_NO_FLAGS, *hiwater,
                     DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
                     DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
             break;
         case FLIP_X:
             *hiwater += move_metasprite_flipx(
                     metasprites[sprite].ms[frame], metasprites[sprite].off,
-                    metasprites[sprite].pa_i, *hiwater,
+                    metasprites[sprite].pa_i & PALETTE_NO_FLAGS, *hiwater,
                     DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
                     DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
             break;
         default:
             *hiwater += move_metasprite_ex(
                     metasprites[sprite].ms[frame], metasprites[sprite].off,
-                    metasprites[sprite].pa_i, *hiwater,
+                    metasprites[sprite].pa_i & PALETTE_NO_FLAGS, *hiwater,
                     DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2) + x_off,
                     DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
             break;

src/sprites.h

     SPR_SHOT,
     SPR_SHOT_LIGHT,
     SPR_SHOT_DARK,
-    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,
+    SPR_HEALTH,
+    SPR_POWER,
+    SPR_EXPL,
 
     SPRITE_COUNT
 };
 };
 
 void spr_init(void);
+void spr_init_pal(void);
 void spr_draw(enum SPRITES sprite, enum SPRITE_FLIP flip, int8_t x_off, int8_t y_off, uint8_t frame, uint8_t *hiwater);
 void spr_ship(enum SPRITE_ROT rot, uint8_t moving, uint8_t *hiwater);