X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/4a29930e1b9db1332c93244365db1642fcfac1cd..HEAD:/flip.c

diff --git a/flip.c b/flip.c
index 9876e1d..c30e484 100644
--- a/flip.c
+++ b/flip.c
@@ -3,15 +3,6 @@
  * where each click toggles an overlapping set of lights.
  */
 
-/*
- * TODO:
- * 
- *  - `Solve' could mark the squares you must click to solve
- *     + infrastructure change: this would mean the Solve operation
- * 	 must receive the current game_state as well as the initial
- * 	 one, which I've been wondering about for a while
- */
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -28,6 +19,8 @@ enum {
     COL_RIGHT,
     COL_GRID,
     COL_DIAG,
+    COL_HINT,
+    COL_CURSOR,
     NCOLOURS
 };
 
@@ -65,7 +58,7 @@ struct matrix {
 
 struct game_state {
     int w, h;
-    int moves, completed;
+    int moves, completed, cheated, hints_active;
     unsigned char *grid;               /* array of w*h */
     struct matrix *matrix;
 };
@@ -123,11 +116,11 @@ static game_params *dup_params(game_params *params)
 static void decode_params(game_params *ret, char const *string)
 {
     ret->w = ret->h = atoi(string);
-    while (*string && isdigit(*string)) string++;
+    while (*string && isdigit((unsigned char)*string)) string++;
     if (*string == 'x') {
         string++;
         ret->h = atoi(string);
-        while (*string && isdigit(*string)) string++;
+        while (*string && isdigit((unsigned char)*string)) string++;
     }
     if (*string == 'r') {
         string++;
@@ -189,7 +182,7 @@ static game_params *custom_params(config_item *cfg)
     return ret;
 }
 
-static char *validate_params(game_params *params)
+static char *validate_params(game_params *params, int full)
 {
     if (params->w <= 0 || params->h <= 0)
         return "Width and height must both be greater than zero";
@@ -355,7 +348,7 @@ static void addneighbours(tree234 *t, int w, int h, int cx, int cy,
 }
 
 static char *new_game_desc(game_params *params, random_state *rs,
-			   game_aux_info **aux, int interactive)
+			   char **aux, int interactive)
 {
     int w = params->w, h = params->h, wh = w * h;
     int i, j;
@@ -598,14 +591,11 @@ static char *new_game_desc(game_params *params, random_state *rs,
     sprintf(ret, "%s,%s", mbmp, gbmp);
     sfree(mbmp);
     sfree(gbmp);
+    sfree(matrix);
+    sfree(grid);
     return ret;
 }
 
-static void game_free_aux_info(game_aux_info *aux)
-{
-    assert(!"Shouldn't happen");
-}
-
 static char *validate_desc(game_params *params, char *desc)
 {
     int w = params->w, h = params->h, wh = w * h;
@@ -623,7 +613,7 @@ static char *validate_desc(game_params *params, char *desc)
     return NULL;
 }
 
-static game_state *new_game(midend_data *me, game_params *params, char *desc)
+static game_state *new_game(midend *me, game_params *params, char *desc)
 {
     int w = params->w, h = params->h, wh = w * h;
     int mlen = (wh*wh+3)/4;
@@ -633,6 +623,8 @@ static game_state *new_game(midend_data *me, game_params *params, char *desc)
     state->w = w;
     state->h = h;
     state->completed = FALSE;
+    state->cheated = FALSE;
+    state->hints_active = FALSE;
     state->moves = 0;
     state->matrix = snew(struct matrix);
     state->matrix->refcount = 1;
@@ -651,6 +643,8 @@ static game_state *dup_game(game_state *state)
     ret->w = state->w;
     ret->h = state->h;
     ret->completed = state->completed;
+    ret->cheated = state->cheated;
+    ret->hints_active = state->hints_active;
     ret->moves = state->moves;
     ret->matrix = state->matrix;
     state->matrix->refcount++;
@@ -670,10 +664,198 @@ static void free_game(game_state *state)
     sfree(state);
 }
 
-static game_state *solve_game(game_state *state, game_state *currstate,
-			      game_aux_info *aux, char **error)
+static void rowxor(unsigned char *row1, unsigned char *row2, int len)
 {
-    return NULL;
+    int i;
+    for (i = 0; i < len; i++)
+	row1[i] ^= row2[i];
+}
+
+static char *solve_game(game_state *state, game_state *currstate,
+			char *aux, char **error)
+{
+    int w = state->w, h = state->h, wh = w * h;
+    unsigned char *equations, *solution, *shortest;
+    int *und, nund;
+    int rowsdone, colsdone;
+    int i, j, k, len, bestlen;
+    char *ret;
+
+    /*
+     * Set up a list of simultaneous equations. Each one is of
+     * length (wh+1) and has wh coefficients followed by a value.
+     */
+    equations = snewn((wh + 1) * wh, unsigned char);
+    for (i = 0; i < wh; i++) {
+	for (j = 0; j < wh; j++)
+	    equations[i * (wh+1) + j] = currstate->matrix->matrix[j*wh+i];
+	equations[i * (wh+1) + wh] = currstate->grid[i] & 1;
+    }
+
+    /*
+     * Perform Gaussian elimination over GF(2).
+     */
+    rowsdone = colsdone = 0;
+    nund = 0;
+    und = snewn(wh, int);
+    do {
+	/*
+	 * Find the leftmost column which has a 1 in it somewhere
+	 * outside the first `rowsdone' rows.
+	 */
+	j = -1;
+	for (i = colsdone; i < wh; i++) {
+	    for (j = rowsdone; j < wh; j++)
+		if (equations[j * (wh+1) + i])
+		    break;
+	    if (j < wh)
+		break;		       /* found one */
+	    /*
+	     * This is a column which will not have an equation
+	     * controlling it. Mark it as undetermined.
+	     */
+	    und[nund++] = i;
+	}
+
+	/*
+	 * If there wasn't one, then we've finished: all remaining
+	 * equations are of the form 0 = constant. Check to see if
+	 * any of them wants 0 to be equal to 1; this is the
+	 * condition which indicates an insoluble problem
+	 * (therefore _hopefully_ one typed in by a user!).
+	 */
+	if (i == wh) {
+	    for (j = rowsdone; j < wh; j++)
+		if (equations[j * (wh+1) + wh]) {
+		    *error = "No solution exists for this position";
+		    sfree(equations);
+		    sfree(und);
+		    return NULL;
+		}
+	    break;
+	}
+
+	/*
+	 * We've found a 1. It's in column i, and the topmost 1 in
+	 * that column is in row j. Do a row-XOR to move it up to
+	 * the topmost row if it isn't already there.
+	 */
+	assert(j != -1);
+	if (j > rowsdone)
+	    rowxor(equations + rowsdone*(wh+1), equations + j*(wh+1), wh+1);
+
+	/*
+	 * Do row-XORs to eliminate that 1 from all rows below the
+	 * topmost row.
+	 */
+	for (j = rowsdone + 1; j < wh; j++)
+	    if (equations[j*(wh+1) + i])
+		rowxor(equations + j*(wh+1),
+		       equations + rowsdone*(wh+1), wh+1);
+
+	/*
+	 * Mark this row and column as done.
+	 */
+	rowsdone++;
+	colsdone = i+1;
+
+	/*
+	 * If we've done all the rows, terminate.
+	 */
+    } while (rowsdone < wh);
+
+    /*
+     * If we reach here, we have the ability to produce a solution.
+     * So we go through _all_ possible solutions (each
+     * corresponding to a set of arbitrary choices of those
+     * components not directly determined by an equation), and pick
+     * one requiring the smallest number of flips.
+     */
+    solution = snewn(wh, unsigned char);
+    shortest = snewn(wh, unsigned char);
+    memset(solution, 0, wh);
+    bestlen = wh + 1;
+    while (1) {
+	/*
+	 * Find a solution based on the current values of the
+	 * undetermined variables.
+	 */
+	for (j = rowsdone; j-- ;) {
+	    int v;
+
+	    /*
+	     * Find the leftmost set bit in this equation.
+	     */
+	    for (i = 0; i < wh; i++)
+		if (equations[j * (wh+1) + i])
+		    break;
+	    assert(i < wh);		       /* there must have been one! */
+
+	    /*
+	     * Compute this variable using the rest.
+	     */
+	    v = equations[j * (wh+1) + wh];
+	    for (k = i+1; k < wh; k++)
+		if (equations[j * (wh+1) + k])
+		    v ^= solution[k];
+
+	    solution[i] = v;
+	}
+
+	/*
+	 * Compare this solution to the current best one, and
+	 * replace the best one if this one is shorter.
+	 */
+	len = 0;
+	for (i = 0; i < wh; i++)
+	    if (solution[i])
+		len++;
+	if (len < bestlen) {
+	    bestlen = len;
+	    memcpy(shortest, solution, wh);
+	}
+
+	/*
+	 * Now increment the binary number given by the
+	 * undetermined variables: turn all 1s into 0s until we see
+	 * a 0, at which point we turn it into a 1.
+	 */
+	for (i = 0; i < nund; i++) {
+	    solution[und[i]] = !solution[und[i]];
+	    if (solution[und[i]])
+		break;
+	}
+
+	/*
+	 * If we didn't find a 0 at any point, we have wrapped
+	 * round and are back at the start, i.e. we have enumerated
+	 * all solutions.
+	 */
+	if (i == nund)
+	    break;
+    }
+
+    /*
+     * We have a solution. Produce a move string encoding the
+     * solution.
+     */
+    ret = snewn(wh + 2, char);
+    ret[0] = 'S';
+    for (i = 0; i < wh; i++)
+	ret[i+1] = shortest[i] ? '1' : '0';
+    ret[wh+1] = '\0';
+
+    sfree(shortest);
+    sfree(solution);
+    sfree(equations);
+    sfree(und);
+
+    return ret;
+}
+
+static int game_can_format_as_text_now(game_params *params)
+{
+    return TRUE;
 }
 
 static char *game_text_format(game_state *state)
@@ -681,13 +863,29 @@ static char *game_text_format(game_state *state)
     return NULL;
 }
 
+struct game_ui {
+    int cx, cy, cdraw;
+};
+
 static game_ui *new_ui(game_state *state)
 {
-    return NULL;
+    game_ui *ui = snew(game_ui);
+    ui->cx = ui->cy = ui->cdraw = 0;
+    return ui;
 }
 
 static void free_ui(game_ui *ui)
 {
+    sfree(ui);
+}
+
+static char *encode_ui(game_ui *ui)
+{
+    return NULL;
+}
+
+static void decode_ui(game_ui *ui, char *encoding)
+{
 }
 
 static void game_changed_state(game_ui *ui, game_state *oldstate,
@@ -701,66 +899,130 @@ struct game_drawstate {
     int tilesize;
 };
 
-static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
-                             int x, int y, int button)
+static char *interpret_move(game_state *state, game_ui *ui, const game_drawstate *ds,
+			    int x, int y, int button)
 {
-    int w = from->w, h = from->h, wh = w * h;
-    game_state *ret;
+    int w = state->w, h = state->h, wh = w * h;
+    char buf[80], *nullret = NULL;
+
+    if (button == LEFT_BUTTON || IS_CURSOR_SELECT(button)) {
+        int tx, ty;
+        if (button == LEFT_BUTTON) {
+            tx = FROMCOORD(x), ty = FROMCOORD(y);
+            ui->cdraw = 0;
+        } else {
+            tx = ui->cx; ty = ui->cy;
+            ui->cdraw = 1;
+        }
+        nullret = "";
 
-    if (button == LEFT_BUTTON) {
-        int tx = FROMCOORD(x), ty = FROMCOORD(y);
         if (tx >= 0 && tx < w && ty >= 0 && ty < h) {
-            int i, j, done;
+            /*
+             * It's just possible that a manually entered game ID
+             * will have at least one square do nothing whatsoever.
+             * If so, we avoid encoding a move at all.
+             */
+            int i = ty*w+tx, j, makemove = FALSE;
+            for (j = 0; j < wh; j++) {
+                if (state->matrix->matrix[i*wh+j])
+                    makemove = TRUE;
+            }
+            if (makemove) {
+                sprintf(buf, "M%d,%d", tx, ty);
+                return dupstr(buf);
+            } else {
+                return NULL;
+            }
+        }
+    }
+    else if (IS_CURSOR_MOVE(button)) {
+        int dx = 0, dy = 0;
+        switch (button) {
+        case CURSOR_UP:         dy = -1; break;
+        case CURSOR_DOWN:       dy = 1; break;
+        case CURSOR_RIGHT:      dx = 1; break;
+        case CURSOR_LEFT:       dx = -1; break;
+        default: assert(!"shouldn't get here");
+        }
+        ui->cx += dx; ui->cy += dy;
+        ui->cx = min(max(ui->cx, 0), state->w - 1);
+        ui->cy = min(max(ui->cy, 0), state->h - 1);
+        ui->cdraw = 1;
+        nullret = "";
+    }
 
-            ret = dup_game(from);
+    return nullret;
+}
+
+static game_state *execute_move(game_state *from, char *move)
+{
+    int w = from->w, h = from->h, wh = w * h;
+    game_state *ret;
+    int x, y;
+
+    if (move[0] == 'S' && strlen(move) == wh+1) {
+	int i;
+
+	ret = dup_game(from);
+	ret->hints_active = TRUE;
+	ret->cheated = TRUE;
+	for (i = 0; i < wh; i++) {
+	    ret->grid[i] &= ~2;
+	    if (move[i+1] != '0')
+		ret->grid[i] |= 2;
+	}
+	return ret;
+    } else if (move[0] == 'M' &&
+	       sscanf(move+1, "%d,%d", &x, &y) == 2 &&
+	x >= 0 && x < w && y >= 0 && y < h) {
+	int i, j, done;
 
-	    if (!ret->completed)
-		ret->moves++;
+	ret = dup_game(from);
 
-            i = ty * w + tx;
+	if (!ret->completed)
+	    ret->moves++;
 
-	    done = TRUE;
-            for (j = 0; j < wh; j++) {
-                ret->grid[j] ^= ret->matrix->matrix[i*wh+j];
-		if (ret->grid[j] & 1)
-		    done = FALSE;
-	    }
-	    if (done)
-		ret->completed = TRUE;
+	i = y * w + x;
 
-            return ret;
-        }
-    }
+	done = TRUE;
+	for (j = 0; j < wh; j++) {
+	    ret->grid[j] ^= ret->matrix->matrix[i*wh+j];
+	    if (ret->grid[j] & 1)
+		done = FALSE;
+	}
+	ret->grid[i] ^= 2;	       /* toggle hint */
+	if (done) {
+	    ret->completed = TRUE;
+	    ret->hints_active = FALSE;
+	}
 
-    return NULL;
+	return ret;
+    } else
+	return NULL;		       /* can't parse move string */
 }
 
 /* ----------------------------------------------------------------------
  * Drawing routines.
  */
 
-static void game_size(game_params *params, game_drawstate *ds,
-                      int *x, int *y, int expand)
+static void game_compute_size(game_params *params, int tilesize,
+			      int *x, int *y)
 {
-    int tsx, tsy, ts;
-    /*
-     * Each window dimension equals the tile size times one more
-     * than the grid dimension (the border is half the width of the
-     * tiles).
-     */
-    tsx = *x / (params->w + 1);
-    tsy = *y / (params->h + 1);
-    ts = min(tsx, tsy);
-    if (expand)
-        ds->tilesize = ts;
-    else
-        ds->tilesize = min(ts, PREFERRED_TILE_SIZE);
+    /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+    struct { int tilesize; } ads, *ds = &ads;
+    ads.tilesize = tilesize;
 
     *x = TILE_SIZE * params->w + 2 * BORDER;
     *y = TILE_SIZE * params->h + 2 * BORDER;
 }
 
-static float *game_colours(frontend *fe, game_state *state, int *ncolours)
+static void game_set_size(drawing *dr, game_drawstate *ds,
+			  game_params *params, int tilesize)
+{
+    ds->tilesize = tilesize;
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
 {
     float *ret = snewn(3 * NCOLOURS, float);
 
@@ -782,11 +1044,19 @@ static float *game_colours(frontend *fe, game_state *state, int *ncolours)
     ret[COL_DIAG * 3 + 1] = ret[COL_GRID * 3 + 1];
     ret[COL_DIAG * 3 + 2] = ret[COL_GRID * 3 + 2];
 
+    ret[COL_HINT * 3 + 0] = 1.0F;
+    ret[COL_HINT * 3 + 1] = 0.0F;
+    ret[COL_HINT * 3 + 2] = 0.0F;
+
+    ret[COL_CURSOR * 3 + 0] = 0.8F;
+    ret[COL_CURSOR * 3 + 1] = 0.0F;
+    ret[COL_CURSOR * 3 + 2] = 0.0F;
+
     *ncolours = NCOLOURS;
     return ret;
 }
 
-static game_drawstate *game_new_drawstate(game_state *state)
+static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
 {
     struct game_drawstate *ds = snew(struct game_drawstate);
     int i;
@@ -802,23 +1072,23 @@ static game_drawstate *game_new_drawstate(game_state *state)
     return ds;
 }
 
-static void game_free_drawstate(game_drawstate *ds)
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 {
     sfree(ds->tiles);
     sfree(ds);
 }
 
-static void draw_tile(frontend *fe, game_drawstate *ds,
+static void draw_tile(drawing *dr, game_drawstate *ds,
 		      game_state *state, int x, int y, int tile, int anim,
 		      float animtime)
 {
     int w = ds->w, h = ds->h, wh = w * h;
     int bx = x * TILE_SIZE + BORDER, by = y * TILE_SIZE + BORDER;
-    int i, j;
+    int i, j, dcol = (tile & 4) ? COL_CURSOR : COL_DIAG;
 
-    clip(fe, bx+1, by+1, TILE_SIZE-1, TILE_SIZE-1);
+    clip(dr, bx+1, by+1, TILE_SIZE-1, TILE_SIZE-1);
 
-    draw_rect(fe, bx+1, by+1, TILE_SIZE-1, TILE_SIZE-1,
+    draw_rect(dr, bx+1, by+1, TILE_SIZE-1, TILE_SIZE-1,
               anim ? COL_BACKGROUND : tile & 1 ? COL_WRONG : COL_RIGHT);
     if (anim) {
 	/*
@@ -829,19 +1099,18 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 
 	coords[0] = bx + TILE_SIZE;
 	coords[1] = by;
-	coords[2] = bx + TILE_SIZE * animtime;
-	coords[3] = by + TILE_SIZE * animtime;
+	coords[2] = bx + (int)((float)TILE_SIZE * animtime);
+	coords[3] = by + (int)((float)TILE_SIZE * animtime);
 	coords[4] = bx;
 	coords[5] = by + TILE_SIZE;
-	coords[6] = bx + TILE_SIZE - TILE_SIZE * animtime;
-	coords[7] = by + TILE_SIZE - TILE_SIZE * animtime;
+	coords[6] = bx + TILE_SIZE - (int)((float)TILE_SIZE * animtime);
+	coords[7] = by + TILE_SIZE - (int)((float)TILE_SIZE * animtime);
 
 	colour = (tile & 1 ? COL_WRONG : COL_RIGHT);
 	if (animtime < 0.5)
 	    colour = COL_WRONG + COL_RIGHT - colour;
 
-	draw_polygon(fe, coords, 4, TRUE, colour);
-	draw_polygon(fe, coords, 4, FALSE, COL_GRID);
+	draw_polygon(dr, coords, 4, colour, COL_GRID);
     }
 
     /*
@@ -856,21 +1125,37 @@ static void draw_tile(frontend *fe, game_drawstate *ds,
 		int cx = (bx + TILE_SIZE/2) + (2 * ox - 1) * td;
 		int cy = (by + TILE_SIZE/2) + (2 * oy - 1) * td;
 		if (ox == 0 && oy == 0)
-                    draw_rect(fe, cx, cy, 2*td+1, 2*td+1, COL_DIAG);
+                    draw_rect(dr, cx, cy, 2*td+1, 2*td+1, dcol);
                 else {
-                    draw_line(fe, cx, cy, cx+2*td, cy, COL_DIAG);
-                    draw_line(fe, cx, cy+2*td, cx+2*td, cy+2*td, COL_DIAG);
-                    draw_line(fe, cx, cy, cx, cy+2*td, COL_DIAG);
-                    draw_line(fe, cx+2*td, cy, cx+2*td, cy+2*td, COL_DIAG);
+                    draw_line(dr, cx, cy, cx+2*td, cy, dcol);
+                    draw_line(dr, cx, cy+2*td, cx+2*td, cy+2*td, dcol);
+                    draw_line(dr, cx, cy, cx, cy+2*td, dcol);
+                    draw_line(dr, cx+2*td, cy, cx+2*td, cy+2*td, dcol);
                 }
 	    }
 
-    unclip(fe);
+    /*
+     * Draw a hint rectangle if required.
+     */
+    if (tile & 2) {
+	int x1 = bx + TILE_SIZE / 20, x2 = bx + TILE_SIZE - TILE_SIZE / 20;
+	int y1 = by + TILE_SIZE / 20, y2 = by + TILE_SIZE - TILE_SIZE / 20;
+	int i = 3;
+	while (i--) {
+	    draw_line(dr, x1, y1, x2, y1, COL_HINT);
+	    draw_line(dr, x1, y2, x2, y2, COL_HINT);
+	    draw_line(dr, x1, y1, x1, y2, COL_HINT);
+	    draw_line(dr, x2, y1, x2, y2, COL_HINT);
+	    x1++, y1++, x2--, y2--;
+	}
+    }
+
+    unclip(dr);
 
-    draw_update(fe, bx+1, by+1, TILE_SIZE-1, TILE_SIZE-1);
+    draw_update(dr, bx+1, by+1, TILE_SIZE-1, TILE_SIZE-1);
 }
 
-static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
+static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
 			game_state *state, int dir, game_ui *ui,
 			float animtime, float flashtime)
 {
@@ -878,29 +1163,29 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
     int i, flashframe;
 
     if (!ds->started) {
-        draw_rect(fe, 0, 0, TILE_SIZE * w + 2 * BORDER,
+        draw_rect(dr, 0, 0, TILE_SIZE * w + 2 * BORDER,
                   TILE_SIZE * h + 2 * BORDER, COL_BACKGROUND);
 
         /*
          * Draw the grid lines.
          */
         for (i = 0; i <= w; i++)
-            draw_line(fe, i * TILE_SIZE + BORDER, BORDER,
+            draw_line(dr, i * TILE_SIZE + BORDER, BORDER,
                       i * TILE_SIZE + BORDER, h * TILE_SIZE + BORDER,
                       COL_GRID);
         for (i = 0; i <= h; i++)
-            draw_line(fe, BORDER, i * TILE_SIZE + BORDER,
+            draw_line(dr, BORDER, i * TILE_SIZE + BORDER,
                       w * TILE_SIZE + BORDER, i * TILE_SIZE + BORDER,
                       COL_GRID);
 
-        draw_update(fe, 0, 0, TILE_SIZE * w + 2 * BORDER,
+        draw_update(dr, 0, 0, TILE_SIZE * w + 2 * BORDER,
                     TILE_SIZE * h + 2 * BORDER);
 
         ds->started = TRUE;
     }
 
     if (flashtime)
-	flashframe = flashtime / FLASH_FRAME;
+	flashframe = (int)(flashtime / FLASH_FRAME);
     else
 	flashframe = -1;
 
@@ -922,13 +1207,18 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
 		v &= ~1;
 	}
 
-	if (oldstate && state->grid[i] != oldstate->grid[i])
+	if (!state->hints_active)
+	    v &= ~2;
+        if (ui->cdraw && ui->cx == x && ui->cy == y)
+            v |= 4;
+
+	if (oldstate && ((state->grid[i] ^ oldstate->grid[i]) &~ 2))
 	    vv = 255;		       /* means `animated' */
 	else
 	    vv = v;
 
         if (ds->tiles[i] == 255 || vv == 255 || ds->tiles[i] != vv) {
-            draw_tile(fe, ds, state, x, y, v, vv == 255, animtime);
+            draw_tile(dr, ds, state, x, y, v, vv == 255, animtime);
             ds->tiles[i] = vv;
         }
     }
@@ -936,10 +1226,13 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
     {
 	char buf[256];
 
-	sprintf(buf, "%sMoves: %d", state->completed ? "COMPLETED! " : "",
+	sprintf(buf, "%sMoves: %d",
+		(state->completed ? 
+		 (state->cheated ? "Auto-solved. " : "COMPLETED! ") :
+		 (state->cheated ? "Auto-solver used. " : "")),
 		state->moves);
 
-	status_bar(fe, buf);
+	status_bar(dr, buf);
     }
 }
 
@@ -958,22 +1251,30 @@ static float game_flash_length(game_state *oldstate, game_state *newstate,
     return 0.0F;
 }
 
-static int game_wants_statusbar(void)
+static int game_status(game_state *state)
 {
-    return TRUE;
+    return state->completed ? +1 : 0;
 }
 
-static int game_timing_state(game_state *state)
+static int game_timing_state(game_state *state, game_ui *ui)
 {
     return TRUE;
 }
 
+static void game_print_size(game_params *params, float *x, float *y)
+{
+}
+
+static void game_print(drawing *dr, game_state *state, int tilesize)
+{
+}
+
 #ifdef COMBINED
 #define thegame flip
 #endif
 
 const struct game thegame = {
-    "Flip", NULL,
+    "Flip", "games.flip", "flip",
     default_params,
     game_fetch_preset,
     decode_params,
@@ -983,25 +1284,29 @@ const struct game thegame = {
     TRUE, game_configure, custom_params,
     validate_params,
     new_game_desc,
-    game_free_aux_info,
     validate_desc,
     new_game,
     dup_game,
     free_game,
-    FALSE, solve_game,
-    FALSE, game_text_format,
+    TRUE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
+    encode_ui,
+    decode_ui,
     game_changed_state,
-    make_move,
-    game_size,
+    interpret_move,
+    execute_move,
+    PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
     game_colours,
     game_new_drawstate,
     game_free_drawstate,
     game_redraw,
     game_anim_length,
     game_flash_length,
-    game_wants_statusbar,
+    game_status,
+    FALSE, FALSE, game_print_size, game_print,
+    TRUE,			       /* wants_statusbar */
     FALSE, game_timing_state,
-    0,				       /* mouse_priorities */
+    0,				       /* flags */
 };