generate a const shot speed table to save lots of rom bank 0 space

Makefile

 GIT := $(BUILD_DIR)/$(DATA_DIR)/git.c
 SRCS += $(GIT)
 
+SPEED_TABLE := $(BUILD_DIR)/$(DATA_DIR)/speed_table.c
+SRCS += $(SPEED_TABLE)
+
 OBJS := $(SRCS:%.c=$(BUILD_DIR)/%.o)
 
 IMAGES := $(wildcard $(DATA_DIR)/*.png)
 DEPS=$(OBJS:%.o=%.d)
 -include $(DEPS)
 
-.PHONY: all run cloc sgb_run bgb_run gbe_run flash clean compile_commands.json usage $(GIT)
+.PHONY: all run cloc sgb_run bgb_run gbe_run flash clean compile_commands.json usage $(GIT) $(SPEED_TABLE)
 .PRECIOUS: $(BUILD_DIR)/$(DATA_DIR)/%.c $(BUILD_DIR)/$(DATA_DIR)/%.h
 
 all: $(BIN)
 	@echo Generating $@ from $<
 	@sed 's|GIT_VERSION|$(shell git describe --abbrev=7 --dirty --always --tags)|g' $< > $@
 
+$(SPEED_TABLE):
+	@echo Generating $@
+	@util/gen_angles.py -n speed_table -d $(BUILD_DIR)/$(DATA_DIR) -s 16 -w 2 -f 0 -m 42 -t int8_t
+
 usage: $(BUILD_DIR)/$(BIN)
 	@echo Analyzing $<
 	@$(ROMU) $(BUILD_DIR)/$(BIN:%.gb=%.map)

src/game.c

 #include <rand.h>
 #include <stdint.h>
 
+#include "banks.h"
 #include "config.h"
 #include "maps.h"
 #include "obj.h"
 #include "sample.h"
 #include "window.h"
 #include "multiplayer.h"
+#include "speed_table.h"
 #include "game.h"
 
 #define BAR_OFFSET_X (4 - 80)
         }
 
         if (key_pressed(J_B)) {
+            int16_t shot_spd_x;
+            int16_t shot_spd_y;
+            START_ROM_BANK(BANK(speed_table)) {
+                shot_spd_x = spd_x + speed_table[(rot * speed_table_WIDTH) + 0];
+                shot_spd_y = spd_y - speed_table[(rot * speed_table_WIDTH) + 1];
+            } END_ROM_BANK;
+
+            // TODO ugly hard-coded offsets?!
             int16_t shot_pos_x = 0, shot_pos_y = 0;
-            int16_t shot_spd_x = 0, shot_spd_y = 0;
-
             switch (rot) {
                 case ROT_0:
                     shot_pos_x = 0;
                     shot_pos_y = -SHIP_OFF;
-                    shot_spd_x = spd_x;
-                    shot_spd_y = spd_y - SHOT_SPEED;
                     break;
 
                 case ROT_22_5:
                     shot_pos_x = SHIP_OFF / 2 - 1;
                     shot_pos_y = -SHIP_OFF / 2 - 4;
-                    shot_spd_x = spd_x + SHOT_SPEED_D_LO;
-                    shot_spd_y = spd_y - SHOT_SPEED_D_HI;
                     break;
 
                 case ROT_45:
                     shot_pos_x = SHIP_OFF / 2 + 3;
                     shot_pos_y = -SHIP_OFF / 2 - 2;
-                    shot_spd_x = spd_x + SHOT_SPEED_DIAG;
-                    shot_spd_y = spd_y - SHOT_SPEED_DIAG;
                     break;
 
                 case ROT_67_5:
                     shot_pos_x = SHIP_OFF / 2 + 5;
                     shot_pos_y = -SHIP_OFF / 2 + 2;
-                    shot_spd_x = spd_x + SHOT_SPEED_D_HI;
-                    shot_spd_y = spd_y - SHOT_SPEED_D_LO;
                     break;
 
                 case ROT_90:
                     shot_pos_x = SHIP_OFF;
                     shot_pos_y = 0;
-                    shot_spd_x = spd_x + SHOT_SPEED;
-                    shot_spd_y = spd_y;
                     break;
 
                 case ROT_112_5:
                     shot_pos_x = SHIP_OFF / 2 + 5;
                     shot_pos_y = SHIP_OFF / 2 + 0;
-                    shot_spd_x = spd_x + SHOT_SPEED_D_HI;
-                    shot_spd_y = spd_y + SHOT_SPEED_D_LO;
                     break;
 
                 case ROT_135:
                     shot_pos_x = SHIP_OFF / 2 + 3;
                     shot_pos_y = SHIP_OFF / 2 + 2;
-                    shot_spd_x = spd_x + SHOT_SPEED_DIAG;
-                    shot_spd_y = spd_y + SHOT_SPEED_DIAG;
                     break;
 
                 case ROT_157_5:
                     shot_pos_x = SHIP_OFF / 2 + 1;
                     shot_pos_y = SHIP_OFF / 2 + 4;
-                    shot_spd_x = spd_x + SHOT_SPEED_D_LO;
-                    shot_spd_y = spd_y + SHOT_SPEED_D_HI;
                     break;
 
                 case ROT_180:
                     shot_pos_x = 0;
                     shot_pos_y = SHIP_OFF;
-                    shot_spd_x = spd_x;
-                    shot_spd_y = spd_y + SHOT_SPEED;
                     break;
 
                 case ROT_202_5:
                     shot_pos_x = -SHIP_OFF / 2 + 2;
                     shot_pos_y = SHIP_OFF / 2 + 3;
-                    shot_spd_x = spd_x - SHOT_SPEED_D_LO;
-                    shot_spd_y = spd_y + SHOT_SPEED_D_HI;
                     break;
 
                 case ROT_225:
                     shot_pos_x = -SHIP_OFF / 2 - 3;
                     shot_pos_y = SHIP_OFF / 2 + 2;
-                    shot_spd_x = spd_x - SHOT_SPEED_DIAG;
-                    shot_spd_y = spd_y + SHOT_SPEED_DIAG;
                     break;
 
                 case ROT_247_5:
                     shot_pos_x = -SHIP_OFF / 2 - 5;
                     shot_pos_y = SHIP_OFF / 2 - 1;
-                    shot_spd_x = spd_x - SHOT_SPEED_D_HI;
-                    shot_spd_y = spd_y + SHOT_SPEED_D_LO;
                     break;
 
                 case ROT_270:
                     shot_pos_x = -SHIP_OFF;
                     shot_pos_y = 0;
-                    shot_spd_x = spd_x - SHOT_SPEED;
-                    shot_spd_y = spd_y;
                     break;
 
                 case ROT_292_5:
                     shot_pos_x = -SHIP_OFF / 2 - 2;
                     shot_pos_y = -SHIP_OFF / 2 + 2;
-                    shot_spd_x = spd_x - SHOT_SPEED_D_HI;
-                    shot_spd_y = spd_y - SHOT_SPEED_D_LO;
                     break;
 
                 case ROT_315:
                     shot_pos_x = -SHIP_OFF / 2 - 3;
                     shot_pos_y = -SHIP_OFF / 2 - 2;
-                    shot_spd_x = spd_x - SHOT_SPEED_DIAG;
-                    shot_spd_y = spd_y - SHOT_SPEED_DIAG;
                     break;
 
                 case ROT_337_5:
                     shot_pos_x = -SHIP_OFF / 2 + 1;
                     shot_pos_y = -SHIP_OFF / 2 - 4;
-                    shot_spd_x = spd_x - SHOT_SPEED_D_LO;
-                    shot_spd_y = spd_y - SHOT_SPEED_D_HI;
                     break;
             }
 

src/main.c

 #include "window.h"
 #include "gbprinter.h"
 #include "multiplayer.h"
+#include "speed_table.h"
 #include "main.h"
 
 uint8_t debug_menu_index = 0;
     switch (anim_state) {
         case 1:
             if (anim_frame == 0) {
-                obj_add(SPR_SHOT, SHIP_OFF, -42, SHOT_SPEED, 0);
+                START_ROM_BANK(BANK(speed_table)) {
+                    obj_add(SPR_SHOT, SHIP_OFF, -42,
+                            speed_table[(ROT_90 * speed_table_WIDTH) + 0],
+                            -speed_table[(ROT_90 * speed_table_WIDTH) + 1]);
+                } END_ROM_BANK;
                 sample_play(SFX_SHOT);
             }
         case 0:
 
         case 7:
             if (anim_frame == 0) {
-                obj_add(SPR_SHOT, -SHIP_OFF, -42, -SHOT_SPEED, 0);
+                START_ROM_BANK(BANK(speed_table)) {
+                    obj_add(SPR_SHOT, -SHIP_OFF, -42,
+                            speed_table[(ROT_270 * speed_table_WIDTH) + 0],
+                            -speed_table[(ROT_270 * speed_table_WIDTH) + 1]);
+                } END_ROM_BANK;
                 sample_play(SFX_SHOT);
             }
         case 6:

util/gen_angles.py

+#!/usr/bin/env python3
+
+import sys
+import os
+import math
+import argparse
+
+sGBDK = """//AUTOGENERATED FILE FROM {:s}
+#include <stdint.h>
+#include <gbdk/platform.h>
+#include "{:s}.h"
+BANKREF({:s})
+const {:s} {:s}[{:s}_SIZE] = {{
+{:s}}};
+"""
+
+hGBDK = """//AUTOGENERATED FILE FROM {:s}
+#ifndef GEN_CONST_ANGLES_{:s}_H
+#define GEN_CONST_ANGLES_{:s}_H
+#include <stdint.h>
+#include <gbdk/platform.h>
+
+#define {:s}_WIDTH {:d}
+#define {:s}_SIZE {:d}
+extern const {:s} {:s}[{:s}_SIZE];
+
+BANKREF_EXTERN({:s})
+#endif
+"""
+
+def calc(args):
+    s = ""
+
+    for i in range(0, args.steps):
+        angle = 360 / args.steps * i
+        sin_a = math.sin(math.radians(angle)) * args.max
+        cos_a = math.cos(math.radians(angle)) * args.max
+
+        for n in range(0, args.shift):
+            sin_a *= 2
+            cos_a *= 2
+
+        if args.width > 0:
+            s += f"    {round(sin_a)},"
+
+        if args.width > 1:
+            s += f" {round(cos_a)},"
+
+        s += f" // {angle}\n"
+
+    return (s, args.steps * args.width)
+
+def main(args):
+    outheader = os.path.join(args.dir, f"{args.name}.h")
+    outsource = os.path.join(args.dir, f"{args.name}.c")
+
+    data, length = calc(args)
+
+    source = sGBDK.format(sys.argv[0],
+                          args.name, args.name,
+                          args.type,
+                          args.name, args.name,
+                          data)
+
+    if args.verbose:
+        print(f"Source: {outsource}")
+        print(source)
+
+    if not args.dry_run:
+        with open(outsource, "w") as o:
+            o.write(source)
+
+    header = hGBDK.format(sys.argv[0],
+                          args.name, args.name, args.name,
+                          args.width,
+                          args.name,
+                          length, args.type,
+                          args.name, args.name, args.name)
+
+    if args.verbose:
+        print(f"Header: {outheader}")
+        print(header)
+
+    if not args.dry_run:
+        with open(outheader, "w") as o:
+            o.write(header)
+
+if __name__=='__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-d", "--dir", default=os.path.realpath("."))
+    parser.add_argument("-n", "--name", required=True) #default="angles")
+    parser.add_argument("-s", "--steps", default=16, type=int)
+    parser.add_argument("-w", "--width", default=2, type=int)
+    parser.add_argument("-f", "--shift", default=0, type=int)
+    parser.add_argument("-m", "--max", default=42, type=int)
+    parser.add_argument("-t", "--type", default="int8_t")
+    parser.add_argument("-v", "--verbose", action="store_true")
+    parser.add_argument("-y", "--dry-run", action="store_true")
+    args = parser.parse_args()
+    #print(args)
+    main(args)