`Guess', a Mastermind clone from James Harvey. This checkin also

introduces a few new utility functions in misc.c, one of which is
the bitmap obfuscator from Mines (which has therefore been moved out
of mines.c).

[originally from svn r5992]

Recipe

@@ -21,7 +21,7 @@ MINES    = mines tree234
 FLIP     = flip tree234
 
 ALL      = list NET NETSLIDE cube fifteen sixteen rect pattern solo twiddle
-         + MINES samegame FLIP
+         + MINES samegame FLIP guess
 
 net      : [X] gtk COMMON NET
 netslide : [X] gtk COMMON NETSLIDE
@@ -35,6 +35,7 @@ twiddle  : [X] gtk COMMON twiddle
 mines    : [X] gtk COMMON MINES
 samegame : [X] gtk COMMON samegame
 flip     : [X] gtk COMMON FLIP
+guess    : [X] gtk COMMON guess
 
 # The Windows Net shouldn't be called `net.exe' since Windows
 # already has a reasonably important utility program by that name!
@@ -50,6 +51,7 @@ twiddle  : [G] WINDOWS COMMON twiddle
 mines    : [G] WINDOWS COMMON MINES
 samegame : [G] WINDOWS COMMON samegame
 flip     : [G] WINDOWS COMMON FLIP
+guess    : [G] WINDOWS COMMON guess
 
 # Mac OS X unified application containing all the puzzles.
 Puzzles  : [MX] osx osx.icns osx-info.plist COMMON ALL

list.c

@@ -20,6 +20,7 @@ echo -e '};\n\nconst int gamecount = lenof(gamelist);'
 extern const game cube;
 extern const game fifteen;
 extern const game flip;
+extern const game guess;
 extern const game mines;
 extern const game net;
 extern const game netslide;
@@ -34,6 +35,7 @@ const game *gamelist[] = {
     &cube,
     &fifteen,
     &flip,
+    &guess,
     &mines,
     &net,
     &netslide,

mines.c

@@ -1828,112 +1828,6 @@ static char *minegen(int w, int h, int n, int x, int y, int unique,
     return ret;
 }
 
-/*
- * The Mines game descriptions contain the location of every mine,
- * and can therefore be used to cheat.
- * 
- * It would be pointless to attempt to _prevent_ this form of
- * cheating by encrypting the description, since Mines is
- * open-source so anyone can find out the encryption key. However,
- * I think it is worth doing a bit of gentle obfuscation to prevent
- * _accidental_ spoilers: if you happened to note that the game ID
- * starts with an F, for example, you might be unable to put the
- * knowledge of those mines out of your mind while playing. So,
- * just as discussions of film endings are rot13ed to avoid
- * spoiling it for people who don't want to be told, we apply a
- * keyless, reversible, but visually completely obfuscatory masking
- * function to the mine bitmap.
- */
-static void obfuscate_bitmap(unsigned char *bmp, int bits, int decode)
-{
-    int bytes, firsthalf, secondhalf;
-    struct step {
-	unsigned char *seedstart;
-	int seedlen;
-	unsigned char *targetstart;
-	int targetlen;
-    } steps[2];
-    int i, j;
-
-    /*
-     * My obfuscation algorithm is similar in concept to the OAEP
-     * encoding used in some forms of RSA. Here's a specification
-     * of it:
-     * 
-     * 	+ We have a `masking function' which constructs a stream of
-     * 	  pseudorandom bytes from a seed of some number of input
-     * 	  bytes.
-     * 
-     * 	+ We pad out our input bit stream to a whole number of
-     * 	  bytes by adding up to 7 zero bits on the end. (In fact
-     * 	  the bitmap passed as input to this function will already
-     * 	  have had this done in practice.)
-     * 
-     * 	+ We divide the _byte_ stream exactly in half, rounding the
-     * 	  half-way position _down_. So an 81-bit input string, for
-     * 	  example, rounds up to 88 bits or 11 bytes, and then
-     * 	  dividing by two gives 5 bytes in the first half and 6 in
-     * 	  the second half.
-     * 
-     * 	+ We generate a mask from the second half of the bytes, and
-     * 	  XOR it over the first half.
-     * 
-     * 	+ We generate a mask from the (encoded) first half of the
-     * 	  bytes, and XOR it over the second half. Any null bits at
-     * 	  the end which were added as padding are cleared back to
-     * 	  zero even if this operation would have made them nonzero.
-     * 
-     * To de-obfuscate, the steps are precisely the same except
-     * that the final two are reversed.
-     * 
-     * Finally, our masking function. Given an input seed string of
-     * bytes, the output mask consists of concatenating the SHA-1
-     * hashes of the seed string and successive decimal integers,
-     * starting from 0.
-     */
-
-    bytes = (bits + 7) / 8;
-    firsthalf = bytes / 2;
-    secondhalf = bytes - firsthalf;
-
-    steps[decode ? 1 : 0].seedstart = bmp + firsthalf;
-    steps[decode ? 1 : 0].seedlen = secondhalf;
-    steps[decode ? 1 : 0].targetstart = bmp;
-    steps[decode ? 1 : 0].targetlen = firsthalf;
-
-    steps[decode ? 0 : 1].seedstart = bmp;
-    steps[decode ? 0 : 1].seedlen = firsthalf;
-    steps[decode ? 0 : 1].targetstart = bmp + firsthalf;
-    steps[decode ? 0 : 1].targetlen = secondhalf;
-
-    for (i = 0; i < 2; i++) {
-	SHA_State base, final;
-	unsigned char digest[20];
-	char numberbuf[80];
-	int digestpos = 20, counter = 0;
-
-	SHA_Init(&base);
-	SHA_Bytes(&base, steps[i].seedstart, steps[i].seedlen);
-
-	for (j = 0; j < steps[i].targetlen; j++) {
-	    if (digestpos >= 20) {
-		sprintf(numberbuf, "%d", counter++);
-		final = base;
-		SHA_Bytes(&final, numberbuf, strlen(numberbuf));
-		SHA_Final(&final, digest);
-		digestpos = 0;
-	    }
-	    steps[i].targetstart[j] ^= digest[digestpos++];
-	}
-
-	/*
-	 * Mask off the pad bits in the final byte after both steps.
-	 */
-	if (bits % 8)
-	    bmp[bits / 8] &= 0xFF & (0xFF00 >> (bits % 8));
-    }
-}
-
 static char *describe_layout(char *grid, int area, int x, int y,
                              int obfuscate)
 {

misc.c

@@ -4,6 +4,8 @@
 
 #include <assert.h>
 #include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
 
 #include "puzzles.h"
 
@@ -16,3 +18,155 @@ void free_cfg(config_item *cfg)
 	    sfree(i->sval);
     sfree(cfg);
 }
+
+/*
+ * The Mines (among others) game descriptions contain the location of every
+ * mine, and can therefore be used to cheat.
+ *
+ * It would be pointless to attempt to _prevent_ this form of
+ * cheating by encrypting the description, since Mines is
+ * open-source so anyone can find out the encryption key. However,
+ * I think it is worth doing a bit of gentle obfuscation to prevent
+ * _accidental_ spoilers: if you happened to note that the game ID
+ * starts with an F, for example, you might be unable to put the
+ * knowledge of those mines out of your mind while playing. So,
+ * just as discussions of film endings are rot13ed to avoid
+ * spoiling it for people who don't want to be told, we apply a
+ * keyless, reversible, but visually completely obfuscatory masking
+ * function to the mine bitmap.
+ */
+void obfuscate_bitmap(unsigned char *bmp, int bits, int decode)
+{
+    int bytes, firsthalf, secondhalf;
+    struct step {
+	unsigned char *seedstart;
+	int seedlen;
+	unsigned char *targetstart;
+	int targetlen;
+    } steps[2];
+    int i, j;
+
+    /*
+     * My obfuscation algorithm is similar in concept to the OAEP
+     * encoding used in some forms of RSA. Here's a specification
+     * of it:
+     * 
+     * 	+ We have a `masking function' which constructs a stream of
+     * 	  pseudorandom bytes from a seed of some number of input
+     * 	  bytes.
+     * 
+     * 	+ We pad out our input bit stream to a whole number of
+     * 	  bytes by adding up to 7 zero bits on the end. (In fact
+     * 	  the bitmap passed as input to this function will already
+     * 	  have had this done in practice.)
+     * 
+     * 	+ We divide the _byte_ stream exactly in half, rounding the
+     * 	  half-way position _down_. So an 81-bit input string, for
+     * 	  example, rounds up to 88 bits or 11 bytes, and then
+     * 	  dividing by two gives 5 bytes in the first half and 6 in
+     * 	  the second half.
+     * 
+     * 	+ We generate a mask from the second half of the bytes, and
+     * 	  XOR it over the first half.
+     * 
+     * 	+ We generate a mask from the (encoded) first half of the
+     * 	  bytes, and XOR it over the second half. Any null bits at
+     * 	  the end which were added as padding are cleared back to
+     * 	  zero even if this operation would have made them nonzero.
+     * 
+     * To de-obfuscate, the steps are precisely the same except
+     * that the final two are reversed.
+     * 
+     * Finally, our masking function. Given an input seed string of
+     * bytes, the output mask consists of concatenating the SHA-1
+     * hashes of the seed string and successive decimal integers,
+     * starting from 0.
+     */
+
+    bytes = (bits + 7) / 8;
+    firsthalf = bytes / 2;
+    secondhalf = bytes - firsthalf;
+
+    steps[decode ? 1 : 0].seedstart = bmp + firsthalf;
+    steps[decode ? 1 : 0].seedlen = secondhalf;
+    steps[decode ? 1 : 0].targetstart = bmp;
+    steps[decode ? 1 : 0].targetlen = firsthalf;
+
+    steps[decode ? 0 : 1].seedstart = bmp;
+    steps[decode ? 0 : 1].seedlen = firsthalf;
+    steps[decode ? 0 : 1].targetstart = bmp + firsthalf;
+    steps[decode ? 0 : 1].targetlen = secondhalf;
+
+    for (i = 0; i < 2; i++) {
+	SHA_State base, final;
+	unsigned char digest[20];
+	char numberbuf[80];
+	int digestpos = 20, counter = 0;
+
+	SHA_Init(&base);
+	SHA_Bytes(&base, steps[i].seedstart, steps[i].seedlen);
+
+	for (j = 0; j < steps[i].targetlen; j++) {
+	    if (digestpos >= 20) {
+		sprintf(numberbuf, "%d", counter++);
+		final = base;
+		SHA_Bytes(&final, numberbuf, strlen(numberbuf));
+		SHA_Final(&final, digest);
+		digestpos = 0;
+	    }
+	    steps[i].targetstart[j] ^= digest[digestpos++];
+	}
+
+	/*
+	 * Mask off the pad bits in the final byte after both steps.
+	 */
+	if (bits % 8)
+	    bmp[bits / 8] &= 0xFF & (0xFF00 >> (bits % 8));
+    }
+}
+
+/* err, yeah, these two pretty much rely on unsigned char being 8 bits.
+ * Platforms where this is not the case probably have bigger problems
+ * than just making these two work, though... */
+char *bin2hex(const unsigned char *in, int inlen)
+{
+    char *ret = snewn(inlen*2 + 1, char), *p = ret;
+    int i;
+
+    for (i = 0; i < inlen*2; i++) {
+        int v = in[i/2];
+        if (i % 2 == 0) v >>= 4;
+        *p++ = "0123456789abcdef"[v & 0xF];
+    }
+    *p = '\0';
+    return ret;
+}
+
+unsigned char *hex2bin(const char *in, int outlen)
+{
+    unsigned char *ret = snewn(outlen, unsigned char);
+    int i;
+
+    debug(("hex2bin: in '%s'", in));
+
+    memset(ret, 0, outlen*sizeof(unsigned char));
+    for (i = 0; i < outlen*2; i++) {
+        int c = in[i];
+        int v;
+
+        assert(c != 0);
+        if (c >= '0' && c <= '9')
+            v = c - '0';
+        else if (c >= 'a' && c <= 'f')
+            v = c - 'a' + 10;
+        else if (c >= 'A' && c <= 'F')
+            v = c - 'A' + 10;
+        else
+            v = 0;
+
+        ret[i / 2] |= v << (4 * (1 - (i % 2)));
+    }
+    return ret;
+}
+
+/* vim: set shiftwidth=4 tabstop=8: */

puzzles.h

@@ -205,6 +205,13 @@ char *dupstr(const char *s);
  * misc.c
  */
 void free_cfg(config_item *cfg);
+void obfuscate_bitmap(unsigned char *bmp, int bits, int decode);
+
+/* allocates output each time. len is always in bytes of binary data.
+ * May assert (or just go wrong) if lengths are unchecked. */
+char *bin2hex(const unsigned char *in, int inlen);
+unsigned char *hex2bin(const char *in, int outlen);
+
 
 /*
  * version.c