Sort Pokemon and trainer sprite palettes, with Makefile-specified exceptions (#1137)

This avoids the need to define their order via indexed PNG palettes

It also avoids the need to use gb-asm-tools' palfix.py on custom sprites

Fixes #1136

tools/.gitignore

@@ -1,3 +1,4 @@
+gbcpal
 gfx
 lzcomp
 make_patch

tools/Makefile

@@ -4,6 +4,7 @@ CC := gcc
 CFLAGS := -O3 -flto -std=c11 -Wall -Wextra -pedantic
 
 tools := \
+	gbcpal \
 	gfx \
 	lzcomp \
 	make_patch \

tools/gbcpal.c

@@ -0,0 +1,141 @@
+#define PROGRAM_NAME "gbcpal"
+#define USAGE_OPTS "[-h|--help] [-r|--reverse] out.gbcpal in.gbcpal..."
+
+#include "common.h"
+
+bool reverse;
+
+void parse_args(int argc, char *argv[]) {
+	struct option long_options[] = {
+		{"reverse", no_argument, 0, 'r'},
+		{"help", no_argument, 0, 'h'},
+		{0}
+	};
+	for (int opt; (opt = getopt_long(argc, argv, "rh", long_options)) != -1;) {
+		switch (opt) {
+		case 'r':
+			reverse = true;
+			break;
+		case 'h':
+			usage_exit(0);
+			break;
+		default:
+			usage_exit(1);
+		}
+	}
+}
+
+struct Color {
+	uint8_t r, g, b;
+};
+
+const struct Color BLACK = {0, 0, 0};
+const struct Color WHITE = {31, 31, 31};
+
+uint16_t pack_color(struct Color color) {
+	return (color.b << 10) | (color.g << 5) | color.r;
+}
+
+struct Color unpack_color(uint16_t gbc_color) {
+	return (struct Color){
+		.r = gbc_color & 0x1f,
+		.g = (gbc_color >> 5) & 0x1f,
+		.b = (gbc_color >> 10) & 0x1f,
+	};
+}
+
+double luminance(struct Color color) {
+	return 0.299 * color.r + 0.587 * color.g + 0.114 * color.b;
+}
+
+int compare_colors(const void *color1, const void *color2) {
+	double lum1 = luminance(*(const struct Color *)color1);
+	double lum2 = luminance(*(const struct Color *)color2);
+	// sort lightest to darkest, or darkest to lightest if reversed
+	return reverse ? (lum1 > lum2) - (lum1 < lum2) : (lum1 < lum2) - (lum1 > lum2);
+}
+
+void read_gbcpal(const char *filename, struct Color **colors, size_t *num_colors) {
+	long filesize;
+	uint8_t *bytes = read_u8(filename, &filesize);
+	if (filesize == 0) {
+		error_exit("%s: empty gbcpal file\n", filename);
+	}
+	if (filesize % 2) {
+		error_exit("%s: invalid gbcpal file\n", filename);
+	}
+
+	size_t new_colors = filesize / 2;
+	*colors = xrealloc(*colors, (sizeof **colors) * (*num_colors + new_colors));
+	for (size_t i = 0; i < new_colors; i++) {
+		uint16_t gbc_color = (bytes[i * 2 + 1] << 8) | bytes[i * 2];
+		(*colors)[*num_colors + i] = unpack_color(gbc_color);
+	}
+	*num_colors += new_colors;
+
+	free(bytes);
+}
+
+void filter_colors(struct Color *colors, size_t *num_colors) {
+	size_t num_filtered = 0;
+	// filter out black, white, and duplicate colors
+	for (size_t i = 0; i < *num_colors; i++) {
+		struct Color color = colors[i];
+		if (color.r == BLACK.r && color.g == BLACK.g && color.b == BLACK.b) {
+			continue;
+		}
+		if (color.r == WHITE.r && color.g == WHITE.g && color.b == WHITE.b) {
+			continue;
+		}
+		if (num_filtered > 0) {
+			struct Color last = colors[num_filtered - 1];
+			if (color.r == last.r && color.g == last.g && color.b == last.b) {
+				continue;
+			}
+		}
+		colors[num_filtered++] = color;
+	}
+	*num_colors = num_filtered;
+}
+
+int main(int argc, char *argv[]) {
+	parse_args(argc, argv);
+
+	argc -= optind;
+	argv += optind;
+	if (argc < 2) {
+		usage_exit(1);
+	}
+
+	const char *out_filename = argv[0];
+
+	struct Color *colors = NULL;
+	size_t num_colors = 0;
+	for (int i = 1; i < argc; i++) {
+		read_gbcpal(argv[i], &colors, &num_colors);
+	}
+
+	qsort(colors, num_colors, sizeof(*colors), compare_colors);
+	filter_colors(colors, &num_colors);
+
+	struct Color pal_colors[4] = {
+		WHITE,
+		num_colors > 0 ? colors[0] : WHITE,
+		num_colors > 1 ? colors[1] : num_colors > 0 ? colors[0] : BLACK,
+		BLACK,
+	};
+	if (num_colors > 2) {
+		error_exit("%s: more than 2 colors besides black and white (%zu)\n", out_filename, num_colors);
+	}
+
+	uint8_t bytes[COUNTOF(pal_colors) * 2] = {0};
+	for (size_t i = 0; i < COUNTOF(pal_colors); i++) {
+		uint16_t packed_color = pack_color(pal_colors[i]);
+		bytes[2 * i] = packed_color & 0xff;
+		bytes[2 * i + 1] = packed_color >> 8;
+	}
+	write_u8(out_filename, bytes, COUNTOF(bytes));
+
+	free(colors);
+	return 0;
+}

tools/make_patch.c

@@ -417,7 +417,7 @@ struct Buffer *process_template(const char *template_filename, const char *patch
 int compare_patch(const void *patch1, const void *patch2) {
 	unsigned int offset1 = ((const struct Patch *)patch1)->offset;
 	unsigned int offset2 = ((const struct Patch *)patch2)->offset;
-	return offset1 > offset2 ? 1 : offset1 < offset2 ? -1 : 0;
+	return (offset1 > offset2) - (offset1 < offset2);
 }
 
 bool verify_completeness(FILE *restrict orig_rom, FILE *restrict new_rom, struct Buffer *patches) {

tools/palfix.py

@@ -1,76 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Usage: python palfix.py image.png
-
-Fix the palette format of the input image. Colored images (Pokémon or trainer
-sprites) will become indexed, with a palette sorted {white, light color, dark
-color, black}. Grayscale images will become two-bit grayscale.
-"""
-
-import sys
-
-import png
-
-def rgb8_to_rgb5(c):
-	r, g, b = c
-	return (r // 8, g // 8, b // 8)
-
-def rgb5_to_rgb8(c):
-	r, g, b = c
-	return (r * 8 + r // 4, g * 8 + g // 4, b * 8 + b // 4)
-
-def invert(c):
-	r, g, b = c
-	return (31 - r, 31 - g, 31 - b)
-
-def luminance(c):
-	r, g, b = c
-	return 0.299 * r**2 + 0.587 * g**2 + 0.114 * b**2
-
-def rgb5_pixels(row):
-	yield from (rgb8_to_rgb5(row[x:x+3]) for x in range(0, len(row), 4))
-
-def is_grayscale(palette):
-	return (palette == ((31, 31, 31), (21, 21, 21), (10, 10, 10), (0, 0, 0)) or
-		palette == ((31, 31, 31), (20, 20, 20), (10, 10, 10), (0, 0, 0)))
-
-def fix_pal(filename):
-	with open(filename, 'rb') as file:
-		width, height, rows = png.Reader(file).asRGBA8()[:3]
-		rows = list(rows)
-	b_and_w = {(0, 0, 0), (31, 31, 31)}
-	colors = {c for row in rows for c in rgb5_pixels(row)} - b_and_w
-	if not colors:
-		colors = {(21, 21, 21), (10, 10, 10)}
-	elif len(colors) == 1:
-		c = colors.pop()
-		colors = {c, invert(c)}
-	elif len(colors) != 2:
-		return False
-	palette = tuple(sorted(colors | b_and_w, key=luminance, reverse=True))
-	assert len(palette) == 4
-	rows = [list(map(palette.index, rgb5_pixels(row))) for row in rows]
-	if is_grayscale(palette):
-		rows = [[3 - c for c in row] for row in rows]
-		writer = png.Writer(width, height, greyscale=True, bitdepth=2, compression=9)
-	else:
-		palette = tuple(map(rgb5_to_rgb8, palette))
-		writer = png.Writer(width, height, palette=palette, bitdepth=8, compression=9)
-	with open(filename, 'wb') as file:
-		writer.write(file, rows)
-	return True
-
-def main():
-	if len(sys.argv) < 2:
-		print(f'Usage: {sys.argv[0]} pic.png', file=sys.stderr)
-		sys.exit(1)
-	for filename in sys.argv[1:]:
-		if not filename.lower().endswith('.png'):
-			print(f'{filename} is not a .png file!', file=sys.stderr)
-		elif not fix_pal(filename):
-			print(f'{filename} has too many colors!', file=sys.stderr)
-
-if __name__ == '__main__':
-	main()