X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/8317499a9932b585a28a452677b6128324adaba0..102541860ca92537ea7441cfe21b1bd2f63edeac:/mines.c

diff --git a/mines.c b/mines.c
index b70167e..746106b 100644
--- a/mines.c
+++ b/mines.c
@@ -53,7 +53,7 @@ struct mine_layout {
      */
     int n, unique;
     random_state *rs;
-    midend_data *me;		       /* to give back the new game desc */
+    midend *me;		       /* to give back the new game desc */
 };
 
 struct game_state {
@@ -237,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.
@@ -253,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";
@@ -2157,7 +2157,7 @@ static int open_square(game_state *state, int x, int y)
     return 0;
 }
 
-static game_state *new_game(midend_data *me, game_params *params, char *desc)
+static game_state *new_game(midend *me, game_params *params, char *desc)
 {
     game_state *state = snew(game_state);
     int i, wh, x, y, ret, masked;
@@ -2334,16 +2334,18 @@ static char *game_text_format(game_state *state)
 
 struct game_ui {
     int hx, hy, hradius;	       /* for mouse-down highlights */
+    int validradius;
     int flash_is_death;
-    int deaths;
+    int deaths, completed;
 };
 
 static game_ui *new_ui(game_state *state)
 {
     game_ui *ui = snew(game_ui);
     ui->hx = ui->hy = -1;
-    ui->hradius = 0;
+    ui->hradius = ui->validradius = 0;
     ui->deaths = 0;
+    ui->completed = FALSE;
     ui->flash_is_death = FALSE;	       /* *shrug* */
     return ui;
 }
@@ -2357,24 +2359,32 @@ static char *encode_ui(game_ui *ui)
 {
     char buf[80];
     /*
-     * The deaths counter needs preserving across a serialisation.
+     * The deaths counter and completion status need preserving
+     * across a serialisation.
      */
     sprintf(buf, "D%d", ui->deaths);
+    if (ui->completed)
+	strcat(buf, "C");
     return dupstr(buf);
 }
 
 static void decode_ui(game_ui *ui, char *encoding)
 {
-    sscanf(encoding, "D%d", &ui->deaths);
+    int p= 0;
+    sscanf(encoding, "D%d%n", &ui->deaths, &p);
+    if (encoding[p] == 'C')
+	ui->completed = TRUE;
 }
 
 static void game_changed_state(game_ui *ui, game_state *oldstate,
                                game_state *newstate)
 {
+    if (newstate->won)
+	ui->completed = TRUE;
 }
 
 struct game_drawstate {
-    int w, h, started, tilesize;
+    int w, h, started, tilesize, bg;
     signed char *grid;
     /*
      * Items in this `grid' array have all the same values as in
@@ -2416,6 +2426,10 @@ static char *interpret_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);
+	if (button == LEFT_BUTTON)
+	    ui->validradius = ui->hradius;
+	else if (button == MIDDLE_BUTTON)
+	    ui->validradius = 1;
 	return "";
     }
 
@@ -2456,7 +2470,8 @@ static char *interpret_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)) {
+	     from->grid[cy * from->w + cx] == -3) &&
+	    ui->validradius == 0) {
 	    /* Check if you've killed yourself. */
 	    if (from->layout->mines && from->layout->mines[cy * from->w + cx])
 		ui->deaths++;
@@ -2471,7 +2486,7 @@ static char *interpret_move(game_state *from, game_ui *ui, game_drawstate *ds,
 	 * surrounding the tile is equal to its mine count, and if
 	 * so then we open all other surrounding squares.
 	 */
-	if (from->grid[cy * from->w + cx] > 0) {
+	if (from->grid[cy * from->w + cx] > 0 && ui->validradius == 1) {
 	    int dy, dx, n;
 
 	    /* Count mine markers. */
@@ -2615,8 +2630,8 @@ static void game_compute_size(game_params *params, int tilesize,
     *y = BORDER * 2 + TILE_SIZE * params->h;
 }
 
-static void game_set_size(game_drawstate *ds, game_params *params,
-			  int tilesize)
+static void game_set_size(drawing *dr, game_drawstate *ds,
+			  game_params *params, int tilesize)
 {
     ds->tilesize = tilesize;
 }
@@ -2699,7 +2714,7 @@ static float *game_colours(frontend *fe, game_state *state, int *ncolours)
     return ret;
 }
 
-static game_drawstate *game_new_drawstate(game_state *state)
+static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
 {
     struct game_drawstate *ds = snew(struct game_drawstate);
 
@@ -2708,19 +2723,20 @@ static game_drawstate *game_new_drawstate(game_state *state)
     ds->started = FALSE;
     ds->tilesize = 0;                  /* not decided yet */
     ds->grid = snewn(ds->w * ds->h, signed char);
+    ds->bg = -1;
 
     memset(ds->grid, -99, ds->w * ds->h);
 
     return ds;
 }
 
-static void game_free_drawstate(game_drawstate *ds)
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 {
     sfree(ds->grid);
     sfree(ds);
 }
 
-static void draw_tile(frontend *fe, game_drawstate *ds,
+static void draw_tile(drawing *dr, game_drawstate *ds,
                       int x, int y, int v, int bg)
 {
     if (v < 0) {
@@ -2733,10 +2749,10 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 	    /*
 	     * Omit the highlights in this case.
 	     */
-	    draw_rect(fe, x, y, TILE_SIZE, TILE_SIZE,
+	    draw_rect(dr, x, y, TILE_SIZE, TILE_SIZE,
                       bg == COL_BACKGROUND ? COL_BACKGROUND2 : bg);
-	    draw_line(fe, x, y, x + TILE_SIZE - 1, y, COL_LOWLIGHT);
-	    draw_line(fe, x, y, x, y + TILE_SIZE - 1, COL_LOWLIGHT);
+	    draw_line(dr, x, y, x + TILE_SIZE - 1, y, COL_LOWLIGHT);
+	    draw_line(dr, x, y, x, y + TILE_SIZE - 1, COL_LOWLIGHT);
 	} else {
 	    /*
 	     * Draw highlights to indicate the square is covered.
@@ -2747,14 +2763,14 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 	    coords[3] = y;
 	    coords[4] = x;
 	    coords[5] = y + TILE_SIZE - 1;
-	    draw_polygon(fe, coords, 3, COL_LOWLIGHT ^ hl, COL_LOWLIGHT ^ hl);
+	    draw_polygon(dr, coords, 3, COL_LOWLIGHT ^ hl, COL_LOWLIGHT ^ hl);
 
 	    coords[0] = x;
 	    coords[1] = y;
-	    draw_polygon(fe, coords, 3, COL_HIGHLIGHT ^ hl,
+	    draw_polygon(dr, coords, 3, COL_HIGHLIGHT ^ hl,
 			 COL_HIGHLIGHT ^ hl);
 
-	    draw_rect(fe, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH,
+	    draw_rect(dr, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH,
 		      TILE_SIZE - 2*HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH,
 		      bg);
 	}
@@ -2773,19 +2789,19 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 	    SETCOORD(3, 0.25, 0.8);
 	    SETCOORD(4, 0.55, 0.7);
 	    SETCOORD(5, 0.55, 0.35);
-	    draw_polygon(fe, coords, 6, COL_FLAGBASE, COL_FLAGBASE);
+	    draw_polygon(dr, 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, COL_FLAG, COL_FLAG);
+	    draw_polygon(dr, coords, 3, COL_FLAG, COL_FLAG);
 #undef SETCOORD
 
 	} else if (v == -3) {
 	    /*
 	     * Draw a question mark.
 	     */
-	    draw_text(fe, x + TILE_SIZE / 2, y + TILE_SIZE / 2,
+	    draw_text(dr, x + TILE_SIZE / 2, y + TILE_SIZE / 2,
 		      FONT_VARIABLE, TILE_SIZE * 6 / 8,
 		      ALIGN_VCENTRE | ALIGN_HCENTRE,
 		      COL_QUERY, "?");
@@ -2798,11 +2814,11 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 	 * Exception is that for value 65 (mine we've just trodden
 	 * on), we clear the square to COL_BANG.
 	 */
-        draw_rect(fe, x, y, TILE_SIZE, TILE_SIZE,
+        draw_rect(dr, x, y, TILE_SIZE, TILE_SIZE,
 		  (v == 65 ? COL_BANG :
                    bg == COL_BACKGROUND ? COL_BACKGROUND2 : bg));
-	draw_line(fe, x, y, x + TILE_SIZE - 1, y, COL_LOWLIGHT);
-	draw_line(fe, x, y, x, y + TILE_SIZE - 1, COL_LOWLIGHT);
+	draw_line(dr, x, y, x + TILE_SIZE - 1, y, COL_LOWLIGHT);
+	draw_line(dr, x, y, x, y + TILE_SIZE - 1, COL_LOWLIGHT);
 
 	if (v > 0 && v <= 8) {
 	    /*
@@ -2811,7 +2827,7 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 	    char str[2];
 	    str[0] = v + '0';
 	    str[1] = '\0';
-	    draw_text(fe, x + TILE_SIZE / 2, y + TILE_SIZE / 2,
+	    draw_text(dr, x + TILE_SIZE / 2, y + TILE_SIZE / 2,
 		      FONT_VARIABLE, TILE_SIZE * 7 / 8,
 		      ALIGN_VCENTRE | ALIGN_HCENTRE,
 		      (COL_1 - 1) + v, str);
@@ -2823,7 +2839,7 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 	     * FIXME: this could be done better!
 	     */
 #if 0
-	    draw_text(fe, x + TILE_SIZE / 2, y + TILE_SIZE / 2,
+	    draw_text(dr, x + TILE_SIZE / 2, y + TILE_SIZE / 2,
 		      FONT_VARIABLE, TILE_SIZE * 7 / 8,
 		      ALIGN_VCENTRE | ALIGN_HCENTRE,
 		      COL_MINE, "*");
@@ -2856,9 +2872,9 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 		    xdy = -tdy;
 		}
 
-		draw_polygon(fe, coords, 5*4, COL_MINE, COL_MINE);
+		draw_polygon(dr, coords, 5*4, COL_MINE, COL_MINE);
 
-		draw_rect(fe, cx-r/3, cy-r/3, r/3, r/4, COL_HIGHLIGHT);
+		draw_rect(dr, cx-r/3, cy-r/3, r/3, r/4, COL_HIGHLIGHT);
 	    }
 #endif
 
@@ -2868,10 +2884,10 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 		 */
 		int dx;
 		for (dx = -1; dx <= +1; dx++) {
-		    draw_line(fe, x + 3 + dx, y + 2,
+		    draw_line(dr, x + 3 + dx, y + 2,
 			      x + TILE_SIZE - 3 + dx,
 			      y + TILE_SIZE - 2, COL_CROSS);
-		    draw_line(fe, x + TILE_SIZE - 3 + dx, y + 2,
+		    draw_line(dr, x + TILE_SIZE - 3 + dx, y + 2,
 			      x + 3 + dx, y + TILE_SIZE - 2,
 			      COL_CROSS);
 		}
@@ -2879,10 +2895,10 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 	}
     }
 
-    draw_update(fe, x, y, TILE_SIZE, TILE_SIZE);
+    draw_update(dr, x, y, TILE_SIZE, TILE_SIZE);
 }
 
-static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
+static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
 			game_state *state, int dir, game_ui *ui,
 			float animtime, float flashtime)
 {
@@ -2901,10 +2917,10 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
     if (!ds->started) {
         int coords[10];
 
-	draw_rect(fe, 0, 0,
+	draw_rect(dr, 0, 0,
 		  TILE_SIZE * state->w + 2 * BORDER,
 		  TILE_SIZE * state->h + 2 * BORDER, COL_BACKGROUND);
-	draw_update(fe, 0, 0,
+	draw_update(dr, 0, 0,
 		    TILE_SIZE * state->w + 2 * BORDER,
 		    TILE_SIZE * state->h + 2 * BORDER);
 
@@ -2921,11 +2937,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, COL_HIGHLIGHT, COL_HIGHLIGHT);
+        draw_polygon(dr, 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, COL_LOWLIGHT, COL_LOWLIGHT);
+        draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
 
         ds->started = TRUE;
     }
@@ -2948,11 +2964,12 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
 		(abs(x-ui->hx) <= ui->hradius && abs(y-ui->hy) <= ui->hradius))
 		v -= 20;
 
-	    if (ds->grid[y*ds->w+x] != v || bg != COL_BACKGROUND) {
-		draw_tile(fe, ds, COORD(x), COORD(y), v, bg);
-		ds->grid[y*ds->w+x] = (bg == COL_BACKGROUND ? v : -10);
+	    if (ds->grid[y*ds->w+x] != v || bg != ds->bg) {
+		draw_tile(dr, ds, COORD(x), COORD(y), v, bg);
+		ds->grid[y*ds->w+x] = v;
 	    }
 	}
+    ds->bg = bg;
 
     if (!state->layout->mines)
 	mines = state->layout->n;
@@ -2975,7 +2992,7 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
         if (ui->deaths)
             sprintf(statusbar + strlen(statusbar),
                     "  Deaths: %d", ui->deaths);
-	status_bar(fe, statusbar);
+	status_bar(dr, statusbar);
     }
 }
 
@@ -3009,13 +3026,21 @@ static int game_wants_statusbar(void)
     return TRUE;
 }
 
-static int game_timing_state(game_state *state)
+static int game_timing_state(game_state *state, game_ui *ui)
 {
-    if (state->dead || state->won || !state->layout->mines)
+    if (state->dead || state->won || ui->completed || !state->layout->mines)
 	return FALSE;
     return TRUE;
 }
 
+static void game_print_size(game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, game_state *state, int tilesize)
+{
+}
+
 #ifdef COMBINED
 #define thegame mines
 #endif
@@ -3051,6 +3076,7 @@ const struct game thegame = {
     game_redraw,
     game_anim_length,
     game_flash_length,
+    FALSE, FALSE, game_print_size, game_print,
     game_wants_statusbar,
     TRUE, game_timing_state,
     BUTTON_BEATS(LEFT_BUTTON, RIGHT_BUTTON),
@@ -3076,19 +3102,19 @@ const struct game thegame = {
 #include <stdarg.h>
 
 void frontend_default_colour(frontend *fe, float *output) {}
-void draw_text(frontend *fe, int x, int y, int fonttype, int fontsize,
+void draw_text(drawing *dr, 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,
+void draw_rect(drawing *dr, int x, int y, int w, int h, int colour) {}
+void draw_line(drawing *dr, int x1, int y1, int x2, int y2, int colour) {}
+void draw_polygon(drawing *dr, int *coords, int npoints,
                   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, char *privdesc) {}
-void status_bar(frontend *fe, char *text) {}
+void clip(drawing *dr, int x, int y, int w, int h) {}
+void unclip(drawing *dr) {}
+void start_draw(drawing *dr) {}
+void draw_update(drawing *dr, int x, int y, int w, int h) {}
+void end_draw(drawing *dr) {}
+void midend_supersede_game_desc(midend *me, char *desc, char *privdesc) {}
+void status_bar(drawing *dr, char *text) {}
 
 void fatal(char *fmt, ...)
 {