X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/19ef4855cd8681b43024a9df144c22aae91abc4f..HEAD:/cube.c

diff --git a/cube.c b/cube.c
index 145a1e5..15c479b 100644
--- a/cube.c
+++ b/cube.c
@@ -157,7 +157,8 @@ enum {
 
 enum { LEFT, RIGHT, UP, DOWN, UP_LEFT, UP_RIGHT, DOWN_LEFT, DOWN_RIGHT };
 
-#define GRID_SCALE 48.0F
+#define PREFERRED_GRID_SCALE 48
+#define GRID_SCALE (ds->gridscale)
 #define ROLLTIME 0.13F
 
 #define SQ(x) ( (x) * (x) )
@@ -178,7 +179,6 @@ struct grid_square {
     float points[8];                   /* maximum */
     int directions[8];                 /* bit masks showing point pairs */
     int flip;
-    int blue;
     int tetra_class;
 };
 
@@ -194,12 +194,25 @@ struct game_params {
     int d1, d2;
 };
 
+typedef struct game_grid game_grid;
+struct game_grid {
+    int refcount;
+    struct grid_square *squares;
+    int nsquares;
+};
+
+#define SET_SQUARE(state, i, val) \
+    ((state)->bluemask[(i)/32] &= ~(1 << ((i)%32)), \
+     (state)->bluemask[(i)/32] |= ((!!val) << ((i)%32)))
+#define GET_SQUARE(state, i) \
+    (((state)->bluemask[(i)/32] >> ((i)%32)) & 1)
+
 struct game_state {
     struct game_params params;
     const struct solid *solid;
     int *facecolours;
-    struct grid_square *squares;
-    int nsquares;
+    game_grid *grid;
+    unsigned long *bluemask;
     int current;                       /* index of current grid square */
     int sgkey[2];                      /* key-point indices into grid sq */
     int dgkey[2];                      /* key-point indices into grid sq */
@@ -274,10 +287,8 @@ static game_params *dup_params(game_params *params)
     return ret;
 }
 
-static game_params *decode_params(char const *string)
+static void decode_params(game_params *ret, char const *string)
 {
-    game_params *ret = default_params();
-
     switch (*string) {
       case 't': ret->solid = TETRAHEDRON; string++; break;
       case 'c': ret->solid = CUBE;        string++; break;
@@ -286,16 +297,14 @@ static game_params *decode_params(char const *string)
       default: break;
     }
     ret->d1 = ret->d2 = atoi(string);
-    while (*string && isdigit(*string)) string++;
+    while (*string && isdigit((unsigned char)*string)) string++;
     if (*string == 'x') {
         string++;
         ret->d2 = atoi(string);
     }
-
-    return ret;
 }
 
-static char *encode_params(game_params *params)
+static char *encode_params(game_params *params, int full)
 {
     char data[256];
 
@@ -304,10 +313,9 @@ static char *encode_params(game_params *params)
 
     return dupstr(data);
 }
+typedef void (*egc_callback)(void *, struct grid_square *);
 
-static void enum_grid_squares(game_params *params,
-                              void (*callback)(void *, struct grid_square *),
-                              void *ctx)
+static void enum_grid_squares(game_params *params, egc_callback callback, void *ctx)
 {
     const struct solid *solid = solids[params->solid];
 
@@ -529,7 +537,7 @@ static void count_grid_square_callback(void *ctx, struct grid_square *sq)
     classes[thisclass]++;
 }
 
-static char *validate_params(game_params *params)
+static char *validate_params(game_params *params, int full)
 {
     int classes[5];
     int i;
@@ -589,12 +597,13 @@ static void classify_grid_square_callback(void *ctx, struct grid_square *sq)
 	data->squareindex++;
 }
 
-static char *new_game_seed(game_params *params, random_state *rs)
+static char *new_game_desc(game_params *params, random_state *rs,
+			   char **aux, int interactive)
 {
     struct grid_data data;
     int i, j, k, m, area, facesperclass;
     int *flags;
-    char *seed, *p;
+    char *desc, *p;
 
     /*
      * Enumerate the grid squares, dividing them into equivalence
@@ -658,8 +667,8 @@ static char *new_game_seed(game_params *params, random_state *rs)
      * the non-blue squares into a list in the now-unused gridptrs
      * array.
      */
-    seed = snewn(area / 4 + 40, char);
-    p = seed;
+    desc = snewn(area / 4 + 40, char);
+    p = desc;
     j = 0;
     k = 8;
     m = 0;
@@ -687,16 +696,14 @@ static char *new_game_seed(game_params *params, random_state *rs)
     sfree(data.gridptrs[0]);
     sfree(flags);
 
-    return seed;
+    return desc;
 }
 
 static void add_grid_square_callback(void *ctx, struct grid_square *sq)
 {
-    game_state *state = (game_state *)ctx;
+    game_grid *grid = (game_grid *)ctx;
 
-    state->squares[state->nsquares] = *sq;   /* structure copy */
-    state->squares[state->nsquares].blue = FALSE;
-    state->nsquares++;
+    grid->squares[grid->nsquares++] = *sq;   /* structure copy */
 }
 
 static int lowest_face(const struct solid *solid)
@@ -838,36 +845,37 @@ static struct solid *transform_poly(const struct solid *solid, int flip,
     return ret;
 }
 
-static char *validate_seed(game_params *params, char *seed)
+static char *validate_desc(game_params *params, char *desc)
 {
     int area = grid_area(params->d1, params->d2, solids[params->solid]->order);
     int i, j;
 
     i = (area + 3) / 4;
     for (j = 0; j < i; j++) {
-	int c = seed[j];
+	int c = desc[j];
 	if (c >= '0' && c <= '9') continue;
 	if (c >= 'A' && c <= 'F') continue;
 	if (c >= 'a' && c <= 'f') continue;
 	return "Not enough hex digits at start of string";
-	/* NB if seed[j]=='\0' that will also be caught here, so we're safe */
+	/* NB if desc[j]=='\0' that will also be caught here, so we're safe */
     }
 
-    if (seed[i] != ',')
+    if (desc[i] != ',')
 	return "Expected ',' after hex digits";
 
     i++;
     do {
-	if (seed[i] < '0' || seed[i] > '9')
+	if (desc[i] < '0' || desc[i] > '9')
 	    return "Expected decimal integer after ','";
 	i++;
-    } while (seed[i]);
+    } while (desc[i]);
 
     return NULL;
 }
 
-static game_state *new_game(game_params *params, char *seed)
+static game_state *new_game(midend *me, game_params *params, char *desc)
 {
+    game_grid *grid = snew(game_grid);
     game_state *state = snew(game_state);
     int area;
 
@@ -875,25 +883,31 @@ static game_state *new_game(game_params *params, char *seed)
     state->solid = solids[params->solid];
 
     area = grid_area(params->d1, params->d2, state->solid->order);
-    state->squares = snewn(area, struct grid_square);
-    state->nsquares = 0;
-    enum_grid_squares(params, add_grid_square_callback, state);
-    assert(state->nsquares == area);
+    grid->squares = snewn(area, struct grid_square);
+    grid->nsquares = 0;
+    enum_grid_squares(params, add_grid_square_callback, grid);
+    assert(grid->nsquares == area);
+    state->grid = grid;
+    grid->refcount = 1;
 
     state->facecolours = snewn(state->solid->nfaces, int);
     memset(state->facecolours, 0, state->solid->nfaces * sizeof(int));
 
+    state->bluemask = snewn((state->grid->nsquares + 31) / 32, unsigned long);
+    memset(state->bluemask, 0, (state->grid->nsquares + 31) / 32 *
+	   sizeof(unsigned long));
+
     /*
      * Set up the blue squares and polyhedron position according to
-     * the game seed.
+     * the game description.
      */
     {
-	char *p = seed;
+	char *p = desc;
 	int i, j, v;
 
 	j = 8;
 	v = 0;
-	for (i = 0; i < state->nsquares; i++) {
+	for (i = 0; i < state->grid->nsquares; i++) {
 	    if (j == 8) {
 		v = *p++;
 		if (v >= '0' && v <= '9')
@@ -906,7 +920,7 @@ static game_state *new_game(game_params *params, char *seed)
 		    break;
 	    }
 	    if (v & j)
-		state->squares[i].blue = TRUE;
+		SET_SQUARE(state, i, TRUE);
 	    j >>= 1;
 	    if (j == 0)
 		j = 8;
@@ -916,7 +930,7 @@ static game_state *new_game(game_params *params, char *seed)
 	    p++;
 
 	state->current = atoi(p);
-	if (state->current < 0 || state->current >= state->nsquares)
+	if (state->current < 0 || state->current >= state->grid->nsquares)
 	    state->current = 0;	       /* got to do _something_ */
     }
 
@@ -928,7 +942,7 @@ static game_state *new_game(game_params *params, char *seed)
         int pkey[4];
         int ret;
 
-        ret = align_poly(state->solid, &state->squares[state->current], pkey);
+        ret = align_poly(state->solid, &state->grid->squares[state->current], pkey);
         assert(ret);
 
         state->dpkey[0] = state->spkey[0] = pkey[0];
@@ -954,10 +968,12 @@ static game_state *dup_game(game_state *state)
     ret->facecolours = snewn(ret->solid->nfaces, int);
     memcpy(ret->facecolours, state->facecolours,
            ret->solid->nfaces * sizeof(int));
-    ret->nsquares = state->nsquares;
-    ret->squares = snewn(ret->nsquares, struct grid_square);
-    memcpy(ret->squares, state->squares,
-           ret->nsquares * sizeof(struct grid_square));
+    ret->current = state->current;
+    ret->grid = state->grid;
+    ret->grid->refcount++;
+    ret->bluemask = snewn((ret->grid->nsquares + 31) / 32, unsigned long);
+    memcpy(ret->bluemask, state->bluemask, (ret->grid->nsquares + 31) / 32 *
+	   sizeof(unsigned long));
     ret->dpkey[0] = state->dpkey[0];
     ret->dpkey[1] = state->dpkey[1];
     ret->dgkey[0] = state->dgkey[0];
@@ -976,9 +992,31 @@ static game_state *dup_game(game_state *state)
 
 static void free_game(game_state *state)
 {
+    if (--state->grid->refcount <= 0) {
+	sfree(state->grid->squares);
+	sfree(state->grid);
+    }
+    sfree(state->bluemask);
+    sfree(state->facecolours);
     sfree(state);
 }
 
+static char *solve_game(game_state *state, game_state *currstate,
+			char *aux, char **error)
+{
+    return NULL;
+}
+
+static int game_can_format_as_text_now(game_params *params)
+{
+    return TRUE;
+}
+
+static char *game_text_format(game_state *state)
+{
+    return NULL;
+}
+
 static game_ui *new_ui(game_state *state)
 {
     return NULL;
@@ -988,50 +1026,45 @@ static void free_ui(game_ui *ui)
 {
 }
 
-static game_state *make_move(game_state *from, game_ui *ui,
-			     int x, int y, int button)
+static char *encode_ui(game_ui *ui)
 {
-    int direction;
-    int pkey[2], skey[2], dkey[2];
-    float points[4];
-    game_state *ret;
-    float angle;
-    int i, j, dest, mask;
-    struct solid *poly;
+    return NULL;
+}
 
-    /*
-     * All moves are made with the cursor keys.
-     */
-    if (button == CURSOR_UP)
-        direction = UP;
-    else if (button == CURSOR_DOWN)
-        direction = DOWN;
-    else if (button == CURSOR_LEFT)
-        direction = LEFT;
-    else if (button == CURSOR_RIGHT)
-        direction = RIGHT;
-    else if (button == CURSOR_UP_LEFT)
-        direction = UP_LEFT;
-    else if (button == CURSOR_DOWN_LEFT)
-        direction = DOWN_LEFT;
-    else if (button == CURSOR_UP_RIGHT)
-        direction = UP_RIGHT;
-    else if (button == CURSOR_DOWN_RIGHT)
-        direction = DOWN_RIGHT;
-    else
-        return NULL;
+static void decode_ui(game_ui *ui, char *encoding)
+{
+}
+
+static void game_changed_state(game_ui *ui, game_state *oldstate,
+                               game_state *newstate)
+{
+}
+
+struct game_drawstate {
+    float gridscale;
+    int ox, oy;                        /* pixel position of float origin */
+};
+
+/*
+ * Code shared between interpret_move() and execute_move().
+ */
+static int find_move_dest(game_state *from, int direction,
+			  int *skey, int *dkey)
+{
+    int mask, dest, i, j;
+    float points[4];
 
     /*
      * Find the two points in the current grid square which
      * correspond to this move.
      */
-    mask = from->squares[from->current].directions[direction];
+    mask = from->grid->squares[from->current].directions[direction];
     if (mask == 0)
-        return NULL;
-    for (i = j = 0; i < from->squares[from->current].npoints; i++)
+        return -1;
+    for (i = j = 0; i < from->grid->squares[from->current].npoints; i++)
         if (mask & (1 << i)) {
-            points[j*2] = from->squares[from->current].points[i*2];
-            points[j*2+1] = from->squares[from->current].points[i*2+1];
+            points[j*2] = from->grid->squares[from->current].points[i*2];
+            points[j*2+1] = from->grid->squares[from->current].points[i*2+1];
             skey[j] = i;
             j++;
         }
@@ -1042,18 +1075,18 @@ static game_state *make_move(game_state *from, game_ui *ui,
      * This is our move destination.
      */
     dest = -1;
-    for (i = 0; i < from->nsquares; i++)
+    for (i = 0; i < from->grid->nsquares; i++)
         if (i != from->current) {
             int match = 0;
             float dist;
 
-            for (j = 0; j < from->squares[i].npoints; j++) {
-                dist = (SQ(from->squares[i].points[j*2] - points[0]) +
-                        SQ(from->squares[i].points[j*2+1] - points[1]));
+            for (j = 0; j < from->grid->squares[i].npoints; j++) {
+                dist = (SQ(from->grid->squares[i].points[j*2] - points[0]) +
+                        SQ(from->grid->squares[i].points[j*2+1] - points[1]));
                 if (dist < 0.1)
                     dkey[match++] = j;
-                dist = (SQ(from->squares[i].points[j*2] - points[2]) +
-                        SQ(from->squares[i].points[j*2+1] - points[3]));
+                dist = (SQ(from->grid->squares[i].points[j*2] - points[2]) +
+                        SQ(from->grid->squares[i].points[j*2+1] - points[3]));
                 if (dist < 0.1)
                     dkey[match++] = j;
             }
@@ -1064,11 +1097,154 @@ static game_state *make_move(game_state *from, game_ui *ui,
             }
         }
 
+    return dest;
+}
+
+static char *interpret_move(game_state *state, game_ui *ui, const game_drawstate *ds,
+			    int x, int y, int button)
+{
+    int direction, mask, i;
+    int skey[2], dkey[2];
+
+    button = button & (~MOD_MASK | MOD_NUM_KEYPAD);
+
+    /*
+     * Moves can be made with the cursor keys or numeric keypad, or
+     * alternatively you can left-click and the polyhedron will
+     * move in the general direction of the mouse pointer.
+     */
+    if (button == CURSOR_UP || button == (MOD_NUM_KEYPAD | '8'))
+        direction = UP;
+    else if (button == CURSOR_DOWN || button == (MOD_NUM_KEYPAD | '2'))
+        direction = DOWN;
+    else if (button == CURSOR_LEFT || button == (MOD_NUM_KEYPAD | '4'))
+        direction = LEFT;
+    else if (button == CURSOR_RIGHT || button == (MOD_NUM_KEYPAD | '6'))
+        direction = RIGHT;
+    else if (button == (MOD_NUM_KEYPAD | '7'))
+        direction = UP_LEFT;
+    else if (button == (MOD_NUM_KEYPAD | '1'))
+        direction = DOWN_LEFT;
+    else if (button == (MOD_NUM_KEYPAD | '9'))
+        direction = UP_RIGHT;
+    else if (button == (MOD_NUM_KEYPAD | '3'))
+        direction = DOWN_RIGHT;
+    else if (button == LEFT_BUTTON) {
+        /*
+         * Find the bearing of the click point from the current
+         * square's centre.
+         */
+        int cx, cy;
+        double angle;
+
+        cx = (int)(state->grid->squares[state->current].x * GRID_SCALE) + ds->ox;
+        cy = (int)(state->grid->squares[state->current].y * GRID_SCALE) + ds->oy;
+
+        if (x == cx && y == cy)
+            return NULL;               /* clicked in exact centre!  */
+        angle = atan2(y - cy, x - cx);
+
+        /*
+         * There are three possibilities.
+         * 
+         *  - This square is a square, so we choose between UP,
+         *    DOWN, LEFT and RIGHT by dividing the available angle
+         *    at the 45-degree points.
+         * 
+         *  - This square is an up-pointing triangle, so we choose
+         *    between DOWN, LEFT and RIGHT by dividing into
+         *    120-degree arcs.
+         * 
+         *  - This square is a down-pointing triangle, so we choose
+         *    between UP, LEFT and RIGHT in the inverse manner.
+         * 
+         * Don't forget that since our y-coordinates increase
+         * downwards, `angle' is measured _clockwise_ from the
+         * x-axis, not anticlockwise as most mathematicians would
+         * instinctively assume.
+         */
+        if (state->grid->squares[state->current].npoints == 4) {
+            /* Square. */
+            if (fabs(angle) > 3*PI/4)
+                direction = LEFT;
+            else if (fabs(angle) < PI/4)
+                direction = RIGHT;
+            else if (angle > 0)
+                direction = DOWN;
+            else
+                direction = UP;
+        } else if (state->grid->squares[state->current].directions[UP] == 0) {
+            /* Up-pointing triangle. */
+            if (angle < -PI/2 || angle > 5*PI/6)
+                direction = LEFT;
+            else if (angle > PI/6)
+                direction = DOWN;
+            else
+                direction = RIGHT;
+        } else {
+            /* Down-pointing triangle. */
+            assert(state->grid->squares[state->current].directions[DOWN] == 0);
+            if (angle > PI/2 || angle < -5*PI/6)
+                direction = LEFT;
+            else if (angle < -PI/6)
+                direction = UP;
+            else
+                direction = RIGHT;
+        }
+    } else
+        return NULL;
+
+    mask = state->grid->squares[state->current].directions[direction];
+    if (mask == 0)
+        return NULL;
+
+    /*
+     * Translate diagonal directions into orthogonal ones.
+     */
+    if (direction > DOWN) {
+	for (i = LEFT; i <= DOWN; i++)
+	    if (state->grid->squares[state->current].directions[i] == mask) {
+		direction = i;
+		break;
+	    }
+	assert(direction <= DOWN);
+    }
+
+    if (find_move_dest(state, direction, skey, dkey) < 0)
+	return NULL;
+
+    if (direction == LEFT)  return dupstr("L");
+    if (direction == RIGHT) return dupstr("R");
+    if (direction == UP)    return dupstr("U");
+    if (direction == DOWN)  return dupstr("D");
+
+    return NULL;		       /* should never happen */
+}
+
+static game_state *execute_move(game_state *from, char *move)
+{
+    game_state *ret;
+    float angle;
+    struct solid *poly;
+    int pkey[2];
+    int skey[2], dkey[2];
+    int i, j, dest;
+    int direction;
+
+    switch (*move) {
+      case 'L': direction = LEFT; break;
+      case 'R': direction = RIGHT; break;
+      case 'U': direction = UP; break;
+      case 'D': direction = DOWN; break;
+      default: return NULL;
+    }
+
+    dest = find_move_dest(from, direction, skey, dkey);
     if (dest < 0)
         return NULL;
 
     ret = dup_game(from);
-    ret->current = i;
+    ret->current = dest;
 
     /*
      * So we know what grid square we're aiming for, and we also
@@ -1083,7 +1259,7 @@ static game_state *make_move(game_state *from, game_ui *ui,
      */
     {
         int all_pkey[4];
-        align_poly(from->solid, &from->squares[from->current], all_pkey);
+        align_poly(from->solid, &from->grid->squares[from->current], all_pkey);
         pkey[0] = all_pkey[skey[0]];
         pkey[1] = all_pkey[skey[1]];
         /*
@@ -1143,18 +1319,19 @@ static game_state *make_move(game_state *from, game_ui *ui,
             angle = -angle;            /* HACK */
 
         poly = transform_poly(from->solid,
-                              from->squares[from->current].flip,
+                              from->grid->squares[from->current].flip,
                               pkey[0], pkey[1], angle);
-        flip_poly(poly, from->squares[ret->current].flip);
-        success = align_poly(poly, &from->squares[ret->current], all_pkey);
+        flip_poly(poly, from->grid->squares[ret->current].flip);
+        success = align_poly(poly, &from->grid->squares[ret->current], all_pkey);
 
         if (!success) {
+            sfree(poly);
             angle = -angle;
             poly = transform_poly(from->solid,
-                                  from->squares[from->current].flip,
+                                  from->grid->squares[from->current].flip,
                                   pkey[0], pkey[1], angle);
-            flip_poly(poly, from->squares[ret->current].flip);
-            success = align_poly(poly, &from->squares[ret->current], all_pkey);
+            flip_poly(poly, from->grid->squares[ret->current].flip);
+            success = align_poly(poly, &from->grid->squares[ret->current], all_pkey);
         }
 
         assert(success);
@@ -1220,8 +1397,8 @@ static game_state *make_move(game_state *from, game_ui *ui,
     if (!ret->completed) {
         i = lowest_face(from->solid);
         j = ret->facecolours[i];
-        ret->facecolours[i] = ret->squares[ret->current].blue;
-        ret->squares[ret->current].blue = j;
+        ret->facecolours[i] = GET_SQUARE(ret, ret->current);
+        SET_SQUARE(ret, ret->current, j);
 
         /*
          * Detect game completion.
@@ -1244,7 +1421,7 @@ static game_state *make_move(game_state *from, game_ui *ui,
         int pkey[4];
         int success;
 
-        success = align_poly(ret->solid, &ret->squares[ret->current], pkey);
+        success = align_poly(ret->solid, &ret->grid->squares[ret->current], pkey);
         assert(success);
 
         ret->dpkey[0] = pkey[0];
@@ -1272,10 +1449,6 @@ struct bbox {
     float l, r, u, d;
 };
 
-struct game_drawstate {
-    int ox, oy;                        /* pixel position of float origin */
-};
-
 static void find_bbox_callback(void *ctx, struct grid_square *sq)
 {
     struct bbox *bb = (struct bbox *)ctx;
@@ -1306,14 +1479,31 @@ static struct bbox find_bbox(game_params *params)
     return bb;
 }
 
-static void game_size(game_params *params, int *x, int *y)
+#define XSIZE(gs, bb, solid) \
+    ((int)(((bb).r - (bb).l + 2*(solid)->border) * gs))
+#define YSIZE(gs, bb, solid) \
+    ((int)(((bb).d - (bb).u + 2*(solid)->border) * gs))
+
+static void game_compute_size(game_params *params, int tilesize,
+			      int *x, int *y)
 {
     struct bbox bb = find_bbox(params);
-    *x = (int)((bb.r - bb.l + 2*solids[params->solid]->border) * GRID_SCALE);
-    *y = (int)((bb.d - bb.u + 2*solids[params->solid]->border) * GRID_SCALE);
+
+    *x = XSIZE(tilesize, bb, solids[params->solid]);
+    *y = YSIZE(tilesize, bb, solids[params->solid]);
 }
 
-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)
+{
+    struct bbox bb = find_bbox(params);
+
+    ds->gridscale = (float)tilesize;
+    ds->ox = (int)(-(bb.l - solids[params->solid]->border) * ds->gridscale);
+    ds->oy = (int)(-(bb.u - solids[params->solid]->border) * ds->gridscale);
+}
+
+static float *game_colours(frontend *fe, int *ncolours)
 {
     float *ret = snewn(3 * NCOLOURS, float);
 
@@ -1331,25 +1521,24 @@ static float *game_colours(frontend *fe, game_state *state, int *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);
-    struct bbox bb = find_bbox(&state->params);
 
-    ds->ox = (int)(-(bb.l - state->solid->border) * GRID_SCALE);
-    ds->oy = (int)(-(bb.u - state->solid->border) * GRID_SCALE);
+    ds->ox = ds->oy = 0;
+    ds->gridscale = 0.0F; /* not decided yet */
 
     return ds;
 }
 
-static void game_free_drawstate(game_drawstate *ds)
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
 {
     sfree(ds);
 }
 
-static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
-                 game_state *state, int dir, game_ui *ui,
-                 float animtime, float flashtime)
+static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
+                        game_state *state, int dir, game_ui *ui,
+                        float animtime, float flashtime)
 {
     int i, j;
     struct bbox bb = find_bbox(&state->params);
@@ -1357,11 +1546,10 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
     int *pkey, *gkey;
     float t[3];
     float angle;
-    game_state *newstate;
     int square;
 
-    draw_rect(fe, 0, 0, (int)((bb.r-bb.l+2.0F) * GRID_SCALE),
-              (int)((bb.d-bb.u+2.0F) * GRID_SCALE), COL_BACKGROUND);
+    draw_rect(dr, 0, 0, XSIZE(GRID_SCALE, bb, state->solid),
+	      YSIZE(GRID_SCALE, bb, state->solid), COL_BACKGROUND);
 
     if (dir < 0) {
         game_state *t;
@@ -1391,28 +1579,27 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
         pkey = state->spkey;
         gkey = state->sgkey;
     }
-    newstate = state;
     state = oldstate;
 
-    for (i = 0; i < state->nsquares; i++) {
+    for (i = 0; i < state->grid->nsquares; i++) {
         int coords[8];
 
-        for (j = 0; j < state->squares[i].npoints; j++) {
-            coords[2*j] = ((int)(state->squares[i].points[2*j] * GRID_SCALE)
+        for (j = 0; j < state->grid->squares[i].npoints; j++) {
+            coords[2*j] = ((int)(state->grid->squares[i].points[2*j] * GRID_SCALE)
 			   + ds->ox);
-            coords[2*j+1] = ((int)(state->squares[i].points[2*j+1]*GRID_SCALE)
+            coords[2*j+1] = ((int)(state->grid->squares[i].points[2*j+1]*GRID_SCALE)
 			     + ds->oy);
         }
 
-        draw_polygon(fe, coords, state->squares[i].npoints, TRUE,
-                     state->squares[i].blue ? COL_BLUE : COL_BACKGROUND);
-        draw_polygon(fe, coords, state->squares[i].npoints, FALSE, COL_BORDER);
+        draw_polygon(dr, coords, state->grid->squares[i].npoints,
+                     GET_SQUARE(state, i) ? COL_BLUE : COL_BACKGROUND,
+		     COL_BORDER);
     }
 
     /*
      * Now compute and draw the polyhedron.
      */
-    poly = transform_poly(state->solid, state->squares[square].flip,
+    poly = transform_poly(state->solid, state->grid->squares[square].flip,
                           pkey[0], pkey[1], angle);
 
     /*
@@ -1428,7 +1615,7 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
 
             if (i < 2) {
                 grid_coord =
-                    state->squares[square].points[gkey[j]*2+i];
+                    state->grid->squares[square].points[gkey[j]*2+i];
             } else {
                 grid_coord = 0.0;
             }
@@ -1486,14 +1673,14 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
                 continue;
         }
 
-        draw_polygon(fe, coords, poly->order, TRUE,
-                     state->facecolours[i] ? COL_BLUE : COL_BACKGROUND);
-        draw_polygon(fe, coords, poly->order, FALSE, COL_BORDER);
+        draw_polygon(dr, coords, poly->order,
+                     state->facecolours[i] ? COL_BLUE : COL_BACKGROUND,
+		     COL_BORDER);
     }
     sfree(poly);
 
-    draw_update(fe, 0, 0, (int)((bb.r-bb.l+2.0F) * GRID_SCALE),
-                (int)((bb.d-bb.u+2.0F) * GRID_SCALE));
+    draw_update(dr, 0, 0, XSIZE(GRID_SCALE, bb, state->solid),
+		YSIZE(GRID_SCALE, bb, state->solid));
 
     /*
      * Update the status bar.
@@ -1505,56 +1692,78 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
 		(state->completed ? "COMPLETED! " : ""),
 		(state->completed ? state->completed : state->movecount));
 
-	status_bar(fe, statusbuf);
+	status_bar(dr, statusbuf);
     }
 }
 
 static float game_anim_length(game_state *oldstate,
-			      game_state *newstate, int dir)
+			      game_state *newstate, int dir, game_ui *ui)
 {
     return ROLLTIME;
 }
 
 static float game_flash_length(game_state *oldstate,
-			       game_state *newstate, int dir)
+			       game_state *newstate, int dir, game_ui *ui)
 {
     return 0.0F;
 }
 
-static int game_wants_statusbar(void)
+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;
 }
 
+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 cube
 #endif
 
 const struct game thegame = {
-    "Cube", "games.cube", TRUE,
+    "Cube", "games.cube", "cube",
     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_desc,
+    validate_desc,
     new_game,
     dup_game,
     free_game,
+    FALSE, solve_game,
+    FALSE, game_can_format_as_text_now, game_text_format,
     new_ui,
     free_ui,
-    make_move,
-    game_size,
+    encode_ui,
+    decode_ui,
+    game_changed_state,
+    interpret_move,
+    execute_move,
+    PREFERRED_GRID_SCALE, 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,				       /* flags */
 };