/*
* pattern.c: the pattern-reconstruction game known as `nonograms'.
- *
- * TODO before checkin:
- *
- * - make some sort of stab at number-of-numbers judgment
*/
#include <stdio.h>
#include "puzzles.h"
-#define max(x,y) ( (x)>(y) ? (x):(y) )
-#define min(x,y) ( (x)<(y) ? (x):(y) )
-
enum {
COL_BACKGROUND,
COL_EMPTY,
unsigned char *grid;
int rowsize;
int *rowdata, *rowlen;
- int completed;
+ int completed, cheated;
};
#define FLASH_TIME 0.13F
return ret;
}
+static const struct game_params pattern_presets[] = {
+ {10, 10},
+ {15, 15},
+ {20, 20},
+#ifndef SLOW_SYSTEM
+ {25, 25},
+ {30, 30},
+#endif
+};
+
static int game_fetch_preset(int i, char **name, game_params **params)
{
game_params *ret;
char str[80];
- static const struct { int x, y; } values[] = {
- {10, 10},
- {15, 15},
- {20, 20},
- {25, 25},
- {30, 30},
- };
-
- if (i < 0 || i >= lenof(values))
+
+ if (i < 0 || i >= lenof(pattern_presets))
return FALSE;
ret = snew(game_params);
- ret->w = values[i].x;
- ret->h = values[i].y;
+ *ret = pattern_presets[i];
sprintf(str, "%dx%d", ret->w, ret->h);
return ret;
}
-static game_params *decode_params(char const *string)
+static void decode_params(game_params *ret, char const *string)
{
- game_params *ret = default_params();
char const *p = string;
ret->w = atoi(p);
} else {
ret->h = ret->w;
}
-
- return ret;
}
-static char *encode_params(game_params *params)
+static char *encode_params(game_params *params, int full)
{
char ret[400];
int len;
static char *validate_params(game_params *params)
{
- if (params->w <= 0 && params->h <= 0)
+ if (params->w <= 0 || params->h <= 0)
return "Width and height must both be greater than zero";
- if (params->w <= 0)
- return "Width must be greater than zero";
- if (params->h <= 0)
- return "Height must be greater than zero";
return NULL;
}
return grid;
}
-static char *new_game_seed(game_params *params, random_state *rs,
- game_aux_info **aux)
+struct game_aux_info {
+ int w, h;
+ unsigned char *grid;
+};
+
+static char *new_game_desc(game_params *params, random_state *rs,
+ game_aux_info **aux, int interactive)
{
unsigned char *grid;
int i, j, max, rowlen, *rowdata;
- char intbuf[80], *seed;
- int seedlen, seedpos;
+ char intbuf[80], *desc;
+ int desclen, descpos;
grid = generate_soluble(rs, params->w, params->h);
max = max(params->w, params->h);
rowdata = snewn(max, int);
/*
+ * Save the solved game in an aux_info.
+ */
+ {
+ game_aux_info *ai = snew(game_aux_info);
+
+ ai->w = params->w;
+ ai->h = params->h;
+ ai->grid = grid;
+
+ *aux = ai;
+ }
+
+ /*
* Seed is a slash-separated list of row contents; each row
* contents section is a dot-separated list of integers. Row
* contents are listed in the order (columns left to right,
* passes, first computing the seed size and then writing it
* out.
*/
- seedlen = 0;
+ desclen = 0;
for (i = 0; i < params->w + params->h; i++) {
if (i < params->w)
rowlen = compute_rowdata(rowdata, grid+i, params->h, params->w);
params->w, 1);
if (rowlen > 0) {
for (j = 0; j < rowlen; j++) {
- seedlen += 1 + sprintf(intbuf, "%d", rowdata[j]);
+ desclen += 1 + sprintf(intbuf, "%d", rowdata[j]);
}
} else {
- seedlen++;
+ desclen++;
}
}
- seed = snewn(seedlen, char);
- seedpos = 0;
+ desc = snewn(desclen, char);
+ descpos = 0;
for (i = 0; i < params->w + params->h; i++) {
if (i < params->w)
rowlen = compute_rowdata(rowdata, grid+i, params->h, params->w);
params->w, 1);
if (rowlen > 0) {
for (j = 0; j < rowlen; j++) {
- int len = sprintf(seed+seedpos, "%d", rowdata[j]);
+ int len = sprintf(desc+descpos, "%d", rowdata[j]);
if (j+1 < rowlen)
- seed[seedpos + len] = '.';
+ desc[descpos + len] = '.';
else
- seed[seedpos + len] = '/';
- seedpos += len+1;
+ desc[descpos + len] = '/';
+ descpos += len+1;
}
} else {
- seed[seedpos++] = '/';
+ desc[descpos++] = '/';
}
}
- assert(seedpos == seedlen);
- assert(seed[seedlen-1] == '/');
- seed[seedlen-1] = '\0';
+ assert(descpos == desclen);
+ assert(desc[desclen-1] == '/');
+ desc[desclen-1] = '\0';
sfree(rowdata);
- 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 i, n, rowspace;
char *p;
else
rowspace = params->w + 1;
- if (*seed && isdigit((unsigned char)*seed)) {
+ if (*desc && isdigit((unsigned char)*desc)) {
do {
- p = seed;
- while (seed && isdigit((unsigned char)*seed)) seed++;
+ p = desc;
+ while (desc && isdigit((unsigned char)*desc)) desc++;
n = atoi(p);
rowspace -= n+1;
else
return "at least one row contains more numbers than will fit";
}
- } while (*seed++ == '.');
+ } while (*desc++ == '.');
} else {
- seed++; /* expect a slash immediately */
+ desc++; /* expect a slash immediately */
}
- if (seed[-1] == '/') {
+ if (desc[-1] == '/') {
if (i+1 == params->w + params->h)
return "too many row/column specifications";
- } else if (seed[-1] == '\0') {
+ } else if (desc[-1] == '\0') {
if (i+1 < params->w + params->h)
return "too few row/column specifications";
} else
return NULL;
}
-static game_state *new_game(game_params *params, char *seed)
+static game_state *new_game(midend_data *me, game_params *params, char *desc)
{
int i;
char *p;
state->rowdata = snewn(state->rowsize * (state->w + state->h), int);
state->rowlen = snewn(state->w + state->h, int);
- state->completed = FALSE;
+ state->completed = state->cheated = FALSE;
for (i = 0; i < params->w + params->h; i++) {
state->rowlen[i] = 0;
- if (*seed && isdigit((unsigned char)*seed)) {
+ if (*desc && isdigit((unsigned char)*desc)) {
do {
- p = seed;
- while (seed && isdigit((unsigned char)*seed)) seed++;
+ p = desc;
+ while (desc && isdigit((unsigned char)*desc)) desc++;
state->rowdata[state->rowsize * i + state->rowlen[i]++] =
atoi(p);
- } while (*seed++ == '.');
+ } while (*desc++ == '.');
} else {
- seed++; /* expect a slash immediately */
+ desc++; /* expect a slash immediately */
}
}
(ret->w + ret->h) * sizeof(int));
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;
+
+ ret = dup_game(state);
+ ret->completed = ret->cheated = TRUE;
+
+ /*
+ * If we already have the solved state in an aux_info, copy it
+ * out.
+ */
+ if (ai) {
+
+ assert(ret->w == ai->w);
+ assert(ret->h == ai->h);
+ memcpy(ret->grid, ai->grid, ai->w * ai->h);
+
+ } else {
+ int w = state->w, h = state->h, i, j, done_any, max;
+ unsigned char *matrix, *workspace;
+ int *rowdata;
+
+ matrix = snewn(w*h, unsigned char);
+ max = max(w, h);
+ workspace = snewn(max*3, unsigned char);
+ rowdata = snewn(max+1, int);
+
+ memset(matrix, 0, w*h);
+
+ do {
+ done_any = 0;
+ for (i=0; i<h; i++) {
+ memcpy(rowdata, state->rowdata + state->rowsize*(w+i),
+ max*sizeof(int));
+ rowdata[state->rowlen[w+i]] = 0;
+ done_any |= do_row(workspace, workspace+max, workspace+2*max,
+ matrix+i*w, w, 1, rowdata);
+ }
+ for (i=0; i<w; i++) {
+ memcpy(rowdata, state->rowdata + state->rowsize*i, max*sizeof(int));
+ rowdata[state->rowlen[i]] = 0;
+ done_any |= do_row(workspace, workspace+max, workspace+2*max,
+ matrix+i, h, w, rowdata);
+ }
+ } while (done_any);
+
+ for (i = 0; i < h; i++) {
+ for (j = 0; j < w; j++) {
+ int c = (matrix[i*w+j] == BLOCK ? GRID_FULL :
+ matrix[i*w+j] == DOT ? GRID_EMPTY : GRID_UNKNOWN);
+ ret->grid[i*w+j] = c;
+ if (c == GRID_UNKNOWN)
+ ret->completed = FALSE;
+ }
+ }
+
+ if (!ret->completed) {
+ free_game(ret);
+ *error = "Solving algorithm cannot complete this puzzle";
+ return NULL;
+ }
+ }
+
+ return ret;
+}
+
static char *game_text_format(game_state *state)
{
return NULL;
sfree(ui);
}
-static game_state *make_move(game_state *from, game_ui *ui,
- int x, int y, int button)
-{
+static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
+ int x, int y, int button) {
game_state *ret;
+ button &= ~MOD_MASK;
+
x = FROMCOORD(from->w, x);
y = FROMCOORD(from->h, y);
}
static float game_anim_length(game_state *oldstate,
- game_state *newstate, int dir)
+ 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_state *newstate, int dir, game_ui *ui)
{
- if (!oldstate->completed && newstate->completed)
+ if (!oldstate->completed && newstate->completed &&
+ !oldstate->cheated && !newstate->cheated)
return FLASH_TIME;
return 0.0F;
}
return FALSE;
}
+static int game_timing_state(game_state *state)
+{
+ return TRUE;
+}
+
#ifdef COMBINED
#define thegame pattern
#endif
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,
FALSE, game_text_format,
new_ui,
free_ui,
game_anim_length,
game_flash_length,
game_wants_statusbar,
+ FALSE, game_timing_state,
+ 0, /* mouse_priorities */
};
#ifdef STANDALONE_SOLVER
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(NULL, p, desc);
{
int w = p->w, h = p->h, i, j, done_any, max;
~mdw / sgt / puzzles / blobdiff