X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/d2d40d2466f19e469e6734b1a096f548dfc47095..HEAD:/unequal.c

diff --git a/unequal.c b/unequal.c
index 7ea0349..d16a572 100644
--- a/unequal.c
+++ b/unequal.c
@@ -98,10 +98,9 @@ struct game_state {
 #define TITLE(upper,title,func,lower) #title,
 #define ENCODE(upper,title,func,lower) #lower
 #define CONFIG(upper,title,func,lower) ":" #title
-enum { DIFFLIST(ENUM) DIFF_IMPOSSIBLE = diff_impossible, DIFF_AMBIGUOUS = diff_ambiguous, DIFF_UNFINISHED = diff_unfinished };
+enum { DIFFLIST(ENUM) DIFFCOUNT, DIFF_IMPOSSIBLE = diff_impossible, DIFF_AMBIGUOUS = diff_ambiguous, DIFF_UNFINISHED = diff_unfinished };
 static char const *const unequal_diffnames[] = { DIFFLIST(TITLE) };
 static char const unequal_diffchars[] = DIFFLIST(ENCODE);
-#define DIFFCOUNT lenof(unequal_diffchars)
 #define DIFFCONFIG DIFFLIST(CONFIG)
 
 #define DEFAULT_PRESET 0
@@ -952,7 +951,7 @@ static int gg_best_clue(game_state *state, int *scratch, digit *latin)
 {
     int ls = state->order * state->order * 5;
     int maxposs = 0, minclues = 5, best = -1, i, j;
-    int nposs, nclues, loc, x, y;
+    int nposs, nclues, loc;
 
 #ifdef STANDALONE_SOLVER
     if (solver_show_working) {
@@ -965,7 +964,6 @@ static int gg_best_clue(game_state *state, int *scratch, digit *latin)
         if (!gg_place_clue(state, scratch[i], latin, 1)) continue;
 
         loc = scratch[i] / 5;
-        x = loc % state->order; y = loc / state->order;
         for (j = nposs = 0; j < state->order; j++) {
             if (state->hints[loc*state->order + j]) nposs++;
         }
@@ -976,9 +974,11 @@ static int gg_best_clue(game_state *state, int *scratch, digit *latin)
             (nposs == maxposs && nclues < minclues)) {
             best = i; maxposs = nposs; minclues = nclues;
 #ifdef STANDALONE_SOLVER
-            if (solver_show_working)
+            if (solver_show_working) {
+                int x = loc % state->order, y = loc / state->order;
                 printf("gg_best_clue: b%d (%d,%d) new best [%d poss, %d clues].\n",
                        best, x+1, y+1, nposs, nclues);
+            }
 #endif
         }
     }
@@ -1310,7 +1310,7 @@ static char *solve_game(game_state *state, game_state *currstate,
         if (!(solved->flags[r] & F_IMMUTABLE))
             solved->nums[r] = 0;
     }
-    r = solver_state(solved, DIFFCOUNT);
+    r = solver_state(solved, DIFFCOUNT-1);   /* always use full solver */
     if (r > 0) ret = latin_desc(solved->nums, solved->order);
     free_game(solved);
     return ret;
@@ -1371,7 +1371,7 @@ struct game_drawstate {
     int hflash;
 };
 
-static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
+static char *interpret_move(game_state *state, game_ui *ui, const game_drawstate *ds,
 			    int ox, int oy, int button)
 {
     int x = FROMCOORD(ox), y = FROMCOORD(oy), n;
@@ -1620,36 +1620,40 @@ static void draw_gt(drawing *dr, int ox, int oy,
 }
 
 static void draw_gts(drawing *dr, game_drawstate *ds, int ox, int oy,
-                     unsigned int f, int col)
+                     unsigned int f, int bg, int fg)
 {
     int g = GAP_SIZE, g2 = (g+1)/2, g4 = (g+1)/4;
 
     /* Draw all the greater-than signs emanating from this tile. */
 
     if (f & F_ADJ_UP) {
+	if (bg >= 0) draw_rect(dr, ox, oy - g, TILE_SIZE, g, bg);
         draw_gt(dr, ox+g2, oy-g4, g2, -g2, g2, g2,
-               (f & F_ERROR_UP) ? COL_ERROR : col);
+               (f & F_ERROR_UP) ? COL_ERROR : fg);
         draw_update(dr, ox, oy-g, TILE_SIZE, g);
     }
     if (f & F_ADJ_RIGHT) {
+	if (bg >= 0) draw_rect(dr, ox + TILE_SIZE, oy, g, TILE_SIZE, bg);
         draw_gt(dr, ox+TILE_SIZE+g4, oy+g2, g2, g2, -g2, g2,
-                (f & F_ERROR_RIGHT) ? COL_ERROR : col);
+                (f & F_ERROR_RIGHT) ? COL_ERROR : fg);
         draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE);
     }
     if (f & F_ADJ_DOWN) {
+	if (bg >= 0) draw_rect(dr, ox, oy + TILE_SIZE, TILE_SIZE, g, bg);
         draw_gt(dr, ox+g2, oy+TILE_SIZE+g4, g2, g2, g2, -g2,
-               (f & F_ERROR_DOWN) ? COL_ERROR : col);
+               (f & F_ERROR_DOWN) ? COL_ERROR : fg);
         draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g);
     }
     if (f & F_ADJ_LEFT) {
+	if (bg >= 0) draw_rect(dr, ox - g, oy, g, TILE_SIZE, bg);
         draw_gt(dr, ox-g4, oy+g2, -g2, g2, g2, g2,
-                (f & F_ERROR_LEFT) ? COL_ERROR : col);
+                (f & F_ERROR_LEFT) ? COL_ERROR : fg);
         draw_update(dr, ox-g, oy, g, TILE_SIZE);
     }
 }
 
 static void draw_adjs(drawing *dr, game_drawstate *ds, int ox, int oy,
-                     unsigned int f, int col)
+                      unsigned int f, int bg, int fg)
 {
     int g = GAP_SIZE, g38 = 3*(g+1)/8, g4 = (g+1)/4;
 
@@ -1663,24 +1667,24 @@ static void draw_adjs(drawing *dr, game_drawstate *ds, int ox, int oy,
     if (f & (F_ADJ_RIGHT|F_ERROR_RIGHT)) {
         if (f & F_ADJ_RIGHT) {
             draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE,
-                      (f & F_ERROR_RIGHT) ? COL_ERROR : col);
+                      (f & F_ERROR_RIGHT) ? COL_ERROR : fg);
         } else {
             draw_rect_outline(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, COL_ERROR);
         }
-    } else {
-        draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, COL_BACKGROUND);
+    } else if (bg >= 0) {
+        draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, bg);
     }
     draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE);
 
     if (f & (F_ADJ_DOWN|F_ERROR_DOWN)) {
         if (f & F_ADJ_DOWN) {
             draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4,
-                      (f & F_ERROR_DOWN) ? COL_ERROR : col);
+                      (f & F_ERROR_DOWN) ? COL_ERROR : fg);
         } else {
             draw_rect_outline(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, COL_ERROR);
         }
-    } else {
-        draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, COL_BACKGROUND);
+    } else if (bg >= 0) {
+        draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, bg);
     }
     draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g);
 }
@@ -1718,9 +1722,9 @@ static void draw_furniture(drawing *dr, game_drawstate *ds, game_state *state,
 
     /* Draw the adjacent clue signs. */
     if (ds->adjacent)
-        draw_adjs(dr, ds, ox, oy, f, COL_GRID);
+        draw_adjs(dr, ds, ox, oy, f, COL_BACKGROUND, COL_GRID);
     else
-        draw_gts(dr, ds, ox, oy, f, COL_TEXT);
+        draw_gts(dr, ds, ox, oy, f, COL_BACKGROUND, COL_TEXT);
 }
 
 static void draw_num(drawing *dr, game_drawstate *ds, int x, int y)
@@ -1861,6 +1865,11 @@ static float game_flash_length(game_state *oldstate, game_state *newstate,
     return 0.0F;
 }
 
+static int game_status(game_state *state)
+{
+    return state->completed ? +1 : 0;
+}
+
 static int game_timing_state(game_state *state, game_ui *ui)
 {
     return TRUE;
@@ -1902,10 +1911,10 @@ static void game_print(drawing *dr, game_state *state, int tilesize)
                       FONT_VARIABLE, TILE_SIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE,
                       ink, str);
 
-            if (ds->adjacent)
-                draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), ink);
+            if (state->adjacent)
+                draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink);
             else
-                draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), ink);
+                draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink);
         }
     }
 }
@@ -1949,6 +1958,7 @@ const struct game thegame = {
     game_redraw,
     game_anim_length,
     game_flash_length,
+    game_status,
     TRUE, FALSE, game_print_size, game_print,
     FALSE,			       /* wants_statusbar */
     FALSE, game_timing_state,