Alter the `Octagon' board preset so that instead of presenting you
[sgt/puzzles] / mines.c
diff --git a/mines.c b/mines.c
index 286f76d..f3e216c 100644 (file)
--- a/mines.c
+++ b/mines.c
@@ -25,10 +25,11 @@ enum {
     NCOLOURS
 };
 
-#define TILE_SIZE 20
+#define PREFERRED_TILE_SIZE 20
+#define TILE_SIZE (ds->tilesize)
 #define BORDER (TILE_SIZE * 3 / 2)
-#define HIGHLIGHT_WIDTH 2
-#define OUTER_HIGHLIGHT_WIDTH 3
+#define HIGHLIGHT_WIDTH (TILE_SIZE / 10)
+#define OUTER_HIGHLIGHT_WIDTH (BORDER / 10)
 #define COORD(x)  ( (x) * TILE_SIZE + BORDER )
 #define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
 
@@ -236,7 +237,7 @@ static game_params *custom_params(config_item *cfg)
     return ret;
 }
 
-static char *validate_params(game_params *params)
+static char *validate_params(game_params *params, int full)
 {
     /*
      * Lower limit on grid size: each dimension must be at least 3.
@@ -252,7 +253,7 @@ static char *validate_params(game_params *params)
      * _have_ to have a gap somewhere which you can't determine the
      * position of.
      */
-    if (params->w <= 2 || params->h <= 2)
+    if (full && params->unique && (params->w <= 2 || params->h <= 2))
        return "Width and height must both be greater than two";
     if (params->n > params->w * params->h - 9)
        return "Too many mines for grid size";
@@ -1827,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)
 {
@@ -1960,7 +1855,7 @@ static char *describe_layout(char *grid, int area, int x, int y,
      */
     ret = snewn((area+3)/4 + 100, char);
     p = ret + sprintf(ret, "%d,%d,%s", x, y,
-                      obfuscate ? "m" : "");   /* 'm' == masked */
+                      obfuscate ? "m" : "u");   /* 'm' == masked */
     for (i = 0; i < (area+3)/4; i++) {
         int v = bmp[i/2];
         if (i % 2 == 0)
@@ -2051,7 +1946,7 @@ static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
 }
 
 static char *new_game_desc(game_params *params, random_state *rs,
-                          game_aux_info **aux, int interactive)
+                          char **aux, int interactive)
 {
     /*
      * We generate the coordinates of an initial click even if they
@@ -2089,17 +1984,13 @@ static char *new_game_desc(game_params *params, random_state *rs,
     }
 }
 
-static void game_free_aux_info(game_aux_info *aux)
-{
-    assert(!"Shouldn't happen");
-}
-
 static char *validate_desc(game_params *params, char *desc)
 {
     int wh = params->w * params->h;
     int x, y;
 
     if (*desc == 'r') {
+        desc++;
        if (!*desc || !isdigit((unsigned char)*desc))
            return "No initial mine count in game description";
        while (*desc && isdigit((unsigned char)*desc))
@@ -2114,28 +2005,28 @@ static char *validate_desc(game_params *params, char *desc)
            return "No ',' after uniqueness specifier in game description";
        /* now ignore the rest */
     } else {
-       if (!*desc || !isdigit((unsigned char)*desc))
-           return "No initial x-coordinate in game description";
-       x = atoi(desc);
-       if (x < 0 || x >= params->w)
-           return "Initial x-coordinate was out of range";
-       while (*desc && isdigit((unsigned char)*desc))
-           desc++;                    /* skip over x coordinate */
-       if (*desc != ',')
-           return "No ',' after initial x-coordinate in game description";
-       desc++;                        /* eat comma */
-       if (!*desc || !isdigit((unsigned char)*desc))
-           return "No initial y-coordinate in game description";
-       y = atoi(desc);
-       if (y < 0 || y >= params->h)
-           return "Initial y-coordinate was out of range";
-       while (*desc && isdigit((unsigned char)*desc))
-           desc++;                    /* skip over y coordinate */
-       if (*desc != ',')
-           return "No ',' after initial y-coordinate in game description";
-       desc++;                        /* eat comma */
-       /* eat `m', meaning `masked', if present */
-       if (*desc == 'm')
+       if (*desc && isdigit((unsigned char)*desc)) {
+           x = atoi(desc);
+           if (x < 0 || x >= params->w)
+               return "Initial x-coordinate was out of range";
+           while (*desc && isdigit((unsigned char)*desc))
+               desc++;                /* skip over x coordinate */
+           if (*desc != ',')
+               return "No ',' after initial x-coordinate in game description";
+           desc++;                    /* eat comma */
+           if (!*desc || !isdigit((unsigned char)*desc))
+               return "No initial y-coordinate in game description";
+           y = atoi(desc);
+           if (y < 0 || y >= params->h)
+               return "Initial y-coordinate was out of range";
+           while (*desc && isdigit((unsigned char)*desc))
+               desc++;                /* skip over y coordinate */
+           if (*desc != ',')
+               return "No ',' after initial y-coordinate in game description";
+           desc++;                    /* eat comma */
+       }
+       /* eat `m' for `masked' or `u' for `unmasked', if present */
+       if (*desc == 'm' || *desc == 'u')
            desc++;
        /* now just check length of remainder */
        if (strlen(desc) != (wh+3)/4)
@@ -2156,12 +2047,23 @@ static int open_square(game_state *state, int x, int y)
         * hasn't been generated yet. Generate it based on the
         * initial click location.
         */
-       char *desc;
+       char *desc, *privdesc;
        state->layout->mines = new_mine_layout(w, h, state->layout->n,
                                               x, y, state->layout->unique,
                                               state->layout->rs,
                                               &desc);
-       midend_supersede_game_desc(state->layout->me, desc);
+       /*
+        * Find the trailing substring of the game description
+        * corresponding to just the mine layout; we will use this
+        * as our second `private' game ID for serialisation.
+        */
+       privdesc = desc;
+       while (*privdesc && isdigit((unsigned char)*privdesc)) privdesc++;
+       if (*privdesc == ',') privdesc++;
+       while (*privdesc && isdigit((unsigned char)*privdesc)) privdesc++;
+       if (*privdesc == ',') privdesc++;
+       assert(*privdesc == 'm');
+       midend_supersede_game_desc(state->layout->me, desc, privdesc);
        sfree(desc);
        random_free(state->layout->rs);
        state->layout->rs = NULL;
@@ -2296,21 +2198,27 @@ static game_state *new_game(midend_data *me, game_params *params, char *desc)
     } else {
        state->layout->rs = NULL;
        state->layout->me = NULL;
-
        state->layout->mines = snewn(wh, char);
-       x = atoi(desc);
-       while (*desc && isdigit((unsigned char)*desc))
-           desc++;                    /* skip over x coordinate */
-       if (*desc) desc++;             /* eat comma */
-       y = atoi(desc);
-       while (*desc && isdigit((unsigned char)*desc))
-           desc++;                    /* skip over y coordinate */
-       if (*desc) desc++;             /* eat comma */
+
+       if (*desc && isdigit((unsigned char)*desc)) {
+           x = atoi(desc);
+           while (*desc && isdigit((unsigned char)*desc))
+               desc++;                /* skip over x coordinate */
+           if (*desc) desc++;         /* eat comma */
+           y = atoi(desc);
+           while (*desc && isdigit((unsigned char)*desc))
+               desc++;                /* skip over y coordinate */
+           if (*desc) desc++;         /* eat comma */
+       } else {
+           x = y = -1;
+       }
 
        if (*desc == 'm') {
            masked = TRUE;
            desc++;
        } else {
+           if (*desc == 'u')
+               desc++;
            /*
             * We permit game IDs to be entered by hand without the
             * masking transformation.
@@ -2346,7 +2254,8 @@ static game_state *new_game(midend_data *me, game_params *params, char *desc)
                state->layout->mines[i] = 1;
        }
 
-       ret = open_square(state, x, y);
+       if (x >= 0 && y >= 0)
+           ret = open_square(state, x, y);
         sfree(bmp);
     }
 
@@ -2384,46 +2293,15 @@ static void free_game(game_state *state)
     sfree(state);
 }
 
-static game_state *solve_game(game_state *state, game_aux_info *aux,
-                             char **error)
+static char *solve_game(game_state *state, game_state *currstate,
+                       char *aux, char **error)
 {
-    /*
-     * Simply expose the entire grid as if it were a completed
-     * solution.
-     */
-    game_state *ret;
-    int yy, xx;
-
     if (!state->layout->mines) {
-        *error = "Game has not been started yet";
-        return NULL;
+       *error = "Game has not been started yet";
+       return NULL;
     }
 
-    ret = dup_game(state);
-    for (yy = 0; yy < ret->h; yy++)
-        for (xx = 0; xx < ret->w; xx++) {
-
-            if (ret->layout->mines[yy*ret->w+xx]) {
-                ret->grid[yy*ret->w+xx] = -1;
-            } else {
-                int dx, dy, v;
-
-                v = 0;
-
-                for (dx = -1; dx <= +1; dx++)
-                    for (dy = -1; dy <= +1; dy++)
-                        if (xx+dx >= 0 && xx+dx < ret->w &&
-                            yy+dy >= 0 && yy+dy < ret->h &&
-                            ret->layout->mines[(yy+dy)*ret->w+(xx+dx)])
-                            v++;
-
-                ret->grid[yy*ret->w+xx] = v;
-            }
-        }
-    ret->used_solve = ret->just_used_solve = TRUE;
-    ret->won = TRUE;
-
-    return ret;
+    return dupstr("S");
 }
 
 static char *game_text_format(game_state *state)
@@ -2475,16 +2353,46 @@ static void free_ui(game_ui *ui)
     sfree(ui);
 }
 
+static char *encode_ui(game_ui *ui)
+{
+    char buf[80];
+    /*
+     * The deaths counter needs preserving across a serialisation.
+     */
+    sprintf(buf, "D%d", ui->deaths);
+    return dupstr(buf);
+}
+
+static void decode_ui(game_ui *ui, char *encoding)
+{
+    sscanf(encoding, "D%d", &ui->deaths);
+}
+
 static void game_changed_state(game_ui *ui, game_state *oldstate,
                                game_state *newstate)
 {
 }
 
-static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
-                             int x, int y, int button)
+struct game_drawstate {
+    int w, h, started, tilesize;
+    signed char *grid;
+    /*
+     * Items in this `grid' array have all the same values as in
+     * the game_state grid, and in addition:
+     * 
+     *         - -10 means the tile was drawn `specially' as a result of a
+     *           flash, so it will always need redrawing.
+     * 
+     *         - -22 and -23 mean the tile is highlighted for a possible
+     *           click.
+     */
+};
+
+static char *interpret_move(game_state *from, game_ui *ui, game_drawstate *ds,
+                           int x, int y, int button)
 {
-    game_state *ret;
     int cx, cy;
+    char buf[256];
 
     if (from->dead || from->won)
        return NULL;                   /* no further moves permitted */
@@ -2508,7 +2416,7 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
        ui->hx = cx;
        ui->hy = cy;
        ui->hradius = (from->grid[cy*from->w+cx] >= 0 ? 1 : 0);
-       return from;
+       return "";
     }
 
     if (button == RIGHT_BUTTON) {
@@ -2526,11 +2434,8 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
            from->grid[cy * from->w + cx] != -1)
            return NULL;
 
-       ret = dup_game(from);
-        ret->just_used_solve = FALSE;
-       ret->grid[cy * from->w + cx] ^= (-2 ^ -1);
-
-       return ret;
+       sprintf(buf, "F%d,%d", cx, cy);
+       return dupstr(buf);
     }
 
     if (button == LEFT_RELEASE || button == MIDDLE_RELEASE) {
@@ -2539,10 +2444,10 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
 
        /*
         * At this stage we must never return NULL: we have adjusted
-        * the ui, so at worst we return `from'.
+        * the ui, so at worst we return "".
         */
        if (cx < 0 || cx >= from->w || cy < 0 || cy >= from->h)
-           return from;
+           return "";
 
        /*
         * Left-clicking on a covered square opens a tile. Not
@@ -2552,12 +2457,12 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
        if (button == LEFT_RELEASE &&
            (from->grid[cy * from->w + cx] == -2 ||
             from->grid[cy * from->w + cx] == -3)) {
-           ret = dup_game(from);
-            ret->just_used_solve = FALSE;
-           open_square(ret, cx, cy);
-            if (ret->dead)
-                ui->deaths++;
-           return ret;
+           /* Check if you've killed yourself. */
+           if (from->layout->mines && from->layout->mines[cy * from->w + cx])
+               ui->deaths++;
+
+           sprintf(buf, "O%d,%d", cx, cy);
+           return dupstr(buf);
        }
 
        /*
@@ -2580,8 +2485,101 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
                    }
 
            if (n == from->grid[cy * from->w + cx]) {
-               ret = dup_game(from);
-                ret->just_used_solve = FALSE;
+
+               /*
+                * Now see if any of the squares we're clearing
+                * contains a mine (which will happen iff you've
+                * incorrectly marked the mines around the clicked
+                * square). If so, we open _just_ those squares, to
+                * reveal as little additional information as we
+                * can.
+                */
+               char *p = buf;
+               char *sep = "";
+
+               for (dy = -1; dy <= +1; dy++)
+                   for (dx = -1; dx <= +1; dx++)
+                       if (cx+dx >= 0 && cx+dx < from->w &&
+                           cy+dy >= 0 && cy+dy < from->h) {
+                           if (from->grid[(cy+dy)*from->w+(cx+dx)] != -1 &&
+                               from->layout->mines &&
+                               from->layout->mines[(cy+dy)*from->w+(cx+dx)]) {
+                               p += sprintf(p, "%sO%d,%d", sep, cx+dx, cy+dy);
+                               sep = ";";
+                           }
+                       }
+
+               if (p > buf) {
+                   ui->deaths++;
+               } else {
+                   sprintf(buf, "C%d,%d", cx, cy);
+               }
+
+               return dupstr(buf);
+           }
+       }
+
+       return "";
+    }
+
+    return NULL;
+}
+
+static game_state *execute_move(game_state *from, char *move)
+{
+    int cy, cx;
+    game_state *ret;
+
+    if (!strcmp(move, "S")) {
+       /*
+        * Simply expose the entire grid as if it were a completed
+        * solution.
+        */
+       int yy, xx;
+
+       ret = dup_game(from);
+       for (yy = 0; yy < ret->h; yy++)
+           for (xx = 0; xx < ret->w; xx++) {
+
+               if (ret->layout->mines[yy*ret->w+xx]) {
+                   ret->grid[yy*ret->w+xx] = -1;
+               } else {
+                   int dx, dy, v;
+
+                   v = 0;
+
+                   for (dx = -1; dx <= +1; dx++)
+                       for (dy = -1; dy <= +1; dy++)
+                           if (xx+dx >= 0 && xx+dx < ret->w &&
+                               yy+dy >= 0 && yy+dy < ret->h &&
+                               ret->layout->mines[(yy+dy)*ret->w+(xx+dx)])
+                               v++;
+
+                   ret->grid[yy*ret->w+xx] = v;
+               }
+           }
+       ret->used_solve = ret->just_used_solve = TRUE;
+       ret->won = TRUE;
+
+       return ret;
+    } else {
+       ret = dup_game(from);
+       ret->just_used_solve = FALSE;
+
+       while (*move) {
+           if (move[0] == 'F' &&
+               sscanf(move+1, "%d,%d", &cx, &cy) == 2 &&
+               cx >= 0 && cx < from->w && cy >= 0 && cy < from->h) {
+               ret->grid[cy * from->w + cx] ^= (-2 ^ -1);
+           } else if (move[0] == 'O' &&
+                      sscanf(move+1, "%d,%d", &cx, &cy) == 2 &&
+                      cx >= 0 && cx < from->w && cy >= 0 && cy < from->h) {
+               open_square(ret, cx, cy);
+           } else if (move[0] == 'C' &&
+                      sscanf(move+1, "%d,%d", &cx, &cy) == 2 &&
+                      cx >= 0 && cx < from->w && cy >= 0 && cy < from->h) {
+               int dx, dy;
+
                for (dy = -1; dy <= +1; dy++)
                    for (dx = -1; dx <= +1; dx++)
                        if (cx+dx >= 0 && cx+dx < ret->w &&
@@ -2589,43 +2587,40 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
                            (ret->grid[(cy+dy)*ret->w+(cx+dx)] == -2 ||
                             ret->grid[(cy+dy)*ret->w+(cx+dx)] == -3))
                            open_square(ret, cx+dx, cy+dy);
-                if (ret->dead)
-                    ui->deaths++;
-               return ret;
+           } else {
+               free_game(ret);
+               return NULL;
            }
+
+           while (*move && *move != ';') move++;
+           if (*move) move++;
        }
 
-       return from;
+       return ret;
     }
-
-    return NULL;
 }
 
 /* ----------------------------------------------------------------------
  * Drawing routines.
  */
 
-struct game_drawstate {
-    int w, h, started;
-    signed char *grid;
-    /*
-     * Items in this `grid' array have all the same values as in
-     * the game_state grid, and in addition:
-     * 
-     *         - -10 means the tile was drawn `specially' as a result of a
-     *           flash, so it will always need redrawing.
-     * 
-     *         - -22 and -23 mean the tile is highlighted for a possible
-     *           click.
-     */
-};
-
-static void game_size(game_params *params, int *x, int *y)
+static void game_compute_size(game_params *params, int tilesize,
+                             int *x, int *y)
 {
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
+
     *x = BORDER * 2 + TILE_SIZE * params->w;
     *y = BORDER * 2 + TILE_SIZE * params->h;
 }
 
+static void game_set_size(game_drawstate *ds, game_params *params,
+                         int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
 static float *game_colours(frontend *fe, game_state *state, int *ncolours)
 {
     float *ret = snewn(3 * NCOLOURS, float);
@@ -2711,6 +2706,7 @@ static game_drawstate *game_new_drawstate(game_state *state)
     ds->w = state->w;
     ds->h = state->h;
     ds->started = FALSE;
+    ds->tilesize = 0;                  /* not decided yet */
     ds->grid = snewn(ds->w * ds->h, signed char);
 
     memset(ds->grid, -99, ds->w * ds->h);
@@ -2724,7 +2720,8 @@ static void game_free_drawstate(game_drawstate *ds)
     sfree(ds);
 }
 
-static void draw_tile(frontend *fe, int x, int y, int v, int bg)
+static void draw_tile(frontend *fe, game_drawstate *ds,
+                      int x, int y, int v, int bg)
 {
     if (v < 0) {
         int coords[12];
@@ -2750,13 +2747,12 @@ static void draw_tile(frontend *fe, int x, int y, int v, int bg)
            coords[3] = y;
            coords[4] = x;
            coords[5] = y + TILE_SIZE - 1;
-           draw_polygon(fe, coords, 3, TRUE, COL_LOWLIGHT ^ hl);
-           draw_polygon(fe, coords, 3, FALSE, COL_LOWLIGHT ^ hl);
+           draw_polygon(fe, coords, 3, COL_LOWLIGHT ^ hl, COL_LOWLIGHT ^ hl);
 
            coords[0] = x;
            coords[1] = y;
-           draw_polygon(fe, coords, 3, TRUE, COL_HIGHLIGHT ^ hl);
-           draw_polygon(fe, coords, 3, FALSE, COL_HIGHLIGHT ^ hl);
+           draw_polygon(fe, coords, 3, COL_HIGHLIGHT ^ hl,
+                        COL_HIGHLIGHT ^ hl);
 
            draw_rect(fe, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH,
                      TILE_SIZE - 2*HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH,
@@ -2777,14 +2773,12 @@ static void draw_tile(frontend *fe, int x, int y, int v, int bg)
            SETCOORD(3, 0.25, 0.8);
            SETCOORD(4, 0.55, 0.7);
            SETCOORD(5, 0.55, 0.35);
-           draw_polygon(fe, coords, 6, TRUE, COL_FLAGBASE);
-           draw_polygon(fe, coords, 6, FALSE, COL_FLAGBASE);
+           draw_polygon(fe, coords, 6, COL_FLAGBASE, COL_FLAGBASE);
 
            SETCOORD(0, 0.6, 0.2);
            SETCOORD(1, 0.6, 0.5);
            SETCOORD(2, 0.2, 0.35);
-           draw_polygon(fe, coords, 3, TRUE, COL_FLAG);
-           draw_polygon(fe, coords, 3, FALSE, COL_FLAG);
+           draw_polygon(fe, coords, 3, COL_FLAG, COL_FLAG);
 #undef SETCOORD
 
        } else if (v == -3) {
@@ -2862,8 +2856,7 @@ static void draw_tile(frontend *fe, int x, int y, int v, int bg)
                    xdy = -tdy;
                }
 
-               draw_polygon(fe, coords, 5*4, TRUE, COL_MINE);
-               draw_polygon(fe, coords, 5*4, FALSE, COL_MINE);
+               draw_polygon(fe, coords, 5*4, COL_MINE, COL_MINE);
 
                draw_rect(fe, cx-r/3, cy-r/3, r/3, r/4, COL_HIGHLIGHT);
            }
@@ -2928,13 +2921,11 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
         coords[9] = COORD(state->h) + OUTER_HIGHLIGHT_WIDTH - 1;
         coords[6] = coords[8] + TILE_SIZE;
         coords[7] = coords[9] - TILE_SIZE;
-        draw_polygon(fe, coords, 5, TRUE, COL_HIGHLIGHT);
-        draw_polygon(fe, coords, 5, FALSE, COL_HIGHLIGHT);
+        draw_polygon(fe, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
 
         coords[1] = COORD(0) - OUTER_HIGHLIGHT_WIDTH;
         coords[0] = COORD(0) - OUTER_HIGHLIGHT_WIDTH;
-        draw_polygon(fe, coords, 5, TRUE, COL_LOWLIGHT);
-        draw_polygon(fe, coords, 5, FALSE, COL_LOWLIGHT);
+        draw_polygon(fe, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
 
         ds->started = TRUE;
     }
@@ -2958,7 +2949,7 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
                v -= 20;
 
            if (ds->grid[y*ds->w+x] != v || bg != COL_BACKGROUND) {
-               draw_tile(fe, COORD(x), COORD(y), v, bg);
+               draw_tile(fe, ds, COORD(x), COORD(y), v, bg);
                ds->grid[y*ds->w+x] = (bg == COL_BACKGROUND ? v : -10);
            }
        }
@@ -3040,7 +3031,6 @@ const struct game thegame = {
     TRUE, game_configure, custom_params,
     validate_params,
     new_game_desc,
-    game_free_aux_info,
     validate_desc,
     new_game,
     dup_game,
@@ -3049,9 +3039,12 @@ const struct game thegame = {
     TRUE, game_text_format,
     new_ui,
     free_ui,
+    encode_ui,
+    decode_ui,
     game_changed_state,
-    make_move,
-    game_size,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
     game_colours,
     game_new_drawstate,
     game_free_drawstate,
@@ -3077,7 +3070,7 @@ const struct game thegame = {
  * $ ./mineobfusc 9x9:4,4,004000007c00010022080
  * 9x9:4,4,mb071b49fbd1cb6a0d5868
  *
- * gcc -DSTANDALONE_OBFUSCATOR -o mineobfusc mines.c malloc.c random.c tree234.c
+ * gcc -DSTANDALONE_OBFUSCATOR -o mineobfusc mines.c malloc.c random.c tree234.c misc.c
  */
 
 #include <stdarg.h>
@@ -3088,13 +3081,13 @@ void draw_text(frontend *fe, int x, int y, int fonttype, int fontsize,
 void draw_rect(frontend *fe, int x, int y, int w, int h, int colour) {}
 void draw_line(frontend *fe, int x1, int y1, int x2, int y2, int colour) {}
 void draw_polygon(frontend *fe, int *coords, int npoints,
-                  int fill, int colour) {}
+                  int fillcolour, int outlinecolour) {}
 void clip(frontend *fe, int x, int y, int w, int h) {}
 void unclip(frontend *fe) {}
 void start_draw(frontend *fe) {}
 void draw_update(frontend *fe, int x, int y, int w, int h) {}
 void end_draw(frontend *fe) {}
-void midend_supersede_game_desc(midend_data *me, char *desc) {}
+void midend_supersede_game_desc(midend_data *me, char *desc, char *privdesc) {}
 void status_bar(frontend *fe, char *text) {}
 
 void fatal(char *fmt, ...)
@@ -3115,15 +3108,13 @@ int main(int argc, char **argv)
 {
     game_params *p;
     game_state *s;
-    int recurse = TRUE;
     char *id = NULL, *desc, *err;
     int y, x;
-    int grade = FALSE;
 
     while (--argc > 0) {
         char *p = *++argv;
        if (*p == '-') {
-            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0]);
+            fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p);
             return 1;
         } else {
             id = p;