int c, r;
digit *grid;
unsigned char *immutable; /* marks which digits are clues */
- int completed;
+ int completed, cheated;
};
static game_params *default_params(void)
ret->c = ret->r = 3;
ret->symm = SYMM_ROT2; /* a plausible default */
- ret->diff = DIFF_SIMPLE; /* so is this */
+ ret->diff = DIFF_BLOCK; /* so is this */
return ret;
}
} presets[] = {
{ "2x2 Trivial", { 2, 2, SYMM_ROT2, DIFF_BLOCK } },
{ "2x3 Basic", { 2, 3, SYMM_ROT2, DIFF_SIMPLE } },
+ { "3x3 Trivial", { 3, 3, SYMM_ROT2, DIFF_BLOCK } },
{ "3x3 Basic", { 3, 3, SYMM_ROT2, DIFF_SIMPLE } },
{ "3x3 Intermediate", { 3, 3, SYMM_ROT2, DIFF_INTERSECT } },
{ "3x3 Advanced", { 3, 3, SYMM_ROT2, DIFF_SET } },
+ { "3x3 Unreasonable", { 3, 3, SYMM_ROT2, DIFF_RECURSIVE } },
{ "3x4 Basic", { 3, 4, SYMM_ROT2, DIFF_SIMPLE } },
{ "4x4 Basic", { 4, 4, SYMM_ROT2, DIFF_SIMPLE } },
};
return TRUE;
}
-static game_params *decode_params(char const *string)
+static void decode_params(game_params *ret, char const *string)
{
- game_params *ret = default_params();
-
ret->c = ret->r = atoi(string);
- ret->symm = SYMM_ROT2;
while (*string && isdigit((unsigned char)*string)) string++;
if (*string == 'x') {
string++;
string++, ret->diff = DIFF_INTERSECT;
else if (*string == 'a') /* advanced */
string++, ret->diff = DIFF_SET;
+ else if (*string == 'u') /* unreasonable */
+ string++, ret->diff = DIFF_RECURSIVE;
} else
string++; /* eat unknown character */
}
-
- return ret;
}
-static char *encode_params(game_params *params)
+static char *encode_params(game_params *params, int full)
{
char str[80];
- /*
- * Symmetry is a game generation preference and hence is left
- * out of the encoding. Users can add it back in as they see
- * fit.
- */
sprintf(str, "%dx%d", params->c, params->r);
+ if (full) {
+ switch (params->symm) {
+ case SYMM_REF4: strcat(str, "m4"); break;
+ case SYMM_ROT4: strcat(str, "r4"); break;
+ /* case SYMM_ROT2: strcat(str, "r2"); break; [default] */
+ case SYMM_NONE: strcat(str, "a"); break;
+ }
+ switch (params->diff) {
+ /* case DIFF_BLOCK: strcat(str, "dt"); break; [default] */
+ case DIFF_SIMPLE: strcat(str, "db"); break;
+ case DIFF_INTERSECT: strcat(str, "di"); break;
+ case DIFF_SET: strcat(str, "da"); break;
+ case DIFF_RECURSIVE: strcat(str, "du"); break;
+ }
+ }
return dupstr(str);
}
ret[3].name = "Difficulty";
ret[3].type = C_CHOICES;
- ret[3].sval = ":Trivial:Basic:Intermediate:Advanced";
+ ret[3].sval = ":Trivial:Basic:Intermediate:Advanced:Unreasonable";
ret[3].ival = params->diff;
ret[4].name = NULL;
return i;
}
-static char *new_game_seed(game_params *params, random_state *rs,
+struct game_aux_info {
+ int c, r;
+ digit *grid;
+};
+
+static char *new_game_desc(game_params *params, random_state *rs,
game_aux_info **aux)
{
int c = params->c, r = params->r, cr = c*r;
struct xy { int x, y; } *locs;
int nlocs;
int ret;
- char *seed;
+ char *desc;
int coords[16], ncoords;
int xlim, ylim;
- int maxdiff;
+ int maxdiff, recursing;
/*
* Adjust the maximum difficulty level to be consistent with
assert(ret == 1);
assert(check_valid(c, r, grid));
+ /*
+ * Save the solved grid in the aux_info.
+ */
+ {
+ game_aux_info *ai = snew(game_aux_info);
+ ai->c = c;
+ ai->r = r;
+ ai->grid = snewn(cr * cr, digit);
+ memcpy(ai->grid, grid, cr * cr * sizeof(digit));
+ *aux = ai;
+ }
+
/*
* Now we have a solved grid, start removing things from it
* while preserving solubility.
*/
symmetry_limit(params, &xlim, &ylim, params->symm);
+ recursing = FALSE;
while (1) {
int x, y, i, j;
* nsolve.
*/
for (i = 0; i < nlocs; i++) {
+ int ret;
+
x = locs[i].x;
y = locs[i].y;
for (j = 0; j < ncoords; j++)
grid2[coords[2*j+1]*cr+coords[2*j]] = 0;
- if (nsolve(c, r, grid2) <= maxdiff) {
+ if (recursing)
+ ret = (rsolve(c, r, grid2, NULL, 2) == 1);
+ else
+ ret = (nsolve(c, r, grid2) <= maxdiff);
+
+ if (ret) {
for (j = 0; j < ncoords; j++)
grid[coords[2*j+1]*cr+coords[2*j]] = 0;
break;
if (i == nlocs) {
/*
- * There was nothing we could remove without destroying
- * solvability.
+ * There was nothing we could remove without
+ * destroying solvability. If we're trying to
+ * generate a recursion-only grid and haven't
+ * switched over to rsolve yet, we now do;
+ * otherwise we give up.
*/
- break;
+ if (maxdiff == DIFF_RECURSIVE && !recursing) {
+ recursing = TRUE;
+ } else {
+ break;
+ }
}
}
memcpy(grid2, grid, area);
- } while (nsolve(c, r, grid2) != maxdiff);
+ } while (nsolve(c, r, grid2) < maxdiff);
sfree(grid2);
sfree(locs);
/*
* Now we have the grid as it will be presented to the user.
- * Encode it in a game seed.
+ * Encode it in a game desc.
*/
{
char *p;
int run, i;
- seed = snewn(5 * area, char);
- p = seed;
+ desc = snewn(5 * area, char);
+ p = desc;
run = 0;
for (i = 0; i <= area; i++) {
int n = (i < area ? grid[i] : -1);
* bottom right, there's no point putting an
* unnecessary _ before or after it.
*/
- if (p > seed && n > 0)
+ if (p > desc && n > 0)
*p++ = '_';
}
if (n > 0)
run = 0;
}
}
- assert(p - seed < 5 * area);
+ assert(p - desc < 5 * area);
*p++ = '\0';
- seed = sresize(seed, p - seed, char);
+ desc = sresize(desc, p - desc, char);
}
sfree(grid);
- return seed;
+ return desc;
}
-void game_free_aux_info(game_aux_info *aux)
+static void game_free_aux_info(game_aux_info *aux)
{
- assert(!"Shouldn't happen");
+ sfree(aux->grid);
+ sfree(aux);
}
-static char *validate_seed(game_params *params, char *seed)
+static char *validate_desc(game_params *params, char *desc)
{
int area = params->r * params->r * params->c * params->c;
int squares = 0;
- while (*seed) {
- int n = *seed++;
+ while (*desc) {
+ int n = *desc++;
if (n >= 'a' && n <= 'z') {
squares += n - 'a' + 1;
} else if (n == '_') {
/* do nothing */;
} else if (n > '0' && n <= '9') {
squares++;
- while (*seed >= '0' && *seed <= '9')
- seed++;
+ while (*desc >= '0' && *desc <= '9')
+ desc++;
} else
- return "Invalid character in game specification";
+ return "Invalid character in game description";
}
if (squares < area)
return NULL;
}
-static game_state *new_game(game_params *params, char *seed)
+static game_state *new_game(game_params *params, char *desc)
{
game_state *state = snew(game_state);
int c = params->c, r = params->r, cr = c*r, area = cr * cr;
state->immutable = snewn(area, unsigned char);
memset(state->immutable, FALSE, area);
- state->completed = FALSE;
+ state->completed = state->cheated = FALSE;
i = 0;
- while (*seed) {
- int n = *seed++;
+ while (*desc) {
+ int n = *desc++;
if (n >= 'a' && n <= 'z') {
int run = n - 'a' + 1;
assert(i + run <= area);
} else if (n > '0' && n <= '9') {
assert(i < area);
state->immutable[i] = TRUE;
- state->grid[i++] = atoi(seed-1);
- while (*seed >= '0' && *seed <= '9')
- seed++;
+ state->grid[i++] = atoi(desc-1);
+ while (*desc >= '0' && *desc <= '9')
+ desc++;
} else {
assert(!"We can't get here");
}
memcpy(ret->immutable, state->immutable, area);
ret->completed = state->completed;
+ ret->cheated = state->cheated;
return ret;
}
sfree(state);
}
+static game_state *solve_game(game_state *state, game_aux_info *ai,
+ char **error)
+{
+ game_state *ret;
+ int c = state->c, r = state->r, cr = c*r;
+ int rsolve_ret;
+
+ ret = dup_game(state);
+ ret->completed = ret->cheated = TRUE;
+
+ /*
+ * If we already have the solution in the aux_info, save
+ * ourselves some time.
+ */
+ if (ai) {
+
+ assert(c == ai->c);
+ assert(r == ai->r);
+ memcpy(ret->grid, ai->grid, cr * cr * sizeof(digit));
+
+ } else {
+ rsolve_ret = rsolve(c, r, ret->grid, NULL, 2);
+
+ if (rsolve_ret != 1) {
+ free_game(ret);
+ if (rsolve_ret == 0)
+ *error = "No solution exists for this puzzle";
+ else
+ *error = "Multiple solutions exist for this puzzle";
+ return NULL;
+ }
+ }
+
+ return ret;
+}
+
static char *grid_text_format(int c, int r, digit *grid)
{
int cr = c*r;
int tx, ty;
game_state *ret;
+ button &= ~MOD_NUM_KEYPAD; /* we treat this the same as normal */
+
tx = (x + TILE_SIZE - BORDER) / TILE_SIZE - 1;
ty = (y + TILE_SIZE - BORDER) / TILE_SIZE - 1;
static float game_flash_length(game_state *oldstate, game_state *newstate,
int dir)
{
- if (!oldstate->completed && newstate->completed)
+ if (!oldstate->completed && newstate->completed &&
+ !oldstate->cheated && !newstate->cheated)
return FLASH_TIME;
return 0.0F;
}
dup_params,
TRUE, game_configure, custom_params,
validate_params,
- new_game_seed,
+ new_game_desc,
game_free_aux_info,
- validate_seed,
+ validate_desc,
new_game,
dup_game,
free_game,
+ TRUE, solve_game,
TRUE, game_text_format,
new_ui,
free_ui,
game_params *p;
game_state *s;
int recurse = TRUE;
- char *id = NULL, *seed, *err;
+ char *id = NULL, *desc, *err;
int y, x;
int grade = FALSE;
return 1;
}
- seed = strchr(id, ':');
- if (!seed) {
+ desc = strchr(id, ':');
+ if (!desc) {
fprintf(stderr, "%s: game id expects a colon in it\n", argv[0]);
return 1;
}
- *seed++ = '\0';
+ *desc++ = '\0';
- p = decode_params(id);
- err = validate_seed(p, seed);
+ 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(p, seed);
+ s = new_game(p, desc);
if (recurse) {
int ret = rsolve(p->c, p->r, s->grid, NULL, 2);
~mdw / sgt / puzzles / blobdiff