X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/7c568a48f46bd88d9f298a1c29ac0f64a88266c0..bacaa96edd2c632ef4f49fdc7dfc4a11f85c2d8c:/solo.c

diff --git a/solo.c b/solo.c
index d991536..c453b26 100644
--- a/solo.c
+++ b/solo.c
@@ -3,20 +3,12 @@
  *
  * TODO:
  *
- *  - can we do anything about nasty centring of text in GTK? It
- *    seems to be taking ascenders/descenders into account when
- *    centring. Ick.
- *
  *  - it might still be nice to do some prioritisation on the
  *    removal of numbers from the grid
  *     + one possibility is to try to minimise the maximum number
  * 	 of filled squares in any block, which in particular ought
  * 	 to enforce never leaving a completely filled block in the
  * 	 puzzle as presented.
- *     + be careful of being too clever here, though, until after
- * 	 I've tried implementing difficulty levels. It's not
- * 	 impossible that those might impose much more important
- * 	 constraints on this process.
  *
  *  - alternative interface modes
  *     + sudoku.com's Windows program has a palette of possible
@@ -1124,7 +1116,7 @@ static int nsolve(int c, int r, digit *grid)
 #ifdef STANDALONE_SOLVER
                                           , "intersectional analysis,"
                                           " row %d vs block (%d,%d)",
-                                          1+YUNTRANS(y), 1+x, 1+y%r
+                                          1+YUNTRANS(y), 1+x/r, 1+y%r
 #endif
                                           ) ||
                          nsolve_intersect(usage, cubepos(x,y%r,n), r*cr,
@@ -1132,7 +1124,7 @@ static int nsolve(int c, int r, digit *grid)
 #ifdef STANDALONE_SOLVER
                                           , "intersectional analysis,"
                                           " block (%d,%d) vs row %d",
-                                          1+x, 1+y%r, 1+YUNTRANS(y)
+                                          1+x/r, 1+y%r, 1+YUNTRANS(y)
 #endif
                                           ))) {
                         diff = max(diff, DIFF_INTERSECT);
@@ -1615,6 +1607,68 @@ static void free_game(game_state *state)
     sfree(state);
 }
 
+static char *grid_text_format(int c, int r, digit *grid)
+{
+    int cr = c*r;
+    int x, y;
+    int maxlen;
+    char *ret, *p;
+
+    /*
+     * There are cr lines of digits, plus r-1 lines of block
+     * separators. Each line contains cr digits, cr-1 separating
+     * spaces, and c-1 two-character block separators. Thus, the
+     * total length of a line is 2*cr+2*c-3 (not counting the
+     * newline), and there are cr+r-1 of them.
+     */
+    maxlen = (cr+r-1) * (2*cr+2*c-2);
+    ret = snewn(maxlen+1, char);
+    p = ret;
+
+    for (y = 0; y < cr; y++) {
+        for (x = 0; x < cr; x++) {
+            int ch = grid[y * cr + x];
+            if (ch == 0)
+                ch = ' ';
+            else if (ch <= 9)
+                ch = '0' + ch;
+            else
+                ch = 'a' + ch-10;
+            *p++ = ch;
+            if (x+1 < cr) {
+		*p++ = ' ';
+                if ((x+1) % r == 0) {
+                    *p++ = '|';
+		    *p++ = ' ';
+		}
+            }
+        }
+	*p++ = '\n';
+        if (y+1 < cr && (y+1) % c == 0) {
+            for (x = 0; x < cr; x++) {
+                *p++ = '-';
+                if (x+1 < cr) {
+		    *p++ = '-';
+                    if ((x+1) % r == 0) {
+			*p++ = '+';
+			*p++ = '-';
+		    }
+                }
+            }
+	    *p++ = '\n';
+        }
+    }
+
+    assert(p - ret == maxlen);
+    *p = '\0';
+    return ret;
+}
+
+static char *game_text_format(game_state *state)
+{
+    return grid_text_format(state->c, state->r, state->grid);
+}
+
 struct game_ui {
     /*
      * These are the coordinates of the currently highlighted
@@ -1895,21 +1949,21 @@ static int game_wants_statusbar(void)
 #endif
 
 const struct game thegame = {
-    "Solo", "games.solo", TRUE,
+    "Solo", "games.solo",
     default_params,
     game_fetch_preset,
     decode_params,
     encode_params,
     free_params,
     dup_params,
-    game_configure,
-    custom_params,
+    TRUE, game_configure, custom_params,
     validate_params,
     new_game_seed,
     validate_seed,
     new_game,
     dup_game,
     free_game,
+    TRUE, game_text_format,
     new_ui,
     free_ui,
     make_move,
@@ -2031,50 +2085,19 @@ int main(int argc, char **argv)
                 else
                     ret = DIFF_AMBIGUOUS;
             }
-            printf("difficulty rating: %s\n",
-                   ret==DIFF_BLOCK ? "blockwise positional elimination only":
-                   ret==DIFF_SIMPLE ? "row/column/number elimination required":
-                   ret==DIFF_INTERSECT ? "intersectional analysis required":
-                   ret==DIFF_SET ? "set elimination required":
-                   ret==DIFF_RECURSIVE ? "guesswork and backtracking required":
-                   ret==DIFF_AMBIGUOUS ? "multiple solutions exist":
-                   ret==DIFF_IMPOSSIBLE ? "no solution exists":
+            printf("Difficulty rating: %s\n",
+                   ret==DIFF_BLOCK ? "Trivial (blockwise positional elimination only)":
+                   ret==DIFF_SIMPLE ? "Basic (row/column/number elimination required)":
+                   ret==DIFF_INTERSECT ? "Intermediate (intersectional analysis required)":
+                   ret==DIFF_SET ? "Advanced (set elimination required)":
+                   ret==DIFF_RECURSIVE ? "Unreasonable (guesswork and backtracking required)":
+                   ret==DIFF_AMBIGUOUS ? "Ambiguous (multiple solutions exist)":
+                   ret==DIFF_IMPOSSIBLE ? "Impossible (no solution exists)":
                    "INTERNAL ERROR: unrecognised difficulty code");
         }
     }
 
-    for (y = 0; y < p->c * p->r; y++) {
-        for (x = 0; x < p->c * p->r; x++) {
-            int c = s->grid[y * p->c * p->r + x];
-            if (c == 0)
-                c = ' ';
-            else if (c <= 9)
-                c = '0' + c;
-            else
-                c = 'a' + c-10;
-            printf("%c", c);
-            if (x+1 < p->c * p->r) {
-                if ((x+1) % p->c)
-                    printf(" ");
-                else
-                    printf(" | ");
-            }
-        }
-        printf("\n");
-        if (y+1 < p->c * p->r && (y+1) % p->r == 0) {
-            for (x = 0; x < p->c * p->r; x++) {
-                printf("-");
-                if (x+1 < p->c * p->r) {
-                    if ((x+1) % p->c)
-                        printf("-");
-                    else
-                        printf("-+-");
-                }
-            }
-            printf("\n");
-        }
-    }
-    printf("\n");
+    printf("%s\n", grid_text_format(p->c, p->r, s->grid));
 
     return 0;
 }