#define PREFERRED_TILE_SIZE 24
#define TILE_SIZE (ds->tilesize)
+#ifdef SMALL_SCREEN
+#define BORDER (2)
+#else
#define BORDER (TILE_SIZE * 3 / 4)
+#endif
#define CORNER_TOLERANCE 0.15F
#define CENTRE_TOLERANCE 0.15F
case 2: w = 11, h = 11; break;
case 3: w = 13, h = 13; break;
case 4: w = 15, h = 15; break;
+#ifndef SMALL_SCREEN
case 5: w = 17, h = 17; break;
case 6: w = 19, h = 19; break;
+#endif
default: return FALSE;
}
number->npoints--;
}
+/*
+ * Returns 0 for failure to solve due to inconsistency; 1 for
+ * success; 2 for failure to complete a solution due to either
+ * ambiguity or it being too difficult.
+ */
static int rect_solver(int w, int h, int nrects, struct numberdata *numbers,
unsigned char *hedge, unsigned char *vedge,
random_state *rs)
* Indexing of this array is by the formula
*
* overlaps[(rectindex * h + y) * w + x]
+ *
+ * A positive or zero value indicates what it sounds as if it
+ * should; -1 indicates that this square _cannot_ be part of
+ * this rectangle; and -2 indicates that it _definitely_ is
+ * (which is distinct from 1, because one might very well know
+ * that _if_ square S is part of rectangle R then it must be
+ * because R is placed in a certain position without knowing
+ * that it definitely _is_).
*/
overlaps = snewn(nrects * w * h, int);
memset(overlaps, 0, nrects * w * h * sizeof(int));
if (overlaps[(i * h + y) * w + x] >= -1) {
int j;
- assert(overlaps[(i * h + y) * w + x] > 0);
+ if (overlaps[(i * h + y) * w + x] <= 0) {
+ ret = 0; /* inconsistency */
+ goto cleanup;
+ }
#ifdef SOLVER_DIAGNOSTICS
printf("marking %d,%d as known for rect %d"
" (sole remaining number position)\n", x, y, i);
for (yy = miny; yy < maxy; yy++)
for (xx = minx; xx < maxx; xx++)
if (overlaps[(i * h + yy) * w + xx] >= -1) {
- assert(overlaps[(i * h + yy) * w + xx] > 0);
+ if (overlaps[(i * h + yy) * w + xx] <= 0) {
+ ret = 0; /* inconsistency */
+ goto cleanup;
+ }
#ifdef SOLVER_DIAGNOSTICS
printf("marking %d,%d as known for rect %d"
" (intersection of all placements)\n",
}
}
- ret = TRUE;
+ cleanup:
+ ret = 1;
for (i = 0; i < nrects; i++) {
#ifdef SOLVER_DIAGNOSTICS
printf("rect %d has %d possible placements\n",
i, rectpositions[i].n);
#endif
- assert(rectpositions[i].n > 0);
- if (rectpositions[i].n > 1) {
- ret = FALSE;
+ if (rectpositions[i].n <= 0) {
+ ret = 0; /* inconsistency */
+ } else if (rectpositions[i].n > 1) {
+ ret = 2; /* remaining uncertainty */
} else if (hedge && vedge) {
/*
* Place the rectangle in its only possible position.
ret = rect_solver(params->w, params->h, nnumbers, nd,
NULL, NULL, rs);
else
- ret = TRUE; /* allow any number placement at all */
+ ret = 1; /* allow any number placement at all */
- if (ret) {
+ if (ret == 1) {
/*
* Now place the numbers according to the solver's
* recommendations.
/*
* If we've succeeded, then terminate the loop.
*/
- if (ret)
+ if (ret == 1)
break;
}
return 0.0F;
}
-static int game_wants_statusbar(void)
-{
- return TRUE;
-}
-
static int game_timing_state(game_state *state, game_ui *ui)
{
return TRUE;
#endif
const struct game thegame = {
- "Rectangles", "games.rectangles",
+ "Rectangles", "games.rectangles", "rectangles",
default_params,
game_fetch_preset,
decode_params,
game_anim_length,
game_flash_length,
TRUE, FALSE, game_print_size, game_print,
- game_wants_statusbar,
+ TRUE, /* wants_statusbar */
FALSE, game_timing_state,
0, /* flags */
};