feat: convert AI rat boss to full screen GB background for Game Over

prepare_bg.py

@@ -0,0 +1,152 @@
+import sys
+from PIL import Image
+import numpy as np
+import collections
+
+# Load image
+img_path = '/home/enne2/.gemini/antigravity/brain/69a2b2a9-088f-47ee-9f3c-9ba7ac332992/rat_king_boss_1781730936484.png'
+try:
+    img = Image.open(img_path).convert('L')
+except Exception as e:
+    print(f"Error opening image: {e}")
+    sys.exit(1)
+
+# Resize to 160x144, focusing on the center
+w, h = img.size
+target_ratio = 160 / 144
+img_ratio = w / h
+if img_ratio > target_ratio:
+    new_w = int(h * target_ratio)
+    left = (w - new_w) // 2
+    img = img.crop((left, 0, left + new_w, h))
+else:
+    new_h = int(w / target_ratio)
+    top = (h - new_h) // 2
+    img = img.crop((0, top, w, top + new_h))
+
+img = img.resize((160, 144), Image.Resampling.LANCZOS)
+
+# Quantize
+np_img = np.array(img)
+palette_img = np.zeros_like(np_img)
+palette_img[np_img < 64] = 3
+palette_img[(np_img >= 64) & (np_img < 128)] = 2
+palette_img[(np_img >= 128) & (np_img < 192)] = 1
+palette_img[np_img >= 192] = 0
+
+# Draw GAME OVER text directly onto the pixel data
+font = {
+    'G': [" ### ", "#   #", "#    ", "# ###", "#   #", "#   #", " ### "],
+    'A': [" ### ", "#   #", "#   #", "#####", "#   #", "#   #", "#   #"],
+    'M': ["#   #", "## ##", "# # #", "#   #", "#   #", "#   #", "#   #"],
+    'E': ["#####", "#    ", "#    ", "#### ", "#    ", "#    ", "#####"],
+    'O': [" ### ", "#   #", "#   #", "#   #", "#   #", "#   #", " ### "],
+    'V': ["#   #", "#   #", "#   #", "#   #", "#   #", " # # ", "  #  "],
+    'R': ["#### ", "#   #", "#   #", "#### ", "# #  ", "#  # ", "#   #"],
+    '!': ["  #  ", "  #  ", "  #  ", "  #  ", "     ", "  #  ", "  #  "],
+    ' ': ["     ", "     ", "     ", "     ", "     ", "     ", "     "]
+}
+
+text_str = "GAME OVER!"
+# Double scale the font for readability
+scale = 2
+char_w = 5 * scale
+char_h = 7 * scale
+spacing = 1 * scale
+start_x = (160 - len(text_str) * (char_w + spacing)) // 2
+start_y = 144 - char_h - 4
+
+# First, draw a black background box for the text to make it readable
+box_pad = 2
+for y in range(start_y - box_pad, start_y + char_h + box_pad):
+    for x in range(start_x - box_pad, start_x + len(text_str) * (char_w + spacing) + box_pad):
+        if 0 <= y < 144 and 0 <= x < 160:
+            palette_img[y, x] = 3 # Black background
+
+# Draw the white text
+for i, char in enumerate(text_str):
+    if char in font:
+        glyph = font[char]
+        for row in range(7):
+            for col in range(5):
+                if glyph[row][col] == '#':
+                    for sy in range(scale):
+                        for sx in range(scale):
+                            py = start_y + row * scale + sy
+                            px = start_x + i * (char_w + spacing) + col * scale + sx
+                            if 0 <= py < 144 and 0 <= px < 160:
+                                palette_img[py, px] = 0 # White text
+
+# Extract tiles
+tiles = []
+for y in range(0, 144, 8):
+    for x in range(0, 160, 8):
+        tile = palette_img[y:y+8, x:x+8]
+        tiles.append(tuple(map(tuple, tile)))
+
+unique_tiles = list(collections.OrderedDict.fromkeys(tiles))
+
+print(f"Total tiles: {len(tiles)}")
+print(f"Unique tiles: {len(unique_tiles)}")
+
+# If we have too many tiles, we need to reduce detail.
+if len(unique_tiles) > 256:
+    print("WARNING: More than 256 unique tiles! Attempting to force tile matching...")
+    reduced_unique = unique_tiles[:256]
+    for i in range(len(tiles)):
+        if tiles[i] not in reduced_unique:
+            t_arr = np.array(tiles[i])
+            best_match = 0
+            best_dist = float('inf')
+            for j, ru in enumerate(reduced_unique):
+                dist = np.sum((t_arr - np.array(ru))**2)
+                if dist < best_dist:
+                    best_dist = dist
+                    best_match = j
+            tiles[i] = reduced_unique[best_match]
+    unique_tiles = reduced_unique
+    print(f"Reduced to {len(unique_tiles)} unique tiles.")
+
+# Create tile map
+tile_map = []
+for t in tiles:
+    tile_map.append(unique_tiles.index(t))
+
+# Convert to C format
+c_tiles = []
+for tile in unique_tiles:
+    tile_data = []
+    for row in tile:
+        low_byte = 0
+        high_byte = 0
+        for x, color in enumerate(row):
+            if color & 1:
+                low_byte |= (1 << (7 - x))
+            if color & 2:
+                high_byte |= (1 << (7 - x))
+        tile_data.append(low_byte)
+        tile_data.append(high_byte)
+    c_tiles.append(tile_data)
+
+# Write C files
+with open('src/rat_bg.h', 'w') as f:
+    f.write("#ifndef RAT_BG_H\n")
+    f.write("#define RAT_BG_H\n\n")
+    f.write("#include <stdint.h>\n\n")
+    f.write(f"extern const uint8_t rat_bg_tiles[{len(c_tiles) * 16}];\n")
+    f.write(f"extern const uint8_t rat_bg_map[{len(tile_map)}];\n\n")
+    f.write("#endif\n")
+
+with open('src/rat_bg.c', 'w') as f:
+    f.write("#include \"rat_bg.h\"\n\n")
+    f.write(f"const uint8_t rat_bg_tiles[{len(c_tiles) * 16}] = {{\n")
+    for tile in c_tiles:
+        f.write("    " + ", ".join([f"0x{b:02X}" for b in tile]) + ",\n")
+    f.write("};\n\n")
+    f.write(f"const uint8_t rat_bg_map[{len(tile_map)}] = {{\n")
+    # Write 20 elements per line
+    for i in range(0, len(tile_map), 20):
+        f.write("    " + ", ".join([f"0x{b:02X}" for b in tile_map[i:i+20]]) + ",\n")
+    f.write("};\n")
+
+print("Generated src/rat_bg.h and src/rat_bg.c")