add basic shooting

src/main.c

 #include <stdint.h>
 
 #include "maps.h"
+#include "obj.h"
 #include "sprites.h"
 
 // The metasprite will be built starting with hardware sprite zero (the first)
 
 #define SPEED_INC 1
 #define SPEED_MAX 16
+#define SHOT_SPEED 8
 
 static void splash(void) {
     disable_interrupts();
 
     set_default_palette();
     map_game();
-    spr_init();
 
     SHOW_BKG;
+
+    spr_init();
+    obj_init();
+
     SHOW_SPRITES;
     SPRITES_8x8;
     DISPLAY_ON;
     int16_t SpdY = 0;
     enum SPRITE_ROT rot = 0;
     enum ACCELERATION prev_acc = 0xFF; // so we draw the ship on the first frame
+    uint8_t ship_hiwater = 0;
+
+    // TODO remove
+    obj_add(SPR_LIGHT, 64, 64, 0, 0);
+    obj_add(SPR_DARK, -64, -64, 0, 0);
 
     while(1) {
         KEY_INPUT;
             }
         }
 
+        if (KEY_PRESSED(J_B)) {
+            switch (rot) {
+                case ROT_0:
+                    obj_add(SPR_SHOT, 0, -SHIP_OFF, 0, -SHOT_SPEED);
+                break;
+
+                case ROT_90:
+                    obj_add(SPR_SHOT, SHIP_OFF, 0, SHOT_SPEED, 0);
+                break;
+
+                case ROT_180:
+                    obj_add(SPR_SHOT, 0, SHIP_OFF, 0, SHOT_SPEED);
+                break;
+
+                case ROT_270:
+                    obj_add(SPR_SHOT, -SHIP_OFF, 0, -SHOT_SPEED, 0);
+                break;
+
+                default:
+                    break;
+            }
+        }
+
         PosX += SpdX;
         PosY += SpdY;
-
         move_bkg(PosX >> 4, PosY >> 4);
 
+        uint8_t hiwater = SPR_NUM_START;
+
         // 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);
+            ship_hiwater = hiwater;
+        } else {
+            hiwater = ship_hiwater;
         }
 
+        obj_draw(SpdX, SpdY, &hiwater);
+        hide_sprites_range(hiwater, MAX_HARDWARE_SPRITES);
+
         prev_acc = acc;
 
         vsync();

src/obj.c

+/*
+ * obj.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
+ * https://github.com/gbdk-2020/gbdk-2020/blob/develop/gbdk-lib/examples/gb/rand/rand.c
+ */
+
+#include <gbdk/platform.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "obj.h"
+#include "sprites.h"
+
+#define MAX_OBJ 10
+#define MAX_TRAVEL 2000
+
+struct obj {
+    uint8_t active;
+    enum SPRITES sprite;
+    int16_t off_x;
+    int16_t off_y;
+    int16_t spd_x;
+    int16_t spd_y;
+    uint16_t travel;
+};
+
+static struct obj objs[MAX_OBJ];
+
+void obj_init(void) {
+    memset(objs, 0, sizeof(objs));
+}
+
+int8_t obj_add(enum SPRITES sprite, int16_t off_x, int16_t off_y, int16_t spd_x, int16_t spd_y) {
+    uint8_t obj_cnt = 0xFF;
+    for (uint8_t i = 0; i < MAX_OBJ; i++) {
+        if (!objs[i].active) {
+            obj_cnt = i;
+            break;
+        }
+    }
+    if (obj_cnt >= MAX_OBJ) {
+        return OBJ_LIST_FULL;
+    }
+
+    objs[obj_cnt].active = 1;
+    objs[obj_cnt].sprite = sprite;
+    objs[obj_cnt].off_x = off_x << 4;
+    objs[obj_cnt].off_y = off_y << 4;
+    objs[obj_cnt].spd_x = spd_x;
+    objs[obj_cnt].spd_y = spd_y;
+    objs[obj_cnt].travel = 0;
+
+    obj_cnt += 1;
+    return OBJ_ADDED;
+}
+
+void obj_draw(int16_t spd_x, int16_t spd_y, uint8_t *hiwater) {
+    for (uint8_t i = 0; i < MAX_OBJ; i++) {
+        if (!objs[i].active) {
+            continue;
+        }
+
+        spr_draw(objs[i].sprite, hiwater, FLIP_NONE, objs[i].off_x >> 4, objs[i].off_y >> 4);
+
+        objs[i].off_x += objs[i].spd_x - spd_x;
+        objs[i].off_y += objs[i].spd_y - spd_y;
+
+        objs[i].travel += abs(objs[i].spd_x) + abs(objs[i].spd_y);
+        if (objs[i].travel >= MAX_TRAVEL) {
+            objs[i].active = 0;
+        }
+    }
+}

src/obj.h

+/*
+ * obj.h
+ * 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
+ * https://github.com/gbdk-2020/gbdk-2020/blob/develop/gbdk-lib/examples/gb/rand/rand.c
+ */
+
+#ifndef __OBJ_H__
+#define __OBJ_H__
+
+#include <stdint.h>
+#include "sprites.h"
+
+#define OBJ_ADDED 0
+#define OBJ_LIST_FULL -1
+
+void obj_init(void);
+int8_t obj_add(enum SPRITES sprite, int16_t off_x, int16_t off_y, int16_t spd_x, int16_t spd_y);
+void obj_draw(int16_t spd_x, int16_t spd_y, uint8_t *hiwater);
+
+#endif // __OBJ_H__

src/sprites.c

 
 #include <gbdk/platform.h>
 #include <gbdk/metasprites.h>
-#include <stdint.h>
 
 #include "sprites.h"
 
     }
 }
 
-void spr_draw(uint8_t sprite, uint8_t *hiwater, enum SPRITE_FLIP flip, int8_t x_off, int8_t y_off) {
+void spr_draw(enum SPRITES 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(
         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);
+                spr_draw(SPR_THRUST_0, hiwater, FLIP_NONE, 0, SHIP_OFF);
             }
             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);
+                spr_draw(SPR_THRUST_90, hiwater, FLIP_NONE, -SHIP_OFF, 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);
+                spr_draw(SPR_THRUST_0, hiwater, FLIP_Y, 0, -SHIP_OFF);
             }
             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);
+                spr_draw(SPR_THRUST_90, hiwater, FLIP_X, SHIP_OFF, 0);
             }
             break;
 

src/sprites.h

 
 #include <stdint.h>
 
+#define SHIP_OFF (8 + 4)
+
 enum SPRITES {
     SPR_SHIP_0 = 0,
     SPR_SHIP_90,
 };
 
 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_draw(enum SPRITES 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__