X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?a=blobdiff_plain;f=pattern.c;h=78d6b5ef26fdf77be41f6e63587635b6f3fbda46;hb=3ce69e84cad15844282d691fa03e711c5353c05e;hp=0688f33e4272e6d7a7fdb144a7351c6fa1f428dc;hpb=051ab1701ee8671e7754951c1f170c609c9b67a8;p=sgt-puzzles.git

diff --git a/pattern.c b/pattern.c
index 0688f33..78d6b5e 100644
--- a/pattern.c
+++ b/pattern.c
@@ -45,11 +45,18 @@ struct game_params {
 #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;
 };
 
@@ -219,6 +226,7 @@ static char *validate_params(const game_params *params, int full)
  * 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;
@@ -312,6 +320,7 @@ static void generate(random_state *rs, int w, int h, unsigned char *retgrid)
 
     sfree(fgrid);
 }
+#endif
 
 static int compute_rowdata(int *ret, unsigned char *start, int len, int step)
 {
@@ -435,7 +444,12 @@ static int do_row(unsigned char *known, unsigned char *deduced,
     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++)
@@ -483,46 +497,70 @@ static int solve_puzzle(const game_state *state, unsigned char *grid,
     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)
@@ -541,9 +579,9 @@ static int solve_puzzle(const game_state *state, unsigned char *grid,
 	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;
 		    }
@@ -565,9 +603,9 @@ static int solve_puzzle(const game_state *state, unsigned char *grid,
 	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;
 		    }
@@ -599,6 +637,7 @@ static int solve_puzzle(const game_state *state, unsigned char *grid,
     return ok;
 }
 
+#ifndef STANDALONE_PICTURE_GENERATOR
 static unsigned char *generate_soluble(random_state *rs, int w, int h)
 {
     int i, j, ok, ntries, max;
@@ -662,6 +701,11 @@ static unsigned char *generate_soluble(random_state *rs, int w, int h)
     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)
@@ -670,15 +714,63 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     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);
 
         /*
@@ -745,6 +837,40 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     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;
@@ -782,13 +908,41 @@ static char *validate_desc(const game_params *params, const char *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;
 }
 
@@ -799,25 +953,32 @@ static game_state *new_game(midend *me, const game_params *params,
     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->grid = snewn(state->w * state->h, unsigned char);
-    memset(state->grid, GRID_UNKNOWN, state->w * state->h);
+    state->common->w = params->w;
+    state->common->h = params->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->grid = snewn(state->common->w * state->common->h, unsigned char);
+    memset(state->grid, GRID_UNKNOWN, state->common->w * state->common->h);
+
+    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 {
@@ -825,6 +986,24 @@ static game_state *new_game(midend *me, const game_params *params,
         }
     }
 
+    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;
 }
 
@@ -832,19 +1011,11 @@ static game_state *dup_game(const game_state *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;
@@ -854,8 +1025,12 @@ static game_state *dup_game(const game_state *state)
 
 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);
 }
@@ -864,7 +1039,7 @@ static char *solve_game(const game_state *state, const game_state *currstate,
                         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;
@@ -919,24 +1094,24 @@ static int game_can_format_as_text_now(const game_params *params)
 
 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);
@@ -963,10 +1138,10 @@ static char *game_text_format(const game_state *state)
     }
 
     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 */
 	}
     }
@@ -974,9 +1149,9 @@ static char *game_text_format(const game_state *state)
     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);
     }
@@ -1056,16 +1231,17 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                             const game_drawstate *ds,
                             int x, int y, int button)
 {
+    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;
@@ -1119,8 +1295,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
         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;
@@ -1139,7 +1315,8 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
         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;
@@ -1156,12 +1333,25 @@ static char *interpret_move(const game_state *state, game_ui *ui,
     }
 
     if (IS_CURSOR_MOVE(button)) {
-        move_cursor(button, &ui->cur_x, &ui->cur_y, state->w, state->h, 0);
+	int x = ui->cur_x, y = ui->cur_y, newstate;
+	char buf[80];
+        move_cursor(button, &ui->cur_x, &ui->cur_y, state->common->w, state->common->h, 0);
         ui->cur_visible = 1;
-        return "";
+	if (!control && !shift) return "";
+
+	newstate = control ? shift ? GRID_UNKNOWN : GRID_FULL : GRID_EMPTY;
+	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',
+		min(x, ui->cur_x), min(y, ui->cur_y),
+		abs(x - ui->cur_x) + 1, abs(y - ui->cur_y) + 1);
+	return dupstr(buf);
     }
+
     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];
 
@@ -1193,12 +1383,13 @@ static game_state *execute_move(const game_state *from, const char *move)
     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;
@@ -1206,8 +1397,8 @@ static game_state *execute_move(const game_state *from, const char *move)
 	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;
@@ -1217,34 +1408,36 @@ static game_state *execute_move(const game_state *from, const char *move)
 	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;
 		}
@@ -1370,20 +1563,20 @@ static int check_errors(const game_state *state, int i)
     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;
@@ -1468,8 +1661,8 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
     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);
@@ -1522,19 +1715,19 @@ static void grid_square(drawing *dr, game_drawstate *ds,
 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);
         }
     }
@@ -1544,10 +1737,10 @@ static void draw_numbers(drawing *dr, game_drawstate *ds,
      * 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);
 
@@ -1555,14 +1748,14 @@ static void draw_numbers(drawing *dr, game_drawstate *ds,
         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]);
@@ -1570,12 +1763,12 @@ static void draw_numbers(drawing *dr, game_drawstate *ds,
                   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);
     }
 }
 
@@ -1637,10 +1830,11 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
              * 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
@@ -1671,7 +1865,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
      * 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);
@@ -1719,7 +1913,7 @@ static void game_print_size(const game_params *params, float *x, float *y)
 
 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;
 
@@ -1751,7 +1945,7 @@ static void game_print(drawing *dr, const game_state *state, int tilesize)
     /*
      * 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);
 
     /*
@@ -1877,8 +2071,10 @@ int main(int argc, char **argv)
 	     */
 	    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;
 	    }
@@ -1904,4 +2100,156 @@ int main(int argc, char **argv)
 
 #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: */