Re-architecting of the game backend interface. make_move() has been

split into two functions. The first, interpret_move(), takes all the
arguments that make_move() used to get and may have the usual side
effects of modifying the game_ui, but instead of returning a
modified game_state it instead returns a string description of the
move to be made. This string description is then passed to a second
function, execute_move(), together with an input game_state, which
is responsible for actually producing the new state. (solve_game()
also returns a string to be passed to execute_move().)

The point of this is to work towards being able to serialise the
whole of a game midend into a byte stream such as a disk file, which
will eventually support save and load functions in the desktop
puzzles, as well as restoring half-finished games after a quit and
restart in James Harvey's Palm port. Making each game supply a
convert-to-string function for its game_state format would have been
an unreliable way to do this, since those functions would not have
been used in normal play, so they'd only have been tested when you
actually tried to save and load - a recipe for latent bugs if ever I
heard one. This way, you won't even be able to _make_ a move if
execute_move() doesn't work properly, which means that if you can
play a game at all I can have pretty high confidence that
serialising it will work first time.

This is only the groundwork; there will be more checkins to come on
this theme. But the major upheaval should now be done, and as far as
I can tell everything's still working normally.

[originally from svn r6024]

1 files changed, 106 insertions, 52 deletions

diff --git a/cube.c b/cube.c
index 0658970..4f26df7 100644
--- a/cube.c
+++ b/cube.c
@@ -984,8 +984,8 @@ 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 char *solve_game(game_state *state, game_state *currstate,
+			game_aux_info *aux, char **error)
 {
     return NULL;
 }
@@ -1014,16 +1014,66 @@ struct game_drawstate {
     int ox, oy;                        /* pixel position of float origin */
 };
 
-static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
-			     int x, int y, int button)
+/*
+ * Code shared between interpret_move() and execute_move().
+ */
+static int find_move_dest(game_state *from, int direction,
+			  int *skey, int *dkey)
 {
-    int direction;
-    int pkey[2], skey[2], dkey[2];
+    int mask, dest, i, j;
     float points[4];
-    game_state *ret;
-    float angle;
-    int i, j, dest, mask;
-    struct solid *poly;
+
+    /*
+     * Find the two points in the current grid square which
+     * correspond to this move.
+     */
+    mask = from->squares[from->current].directions[direction];
+    if (mask == 0)
+        return -1;
+    for (i = j = 0; i < from->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];
+            skey[j] = i;
+            j++;
+        }
+    assert(j == 2);
+
+    /*
+     * Now find the other grid square which shares those points.
+     * This is our move destination.
+     */
+    dest = -1;
+    for (i = 0; i < from->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]));
+                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]));
+                if (dist < 0.1)
+                    dkey[match++] = j;
+            }
+
+            if (match == 2) {
+                dest = i;
+                break;
+            }
+        }
+
+    return dest;
+}
+
+static char *interpret_move(game_state *state, game_ui *ui, 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);
 
@@ -1056,8 +1106,8 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
         int cx, cy;
         double angle;
 
-        cx = from->squares[from->current].x * GRID_SCALE + ds->ox;
-        cy = from->squares[from->current].y * GRID_SCALE + ds->oy;
+        cx = state->squares[state->current].x * GRID_SCALE + ds->ox;
+        cy = state->squares[state->current].y * GRID_SCALE + ds->oy;
 
         if (x == cx && y == cy)
             return NULL;               /* clicked in exact centre!  */
@@ -1082,7 +1132,7 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
          * x-axis, not anticlockwise as most mathematicians would
          * instinctively assume.
          */
-        if (from->squares[from->current].npoints == 4) {
+        if (state->squares[state->current].npoints == 4) {
             /* Square. */
             if (fabs(angle) > 3*PI/4)
                 direction = LEFT;
@@ -1092,7 +1142,7 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
                 direction = DOWN;
             else
                 direction = UP;
-        } else if (from->squares[from->current].directions[UP] == 0) {
+        } else if (state->squares[state->current].directions[UP] == 0) {
             /* Up-pointing triangle. */
             if (angle < -PI/2 || angle > 5*PI/6)
                 direction = LEFT;
@@ -1102,7 +1152,7 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
                 direction = RIGHT;
         } else {
             /* Down-pointing triangle. */
-            assert(from->squares[from->current].directions[DOWN] == 0);
+            assert(state->squares[state->current].directions[DOWN] == 0);
             if (angle > PI/2 || angle < -5*PI/6)
                 direction = LEFT;
             else if (angle < -PI/6)
@@ -1113,54 +1163,57 @@ static game_state *make_move(game_state *from, game_ui *ui, game_drawstate *ds,
     } else
         return NULL;
 
-    /*
-     * Find the two points in the current grid square which
-     * correspond to this move.
-     */
-    mask = from->squares[from->current].directions[direction];
+    mask = state->squares[state->current].directions[direction];
     if (mask == 0)
         return NULL;
-    for (i = j = 0; i < from->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];
-            skey[j] = i;
-            j++;
-        }
-    assert(j == 2);
 
     /*
-     * Now find the other grid square which shares those points.
-     * This is our move destination.
+     * Translate diagonal directions into orthogonal ones.
      */
-    dest = -1;
-    for (i = 0; i < from->nsquares; i++)
-        if (i != from->current) {
-            int match = 0;
-            float dist;
+    if (direction > DOWN) {
+	for (i = LEFT; i <= DOWN; i++)
+	    if (state->squares[state->current].directions[i] == mask) {
+		direction = i;
+		break;
+	    }
+	assert(direction <= DOWN);
+    }
 
-            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]));
-                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]));
-                if (dist < 0.1)
-                    dkey[match++] = j;
-            }
+    if (find_move_dest(state, direction, skey, dkey) < 0)
+	return NULL;
 
-            if (match == 2) {
-                dest = i;
-                break;
-            }
-        }
+    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
@@ -1662,7 +1715,8 @@ const struct game thegame = {
     new_ui,
     free_ui,
     game_changed_state,
-    make_move,
+    interpret_move,
+    execute_move,
     game_size,
     game_colours,
     game_new_drawstate,