add rotated ship sprite. basic 2-axis movement with 4-way rotation.

src/main.c

@@ -2,6 +2,8 @@
  * main.c
  * Duality
  *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ *
  * Based on examples from gbdk-2020:
  * https://github.com/gbdk-2020/gbdk-2020/blob/develop/gbdk-lib/examples/cross-platform/metasprites/src/metasprites.c
  * https://github.com/gbdk-2020/gbdk-2020/blob/develop/gbdk-lib/examples/gb/galaxy/galaxy.c
@@ -13,35 +15,12 @@
 #include <rand.h>
 #include <stdint.h>
 
-#include "title_map.h"
-#include "bg_map.h"
-#include "rockshp.h"
-#include "thrustG.h"
-#include "light.h"
-#include "dark.h"
-#include "shoot.h"
-
-#define TILE_WIDTH          8
-#define TILE_HEIGHT         8
-#define NUM_BYTES_PER_TILE  16
-
-#define ACC_X 1
-#define ACC_Y 2
+#include "maps.h"
+#include "sprites.h"
 
 // The metasprite will be built starting with hardware sprite zero (the first)
 #define SPR_NUM_START 0
 
-// Metasprite tiles are loaded into VRAM starting at tile number 0
-#define TILE_NUM_START 0
-
-static int16_t PosX = 0;
-static int16_t PosY = 0;
-static int16_t SpdX = 0;
-static int16_t SpdY = 0;
-static uint8_t PosF = 0;
-
-static uint8_t rot = 0;
-
 static uint8_t joyp = 0;
 static uint8_t old_joyp = 0;
 
@@ -49,122 +28,21 @@ static uint8_t old_joyp = 0;
 #define KEY_DOWN(KEY) (joyp & (KEY))
 #define KEY_PRESSED(KEY) ((joyp ^ old_joyp) & joyp & (KEY))
 
-struct sprites {
-    const metasprite_t * const * ms;
-    const uint8_t * ti;
-    const palette_color_t * pa;
-    uint8_t cnt;
-    uint8_t off;
+enum ACCELERATION {
+    ACC_X = 1,
+    ACC_Y = 2,
+    ACC_R = 4,
 };
 
-#define SPR_SHIP 0
-#define SPR_THRUST 1
-#define SPR_LIGHT 2
-#define SPR_DARK 3
-#define SPR_SHOT 4
-#define SPRITE_COUNT 5
-
-struct sprites metasprites[SPRITE_COUNT] = {
-    {
-        .ms = rockshp_metasprites,
-        .ti = rockshp_tiles,
-        .pa = rockshp_palettes,
-        .cnt = rockshp_TILE_COUNT,
-        .off = TILE_NUM_START
-    }, {
-        .ms = thrustG_metasprites,
-        .ti = thrustG_tiles,
-        .pa = thrustG_palettes,
-        .cnt = thrustG_TILE_COUNT,
-        .off = TILE_NUM_START
-    }, {
-        .ms = light_metasprites,
-        .ti = light_tiles,
-        .pa = light_palettes,
-        .cnt = light_TILE_COUNT,
-        .off = TILE_NUM_START
-    }, {
-        .ms = dark_metasprites,
-        .ti = dark_tiles,
-        .pa = dark_palettes,
-        .cnt = dark_TILE_COUNT,
-        .off = TILE_NUM_START
-    }, {
-        .ms = shoot_metasprites,
-        .ti = shoot_tiles,
-        .pa = shoot_palettes,
-        .cnt = shoot_TILE_COUNT,
-        .off = TILE_NUM_START
-    }
-};
-
-static void draw(uint8_t sprite, uint8_t *hiwater, int8_t y_off) {
-    switch (rot & 0x3) {
-        case 1:
-            *hiwater += move_metasprite_flipy(
-                    metasprites[sprite].ms[0], metasprites[sprite].off,
-                    OAMF_CGB_PAL0 + sprite, *hiwater,
-                    DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2),
-                    DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
-            break;
-
-        case 2:
-            *hiwater += move_metasprite_flipxy(
-                    metasprites[sprite].ms[0], metasprites[sprite].off,
-                    OAMF_CGB_PAL0 + sprite, *hiwater,
-                    DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2),
-                    DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
-            break;
-
-        case 3:
-            *hiwater += move_metasprite_flipx(
-                    metasprites[sprite].ms[0], metasprites[sprite].off,
-                    OAMF_CGB_PAL0 + sprite, *hiwater,
-                    DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2),
-                    DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
-            break;
-
-        default:
-            *hiwater += move_metasprite_ex(
-                    metasprites[sprite].ms[0], metasprites[sprite].off,
-                    OAMF_CGB_PAL0 + sprite, *hiwater,
-                    DEVICE_SPRITE_PX_OFFSET_X + (DEVICE_SCREEN_PX_WIDTH / 2),
-                    DEVICE_SPRITE_PX_OFFSET_Y + (DEVICE_SCREEN_PX_HEIGHT / 2) + y_off);
-            break;
-    }
-}
-
-static void ship(uint8_t *hiwater) {
-    switch (rot & 0x3) {
-        case 1:
-        case 2:
-            draw(SPR_SHIP, hiwater, 0);
-            if (PosF) {
-                draw(SPR_THRUST, hiwater, -8 - 4);
-            }
-            break;
-
-        case 3:
-        default:
-            draw(SPR_SHIP, hiwater, 0);
-            if (PosF) {
-                draw(SPR_THRUST, hiwater, 8 + 4);
-            }
-            break;
-    }
-}
+#define SPEED_INC 1
+#define SPEED_MAX 16
 
 static void splash(void) {
     disable_interrupts();
     DISPLAY_OFF;
 
     set_default_palette();
-
-    // title_map as background map
-    set_bkg_palette(OAMF_CGB_PAL0, title_map_PALETTE_COUNT, title_map_palettes);
-    set_bkg_data(0, bg_map_TILE_COUNT, title_map_tiles);
-    set_bkg_attributes(0, 0, title_map_MAP_ATTRIBUTES_WIDTH, title_map_MAP_ATTRIBUTES_HEIGHT, title_map_MAP_ATTRIBUTES);
-    set_bkg_tiles(0, 0, title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H, title_map_map);
+    map_title();
 
     SHOW_BKG;
     DISPLAY_ON;
@@ -184,22 +62,8 @@ static void game(void) {
     DISPLAY_OFF;
 
     set_default_palette();
-
-    // bg_map as background map
-    set_bkg_palette(OAMF_CGB_PAL0, bg_map_PALETTE_COUNT, bg_map_palettes);
-    set_bkg_data(0, bg_map_TILE_COUNT, bg_map_tiles);
-    set_bkg_attributes(0, 0, bg_map_MAP_ATTRIBUTES_WIDTH, bg_map_MAP_ATTRIBUTES_HEIGHT, bg_map_MAP_ATTRIBUTES);
-    set_bkg_tiles(0, 0, bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H, bg_map_map);
-
-    // metasprites
-    uint8_t off = TILE_NUM_START;
-    for (int i = 0; i < (sizeof(metasprites) / sizeof(metasprites[0])); i++) {
-        metasprites[i].off = off;
-        off += metasprites[i].cnt;
-
-        set_sprite_palette(OAMF_CGB_PAL0 + i, 1, metasprites[i].pa);
-        set_sprite_data(metasprites[i].off, metasprites[i].cnt, metasprites[i].ti);
-    }
+    map_game();
+    spr_init();
 
     SHOW_BKG;
     SHOW_SPRITES;
@@ -207,73 +71,70 @@ static void game(void) {
     DISPLAY_ON;
     enable_interrupts();
 
+    int16_t PosX = 0;
+    int16_t PosY = 0;
+    int16_t SpdX = 0;
+    int16_t SpdY = 0;
+    enum SPRITE_ROT rot = 0;
+    enum ACCELERATION prev_acc = 0xFF; // so we draw the ship on the first frame
+
     while(1) {
         KEY_INPUT;
 
-        PosF = 0;
+        enum ACCELERATION acc = 0;
 
-        // Game object
-        if (KEY_DOWN(J_UP)) {
-            SpdY -= 2;
-            if (SpdY < -32) SpdY = -32;
-            PosF |= ACC_Y;
-        } else if (KEY_DOWN(J_DOWN)) {
-            SpdY += 2;
-            if (SpdY > 32) SpdY = 32;
-            PosF |= ACC_Y;
+        if (KEY_PRESSED(J_LEFT)) {
+            rot = (rot - 1) & (ROT_INVALID - 1);
+            acc |= ACC_R;
+        } else if (KEY_PRESSED(J_RIGHT)) {
+            rot = (rot + 1) & (ROT_INVALID - 1);
+            acc |= ACC_R;
         }
 
-        if (KEY_DOWN(J_LEFT)) {
-            SpdX -= 2;
-            if (SpdX < -32) SpdX = -32;
-            PosF |= ACC_X;
-        } else if (KEY_DOWN(J_RIGHT)) {
-            SpdX += 2;
-            if (SpdX > 32) SpdX = 32;
-            PosF |= ACC_X;
-        }
-
-        if (KEY_PRESSED(J_A)) {
-            // TODO shoot
-        }
-
-        if (KEY_PRESSED(J_B)) {
-            rot++; rot &= 0x3;
+        if (KEY_DOWN(J_A)) {
+            switch (rot) {
+                case ROT_0:
+                    SpdY -= SPEED_INC;
+                    if (SpdY < -SPEED_MAX) SpdY = -SPEED_MAX;
+                    acc |= ACC_Y;
+                    break;
+
+                case ROT_90:
+                    SpdX += SPEED_INC;
+                    if (SpdX > SPEED_MAX) SpdX = SPEED_MAX;
+                    acc |= ACC_X;
+                    break;
+
+                case ROT_180:
+                    SpdY += SPEED_INC;
+                    if (SpdY > SPEED_MAX) SpdY = SPEED_MAX;
+                    acc |= ACC_Y;
+                    break;
+
+                case ROT_270:
+                    SpdX -= SPEED_INC;
+                    if (SpdX < -SPEED_MAX) SpdX = -SPEED_MAX;
+                    acc |= ACC_X;
+                    break;
+
+                default:
+                    break;
+            }
         }
 
         PosX += SpdX;
         PosY += SpdY;
 
-        // Y Axis: update velocity (reduce speed) if no U/D button pressed
-        if (!(PosF & ACC_Y)) {
-            if (SpdY != 0) {
-                if (SpdY > 0) SpdY--;
-                else SpdY ++;
-            }
-        }
-
-        // X Axis: update velocity (reduce speed) if no L/R button pressed
-        if (!(PosF & ACC_X)) {
-            if (SpdX != 0) {
-                if (SpdX > 0) SpdX--;
-                else SpdX ++;
-            }
-        }
-
         move_bkg(PosX >> 4, PosY >> 4);
 
-        uint8_t hiwater = SPR_NUM_START;
-
-        // NOTE: In a real game it would be better to only call the move_metasprite..()
-        //       functions if something changed (such as movement or rotation). That
-        //       reduces CPU usage on frames that don't need updates.
-        //
-        // In this example they are called every frame to simplify the example code
-
-        ship(&hiwater);
+        // re-draw ship sprite when we've just rotated or are starting or stopping acceleration
+        if ((acc & ACC_R) || ((prev_acc & (ACC_X | ACC_Y)) != (acc & (ACC_X | ACC_Y)))) {
+            uint8_t hiwater = SPR_NUM_START;
+            spr_ship(rot, acc & (ACC_X | ACC_Y), &hiwater);
+            hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
+        }
 
-        // Hide rest of the hardware sprites, because amount of sprites differ between animation frames.
-        hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
+        prev_acc = acc;
 
         vsync();
     }

src/maps.c

@@ -0,0 +1,27 @@
+/*
+ * maps.c
+ * Duality
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ */
+
+#include <gbdk/platform.h>
+
+#include "maps.h"
+
+#include "title_map.h"
+#include "bg_map.h"
+
+void map_title(void) {
+    set_bkg_palette(OAMF_CGB_PAL0, title_map_PALETTE_COUNT, title_map_palettes);
+    set_bkg_data(0, title_map_TILE_COUNT, title_map_tiles);
+    set_bkg_attributes(0, 0, title_map_MAP_ATTRIBUTES_WIDTH, title_map_MAP_ATTRIBUTES_HEIGHT, title_map_MAP_ATTRIBUTES);
+    set_bkg_tiles(0, 0, title_map_WIDTH / title_map_TILE_W, title_map_HEIGHT / title_map_TILE_H, title_map_map);
+}
+
+void map_game(void) {
+    set_bkg_palette(OAMF_CGB_PAL0, bg_map_PALETTE_COUNT, bg_map_palettes);
+    set_bkg_data(0, bg_map_TILE_COUNT, bg_map_tiles);
+    set_bkg_attributes(0, 0, bg_map_MAP_ATTRIBUTES_WIDTH, bg_map_MAP_ATTRIBUTES_HEIGHT, bg_map_MAP_ATTRIBUTES);
+    set_bkg_tiles(0, 0, bg_map_WIDTH / bg_map_TILE_W, bg_map_HEIGHT / bg_map_TILE_H, bg_map_map);
+}

src/maps.h

@@ -0,0 +1,14 @@
+/*
+ * maps.h
+ * Duality
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ */
+
+#ifndef __MAPS_H__
+#define __MAPS_H__
+
+void map_title(void);
+void map_game(void);
+
+#endif // __MAPS_H__

src/sprites.c

@@ -0,0 +1,160 @@
+/*
+ * sprites.c
+ * Duality
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ */
+
+#include <gbdk/platform.h>
+#include <gbdk/metasprites.h>
+#include <stdint.h>
+
+#include "sprites.h"
+
+#include "rockshp_0.h"
+#include "rockshp_90.h"
+#include "thrust_0.h"
+#include "thrust_90.h"
+#include "light.h"
+#include "dark.h"
+#include "shoot.h"
+
+// Metasprite tiles are loaded into VRAM starting at tile number 0
+#define TILE_NUM_START 0
+
+struct sprites {
+    const metasprite_t * const * ms;
+    const uint8_t * ti;
+    const palette_color_t * pa;
+    uint8_t cnt;
+    uint8_t off;
+};
+
+static struct sprites metasprites[SPRITE_COUNT] = {
+    {
+        .ms = rockshp_0_metasprites,
+        .ti = rockshp_0_tiles,
+        .pa = rockshp_0_palettes,
+        .cnt = rockshp_0_TILE_COUNT,
+        .off = TILE_NUM_START
+    }, {
+        .ms = rockshp_90_metasprites,
+        .ti = rockshp_90_tiles,
+        .pa = rockshp_90_palettes,
+        .cnt = rockshp_90_TILE_COUNT,
+        .off = TILE_NUM_START
+    }, {
+        .ms = thrust_0_metasprites,
+        .ti = thrust_0_tiles,
+        .pa = thrust_0_palettes,
+        .cnt = thrust_0_TILE_COUNT,
+        .off = TILE_NUM_START
+    }, {
+        .ms = thrust_90_metasprites,
+        .ti = thrust_90_tiles,
+        .pa = thrust_90_palettes,
+        .cnt = thrust_90_TILE_COUNT,
+        .off = TILE_NUM_START
+    }, {
+        .ms = light_metasprites,
+        .ti = light_tiles,
+        .pa = light_palettes,
+        .cnt = light_TILE_COUNT,
+        .off = TILE_NUM_START
+    }, {
+        .ms = dark_metasprites,
+        .ti = dark_tiles,
+        .pa = dark_palettes,
+        .cnt = dark_TILE_COUNT,
+        .off = TILE_NUM_START
+    }, {
+        .ms = shoot_metasprites,
+        .ti = shoot_tiles,
+        .pa = shoot_palettes,
+        .cnt = shoot_TILE_COUNT,
+        .off = TILE_NUM_START
+    }
+};
+
+void spr_init(void) {
+    uint8_t off = TILE_NUM_START;
+    for (int i = 0; i < (sizeof(metasprites) / sizeof(metasprites[0])); i++) {
+        metasprites[i].off = off;
+        off += metasprites[i].cnt;
+
+        set_sprite_palette(OAMF_CGB_PAL0 + i, 1, metasprites[i].pa);
+        set_sprite_data(metasprites[i].off, metasprites[i].cnt, metasprites[i].ti);
+    }
+}
+
+void spr_draw(uint8_t sprite, uint8_t *hiwater, enum SPRITE_FLIP flip, int8_t x_off, int8_t y_off) {
+    switch (flip) {
+        case FLIP_Y:
+            *hiwater += move_metasprite_flipy(
+                    metasprites[sprite].ms[0], metasprites[sprite].off,
+                    OAMF_CGB_PAL0 + sprite, *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[0], metasprites[sprite].off,
+                    OAMF_CGB_PAL0 + sprite, *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[0], metasprites[sprite].off,
+                    OAMF_CGB_PAL0 + sprite, *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_NONE:
+        default:
+            *hiwater += move_metasprite_ex(
+                    metasprites[sprite].ms[0], metasprites[sprite].off,
+                    OAMF_CGB_PAL0 + sprite, *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;
+    }
+}
+
+void spr_ship(enum SPRITE_ROT rot, uint8_t moving, uint8_t *hiwater) {
+    switch (rot) {
+        case ROT_0:
+            spr_draw(SPR_SHIP_0, hiwater, FLIP_NONE, 0, 0);
+            if (moving) {
+                spr_draw(SPR_THRUST_0, hiwater, FLIP_NONE, 0, 8 + 4);
+            }
+            break;
+
+        case ROT_90:
+            spr_draw(SPR_SHIP_90, hiwater, FLIP_NONE, 0, 0);
+            if (moving) {
+                spr_draw(SPR_THRUST_90, hiwater, FLIP_NONE, -8 - 4, 0);
+            }
+            break;
+
+        case ROT_180:
+            spr_draw(SPR_SHIP_0, hiwater, FLIP_Y, 0, 0);
+            if (moving) {
+                spr_draw(SPR_THRUST_0, hiwater, FLIP_Y, 0, -8 - 4);
+            }
+            break;
+
+        case ROT_270:
+            spr_draw(SPR_SHIP_90, hiwater, FLIP_X, 0, 0);
+            if (moving) {
+                spr_draw(SPR_THRUST_90, hiwater, FLIP_X, 8 + 4, 0);
+            }
+            break;
+
+        default:
+            break;
+    }
+}

src/sprites.h

@@ -0,0 +1,45 @@
+/*
+ * sprites.h
+ * Duality
+ *
+ * Copyright (C) 2025 Thomas Buck <thomas@xythobuz.de>
+ */
+
+#ifndef __SPRITES_H__
+#define __SPRITES_H__
+
+#include <stdint.h>
+
+enum SPRITES {
+    SPR_SHIP_0 = 0,
+    SPR_SHIP_90,
+    SPR_THRUST_0,
+    SPR_THRUST_90,
+    SPR_LIGHT,
+    SPR_DARK,
+    SPR_SHOT,
+
+    SPRITE_COUNT
+};
+
+enum SPRITE_FLIP {
+    FLIP_NONE = 0,
+    FLIP_X,
+    FLIP_Y,
+    FLIP_XY
+};
+
+enum SPRITE_ROT {
+    ROT_0 = 0,
+    ROT_90,
+    ROT_180,
+    ROT_270,
+
+    ROT_INVALID
+};
+
+void spr_init(void);
+void spr_draw(uint8_t sprite, uint8_t *hiwater, enum SPRITE_FLIP flip, int8_t x_off, int8_t y_off);
+void spr_ship(enum SPRITE_ROT rot, uint8_t moving, uint8_t *hiwater);
+
+#endif // __SPRITES_H__