pietp

pietp.c (4469B)

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <err.h>

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"

#define ARRLEN(x) (sizeof(x)/sizeof((x)[0]))

enum {
	PUSH,
	POP,
	ADD,
	SUB,
	MUL,
	DIV,
	MOD,
	NOT,
	GTR,
	DPI,
	CCI,
	DUP,
	ROLL,
	INN,
	INC,
	OUTN,
	OUTC,
	NONE
};

static const char *inst_names[] = {
	"PUSH",
	"POP",
	"ADD",
	"SUB",
	"MUL",
	"DIV",
	"MOD",
	"NOT",
	"GTR",
	"DPI",
	"CCI",
	"DUP",
	"ROLL",
	"INN",
	"INC",
	"OUTN",
	"OUTC",
	""
};

static const uint32_t colors[] = {
	0xffc0c0, 0xffffc0, 0xc0ffc0, 0xc0ffff, 0xc0c0ff, 0xffc0ff,
	0xff0000, 0xffff00, 0x00ff00, 0x00ffff, 0x0000ff, 0xff00ff,
	0xc00000, 0xc0c000, 0x00c000, 0x00c0c0, 0x0000c0, 0xc000c0,
	0x000000, 0xffffff
};

static const int instructions[][2] = {
	[PUSH] = { 0, 1 },
	[POP]  = { 0, 2 },
	[ADD]  = { 1, 0 },
	[SUB]  = { 1, 1 },
	[MUL]  = { 1, 2 },
	[DIV]  = { 2, 0 },
	[MOD]  = { 2, 1 },
	[NOT]  = { 2, 2 },
	[GTR]  = { 3, 0 },
	[DPI]  = { 3, 1 },
	[CCI]  = { 3, 2 },
	[DUP]  = { 4, 0 },
	[ROLL] = { 4, 1 },
	[INN]  = { 4, 2 },
	[INC]  = { 5, 0 },
	[OUTN] = { 5, 1 },
	[OUTC] = { 5, 2 },
};

static const int piet_code[] = {
	PUSH, PUSH, ADD, DUP, MUL, DUP, DUP, DUP, MUL, // 4 4 16
	DUP, DUP, ADD, DUP, DUP, ADD, ADD, ADD, // 4 4 112
	DUP, DUP, PUSH, PUSH, ADD, PUSH, ADD, ADD, // 4 4 112 112 115
	OUTC,
	PUSH, PUSH, ADD, SUB, // 4 4 112 110
	OUTC,
	ADD, ADD, // 120
	OUTC
};

static int debug = 0;

const char *
dirstr(int dx, int dy)
{
	if (dx > 0)
		return "+X";
	else if (dx < 0)
		return "-X";
	else if (dy > 0)
		return "+Y";
	else if (dy < 0)
		return "-Y";
	else
		return "O";
}

int
nextcolor(int prev, int insti)
{
	int x, y;

	x = ((prev % 6) + 6 + instructions[insti][0]) % 6;
	y = ((prev / 6) + 3 + instructions[insti][1]) % 3;
	return y * 6 + x;
}

void
setrgb(uint8_t *pix, int stride, int x, int y, int color)
{
	pix[y * stride + x * 3 + 0] = (colors[color] & 0xff0000) >> 16;
	pix[y * stride + x * 3 + 1] = (colors[color] & 0x00ff00) >> 8;
	pix[y * stride + x * 3 + 2] = (colors[color] & 0x0000ff) >> 0;
}

int
main(int argc, const char **argv)
{
	uint8_t *map, *vis;
	uint8_t *pix;
	const char *mappath;
	int width, height;
	int insti, nexti;
	int x, y, dx, dy;
	int color, nextc;
	int rotonce;
	int i;

	color = 0;
	mappath = NULL;
	for (i = 1; i < argc; i++) {
		if (!strcmp(argv[i], "-d"))
			debug = 1;
		else if (!strcmp(argv[i], "-s") && i + 1 < argc)
			color = atoi(argv[++i]);
		else if (!strcmp(argv[i], "-h"))
			errx(0, "pietp [-h] [-d] [-s COLOR] [MAP-IMAGE]");
		else if (mappath)
			errx(1, "More than one map specified\n");
		else
			mappath = argv[i];
	}

	if (mappath) {
		map = stbi_load(mappath, &width, &height, NULL, STBI_grey);
		if (!map) errx(1, "Failed to read image");
	} else {
		map = calloc(width * height, 1);
		if (!map) err(1, "calloc");
	}

	vis = calloc(width * height, 1);
	pix = calloc(width * height, 3);
	if (!pix || !vis) err(1, "malloc");

	dx = 1;
	dy = 0;

	x = y = 0;
	setrgb(pix, width * 3, x++, y, color);

	insti = 0;
	while (1) {
		if (vis[y * width + x]) {
			if (insti >= ARRLEN(piet_code))
				break;
			fprintf(stderr, "Overlap! Code remaining: %i/%li\n",
				insti, ARRLEN(piet_code));
			exit(1);
		}

		/* write color to image */
		if (map[y * width + x] == 0xC0) {
			nexti = PUSH;
			nextc = nextcolor(color, nexti);
		} else if (map[y * width + x] == 0x80) {
			nexti = DPI;
			nextc = nextcolor(color, nexti);
		} else if (map[y * width + x] == 0x40) {
			nexti = NONE;
			nextc = color;
		} else if (insti < ARRLEN(piet_code)) {
			nexti = piet_code[insti++];
			nextc = nextcolor(color, nexti);
		} else {
			nexti = NONE;
			nextc = color;
		}
		setrgb(pix, width * 3, x, y, nextc);
		vis[y * width + x] = 1;
		if (debug) printf("[%3i,%3i]: %06X -> %06X  | %4s\n", x, y,
			colors[color], colors[nextc], inst_names[nexti]);
		color = nextc;

		/* rotate until free */
		rotonce = 0;
		while (x + dx < 0 || x + dx >= width
			|| y + dy < 0 || y + dy >= height
			|| map[y * width + x] == 0x80 && !rotonce
			|| map[(y + dy) * width + x + dx] == 0)
		{
			if (debug) printf("ROTATE %s ->", dirstr(dx, dy));
			if (dx != 0) {
				dy = dx;
				dx = 0;
			} else {
				dx = -dy;
				dy = 0;
			}
			if (debug) printf(" %s\n", dirstr(dx, dy));
			rotonce = 1;
		}

		x += dx;
		y += dy;
	}

	stbi_write_png("piet.png", width, height, STBI_rgb, pix, 3 * width);

	free(pix);
	free(vis);
	STBI_FREE(map);
}