X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/8266f3fccfd8621ac980d6209cbeac94e0a9c69b..HEAD:/slant.c diff --git a/slant.c b/slant.c index 8b4e414..2f9de52 100644 --- a/slant.c +++ b/slant.c @@ -24,6 +24,7 @@ #include #include +#include #include #include #include @@ -38,6 +39,8 @@ enum { COL_SLANT1, COL_SLANT2, COL_ERROR, + COL_CURSOR, + COL_FILLEDSQUARE, NCOLOURS }; @@ -82,7 +85,6 @@ typedef struct game_clues { #define ERR_VERTEX 1 #define ERR_SQUARE 2 -#define ERR_SQUARE_TMP 4 struct game_state { struct game_params p; @@ -273,6 +275,30 @@ struct solver_scratch { 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 * allocated by new_scratch and free_scratch.) @@ -289,11 +315,13 @@ static struct solver_scratch *new_scratch(int w, int h) 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); @@ -388,6 +416,36 @@ static void fill_square(int w, int h, int x, int y, int v, } } +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. @@ -411,15 +469,13 @@ static int slant_solve(int w, int h, const signed char *clues, * 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. @@ -427,7 +483,12 @@ static int slant_solve(int w, int h, const signed char *clues, 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 @@ -454,69 +515,6 @@ static int slant_solve(int w, int h, const signed char *clues, } /* - * 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. */ do { @@ -837,6 +835,147 @@ static int slant_solve(int w, int h, const signed char *clues, } } + 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); /* @@ -866,9 +1005,7 @@ static void slant_generate(int w, int h, signed char *soln, random_state *rs) * 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 @@ -1123,7 +1260,7 @@ static game_state *new_game(midend *me, game_params *params, char *desc) state->clues->h = h; state->clues->clues = snewn(W*H, signed char); state->clues->refcount = 1; - state->clues->tmpdsf = snewn(W*H, int); + state->clues->tmpdsf = snewn(W*H*2+W+H, int); memset(state->clues->clues, -1, W*H); while (*desc) { int n = *desc++; @@ -1217,160 +1354,92 @@ static int vertex_degree(int w, int h, signed char *soln, int x, int y, static int check_completion(game_state *state) { int w = state->p.w, h = state->p.h, W = w+1, H = h+1; - int i, x, y, err = FALSE; + int x, y, err = FALSE; int *dsf; memset(state->errors, 0, W*H); /* * 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. - * + * building up a dsf of connected components of the space + * around the edges; if there's more than one such component, + * we have a loop, and in particular we can then easily + * identify and highlight every edge forming part of a loop + * because it separates two nonequivalent regions. + * * 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. + * + * For these purposes, the grid is considered to be divided + * into diamond-shaped regions surrounding an orthogonal edge. + * This means we have W*h vertical edges and w*H horizontal + * ones; so our vertical edges are indexed in the dsf as + * (y*W+x) (0<=yclues->tmpdsf; - for (i = 0; i < W*H; i++) - dsf[i] = i; /* initially all distinct */ + dsf_init(dsf, W*h + w*H); + /* Start by identifying all the outer edges with each other. */ + for (y = 0; y < h; y++) { + dsf_merge(dsf, 0, y*W+0); + dsf_merge(dsf, 0, y*W+w); + } + for (x = 0; x < w; x++) { + dsf_merge(dsf, 0, W*h + 0*w+x); + dsf_merge(dsf, 0, W*h + h*w+x); + } + /* Now go through the actual grid. */ 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; - } - - /* - * Our edge connects i1 with i2. If they're already - * connected, flag an error. Otherwise, link them. - */ - if (dsf_canonify(dsf, i1) == dsf_canonify(dsf, i2)) { - int x1, y1, x2, y2, dx, dy, dt, pass; - - err = TRUE; - + if (state->soln[y*w+x] >= 0) { /* - * 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. + * There isn't a \ in this square, so we can unify + * the top edge with the left, and the bottom with + * the right. */ - - 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); + dsf_merge(dsf, y*W+x, W*h + y*w+x); + dsf_merge(dsf, y*W+(x+1), W*h + (y+1)*w+x); + } + if (state->soln[y*w+x] <= 0) { + /* + * There isn't a / in this square, so we can unify + * the top edge with the right, and the bottom + * with the left. + */ + dsf_merge(dsf, y*W+x, W*h + (y+1)*w+x); + dsf_merge(dsf, y*W+(x+1), W*h + y*w+x); + } + } + /* Now go through again and mark the appropriate edges as erroneous. */ + for (y = 0; y < h; y++) + for (x = 0; x < w; x++) { + int erroneous = 0; + if (state->soln[y*w+x] > 0) { + /* + * A / separates the top and left edges (which + * must already have been identified with each + * other) from the bottom and right (likewise). + * Hence it is erroneous if and only if the top + * and right edges are nonequivalent. + */ + erroneous = (dsf_canonify(dsf, y*W+(x+1)) != + dsf_canonify(dsf, W*h + y*w+x)); + } else if (state->soln[y*w+x] < 0) { + /* + * A \ separates the top and right edges (which + * must already have been identified with each + * other) from the bottom and left (likewise). + * Hence it is erroneous if and only if the top + * and left edges are nonequivalent. + */ + erroneous = (dsf_canonify(dsf, y*W+x) != + dsf_canonify(dsf, W*h + y*w+x)); + } + if (erroneous) { + state->errors[y*W+x] |= ERR_SQUARE; + err = TRUE; + } } /* @@ -1480,6 +1549,11 @@ static char *solve_game(game_state *state, game_state *currstate, 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; @@ -1522,13 +1596,20 @@ static char *game_text_format(game_state *state) return ret; } +struct game_ui { + int cur_x, cur_y, cur_visible; +}; + static game_ui *new_ui(game_state *state) { - return NULL; + game_ui *ui = snew(game_ui); + ui->cur_x = ui->cur_y = ui->cur_visible = 0; + return ui; } static void free_ui(game_ui *ui) { + sfree(ui); } static char *encode_ui(game_ui *ui) @@ -1576,6 +1657,7 @@ static void game_changed_state(game_ui *ui, game_state *oldstate, #define ERR_TR 0x00008000L #define ERR_BL 0x00010000L #define ERR_BR 0x00020000L +#define CURSOR 0x00040000L struct game_drawstate { int tilesize; @@ -1584,15 +1666,15 @@ struct game_drawstate { long *todraw; }; -static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, +static char *interpret_move(game_state *state, game_ui *ui, const game_drawstate *ds, int x, int y, int button) { int w = state->p.w, h = state->p.h; + int v; + char buf[80]; + enum { CLOCKWISE, ANTICLOCKWISE, NONE } action = NONE; if (button == LEFT_BUTTON || button == RIGHT_BUTTON) { - int v; - char buf[80]; - /* * This is an utterly awful hack which I should really sort out * by means of a proper configuration mechanism. One Slant @@ -1615,13 +1697,29 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, button = LEFT_BUTTON; } } + action = (button == LEFT_BUTTON) ? CLOCKWISE : ANTICLOCKWISE; x = FROMCOORD(x); y = FROMCOORD(y); if (x < 0 || y < 0 || x >= w || y >= h) return NULL; + } else if (IS_CURSOR_SELECT(button)) { + if (!ui->cur_visible) { + ui->cur_visible = 1; + return ""; + } + x = ui->cur_x; + y = ui->cur_y; + + action = (button == CURSOR_SELECT2) ? ANTICLOCKWISE : CLOCKWISE; + } else if (IS_CURSOR_MOVE(button)) { + move_cursor(button, &ui->cur_x, &ui->cur_y, w, h, 0); + ui->cur_visible = 1; + return ""; + } - if (button == LEFT_BUTTON) { + if (action != NONE) { + if (action == CLOCKWISE) { /* * Left-clicking cycles blank -> \ -> / -> blank. */ @@ -1695,7 +1793,8 @@ static void game_compute_size(game_params *params, int tilesize, int *x, int *y) { /* fool the macros */ - struct dummy { int tilesize; } dummy = { tilesize }, *ds = &dummy; + struct dummy { int tilesize; } dummy, *ds = &dummy; + dummy.tilesize = tilesize; *x = 2 * BORDER + params->w * TILESIZE + 1; *y = 2 * BORDER + params->h * TILESIZE + 1; @@ -1711,7 +1810,12 @@ static float *game_colours(frontend *fe, int *ncolours) { float *ret = snewn(3 * NCOLOURS, float); - frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]); + /* CURSOR colour is a background highlight. */ + game_mkhighlight(fe, ret, COL_BACKGROUND, COL_CURSOR, -1); + + ret[COL_FILLEDSQUARE * 3 + 0] = ret[COL_BACKGROUND * 3 + 0]; + ret[COL_FILLEDSQUARE * 3 + 1] = ret[COL_BACKGROUND * 3 + 1]; + ret[COL_FILLEDSQUARE * 3 + 2] = ret[COL_BACKGROUND * 3 + 2]; ret[COL_GRID * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.7F; ret[COL_GRID * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.7F; @@ -1770,7 +1874,7 @@ static void draw_clue(drawing *dr, game_drawstate *ds, if (v < 0) return; - p[0] = v + '0'; + p[0] = (char)v + '0'; p[1] = '\0'; draw_circle(dr, COORD(x), COORD(y), CLUE_RADIUS, bg >= 0 ? bg : COL_BACKGROUND, ccol); @@ -1789,7 +1893,10 @@ static void draw_tile(drawing *dr, game_drawstate *ds, game_clues *clues, clip(dr, COORD(x), COORD(y), TILESIZE, TILESIZE); draw_rect(dr, COORD(x), COORD(y), TILESIZE, TILESIZE, - (v & FLASH) ? COL_GRID : COL_BACKGROUND); + (v & FLASH) ? COL_GRID : + (v & CURSOR) ? COL_CURSOR : + (v & (BACKSLASH | FORWSLASH)) ? COL_FILLEDSQUARE : + COL_BACKGROUND); /* * Draw the grid lines. @@ -1928,6 +2035,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, ds->todraw[(y+2)*(w+2)+(x+1)] |= ERR_T_L | ERR_C_TL; } } + if (ui->cur_visible && ui->cur_x == x && ui->cur_y == y) + ds->todraw[(y+1)*(w+2)+(x+1)] |= CURSOR; } } @@ -1970,9 +2079,9 @@ static float game_flash_length(game_state *oldstate, game_state *newstate, return 0.0F; } -static int game_wants_statusbar(void) +static int game_status(game_state *state) { - return FALSE; + return state->completed ? +1 : 0; } static int game_timing_state(game_state *state, game_ui *ui) @@ -1988,8 +2097,8 @@ static void game_print_size(game_params *params, float *x, float *y) * I'll use 6mm squares by default. */ game_compute_size(params, 600, &pw, &ph); - *x = pw / 100.0; - *y = ph / 100.0; + *x = pw / 100.0F; + *y = ph / 100.0F; } static void game_print(drawing *dr, game_state *state, int tilesize) @@ -2056,7 +2165,7 @@ static void game_print(drawing *dr, game_state *state, int tilesize) #endif const struct game thegame = { - "Slant", "games.slant", + "Slant", "games.slant", "slant", default_params, game_fetch_preset, decode_params, @@ -2071,7 +2180,7 @@ const struct game thegame = { 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, @@ -2086,8 +2195,9 @@ const struct game thegame = { game_redraw, game_anim_length, game_flash_length, + game_status, TRUE, FALSE, game_print_size, game_print, - game_wants_statusbar, + FALSE, /* wants_statusbar */ FALSE, game_timing_state, 0, /* flags */ }; @@ -2181,3 +2291,5 @@ int main(int argc, char **argv) } #endif + +/* vim: set shiftwidth=4 tabstop=8: */