X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/ab53eb64790d5bee44525c3a50a420a6816e2495..edf63745d9f5a4432e05eb6cb27b9c69b7caf237:/mines.c?ds=sidebyside

diff --git a/mines.c b/mines.c
index 50ba8f0..969c3ec 100644
--- a/mines.c
+++ b/mines.c
@@ -97,8 +97,11 @@ static game_params *default_params(void)
 
 static const struct game_params mines_presets[] = {
   {9, 9, 10, TRUE},
+  {9, 9, 35, TRUE},
   {16, 16, 40, TRUE},
+  {16, 16, 99, TRUE},
   {30, 16, 99, TRUE},
+  {30, 16, 170, TRUE},
 };
 
 static int game_fetch_preset(int i, char **name, game_params **params)
@@ -1291,7 +1294,7 @@ static int minesolve(int w, int h, int n, signed char *grid,
  */
 
 struct minectx {
-    signed char *grid;
+    char *grid;
     int w, h;
     int sx, sy;
     int allow_big_perturbs;
@@ -1786,7 +1789,7 @@ static char *minegen(int w, int h, int n, int x, int y, int unique,
 	 * We bypass this bit if we're not after a unique grid.
          */
 	if (unique) {
-	    signed char *solvegrid = snewn(w*h, char);
+	    signed char *solvegrid = snewn(w*h, signed char);
 	    struct minectx actx, *ctx = &actx;
 	    int solveret, prevret = -2;
 
@@ -1930,12 +1933,51 @@ static void obfuscate_bitmap(unsigned char *bmp, int bits, int decode)
     }
 }
 
+static char *describe_layout(char *grid, int area, int x, int y,
+                             int obfuscate)
+{
+    char *ret, *p;
+    unsigned char *bmp;
+    int i;
+
+    /*
+     * Set up the mine bitmap and obfuscate it.
+     */
+    bmp = snewn((area + 7) / 8, unsigned char);
+    memset(bmp, 0, (area + 7) / 8);
+    for (i = 0; i < area; i++) {
+        if (grid[i])
+            bmp[i / 8] |= 0x80 >> (i % 8);
+    }
+    if (obfuscate)
+        obfuscate_bitmap(bmp, area, FALSE);
+
+    /*
+     * Now encode the resulting bitmap in hex. We can work to
+     * nibble rather than byte granularity, since the obfuscation
+     * function guarantees to return a bit string of the same
+     * length as its input.
+     */
+    ret = snewn((area+3)/4 + 100, char);
+    p = ret + sprintf(ret, "%d,%d,%s", x, y,
+                      obfuscate ? "m" : "");   /* 'm' == masked */
+    for (i = 0; i < (area+3)/4; i++) {
+        int v = bmp[i/2];
+        if (i % 2 == 0)
+            v >>= 4;
+        *p++ = "0123456789abcdef"[v & 0xF];
+    }
+    *p = '\0';
+
+    sfree(bmp);
+
+    return ret;
+}
+
 static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
 			     random_state *rs, char **game_desc)
 {
-    signed char *grid, *ret, *p;
-    unsigned char *bmp;
-    int i, area;
+    char *grid;
 
 #ifdef TEST_OBFUSCATION
     static int tested_obfuscation = FALSE;
@@ -2002,39 +2044,8 @@ static char *new_mine_layout(int w, int h, int n, int x, int y, int unique,
 
     grid = minegen(w, h, n, x, y, unique, rs);
 
-    if (game_desc) {
-	/*
-	 * Set up the mine bitmap and obfuscate it.
-	 */
-	area = w * h;
-	bmp = snewn((area + 7) / 8, unsigned char);
-	memset(bmp, 0, (area + 7) / 8);
-	for (i = 0; i < area; i++) {
-	    if (grid[i])
-		bmp[i / 8] |= 0x80 >> (i % 8);
-	}
-	obfuscate_bitmap(bmp, area, FALSE);
-
-	/*
-	 * Now encode the resulting bitmap in hex. We can work to
-	 * nibble rather than byte granularity, since the obfuscation
-	 * function guarantees to return a bit string of the same
-	 * length as its input.
-	 */
-	ret = snewn((area+3)/4 + 100, char);
-	p = ret + sprintf(ret, "%d,%d,m", x, y);   /* 'm' == masked */
-	for (i = 0; i < (area+3)/4; i++) {
-	    int v = bmp[i/2];
-	    if (i % 2 == 0)
-		v >>= 4;
-	    *p++ = "0123456789abcdef"[v & 0xF];
-	}
-	*p = '\0';
-
-	sfree(bmp);
-
-	*game_desc = ret;
-    }	
+    if (game_desc)
+        *game_desc = describe_layout(grid, w * h, x, y, TRUE);
 
     return grid;
 }
@@ -2060,7 +2071,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
 	/*
 	 * For batch-generated grids, pre-open one square.
 	 */
-	signed char *grid;
+	char *grid;
 	char *desc;
 
 	grid = new_mine_layout(params->w, params->h, params->n,
@@ -2262,7 +2273,7 @@ static game_state *new_game(midend_data *me, game_params *params, char *desc)
     memset(state->layout, 0, sizeof(struct mine_layout));
     state->layout->refcount = 1;
 
-    state->grid = snewn(wh, char);
+    state->grid = snewn(wh, signed char);
     memset(state->grid, -2, wh);
 
     if (*desc == 'r') {
@@ -2355,7 +2366,7 @@ static game_state *dup_game(game_state *state)
     ret->just_used_solve = state->just_used_solve;
     ret->layout = state->layout;
     ret->layout->refcount++;
-    ret->grid = snewn(ret->w * ret->h, char);
+    ret->grid = snewn(ret->w * ret->h, signed char);
     memcpy(ret->grid, state->grid, ret->w * ret->h);
 
     return ret;
@@ -2689,7 +2700,7 @@ static game_drawstate *game_new_drawstate(game_state *state)
     ds->w = state->w;
     ds->h = state->h;
     ds->started = FALSE;
-    ds->grid = snewn(ds->w * ds->h, char);
+    ds->grid = snewn(ds->w * ds->h, signed char);
 
     memset(ds->grid, -99, ds->w * ds->h);
 
@@ -3039,3 +3050,108 @@ const struct game thegame = {
     TRUE, game_timing_state,
     BUTTON_BEATS(LEFT_BUTTON, RIGHT_BUTTON),
 };
+
+#ifdef STANDALONE_OBFUSCATOR
+
+/*
+ * Vaguely useful stand-alone program which translates between
+ * obfuscated and clear Mines game descriptions. Pass in a game
+ * description on the command line, and if it's clear it will be
+ * obfuscated and vice versa. The output text should also be a
+ * valid game ID describing the same game. Like this:
+ *
+ * $ ./mineobfusc 9x9:4,4,mb071b49fbd1cb6a0d5868
+ * 9x9:4,4,004000007c00010022080
+ * $ ./mineobfusc 9x9:4,4,004000007c00010022080
+ * 9x9:4,4,mb071b49fbd1cb6a0d5868
+ *
+ * gcc -DSTANDALONE_OBFUSCATOR -o mineobfusc mines.c malloc.c random.c tree234.c
+ */
+
+#include <stdarg.h>
+
+void frontend_default_colour(frontend *fe, float *output) {}
+void draw_text(frontend *fe, int x, int y, int fonttype, int fontsize,
+               int align, int colour, char *text) {}
+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) {}
+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 status_bar(frontend *fe, char *text) {}
+
+void fatal(char *fmt, ...)
+{
+    va_list ap;
+
+    fprintf(stderr, "fatal error: ");
+
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+
+    fprintf(stderr, "\n");
+    exit(1);
+}
+
+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]);
+            return 1;
+        } else {
+            id = p;
+        }
+    }
+
+    if (!id) {
+        fprintf(stderr, "usage: %s <game_id>\n", argv[0]);
+        return 1;
+    }
+
+    desc = strchr(id, ':');
+    if (!desc) {
+        fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
+        return 1;
+    }
+    *desc++ = '\0';
+
+    p = default_params();
+    decode_params(p, id);
+    err = validate_desc(p, desc);
+    if (err) {
+        fprintf(stderr, "%s: %s\n", argv[0], err);
+        return 1;
+    }
+    s = new_game(NULL, p, desc);
+
+    x = atoi(desc);
+    while (*desc && *desc != ',') desc++;
+    if (*desc) desc++;
+    y = atoi(desc);
+    while (*desc && *desc != ',') desc++;
+    if (*desc) desc++;
+
+    printf("%s:%s\n", id, describe_layout(s->layout->mines,
+                                          p->w * p->h,
+                                          x, y,
+                                          (*desc != 'm')));
+
+    return 0;
+}
+
+#endif