#define GRID_FULL 1
#define GRID_EMPTY 0
-struct game_state {
+typedef struct game_state_common {
+ /* Parts of the game state that don't change during play. */
int w, h;
- unsigned char *grid;
int rowsize;
int *rowdata, *rowlen;
+ unsigned char *immutable;
+ int refcount;
+} game_state_common;
+
+struct game_state {
+ game_state_common *common;
+ unsigned char *grid;
int completed, cheated;
};
* it's useful to anyone.)
*/
+#ifndef STANDALONE_PICTURE_GENERATOR
static int float_compare(const void *av, const void *bv)
{
const float *a = (const float *)av;
sfree(fgrid);
}
+#endif
static int compute_rowdata(int *ret, unsigned char *start, int len, int step)
{
for (i = len - 1; i >= 0 && known[i] == DOT; i--)
freespace--;
- do_recurse(known, deduced, row, minpos_done, maxpos_done, minpos_ok, maxpos_ok, data, len, freespace, 0, 0);
+ if (rowlen == 0) {
+ memset(deduced, DOT, len);
+ } else {
+ do_recurse(known, deduced, row, minpos_done, maxpos_done, minpos_ok,
+ maxpos_ok, data, len, freespace, 0, 0);
+ }
done_any = FALSE;
for (i=0; i<len; i++)
int i, j, ok, max;
int max_h, max_w;
- assert((state!=NULL) ^ (grid!=NULL));
+ assert((state!=NULL && state->common->rowdata!=NULL) ^ (grid!=NULL));
max = max(w, h);
memset(matrix, 0, w*h);
+ if (state) {
+ for (i=0; i<w*h; i++) {
+ if (state->common->immutable[i])
+ matrix[i] = state->grid[i];
+ }
+ }
/* For each column, compute how many squares can be deduced
- * from just the row-data.
+ * from just the row-data and initial clues.
* Later, changed_* will hold how many squares were changed
* in every row/column in the previous iteration
* Changed_* is used to choose the next rows / cols to re-examine
*/
for (i=0; i<h; i++) {
- int freespace;
- if (state) {
- memcpy(rowdata, state->rowdata + state->rowsize*(w+i), max*sizeof(int));
- rowdata[state->rowlen[w+i]] = 0;
+ int freespace, rowlen;
+ if (state && state->common->rowdata) {
+ memcpy(rowdata, state->common->rowdata + state->common->rowsize*(w+i), max*sizeof(int));
+ rowlen = state->common->rowlen[w+i];
} else {
- rowdata[compute_rowdata(rowdata, grid+i*w, w, 1)] = 0;
+ rowlen = compute_rowdata(rowdata, grid+i*w, w, 1);
}
- for (j=0, freespace=w+1; rowdata[j]; j++) freespace -= rowdata[j] + 1;
- for (j=0, changed_h[i]=0; rowdata[j]; j++)
- if (rowdata[j] > freespace)
- changed_h[i] += rowdata[j] - freespace;
+ rowdata[rowlen] = 0;
+ if (rowlen == 0) {
+ changed_h[i] = w;
+ } else {
+ for (j=0, freespace=w+1; rowdata[j]; j++)
+ freespace -= rowdata[j] + 1;
+ for (j=0, changed_h[i]=0; rowdata[j]; j++)
+ if (rowdata[j] > freespace)
+ changed_h[i] += rowdata[j] - freespace;
+ }
+ for (j = 0; j < w; j++)
+ if (matrix[i*w+j])
+ changed_h[i]++;
}
for (i=0,max_h=0; i<h; i++)
if (changed_h[i] > max_h)
max_h = changed_h[i];
for (i=0; i<w; i++) {
- int freespace;
- if (state) {
- memcpy(rowdata, state->rowdata + state->rowsize*i, max*sizeof(int));
- rowdata[state->rowlen[i]] = 0;
+ int freespace, rowlen;
+ if (state && state->common->rowdata) {
+ memcpy(rowdata, state->common->rowdata + state->common->rowsize*i, max*sizeof(int));
+ rowlen = state->common->rowlen[i];
} else {
- rowdata[compute_rowdata(rowdata, grid+i, h, w)] = 0;
+ rowlen = compute_rowdata(rowdata, grid+i, h, w);
}
- for (j=0, freespace=h+1; rowdata[j]; j++) freespace -= rowdata[j] + 1;
- for (j=0, changed_w[i]=0; rowdata[j]; j++)
- if (rowdata[j] > freespace)
- changed_w[i] += rowdata[j] - freespace;
+ rowdata[rowlen] = 0;
+ if (rowlen == 0) {
+ changed_w[i] = h;
+ } else {
+ for (j=0, freespace=h+1; rowdata[j]; j++)
+ freespace -= rowdata[j] + 1;
+ for (j=0, changed_w[i]=0; rowdata[j]; j++)
+ if (rowdata[j] > freespace)
+ changed_w[i] += rowdata[j] - freespace;
+ }
+ for (j = 0; j < h; j++)
+ if (matrix[j*w+i])
+ changed_w[i]++;
}
for (i=0,max_w=0; i<w; i++)
if (changed_w[i] > max_w)
for (; max_h && max_h >= max_w; max_h--) {
for (i=0; i<h; i++) {
if (changed_h[i] >= max_h) {
- if (state) {
- memcpy(rowdata, state->rowdata + state->rowsize*(w+i), max*sizeof(int));
- rowdata[state->rowlen[w+i]] = 0;
+ if (state && state->common->rowdata) {
+ memcpy(rowdata, state->common->rowdata + state->common->rowsize*(w+i), max*sizeof(int));
+ rowdata[state->common->rowlen[w+i]] = 0;
} else {
rowdata[compute_rowdata(rowdata, grid+i*w, w, 1)] = 0;
}
for (; max_w && max_w >= max_h; max_w--) {
for (i=0; i<w; i++) {
if (changed_w[i] >= max_w) {
- if (state) {
- memcpy(rowdata, state->rowdata + state->rowsize*i, max*sizeof(int));
- rowdata[state->rowlen[i]] = 0;
+ if (state && state->common->rowdata) {
+ memcpy(rowdata, state->common->rowdata + state->common->rowsize*i, max*sizeof(int));
+ rowdata[state->common->rowlen[i]] = 0;
} else {
rowdata[compute_rowdata(rowdata, grid+i, h, w)] = 0;
}
return ok;
}
+#ifndef STANDALONE_PICTURE_GENERATOR
static unsigned char *generate_soluble(random_state *rs, int w, int h)
{
int i, j, ok, ntries, max;
sfree(rowdata);
return grid;
}
+#endif
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+unsigned char *picture;
+#endif
static char *new_game_desc(const game_params *params, random_state *rs,
char **aux, int interactive)
int i, j, max, rowlen, *rowdata;
char intbuf[80], *desc;
int desclen, descpos;
+#ifdef STANDALONE_PICTURE_GENERATOR
+ game_state *state;
+ int *index;
+#endif
- grid = generate_soluble(rs, params->w, params->h);
max = max(params->w, params->h);
+
+#ifdef STANDALONE_PICTURE_GENERATOR
+ /*
+ * Fixed input picture.
+ */
+ grid = snewn(params->w * params->h, unsigned char);
+ memcpy(grid, picture, params->w * params->h);
+
+ /*
+ * Now winnow the immutable square set as far as possible.
+ */
+ state = snew(game_state);
+ state->grid = grid;
+ state->common = snew(game_state_common);
+ state->common->rowdata = NULL;
+ state->common->immutable = snewn(params->w * params->h, unsigned char);
+ memset(state->common->immutable, 1, params->w * params->h);
+
+ index = snewn(params->w * params->h, int);
+ for (i = 0; i < params->w * params->h; i++)
+ index[i] = i;
+ shuffle(index, params->w * params->h, sizeof(*index), rs);
+
+ {
+ unsigned char *matrix = snewn(params->w*params->h, unsigned char);
+ unsigned char *workspace = snewn(max*7, unsigned char);
+ unsigned int *changed_h = snewn(max+1, unsigned int);
+ unsigned int *changed_w = snewn(max+1, unsigned int);
+ int *rowdata = snewn(max+1, int);
+ for (i = 0; i < params->w * params->h; i++) {
+ state->common->immutable[index[i]] = 0;
+ if (!solve_puzzle(state, grid, params->w, params->h,
+ matrix, workspace, changed_h, changed_w,
+ rowdata, 0))
+ state->common->immutable[index[i]] = 1;
+ }
+ sfree(workspace);
+ sfree(changed_h);
+ sfree(changed_w);
+ sfree(rowdata);
+ sfree(matrix);
+ }
+#else
+ grid = generate_soluble(rs, params->w, params->h);
+#endif
rowdata = snewn(max, int);
/*
* Save the solved game in aux.
*/
- {
+ if (aux) {
char *ai = snewn(params->w * params->h + 2, char);
/*
assert(descpos == desclen);
assert(desc[desclen-1] == '/');
desc[desclen-1] = '\0';
+#ifdef STANDALONE_PICTURE_GENERATOR
+ for (i = 0; i < params->w * params->h; i++)
+ if (state->common->immutable[i])
+ break;
+ if (i < params->w * params->h) {
+ /*
+ * At least one immutable square, so we need a suffix.
+ */
+ int run;
+
+ desc = sresize(desc, desclen + params->w * params->h + 3, char);
+ desc[descpos-1] = ',';
+
+ run = 0;
+ for (i = 0; i < params->w * params->h; i++) {
+ if (!state->common->immutable[i]) {
+ run++;
+ if (run == 25) {
+ desc[descpos++] = 'z';
+ run = 0;
+ }
+ } else {
+ desc[descpos++] = run + (grid[i] == GRID_FULL ? 'A' : 'a');
+ run = 0;
+ }
+ }
+ if (run > 0)
+ desc[descpos++] = run + 'a';
+ desc[descpos] = '\0';
+ }
+ sfree(state->common->immutable);
+ sfree(state->common);
+ sfree(state);
+#endif
sfree(rowdata);
sfree(grid);
return desc;
if (desc[-1] == '/') {
if (i+1 == params->w + params->h)
return "too many row/column specifications";
- } else if (desc[-1] == '\0') {
+ } else if (desc[-1] == '\0' || desc[-1] == ',') {
if (i+1 < params->w + params->h)
return "too few row/column specifications";
} else
return "unrecognised character in game specification";
}
+ if (desc[-1] == ',') {
+ /*
+ * Optional extra piece of game description which fills in
+ * some grid squares as extra clues.
+ */
+ i = 0;
+ while (i < params->w * params->h) {
+ int c = (unsigned char)*desc++;
+ if ((c >= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z')) {
+ int len = tolower(c) - 'a';
+ i += len;
+ if (len < 25 && i < params->w*params->h)
+ i++;
+ if (i > params->w * params->h) {
+ return "too much data in clue-squares section";
+ }
+ } else if (!c) {
+ return "too little data in clue-squares section";
+ } else {
+ return "unrecognised character in clue-squares section";
+ }
+ }
+ if (*desc) {
+ return "too much data in clue-squares section";
+ }
+ }
+
return NULL;
}
const char *p;
game_state *state = snew(game_state);
- state->w = params->w;
- state->h = params->h;
+ state->common = snew(game_state_common);
+ state->common->refcount = 1;
+
+ state->common->w = params->w;
+ state->common->h = params->h;
- state->grid = snewn(state->w * state->h, unsigned char);
- memset(state->grid, GRID_UNKNOWN, state->w * state->h);
+ state->grid = snewn(state->common->w * state->common->h, unsigned char);
+ memset(state->grid, GRID_UNKNOWN, state->common->w * state->common->h);
- state->rowsize = max(state->w, state->h);
- state->rowdata = snewn(state->rowsize * (state->w + state->h), int);
- state->rowlen = snewn(state->w + state->h, int);
+ state->common->immutable = snewn(state->common->w * state->common->h,
+ unsigned char);
+ memset(state->common->immutable, 0, state->common->w * state->common->h);
+
+ state->common->rowsize = max(state->common->w, state->common->h);
+ state->common->rowdata = snewn(state->common->rowsize * (state->common->w + state->common->h), int);
+ state->common->rowlen = snewn(state->common->w + state->common->h, int);
state->completed = state->cheated = FALSE;
for (i = 0; i < params->w + params->h; i++) {
- state->rowlen[i] = 0;
+ state->common->rowlen[i] = 0;
if (*desc && isdigit((unsigned char)*desc)) {
do {
p = desc;
while (*desc && isdigit((unsigned char)*desc)) desc++;
- state->rowdata[state->rowsize * i + state->rowlen[i]++] =
+ state->common->rowdata[state->common->rowsize * i + state->common->rowlen[i]++] =
atoi(p);
} while (*desc++ == '.');
} else {
}
}
+ if (desc[-1] == ',') {
+ /*
+ * Optional extra piece of game description which fills in
+ * some grid squares as extra clues.
+ */
+ i = 0;
+ while (i < params->w * params->h) {
+ int c = (unsigned char)*desc++;
+ int full = isupper(c), len = tolower(c) - 'a';
+ i += len;
+ if (len < 25 && i < params->w*params->h) {
+ state->grid[i] = full ? GRID_FULL : GRID_EMPTY;
+ state->common->immutable[i] = TRUE;
+ i++;
+ }
+ }
+ }
+
return state;
}
{
game_state *ret = snew(game_state);
- ret->w = state->w;
- ret->h = state->h;
+ ret->common = state->common;
+ ret->common->refcount++;
- ret->grid = snewn(ret->w * ret->h, unsigned char);
- memcpy(ret->grid, state->grid, ret->w * ret->h);
-
- ret->rowsize = state->rowsize;
- ret->rowdata = snewn(ret->rowsize * (ret->w + ret->h), int);
- ret->rowlen = snewn(ret->w + ret->h, int);
- memcpy(ret->rowdata, state->rowdata,
- ret->rowsize * (ret->w + ret->h) * sizeof(int));
- memcpy(ret->rowlen, state->rowlen,
- (ret->w + ret->h) * sizeof(int));
+ ret->grid = snewn(ret->common->w * ret->common->h, unsigned char);
+ memcpy(ret->grid, state->grid, ret->common->w * ret->common->h);
ret->completed = state->completed;
ret->cheated = state->cheated;
static void free_game(game_state *state)
{
- sfree(state->rowdata);
- sfree(state->rowlen);
+ if (--state->common->refcount == 0) {
+ sfree(state->common->rowdata);
+ sfree(state->common->rowlen);
+ sfree(state->common->immutable);
+ sfree(state->common);
+ }
sfree(state->grid);
sfree(state);
}
const char *ai, char **error)
{
unsigned char *matrix;
- int w = state->w, h = state->h;
+ int w = state->common->w, h = state->common->h;
int i;
char *ret;
int max, ok;
static char *game_text_format(const game_state *state)
{
- int w = state->w, h = state->h, i, j;
+ int w = state->common->w, h = state->common->h, i, j;
int left_gap = 0, top_gap = 0, ch = 2, cw = 1, limit = 1;
int len, topleft, lw, lh, gw, gh; /* {line,grid}_{width,height} */
char *board, *buf;
for (i = 0; i < w; ++i) {
- top_gap = max(top_gap, state->rowlen[i]);
- for (j = 0; j < state->rowlen[i]; ++j)
- while (state->rowdata[i*state->rowsize + j] >= limit) {
+ top_gap = max(top_gap, state->common->rowlen[i]);
+ for (j = 0; j < state->common->rowlen[i]; ++j)
+ while (state->common->rowdata[i*state->common->rowsize + j] >= limit) {
++cw;
limit *= 10;
}
}
for (i = 0; i < h; ++i) {
int rowlen = 0, predecessors = FALSE;
- for (j = 0; j < state->rowlen[i+w]; ++j) {
- int copy = state->rowdata[(i+w)*state->rowsize + j];
+ for (j = 0; j < state->common->rowlen[i+w]; ++j) {
+ int copy = state->common->rowdata[(i+w)*state->common->rowsize + j];
rowlen += predecessors;
predecessors = TRUE;
do ++rowlen; while (copy /= 10);
}
for (i = 0; i < w; ++i) {
- for (j = 0; j < state->rowlen[i]; ++j) {
- int cell = topleft + i*cw + 1 + lw*(j - state->rowlen[i]);
+ for (j = 0; j < state->common->rowlen[i]; ++j) {
+ int cell = topleft + i*cw + 1 + lw*(j - state->common->rowlen[i]);
int nch = sprintf(board + cell, "%*d", cw - 1,
- state->rowdata[i*state->rowsize + j]);
+ state->common->rowdata[i*state->common->rowsize + j]);
board[cell + nch] = ' '; /* de-NUL-ify */
}
}
buf = snewn(left_gap, char);
for (i = 0; i < h; ++i) {
char *p = buf, *start = board + top_gap*lw + left_gap + (i*ch+1)*lw;
- for (j = 0; j < state->rowlen[i+w]; ++j) {
+ for (j = 0; j < state->common->rowlen[i+w]; ++j) {
if (p > buf) *p++ = ' ';
- p += sprintf(p, "%d", state->rowdata[(i+w)*state->rowsize + j]);
+ p += sprintf(p, "%d", state->common->rowdata[(i+w)*state->common->rowsize + j]);
}
memcpy(start - (p - buf), buf, p - buf);
}
int control = button & MOD_CTRL, shift = button & MOD_SHFT;
button &= ~MOD_MASK;
- x = FROMCOORD(state->w, x);
- y = FROMCOORD(state->h, y);
+ x = FROMCOORD(state->common->w, x);
+ y = FROMCOORD(state->common->h, y);
- if (x >= 0 && x < state->w && y >= 0 && y < state->h &&
+ if (x >= 0 && x < state->common->w && y >= 0 && y < state->common->h &&
(button == LEFT_BUTTON || button == RIGHT_BUTTON ||
button == MIDDLE_BUTTON)) {
#ifdef STYLUS_BASED
- int currstate = state->grid[y * state->w + x];
+ int currstate = state->grid[y * state->common->w + x];
#endif
ui->dragging = TRUE;
if (x < 0) x = 0;
if (y < 0) y = 0;
- if (x >= state->w) x = state->w - 1;
- if (y >= state->h) y = state->h - 1;
+ if (x >= state->common->w) x = state->common->w - 1;
+ if (y >= state->common->h) y = state->common->h - 1;
ui->drag_end_x = x;
ui->drag_end_y = y;
for (yy = y1; yy <= y2; yy++)
for (xx = x1; xx <= x2; xx++)
- if (state->grid[yy * state->w + xx] != ui->state)
+ if (!state->common->immutable[yy * state->common->w + xx] &&
+ state->grid[yy * state->common->w + xx] != ui->state)
move_needed = TRUE;
ui->dragging = FALSE;
if (IS_CURSOR_MOVE(button)) {
int x = ui->cur_x, y = ui->cur_y, newstate;
char buf[80];
- move_cursor(button, &ui->cur_x, &ui->cur_y, state->w, state->h, 0);
+ move_cursor(button, &ui->cur_x, &ui->cur_y, state->common->w, state->common->h, 0);
ui->cur_visible = 1;
if (!control && !shift) return "";
newstate = control ? shift ? GRID_UNKNOWN : GRID_FULL : GRID_EMPTY;
- if (state->grid[y * state->w + x] == newstate &&
- state->grid[ui->cur_y * state->w + ui->cur_x] == newstate)
+ if (state->grid[y * state->common->w + x] == newstate &&
+ state->grid[ui->cur_y * state->common->w + ui->cur_x] == newstate)
return "";
sprintf(buf, "%c%d,%d,%d,%d", control ? shift ? 'U' : 'F' : 'E',
}
if (IS_CURSOR_SELECT(button)) {
- int currstate = state->grid[ui->cur_y * state->w + ui->cur_x];
+ int currstate = state->grid[ui->cur_y * state->common->w + ui->cur_x];
int newstate;
char buf[80];
int x1, x2, y1, y2, xx, yy;
int val;
- if (move[0] == 'S' && strlen(move) == from->w * from->h + 1) {
+ if (move[0] == 'S' &&
+ strlen(move) == from->common->w * from->common->h + 1) {
int i;
ret = dup_game(from);
- for (i = 0; i < ret->w * ret->h; i++)
+ for (i = 0; i < ret->common->w * ret->common->h; i++)
ret->grid[i] = (move[i+1] == '1' ? GRID_FULL : GRID_EMPTY);
ret->completed = ret->cheated = TRUE;
return ret;
} else if ((move[0] == 'F' || move[0] == 'E' || move[0] == 'U') &&
sscanf(move+1, "%d,%d,%d,%d", &x1, &y1, &x2, &y2) == 4 &&
- x1 >= 0 && x2 >= 0 && x1+x2 <= from->w &&
- y1 >= 0 && y2 >= 0 && y1+y2 <= from->h) {
+ x1 >= 0 && x2 >= 0 && x1+x2 <= from->common->w &&
+ y1 >= 0 && y2 >= 0 && y1+y2 <= from->common->h) {
x2 += x1;
y2 += y1;
ret = dup_game(from);
for (yy = y1; yy < y2; yy++)
for (xx = x1; xx < x2; xx++)
- ret->grid[yy * ret->w + xx] = val;
+ if (!ret->common->immutable[yy * ret->common->w + xx])
+ ret->grid[yy * ret->common->w + xx] = val;
/*
* An actual change, so check to see if we've completed the
* game.
*/
if (!ret->completed) {
- int *rowdata = snewn(ret->rowsize, int);
+ int *rowdata = snewn(ret->common->rowsize, int);
int i, len;
ret->completed = TRUE;
- for (i=0; i<ret->w; i++) {
- len = compute_rowdata(rowdata,
- ret->grid+i, ret->h, ret->w);
- if (len != ret->rowlen[i] ||
- memcmp(ret->rowdata+i*ret->rowsize, rowdata,
- len * sizeof(int))) {
+ for (i=0; i<ret->common->w; i++) {
+ len = compute_rowdata(rowdata, ret->grid+i,
+ ret->common->h, ret->common->w);
+ if (len != ret->common->rowlen[i] ||
+ memcmp(ret->common->rowdata+i*ret->common->rowsize,
+ rowdata, len * sizeof(int))) {
ret->completed = FALSE;
break;
}
}
- for (i=0; i<ret->h; i++) {
- len = compute_rowdata(rowdata,
- ret->grid+i*ret->w, ret->w, 1);
- if (len != ret->rowlen[i+ret->w] ||
- memcmp(ret->rowdata+(i+ret->w)*ret->rowsize, rowdata,
- len * sizeof(int))) {
+ for (i=0; i<ret->common->h; i++) {
+ len = compute_rowdata(rowdata, ret->grid+i*ret->common->w,
+ ret->common->w, 1);
+ if (len != ret->common->rowlen[i+ret->common->w] ||
+ memcmp(ret->common->rowdata +
+ (i+ret->common->w)*ret->common->rowsize,
+ rowdata, len * sizeof(int))) {
ret->completed = FALSE;
break;
}
int val, runlen;
struct errcheck_state aes, *es = &aes;
- es->rowlen = state->rowlen[i];
- es->rowdata = state->rowdata + state->rowsize * i;
+ es->rowlen = state->common->rowlen[i];
+ es->rowdata = state->common->rowdata + state->common->rowsize * i;
/* Pretend that we've already encountered the initial zero run */
es->ncontig = 1;
es->rowpos = 0;
- if (i < state->w) {
+ if (i < state->common->w) {
start = i;
- step = state->w;
- end = start + step * state->h;
+ step = state->common->w;
+ end = start + step * state->common->h;
} else {
- start = (i - state->w) * state->w;
+ start = (i - state->common->w) * state->common->w;
step = 1;
- end = start + step * state->w;
+ end = start + step * state->common->w;
}
runlen = -1;
struct game_drawstate *ds = snew(struct game_drawstate);
ds->started = FALSE;
- ds->w = state->w;
- ds->h = state->h;
+ ds->w = state->common->w;
+ ds->h = state->common->h;
ds->visible = snewn(ds->w * ds->h, unsigned char);
ds->tilesize = 0; /* not decided yet */
memset(ds->visible, 255, ds->w * ds->h);
static void draw_numbers(drawing *dr, game_drawstate *ds,
const game_state *state, int i, int erase, int colour)
{
- int rowlen = state->rowlen[i];
- int *rowdata = state->rowdata + state->rowsize * i;
+ int rowlen = state->common->rowlen[i];
+ int *rowdata = state->common->rowdata + state->common->rowsize * i;
int nfit;
int j;
if (erase) {
- if (i < state->w) {
- draw_rect(dr, TOCOORD(state->w, i), 0,
- TILE_SIZE, BORDER + TLBORDER(state->h) * TILE_SIZE,
+ if (i < state->common->w) {
+ draw_rect(dr, TOCOORD(state->common->w, i), 0,
+ TILE_SIZE, BORDER + TLBORDER(state->common->h) * TILE_SIZE,
COL_BACKGROUND);
} else {
- draw_rect(dr, 0, TOCOORD(state->h, i - state->w),
- BORDER + TLBORDER(state->w) * TILE_SIZE, TILE_SIZE,
+ draw_rect(dr, 0, TOCOORD(state->common->h, i - state->common->w),
+ BORDER + TLBORDER(state->common->w) * TILE_SIZE, TILE_SIZE,
COL_BACKGROUND);
}
}
* tile size. However, if there are more numbers than available
* spaces, I have to squash them up a bit.
*/
- if (i < state->w)
- nfit = TLBORDER(state->h);
+ if (i < state->common->w)
+ nfit = TLBORDER(state->common->h);
else
- nfit = TLBORDER(state->w);
+ nfit = TLBORDER(state->common->w);
nfit = max(rowlen, nfit) - 1;
assert(nfit > 0);
int x, y;
char str[80];
- if (i < state->w) {
- x = TOCOORD(state->w, i);
- y = BORDER + TILE_SIZE * (TLBORDER(state->h)-1);
- y -= ((rowlen-j-1)*TILE_SIZE) * (TLBORDER(state->h)-1) / nfit;
+ if (i < state->common->w) {
+ x = TOCOORD(state->common->w, i);
+ y = BORDER + TILE_SIZE * (TLBORDER(state->common->h)-1);
+ y -= ((rowlen-j-1)*TILE_SIZE) * (TLBORDER(state->common->h)-1) / nfit;
} else {
- y = TOCOORD(state->h, i - state->w);
- x = BORDER + TILE_SIZE * (TLBORDER(state->w)-1);
- x -= ((rowlen-j-1)*TILE_SIZE) * (TLBORDER(state->w)-1) / nfit;
+ y = TOCOORD(state->common->h, i - state->common->w);
+ x = BORDER + TILE_SIZE * (TLBORDER(state->common->w)-1);
+ x -= ((rowlen-j-1)*TILE_SIZE) * (TLBORDER(state->common->w)-1) / nfit;
}
sprintf(str, "%d", rowdata[j]);
TILE_SIZE/2, ALIGN_HCENTRE | ALIGN_VCENTRE, colour, str);
}
- if (i < state->w) {
- draw_update(dr, TOCOORD(state->w, i), 0,
- TILE_SIZE, BORDER + TLBORDER(state->h) * TILE_SIZE);
+ if (i < state->common->w) {
+ draw_update(dr, TOCOORD(state->common->w, i), 0,
+ TILE_SIZE, BORDER + TLBORDER(state->common->h) * TILE_SIZE);
} else {
- draw_update(dr, 0, TOCOORD(state->h, i - state->w),
- BORDER + TLBORDER(state->w) * TILE_SIZE, TILE_SIZE);
+ draw_update(dr, 0, TOCOORD(state->common->h, i - state->common->w),
+ BORDER + TLBORDER(state->common->w) * TILE_SIZE, TILE_SIZE);
}
}
* Work out what state this square should be drawn in,
* taking any current drag operation into account.
*/
- if (ui->dragging && x1 <= j && j <= x2 && y1 <= i && i <= y2)
+ if (ui->dragging && x1 <= j && j <= x2 && y1 <= i && i <= y2 &&
+ !state->common->immutable[i * state->common->w + j])
val = ui->state;
else
- val = state->grid[i * state->w + j];
+ val = state->grid[i * state->common->w + j];
if (cmoved) {
/* the cursor has moved; if we were the old or
* Redraw any numbers which have changed their colour due to error
* indication.
*/
- for (i = 0; i < state->w + state->h; i++) {
+ for (i = 0; i < state->common->w + state->common->h; i++) {
int colour = check_errors(state, i) ? COL_ERROR : COL_TEXT;
if (ds->numcolours[i] != colour) {
draw_numbers(dr, ds, state, i, TRUE, colour);
static void game_print(drawing *dr, const game_state *state, int tilesize)
{
- int w = state->w, h = state->h;
+ int w = state->common->w, h = state->common->h;
int ink = print_mono_colour(dr, 0);
int x, y, i;
/*
* Clues.
*/
- for (i = 0; i < state->w + state->h; i++)
+ for (i = 0; i < state->common->w + state->common->h; i++)
draw_numbers(dr, ds, state, i, FALSE, ink);
/*
*/
for (i = 0; i < (w+h); i++) {
char buf[80];
- for (thiswid = -1, j = 0; j < s->rowlen[i]; j++)
- thiswid += sprintf(buf, " %d", s->rowdata[s->rowsize*i+j]);
+ for (thiswid = -1, j = 0; j < s->common->rowlen[i]; j++)
+ thiswid += sprintf
+ (buf, " %d",
+ s->common->rowdata[s->common->rowsize*i+j]);
if (cluewid < thiswid)
cluewid = thiswid;
}
#endif
+#ifdef STANDALONE_PICTURE_GENERATOR
+
+/*
+ * Main program for the standalone picture generator. To use it,
+ * simply provide it with an XBM-format bitmap file (note XBM, not
+ * XPM) on standard input, and it will output a game ID in return.
+ * For example:
+ *
+ * $ ./patternpicture < calligraphic-A.xbm
+ * 15x15:2/4/2/2/2/3/3/3.1/3.1/3.1/11/14/12/6/1/2/2/3/4/5/1.3/2.3/1.3/2.3/1.4/9/1.1.3/2.2.3/5.4/3.2
+ *
+ * That looks easy, of course - all the program has done is to count
+ * up the clue numbers! But in fact, it's done more than that: it's
+ * also checked that the result is uniquely soluble from just the
+ * numbers. If it hadn't been, then it would have also left some
+ * filled squares in the playing area as extra clues.
+ *
+ * $ ./patternpicture < cube.xbm
+ * 15x15:10/2.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.10/1.1.1/1.1.1/1.1.1/2.1/10/10/1.2/1.1.1/1.1.1/1.1.1/10.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.1.1/1.2/10,TNINzzzzGNzw
+ *
+ * This enables a reasonably convenient design workflow for coming up
+ * with pictorial Pattern puzzles which _are_ uniquely soluble without
+ * those inelegant pre-filled squares. Fire up a bitmap editor (X11
+ * bitmap(1) is good enough), save a trial .xbm, and then test it by
+ * running a command along the lines of
+ *
+ * $ ./pattern $(./patternpicture < test.xbm)
+ *
+ * If the resulting window pops up with some pre-filled squares, then
+ * that tells you which parts of the image are giving rise to
+ * ambiguities, so try making tweaks in those areas, try the test
+ * command again, and see if it helps. Once you have a design for
+ * which the Pattern starting grid comes out empty, there's your game
+ * ID.
+ */
+
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+ game_params *par;
+ char *params, *desc;
+ random_state *rs;
+ time_t seed = time(NULL);
+ char buf[4096];
+ int i;
+ int x, y;
+
+ par = default_params();
+ if (argc > 1)
+ decode_params(par, argv[1]); /* get difficulty */
+ par->w = par->h = -1;
+
+ /*
+ * Now read an XBM file from standard input. This is simple and
+ * hacky and will do very little error detection, so don't feed
+ * it bogus data.
+ */
+ picture = NULL;
+ x = y = 0;
+ while (fgets(buf, sizeof(buf), stdin)) {
+ buf[strcspn(buf, "\r\n")] = '\0';
+ if (!strncmp(buf, "#define", 7)) {
+ /*
+ * Lines starting `#define' give the width and height.
+ */
+ char *num = buf + strlen(buf);
+ char *symend;
+
+ while (num > buf && isdigit((unsigned char)num[-1]))
+ num--;
+ symend = num;
+ while (symend > buf && isspace((unsigned char)symend[-1]))
+ symend--;
+
+ if (symend-5 >= buf && !strncmp(symend-5, "width", 5))
+ par->w = atoi(num);
+ else if (symend-6 >= buf && !strncmp(symend-6, "height", 6))
+ par->h = atoi(num);
+ } else {
+ /*
+ * Otherwise, break the string up into words and take
+ * any word of the form `0x' plus hex digits to be a
+ * byte.
+ */
+ char *p, *wordstart;
+
+ if (!picture) {
+ if (par->w < 0 || par->h < 0) {
+ printf("failed to read width and height\n");
+ return 1;
+ }
+ picture = snewn(par->w * par->h, unsigned char);
+ for (i = 0; i < par->w * par->h; i++)
+ picture[i] = GRID_UNKNOWN;
+ }
+
+ p = buf;
+ while (*p) {
+ while (*p && (*p == ',' || isspace((unsigned char)*p)))
+ p++;
+ wordstart = p;
+ while (*p && !(*p == ',' || *p == '}' ||
+ isspace((unsigned char)*p)))
+ p++;
+ if (*p)
+ *p++ = '\0';
+
+ if (wordstart[0] == '0' &&
+ (wordstart[1] == 'x' || wordstart[1] == 'X') &&
+ !wordstart[2 + strspn(wordstart+2,
+ "0123456789abcdefABCDEF")]) {
+ unsigned long byte = strtoul(wordstart+2, NULL, 16);
+ for (i = 0; i < 8; i++) {
+ int bit = (byte >> i) & 1;
+ if (y < par->h && x < par->w)
+ picture[y * par->w + x] =
+ bit ? GRID_FULL : GRID_EMPTY;
+ x++;
+ }
+
+ if (x >= par->w) {
+ x = 0;
+ y++;
+ }
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < par->w * par->h; i++)
+ if (picture[i] == GRID_UNKNOWN) {
+ fprintf(stderr, "failed to read enough bitmap data\n");
+ return 1;
+ }
+
+ rs = random_new((void*)&seed, sizeof(time_t));
+
+ desc = new_game_desc(par, rs, NULL, FALSE);
+ params = encode_params(par, FALSE);
+ printf("%s:%s\n", params, desc);
+
+ sfree(desc);
+ sfree(params);
+ free_params(par);
+ random_free(rs);
+
+ return 0;
+}
+
+#endif
+
/* vim: set shiftwidth=4 tabstop=8: */
~ian / sgt-puzzles.git / blobdiff