X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/388b2f0063a017a5be26f72eae1424bad5b23f3c..1277ff5d43604ae983f5e977fca0658288ea1fdc:/unequal.c

diff --git a/unequal.c b/unequal.c
index 5f89348..57d8afc 100644
--- a/unequal.c
+++ b/unequal.c
@@ -634,10 +634,10 @@ static int solver_links(struct latin_solver *solver, void *vctx)
                     if (solver_show_working) {
                         printf("%*slink elimination, (%d,%d) > (%d,%d):\n",
                                solver_recurse_depth*4, "",
-                               link->gx, link->gy, link->lx, link->ly);
+                               link->gx+1, link->gy+1, link->lx+1, link->ly+1);
                         printf("%*s  ruling out %d at (%d,%d)\n",
                                solver_recurse_depth*4, "",
-                               j+1, link->gx, link->gy);
+                               j+1, link->gx+1, link->gy+1);
                     }
 #endif
                     cube(link->gx, link->gy, j+1) = FALSE;
@@ -652,10 +652,10 @@ static int solver_links(struct latin_solver *solver, void *vctx)
                     if (solver_show_working) {
                         printf("%*slink elimination, (%d,%d) > (%d,%d):\n",
                                solver_recurse_depth*4, "",
-                               link->gx, link->gy, link->lx, link->ly);
+                               link->gx+1, link->gy+1, link->lx+1, link->ly+1);
                         printf("%*s  ruling out %d at (%d,%d)\n",
                                solver_recurse_depth*4, "",
-                               j+1, link->lx, link->ly);
+                               j+1, link->lx+1, link->ly+1);
                     }
 #endif
                     cube(link->lx, link->ly, j+1) = FALSE;
@@ -702,9 +702,9 @@ static int solver_adjacent(struct latin_solver *solver, void *vctx)
                     if (solver_show_working) {
                         printf("%*sadjacent elimination, (%d,%d):%d %s (%d,%d):\n",
                                solver_recurse_depth*4, "",
-                               x, y, grid(x, y), isadjacent ? "|" : "!|", nx, ny);
+                               x+1, y+1, grid(x, y), isadjacent ? "|" : "!|", nx+1, ny+1);
                         printf("%*s  ruling out %d at (%d,%d)\n",
-                               solver_recurse_depth*4, "", n+1, nx, ny);
+                               solver_recurse_depth*4, "", n+1, nx+1, ny+1);
                     }
 #endif
                     cube(nx, ny, n+1) = FALSE;
@@ -728,7 +728,7 @@ static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
 
     for (x = 0; x < o; x++) {
         for (y = 0; y < o; y++) {
-            for (i = 0; i < o; i++) {
+            for (i = 0; i < 4; i++) {
                 int isadjacent = (GRID(ctx->state, flags, x, y) & adjthan[i].f);
 
                 nx = x + adjthan[i].dx, ny = y + adjthan[i].dy;
@@ -766,9 +766,9 @@ static int solver_adjacent_set(struct latin_solver *solver, void *vctx)
                     if (solver_show_working) {
                         printf("%*sadjacent possible elimination, (%d,%d) %s (%d,%d):\n",
                                solver_recurse_depth*4, "",
-                               x, y, isadjacent ? "|" : "!|", nx, ny);
+                               x+1, y+1, isadjacent ? "|" : "!|", nx+1, ny+1);
                         printf("%*s  ruling out %d at (%d,%d)\n",
-                               solver_recurse_depth*4, "", n+1, nx, ny);
+                               solver_recurse_depth*4, "", n+1, nx+1, ny+1);
                     }
 #endif
                     cube(nx, ny, n+1) = FALSE;
@@ -876,7 +876,7 @@ static int gg_place_clue(game_state *state, int ccode, digit *latin, int checkon
 #ifdef STANDALONE_SOLVER
             if (state->nums[loc] != latin[loc]) {
                 printf("inconsistency for (%d,%d): state %d latin %d\n",
-                       x, y, state->nums[loc], latin[loc]);
+                       x+1, y+1, state->nums[loc], latin[loc]);
             }
 #endif
             assert(state->nums[loc] == latin[loc]);
@@ -927,7 +927,7 @@ static int gg_remove_clue(game_state *state, int ccode, int checkonly)
 #ifdef STANDALONE_SOLVER
             if (solver_show_working)
                 printf("gg_remove_clue: removing %d at (%d,%d)",
-                       state->nums[loc], x, y);
+                       state->nums[loc], x+1, y+1);
 #endif
             state->nums[loc] = 0;
         }
@@ -940,7 +940,7 @@ static int gg_remove_clue(game_state *state, int ccode, int checkonly)
 #ifdef STANDALONE_SOLVER
             if (solver_show_working)
                printf("gg_remove_clue: removing %c at (%d,%d)",
-                       adjthan[which].c, x, y);
+                       adjthan[which].c, x+1, y+1);
 #endif
             state->flags[loc] &= ~adjthan[which].f;
         }
@@ -978,7 +978,7 @@ static int gg_best_clue(game_state *state, int *scratch, digit *latin)
 #ifdef STANDALONE_SOLVER
             if (solver_show_working)
                 printf("gg_best_clue: b%d (%d,%d) new best [%d poss, %d clues].\n",
-                       best, x, y, nposs, nclues);
+                       best, x+1, y+1, nposs, nclues);
 #endif
         }
     }
@@ -1602,8 +1602,21 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 static void draw_gt(drawing *dr, int ox, int oy,
                     int dx1, int dy1, int dx2, int dy2, int col)
 {
-    draw_line(dr, ox, oy, ox+dx1, oy+dy1, col);
-    draw_line(dr, ox+dx1, oy+dy1, ox+dx1+dx2, oy+dy1+dy2, col);
+    int coords[12];
+    int xdx = (dx1+dx2 ? 0 : 1), xdy = (dx1+dx2 ? 1 : 0);
+    coords[0] = ox + xdx;
+    coords[1] = oy + xdy;
+    coords[2] = ox + xdx + dx1;
+    coords[3] = oy + xdy + dy1;
+    coords[4] = ox + xdx + dx1 + dx2;
+    coords[5] = oy + xdy + dy1 + dy2;
+    coords[6] = ox - xdx + dx1 + dx2;
+    coords[7] = oy - xdy + dy1 + dy2;
+    coords[8] = ox - xdx + dx1;
+    coords[9] = oy - xdy + dy1;
+    coords[10] = ox - xdx;
+    coords[11] = oy - xdy;
+    draw_polygon(dr, coords, 6, col, col);
 }
 
 static void draw_gts(drawing *dr, game_drawstate *ds, int ox, int oy,
@@ -1889,7 +1902,7 @@ 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)
+            if (state->adjacent)
                 draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), ink);
             else
                 draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), ink);