X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/934797c7842db7db83f8a241722d798ef589cd25..d4e7900ff493b02958f7bea92817c219fe678391:/rect.c

diff --git a/rect.c b/rect.c
index c145e9b..0d71226 100644
--- a/rect.c
+++ b/rect.c
@@ -76,6 +76,11 @@ struct game_params {
 #define TILE_SIZE 24
 #define BORDER 18
 
+#define CORNER_TOLERANCE 0.15F
+#define CENTRE_TOLERANCE 0.15F
+
+#define FLASH_TIME 0.13F
+
 #define COORD(x) ( (x) * TILE_SIZE + BORDER )
 #define FROMCOORD(x) ( ((x) - BORDER) / TILE_SIZE )
 
@@ -84,6 +89,7 @@ struct game_state {
     int *grid;			       /* contains the numbers */
     unsigned char *vedge;	       /* (w+1) x h */
     unsigned char *hedge;	       /* w x (h+1) */
+    int completed;
 };
 
 game_params *default_params(void)
@@ -170,8 +176,8 @@ 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 * params->h < 4)
-	return "Total area must be at least 4";
+    if (params->w < 2 && params->h < 2)
+	return "Grid area must be greater than one";
     return NULL;
 }
 
@@ -194,9 +200,13 @@ static struct rectlist *get_rectlist(game_params *params, int *grid)
     int nrects = 0, rectsize = 0;
 
     /*
-     * Maximum rectangle area is 1/6 of total grid size.
+     * Maximum rectangle area is 1/6 of total grid size, unless
+     * this means we can't place any rectangles at all in which
+     * case we set it to 2 at minimum.
      */
     maxarea = params->w * params->h / 6;
+    if (maxarea < 2)
+        maxarea = 2;
 
     for (rw = 1; rw <= params->w; rw++)
         for (rh = 1; rh <= params->h; rh++) {
@@ -716,6 +726,7 @@ game_state *new_game(game_params *params, char *seed)
     state->grid = snewn(area, int);
     state->vedge = snewn(area, unsigned char);
     state->hedge = snewn(area, unsigned char);
+    state->completed = FALSE;
 
     i = 0;
     while (*seed) {
@@ -756,6 +767,8 @@ game_state *dup_game(game_state *state)
     ret->hedge = snewn(state->w * state->h, unsigned char);
     ret->grid = snewn(state->w * state->h, int);
 
+    ret->completed = state->completed;
+
     memcpy(ret->grid, state->grid, state->w * state->h * sizeof(int));
     memcpy(ret->vedge, state->vedge, state->w*state->h*sizeof(unsigned char));
     memcpy(ret->hedge, state->hedge, state->w*state->h*sizeof(unsigned char));
@@ -904,29 +917,88 @@ void free_ui(game_ui *ui)
     sfree(ui);
 }
 
-int coord_round(float coord)
+void coord_round(float x, float y, int *xr, int *yr)
 {
-    int i;
-    float dist;
+    float xs, ys, xv, yv, dx, dy, dist;
+
+    /*
+     * Find the nearest square-centre.
+     */
+    xs = (float)floor(x) + 0.5F;
+    ys = (float)floor(y) + 0.5F;
 
     /*
-     * Find the nearest integer.
+     * And find the nearest grid vertex.
      */
-    i = (int)(coord + 0.5F);
+    xv = (float)floor(x + 0.5F);
+    yv = (float)floor(y + 0.5F);
 
     /*
-     * Find the distance from us to that integer.
+     * We allocate clicks in parts of the grid square to either
+     * corners, edges or square centres, as follows:
+     * 
+     *   +--+--------+--+
+     *   |  |        |  |
+     *   +--+        +--+
+     *   |   `.    ,'   |
+     *   |     +--+     |
+     *   |     |  |     |
+     *   |     +--+     |
+     *   |   ,'    `.   |
+     *   +--+        +--+
+     *   |  |        |  |
+     *   +--+--------+--+
+     * 
+     * (Not to scale!)
+     * 
+     * In other words: we measure the square distance (i.e.
+     * max(dx,dy)) from the click to the nearest corner, and if
+     * it's within CORNER_TOLERANCE then we return a corner click.
+     * We measure the square distance from the click to the nearest
+     * centre, and if that's within CENTRE_TOLERANCE we return a
+     * centre click. Failing that, we find which of the two edge
+     * centres is nearer to the click and return that edge.
      */
-    dist = fabs(coord - (float)i);
 
     /*
-     * If we're within the tolerance limit, return the edge
-     * coordinate. Otherwise, return the centre coordinate.
+     * Check for corner click.
      */
-    if (dist < 0.3F)
-        return i * 2;
-    else
-        return 1 + 2 * (int)coord;
+    dx = (float)fabs(x - xv);
+    dy = (float)fabs(y - yv);
+    dist = (dx > dy ? dx : dy);
+    if (dist < CORNER_TOLERANCE) {
+        *xr = 2 * (int)xv;
+        *yr = 2 * (int)yv;
+    } else {
+        /*
+         * Check for centre click.
+         */
+        dx = (float)fabs(x - xs);
+        dy = (float)fabs(y - ys);
+        dist = (dx > dy ? dx : dy);
+        if (dist < CENTRE_TOLERANCE) {
+            *xr = 1 + 2 * (int)xs;
+            *yr = 1 + 2 * (int)ys;
+        } else {
+            /*
+             * Failing both of those, see which edge we're closer to.
+             * Conveniently, this is simply done by testing the relative
+             * magnitude of dx and dy (which are currently distances from
+             * the square centre).
+             */
+            if (dx > dy) {
+                /* Vertical edge: x-coord of corner,
+                 * y-coord of square centre. */
+                *xr = 2 * (int)xv;
+                *yr = 1 + 2 * (int)ys;
+            } else {
+                /* Horizontal edge: x-coord of square centre,
+                 * y-coord of corner. */
+                *xr = 1 + 2 * (int)xs;
+                *yr = 2 * (int)yv;
+            }
+        }
+    }
 }
 
 static void ui_draw_rect(game_state *state, game_ui *ui,
@@ -990,8 +1062,7 @@ game_state *make_move(game_state *from, game_ui *ui, int x, int y, int button)
         return NULL;
     }
 
-    xc = coord_round(FROMCOORD((float)x));
-    yc = coord_round(FROMCOORD((float)y));
+    coord_round(FROMCOORD((float)x), FROMCOORD((float)y), &xc, &yc);
 
     if (startdrag) {
         ui->drag_start_x = xc;
@@ -1032,6 +1103,26 @@ game_state *make_move(game_state *from, game_ui *ui, int x, int y, int button)
 		free_game(ret);
 		ret = NULL;
 	    }
+
+            /*
+             * We've made a real change to the grid. Check to see
+             * if the game has been completed.
+             */
+            if (ret && !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))
+                            ok = FALSE;
+
+                sfree(correct);
+
+                if (ok)
+                    ret->completed = TRUE;
+            }
 	}
 
 	ui->drag_start_x = -1;
@@ -1136,7 +1227,7 @@ void draw_tile(frontend *fe, game_state *state, int x, int y,
     if (grid(state,x,y)) {
 	sprintf(str, "%d", grid(state,x,y));
 	draw_text(fe, cx+TILE_SIZE/2, cy+TILE_SIZE/2, FONT_VARIABLE,
-		  TILE_SIZE/3, ALIGN_HCENTRE | ALIGN_VCENTRE, COL_TEXT, str);
+		  TILE_SIZE/2, ALIGN_HCENTRE | ALIGN_VCENTRE, COL_TEXT, str);
     }
 
     /*
@@ -1216,9 +1307,15 @@ void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
     }
 
     if (!ds->started) {
+	draw_rect(fe, 0, 0,
+		  state->w * TILE_SIZE + 2*BORDER + 1,
+		  state->h * TILE_SIZE + 2*BORDER + 1, COL_BACKGROUND);
 	draw_rect(fe, COORD(0)-1, COORD(0)-1,
 		  ds->w*TILE_SIZE+3, ds->h*TILE_SIZE+3, COL_LINE);
 	ds->started = TRUE;
+	draw_update(fe, 0, 0,
+		    state->w * TILE_SIZE + 2*BORDER + 1,
+		    state->h * TILE_SIZE + 2*BORDER + 1);
     }
 
     for (x = 0; x < state->w; x++)
@@ -1233,7 +1330,7 @@ void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
 		c |= index(state,vedge,x,y) << 4;
 	    if (VRANGE(state,x,y+1))
 		c |= index(state,vedge,x,y+1) << 6;
-	    if (index(state, correct, x, y))
+	    if (index(state, correct, x, y) && !flashtime)
 		c |= CORRECT;
 
 	    if (index(ds,ds->visible,x,y) != c) {
@@ -1257,6 +1354,8 @@ float game_anim_length(game_state *oldstate, game_state *newstate)
 
 float game_flash_length(game_state *oldstate, game_state *newstate)
 {
+    if (!oldstate->completed && newstate->completed)
+        return FLASH_TIME;
     return 0.0F;
 }