*/
/* Steal the method from map.c for difficulty levels. */
-#define DIFFLIST(A) \
- A(LATIN,Trivial,t) \
- A(EASY,Easy,e) \
- A(SET,Tricky,k) \
- A(EXTREME,Extreme,x) \
- A(RECURSIVE,Recursive,r)
-
-#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_IMPOSSIBLE = diff_impossible, DIFF_AMBIGUOUS = diff_ambiguous, DIFF_UNFINISHED = diff_unfinished };
+#define DIFFLIST(A) \
+ A(LATIN,Trivial,NULL,t) \
+ A(EASY,Easy,solver_easy, e) \
+ A(SET,Tricky,solver_set, k) \
+ A(EXTREME,Extreme,NULL,x) \
+ A(RECURSIVE,Recursive,NULL,r)
+
+#define ENUM(upper,title,func,lower) DIFF_ ## upper,
+#define TITLE(upper,title,func,lower) #title,
+#define ENCODE(upper,title,func,lower) #lower
+#define CONFIG(upper,title,func,lower) ":" #title
+enum { DIFFLIST(ENUM) DIFFCOUNT, DIFF_IMPOSSIBLE = diff_impossible, DIFF_AMBIGUOUS = diff_ambiguous, DIFF_UNFINISHED = diff_unfinished };
static char const *const unequal_diffnames[] = { DIFFLIST(TITLE) };
static char const unequal_diffchars[] = DIFFLIST(ENCODE);
-#define DIFFCOUNT lenof(unequal_diffchars)
#define DIFFCONFIG DIFFLIST(CONFIG)
#define DEFAULT_PRESET 0
sfree(params);
}
-static game_params *dup_params(game_params *params)
+static game_params *dup_params(const game_params *params)
{
game_params *ret = snew(game_params);
*ret = *params; /* structure copy */
}
}
-static char *encode_params(game_params *params, int full)
+static char *encode_params(const game_params *params, int full)
{
char ret[80];
return dupstr(ret);
}
-static config_item *game_configure(game_params *params)
+static config_item *game_configure(const game_params *params)
{
config_item *ret;
char buf[80];
return ret;
}
-static game_params *custom_params(config_item *cfg)
+static game_params *custom_params(const config_item *cfg)
{
game_params *ret = snew(game_params);
return ret;
}
-static char *validate_params(game_params *params, int full)
+static char *validate_params(const game_params *params, int full)
{
if (params->order < 3 || params->order > 32)
return "Order must be between 3 and 32";
return state;
}
-static game_state *dup_game(game_state *state)
+static game_state *dup_game(const game_state *state)
{
game_state *ret = blank_game(state->order, state->adjacent);
int o2 = state->order*state->order, o3 = o2*state->order;
return -1;
}
-static int game_can_format_as_text_now(game_params *params)
+static int game_can_format_as_text_now(const game_params *params)
{
return TRUE;
}
-static char *game_text_format(game_state *state)
+static char *game_text_format(const game_state *state)
{
int x, y, len, n;
char *ret, *p;
int len, gx, gy, lx, ly;
};
-typedef struct game_solver {
- struct latin_solver latin; /* keep first in struct! */
-
+struct solver_ctx {
game_state *state;
int nlinks, alinks;
struct solver_link *links;
-} game_solver;
-
-#if 0
-static void solver_debug(game_solver *solver, int wide)
-{
-#ifdef STANDALONE_SOLVER
- if (solver_show_working) {
- if (!wide)
- game_debug(solver->state);
- else
- latin_solver_debug(solver->latin.cube, solver->latin.o);
- }
-#endif
-}
-#endif
+};
-static void solver_add_link(game_solver *solver,
+static void solver_add_link(struct solver_ctx *ctx,
int gx, int gy, int lx, int ly, int len)
{
- if (solver->alinks < solver->nlinks+1) {
- solver->alinks = solver->alinks*2 + 1;
- /*debug(("resizing solver->links, new size %d", solver->alinks));*/
- solver->links = sresize(solver->links, solver->alinks, struct solver_link);
+ if (ctx->alinks < ctx->nlinks+1) {
+ ctx->alinks = ctx->alinks*2 + 1;
+ /*debug(("resizing ctx->links, new size %d", ctx->alinks));*/
+ ctx->links = sresize(ctx->links, ctx->alinks, struct solver_link);
}
- solver->links[solver->nlinks].gx = gx;
- solver->links[solver->nlinks].gy = gy;
- solver->links[solver->nlinks].lx = lx;
- solver->links[solver->nlinks].ly = ly;
- solver->links[solver->nlinks].len = len;
- solver->nlinks++;
+ ctx->links[ctx->nlinks].gx = gx;
+ ctx->links[ctx->nlinks].gy = gy;
+ ctx->links[ctx->nlinks].lx = lx;
+ ctx->links[ctx->nlinks].ly = ly;
+ ctx->links[ctx->nlinks].len = len;
+ ctx->nlinks++;
/*debug(("Adding new link: len %d (%d,%d) < (%d,%d), nlinks now %d",
- len, lx, ly, gx, gy, solver->nlinks));*/
+ len, lx, ly, gx, gy, ctx->nlinks));*/
}
-static game_solver *new_solver(digit *grid, game_state *state)
+static struct solver_ctx *new_ctx(game_state *state)
{
- game_solver *solver = snew(game_solver);
+ struct solver_ctx *ctx = snew(struct solver_ctx);
int o = state->order;
int i, x, y;
unsigned int f;
- latin_solver_alloc(&solver->latin, grid, o);
-
- solver->nlinks = solver->alinks = 0;
- solver->links = NULL;
- solver->state = state;
+ ctx->nlinks = ctx->alinks = 0;
+ ctx->links = NULL;
+ ctx->state = state;
- if (state->adjacent) return solver; /* adjacent mode doesn't use links. */
+ if (state->adjacent) return ctx; /* adjacent mode doesn't use links. */
for (x = 0; x < o; x++) {
for (y = 0; y < o; y++) {
f = GRID(state, flags, x, y);
for (i = 0; i < 4; i++) {
if (f & adjthan[i].f)
- solver_add_link(solver, x, y, x+adjthan[i].dx, y+adjthan[i].dy, 1);
+ solver_add_link(ctx, x, y, x+adjthan[i].dx, y+adjthan[i].dy, 1);
}
}
}
- return solver;
+ return ctx;
+}
+
+static void *clone_ctx(void *vctx)
+{
+ struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+ return new_ctx(ctx->state);
}
-static void free_solver(game_solver *solver)
+static void free_ctx(void *vctx)
{
- if (solver->links) sfree(solver->links);
- latin_solver_free(&solver->latin);
- sfree(solver);
+ struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+ if (ctx->links) sfree(ctx->links);
+ sfree(ctx);
}
-static void solver_nminmax(game_solver *usolver,
+static void solver_nminmax(struct latin_solver *solver,
int x, int y, int *min_r, int *max_r,
unsigned char **ns_r)
{
- struct latin_solver *solver = &usolver->latin;
- int o = usolver->latin.o, min = o, max = 0, n;
+ int o = solver->o, min = o, max = 0, n;
unsigned char *ns;
assert(x >= 0 && y >= 0 && x < o && y < o);
if (ns_r) *ns_r = ns;
}
-static int solver_links(game_solver *usolver)
+static int solver_links(struct latin_solver *solver, void *vctx)
{
+ struct solver_ctx *ctx = (struct solver_ctx *)vctx;
int i, j, lmin, gmax, nchanged = 0;
unsigned char *gns, *lns;
struct solver_link *link;
- struct latin_solver *solver = &usolver->latin;
- for (i = 0; i < usolver->nlinks; i++) {
- link = &usolver->links[i];
- solver_nminmax(usolver, link->gx, link->gy, NULL, &gmax, &gns);
- solver_nminmax(usolver, link->lx, link->ly, &lmin, NULL, &lns);
+ for (i = 0; i < ctx->nlinks; i++) {
+ link = &ctx->links[i];
+ solver_nminmax(solver, link->gx, link->gy, NULL, &gmax, &gns);
+ solver_nminmax(solver, link->lx, link->ly, &lmin, NULL, &lns);
for (j = 0; j < solver->o; j++) {
/* For the 'greater' end of the link, discount all numbers
if (solver_show_working) {
printf("%*slink elimination, (%d,%d) > (%d,%d):\n",
solver_recurse_depth*4, "",
- link->gx, link->gy, link->lx, link->ly);
+ link->gx+1, link->gy+1, link->lx+1, link->ly+1);
printf("%*s ruling out %d at (%d,%d)\n",
solver_recurse_depth*4, "",
- j+1, link->gx, link->gy);
+ j+1, link->gx+1, link->gy+1);
}
#endif
cube(link->gx, link->gy, j+1) = FALSE;
if (solver_show_working) {
printf("%*slink elimination, (%d,%d) > (%d,%d):\n",
solver_recurse_depth*4, "",
- link->gx, link->gy, link->lx, link->ly);
+ link->gx+1, link->gy+1, link->lx+1, link->ly+1);
printf("%*s ruling out %d at (%d,%d)\n",
solver_recurse_depth*4, "",
- j+1, link->lx, link->ly);
+ j+1, link->lx+1, link->ly+1);
}
#endif
cube(link->lx, link->ly, j+1) = FALSE;
return nchanged;
}
-static int solver_adjacent(game_solver *usolver)
+static int solver_adjacent(struct latin_solver *solver, void *vctx)
{
- struct latin_solver *solver = &usolver->latin;
- int nchanged = 0, x, y, i, n, o = usolver->latin.o, nx, ny, gd;
+ struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+ int nchanged = 0, x, y, i, n, o = solver->o, nx, ny, gd;
/* Update possible values based on known values and adjacency clues. */
* adjacent possibles reflect the adjacent/non-adjacent clue. */
for (i = 0; i < 4; i++) {
- int isadjacent = (GRID(usolver->state, flags, x, y) & adjthan[i].f);
+ int isadjacent = (GRID(ctx->state, flags, x, y) & adjthan[i].f);
nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
if (nx < 0 || ny < 0 || nx >= o || ny >= o)
if (solver_show_working) {
printf("%*sadjacent elimination, (%d,%d):%d %s (%d,%d):\n",
solver_recurse_depth*4, "",
- x, y, grid(x, y), isadjacent ? "|" : "!|", nx, ny);
+ x+1, y+1, grid(x, y), isadjacent ? "|" : "!|", nx+1, ny+1);
printf("%*s ruling out %d at (%d,%d)\n",
- solver_recurse_depth*4, "", n+1, nx, ny);
+ solver_recurse_depth*4, "", n+1, nx+1, ny+1);
}
#endif
cube(nx, ny, n+1) = FALSE;
return nchanged;
}
-static int solver_adjacent_set(game_solver *usolver)
+static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
{
- struct latin_solver *solver = &usolver->latin;
- int x, y, i, n, nn, o = usolver->latin.o, nx, ny, gd;
+ struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+ int x, y, i, n, nn, o = solver->o, nx, ny, gd;
int nchanged = 0, *scratch = snewn(o, int);
/* Update possible values based on other possible values
for (x = 0; x < o; x++) {
for (y = 0; y < o; y++) {
- for (i = 0; i < o; i++) {
- int isadjacent = (GRID(usolver->state, flags, x, y) & adjthan[i].f);
+ for (i = 0; i < 4; i++) {
+ int isadjacent = (GRID(ctx->state, flags, x, y) & adjthan[i].f);
nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
if (nx < 0 || ny < 0 || nx >= o || ny >= o)
if (solver_show_working) {
printf("%*sadjacent possible elimination, (%d,%d) %s (%d,%d):\n",
solver_recurse_depth*4, "",
- x, y, isadjacent ? "|" : "!|", nx, ny);
+ x+1, y+1, isadjacent ? "|" : "!|", nx+1, ny+1);
printf("%*s ruling out %d at (%d,%d)\n",
- solver_recurse_depth*4, "", n+1, nx, ny);
+ solver_recurse_depth*4, "", n+1, nx+1, ny+1);
}
#endif
cube(nx, ny, n+1) = FALSE;
return nchanged;
}
-static int solver_grid(digit *grid, int o, int maxdiff, void *ctx)
+static int solver_easy(struct latin_solver *solver, void *vctx)
{
- game_state *state = (game_state *)ctx;
- game_solver *solver;
- struct latin_solver *lsolver;
- struct latin_solver_scratch *scratch;
- int ret, diff = DIFF_LATIN;
-
- assert(maxdiff <= DIFF_RECURSIVE);
-
- assert(state->order == o);
- solver = new_solver(grid, state);
-
- lsolver = &solver->latin;
- scratch = latin_solver_new_scratch(lsolver);
-
- while (1) {
-cont:
- ret = latin_solver_diff_simple(lsolver);
- if (ret < 0) {
- diff = DIFF_IMPOSSIBLE;
- goto got_result;
- } else if (ret > 0) {
- diff = max(diff, DIFF_LATIN);
- goto cont;
- }
-
- if (maxdiff <= DIFF_LATIN)
- break;
-
- if (state->adjacent) {
- /* Adjacent-specific: set possibles from known numbers
- * and adjacency clues. */
- ret = solver_adjacent(solver);
- } else {
- /* Unequal-specific: set possibles from chains of
- * inequalities. */
- ret = solver_links(solver);
- }
- if (ret < 0) {
- diff = DIFF_IMPOSSIBLE;
- goto got_result;
- } else if (ret > 0) {
- diff = max(diff, DIFF_EASY);
- goto cont;
- }
-
- if (maxdiff <= DIFF_EASY)
- break;
-
- /* Row- and column-wise set elimination */
- ret = latin_solver_diff_set(lsolver, scratch, 0);
- if (ret < 0) {
- diff = DIFF_IMPOSSIBLE;
- goto got_result;
- } else if (ret > 0) {
- diff = max(diff, DIFF_SET);
- goto cont;
- }
-
- if (state->adjacent) {
- /* Adjacent-specific: set possibles from other possibles
- * and adjacency clues. */
- ret = solver_adjacent_set(solver);
- if (ret < 0) {
- diff = DIFF_IMPOSSIBLE;
- goto got_result;
- } else if (ret > 0) {
- diff = max(diff, DIFF_SET);
- goto cont;
- }
- }
-
- if (maxdiff <= DIFF_SET)
- break;
+ struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+ if (ctx->state->adjacent)
+ return solver_adjacent(solver, vctx);
+ else
+ return solver_links(solver, vctx);
+}
- ret = latin_solver_diff_set(lsolver, scratch, 1);
- if (ret < 0) {
- diff = DIFF_IMPOSSIBLE;
- goto got_result;
- } else if (ret > 0) {
- diff = max(diff, DIFF_EXTREME);
- goto cont;
- }
+static int solver_set(struct latin_solver *solver, void *vctx)
+{
+ struct solver_ctx *ctx = (struct solver_ctx *)vctx;
+ if (ctx->state->adjacent)
+ return solver_adjacent_set(solver, vctx);
+ else
+ return 0;
+}
- /*
- * Forcing chains.
- */
- if (latin_solver_forcing(lsolver, scratch)) {
- diff = max(diff, DIFF_EXTREME);
- goto cont;
- }
+#define SOLVER(upper,title,func,lower) func,
+static usersolver_t const unequal_solvers[] = { DIFFLIST(SOLVER) };
- /*
- * If we reach here, we have made no deductions in this
- * iteration, so the algorithm terminates.
- */
- break;
- }
- /*
- * Last chance: if we haven't fully solved the puzzle yet, try
- * recursing based on guesses for a particular square. We pick
- * one of the most constrained empty squares we can find, which
- * has the effect of pruning the search tree as much as
- * possible.
- */
- if (maxdiff == DIFF_RECURSIVE) {
- int nsol = latin_solver_recurse(lsolver, DIFF_RECURSIVE, solver_grid, ctx);
- if (nsol < 0) diff = DIFF_IMPOSSIBLE;
- else if (nsol == 1) diff = DIFF_RECURSIVE;
- else if (nsol > 1) diff = DIFF_AMBIGUOUS;
- /* if nsol == 0 then we were complete anyway
- * (and thus don't need to change diff) */
- } else {
- int cc = check_complete(grid, state, 0);
- if (cc == -1) diff = DIFF_IMPOSSIBLE;
- if (cc == 0) diff = DIFF_UNFINISHED;
- }
+static int solver_state(game_state *state, int maxdiff)
+{
+ struct solver_ctx *ctx = new_ctx(state);
+ struct latin_solver solver;
+ int diff;
-got_result:
+ latin_solver_alloc(&solver, state->nums, state->order);
-#ifdef STANDALONE_SOLVER
- if (solver_show_working)
- printf("%*s%s found\n",
- solver_recurse_depth*4, "",
- diff == DIFF_IMPOSSIBLE ? "no solution (impossible)" :
- diff == DIFF_UNFINISHED ? "no solution (unfinished)" :
- diff == DIFF_AMBIGUOUS ? "multiple solutions" :
- "one solution");
-#endif
+ diff = latin_solver_main(&solver, maxdiff,
+ DIFF_LATIN, DIFF_SET, DIFF_EXTREME,
+ DIFF_EXTREME, DIFF_RECURSIVE,
+ unequal_solvers, ctx, clone_ctx, free_ctx);
- latin_solver_free_scratch(scratch);
- memcpy(state->hints, solver->latin.cube, o*o*o);
- free_solver(solver);
+ memcpy(state->hints, solver.cube, state->order*state->order*state->order);
- return diff;
-}
+ free_ctx(ctx);
-static int solver_state(game_state *state, int maxdiff)
-{
- int diff = solver_grid(state->nums, state->order, maxdiff, (void*)state);
+ latin_solver_free(&solver);
if (diff == DIFF_IMPOSSIBLE)
return -1;
return 1;
}
-static game_state *solver_hint(game_state *state, int *diff_r, int mindiff, int maxdiff)
+static game_state *solver_hint(const game_state *state, int *diff_r,
+ int mindiff, int maxdiff)
{
game_state *ret = dup_game(state);
int diff, r = 0;
#ifdef STANDALONE_SOLVER
if (state->nums[loc] != latin[loc]) {
printf("inconsistency for (%d,%d): state %d latin %d\n",
- x, y, state->nums[loc], latin[loc]);
+ x+1, y+1, state->nums[loc], latin[loc]);
}
#endif
assert(state->nums[loc] == latin[loc]);
#ifdef STANDALONE_SOLVER
if (solver_show_working)
printf("gg_remove_clue: removing %d at (%d,%d)",
- state->nums[loc], x, y);
+ state->nums[loc], x+1, y+1);
#endif
state->nums[loc] = 0;
}
#ifdef STANDALONE_SOLVER
if (solver_show_working)
printf("gg_remove_clue: removing %c at (%d,%d)",
- adjthan[which].c, x, y);
+ adjthan[which].c, x+1, y+1);
#endif
state->flags[loc] &= ~adjthan[which].f;
}
{
int ls = state->order * state->order * 5;
int maxposs = 0, minclues = 5, best = -1, i, j;
- int nposs, nclues, loc, x, y;
+ int nposs, nclues, loc;
#ifdef STANDALONE_SOLVER
if (solver_show_working) {
if (!gg_place_clue(state, scratch[i], latin, 1)) continue;
loc = scratch[i] / 5;
- x = loc % state->order; y = loc / state->order;
for (j = nposs = 0; j < state->order; j++) {
if (state->hints[loc*state->order + j]) nposs++;
}
(nposs == maxposs && nclues < minclues)) {
best = i; maxposs = nposs; minclues = nclues;
#ifdef STANDALONE_SOLVER
- if (solver_show_working)
+ if (solver_show_working) {
+ int x = loc % state->order, y = loc / state->order;
printf("gg_best_clue: b%d (%d,%d) new best [%d poss, %d clues].\n",
- best, x, y, nposs, nclues);
+ best, x+1, y+1, nposs, nclues);
+ }
#endif
}
}
}
}
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params_in, random_state *rs,
char **aux, int interactive)
{
+ game_params params_copy = *params_in; /* structure copy */
+ game_params *params = ¶ms_copy;
digit *sq = NULL;
int i, x, y, retlen, k, nsol;
int o2 = params->order * params->order, ntries = 1;
return ret;
}
-static game_state *load_game(game_params *params, char *desc,
+static game_state *load_game(const game_params *params, const char *desc,
char **why_r)
{
game_state *state = blank_game(params->order, params->adjacent);
- char *p = desc;
+ const char *p = desc;
int i = 0, n, o = params->order, x, y;
char *why = NULL;
return NULL;
}
-static game_state *new_game(midend *me, game_params *params, char *desc)
+static game_state *new_game(midend *me, const game_params *params,
+ const char *desc)
{
game_state *state = load_game(params, desc, NULL);
if (!state) {
return state;
}
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, const char *desc)
{
char *why = NULL;
game_state *dummy = load_game(params, desc, &why);
return why;
}
-static char *solve_game(game_state *state, game_state *currstate,
- char *aux, char **error)
+static char *solve_game(const game_state *state, const game_state *currstate,
+ const char *aux, char **error)
{
game_state *solved;
int r;
if (!(solved->flags[r] & F_IMMUTABLE))
solved->nums[r] = 0;
}
- r = solver_state(solved, DIFFCOUNT);
+ r = solver_state(solved, DIFFCOUNT-1); /* always use full solver */
if (r > 0) ret = latin_desc(solved->nums, solved->order);
free_game(solved);
return ret;
int hshow, hpencil, hcursor; /* show state, type, and ?cursor. */
};
-static game_ui *new_ui(game_state *state)
+static game_ui *new_ui(const game_state *state)
{
game_ui *ui = snew(game_ui);
sfree(ui);
}
-static char *encode_ui(game_ui *ui)
+static char *encode_ui(const game_ui *ui)
{
return NULL;
}
-static void decode_ui(game_ui *ui, char *encoding)
+static void decode_ui(game_ui *ui, const char *encoding)
{
}
-static void game_changed_state(game_ui *ui, game_state *oldstate,
- game_state *newstate)
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+ const game_state *newstate)
{
/* See solo.c; if we were pencil-mode highlighting and
* somehow a square has just been properly filled, cancel
int hflash;
};
-static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
- int ox, int oy, int button)
+static char *interpret_move(const game_state *state, game_ui *ui,
+ const game_drawstate *ds,
+ int ox, int oy, int button)
{
int x = FROMCOORD(ox), y = FROMCOORD(oy), n;
char buf[80];
return "";
}
-
- if (ui->hshow) {
+ n = c2n(button, state->order);
+ if (ui->hshow && n >= 0 && n <= ds->order) {
debug(("button %d, cbutton %d", button, (int)((char)button)));
- n = c2n(button, state->order);
debug(("n %d, h (%d,%d) p %d flags 0x%x nums %d",
n, ui->hx, ui->hy, ui->hpencil,
GRID(state, flags, ui->hx, ui->hy),
GRID(state, nums, ui->hx, ui->hy)));
- if (n < 0 || n > ds->order)
- return NULL; /* out of range */
if (GRID(state, flags, ui->hx, ui->hy) & F_IMMUTABLE)
return NULL; /* can't edit immutable square (!) */
if (ui->hpencil && GRID(state, nums, ui->hx, ui->hy) > 0)
return NULL;
}
-static game_state *execute_move(game_state *state, char *move)
+static game_state *execute_move(const game_state *state, const char *move)
{
game_state *ret = NULL;
int x, y, n, i, rc;
}
return ret;
} else if (move[0] == 'S') {
- char *p;
+ const char *p;
ret = dup_game(state);
ret->completed = ret->cheated = TRUE;
#define DRAW_SIZE (TILE_SIZE*ds->order + GAP_SIZE*(ds->order-1) + BORDER*2)
-static void game_compute_size(game_params *params, int tilesize,
- int *x, int *y)
+static void game_compute_size(const game_params *params, int tilesize,
+ int *x, int *y)
{
/* Ick: fake up `ds->tilesize' for macro expansion purposes */
struct { int tilesize, order; } ads, *ds = &ads;
}
static void game_set_size(drawing *dr, game_drawstate *ds,
- game_params *params, int tilesize)
+ const game_params *params, int tilesize)
{
ds->tilesize = tilesize;
}
return ret;
}
-static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
{
struct game_drawstate *ds = snew(struct game_drawstate);
int o2 = state->order*state->order, o3 = o2*state->order;
static void draw_gt(drawing *dr, int ox, int oy,
int dx1, int dy1, int dx2, int dy2, int col)
{
- draw_line(dr, ox, oy, ox+dx1, oy+dy1, col);
- draw_line(dr, ox+dx1, oy+dy1, ox+dx1+dx2, oy+dy1+dy2, col);
+ int coords[12];
+ int xdx = (dx1+dx2 ? 0 : 1), xdy = (dx1+dx2 ? 1 : 0);
+ coords[0] = ox + xdx;
+ coords[1] = oy + xdy;
+ coords[2] = ox + xdx + dx1;
+ coords[3] = oy + xdy + dy1;
+ coords[4] = ox + xdx + dx1 + dx2;
+ coords[5] = oy + xdy + dy1 + dy2;
+ coords[6] = ox - xdx + dx1 + dx2;
+ coords[7] = oy - xdy + dy1 + dy2;
+ coords[8] = ox - xdx + dx1;
+ coords[9] = oy - xdy + dy1;
+ coords[10] = ox - xdx;
+ coords[11] = oy - xdy;
+ draw_polygon(dr, coords, 6, col, col);
}
static void draw_gts(drawing *dr, game_drawstate *ds, int ox, int oy,
- unsigned int f, int col)
+ unsigned int f, int bg, int fg)
{
int g = GAP_SIZE, g2 = (g+1)/2, g4 = (g+1)/4;
/* Draw all the greater-than signs emanating from this tile. */
if (f & F_ADJ_UP) {
+ if (bg >= 0) draw_rect(dr, ox, oy - g, TILE_SIZE, g, bg);
draw_gt(dr, ox+g2, oy-g4, g2, -g2, g2, g2,
- (f & F_ERROR_UP) ? COL_ERROR : col);
+ (f & F_ERROR_UP) ? COL_ERROR : fg);
draw_update(dr, ox, oy-g, TILE_SIZE, g);
}
if (f & F_ADJ_RIGHT) {
+ if (bg >= 0) draw_rect(dr, ox + TILE_SIZE, oy, g, TILE_SIZE, bg);
draw_gt(dr, ox+TILE_SIZE+g4, oy+g2, g2, g2, -g2, g2,
- (f & F_ERROR_RIGHT) ? COL_ERROR : col);
+ (f & F_ERROR_RIGHT) ? COL_ERROR : fg);
draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE);
}
if (f & F_ADJ_DOWN) {
+ if (bg >= 0) draw_rect(dr, ox, oy + TILE_SIZE, TILE_SIZE, g, bg);
draw_gt(dr, ox+g2, oy+TILE_SIZE+g4, g2, g2, g2, -g2,
- (f & F_ERROR_DOWN) ? COL_ERROR : col);
+ (f & F_ERROR_DOWN) ? COL_ERROR : fg);
draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g);
}
if (f & F_ADJ_LEFT) {
+ if (bg >= 0) draw_rect(dr, ox - g, oy, g, TILE_SIZE, bg);
draw_gt(dr, ox-g4, oy+g2, -g2, g2, g2, g2,
- (f & F_ERROR_LEFT) ? COL_ERROR : col);
+ (f & F_ERROR_LEFT) ? COL_ERROR : fg);
draw_update(dr, ox-g, oy, g, TILE_SIZE);
}
}
static void draw_adjs(drawing *dr, game_drawstate *ds, int ox, int oy,
- unsigned int f, int col)
+ unsigned int f, int bg, int fg)
{
int g = GAP_SIZE, g38 = 3*(g+1)/8, g4 = (g+1)/4;
if (f & (F_ADJ_RIGHT|F_ERROR_RIGHT)) {
if (f & F_ADJ_RIGHT) {
draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE,
- (f & F_ERROR_RIGHT) ? COL_ERROR : col);
+ (f & F_ERROR_RIGHT) ? COL_ERROR : fg);
} else {
draw_rect_outline(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, COL_ERROR);
}
- } else {
- draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, COL_BACKGROUND);
+ } else if (bg >= 0) {
+ draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, bg);
}
draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE);
if (f & (F_ADJ_DOWN|F_ERROR_DOWN)) {
if (f & F_ADJ_DOWN) {
draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4,
- (f & F_ERROR_DOWN) ? COL_ERROR : col);
+ (f & F_ERROR_DOWN) ? COL_ERROR : fg);
} else {
draw_rect_outline(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, COL_ERROR);
}
- } else {
- draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, COL_BACKGROUND);
+ } else if (bg >= 0) {
+ draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, bg);
}
draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g);
}
-static void draw_furniture(drawing *dr, game_drawstate *ds, game_state *state,
- game_ui *ui, int x, int y, int hflash)
+static void draw_furniture(drawing *dr, game_drawstate *ds,
+ const game_state *state, const game_ui *ui,
+ int x, int y, int hflash)
{
int ox = COORD(x), oy = COORD(y), bg, hon;
unsigned int f = GRID(state, flags, x, y);
/* Draw the adjacent clue signs. */
if (ds->adjacent)
- draw_adjs(dr, ds, ox, oy, f, COL_GRID);
+ draw_adjs(dr, ds, ox, oy, f, COL_BACKGROUND, COL_GRID);
else
- draw_gts(dr, ds, ox, oy, f, COL_TEXT);
+ draw_gts(dr, ds, ox, oy, f, COL_BACKGROUND, COL_TEXT);
}
static void draw_num(drawing *dr, game_drawstate *ds, int x, int y)
}
}
-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 game_redraw(drawing *dr, game_drawstate *ds,
+ const game_state *oldstate, const game_state *state,
+ int dir, const game_ui *ui,
+ float animtime, float flashtime)
{
int x, y, i, hchanged = 0, stale, hflash = 0;
ds->hflash = hflash;
}
-static float game_anim_length(game_state *oldstate, game_state *newstate,
- int dir, game_ui *ui)
+static float game_anim_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
return 0.0F;
}
-static float game_flash_length(game_state *oldstate, game_state *newstate,
- int dir, game_ui *ui)
+static float game_flash_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
if (!oldstate->completed && newstate->completed &&
!oldstate->cheated && !newstate->cheated)
return 0.0F;
}
-static int game_timing_state(game_state *state, game_ui *ui)
+static int game_status(const game_state *state)
+{
+ return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
{
return TRUE;
}
-static void game_print_size(game_params *params, float *x, float *y)
+static void game_print_size(const game_params *params, float *x, float *y)
{
int pw, ph;
*y = ph / 100.0F;
}
-static void game_print(drawing *dr, game_state *state, int tilesize)
+static void game_print(drawing *dr, const game_state *state, int tilesize)
{
int ink = print_mono_colour(dr, 0);
int x, y, o = state->order, ox, oy, n;
FONT_VARIABLE, TILE_SIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE,
ink, str);
- if (ds->adjacent)
- draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), ink);
+ if (state->adjacent)
+ draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink);
else
- draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), ink);
+ draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink);
}
}
}
game_redraw,
game_anim_length,
game_flash_length,
+ game_status,
TRUE, FALSE, game_print_size, game_print,
FALSE, /* wants_statusbar */
FALSE, game_timing_state,
static int solve(game_params *p, char *desc, int debug)
{
- game_state *st = new_game(NULL, p, desc);
+ game_state *state = new_game(NULL, p, desc);
+ struct solver_ctx *ctx = new_ctx(state);
+ struct latin_solver solver;
int diff;
solver_show_working = debug;
- game_debug(st);
+ game_debug(state);
+
+ latin_solver_alloc(&solver, state->nums, state->order);
+
+ diff = latin_solver_main(&solver, DIFF_RECURSIVE,
+ DIFF_LATIN, DIFF_SET, DIFF_EXTREME,
+ DIFF_EXTREME, DIFF_RECURSIVE,
+ unequal_solvers, ctx, clone_ctx, free_ctx);
+
+ free_ctx(ctx);
+
+ latin_solver_free(&solver);
- diff = solver_grid(st->nums, st->order, DIFF_RECURSIVE, (void*)st);
if (debug) pdiff(diff);
- game_debug(st);
- free_game(st);
+ game_debug(state);
+ free_game(state);
return diff;
}
~ian / sgt-puzzles.git / blobdiff