X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/ae8290c655dec864db8ef0dc6b59891d6434c71f..de3b0e332712c81307a7800808b6d13d2c5cec93:/rect.c

diff --git a/rect.c b/rect.c
index ca8c04b..a7113af 100644
--- a/rect.c
+++ b/rect.c
@@ -76,6 +76,7 @@ struct game_state {
     unsigned char *vedge;	       /* (w+1) x h */
     unsigned char *hedge;	       /* w x (h+1) */
     int completed, cheated;
+    unsigned char *correct;
 };
 
 static game_params *default_params(void)
@@ -212,7 +213,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)
 {
     if (params->w <= 0 || params->h <= 0)
 	return "Width and height must both be greater than zero";
@@ -1117,14 +1118,8 @@ static void display_grid(game_params *params, int *grid, int *numbers, int all)
 }
 #endif
 
-struct game_aux_info {
-    int w, h;
-    unsigned char *vedge;	       /* (w+1) x h */
-    unsigned char *hedge;	       /* w x (h+1) */
-};
-
 static char *new_game_desc(game_params *params, random_state *rs,
-			   game_aux_info **aux, int interactive)
+			   char **aux, int interactive)
 {
     int *grid, *numbers = NULL;
     int x, y, y2, y2last, yx, run, i, nsquares;
@@ -1679,26 +1674,31 @@ static char *new_game_desc(game_params *params, random_state *rs,
     }
 
     /*
-     * Store the rectangle data in the game_aux_info.
+     * Store the solution in aux.
      */
     {
-        game_aux_info *ai = snew(game_aux_info);
+        char *ai;
+        int len;
+
+        len = 2 + (params->w-1)*params->h + (params->h-1)*params->w;
+        ai = snewn(len, char);
+
+        ai[0] = 'S';
 
-        ai->w = params->w;
-        ai->h = params->h;
-        ai->vedge = snewn(ai->w * ai->h, unsigned char);
-        ai->hedge = snewn(ai->w * ai->h, unsigned char);
+        p = ai+1;
 
         for (y = 0; y < params->h; y++)
-            for (x = 1; x < params->w; x++) {
-                vedge(ai, x, y) =
-                    index(params, grid, x, y) != index(params, grid, x-1, y);
-            }
+            for (x = 1; x < params->w; x++)
+                *p++ = (index(params, grid, x, y) !=
+                        index(params, grid, x-1, y) ? '1' : '0');
+
         for (y = 1; y < params->h; y++)
-            for (x = 0; x < params->w; x++) {
-                hedge(ai, x, y) =
-                    index(params, grid, x, y) != index(params, grid, x, y-1);
-            }
+            for (x = 0; x < params->w; x++)
+                *p++ = (index(params, grid, x, y) !=
+                        index(params, grid, x, y-1) ? '1' : '0');
+
+        assert(p - ai == len-1);
+        *p = '\0';
 
         *aux = ai;
     }
@@ -1746,13 +1746,6 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static void game_free_aux_info(game_aux_info *ai)
-{
-    sfree(ai->vedge);
-    sfree(ai->hedge);
-    sfree(ai);
-}
-
 static char *validate_desc(game_params *params, char *desc)
 {
     int area = params->w * params->h;
@@ -1781,6 +1774,99 @@ static char *validate_desc(game_params *params, char *desc)
     return NULL;
 }
 
+static unsigned char *get_correct(game_state *state)
+{
+    unsigned char *ret;
+    int x, y;
+
+    ret = snewn(state->w * state->h, unsigned char);
+    memset(ret, 0xFF, state->w * state->h);
+
+    for (x = 0; x < state->w; x++)
+	for (y = 0; y < state->h; y++)
+	    if (index(state,ret,x,y) == 0xFF) {
+		int rw, rh;
+		int xx, yy;
+		int num, area, valid;
+
+		/*
+		 * Find a rectangle starting at this point.
+		 */
+		rw = 1;
+		while (x+rw < state->w && !vedge(state,x+rw,y))
+		    rw++;
+		rh = 1;
+		while (y+rh < state->h && !hedge(state,x,y+rh))
+		    rh++;
+
+		/*
+		 * We know what the dimensions of the rectangle
+		 * should be if it's there at all. Find out if we
+		 * really have a valid rectangle.
+		 */
+		valid = TRUE;
+		/* Check the horizontal edges. */
+		for (xx = x; xx < x+rw; xx++) {
+		    for (yy = y; yy <= y+rh; yy++) {
+			int e = !HRANGE(state,xx,yy) || hedge(state,xx,yy);
+			int ec = (yy == y || yy == y+rh);
+			if (e != ec)
+			    valid = FALSE;
+		    }
+		}
+		/* Check the vertical edges. */
+		for (yy = y; yy < y+rh; yy++) {
+		    for (xx = x; xx <= x+rw; xx++) {
+			int e = !VRANGE(state,xx,yy) || vedge(state,xx,yy);
+			int ec = (xx == x || xx == x+rw);
+			if (e != ec)
+			    valid = FALSE;
+		    }
+		}
+
+		/*
+		 * If this is not a valid rectangle with no other
+		 * edges inside it, we just mark this square as not
+		 * complete and proceed to the next square.
+		 */
+		if (!valid) {
+		    index(state, ret, x, y) = 0;
+		    continue;
+		}
+
+		/*
+		 * We have a rectangle. Now see what its area is,
+		 * and how many numbers are in it.
+		 */
+		num = 0;
+		area = 0;
+		for (xx = x; xx < x+rw; xx++) {
+		    for (yy = y; yy < y+rh; yy++) {
+			area++;
+			if (grid(state,xx,yy)) {
+			    if (num > 0)
+				valid = FALSE;   /* two numbers */
+			    num = grid(state,xx,yy);
+			}
+		    }
+		}
+		if (num != area)
+		    valid = FALSE;
+
+		/*
+		 * Now fill in the whole rectangle based on the
+		 * value of `valid'.
+		 */
+		for (xx = x; xx < x+rw; xx++) {
+		    for (yy = y; yy < y+rh; yy++) {
+			index(state, ret, xx, yy) = valid;
+		    }
+		}
+	    }
+
+    return ret;
+}
+
 static game_state *new_game(midend_data *me, game_params *params, char *desc)
 {
     game_state *state = snew(game_state);
@@ -1821,6 +1907,8 @@ static game_state *new_game(midend_data *me, game_params *params, char *desc)
 	for (x = 0; x < state->w; x++)
 	    vedge(state,x,y) = hedge(state,x,y) = 0;
 
+    state->correct = get_correct(state);
+
     return state;
 }
 
@@ -1834,6 +1922,7 @@ static game_state *dup_game(game_state *state)
     ret->vedge = snewn(state->w * state->h, unsigned char);
     ret->hedge = snewn(state->w * state->h, unsigned char);
     ret->grid = snewn(state->w * state->h, int);
+    ret->correct = snewn(ret->w * ret->h, unsigned char);
 
     ret->completed = state->completed;
     ret->cheated = state->cheated;
@@ -1842,6 +1931,8 @@ static game_state *dup_game(game_state *state)
     memcpy(ret->vedge, state->vedge, state->w*state->h*sizeof(unsigned char));
     memcpy(ret->hedge, state->hedge, state->w*state->h*sizeof(unsigned char));
 
+    memcpy(ret->correct, state->correct, state->w*state->h*sizeof(unsigned char));
+
     return ret;
 }
 
@@ -1850,65 +1941,58 @@ static void free_game(game_state *state)
     sfree(state->grid);
     sfree(state->vedge);
     sfree(state->hedge);
+    sfree(state->correct);
     sfree(state);
 }
 
 static char *solve_game(game_state *state, game_state *currstate,
-			game_aux_info *ai, char **error)
+			char *ai, char **error)
 {
     unsigned char *vedge, *hedge;
-    int edges_need_freeing;
     int x, y, len;
     char *ret, *p;
+    int i, j, n;
+    struct numberdata *nd;
 
-    if (!ai) {
-	int i, j, n;
-	struct numberdata *nd;
-
-	/*
-	 * Attempt the in-built solver.
-	 */
-
-	/* Set up each number's (very short) candidate position list. */
-	for (i = n = 0; i < state->h * state->w; i++)
-	    if (state->grid[i])
-		n++;
-
-	nd = snewn(n, struct numberdata);
-
-	for (i = j = 0; i < state->h * state->w; i++)
-	    if (state->grid[i]) {
-		nd[j].area = state->grid[i];
-		nd[j].npoints = 1;
-		nd[j].points = snewn(1, struct point);
-		nd[j].points[0].x = i % state->w;
-		nd[j].points[0].y = i / state->w;
-		j++;
-	    }
+    if (ai)
+        return dupstr(ai);
 
-	assert(j == n);
+    /*
+     * Attempt the in-built solver.
+     */
 
-	vedge = snewn(state->w * state->h, unsigned char);
-	hedge = snewn(state->w * state->h, unsigned char);
-	memset(vedge, 0, state->w * state->h);
-	memset(hedge, 0, state->w * state->h);
-	edges_need_freeing = TRUE;
+    /* Set up each number's (very short) candidate position list. */
+    for (i = n = 0; i < state->h * state->w; i++)
+        if (state->grid[i])
+            n++;
+
+    nd = snewn(n, struct numberdata);
+
+    for (i = j = 0; i < state->h * state->w; i++)
+        if (state->grid[i]) {
+            nd[j].area = state->grid[i];
+            nd[j].npoints = 1;
+            nd[j].points = snewn(1, struct point);
+            nd[j].points[0].x = i % state->w;
+            nd[j].points[0].y = i / state->w;
+            j++;
+        }
 
-	rect_solver(state->w, state->h, n, nd, hedge, vedge, NULL);
+    assert(j == n);
 
-	/*
-	 * Clean up.
-	 */
-	for (i = 0; i < n; i++)
-	    sfree(nd[i].points);
-	sfree(nd);
-    } else {
-	assert(state->w == ai->w);
-	assert(state->h == ai->h);
-	vedge = ai->vedge;
-	hedge = ai->hedge;
-	edges_need_freeing = FALSE;
-    }
+    vedge = snewn(state->w * state->h, unsigned char);
+    hedge = snewn(state->w * state->h, unsigned char);
+    memset(vedge, 0, state->w * state->h);
+    memset(hedge, 0, state->w * state->h);
+
+    rect_solver(state->w, state->h, n, nd, hedge, vedge, NULL);
+
+    /*
+     * Clean up.
+     */
+    for (i = 0; i < n; i++)
+        sfree(nd[i].points);
+    sfree(nd);
 
     len = 2 + (state->w-1)*state->h + (state->h-1)*state->w;
     ret = snewn(len, char);
@@ -1916,18 +2000,16 @@ static char *solve_game(game_state *state, game_state *currstate,
     p = ret;
     *p++ = 'S';
     for (y = 0; y < state->h; y++)
-	for (x = 1; x < state->w; x++)
-	    *p++ = vedge[y*state->w+x] ? '1' : '0';
+        for (x = 1; x < state->w; x++)
+            *p++ = vedge[y*state->w+x] ? '1' : '0';
     for (y = 1; y < state->h; y++)
 	for (x = 0; x < state->w; x++)
 	    *p++ = hedge[y*state->w+x] ? '1' : '0';
     *p++ = '\0';
     assert(p - ret == len);
 
-    if (edges_need_freeing) {
-	sfree(vedge);
-	sfree(hedge);
-    }
+    sfree(vedge);
+    sfree(hedge);
 
     return ret;
 }
@@ -2025,99 +2107,6 @@ static char *game_text_format(game_state *state)
     return ret;
 }
 
-static unsigned char *get_correct(game_state *state)
-{
-    unsigned char *ret;
-    int x, y;
-
-    ret = snewn(state->w * state->h, unsigned char);
-    memset(ret, 0xFF, state->w * state->h);
-
-    for (x = 0; x < state->w; x++)
-	for (y = 0; y < state->h; y++)
-	    if (index(state,ret,x,y) == 0xFF) {
-		int rw, rh;
-		int xx, yy;
-		int num, area, valid;
-
-		/*
-		 * Find a rectangle starting at this point.
-		 */
-		rw = 1;
-		while (x+rw < state->w && !vedge(state,x+rw,y))
-		    rw++;
-		rh = 1;
-		while (y+rh < state->h && !hedge(state,x,y+rh))
-		    rh++;
-
-		/*
-		 * We know what the dimensions of the rectangle
-		 * should be if it's there at all. Find out if we
-		 * really have a valid rectangle.
-		 */
-		valid = TRUE;
-		/* Check the horizontal edges. */
-		for (xx = x; xx < x+rw; xx++) {
-		    for (yy = y; yy <= y+rh; yy++) {
-			int e = !HRANGE(state,xx,yy) || hedge(state,xx,yy);
-			int ec = (yy == y || yy == y+rh);
-			if (e != ec)
-			    valid = FALSE;
-		    }
-		}
-		/* Check the vertical edges. */
-		for (yy = y; yy < y+rh; yy++) {
-		    for (xx = x; xx <= x+rw; xx++) {
-			int e = !VRANGE(state,xx,yy) || vedge(state,xx,yy);
-			int ec = (xx == x || xx == x+rw);
-			if (e != ec)
-			    valid = FALSE;
-		    }
-		}
-
-		/*
-		 * If this is not a valid rectangle with no other
-		 * edges inside it, we just mark this square as not
-		 * complete and proceed to the next square.
-		 */
-		if (!valid) {
-		    index(state, ret, x, y) = 0;
-		    continue;
-		}
-
-		/*
-		 * We have a rectangle. Now see what its area is,
-		 * and how many numbers are in it.
-		 */
-		num = 0;
-		area = 0;
-		for (xx = x; xx < x+rw; xx++) {
-		    for (yy = y; yy < y+rh; yy++) {
-			area++;
-			if (grid(state,xx,yy)) {
-			    if (num > 0)
-				valid = FALSE;   /* two numbers */
-			    num = grid(state,xx,yy);
-			}
-		    }
-		}
-		if (num != area)
-		    valid = FALSE;
-
-		/*
-		 * Now fill in the whole rectangle based on the
-		 * value of `valid'.
-		 */
-		for (xx = x; xx < x+rw; xx++) {
-		    for (yy = y; yy < y+rh; yy++) {
-			index(state, ret, xx, yy) = valid;
-		    }
-		}
-	    }
-
-    return ret;
-}
-
 struct game_ui {
     /*
      * These coordinates are 2 times the obvious grid coordinates.
@@ -2170,12 +2159,12 @@ static void free_ui(game_ui *ui)
     sfree(ui);
 }
 
-char *encode_ui(game_ui *ui)
+static char *encode_ui(game_ui *ui)
 {
     return NULL;
 }
 
-void decode_ui(game_ui *ui, char *encoding)
+static void decode_ui(game_ui *ui, char *encoding)
 {
 }
 
@@ -2347,7 +2336,10 @@ static char *interpret_move(game_state *from, game_ui *ui, game_drawstate *ds,
 
     coord_round(FROMCOORD((float)x), FROMCOORD((float)y), &xc, &yc);
 
-    if (startdrag) {
+    if (startdrag &&
+	xc >= 0 && xc <= 2*from->w &&
+	yc >= 0 && yc <= 2*from->h) {
+
         ui->drag_start_x = xc;
         ui->drag_start_y = yc;
         ui->drag_end_x = xc;
@@ -2356,7 +2348,8 @@ static char *interpret_move(game_state *from, game_ui *ui, game_drawstate *ds,
         active = TRUE;
     }
 
-    if (xc != ui->drag_end_x || yc != ui->drag_end_y) {
+    if (ui->drag_start_x >= 0 &&
+	(xc != ui->drag_end_x || yc != ui->drag_end_y)) {
 	int t;
 
         ui->drag_end_x = xc;
@@ -2388,7 +2381,7 @@ static char *interpret_move(game_state *from, game_ui *ui, game_drawstate *ds,
 
     ret = NULL;
 
-    if (enddrag) {
+    if (enddrag && (ui->drag_start_x >= 0)) {
 	if (xc >= 0 && xc <= 2*from->w &&
 	    yc >= 0 && yc <= 2*from->h) {
 
@@ -2454,6 +2447,9 @@ static game_state *execute_move(game_state *from, char *move)
 		if (*p) p++;
 	    }
 
+	sfree(ret->correct);
+	ret->correct = get_correct(ret);
+
 	return ret;
 
     } else if (move[0] == 'R' &&
@@ -2481,22 +2477,22 @@ static game_state *execute_move(game_state *from, char *move)
 	vedge(ret,x1,y1) = !vedge(ret,x1,y1);
     }
 
+    sfree(ret->correct);
+    ret->correct = get_correct(ret);
+
     /*
      * We've made a real change to the grid. Check to see
      * if the game has been completed.
      */
     if (!ret->completed) {
 	int x, y, ok;
-	unsigned char *correct = get_correct(ret);
 
 	ok = TRUE;
 	for (x = 0; x < ret->w; x++)
 	    for (y = 0; y < ret->h; y++)
-		if (!index(ret, correct, x, y))
+		if (!index(ret, ret->correct, x, y))
 		    ok = FALSE;
 
-	sfree(correct);
-
 	if (ok)
 	    ret->completed = TRUE;
     }
@@ -2513,30 +2509,23 @@ static game_state *execute_move(game_state *from, char *move)
 #define COLOUR(k) ( (k)==1 ? COL_LINE : COL_DRAG )
 #define MAX4(x,y,z,w) ( max(max(x,y),max(z,w)) )
 
-static void game_size(game_params *params, game_drawstate *ds,
-                      int *x, int *y, int expand)
+static void game_compute_size(game_params *params, int tilesize,
+			      int *x, int *y)
 {
-    int tsx, tsy, ts;
-    /*
-     * Each window dimension equals the tile size times 1.5 more
-     * than the grid dimension (the border is 3/4 the width of the
-     * tiles).
-     * 
-     * We must cast to unsigned before multiplying by two, because
-     * *x might be INT_MAX.
-     */
-    tsx = 2 * (unsigned)*x / (2 * params->w + 3);
-    tsy = 2 * (unsigned)*y / (2 * params->h + 3);
-    ts = min(tsx, tsy);
-    if (expand)
-        ds->tilesize = ts;
-    else
-        ds->tilesize = min(ts, PREFERRED_TILE_SIZE);
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
 
     *x = params->w * TILE_SIZE + 2*BORDER + 1;
     *y = params->h * TILE_SIZE + 2*BORDER + 1;
 }
 
+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);
@@ -2650,11 +2639,8 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
                  float animtime, float flashtime)
 {
     int x, y;
-    unsigned char *correct;
     unsigned char *hedge, *vedge, *corners;
 
-    correct = get_correct(state);
-
     if (ui->dragged) {
         hedge = snewn(state->w*state->h, unsigned char);
         vedge = snewn(state->w*state->h, unsigned char);
@@ -2720,7 +2706,7 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
 	    if (x+1 < state->w && y+1 < state->h)
 		/* cast to prevent 2<<14 sign-extending on promotion to long */
 		c |= (unsigned long)index(state,corners,x+1,y+1) << 14;
-	    if (index(state, correct, x, y) && !flashtime)
+	    if (index(state, state->correct, x, y) && !flashtime)
 		c |= CORRECT;
 
 	    if (index(ds,ds->visible,x,y) != c) {
@@ -2756,7 +2742,6 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
     }
 
     sfree(corners);
-    sfree(correct);
 }
 
 static float game_anim_length(game_state *oldstate,
@@ -2779,7 +2764,7 @@ 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)
 {
     return TRUE;
 }
@@ -2799,7 +2784,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,
@@ -2813,7 +2797,7 @@ const struct game thegame = {
     game_changed_state,
     interpret_move,
     execute_move,
-    game_size,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
     game_colours,
     game_new_drawstate,
     game_free_drawstate,