Port of Simon Tatham's Puzzle Collection

Original revision: 5123b1bf68777ffa86e651f178046b26a87cf2d9

MIT Licensed. Some games still crash and others are unplayable due to
issues with controls. Still need a "real" polygon filling algorithm.

Currently builds one plugin per puzzle (about 40 in total, around 100K
each on ARM), but can easily be made to build a single monolithic
overlay (800K or so on ARM).

The following games are at least partially broken for various reasons,
and have been disabled on this commit:

Cube:     failed assertion with "Icosahedron" setting
Keen:     input issues
Mines:    weird stuff happens on target
Palisade: input issues
Solo:     input issues, occasional crash on target
Towers:   input issues
Undead:   input issues
Unequal:  input and drawing issues (concave polys)
Untangle: input issues

Features left to do:
 - In-game help system
 - Figure out the weird bugs

Change-Id: I7c69b6860ab115f973c8d76799502e9bb3d52368

apps/plugins/puzzles/obfusc.c

@@ -0,0 +1,126 @@
+/*
+ * Stand-alone tool to access the Puzzles obfuscation algorithm.
+ * 
+ * To deobfuscate, use "obfusc -d":
+ * 
+ *   obfusc -d                 reads binary data from stdin, writes to stdout
+ *   obfusc -d <hex string>    works on the given hex string instead of stdin
+ *   obfusc -d -h              writes a hex string instead of binary to stdout
+ *
+ * To obfuscate, "obfusc -e":
+ * 
+ *   obfusc -e                 reads binary from stdin, writes hex to stdout
+ *   obfusc -e <hex string>    works on the given hex string instead of stdin
+ *   obfusc -e -b              writes binary instead of text to stdout
+ *
+ * The default output format is hex for -e and binary for -d
+ * because that's the way obfuscation is generally used in
+ * Puzzles. Either of -b and -h can always be specified to set it
+ * explicitly.
+ *
+ * Data read from standard input is assumed always to be binary;
+ * data provided on the command line is taken to be hex.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+
+#include "puzzles.h"
+
+int main(int argc, char **argv)
+{
+    enum { BINARY, DEFAULT, HEX } outputmode = DEFAULT;
+    char *inhex = NULL;
+    unsigned char *data;
+    int datalen;
+    int decode = -1;
+    int doing_opts = TRUE;
+
+    while (--argc > 0) {
+	char *p = *++argv;
+
+	if (doing_opts && *p == '-') {
+	    if (!strcmp(p, "--")) {
+		doing_opts = 0;
+		continue;
+	    }
+	    p++;
+	    while (*p) {
+		switch (*p) {
+		  case 'e':
+		    decode = 0;
+		    break;
+		  case 'd':
+		    decode = 1;
+		    break;
+		  case 'b':
+		    outputmode = BINARY;
+		    break;
+		  case 'h':
+		    outputmode = HEX;
+		    break;
+		  default:
+		    return 1;
+		}
+		p++;
+	    }
+	} else {
+	    if (!inhex) {
+		inhex = p;
+	    } else {
+		return 1;
+	    }
+	}
+    }
+
+    if (decode < 0) {
+	return 0;
+    }
+
+    if (outputmode == DEFAULT)
+	outputmode = (decode ? BINARY : HEX);
+
+    if (inhex) {
+	datalen = strlen(inhex) / 2;
+	data = hex2bin(inhex, datalen);
+    } else {
+	int datasize = 4096;
+	datalen = 0;
+	data = snewn(datasize, unsigned char);
+	while (1) {
+	    int ret = fread(data + datalen, 1, datasize - datalen, stdin);
+	    if (ret < 0) {
+		fprintf(stderr, "obfusc: read: %s\n", strerror(errno));
+		return 1;
+	    } else if (ret == 0) {
+		break;
+	    } else {
+		datalen += ret;
+		if (datasize - datalen < 4096) {
+		    datasize = datalen * 5 / 4 + 4096;
+		    data = sresize(data, datasize, unsigned char);
+		}
+	    }
+	}
+    }
+
+    obfuscate_bitmap(data, datalen * 8, decode);
+
+    if (outputmode == BINARY) {
+	int ret = fwrite(data, 1, datalen, stdout);
+        if (ret < 0) {
+            fprintf(stderr, "obfusc: write: %s\n", strerror(errno));
+            return 1;
+        }
+    } else {
+	int i;
+	for (i = 0; i < datalen; i++)
+	    printf("%02x", data[i]);
+	printf("\n");
+    }
+
+    return 0;
+}