Fix various departures from C found by `gcc -ansi -pedantic'. I

[sgt/puzzles] / mines.c

diff --git a/mines.c b/mines.c
index 4fa63d1..cf35d7c 100644 (file)
--- a/mines.c
+++ b/mines.c
@@ -95,24 +95,22 @@ static game_params *default_params(void)
     return ret;
 }
 
+static const struct game_params mines_presets[] = {
+  {9, 9, 10, TRUE},
+  {16, 16, 40, TRUE},
+  {30, 16, 99, TRUE},
+};
+
 static int game_fetch_preset(int i, char **name, game_params **params)
 {
     game_params *ret;
     char str[80];
-    static const struct { int w, h, n; } values[] = {
-        {9, 9, 10},
-        {16, 16, 40},
-        {30, 16, 99},
-    };
 
-    if (i < 0 || i >= lenof(values))
+    if (i < 0 || i >= lenof(mines_presets))
         return FALSE;
 
     ret = snew(game_params);
-    ret->w = values[i].w;
-    ret->h = values[i].h;
-    ret->n = values[i].n;
-    ret->unique = TRUE;
+    *ret = mines_presets[i];
 
     sprintf(str, "%dx%d, %d mines", ret->w, ret->h, ret->n);
 
@@ -237,12 +235,22 @@ static game_params *custom_params(config_item *cfg)
 
 static char *validate_params(game_params *params)
 {
-    if (params->w <= 0 && params->h <= 0)
-       return "Width and height must both be greater than zero";
-    if (params->w <= 0)
-       return "Width must be greater than zero";
-    if (params->h <= 0)
-       return "Height must be greater than zero";
+    /*
+     * Lower limit on grid size: each dimension must be at least 3.
+     * 1 is theoretically workable if rather boring, but 2 is a
+     * real problem: there is often _no_ way to generate a uniquely
+     * solvable 2xn Mines grid. You either run into two mines
+     * blocking the way and no idea what's behind them, or one mine
+     * and no way to know which of the two rows it's in. If the
+     * mine count is even you can create a soluble grid by packing
+     * all the mines at one end (so what when you hit a two-mine
+     * wall there are only as many covered squares left as there
+     * are mines); but if it's odd, you are doomed, because you
+     * _have_ to have a gap somewhere which you can't determine the
+     * position of.
+     */
+    if (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";
 
@@ -548,9 +556,11 @@ static void std_add(struct squaretodo *std, int i)
     std->next[i] = -1;
 }
 
+typedef int (*open_cb)(void *, int, int);
+
 static void known_squares(int w, int h, struct squaretodo *std,
-                         signed char *grid,
-                         int (*open)(void *ctx, int x, int y), void *openctx,
+                          signed char *grid,
+                         open_cb open, void *openctx,
                          int x, int y, int mask, int mine)
 {
     int xx, yy, bit;
@@ -616,11 +626,12 @@ struct perturbations {
  *    steps were required; the exact return value is the number of
  *    perturb calls.
  */
+
+typedef struct perturbations *(*perturb_cb) (void *, signed char *, int, int, int);
+
 static int minesolve(int w, int h, int n, signed char *grid,
-                    int (*open)(void *ctx, int x, int y),
-                    struct perturbations *(*perturb)(void *ctx,
-                                                     signed char *grid,
-                                                     int x, int y, int mask),
+                    open_cb open,
+                     perturb_cb perturb,
                     void *ctx, random_state *rs)
 {
     struct setstore *ss = ss_new();
@@ -1280,7 +1291,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;
@@ -1775,7 +1786,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;
 
@@ -1922,7 +1933,7 @@ static void obfuscate_bitmap(unsigned char *bmp, int bits, int decode)
 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;
+    char *grid, *ret, *p;
     unsigned char *bmp;
     int i, area;
 
@@ -2031,13 +2042,25 @@ 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)
 {
+    /*
+     * We generate the coordinates of an initial click even if they
+     * aren't actually used. This has the effect of harmonising the
+     * random number usage between interactive and batch use: if
+     * you use `mines --generate' with an explicit random seed, you
+     * should get exactly the same results as if you type the same
+     * random seed into the interactive game and click in the same
+     * initial location. (Of course you won't get the same grid if
+     * you click in a _different_ initial location, but there's
+     * nothing to be done about that.)
+     */
+    int x = random_upto(rs, params->w);
+    int y = random_upto(rs, params->h);
+
     if (!interactive) {
        /*
         * For batch-generated grids, pre-open one square.
         */
-       int x = random_upto(rs, params->w);
-       int y = random_upto(rs, params->h);
-       signed char *grid;
+       char *grid;
        char *desc;
 
        grid = new_mine_layout(params->w, params->h, params->n,
@@ -2049,7 +2072,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
 
        rsdesc = random_state_encode(rs);
        desc = snewn(strlen(rsdesc) + 100, char);
-       sprintf(desc, "r%d,%c,%s", params->n, params->unique ? 'u' : 'a', rsdesc);
+       sprintf(desc, "r%d,%c,%s", params->n, (char)(params->unique ? 'u' : 'a'), rsdesc);
        sfree(rsdesc);
        return desc;
     }
@@ -2236,9 +2259,10 @@ static game_state *new_game(midend_data *me, game_params *params, char *desc)
     wh = state->w * state->h;
 
     state->layout = snew(struct mine_layout);
+    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') {
@@ -2312,6 +2336,7 @@ static game_state *new_game(midend_data *me, game_params *params, char *desc)
        }
 
        ret = open_square(state, x, y);
+        sfree(bmp);
     }
 
     return state;
@@ -2330,7 +2355,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;
@@ -2664,7 +2689,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);