#include <stdio.h>
#include <stdlib.h>
+#include <stdarg.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
typedef struct game_clues {
int w, h;
signed char *clues;
- signed char *tmpsoln;
+ int *tmpdsf;
int refcount;
} game_clues;
#define ERR_VERTEX 1
#define ERR_SQUARE 2
+#define ERR_SQUARE_TMP 4
struct game_state {
struct game_params p;
*/
signed char *slashval;
+ /*
+ * Stores possible v-shapes. This array is w by h in size, but
+ * not every bit of every entry is meaningful. The bits mean:
+ *
+ * - bit 0 for a square means that that square and the one to
+ * its right might form a v-shape between them
+ * - bit 1 for a square means that that square and the one to
+ * its right might form a ^-shape between them
+ * - bit 2 for a square means that that square and the one
+ * below it might form a >-shape between them
+ * - bit 3 for a square means that that square and the one
+ * below it might form a <-shape between them
+ *
+ * Any starting 1 or 3 clue rules out four bits in this array
+ * immediately; a 2 clue propagates any ruled-out bit past it
+ * (if the two squares on one side of a 2 cannot be a v-shape,
+ * then neither can the two on the other side be the same
+ * v-shape); we can rule out further bits during play using
+ * partially filled 2 clues; whenever a pair of squares is
+ * known not to be _either_ kind of v-shape, we can mark them
+ * as equivalent.
+ */
+ unsigned char *vbitmap;
+
/*
* Useful to have this information automatically passed to
* solver subroutines. (This pointer is not dynamically
ret->border = snewn(W*H, unsigned char);
ret->equiv = snewn(w*h, int);
ret->slashval = snewn(w*h, signed char);
+ ret->vbitmap = snewn(w*h, unsigned char);
return ret;
}
static void free_scratch(struct solver_scratch *sc)
{
+ sfree(sc->vbitmap);
sfree(sc->slashval);
sfree(sc->equiv);
sfree(sc->border);
}
}
+static int vbitmap_clear(int w, int h, struct solver_scratch *sc,
+ int x, int y, int vbits, char *reason, ...)
+{
+ int done_something = FALSE;
+ int vbit;
+
+ for (vbit = 1; vbit <= 8; vbit <<= 1)
+ if (vbits & sc->vbitmap[y*w+x] & vbit) {
+ done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+ if (verbose) {
+ va_list ap;
+
+ printf("ruling out %c shape at (%d,%d)-(%d,%d) (",
+ "!v^!>!!!<"[vbit], x, y,
+ x+((vbit&0x3)!=0), y+((vbit&0xC)!=0));
+
+ va_start(ap, reason);
+ vprintf(reason, ap);
+ va_end(ap);
+
+ printf(")\n");
+ }
+#endif
+ sc->vbitmap[y*w+x] &= ~vbit;
+ }
+
+ return done_something;
+}
+
/*
* Solver. Returns 0 for impossibility, 1 for success, 2 for
* ambiguity or failure to converge.
* Establish a disjoint set forest for tracking connectedness
* between grid points.
*/
- for (i = 0; i < W*H; i++)
- sc->connected[i] = i; /* initially all distinct */
+ dsf_init(sc->connected, W*H);
/*
* Establish a disjoint set forest for tracking which squares
* are known to slant in the same direction.
*/
- for (i = 0; i < w*h; i++)
- sc->equiv[i] = i; /* initially all distinct */
+ dsf_init(sc->equiv, w*h);
/*
* Clear the slashval array.
memset(sc->slashval, 0, w*h);
/*
- * Initialise the `exits' and `border' arrays. Theses is used
+ * Set up the vbitmap array. Initially all types of v are possible.
+ */
+ memset(sc->vbitmap, 0xF, w*h);
+
+ /*
+ * Initialise the `exits' and `border' arrays. These are used
* to do second-order loop avoidance: the dual of the no loops
* constraint is that every point must be somehow connected to
* the border of the grid (otherwise there would be a solid
sc->exits[y*W+x] = clues[y*W+x];
}
- /*
- * Make a one-off preliminary pass over the grid looking for
- * starting-point arrangements. The ones we need to spot are:
- *
- * - two adjacent 1s in the centre of the grid imply that each
- * one's single line points towards the other. (If either 1
- * were connected on the far side, the two squares shared
- * between the 1s would both link to the other 1 as a
- * consequence of neither linking to the first.) Thus, we
- * can fill in the four squares around them.
- *
- * - dually, two adjacent 3s imply that each one's _non_-line
- * points towards the other.
- *
- * - if the pair of 1s and 3s is not _adjacent_ but is
- * separated by one or more 2s, the reasoning still applies.
- *
- * This is more advanced than just spotting obvious starting
- * squares such as central 4s and edge 2s, so we disable it on
- * DIFF_EASY.
- *
- * (I don't like this loop; it feels grubby to me. My
- * mathematical intuition feels there ought to be some more
- * general deductive form which contains this loop as a special
- * case, but I can't bring it to mind right now.)
- */
- if (difficulty > DIFF_EASY) {
- for (y = 1; y+1 < H; y++)
- for (x = 1; x+1 < W; x++) {
- int v = clues[y*W+x], s, x2, y2, dx, dy;
- if (v != 1 && v != 3)
- continue;
- /* Slash value of the square up and left of (x,y). */
- s = (v == 1 ? +1 : -1);
-
- /* Look in each direction once. */
- for (dy = 0; dy < 2; dy++) {
- dx = 1 - dy;
- x2 = x+dx;
- y2 = y+dy;
- if (x2+1 >= W || y2+1 >= H)
- continue; /* too close to the border */
- while (x2+dx+1 < W && y2+dy+1 < H && clues[y2*W+x2] == 2)
- x2 += dx, y2 += dy;
- if (clues[y2*W+x2] == v) {
-#ifdef SOLVER_DIAGNOSTICS
- if (verbose)
- printf("found adjacent %ds at %d,%d and %d,%d\n",
- v, x, y, x2, y2);
-#endif
- fill_square(w, h, x-1, y-1, s, soln,
- sc->connected, sc);
- fill_square(w, h, x-1+dy, y-1+dx, -s, soln,
- sc->connected, sc);
- fill_square(w, h, x2, y2, s, soln,
- sc->connected, sc);
- fill_square(w, h, x2-dy, y2-dx, -s, soln,
- sc->connected, sc);
- }
- }
- }
- }
-
/*
* Repeatedly try to deduce something until we can't.
*/
}
}
+ if (done_something)
+ continue;
+
+ /*
+ * Now see what we can do with the vbitmap array. All
+ * vbitmap deductions are disabled at Easy level.
+ */
+ if (difficulty <= DIFF_EASY)
+ continue;
+
+ for (y = 0; y < h; y++)
+ for (x = 0; x < w; x++) {
+ int s, c;
+
+ /*
+ * Any line already placed in a square must rule
+ * out any type of v which contradicts it.
+ */
+ if ((s = soln[y*w+x]) != 0) {
+ if (x > 0)
+ done_something |=
+ vbitmap_clear(w, h, sc, x-1, y, (s < 0 ? 0x1 : 0x2),
+ "contradicts known edge at (%d,%d)",x,y);
+ if (x+1 < w)
+ done_something |=
+ vbitmap_clear(w, h, sc, x, y, (s < 0 ? 0x2 : 0x1),
+ "contradicts known edge at (%d,%d)",x,y);
+ if (y > 0)
+ done_something |=
+ vbitmap_clear(w, h, sc, x, y-1, (s < 0 ? 0x4 : 0x8),
+ "contradicts known edge at (%d,%d)",x,y);
+ if (y+1 < h)
+ done_something |=
+ vbitmap_clear(w, h, sc, x, y, (s < 0 ? 0x8 : 0x4),
+ "contradicts known edge at (%d,%d)",x,y);
+ }
+
+ /*
+ * If both types of v are ruled out for a pair of
+ * adjacent squares, mark them as equivalent.
+ */
+ if (x+1 < w && !(sc->vbitmap[y*w+x] & 0x3)) {
+ int n1 = y*w+x, n2 = y*w+(x+1);
+ if (dsf_canonify(sc->equiv, n1) !=
+ dsf_canonify(sc->equiv, n2)) {
+ dsf_merge(sc->equiv, n1, n2);
+ done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+ if (verbose)
+ printf("(%d,%d) and (%d,%d) must be equivalent"
+ " because both v-shapes are ruled out\n",
+ x, y, x+1, y);
+#endif
+ }
+ }
+ if (y+1 < h && !(sc->vbitmap[y*w+x] & 0xC)) {
+ int n1 = y*w+x, n2 = (y+1)*w+x;
+ if (dsf_canonify(sc->equiv, n1) !=
+ dsf_canonify(sc->equiv, n2)) {
+ dsf_merge(sc->equiv, n1, n2);
+ done_something = TRUE;
+#ifdef SOLVER_DIAGNOSTICS
+ if (verbose)
+ printf("(%d,%d) and (%d,%d) must be equivalent"
+ " because both v-shapes are ruled out\n",
+ x, y, x, y+1);
+#endif
+ }
+ }
+
+ /*
+ * The remaining work in this loop only works
+ * around non-edge clue points.
+ */
+ if (y == 0 || x == 0)
+ continue;
+ if ((c = clues[y*W+x]) < 0)
+ continue;
+
+ /*
+ * x,y marks a clue point not on the grid edge. See
+ * if this clue point allows us to rule out any v
+ * shapes.
+ */
+
+ if (c == 1) {
+ /*
+ * A 1 clue can never have any v shape pointing
+ * at it.
+ */
+ done_something |=
+ vbitmap_clear(w, h, sc, x-1, y-1, 0x5,
+ "points at 1 clue at (%d,%d)", x, y);
+ done_something |=
+ vbitmap_clear(w, h, sc, x-1, y, 0x2,
+ "points at 1 clue at (%d,%d)", x, y);
+ done_something |=
+ vbitmap_clear(w, h, sc, x, y-1, 0x8,
+ "points at 1 clue at (%d,%d)", x, y);
+ } else if (c == 3) {
+ /*
+ * A 3 clue can never have any v shape pointing
+ * away from it.
+ */
+ done_something |=
+ vbitmap_clear(w, h, sc, x-1, y-1, 0xA,
+ "points away from 3 clue at (%d,%d)", x, y);
+ done_something |=
+ vbitmap_clear(w, h, sc, x-1, y, 0x1,
+ "points away from 3 clue at (%d,%d)", x, y);
+ done_something |=
+ vbitmap_clear(w, h, sc, x, y-1, 0x4,
+ "points away from 3 clue at (%d,%d)", x, y);
+ } else if (c == 2) {
+ /*
+ * If a 2 clue has any kind of v ruled out on
+ * one side of it, the same v is ruled out on
+ * the other side.
+ */
+ done_something |=
+ vbitmap_clear(w, h, sc, x-1, y-1,
+ (sc->vbitmap[(y )*w+(x-1)] & 0x3) ^ 0x3,
+ "propagated by 2 clue at (%d,%d)", x, y);
+ done_something |=
+ vbitmap_clear(w, h, sc, x-1, y-1,
+ (sc->vbitmap[(y-1)*w+(x )] & 0xC) ^ 0xC,
+ "propagated by 2 clue at (%d,%d)", x, y);
+ done_something |=
+ vbitmap_clear(w, h, sc, x-1, y,
+ (sc->vbitmap[(y-1)*w+(x-1)] & 0x3) ^ 0x3,
+ "propagated by 2 clue at (%d,%d)", x, y);
+ done_something |=
+ vbitmap_clear(w, h, sc, x, y-1,
+ (sc->vbitmap[(y-1)*w+(x-1)] & 0xC) ^ 0xC,
+ "propagated by 2 clue at (%d,%d)", x, y);
+ }
+
+#undef CLEARBITS
+
+ }
+
} while (done_something);
/*
* Establish a disjoint set forest for tracking connectedness
* between grid points.
*/
- connected = snewn(W*H, int);
- for (i = 0; i < W*H; i++)
- connected[i] = i; /* initially all distinct */
+ connected = snew_dsf(W*H);
/*
* Prepare a list of the squares in the grid, and fill them in
state->clues->h = h;
state->clues->clues = snewn(W*H, signed char);
state->clues->refcount = 1;
- state->clues->tmpsoln = snewn(w*h, signed char);
+ state->clues->tmpdsf = snewn(W*H, int);
memset(state->clues->clues, -1, W*H);
while (*desc) {
int n = *desc++;
assert(state->clues);
if (--state->clues->refcount <= 0) {
sfree(state->clues->clues);
- sfree(state->clues->tmpsoln);
+ sfree(state->clues->tmpdsf);
sfree(state->clues);
}
sfree(state);
static int check_completion(game_state *state)
{
int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
- int x, y, err = FALSE;
- signed char *ts;
+ int i, x, y, err = FALSE;
+ int *dsf;
memset(state->errors, 0, W*H);
/*
- * An easy way to do loop checking would be by means of the
- * same dsf technique we've used elsewhere (loop over all edges
- * in the grid, joining vertices together into equivalence
- * classes when connected by an edge, and raise the alarm when
- * an edge joins two already-equivalent vertices). However, a
- * better approach is to repeatedly remove the single edge
- * connecting to any degree-1 vertex, and then see if there are
- * any edges left over; if so, precisely those edges are part
- * of loops, which means we can highlight them as errors for
- * the user.
+ * To detect loops in the grid, we iterate through each edge
+ * building up a dsf of connected components, and raise the
+ * alarm whenever we find an edge that connects two
+ * already-connected vertices.
*
- * We use the `tmpsoln' scratch space in the shared clues
+ * We use the `tmpdsf' scratch space in the shared clues
* structure, to avoid mallocing too often.
+ *
+ * When we find such an edge, we then search around the grid to
+ * find the loop it is a part of, so that we can highlight it
+ * as an error for the user. We do this by the hand-on-one-wall
+ * technique: the search will follow branches off the inside of
+ * the loop, discover they're dead ends, and unhighlight them
+ * again when returning to the actual loop.
+ *
+ * This technique guarantees that every loop it tracks will
+ * surround a disjoint area of the grid (since if an existing
+ * loop appears on the boundary of a new one, so that there are
+ * multiple possible paths that would come back to the starting
+ * point, it will pick the one that allows it to turn right
+ * most sharply and hence the one that does not re-surround the
+ * area of the previous one). Thus, the total time taken in
+ * searching round loops is linear in the grid area since every
+ * edge is visited at most twice.
*/
- ts = state->clues->tmpsoln;
- memcpy(ts, state->soln, w*h);
- for (y = 0; y < H; y++)
- for (x = 0; x < W; x++) {
- int vx = x, vy = y;
- int sx, sy;
+ dsf = state->clues->tmpdsf;
+ dsf_init(dsf, W*H);
+ for (y = 0; y < h; y++)
+ for (x = 0; x < w; x++) {
+ int i1, i2;
+
+ if (state->soln[y*w+x] == 0)
+ continue;
+ if (state->soln[y*w+x] < 0) {
+ i1 = y*W+x;
+ i2 = (y+1)*W+(x+1);
+ } else {
+ i1 = y*W+(x+1);
+ i2 = (y+1)*W+x;
+ }
+
/*
- * Every time we disconnect a vertex like this, there
- * is precisely one other vertex which might have
- * become degree 1; so we follow the trail as far as it
- * leads. This ensures that we don't have to make more
- * than one loop over the grid, because whenever a
- * degree-1 vertex comes into existence somewhere we've
- * already looked, we immediately remove it again.
- * Hence one loop over the grid is adequate; and
- * moreover, this algorithm visits every vertex at most
- * twice (once in the loop and possibly once more as a
- * result of following a trail) so it has linear time
- * in the area of the grid.
+ * Our edge connects i1 with i2. If they're already
+ * connected, flag an error. Otherwise, link them.
*/
- while (vertex_degree(w, h, ts, vx, vy, FALSE, &sx, &sy) == 1) {
- ts[sy*w+sx] = 0;
- vx = vx + 1 + (sx - vx) * 2;
- vy = vy + 1 + (sy - vy) * 2;
- }
- }
+ if (dsf_canonify(dsf, i1) == dsf_canonify(dsf, i2)) {
+ int x1, y1, x2, y2, dx, dy, dt, pass;
- /*
- * Now mark any remaining edges with ERR_SQUARE.
- */
- for (y = 0; y < h; y++)
- for (x = 0; x < w; x++)
- if (ts[y*w+x]) {
- state->errors[y*W+x] |= ERR_SQUARE;
- err = TRUE;
- }
+ err = TRUE;
+
+ /*
+ * Now search around the boundary of the loop to
+ * highlight it.
+ *
+ * We have to do this in two passes. The first
+ * time, we toggle ERR_SQUARE_TMP on each edge;
+ * this pass terminates with ERR_SQUARE_TMP set on
+ * exactly the loop edges. In the second pass, we
+ * trace round that loop again and turn
+ * ERR_SQUARE_TMP into ERR_SQUARE. We have to do
+ * this because otherwise we might cancel part of a
+ * loop highlighted in a previous iteration of the
+ * outer loop.
+ */
+
+ for (pass = 0; pass < 2; pass++) {
+
+ x1 = i1 % W;
+ y1 = i1 / W;
+ x2 = i2 % W;
+ y2 = i2 / W;
+
+ do {
+ /* Mark this edge. */
+ if (pass == 0) {
+ state->errors[min(y1,y2)*W+min(x1,x2)] ^=
+ ERR_SQUARE_TMP;
+ } else {
+ state->errors[min(y1,y2)*W+min(x1,x2)] |=
+ ERR_SQUARE;
+ state->errors[min(y1,y2)*W+min(x1,x2)] &=
+ ~ERR_SQUARE_TMP;
+ }
+
+ /*
+ * Progress to the next edge by turning as
+ * sharply right as possible. In fact we do
+ * this by facing back along the edge and
+ * turning _left_ until we see an edge we
+ * can follow.
+ */
+ dx = x1 - x2;
+ dy = y1 - y2;
+
+ for (i = 0; i < 4; i++) {
+ /*
+ * Rotate (dx,dy) to the left.
+ */
+ dt = dx; dx = dy; dy = -dt;
+
+ /*
+ * See if (x2,y2) has an edge in direction
+ * (dx,dy).
+ */
+ if (x2+dx < 0 || x2+dx >= W ||
+ y2+dy < 0 || y2+dy >= H)
+ continue; /* off the side of the grid */
+ /* In the second pass, ignore unmarked edges. */
+ if (pass == 1 &&
+ !(state->errors[(y2-(dy<0))*W+x2-(dx<0)] &
+ ERR_SQUARE_TMP))
+ continue;
+ if (state->soln[(y2-(dy<0))*w+x2-(dx<0)] ==
+ (dx==dy ? -1 : +1))
+ break;
+ }
+
+ /*
+ * In pass 0, we expect to have found
+ * _some_ edge we can follow, even if it
+ * was found by rotating all the way round
+ * and going back the way we came.
+ *
+ * In pass 1, because we're removing the
+ * mark on each edge that allows us to
+ * follow it, we expect to find _no_ edge
+ * we can follow when we've come all the
+ * way round the loop.
+ */
+ if (pass == 1 && i == 4)
+ break;
+ assert(i < 4);
+
+ /*
+ * Set x1,y1 to x2,y2, and x2,y2 to be the
+ * other end of the new edge.
+ */
+ x1 = x2;
+ y1 = y2;
+ x2 += dx;
+ y2 += dy;
+ } while (y2*W+x2 != i2);
+
+ }
+
+ } else
+ dsf_merge(dsf, i1, i2);
+ }
/*
* Now go through and check the degree of each clue vertex, and
return move;
}
+static int game_can_format_as_text_now(game_params *params)
+{
+ return TRUE;
+}
+
static char *game_text_format(game_state *state)
{
int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
ds->tilesize = tilesize;
}
-static float *game_colours(frontend *fe, game_state *state, int *ncolours)
+static float *game_colours(frontend *fe, int *ncolours)
{
float *ret = snewn(3 * NCOLOURS, float);
return 0.0F;
}
-static int game_wants_statusbar(void)
-{
- return FALSE;
-}
-
static int game_timing_state(game_state *state, game_ui *ui)
{
return TRUE;
/* Ick: fake up `ds->tilesize' for macro expansion purposes */
game_drawstate ads, *ds = &ads;
- ads.tilesize = tilesize;
+ game_set_size(dr, ds, NULL, tilesize);
/*
* Border.
#endif
const struct game thegame = {
- "Slant", "games.slant",
+ "Slant", "games.slant", "slant",
default_params,
game_fetch_preset,
decode_params,
dup_game,
free_game,
TRUE, solve_game,
- TRUE, game_text_format,
+ TRUE, game_can_format_as_text_now, game_text_format,
new_ui,
free_ui,
encode_ui,
game_anim_length,
game_flash_length,
TRUE, FALSE, game_print_size, game_print,
- game_wants_statusbar,
+ FALSE, /* wants_statusbar */
FALSE, game_timing_state,
- 0, /* mouse_priorities */
+ 0, /* flags */
};
#ifdef STANDALONE_SOLVER
#include <stdarg.h>
-/*
- * gcc -DSTANDALONE_SOLVER -o slantsolver slant.c malloc.c
- */
-
-void frontend_default_colour(frontend *fe, float *output) {}
-void draw_text(drawing *dr, int x, int y, int fonttype, int fontsize,
- int align, int colour, char *text) {}
-void draw_rect(drawing *dr, int x, int y, int w, int h, int colour) {}
-void draw_rect_outline(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 draw_circle(drawing *dr, int cx, int cy, int radius,
- int fillcolour, int outlinecolour) {}
-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) {}
-int print_mono_colour(drawing *dr, int grey) { return 0; }
-void print_line_width(drawing *dr, int width) {}
-unsigned long random_bits(random_state *state, int bits)
-{ assert(!"Shouldn't get randomness"); return 0; }
-unsigned long random_upto(random_state *state, unsigned long limit)
-{ assert(!"Shouldn't get randomness"); return 0; }
-void shuffle(void *array, int nelts, int eltsize, random_state *rs)
-{ assert(!"Shouldn't get randomness"); }
-
-void fatal(char *fmt, ...)
-{
- va_list ap;
-
- fprintf(stderr, "fatal error: ");
-
- va_start(ap, fmt);
- vfprintf(stderr, fmt, ap);
- va_end(ap);
-
- fprintf(stderr, "\n");
- exit(1);
-}
-
int main(int argc, char **argv)
{
game_params *p;
~ian / sgt-puzzles.git / blobdiff