X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/3ff276f2cd88e6f3a6fe08f95f6147abbe3fcfd4..aafaa7fbd122f8109c1a7d99faf74d4892bf22de:/pegs.c

diff --git a/pegs.c b/pegs.c
index 5ed30d0..5bb5de2 100644
--- a/pegs.c
+++ b/pegs.c
@@ -120,11 +120,6 @@ static void decode_params(game_params *params, char const *string)
         params->h = params->w;
     }
 
-    /*
-     * Assume a random generation scheme unless told otherwise, for the
-     * sake of internal consistency.
-     */
-    params->type = TYPE_RANDOM;
     for (i = 0; i < lenof(pegs_lowertypes); i++)
 	if (!strcmp(p, pegs_lowertypes[i]))
 	    params->type = i;
@@ -535,9 +530,7 @@ static char *new_game_desc(game_params *params, random_state *rs,
 		  case TYPE_OCTAGON:
 		    cx = abs(x - w/2);
 		    cy = abs(y - h/2);
-		    if (cx == 0 && cy == 0)
-			v = GRID_HOLE;
-		    else if (cx + cy > 1 + max(w,h)/2)
+		    if (cx + cy > 1 + max(w,h)/2)
 			v = GRID_OBST;
 		    else
 			v = GRID_PEG;
@@ -545,6 +538,107 @@ static char *new_game_desc(game_params *params, random_state *rs,
 		}
 		grid[y*w+x] = v;
 	    }
+
+	if (params->type == TYPE_OCTAGON) {
+	    /*
+	     * The octagonal (European) solitaire layout is
+	     * actually _insoluble_ with the starting hole at the
+	     * centre. Here's a proof:
+	     * 
+	     * Colour the squares of the board diagonally in
+	     * stripes of three different colours, which I'll call
+	     * A, B and C. So the board looks like this:
+	     * 
+	     *     A B C
+	     *   A B C A B
+	     * A B C A B C A
+	     * B C A B C A B
+	     * C A B C A B C
+	     *   B C A B C
+	     *     A B C
+	     * 
+	     * Suppose we keep running track of the number of pegs
+	     * occuping each colour of square. This colouring has
+	     * the property that any valid move whatsoever changes
+	     * all three of those counts by one (two of them go
+	     * down and one goes up), which means that the _parity_
+	     * of every count flips on every move.
+	     * 
+	     * If the centre square starts off unoccupied, then
+	     * there are twelve pegs on each colour and all three
+	     * counts start off even; therefore, after 35 moves all
+	     * three counts would have to be odd, which isn't
+	     * possible if there's only one peg left. []
+	     * 
+	     * This proof works just as well if the starting hole
+	     * is _any_ of the thirteen positions labelled B. Also,
+	     * we can stripe the board in the opposite direction
+	     * and rule out any square labelled B in that colouring
+	     * as well. This leaves:
+	     * 
+	     *     Y n Y
+	     *   n n Y n n
+	     * Y n n Y n n Y
+	     * n Y Y n Y Y n
+	     * Y n n Y n n Y
+	     *   n n Y n n
+	     *     Y n Y
+	     * 
+	     * where the ns are squares we've proved insoluble, and
+	     * the Ys are the ones remaining.
+	     * 
+	     * That doesn't prove all those starting positions to
+	     * be soluble, of course; they're merely the ones we
+	     * _haven't_ proved to be impossible. Nevertheless, it
+	     * turns out that they are all soluble, so when the
+	     * user requests an Octagon board the simplest thing is
+	     * to pick one of these at random.
+	     * 
+	     * Rather than picking equiprobably from those twelve
+	     * positions, we'll pick equiprobably from the three
+	     * equivalence classes
+	     */
+	    switch (random_upto(rs, 3)) {
+	      case 0:
+		/* Remove a random corner piece. */
+		{
+		    int dx, dy;
+
+		    dx = random_upto(rs, 2) * 2 - 1;   /* +1 or -1 */
+		    dy = random_upto(rs, 2) * 2 - 1;   /* +1 or -1 */
+		    if (random_upto(rs, 2))
+			dy *= 3;
+		    else
+			dx *= 3;
+		    grid[(3+dy)*w+(3+dx)] = GRID_HOLE;
+		}
+		break;
+	      case 1:
+		/* Remove a random piece two from the centre. */
+		{
+		    int dx, dy;
+		    dx = 2 * (random_upto(rs, 2) * 2 - 1);
+		    if (random_upto(rs, 2))
+			dy = 0;
+		    else
+			dy = dx, dx = 0;
+		    grid[(3+dy)*w+(3+dx)] = GRID_HOLE;
+		}
+		break;
+	      default /* case 2 */:
+		/* Remove a random piece one from the centre. */
+		{
+		    int dx, dy;
+		    dx = random_upto(rs, 2) * 2 - 1;
+		    if (random_upto(rs, 2))
+			dy = 0;
+		    else
+			dy = dx, dx = 0;
+		    grid[(3+dy)*w+(3+dx)] = GRID_HOLE;
+		}
+		break;
+	    }
+	}
     }
 
     /*
@@ -850,28 +944,8 @@ static void game_set_size(game_drawstate *ds, game_params *params,
 static float *game_colours(frontend *fe, game_state *state, int *ncolours)
 {
     float *ret = snewn(3 * NCOLOURS, float);
-    int i;
-    float max;
 
-    frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
-
-    /*
-     * Drop the background colour so that the highlight is
-     * noticeably brighter than it while still being under 1.
-     */
-    max = ret[COL_BACKGROUND*3];
-    for (i = 1; i < 3; i++)
-        if (ret[COL_BACKGROUND*3+i] > max)
-            max = ret[COL_BACKGROUND*3+i];
-    if (max * 1.2F > 1.0F) {
-        for (i = 0; i < 3; i++)
-            ret[COL_BACKGROUND*3+i] /= (max * 1.2F);
-    }
-
-    for (i = 0; i < 3; i++) {
-        ret[COL_HIGHLIGHT * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 1.2F;
-        ret[COL_LOWLIGHT * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 0.8F;
-    }
+    game_mkhighlight(fe, ret, COL_BACKGROUND, COL_HIGHLIGHT, COL_LOWLIGHT);
 
     ret[COL_PEG * 3 + 0] = 0.0F;
     ret[COL_PEG * 3 + 1] = 0.0F;
@@ -1100,7 +1174,7 @@ static int game_wants_statusbar(void)
     return FALSE;
 }
 
-static int game_timing_state(game_state *state)
+static int game_timing_state(game_state *state, game_ui *ui)
 {
     return TRUE;
 }