X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/7126ca41b5355bd0ef94906cb87c45268bd5a823..826e0298fa89ec38199e45ff9202314882dcab23:/loopy.c diff --git a/loopy.c b/loopy.c index 39dec98..6d88e5d 100644 --- a/loopy.c +++ b/loopy.c @@ -102,6 +102,7 @@ enum { COL_HIGHLIGHT, COL_MISTAKE, COL_SATISFIED, + COL_FAINT, NCOLOURS }; @@ -133,17 +134,6 @@ enum solver_status { }; /* ------ Solver state ------ */ -typedef struct normal { - /* For each dline, store a bitmask for whether we know: - * (bit 0) at least one is YES - * (bit 1) at most one is YES */ - char *dlines; -} normal_mode_state; - -typedef struct hard { - int *linedsf; -} hard_mode_state; - typedef struct solver_state { game_state *state; enum solver_status solver_status; @@ -151,6 +141,10 @@ typedef struct solver_state { * looplen of 1 means there are no lines to a particular dot */ int *looplen; + /* Difficulty level of solver. Used by solver functions that want to + * vary their behaviour depending on the requested difficulty level. */ + int diff; + /* caches */ char *dot_yes_count; char *dot_no_count; @@ -159,8 +153,14 @@ typedef struct solver_state { char *dot_solved, *face_solved; int *dotdsf; - normal_mode_state *normal; - hard_mode_state *hard; + /* Information for Normal level deductions: + * For each dline, store a bitmask for whether we know: + * (bit 0) at least one is YES + * (bit 1) at most one is YES */ + char *dlines; + + /* Hard level information */ + int *linedsf; } solver_state; /* @@ -169,21 +169,39 @@ typedef struct solver_state { */ #define DIFFLIST(A) \ - A(EASY,Easy,e,easy_mode_deductions) \ - A(NORMAL,Normal,n,normal_mode_deductions) \ - A(HARD,Hard,h,hard_mode_deductions) -#define ENUM(upper,title,lower,fn) DIFF_ ## upper, -#define TITLE(upper,title,lower,fn) #title, -#define ENCODE(upper,title,lower,fn) #lower -#define CONFIG(upper,title,lower,fn) ":" #title -#define SOLVER_FN_DECL(upper,title,lower,fn) static int fn(solver_state *); -#define SOLVER_FN(upper,title,lower,fn) &fn, + A(EASY,Easy,e) \ + A(NORMAL,Normal,n) \ + A(TRICKY,Tricky,t) \ + A(HARD,Hard,h) +#define ENUM(upper,title,lower) DIFF_ ## upper, +#define TITLE(upper,title,lower) #title, +#define ENCODE(upper,title,lower) #lower +#define CONFIG(upper,title,lower) ":" #title enum { DIFFLIST(ENUM) DIFF_MAX }; static char const *const diffnames[] = { DIFFLIST(TITLE) }; static char const diffchars[] = DIFFLIST(ENCODE); #define DIFFCONFIG DIFFLIST(CONFIG) -DIFFLIST(SOLVER_FN_DECL) -static int (*(solver_fns[]))(solver_state *) = { DIFFLIST(SOLVER_FN) }; + +/* + * Solver routines, sorted roughly in order of computational cost. + * The solver will run the faster deductions first, and slower deductions are + * only invoked when the faster deductions are unable to make progress. + * Each function is associated with a difficulty level, so that the generated + * puzzles are solvable by applying only the functions with the chosen + * difficulty level or lower. + */ +#define SOLVERLIST(A) \ + A(trivial_deductions, DIFF_EASY) \ + A(dline_deductions, DIFF_NORMAL) \ + A(linedsf_deductions, DIFF_HARD) \ + A(loop_deductions, DIFF_EASY) +#define SOLVER_FN_DECL(fn,diff) static int fn(solver_state *); +#define SOLVER_FN(fn,diff) &fn, +#define SOLVER_DIFF(fn,diff) diff, +SOLVERLIST(SOLVER_FN_DECL) +static int (*(solver_fns[]))(solver_state *) = { SOLVERLIST(SOLVER_FN) }; +static int const solver_diffs[] = { SOLVERLIST(SOLVER_DIFF) }; +const int NUM_SOLVERS = sizeof(solver_diffs)/sizeof(*solver_diffs); struct game_params { int w, h; @@ -210,6 +228,7 @@ struct game_drawstate { int started; int tilesize; int flashing; + int *textx, *texty; char *lines; char *clue_error; char *clue_satisfied; @@ -218,8 +237,7 @@ struct game_drawstate { static char *validate_desc(game_params *params, char *desc); static int dot_order(const game_state* state, int i, char line_type); static int face_order(const game_state* state, int i, char line_type); -static solver_state *solve_game_rec(const solver_state *sstate, - int diff); +static solver_state *solve_game_rec(const solver_state *sstate); #ifdef DEBUG_CACHES static void check_caches(const solver_state* sstate); @@ -236,7 +254,10 @@ static void check_caches(const solver_state* sstate); A(Cairo,grid_new_cairo,3,4) \ A(Great-Hexagonal,grid_new_greathexagonal,3,3) \ A(Octagonal,grid_new_octagonal,3,3) \ - A(Kites,grid_new_kites,3,3) + A(Kites,grid_new_kites,3,3) \ + A(Floret,grid_new_floret,1,2) \ + A(Dodecagonal,grid_new_dodecagonal,2,2) \ + A(Great-Dodecagonal,grid_new_greatdodecagonal,2,2) #define GRID_NAME(title,fn,amin,omin) #title, #define GRID_CONFIG(title,fn,amin,omin) ":" #title @@ -283,7 +304,7 @@ static void params_generate_grid(game_params *params) ((field) &= ~(1<<(bit)), TRUE) : FALSE) #define CLUE2CHAR(c) \ - ((c < 0) ? ' ' : c + '0') + ((c < 0) ? ' ' : c < 10 ? c + '0' : c - 10 + 'A') /* ---------------------------------------------------------------------- * General struct manipulation and other straightforward code @@ -333,6 +354,7 @@ static solver_state *new_solver_state(game_state *state, int diff) { ret->state = dup_game(state); ret->solver_status = SOLVER_INCOMPLETE; + ret->diff = diff; ret->dotdsf = snew_dsf(num_dots); ret->looplen = snewn(num_dots, int); @@ -356,18 +378,16 @@ static solver_state *new_solver_state(game_state *state, int diff) { memset(ret->face_no_count, 0, num_faces); if (diff < DIFF_NORMAL) { - ret->normal = NULL; + ret->dlines = NULL; } else { - ret->normal = snew(normal_mode_state); - ret->normal->dlines = snewn(2*num_edges, char); - memset(ret->normal->dlines, 0, 2*num_edges); + ret->dlines = snewn(2*num_edges, char); + memset(ret->dlines, 0, 2*num_edges); } if (diff < DIFF_HARD) { - ret->hard = NULL; + ret->linedsf = NULL; } else { - ret->hard = snew(hard_mode_state); - ret->hard->linedsf = snew_dsf(state->game_grid->num_edges); + ret->linedsf = snew_dsf(state->game_grid->num_edges); } return ret; @@ -385,15 +405,9 @@ static void free_solver_state(solver_state *sstate) { sfree(sstate->face_yes_count); sfree(sstate->face_no_count); - if (sstate->normal) { - sfree(sstate->normal->dlines); - sfree(sstate->normal); - } - - if (sstate->hard) { - sfree(sstate->hard->linedsf); - sfree(sstate->hard); - } + /* OK, because sfree(NULL) is a no-op */ + sfree(sstate->dlines); + sfree(sstate->linedsf); sfree(sstate); } @@ -409,6 +423,7 @@ static solver_state *dup_solver_state(const solver_state *sstate) { ret->state = state = dup_game(sstate->state); ret->solver_status = sstate->solver_status; + ret->diff = sstate->diff; ret->dotdsf = snewn(num_dots, int); ret->looplen = snewn(num_dots, int); @@ -432,22 +447,20 @@ static solver_state *dup_solver_state(const solver_state *sstate) { ret->face_no_count = snewn(num_faces, char); memcpy(ret->face_no_count, sstate->face_no_count, num_faces); - if (sstate->normal) { - ret->normal = snew(normal_mode_state); - ret->normal->dlines = snewn(2*num_edges, char); - memcpy(ret->normal->dlines, sstate->normal->dlines, + if (sstate->dlines) { + ret->dlines = snewn(2*num_edges, char); + memcpy(ret->dlines, sstate->dlines, 2*num_edges); } else { - ret->normal = NULL; + ret->dlines = NULL; } - if (sstate->hard) { - ret->hard = snew(hard_mode_state); - ret->hard->linedsf = snewn(num_edges, int); - memcpy(ret->hard->linedsf, sstate->hard->linedsf, + if (sstate->linedsf) { + ret->linedsf = snewn(num_edges, int); + memcpy(ret->linedsf, sstate->linedsf, num_edges * sizeof(int)); } else { - ret->hard = NULL; + ret->linedsf = NULL; } return ret; @@ -495,6 +508,9 @@ static const game_params presets[] = { { 5, 4, DIFF_HARD, 5, NULL }, { 5, 5, DIFF_HARD, 6, NULL }, { 5, 5, DIFF_HARD, 7, NULL }, + { 3, 3, DIFF_HARD, 8, NULL }, + { 3, 3, DIFF_HARD, 9, NULL }, + { 3, 3, DIFF_HARD, 10, NULL }, #else { 7, 7, DIFF_EASY, 0, NULL }, { 10, 10, DIFF_EASY, 0, NULL }, @@ -509,6 +525,9 @@ static const game_params presets[] = { { 5, 4, DIFF_HARD, 5, NULL }, { 7, 7, DIFF_HARD, 6, NULL }, { 5, 5, DIFF_HARD, 7, NULL }, + { 5, 5, DIFF_HARD, 8, NULL }, + { 5, 4, DIFF_HARD, 9, NULL }, + { 5, 4, DIFF_HARD, 10, NULL }, #endif }; @@ -693,7 +712,7 @@ static char *validate_desc(game_params *params, char *desc) g = params->game_grid; for (; *desc; ++desc) { - if (*desc >= '0' && *desc <= '9') { + if ((*desc >= '0' && *desc <= '9') || (*desc >= 'A' && *desc <= 'Z')) { count++; continue; } @@ -820,8 +839,14 @@ static float *game_colours(frontend *fe, int *ncolours) ret[COL_FOREGROUND * 3 + 1] = 0.0F; ret[COL_FOREGROUND * 3 + 2] = 0.0F; - ret[COL_LINEUNKNOWN * 3 + 0] = 0.8F; - ret[COL_LINEUNKNOWN * 3 + 1] = 0.8F; + /* + * We want COL_LINEUNKNOWN to be a yellow which is a bit darker + * than the background. (I previously set it to 0.8,0.8,0, but + * found that this went badly with the 0.8,0.8,0.8 favoured as a + * background by the Java frontend.) + */ + ret[COL_LINEUNKNOWN * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.9F; + ret[COL_LINEUNKNOWN * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.9F; ret[COL_LINEUNKNOWN * 3 + 2] = 0.0F; ret[COL_HIGHLIGHT * 3 + 0] = 1.0F; @@ -836,6 +861,14 @@ static float *game_colours(frontend *fe, int *ncolours) ret[COL_SATISFIED * 3 + 1] = 0.0F; ret[COL_SATISFIED * 3 + 2] = 0.0F; + /* We want the faint lines to be a bit darker than the background. + * Except if the background is pretty dark already; then it ought to be a + * bit lighter. Oy vey. + */ + ret[COL_FAINT * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 0.9F; + ret[COL_FAINT * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.9F; + ret[COL_FAINT * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 0.9F; + *ncolours = NCOLOURS; return ret; } @@ -845,17 +878,22 @@ static game_drawstate *game_new_drawstate(drawing *dr, game_state *state) struct game_drawstate *ds = snew(struct game_drawstate); int num_faces = state->game_grid->num_faces; int num_edges = state->game_grid->num_edges; + int i; ds->tilesize = 0; ds->started = 0; ds->lines = snewn(num_edges, char); ds->clue_error = snewn(num_faces, char); ds->clue_satisfied = snewn(num_faces, char); + ds->textx = snewn(num_faces, int); + ds->texty = snewn(num_faces, int); ds->flashing = 0; memset(ds->lines, LINE_UNKNOWN, num_edges); memset(ds->clue_error, 0, num_faces); memset(ds->clue_satisfied, 0, num_faces); + for (i = 0; i < num_faces; i++) + ds->textx[i] = ds->texty[i] = -1; return ds; } @@ -1105,12 +1143,12 @@ static int merge_lines(solver_state *sstate, int i, int j, int inverse assert(i < sstate->state->game_grid->num_edges); assert(j < sstate->state->game_grid->num_edges); - i = edsf_canonify(sstate->hard->linedsf, i, &inv_tmp); + i = edsf_canonify(sstate->linedsf, i, &inv_tmp); inverse ^= inv_tmp; - j = edsf_canonify(sstate->hard->linedsf, j, &inv_tmp); + j = edsf_canonify(sstate->linedsf, j, &inv_tmp); inverse ^= inv_tmp; - edsf_merge(sstate->hard->linedsf, i, j, inverse); + edsf_merge(sstate->linedsf, i, j, inverse); #ifdef SHOW_WORKING if (i != j) { @@ -1292,6 +1330,7 @@ static int can_colour_face(grid *g, char* board, int face_index, int i, j; grid_face *test_face = g->faces + face_index; grid_face *starting_face, *current_face; + grid_dot *starting_dot; int transitions; int current_state, s; /* booleans: equal or not-equal to 'colour' */ int found_same_coloured_neighbour = FALSE; @@ -1336,17 +1375,39 @@ static int can_colour_face(grid *g, char* board, int face_index, * test_face->dots[i]->faces[j] * We assume dots go clockwise around the test face, * and faces go clockwise around dots. */ + + /* + * The end condition is slightly fiddly. In sufficiently strange + * degenerate grids, our test face may be adjacent to the same + * other face multiple times (typically if it's the exterior + * face). Consider this, in particular: + * + * +--+ + * | | + * +--+--+ + * | | | + * +--+--+ + * + * The bottom left face there is adjacent to the exterior face + * twice, so we can't just terminate our iteration when we reach + * the same _face_ we started at. Furthermore, we can't + * condition on having the same (i,j) pair either, because + * several (i,j) pairs identify the bottom left contiguity with + * the exterior face! We canonicalise the (i,j) pair by taking + * one step around before we set the termination tracking. + */ + i = j = 0; - starting_face = test_face->dots[0]->faces[0]; - if (starting_face == test_face) { + current_face = test_face->dots[0]->faces[0]; + if (current_face == test_face) { j = 1; - starting_face = test_face->dots[0]->faces[1]; + current_face = test_face->dots[0]->faces[1]; } - current_face = starting_face; transitions = 0; current_state = (FACE_COLOUR(current_face) == colour); - - do { + starting_dot = NULL; + starting_face = NULL; + while (TRUE) { /* Advance to next face. * Need to loop here because it might take several goes to * find it. */ @@ -1377,13 +1438,22 @@ static int can_colour_face(grid *g, char* board, int face_index, /* (i,j) are now advanced to next face */ current_face = test_face->dots[i]->faces[j]; s = (FACE_COLOUR(current_face) == colour); - if (s != current_state) { - ++transitions; - current_state = s; - if (transitions > 2) - return FALSE; /* no point in continuing */ + if (!starting_dot) { + starting_dot = test_face->dots[i]; + starting_face = current_face; + current_state = s; + } else { + if (s != current_state) { + ++transitions; + current_state = s; + if (transitions > 2) + break; + } + if (test_face->dots[i] == starting_dot && + current_face == starting_face) + break; } - } while (current_face != starting_face); + } return (transitions == 2) ? TRUE : FALSE; } @@ -1496,6 +1566,7 @@ static void add_full_clues(game_state *state, random_state *rs) face_scores = snewn(num_faces, struct face_score); for (i = 0; i < num_faces; i++) { face_scores[i].random = random_bits(rs, 31); + face_scores[i].black_score = face_scores[i].white_score = 0; } /* Colour a random, finite face white. The infinite face is implicitly @@ -1547,12 +1618,11 @@ static void add_full_clues(game_state *state, random_state *rs) struct face_score *fs_white, *fs_black; int c_lightable = count234(lightable_faces_sorted); int c_darkable = count234(darkable_faces_sorted); - if (c_lightable == 0) { - /* No more lightable faces. Because of how the algorithm - * works, there should be no more darkable faces either. */ - assert(c_darkable == 0); + if (c_lightable == 0 && c_darkable == 0) { + /* No more faces we can use at all. */ break; } + assert(c_lightable != 0 && c_darkable != 0); fs_white = (struct face_score *)index234(lightable_faces_sorted, 0); fs_black = (struct face_score *)index234(darkable_faces_sorted, 0); @@ -1713,7 +1783,7 @@ static int game_has_unique_soln(const game_state *state, int diff) solver_state *sstate_new; solver_state *sstate = new_solver_state((game_state *)state, diff); - sstate_new = solve_game_rec(sstate, diff); + sstate_new = solve_game_rec(sstate); assert(sstate_new->solver_status != SOLVER_MISTAKE); ret = (sstate_new->solver_status == SOLVER_SOLVED); @@ -1819,7 +1889,7 @@ static game_state *new_game(midend *me, game_params *params, char *desc) int i; game_state *state = snew(game_state); int empties_to_make = 0; - int n; + int n,n2; const char *dp = desc; grid *g; int num_faces, num_edges; @@ -1847,8 +1917,11 @@ static game_state *new_game(midend *me, game_params *params, char *desc) assert(*dp); n = *dp - '0'; + n2 = *dp - 'A' + 10; if (n >= 0 && n < 10) { state->clues[i] = n; + } else if (n2 >= 10 && n2 < 36) { + state->clues[i] = n2; } else { n = *dp - 'a' + 1; assert(n > 0); @@ -2027,7 +2100,7 @@ static int check_completion(game_state *state) * Easy Mode * Just implement the rules of the game. * - * Normal Mode + * Normal and Tricky Modes * For each (adjacent) pair of lines through each dot we store a bit for * whether at least one of them is on and whether at most one is on. (If we * know both or neither is on that's already stored more directly.) @@ -2164,7 +2237,7 @@ static int dline_set_opp_atleastone(solver_state *sstate, continue; /* Found opposite UNKNOWNS and they're next to each other */ opp_dline_index = dline_index_from_dot(g, d, opp); - return set_atleastone(sstate->normal->dlines, opp_dline_index); + return set_atleastone(sstate->dlines, opp_dline_index); } return FALSE; } @@ -2197,8 +2270,8 @@ static int face_setall_identical(solver_state *sstate, int face_index, continue; /* Found two UNKNOWNS */ - can1 = edsf_canonify(sstate->hard->linedsf, line1_index, &inv1); - can2 = edsf_canonify(sstate->hard->linedsf, line2_index, &inv2); + can1 = edsf_canonify(sstate->linedsf, line1_index, &inv1); + can2 = edsf_canonify(sstate->linedsf, line2_index, &inv2); if (can1 == can2 && inv1 == inv2) { solver_set_line(sstate, line1_index, line_new); solver_set_line(sstate, line2_index, line_new); @@ -2239,7 +2312,7 @@ static int parity_deductions(solver_state *sstate, { game_state *state = sstate->state; int diff = DIFF_MAX; - int *linedsf = sstate->hard->linedsf; + int *linedsf = sstate->linedsf; if (unknown_count == 2) { /* Lines are known alike/opposite, depending on inv. */ @@ -2338,7 +2411,7 @@ static int parity_deductions(solver_state *sstate, * Answer: first all squares then all dots. */ -static int easy_mode_deductions(solver_state *sstate) +static int trivial_deductions(solver_state *sstate) { int i, current_yes, current_no; game_state *state = sstate->state; @@ -2363,6 +2436,13 @@ static int easy_mode_deductions(solver_state *sstate) if (state->clues[i] < 0) continue; + /* + * This code checks whether the numeric clue on a face is so + * large as to permit all its remaining LINE_UNKNOWNs to be + * filled in as LINE_YES, or alternatively so small as to + * permit them all to be filled in as LINE_NO. + */ + if (state->clues[i] < current_yes) { sstate->solver_status = SOLVER_MISTAKE; return DIFF_EASY; @@ -2384,6 +2464,57 @@ static int easy_mode_deductions(solver_state *sstate) sstate->face_solved[i] = TRUE; continue; } + + if (f->order - state->clues[i] == current_no + 1 && + f->order - current_yes - current_no > 2) { + /* + * One small refinement to the above: we also look for any + * adjacent pair of LINE_UNKNOWNs around the face with + * some LINE_YES incident on it from elsewhere. If we find + * one, then we know that pair of LINE_UNKNOWNs can't + * _both_ be LINE_YES, and hence that pushes us one line + * closer to being able to determine all the rest. + */ + int j, k, e1, e2, e, d; + + for (j = 0; j < f->order; j++) { + e1 = f->edges[j] - g->edges; + e2 = f->edges[j+1 < f->order ? j+1 : 0] - g->edges; + + if (g->edges[e1].dot1 == g->edges[e2].dot1 || + g->edges[e1].dot1 == g->edges[e2].dot2) { + d = g->edges[e1].dot1 - g->dots; + } else { + assert(g->edges[e1].dot2 == g->edges[e2].dot1 || + g->edges[e1].dot2 == g->edges[e2].dot2); + d = g->edges[e1].dot2 - g->dots; + } + + if (state->lines[e1] == LINE_UNKNOWN && + state->lines[e2] == LINE_UNKNOWN) { + for (k = 0; k < g->dots[d].order; k++) { + int e = g->dots[d].edges[k] - g->edges; + if (state->lines[e] == LINE_YES) + goto found; /* multi-level break */ + } + } + } + continue; + + found: + /* + * If we get here, we've found such a pair of edges, and + * they're e1 and e2. + */ + for (j = 0; j < f->order; j++) { + e = f->edges[j] - g->edges; + if (state->lines[e] == LINE_UNKNOWN && e != e1 && e != e2) { + int r = solver_set_line(sstate, e, LINE_YES); + assert(r); + diff = min(diff, DIFF_EASY); + } + } + } } check_caches(sstate); @@ -2433,11 +2564,11 @@ static int easy_mode_deductions(solver_state *sstate) return diff; } -static int normal_mode_deductions(solver_state *sstate) +static int dline_deductions(solver_state *sstate) { game_state *state = sstate->state; grid *g = state->game_grid; - char *dlines = sstate->normal->dlines; + char *dlines = sstate->dlines; int i; int diff = DIFF_MAX; @@ -2482,7 +2613,7 @@ static int normal_mode_deductions(solver_state *sstate) * on that. We check this with an assertion, in case someone decides to * make a grid which has larger faces than this. Note, this algorithm * could get quite expensive if there are many large faces. */ -#define MAX_FACE_SIZE 8 +#define MAX_FACE_SIZE 12 for (i = 0; i < g->num_faces; i++) { int maxs[MAX_FACE_SIZE][MAX_FACE_SIZE]; @@ -2583,29 +2714,34 @@ static int normal_mode_deductions(solver_state *sstate) diff = min(diff, DIFF_EASY); } - /* Now see if we can make dline deduction for edges{j,j+1} */ - e = f->edges[k]; - if (state->lines[e - g->edges] != LINE_UNKNOWN) - /* Only worth doing this for an UNKNOWN,UNKNOWN pair. - * Dlines where one of the edges is known, are handled in the - * dot-deductions */ - continue; - - dline_index = dline_index_from_face(g, f, k); - k++; - if (k >= N) k = 0; - - /* minimum YESs in the complement of this dline */ - if (mins[k][j] > clue - 2) { - /* Adding 2 YESs would break the clue */ - if (set_atmostone(dlines, dline_index)) - diff = min(diff, DIFF_NORMAL); - } - /* maximum YESs in the complement of this dline */ - if (maxs[k][j] < clue) { - /* Adding 2 NOs would mean not enough YESs */ - if (set_atleastone(dlines, dline_index)) - diff = min(diff, DIFF_NORMAL); + /* More advanced deduction that allows propagation along diagonal + * chains of faces connected by dots, for example, 3-2-...-2-3 + * in square grids. */ + if (sstate->diff >= DIFF_TRICKY) { + /* Now see if we can make dline deduction for edges{j,j+1} */ + e = f->edges[k]; + if (state->lines[e - g->edges] != LINE_UNKNOWN) + /* Only worth doing this for an UNKNOWN,UNKNOWN pair. + * Dlines where one of the edges is known, are handled in the + * dot-deductions */ + continue; + + dline_index = dline_index_from_face(g, f, k); + k++; + if (k >= N) k = 0; + + /* minimum YESs in the complement of this dline */ + if (mins[k][j] > clue - 2) { + /* Adding 2 YESs would break the clue */ + if (set_atmostone(dlines, dline_index)) + diff = min(diff, DIFF_NORMAL); + } + /* maximum YESs in the complement of this dline */ + if (maxs[k][j] < clue) { + /* Adding 2 NOs would mean not enough YESs */ + if (set_atleastone(dlines, dline_index)) + diff = min(diff, DIFF_NORMAL); + } } } } @@ -2699,48 +2835,54 @@ static int normal_mode_deductions(solver_state *sstate) } } - /* If we have atleastone set for this dline, infer - * atmostone for each "opposite" dline (that is, each - * dline without edges in common with this one). - * Again, this test is only worth doing if both these - * lines are UNKNOWN. For if one of these lines were YES, - * the (yes == 1) test above would kick in instead. */ - if (is_atleastone(dlines, dline_index)) { - int opp; - for (opp = 0; opp < N; opp++) { - int opp_dline_index; - if (opp == j || opp == j+1 || opp == j-1) - continue; - if (j == 0 && opp == N-1) - continue; - if (j == N-1 && opp == 0) - continue; - opp_dline_index = dline_index_from_dot(g, d, opp); - if (set_atmostone(dlines, opp_dline_index)) - diff = min(diff, DIFF_NORMAL); - } - - if (yes == 0 && is_atmostone(dlines, dline_index)) { - /* This dline has *exactly* one YES and there are no - * other YESs. This allows more deductions. */ - if (unknown == 3) { - /* Third unknown must be YES */ - for (opp = 0; opp < N; opp++) { - int opp_index; - if (opp == j || opp == k) - continue; - opp_index = d->edges[opp] - g->edges; - if (state->lines[opp_index] == LINE_UNKNOWN) { - solver_set_line(sstate, opp_index, LINE_YES); - diff = min(diff, DIFF_EASY); + /* More advanced deduction that allows propagation along diagonal + * chains of faces connected by dots, for example: 3-2-...-2-3 + * in square grids. */ + if (sstate->diff >= DIFF_TRICKY) { + /* If we have atleastone set for this dline, infer + * atmostone for each "opposite" dline (that is, each + * dline without edges in common with this one). + * Again, this test is only worth doing if both these + * lines are UNKNOWN. For if one of these lines were YES, + * the (yes == 1) test above would kick in instead. */ + if (is_atleastone(dlines, dline_index)) { + int opp; + for (opp = 0; opp < N; opp++) { + int opp_dline_index; + if (opp == j || opp == j+1 || opp == j-1) + continue; + if (j == 0 && opp == N-1) + continue; + if (j == N-1 && opp == 0) + continue; + opp_dline_index = dline_index_from_dot(g, d, opp); + if (set_atmostone(dlines, opp_dline_index)) + diff = min(diff, DIFF_NORMAL); + } + if (yes == 0 && is_atmostone(dlines, dline_index)) { + /* This dline has *exactly* one YES and there are no + * other YESs. This allows more deductions. */ + if (unknown == 3) { + /* Third unknown must be YES */ + for (opp = 0; opp < N; opp++) { + int opp_index; + if (opp == j || opp == k) + continue; + opp_index = d->edges[opp] - g->edges; + if (state->lines[opp_index] == LINE_UNKNOWN) { + solver_set_line(sstate, opp_index, + LINE_YES); + diff = min(diff, DIFF_EASY); + } } + } else if (unknown == 4) { + /* Exactly one of opposite UNKNOWNS is YES. We've + * already set atmostone, so set atleastone as + * well. + */ + if (dline_set_opp_atleastone(sstate, d, j)) + diff = min(diff, DIFF_NORMAL); } - } else if (unknown == 4) { - /* Exactly one of opposite UNKNOWNS is YES. We've - * already set atmostone, so set atleastone as well. - */ - if (dline_set_opp_atleastone(sstate, d, j)) - diff = min(diff, DIFF_NORMAL); } } } @@ -2749,11 +2891,11 @@ static int normal_mode_deductions(solver_state *sstate) return diff; } -static int hard_mode_deductions(solver_state *sstate) +static int linedsf_deductions(solver_state *sstate) { game_state *state = sstate->state; grid *g = state->game_grid; - char *dlines = sstate->normal->dlines; + char *dlines = sstate->dlines; int i; int diff = DIFF_MAX; int diff_tmp; @@ -2823,8 +2965,8 @@ static int hard_mode_deductions(solver_state *sstate) if (state->lines[line2_index] != LINE_UNKNOWN) continue; /* Infer dline flags from linedsf */ - can1 = edsf_canonify(sstate->hard->linedsf, line1_index, &inv1); - can2 = edsf_canonify(sstate->hard->linedsf, line2_index, &inv2); + can1 = edsf_canonify(sstate->linedsf, line1_index, &inv1); + can2 = edsf_canonify(sstate->linedsf, line2_index, &inv2); if (can1 == can2 && inv1 != inv2) { /* These are opposites, so set dline atmostone/atleastone */ if (set_atmostone(dlines, dline_index)) @@ -2858,7 +3000,7 @@ static int hard_mode_deductions(solver_state *sstate) for (i = 0; i < g->num_edges; i++) { int can, inv; enum line_state s; - can = edsf_canonify(sstate->hard->linedsf, i, &inv); + can = edsf_canonify(sstate->linedsf, i, &inv); if (can == i) continue; s = sstate->state->lines[can]; @@ -3031,52 +3173,59 @@ static int loop_deductions(solver_state *sstate) /* This will return a dynamically allocated solver_state containing the (more) * solved grid */ -static solver_state *solve_game_rec(const solver_state *sstate_start, - int diff) +static solver_state *solve_game_rec(const solver_state *sstate_start) { - solver_state *sstate, *sstate_saved; - int solver_progress; - game_state *state; + solver_state *sstate; - /* Indicates which solver we should call next. This is a sensible starting - * point */ - int current_solver = DIFF_EASY, next_solver; + /* Index of the solver we should call next. */ + int i = 0; + + /* As a speed-optimisation, we avoid re-running solvers that we know + * won't make any progress. This happens when a high-difficulty + * solver makes a deduction that can only help other high-difficulty + * solvers. + * For example: if a new 'dline' flag is set by dline_deductions, the + * trivial_deductions solver cannot do anything with this information. + * If we've already run the trivial_deductions solver (because it's + * earlier in the list), there's no point running it again. + * + * Therefore: if a solver is earlier in the list than "threshold_index", + * we don't bother running it if it's difficulty level is less than + * "threshold_diff". + */ + int threshold_diff = 0; + int threshold_index = 0; + sstate = dup_solver_state(sstate_start); - /* Cache the values of some variables for readability */ - state = sstate->state; - - sstate_saved = NULL; - - solver_progress = FALSE; - check_caches(sstate); - do { + while (i < NUM_SOLVERS) { if (sstate->solver_status == SOLVER_MISTAKE) return sstate; - - next_solver = solver_fns[current_solver](sstate); - - if (next_solver == DIFF_MAX) { - if (current_solver < diff && current_solver + 1 < DIFF_MAX) { - /* Try next beefier solver */ - next_solver = current_solver + 1; - } else { - next_solver = loop_deductions(sstate); - } - } - if (sstate->solver_status == SOLVER_SOLVED || sstate->solver_status == SOLVER_AMBIGUOUS) { -/* fprintf(stderr, "Solver completed\n"); */ + /* solver finished */ break; } - /* Once we've looped over all permitted solvers then the loop - * deductions without making any progress, we'll exit this while loop */ - current_solver = next_solver; - } while (current_solver < DIFF_MAX); + if ((solver_diffs[i] >= threshold_diff || i >= threshold_index) + && solver_diffs[i] <= sstate->diff) { + /* current_solver is eligible, so use it */ + int next_diff = solver_fns[i](sstate); + if (next_diff != DIFF_MAX) { + /* solver made progress, so use new thresholds and + * start again at top of list. */ + threshold_diff = next_diff; + threshold_index = i; + i = 0; + continue; + } + } + /* current_solver is ineligible, or failed to make progress, so + * go to the next solver in the list */ + i++; + } if (sstate->solver_status == SOLVER_SOLVED || sstate->solver_status == SOLVER_AMBIGUOUS) { @@ -3096,7 +3245,7 @@ static char *solve_game(game_state *state, game_state *currstate, solver_state *sstate, *new_sstate; sstate = new_solver_state(state, DIFF_MAX); - new_sstate = solve_game_rec(sstate, DIFF_MAX); + new_sstate = solve_game_rec(sstate); if (new_sstate->solver_status == SOLVER_SOLVED) { soln = encode_solve_move(new_sstate->state); @@ -3155,6 +3304,10 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, button_char = 'y'; break; case LINE_YES: +#ifdef STYLUS_BASED + button_char = 'n'; + break; +#endif case LINE_NO: button_char = 'u'; break; @@ -3169,6 +3322,10 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, button_char = 'n'; break; case LINE_NO: +#ifdef STYLUS_BASED + button_char = 'y'; + break; +#endif case LINE_YES: button_char = 'u'; break; @@ -3197,6 +3354,8 @@ static game_state *execute_move(game_state *state, char *move) while (*move) { i = atoi(move); + if (i < 0 || i >= newstate->game_grid->num_edges) + goto fail; move += strspn(move, "1234567890"); switch (*(move++)) { case 'y': @@ -3245,251 +3404,484 @@ static void grid_to_screen(const game_drawstate *ds, const grid *g, /* Returns (into x,y) position of centre of face for rendering the text clue. */ static void face_text_pos(const game_drawstate *ds, const grid *g, - const grid_face *f, int *x, int *y) + const grid_face *f, int *xret, int *yret) { - int i; + int x, y, x0, y0, x1, y1, xbest, ybest, i, shift; + long bestdist; + int faceindex = f - g->faces; - /* Simplest solution is the centroid. Might not work in some cases. */ + /* + * Return the cached position for this face, if we've already + * worked it out. + */ + if (ds->textx[faceindex] >= 0) { + *xret = ds->textx[faceindex]; + *yret = ds->texty[faceindex]; + return; + } - /* Another algorithm to look into: - * Find the midpoints of the sides, find the bounding-box, - * then take the centre of that. */ + /* + * Otherwise, try to find the point in the polygon with the + * maximum distance to any edge or corner. + * + * Start by working out the face's bounding box, in grid + * coordinates. + */ + x0 = x1 = f->dots[0]->x; + y0 = y1 = f->dots[0]->y; + for (i = 1; i < f->order; i++) { + if (x0 > f->dots[i]->x) x0 = f->dots[i]->x; + if (x1 < f->dots[i]->x) x1 = f->dots[i]->x; + if (y0 > f->dots[i]->y) y0 = f->dots[i]->y; + if (y1 < f->dots[i]->y) y1 = f->dots[i]->y; + } - /* Best solution probably involves incentres (inscribed circles) */ + /* + * If the grid is at excessive resolution, decide on a scaling + * factor to bring it within reasonable bounds so we don't have to + * think too hard or suffer integer overflow. + */ + shift = 0; + while (x1 - x0 > 128 || y1 - y0 > 128) { + shift++; + x0 >>= 1; + x1 >>= 1; + y0 >>= 1; + y1 >>= 1; + } - int sx = 0, sy = 0; /* sums */ - for (i = 0; i < f->order; i++) { - grid_dot *d = f->dots[i]; - sx += d->x; - sy += d->y; + /* + * Now iterate over every point in that bounding box. + */ + xbest = ybest = -1; + bestdist = -1; + for (y = y0; y <= y1; y++) { + for (x = x0; x <= x1; x++) { + /* + * First, disqualify the point if it's not inside the + * polygon, which we work out by counting the edges to the + * right of the point. (For tiebreaking purposes when + * edges start or end on our y-coordinate or go right + * through it, we consider our point to be offset by a + * small _positive_ epsilon in both the x- and + * y-direction.) + */ + int in = 0; + for (i = 0; i < f->order; i++) { + int xs = f->edges[i]->dot1->x >> shift; + int xe = f->edges[i]->dot2->x >> shift; + int ys = f->edges[i]->dot1->y >> shift; + int ye = f->edges[i]->dot2->y >> shift; + if ((y >= ys && y < ye) || (y >= ye && y < ys)) { + /* + * The line goes past our y-position. Now we need + * to know if its x-coordinate when it does so is + * to our right. + * + * The x-coordinate in question is mathematically + * (y - ys) * (xe - xs) / (ye - ys), and we want + * to know whether (x - xs) >= that. Of course we + * avoid the division, so we can work in integers; + * to do this we must multiply both sides of the + * inequality by ye - ys, which means we must + * first check that's not negative. + */ + int num = xe - xs, denom = ye - ys; + if (denom < 0) { + num = -num; + denom = -denom; + } + if ((x - xs) * denom >= (y - ys) * num) + in ^= 1; + } + } + + if (in) { + long mindist = LONG_MAX; + + /* + * This point is inside the polygon, so now we check + * its minimum distance to every edge and corner. + * First the corners ... + */ + for (i = 0; i < f->order; i++) { + int xp = f->dots[i]->x >> shift; + int yp = f->dots[i]->y >> shift; + int dx = x - xp, dy = y - yp; + long dist = (long)dx*dx + (long)dy*dy; + if (mindist > dist) + mindist = dist; + } + + /* + * ... and now also check the perpendicular distance + * to every edge, if the perpendicular lies between + * the edge's endpoints. + */ + for (i = 0; i < f->order; i++) { + int xs = f->edges[i]->dot1->x >> shift; + int xe = f->edges[i]->dot2->x >> shift; + int ys = f->edges[i]->dot1->y >> shift; + int ye = f->edges[i]->dot2->y >> shift; + + /* + * If s and e are our endpoints, and p our + * candidate circle centre, the foot of a + * perpendicular from p to the line se lies + * between s and e if and only if (p-s).(e-s) lies + * strictly between 0 and (e-s).(e-s). + */ + int edx = xe - xs, edy = ye - ys; + int pdx = x - xs, pdy = y - ys; + long pde = (long)pdx * edx + (long)pdy * edy; + long ede = (long)edx * edx + (long)edy * edy; + if (0 < pde && pde < ede) { + /* + * Yes, the nearest point on this edge is + * closer than either endpoint, so we must + * take it into account by measuring the + * perpendicular distance to the edge and + * checking its square against mindist. + */ + + long pdre = (long)pdx * edy - (long)pdy * edx; + long sqlen = pdre * pdre / ede; + + if (mindist > sqlen) + mindist = sqlen; + } + } + + /* + * Right. Now we know the biggest circle around this + * point, so we can check it against bestdist. + */ + if (bestdist < mindist) { + bestdist = mindist; + xbest = x; + ybest = y; + } + } + } } - sx /= f->order; - sy /= f->order; + + assert(bestdist >= 0); /* convert to screen coordinates */ - grid_to_screen(ds, g, sx, sy, x, y); + grid_to_screen(ds, g, xbest << shift, ybest << shift, + &ds->textx[faceindex], &ds->texty[faceindex]); + + *xret = ds->textx[faceindex]; + *yret = ds->texty[faceindex]; } -static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, - game_state *state, int dir, game_ui *ui, - float animtime, float flashtime) +static void face_text_bbox(game_drawstate *ds, grid *g, grid_face *f, + int *x, int *y, int *w, int *h) { - grid *g = state->game_grid; - int border = BORDER(ds->tilesize); - int i, n; - char c[2]; - int line_colour, flash_changed; - int clue_mistake; - int clue_satisfied; + int xx, yy; + face_text_pos(ds, g, f, &xx, &yy); - if (!ds->started) { - /* - * The initial contents of the window are not guaranteed and - * can vary with front ends. To be on the safe side, all games - * should start by drawing a big background-colour rectangle - * covering the whole window. - */ - int grid_width = g->highest_x - g->lowest_x; - int grid_height = g->highest_y - g->lowest_y; - int w = grid_width * ds->tilesize / g->tilesize; - int h = grid_height * ds->tilesize / g->tilesize; - draw_rect(dr, 0, 0, w + 2 * border + 1, h + 2 * border + 1, - COL_BACKGROUND); + /* There seems to be a certain amount of trial-and-error involved + * in working out the correct bounding-box for the text. */ - /* Draw clues */ - for (i = 0; i < g->num_faces; i++) { - grid_face *f; - int x, y; + *x = xx - ds->tilesize/4 - 1; + *y = yy - ds->tilesize/4 - 3; + *w = ds->tilesize/2 + 2; + *h = ds->tilesize/2 + 5; +} - c[0] = CLUE2CHAR(state->clues[i]); - c[1] = '\0'; - f = g->faces + i; - face_text_pos(ds, g, f, &x, &y); - draw_text(dr, x, y, FONT_VARIABLE, ds->tilesize/2, - ALIGN_VCENTRE | ALIGN_HCENTRE, COL_FOREGROUND, c); - } - draw_update(dr, 0, 0, w + 2 * border, h + 2 * border); +static void game_redraw_clue(drawing *dr, game_drawstate *ds, + game_state *state, int i) +{ + grid *g = state->game_grid; + grid_face *f = g->faces + i; + int x, y; + char c[3]; + + if (state->clues[i] < 10) { + c[0] = CLUE2CHAR(state->clues[i]); + c[1] = '\0'; + } else { + sprintf(c, "%d", state->clues[i]); } - if (flashtime > 0 && - (flashtime <= FLASH_TIME/3 || - flashtime >= FLASH_TIME*2/3)) { - flash_changed = !ds->flashing; - ds->flashing = TRUE; + face_text_pos(ds, g, f, &x, &y); + draw_text(dr, x, y, + FONT_VARIABLE, ds->tilesize/2, + ALIGN_VCENTRE | ALIGN_HCENTRE, + ds->clue_error[i] ? COL_MISTAKE : + ds->clue_satisfied[i] ? COL_SATISFIED : COL_FOREGROUND, c); +} + +static void edge_bbox(game_drawstate *ds, grid *g, grid_edge *e, + int *x, int *y, int *w, int *h) +{ + int x1 = e->dot1->x; + int y1 = e->dot1->y; + int x2 = e->dot2->x; + int y2 = e->dot2->y; + int xmin, xmax, ymin, ymax; + + grid_to_screen(ds, g, x1, y1, &x1, &y1); + grid_to_screen(ds, g, x2, y2, &x2, &y2); + /* Allow extra margin for dots, and thickness of lines */ + xmin = min(x1, x2) - 2; + xmax = max(x1, x2) + 2; + ymin = min(y1, y2) - 2; + ymax = max(y1, y2) + 2; + + *x = xmin; + *y = ymin; + *w = xmax - xmin + 1; + *h = ymax - ymin + 1; +} + +static void dot_bbox(game_drawstate *ds, grid *g, grid_dot *d, + int *x, int *y, int *w, int *h) +{ + int x1, y1; + + grid_to_screen(ds, g, d->x, d->y, &x1, &y1); + + *x = x1 - 2; + *y = y1 - 2; + *w = 5; + *h = 5; +} + +static const int loopy_line_redraw_phases[] = { + COL_FAINT, COL_LINEUNKNOWN, COL_FOREGROUND, COL_HIGHLIGHT, COL_MISTAKE +}; +#define NPHASES lenof(loopy_line_redraw_phases) + +static void game_redraw_line(drawing *dr, game_drawstate *ds, + game_state *state, int i, int phase) +{ + grid *g = state->game_grid; + grid_edge *e = g->edges + i; + int x1, x2, y1, y2; + int xmin, ymin, xmax, ymax; + int line_colour; + + if (state->line_errors[i]) + line_colour = COL_MISTAKE; + else if (state->lines[i] == LINE_UNKNOWN) + line_colour = COL_LINEUNKNOWN; + else if (state->lines[i] == LINE_NO) + line_colour = COL_FAINT; + else if (ds->flashing) + line_colour = COL_HIGHLIGHT; + else + line_colour = COL_FOREGROUND; + if (line_colour != loopy_line_redraw_phases[phase]) + return; + + /* Convert from grid to screen coordinates */ + grid_to_screen(ds, g, e->dot1->x, e->dot1->y, &x1, &y1); + grid_to_screen(ds, g, e->dot2->x, e->dot2->y, &x2, &y2); + + xmin = min(x1, x2); + xmax = max(x1, x2); + ymin = min(y1, y2); + ymax = max(y1, y2); + + if (line_colour == COL_FAINT) { + static int draw_faint_lines = -1; + if (draw_faint_lines < 0) { + char *env = getenv("LOOPY_FAINT_LINES"); + draw_faint_lines = (!env || (env[0] == 'y' || + env[0] == 'Y')); + } + if (draw_faint_lines) + draw_line(dr, x1, y1, x2, y2, line_colour); } else { - flash_changed = ds->flashing; - ds->flashing = FALSE; + draw_thick_line(dr, 3.0, + x1 + 0.5, y1 + 0.5, + x2 + 0.5, y2 + 0.5, + line_colour); } +} + +static void game_redraw_dot(drawing *dr, game_drawstate *ds, + game_state *state, int i) +{ + grid *g = state->game_grid; + grid_dot *d = g->dots + i; + int x, y; - /* Some platforms may perform anti-aliasing, which may prevent clean - * repainting of lines when the colour is changed. - * If a line needs to be over-drawn in a different colour, erase a - * bounding-box around the line, then flag all nearby objects for redraw. + grid_to_screen(ds, g, d->x, d->y, &x, &y); + draw_circle(dr, x, y, 2, COL_FOREGROUND, COL_FOREGROUND); +} + +static int boxes_intersect(int x0, int y0, int w0, int h0, + int x1, int y1, int w1, int h1) +{ + /* + * Two intervals intersect iff neither is wholly on one side of + * the other. Two boxes intersect iff their horizontal and + * vertical intervals both intersect. */ - if (ds->started) { - const char redraw_flag = (char)(1<<7); + return (x0 < x1+w1 && x1 < x0+w0 && y0 < y1+h1 && y1 < y0+h0); +} + +static void game_redraw_in_rect(drawing *dr, game_drawstate *ds, + game_state *state, int x, int y, int w, int h) +{ + grid *g = state->game_grid; + int i, phase; + int bx, by, bw, bh; + + clip(dr, x, y, w, h); + draw_rect(dr, x, y, w, h, COL_BACKGROUND); + + for (i = 0; i < g->num_faces; i++) { + face_text_bbox(ds, g, &g->faces[i], &bx, &by, &bw, &bh); + if (boxes_intersect(x, y, w, h, bx, by, bw, bh)) + game_redraw_clue(dr, ds, state, i); + } + for (phase = 0; phase < NPHASES; phase++) { for (i = 0; i < g->num_edges; i++) { - char prev_ds = (ds->lines[i] & ~redraw_flag); - char new_ds = state->lines[i]; - if (state->line_errors[i]) - new_ds = DS_LINE_ERROR; - - /* If we're changing state, AND - * the previous state was a coloured line */ - if ((prev_ds != new_ds) && (prev_ds != LINE_NO)) { - grid_edge *e = g->edges + i; - int x1 = e->dot1->x; - int y1 = e->dot1->y; - int x2 = e->dot2->x; - int y2 = e->dot2->y; - int xmin, xmax, ymin, ymax; - int j; - grid_to_screen(ds, g, x1, y1, &x1, &y1); - grid_to_screen(ds, g, x2, y2, &x2, &y2); - /* Allow extra margin for dots, and thickness of lines */ - xmin = min(x1, x2) - 2; - xmax = max(x1, x2) + 2; - ymin = min(y1, y2) - 2; - ymax = max(y1, y2) + 2; - /* For testing, I find it helpful to change COL_BACKGROUND - * to COL_SATISFIED here. */ - draw_rect(dr, xmin, ymin, xmax - xmin + 1, ymax - ymin + 1, - COL_BACKGROUND); - draw_update(dr, xmin, ymin, xmax - xmin + 1, ymax - ymin + 1); - - /* Mark nearby lines for redraw */ - for (j = 0; j < e->dot1->order; j++) - ds->lines[e->dot1->edges[j] - g->edges] |= redraw_flag; - for (j = 0; j < e->dot2->order; j++) - ds->lines[e->dot2->edges[j] - g->edges] |= redraw_flag; - /* Mark nearby clues for redraw. Use a value that is - * neither TRUE nor FALSE for this. */ - if (e->face1) - ds->clue_error[e->face1 - g->faces] = 2; - if (e->face2) - ds->clue_error[e->face2 - g->faces] = 2; - } + edge_bbox(ds, g, &g->edges[i], &bx, &by, &bw, &bh); + if (boxes_intersect(x, y, w, h, bx, by, bw, bh)) + game_redraw_line(dr, ds, state, i, phase); } } + for (i = 0; i < g->num_dots; i++) { + dot_bbox(ds, g, &g->dots[i], &bx, &by, &bw, &bh); + if (boxes_intersect(x, y, w, h, bx, by, bw, bh)) + game_redraw_dot(dr, ds, state, i); + } - /* Redraw clue colours if necessary */ - for (i = 0; i < g->num_faces; i++) { - grid_face *f = g->faces + i; - int sides = f->order; - int j; - n = state->clues[i]; - if (n < 0) - continue; + unclip(dr); + draw_update(dr, x, y, w, h); +} - c[0] = CLUE2CHAR(n); - c[1] = '\0'; +static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, + game_state *state, int dir, game_ui *ui, + float animtime, float flashtime) +{ +#define REDRAW_OBJECTS_LIMIT 16 /* Somewhat arbitrary tradeoff */ - clue_mistake = (face_order(state, i, LINE_YES) > n || - face_order(state, i, LINE_NO ) > (sides-n)); + grid *g = state->game_grid; + int border = BORDER(ds->tilesize); + int i; + int flash_changed; + int redraw_everything = FALSE; - clue_satisfied = (face_order(state, i, LINE_YES) == n && - face_order(state, i, LINE_NO ) == (sides-n)); + int edges[REDRAW_OBJECTS_LIMIT], nedges = 0; + int faces[REDRAW_OBJECTS_LIMIT], nfaces = 0; - if (clue_mistake != ds->clue_error[i] - || clue_satisfied != ds->clue_satisfied[i]) { - int x, y; - face_text_pos(ds, g, f, &x, &y); - /* There seems to be a certain amount of trial-and-error - * involved in working out the correct bounding-box for - * the text. */ - draw_rect(dr, x - ds->tilesize/4 - 1, y - ds->tilesize/4 - 3, - ds->tilesize/2 + 2, ds->tilesize/2 + 5, - COL_BACKGROUND); - draw_text(dr, x, y, - FONT_VARIABLE, ds->tilesize/2, - ALIGN_VCENTRE | ALIGN_HCENTRE, - clue_mistake ? COL_MISTAKE : - clue_satisfied ? COL_SATISFIED : COL_FOREGROUND, c); - draw_update(dr, x - ds->tilesize/4 - 1, y - ds->tilesize/4 - 3, - ds->tilesize/2 + 2, ds->tilesize/2 + 5); + /* Redrawing is somewhat involved. + * + * An update can theoretically affect an arbitrary number of edges + * (consider, for example, completing or breaking a cycle which doesn't + * satisfy all the clues -- we'll switch many edges between error and + * normal states). On the other hand, redrawing the whole grid takes a + * while, making the game feel sluggish, and many updates are actually + * quite well localized. + * + * This redraw algorithm attempts to cope with both situations gracefully + * and correctly. For localized changes, we set a clip rectangle, fill + * it with background, and then redraw (a plausible but conservative + * guess at) the objects which intersect the rectangle; if several + * objects need redrawing, we'll do them individually. However, if lots + * of objects are affected, we'll just redraw everything. + * + * The reason for all of this is that it's just not safe to do the redraw + * piecemeal. If you try to draw an antialiased diagonal line over + * itself, you get a slightly thicker antialiased diagonal line, which + * looks rather ugly after a while. + * + * So, we take two passes over the grid. The first attempts to work out + * what needs doing, and the second actually does it. + */ - ds->clue_error[i] = clue_mistake; - ds->clue_satisfied[i] = clue_satisfied; + if (!ds->started) + redraw_everything = TRUE; + else { + + /* First, trundle through the faces. */ + for (i = 0; i < g->num_faces; i++) { + grid_face *f = g->faces + i; + int sides = f->order; + int clue_mistake; + int clue_satisfied; + int n = state->clues[i]; + if (n < 0) + continue; + + clue_mistake = (face_order(state, i, LINE_YES) > n || + face_order(state, i, LINE_NO ) > (sides-n)); + clue_satisfied = (face_order(state, i, LINE_YES) == n && + face_order(state, i, LINE_NO ) == (sides-n)); + + if (clue_mistake != ds->clue_error[i] || + clue_satisfied != ds->clue_satisfied[i]) { + ds->clue_error[i] = clue_mistake; + ds->clue_satisfied[i] = clue_satisfied; + if (nfaces == REDRAW_OBJECTS_LIMIT) + redraw_everything = TRUE; + else + faces[nfaces++] = i; + } + } - /* Sometimes, the bounding-box encroaches into the surrounding - * lines (particularly if the window is resized fairly small). - * So redraw them. */ - for (j = 0; j < f->order; j++) - ds->lines[f->edges[j] - g->edges] = -1; - } + /* Work out what the flash state needs to be. */ + if (flashtime > 0 && + (flashtime <= FLASH_TIME/3 || + flashtime >= FLASH_TIME*2/3)) { + flash_changed = !ds->flashing; + ds->flashing = TRUE; + } else { + flash_changed = ds->flashing; + ds->flashing = FALSE; + } + + /* Now, trundle through the edges. */ + for (i = 0; i < g->num_edges; i++) { + char new_ds = + state->line_errors[i] ? DS_LINE_ERROR : state->lines[i]; + if (new_ds != ds->lines[i] || + (flash_changed && state->lines[i] == LINE_YES)) { + ds->lines[i] = new_ds; + if (nedges == REDRAW_OBJECTS_LIMIT) + redraw_everything = TRUE; + else + edges[nedges++] = i; + } + } } - /* Lines */ - for (i = 0; i < g->num_edges; i++) { - grid_edge *e = g->edges + i; - int x1, x2, y1, y2; - int xmin, ymin, xmax, ymax; - char new_ds, need_draw; - new_ds = state->lines[i]; - if (state->line_errors[i]) - new_ds = DS_LINE_ERROR; - need_draw = (new_ds != ds->lines[i]) ? TRUE : FALSE; - if (flash_changed && (state->lines[i] == LINE_YES)) - need_draw = TRUE; - if (!ds->started) - need_draw = TRUE; /* draw everything at the start */ - ds->lines[i] = new_ds; - if (!need_draw) - continue; - if (state->line_errors[i]) - line_colour = COL_MISTAKE; - else if (state->lines[i] == LINE_UNKNOWN) - line_colour = COL_LINEUNKNOWN; - else if (state->lines[i] == LINE_NO) - line_colour = COL_BACKGROUND; - else if (ds->flashing) - line_colour = COL_HIGHLIGHT; - else - line_colour = COL_FOREGROUND; + /* Pass one is now done. Now we do the actual drawing. */ + if (redraw_everything) { + int grid_width = g->highest_x - g->lowest_x; + int grid_height = g->highest_y - g->lowest_y; + int w = grid_width * ds->tilesize / g->tilesize; + int h = grid_height * ds->tilesize / g->tilesize; - /* Convert from grid to screen coordinates */ - grid_to_screen(ds, g, e->dot1->x, e->dot1->y, &x1, &y1); - grid_to_screen(ds, g, e->dot2->x, e->dot2->y, &x2, &y2); + game_redraw_in_rect(dr, ds, state, + 0, 0, w + 2*border + 1, h + 2*border + 1); + } else { - xmin = min(x1, x2); - xmax = max(x1, x2); - ymin = min(y1, y2); - ymax = max(y1, y2); + /* Right. Now we roll up our sleeves. */ - if (line_colour != COL_BACKGROUND) { - /* (dx, dy) points roughly from (x1, y1) to (x2, y2). - * The line is then "fattened" in a (roughly) perpendicular - * direction to create a thin rectangle. */ - int dx = (x1 > x2) ? -1 : ((x1 < x2) ? 1 : 0); - int dy = (y1 > y2) ? -1 : ((y1 < y2) ? 1 : 0); - int points[8]; - points[0] = x1 + dy; - points[1] = y1 - dx; - points[2] = x1 - dy; - points[3] = y1 + dx; - points[4] = x2 - dy; - points[5] = y2 + dx; - points[6] = x2 + dy; - points[7] = y2 - dx; - draw_polygon(dr, points, 4, line_colour, line_colour); - } - if (ds->started) { - /* Draw dots at ends of the line */ - draw_circle(dr, x1, y1, 2, COL_FOREGROUND, COL_FOREGROUND); - draw_circle(dr, x2, y2, 2, COL_FOREGROUND, COL_FOREGROUND); - } - draw_update(dr, xmin-2, ymin-2, xmax - xmin + 4, ymax - ymin + 4); - } - - /* Draw dots */ - if (!ds->started) { - for (i = 0; i < g->num_dots; i++) { - grid_dot *d = g->dots + i; - int x, y; - grid_to_screen(ds, g, d->x, d->y, &x, &y); - draw_circle(dr, x, y, 2, COL_FOREGROUND, COL_FOREGROUND); - } + for (i = 0; i < nfaces; i++) { + grid_face *f = g->faces + faces[i]; + int x, y, w, h; + + face_text_bbox(ds, g, f, &x, &y, &w, &h); + game_redraw_in_rect(dr, ds, state, x, y, w, h); + } + + for (i = 0; i < nedges; i++) { + grid_edge *e = g->edges + edges[i]; + int x, y, w, h; + + edge_bbox(ds, g, e, &x, &y, &w, &h); + game_redraw_in_rect(dr, ds, state, x, y, w, h); + } } + ds->started = TRUE; } @@ -3504,6 +3896,11 @@ static float game_flash_length(game_state *oldstate, game_state *newstate, return 0.0F; } +static int game_is_solved(game_state *state) +{ + return state->solved; +} + static void game_print_size(game_params *params, float *x, float *y) { int pw, ph; @@ -3523,7 +3920,7 @@ static void game_print(drawing *dr, game_state *state, int tilesize) game_drawstate ads, *ds = &ads; grid *g = state->game_grid; - game_set_size(dr, ds, NULL, tilesize); + ds->tilesize = tilesize; for (i = 0; i < g->num_dots; i++) { int x, y; @@ -3630,8 +4027,136 @@ const struct game thegame = { game_redraw, game_anim_length, game_flash_length, + game_is_solved, TRUE, FALSE, game_print_size, game_print, FALSE /* wants_statusbar */, FALSE, game_timing_state, 0, /* mouse_priorities */ }; + +#ifdef STANDALONE_SOLVER + +/* + * Half-hearted standalone solver. It can't output the solution to + * anything but a square puzzle, and it can't log the deductions + * it makes either. But it can solve square puzzles, and more + * importantly it can use its solver to grade the difficulty of + * any puzzle you give it. + */ + +#include + +int main(int argc, char **argv) +{ + game_params *p; + game_state *s; + char *id = NULL, *desc, *err; + int grade = FALSE; + int ret, diff; +#if 0 /* verbose solver not supported here (yet) */ + int really_verbose = FALSE; +#endif + + while (--argc > 0) { + char *p = *++argv; +#if 0 /* verbose solver not supported here (yet) */ + if (!strcmp(p, "-v")) { + really_verbose = TRUE; + } else +#endif + if (!strcmp(p, "-g")) { + grade = TRUE; + } else if (*p == '-') { + fprintf(stderr, "%s: unrecognised option `%s'\n", argv[0], p); + return 1; + } else { + id = p; + } + } + + if (!id) { + fprintf(stderr, "usage: %s [-g | -v] \n", argv[0]); + return 1; + } + + desc = strchr(id, ':'); + if (!desc) { + fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]); + return 1; + } + *desc++ = '\0'; + + p = default_params(); + decode_params(p, id); + err = validate_desc(p, desc); + if (err) { + fprintf(stderr, "%s: %s\n", argv[0], err); + return 1; + } + s = new_game(NULL, p, desc); + + /* + * When solving an Easy puzzle, we don't want to bother the + * user with Hard-level deductions. For this reason, we grade + * the puzzle internally before doing anything else. + */ + ret = -1; /* placate optimiser */ + for (diff = 0; diff < DIFF_MAX; diff++) { + solver_state *sstate_new; + solver_state *sstate = new_solver_state((game_state *)s, diff); + + sstate_new = solve_game_rec(sstate); + + if (sstate_new->solver_status == SOLVER_MISTAKE) + ret = 0; + else if (sstate_new->solver_status == SOLVER_SOLVED) + ret = 1; + else + ret = 2; + + free_solver_state(sstate_new); + free_solver_state(sstate); + + if (ret < 2) + break; + } + + if (diff == DIFF_MAX) { + if (grade) + printf("Difficulty rating: harder than Hard, or ambiguous\n"); + else + printf("Unable to find a unique solution\n"); + } else { + if (grade) { + if (ret == 0) + printf("Difficulty rating: impossible (no solution exists)\n"); + else if (ret == 1) + printf("Difficulty rating: %s\n", diffnames[diff]); + } else { + solver_state *sstate_new; + solver_state *sstate = new_solver_state((game_state *)s, diff); + + /* If we supported a verbose solver, we'd set verbosity here */ + + sstate_new = solve_game_rec(sstate); + + if (sstate_new->solver_status == SOLVER_MISTAKE) + printf("Puzzle is inconsistent\n"); + else { + assert(sstate_new->solver_status == SOLVER_SOLVED); + if (s->grid_type == 0) { + fputs(game_text_format(sstate_new->state), stdout); + } else { + printf("Unable to output non-square grids\n"); + } + } + + free_solver_state(sstate_new); + free_solver_state(sstate); + } + } + + return 0; +} + +#endif