ref: b9c22e5cacc5541c71706889c2cd58ceb966ff45
parent: d54b4c46519385cd1543582cd4ea679f3cbea005
author: Simon Tatham <anakin@pobox.com>
date: Sun Dec 27 05:01:09 EST 2009
New mode for Unequal, from James H. In this mode, called 'Adjacent', the < and > clues are replaced by bars separating every pair of squares whose contents differ by exactly 1. Unlike standard Unequal, which presents only a subset of the available clues, in Adjacent the clues are _all_ present, so you can deduce from the absence of a bar that the two numbers it would separate are _not_ consecutive. [originally from svn r8790]
--- a/puzzles.but
+++ b/puzzles.but
@@ -2240,7 +2240,7 @@
\cfg{winhelp-topic}{games.unequal}You have a square grid; each square may contain a digit from 1 to
-the size of the grid, and some squares have greater-than signs between
+the size of the grid, and some squares have clue signs between
them. Your aim is to fully populate the grid with numbers such that:
\b Each row contains only one occurrence of each digit
@@ -2247,15 +2247,27 @@
\b Each column contains only one occurrence of each digit
-\b All the greater-than signs are satisfied.
+\b All the clue signs are satisfied.
-In \q{Trivial} mode (available via the \q{Custom} game type-selector), there are no greater-than signs; the puzzle is to solve
-the \i{Latin square} only.+There are two modes for this game, \q{Unequal} and \q{Adjacent}.-At the time of writing, this puzzle is appearing in the Guardian
-weekly under the name \q{\i{Futoshiki}}.+In \q{Unequal} mode, the clue signs are greater-than symbols indicating one+square's value is greater than its neighbour's. In this mode not all clues
+may be visible, particularly at higher difficulty levels.
+In \q{Adjacent} mode, the clue signs are bars indicating+one square's value is numerically adjacent (i.e. one higher or one lower)
+than its neighbour. In this mode all clues are always visible: absence of
+a bar thus means that a square's value is definitely not numerically adjacent
+to that neighbour's.
+
+In \q{Trivial} difficulty level (available via the \q{Custom} game type+selector), there are no greater-than signs in \q{Unequal} mode; the puzzle is+to solve the \i{Latin square} only.+
+At the time of writing, the \q{Unequal} mode of this puzzle is appearing in the+Guardian weekly under the name \q{\i{Futoshiki}}.+
Unequal was contributed to this collection by James Harvey.
\H{unequal-controls} \i{Unequal controls}@@ -2304,6 +2316,10 @@
These parameters are available from the \q{Custom...} option on the \q{Type} menu.+
+\dt \e{Mode}+
+\dd Mode of the puzzle (\q{Unequal} or \q{Adjacent}) \dt \e{Size (s*s)}--- a/unequal.c
+++ b/unequal.c
@@ -56,14 +56,17 @@
};
struct game_params {- int order, diff;
+ int order; /* Size of latin square */
+ int diff; /* Difficulty */
+ int adjacent; /* Puzzle indicators are 'adjacent number'
+ not 'greater-than'. */
};
#define F_IMMUTABLE 1 /* passed in as game description */
-#define F_GT_UP 2
-#define F_GT_RIGHT 4
-#define F_GT_DOWN 8
-#define F_GT_LEFT 16
+#define F_ADJ_UP 2
+#define F_ADJ_RIGHT 4
+#define F_ADJ_DOWN 8
+#define F_ADJ_LEFT 16
#define F_ERROR 32
#define F_ERROR_UP 64
#define F_ERROR_RIGHT 128
@@ -73,7 +76,7 @@
#define F_ERROR_MASK (F_ERROR|F_ERROR_UP|F_ERROR_RIGHT|F_ERROR_DOWN|F_ERROR_LEFT)
struct game_state {- int order, completed, cheated;
+ int order, completed, cheated, adjacent;
digit *nums; /* actual numbers (size order^2) */
unsigned char *hints; /* remaining possiblities (size order^3) */
unsigned int *flags; /* flags (size order^2) */
@@ -104,15 +107,18 @@
#define DEFAULT_PRESET 0
const static struct game_params unequal_presets[] = {- { 4, DIFF_EASY },- { 5, DIFF_EASY },- { 5, DIFF_SET },- { 5, DIFF_EXTREME },- { 6, DIFF_EASY },- { 6, DIFF_SET },- { 6, DIFF_EXTREME },- { 7, DIFF_SET },- { 7, DIFF_EXTREME },+ { 4, DIFF_EASY, 0 },+ { 5, DIFF_EASY, 0 },+ { 5, DIFF_SET, 0 },+ { 5, DIFF_SET, 1 },+ { 5, DIFF_EXTREME, 0 },+ { 6, DIFF_EASY, 0 },+ { 6, DIFF_SET, 0 },+ { 6, DIFF_SET, 1 },+ { 6, DIFF_EXTREME, 0 },+ { 7, DIFF_SET, 0 },+ { 7, DIFF_SET, 1 },+ { 7, DIFF_EXTREME, 0 }};
static int game_fetch_preset(int i, char **name, game_params **params)
@@ -126,7 +132,9 @@
ret = snew(game_params);
*ret = unequal_presets[i]; /* structure copy */
- sprintf(buf, "%dx%d %s", ret->order, ret->order,
+ sprintf(buf, "%s: %dx%d %s",
+ ret->adjacent ? "Adjacent" : "Unequal",
+ ret->order, ret->order,
unequal_diffnames[ret->diff]);
*name = dupstr(buf);
@@ -163,6 +171,12 @@
ret->order = atoi(p);
while (*p && isdigit((unsigned char)*p)) p++;
+ if (*p == 'a') {+ p++;
+ ret->adjacent = 1;
+ } else
+ ret->adjacent = 0;
+
if (*p == 'd') {int i;
p++;
@@ -182,6 +196,8 @@
char ret[80];
sprintf(ret, "%d", params->order);
+ if (params->adjacent)
+ sprintf(ret + strlen(ret), "a");
if (full)
sprintf(ret + strlen(ret), "d%c", unequal_diffchars[params->diff]);
@@ -193,23 +209,28 @@
config_item *ret;
char buf[80];
- ret = snewn(3, config_item);
+ ret = snewn(4, config_item);
- ret[0].name = "Size (s*s)";
- ret[0].type = C_STRING;
+ ret[0].name = "Mode";
+ ret[0].type = C_CHOICES;
+ ret[0].sval = ":Unequal:Adjacent";
+ ret[0].ival = params->adjacent;
+
+ ret[1].name = "Size (s*s)";
+ ret[1].type = C_STRING;
sprintf(buf, "%d", params->order);
- ret[0].sval = dupstr(buf);
- ret[0].ival = 0;
+ ret[1].sval = dupstr(buf);
+ ret[1].ival = 0;
- ret[1].name = "Difficulty";
- ret[1].type = C_CHOICES;
- ret[1].sval = DIFFCONFIG;
- ret[1].ival = params->diff;
+ ret[2].name = "Difficulty";
+ ret[2].type = C_CHOICES;
+ ret[2].sval = DIFFCONFIG;
+ ret[2].ival = params->diff;
- ret[2].name = NULL;
- ret[2].type = C_END;
- ret[2].sval = NULL;
- ret[2].ival = 0;
+ ret[3].name = NULL;
+ ret[3].type = C_END;
+ ret[3].sval = NULL;
+ ret[3].ival = 0;
return ret;
}
@@ -218,8 +239,9 @@
{game_params *ret = snew(game_params);
- ret->order = atoi(cfg[0].sval);
- ret->diff = cfg[1].ival;
+ ret->adjacent = cfg[0].ival;
+ ret->order = atoi(cfg[1].sval);
+ ret->diff = cfg[2].ival;
return ret;
}
@@ -230,6 +252,9 @@
return "Order must be between 3 and 32";
if (params->diff >= DIFFCOUNT)
return "Unknown difficulty rating";
+ if (params->order < 5 && params->adjacent &&
+ params->diff >= DIFF_SET)
+ return "Order must be at least 5 for Adjacent puzzles of this difficulty.";
return NULL;
}
@@ -237,19 +262,20 @@
* Various utility functions
*/
-static const struct { unsigned int f, fo, fe; int dx, dy; char c; } gtthan[] = {- { F_GT_UP, F_GT_DOWN, F_ERROR_UP, 0, -1, '^' },- { F_GT_RIGHT, F_GT_LEFT, F_ERROR_RIGHT, 1, 0, '>' },- { F_GT_DOWN, F_GT_UP, F_ERROR_DOWN, 0, 1, 'v' },- { F_GT_LEFT, F_GT_RIGHT, F_ERROR_LEFT, -1, 0, '<' }+static const struct { unsigned int f, fo, fe; int dx, dy; char c, ac; } adjthan[] = {+ { F_ADJ_UP, F_ADJ_DOWN, F_ERROR_UP, 0, -1, '^', '-' },+ { F_ADJ_RIGHT, F_ADJ_LEFT, F_ERROR_RIGHT, 1, 0, '>', '|' },+ { F_ADJ_DOWN, F_ADJ_UP, F_ERROR_DOWN, 0, 1, 'v', '-' },+ { F_ADJ_LEFT, F_ADJ_RIGHT, F_ERROR_LEFT, -1, 0, '<', '|' }};
-static game_state *blank_game(int order)
+static game_state *blank_game(int order, int adjacent)
{game_state *state = snew(game_state);
int o2 = order*order, o3 = o2*order;
state->order = order;
+ state->adjacent = adjacent;
state->completed = state->cheated = 0;
state->nums = snewn(o2, digit);
@@ -265,7 +291,7 @@
static game_state *dup_game(game_state *state)
{- game_state *ret = blank_game(state->order);
+ game_state *ret = blank_game(state->order, state->adjacent);
int o2 = state->order*state->order, o3 = o2*state->order;
memcpy(ret->nums, state->nums, o2 * sizeof(digit));
@@ -286,34 +312,47 @@
#define CHECKG(x,y) grid[(y)*o+(x)]
/* Returns 0 if it finds an error, 1 otherwise. */
-static int check_gt(digit *grid, game_state *state,
- int x, int y, int dx, int dy)
-{- int o = state->order;
- int n = CHECKG(x,y), dn = CHECKG(x+dx, y+dy);
-
- assert(n != 0);
- if (dn == 0) return 1;
-
- if (n <= dn) {- debug(("check_gt error (%d,%d) (%d,%d)", x, y, x+dx, y+dy));- return 0;
- }
- return 1;
-}
-
-/* Returns 0 if it finds an error, 1 otherwise. */
-static int check_num_gt(digit *grid, game_state *state,
+static int check_num_adj(digit *grid, game_state *state,
int x, int y, int me)
{unsigned int f = GRID(state, flags, x, y);
- int ret = 1, i;
+ int ret = 1, i, o = state->order;
for (i = 0; i < 4; i++) {- if ((f & gtthan[i].f) &&
- !check_gt(grid, state, x, y, gtthan[i].dx, gtthan[i].dy)) {- if (me) GRID(state, flags, x, y) |= gtthan[i].fe;
- ret = 0;
+ int dx = adjthan[i].dx, dy = adjthan[i].dy, n, dn;
+
+ if (x+dx < 0 || x+dx >= o || y+dy < 0 || y+dy >= o)
+ continue;
+
+ n = CHECKG(x, y);
+ dn = CHECKG(x+dx, y+dy);
+
+ assert (n != 0);
+ if (dn == 0) continue;
+
+ if (state->adjacent) {+ int gd = abs(n-dn);
+
+ if ((f & adjthan[i].f) && (gd != 1)) {+ debug(("check_adj error (%d,%d):%d should be | (%d,%d):%d",+ x, y, n, x+dx, y+dy, dn));
+ if (me) GRID(state, flags, x, y) |= adjthan[i].fe;
+ ret = 0;
+ }
+ if (!(f & adjthan[i].f) && (gd == 1)) {+ debug(("check_adj error (%d,%d):%d should not be | (%d,%d):%d",+ x, y, n, x+dx, y+dy, dn));
+ if (me) GRID(state, flags, x, y) |= adjthan[i].fe;
+ ret = 0;
+ }
+
+ } else {+ if ((f & adjthan[i].f) && (n <= dn)) {+ debug(("check_adj error (%d,%d):%d not > (%d,%d):%d",+ x, y, n, x+dx, y+dy, dn));
+ if (me) GRID(state, flags, x, y) |= adjthan[i].fe;
+ ret = 0;
+ }
}
}
return ret;
@@ -366,7 +405,7 @@
ret = 0;
} else {if (!check_num_error(grid, state, x, y, mark_errors)) ret = -1;
- if (!check_num_gt(grid, state, x, y, mark_errors)) ret = -1;
+ if (!check_num_adj(grid, state, x, y, mark_errors)) ret = -1;
}
}
}
@@ -395,7 +434,7 @@
if (c == ' ' || c == '\b')
return 0;
if (order < 10) {- if (c >= '1' && c <= '9')
+ if (c >= '0' && c <= '9')
return (int)(c - '0');
} else {if (c >= '0' && c <= '9')
@@ -428,12 +467,16 @@
*p++ = n > 0 ? n2c(n, state->order) : '.';
if (x < (state->order-1)) {- if (GRID(state, flags, x, y) & F_GT_RIGHT)
- *p++ = '>';
- else if (GRID(state, flags, x+1, y) & F_GT_LEFT)
- *p++ = '<';
- else
- *p++ = ' ';
+ if (state->adjacent) {+ *p++ = (GRID(state, flags, x, y) & F_ADJ_RIGHT) ? '|' : ' ';
+ } else {+ if (GRID(state, flags, x, y) & F_ADJ_RIGHT)
+ *p++ = '>';
+ else if (GRID(state, flags, x+1, y) & F_ADJ_LEFT)
+ *p++ = '<';
+ else
+ *p++ = ' ';
+ }
}
}
*p++ = '\n';
@@ -440,12 +483,16 @@
if (y < (state->order-1)) { for (x = 0; x < state->order; x++) {- if (GRID(state, flags, x, y) & F_GT_DOWN)
- *p++ = 'v';
- else if (GRID(state, flags, x, y+1) & F_GT_UP)
- *p++ = '^';
- else
- *p++ = ' ';
+ if (state->adjacent) {+ *p++ = (GRID(state, flags, x, y) & F_ADJ_DOWN) ? '-' : ' ';
+ } else {+ if (GRID(state, flags, x, y) & F_ADJ_DOWN)
+ *p++ = 'v';
+ else if (GRID(state, flags, x, y+1) & F_ADJ_UP)
+ *p++ = '^';
+ else
+ *p++ = ' ';
+ }
if (x < state->order-1)
*p++ = ' ';
@@ -528,13 +575,16 @@
solver->nlinks = solver->alinks = 0;
solver->links = NULL;
+ solver->state = state;
+ if (state->adjacent) return solver; /* 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 & gtthan[i].f)
- solver_add_link(solver, x, y, x+gtthan[i].dx, y+gtthan[i].dy, 1);
+ if (f & adjthan[i].f)
+ solver_add_link(solver, x, y, x+adjthan[i].dx, y+adjthan[i].dy, 1);
}
}
}
@@ -630,6 +680,120 @@
return nchanged;
}
+static int solver_adjacent(game_solver *usolver)
+{+ struct latin_solver *solver = &usolver->latin;
+ int nchanged = 0, x, y, i, n, o = usolver->latin.o, nx, ny, gd;
+
+ /* Update possible values based on known values and adjacency clues. */
+
+ for (x = 0; x < o; x++) {+ for (y = 0; y < o; y++) {+ if (grid(x, y) == 0) continue;
+
+ /* We have a definite number here. Make sure that any
+ * 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);
+
+ nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
+ if (nx < 0 || ny < 0 || nx >= o || ny >= o)
+ continue;
+
+ for (n = 0; n < o; n++) {+ /* Continue past numbers the adjacent square _could_ be,
+ * given the clue we have. */
+ gd = abs((n+1) - grid(x, y));
+ if (isadjacent && (gd == 1)) continue;
+ if (!isadjacent && (gd != 1)) continue;
+
+ if (cube(nx, ny, n+1) == FALSE)
+ continue; /* already discounted this possibility. */
+
+#ifdef STANDALONE_SOLVER
+ 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);
+ printf("%*s ruling out %d at (%d,%d)\n",+ solver_recurse_depth*4, "", n+1, nx, ny);
+ }
+#endif
+ cube(nx, ny, n+1) = FALSE;
+ nchanged++;
+ }
+ }
+ }
+ }
+
+ return nchanged;
+}
+
+static int solver_adjacent_set(game_solver *usolver)
+{+ struct latin_solver *solver = &usolver->latin;
+ int x, y, i, n, nn, o = usolver->latin.o, nx, ny, gd;
+ int nchanged = 0, *scratch = snewn(o, int);
+
+ /* Update possible values based on other possible values
+ * of adjacent squares, and adjacency clues. */
+
+ 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);
+
+ nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
+ if (nx < 0 || ny < 0 || nx >= o || ny >= o)
+ continue;
+
+ /* We know the current possibles for the square (x,y)
+ * and also the adjacency clue from (x,y) to (nx,ny).
+ * Construct a maximum set of possibles for (nx,ny)
+ * in scratch, based on these constraints... */
+
+ memset(scratch, 0, o*sizeof(int));
+
+ for (n = 0; n < o; n++) {+ if (cube(x, y, n+1) == FALSE) continue;
+
+ for (nn = 0; nn < o; nn++) {+ if (n == nn) continue;
+
+ gd = abs(nn - n);
+ if (isadjacent && (gd != 1)) continue;
+ if (!isadjacent && (gd == 1)) continue;
+
+ scratch[nn] = 1;
+ }
+ }
+
+ /* ...and remove any possibilities for (nx,ny) that are
+ * currently set but are not indicated in scratch. */
+ for (n = 0; n < o; n++) {+ if (scratch[n] == 1) continue;
+ if (cube(nx, ny, n+1) == FALSE) continue;
+
+#ifdef STANDALONE_SOLVER
+ if (solver_show_working) {+ printf("%*sadjacent possible elimination, (%d,%d) %s (%d,%d):\n",+ solver_recurse_depth*4, "",
+ x, y, isadjacent ? "|" : "!|", nx, ny);
+ printf("%*s ruling out %d at (%d,%d)\n",+ solver_recurse_depth*4, "", n+1, nx, ny);
+ }
+#endif
+ cube(nx, ny, n+1) = FALSE;
+ nchanged++;
+ }
+ }
+ }
+ }
+
+ return nchanged;
+}
+
static int solver_grid(digit *grid, int o, int maxdiff, void *ctx)
{game_state *state = (game_state *)ctx;
@@ -660,8 +824,15 @@
if (maxdiff <= DIFF_LATIN)
break;
- /* This bit is unequal-specific */
- ret = solver_links(solver);
+ 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;
@@ -683,6 +854,19 @@
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;
@@ -819,20 +1003,24 @@
} else { /* add flag */int lx, ly, lloc;
- if (state->flags[loc] & gtthan[which].f)
+ if (state->adjacent)
+ return 0; /* never add flag clues in adjacent mode (they're always
+ all present) */
+
+ if (state->flags[loc] & adjthan[which].f)
return 0; /* already has flag. */
- lx = x + gtthan[which].dx;
- ly = y + gtthan[which].dy;
+ lx = x + adjthan[which].dx;
+ ly = y + adjthan[which].dy;
if (lx < 0 || ly < 0 || lx >= state->order || ly >= state->order)
return 0; /* flag compares to off grid */
- lloc = loc + gtthan[which].dx + gtthan[which].dy*state->order;
+ lloc = loc + adjthan[which].dx + adjthan[which].dy*state->order;
if (latin[loc] <= latin[lloc])
return 0; /* flag would be incorrect */
if (!checkonly) {- state->flags[loc] |= gtthan[which].f;
+ state->flags[loc] |= adjthan[which].f;
}
}
return 1;
@@ -859,14 +1047,17 @@
state->nums[loc] = 0;
}
} else { /* remove flag */- if (!(state->flags[loc] & gtthan[which].f)) return 0;
+ if (state->adjacent)
+ return 0; /* never remove clues in adjacent mode. */
+
+ if (!(state->flags[loc] & adjthan[which].f)) return 0;
if (!checkonly) {#ifdef STANDALONE_SOLVER
if (solver_show_working)
printf("gg_remove_clue: removing %c at (%d,%d)",- gtthan[which].c, x, y);
+ adjthan[which].c, x, y);
#endif
- state->flags[loc] &= ~gtthan[which].f;
+ state->flags[loc] &= ~adjthan[which].f;
}
}
return 1;
@@ -894,7 +1085,7 @@
if (state->hints[loc*state->order + j]) nposs++;
}
for (j = nclues = 0; j < 4; j++) {- if (state->flags[loc] & gtthan[j].f) nclues++;
+ if (state->flags[loc] & adjthan[j].f) nclues++;
}
if ((nposs > maxposs) ||
(nposs == maxposs && nclues < minclues)) {@@ -964,7 +1155,7 @@
int difficulty)
{int o = new->order, o2 = o*o, lscratch = o2*5, i;
- game_state *copy = blank_game(new->order);
+ game_state *copy = blank_game(new->order, new->adjacent);
/* For each symbol (if it exists in new), try and remove it and
* solve again; if we couldn't solve without it put it back. */
@@ -996,6 +1187,28 @@
#endif
}
+static void add_adjacent_flags(game_state *state, digit *latin)
+{+ int x, y, o = state->order;
+
+ /* All clues in adjacent mode are always present (the only variables are
+ * the numbers). This adds all the flags to state based on the supplied
+ * latin square. */
+
+ for (y = 0; y < o; y++) {+ for (x = 0; x < o; x++) {+ if (x < (o-1) && (abs(latin[y*o+x] - latin[y*o+x+1]) == 1)) {+ GRID(state, flags, x, y) |= F_ADJ_RIGHT;
+ GRID(state, flags, x+1, y) |= F_ADJ_LEFT;
+ }
+ if (y < (o-1) && (abs(latin[y*o+x] - latin[(y+1)*o+x]) == 1)) {+ GRID(state, flags, x, y) |= F_ADJ_DOWN;
+ GRID(state, flags, x, y+1) |= F_ADJ_UP;
+ }
+ }
+ }
+}
+
static char *new_game_desc(game_params *params, random_state *rs,
char **aux, int interactive)
{@@ -1004,7 +1217,7 @@
int o2 = params->order * params->order, ntries = 1;
int *scratch, lscratch = o2*5;
char *ret, buf[80];
- game_state *state = blank_game(params->order);
+ game_state *state = blank_game(params->order, params->adjacent);
/* Generate a list of 'things to strip' (randomised later) */
scratch = snewn(lscratch, int);
@@ -1014,7 +1227,7 @@
generate:
#ifdef STANDALONE_SOLVER
if (solver_show_working)
- printf("new_game_desc: generating %s puzzle, ntries so far %d",+ printf("new_game_desc: generating %s puzzle, ntries so far %d\n",unequal_diffnames[params->diff], ntries);
#endif
if (sq) sfree(sq);
@@ -1027,6 +1240,11 @@
memset(state->nums, 0, o2 * sizeof(digit));
memset(state->flags, 0, o2 * sizeof(unsigned int));
+ if (state->adjacent) {+ /* All adjacency flags are always present. */
+ add_adjacent_flags(state, sq);
+ }
+
gg_solved = 0;
if (game_assemble(state, scratch, sq, params->diff) < 0)
goto generate;
@@ -1066,10 +1284,10 @@
unsigned int f = GRID(state, flags, x, y);
k = sprintf(buf, "%d%s%s%s%s,",
GRID(state, nums, x, y),
- (f & F_GT_UP) ? "U" : "",
- (f & F_GT_RIGHT) ? "R" : "",
- (f & F_GT_DOWN) ? "D" : "",
- (f & F_GT_LEFT) ? "L" : "");
+ (f & F_ADJ_UP) ? "U" : "",
+ (f & F_ADJ_RIGHT) ? "R" : "",
+ (f & F_ADJ_DOWN) ? "D" : "",
+ (f & F_ADJ_LEFT) ? "L" : "");
ret = sresize(ret, retlen + k + 1, char);
strcpy(ret + retlen, buf);
@@ -1088,7 +1306,7 @@
static game_state *load_game(game_params *params, char *desc,
char **why_r)
{- game_state *state = blank_game(params->order);
+ game_state *state = blank_game(params->order, params->adjacent);
char *p = desc;
int i = 0, n, o = params->order, x, y;
char *why = NULL;
@@ -1117,10 +1335,10 @@
while (*p == 'U' || *p == 'R' || *p == 'D' || *p == 'L') { switch (*p) {- case 'U': state->flags[i] |= F_GT_UP; break;
- case 'R': state->flags[i] |= F_GT_RIGHT; break;
- case 'D': state->flags[i] |= F_GT_DOWN; break;
- case 'L': state->flags[i] |= F_GT_LEFT; break;
+ case 'U': state->flags[i] |= F_ADJ_UP; break;
+ case 'R': state->flags[i] |= F_ADJ_RIGHT; break;
+ case 'D': state->flags[i] |= F_ADJ_DOWN; break;
+ case 'L': state->flags[i] |= F_ADJ_LEFT; break;
default: why = "Expecting flag URDL in game description"; goto fail;
}
p++;
@@ -1138,17 +1356,25 @@
for (y = 0; y < o; y++) { for (x = 0; x < o; x++) { for (n = 0; n < 4; n++) {- if (GRID(state, flags, x, y) & gtthan[n].f) {- int nx = x + gtthan[n].dx;
- int ny = y + gtthan[n].dy;
+ if (GRID(state, flags, x, y) & adjthan[n].f) {+ int nx = x + adjthan[n].dx;
+ int ny = y + adjthan[n].dy;
/* a flag must not point us off the grid. */
if (nx < 0 || ny < 0 || nx >= o || ny >= o) {why = "Flags go off grid"; goto fail;
}
- /* if one cell is GT another, the other must not also
- * be GT the first. */
- if (GRID(state, flags, nx, ny) & gtthan[n].fo) {- why = "Flags contradicting each other"; goto fail;
+ if (params->adjacent) {+ /* if one cell is adjacent to another, the other must
+ * also be adjacent to the first. */
+ if (!(GRID(state, flags, nx, ny) & adjthan[n].fo)) {+ why = "Flags contradicting each other"; goto fail;
+ }
+ } else {+ /* if one cell is GT another, the other must _not_ also
+ * be GT the first. */
+ if (GRID(state, flags, nx, ny) & adjthan[n].fo) {+ why = "Flags contradicting each other"; goto fail;
+ }
}
}
}
@@ -1251,7 +1477,7 @@
}
struct game_drawstate {- int tilesize, order, started;
+ int tilesize, order, started, adjacent;
digit *nums; /* copy of nums, o^2 */
unsigned char *hints; /* copy of hints, o^3 */
unsigned int *flags; /* o^2 */
@@ -1465,6 +1691,7 @@
ds->tilesize = 0;
ds->order = state->order;
+ ds->adjacent = state->adjacent;
ds->nums = snewn(o2, digit);
ds->hints = snewn(o3, unsigned char);
@@ -1495,32 +1722,71 @@
}
static void draw_gts(drawing *dr, game_drawstate *ds, int ox, int oy,
- unsigned int f, int col, int needsupdate)
+ unsigned int f, int col)
{int g = GAP_SIZE, g2 = (g+1)/2, g4 = (g+1)/4;
- if (f & F_GT_UP) {+ /* Draw all the greater-than signs emanating from this tile. */
+
+ if (f & F_ADJ_UP) {draw_gt(dr, ox+g2, oy-g4, g2, -g2, g2, g2,
(f & F_ERROR_UP) ? COL_ERROR : col);
- if (needsupdate) draw_update(dr, ox, oy-g, TILE_SIZE, g);
+ draw_update(dr, ox, oy-g, TILE_SIZE, g);
}
- if (f & F_GT_RIGHT) {+ if (f & F_ADJ_RIGHT) {draw_gt(dr, ox+TILE_SIZE+g4, oy+g2, g2, g2, -g2, g2,
(f & F_ERROR_RIGHT) ? COL_ERROR : col);
- if (needsupdate) draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE);
+ draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE);
}
- if (f & F_GT_DOWN) {+ if (f & F_ADJ_DOWN) {draw_gt(dr, ox+g2, oy+TILE_SIZE+g4, g2, g2, g2, -g2,
(f & F_ERROR_DOWN) ? COL_ERROR : col);
- if (needsupdate) draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g);
+ draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g);
}
- if (f & F_GT_LEFT) {+ if (f & F_ADJ_LEFT) {draw_gt(dr, ox-g4, oy+g2, -g2, g2, g2, g2,
(f & F_ERROR_LEFT) ? COL_ERROR : col);
- if (needsupdate) draw_update(dr, ox-g, oy, g, TILE_SIZE);
+ 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)
+{+ int g = GAP_SIZE, g38 = 3*(g+1)/8, g4 = (g+1)/4;
+
+ /* Draw all the adjacency bars relevant to this tile; we only have
+ * to worry about F_ADJ_RIGHT and F_ADJ_DOWN.
+ *
+ * If we _only_ have the error flag set (i.e. it's not supposed to be
+ * adjacent, but adjacent numbers were entered) draw an outline red bar.
+ */
+
+ 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);
+ } 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);
+ }
+ 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);
+ } 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);
+ }
+ 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)
{@@ -1552,8 +1818,11 @@
draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
- /* Draw the GT signs. */
- draw_gts(dr, ds, ox, oy, f, COL_TEXT, 1);
+ /* Draw the adjacent clue signs. */
+ if (ds->adjacent)
+ draw_adjs(dr, ds, ox, oy, f, COL_GRID);
+ else
+ draw_gts(dr, ds, ox, oy, f, COL_TEXT);
}
static void draw_num(drawing *dr, game_drawstate *ds, int x, int y)
@@ -1735,7 +2004,10 @@
FONT_VARIABLE, TILE_SIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE,
ink, str);
- draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), ink, 1);
+ if (ds->adjacent)
+ draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), ink);
+ else
+ draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), ink);
}
}
}
@@ -1907,7 +2179,8 @@
tt_start = tt_now = time(NULL);
- printf("Soak-generating a %dx%d grid, difficulty %s.\n",+ printf("Soak-generating an %s %dx%d grid, difficulty %s.\n",+ p->adjacent ? "adjacent" : "unequal",
p->order, p->order, unequal_diffnames[p->diff]);
while (1) {