X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/2ac6d24e968232e9040ee0bca5e605b3a75e9c39..98efcdb9e3026bceb161a576e7733d2db67ede5a:/pattern.c

diff --git a/pattern.c b/pattern.c
index 0f0a9c6..26201e8 100644
--- a/pattern.c
+++ b/pattern.c
@@ -100,9 +100,8 @@ static game_params *dup_params(game_params *params)
     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);
@@ -114,11 +113,9 @@ static game_params *decode_params(char const *string)
     } 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;
@@ -472,19 +469,38 @@ static unsigned char *generate_soluble(random_state *rs, int w, int h)
     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 = snewn(ai->w * ai->h, unsigned char);
+	memcpy(ai->grid, grid, ai->w * ai->h);
+
+	*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,
@@ -494,7 +510,7 @@ static char *new_game_seed(game_params *params, random_state *rs,
      * 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);
@@ -503,14 +519,14 @@ static char *new_game_seed(game_params *params, random_state *rs,
                                      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);
@@ -519,30 +535,31 @@ static char *new_game_seed(game_params *params, random_state *rs,
                                      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;
 }
 
 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;
@@ -553,10 +570,10 @@ static char *validate_seed(game_params *params, char *seed)
         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;
 
@@ -566,15 +583,15 @@ static char *validate_seed(game_params *params, char *seed)
                     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
@@ -584,7 +601,7 @@ static char *validate_seed(game_params *params, char *seed)
     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;
@@ -604,15 +621,15 @@ static game_state *new_game(game_params *params, char *seed)
 
     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 */
         }
     }
 
@@ -651,21 +668,25 @@ static void free_game(game_state *state)
     sfree(state);
 }
 
-static game_state *solve_game(game_state *state, game_aux_info *aux,
+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;
+
     /*
-     * I could have stored the grid I invented in the game_aux_info
-     * and extracted it here where available, but it seems easier
-     * just to run my internal solver in all cases.
+     * If we already have the solved state in an aux_info, copy it
+     * out.
      */
+    if (ai) {
 
-    ret = dup_game(state);
-    ret->completed = ret->cheated = TRUE;
+	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;
@@ -743,11 +764,12 @@ static void free_ui(game_ui *ui)
     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);
 
@@ -1063,13 +1085,13 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
 }
 
 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 &&
 	!oldstate->cheated && !newstate->cheated)
@@ -1082,6 +1104,11 @@ static int game_wants_statusbar(void)
     return FALSE;
 }
 
+static int game_timing_state(game_state *state)
+{
+    return TRUE;
+}
+
 #ifdef COMBINED
 #define thegame pattern
 #endif
@@ -1096,9 +1123,9 @@ const struct game thegame = {
     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,
@@ -1115,6 +1142,8 @@ const struct game thegame = {
     game_anim_length,
     game_flash_length,
     game_wants_statusbar,
+    FALSE, game_timing_state,
+    0,				       /* mouse_priorities */
 };
 
 #ifdef STANDALONE_SOLVER
@@ -1159,7 +1188,7 @@ int main(int argc, char **argv)
     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;
 
@@ -1178,20 +1207,21 @@ int main(int argc, char **argv)
         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;