X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/07dfb697bb30781c963b11eb00c4951bb5db6a7d..11aeddcc37ecb38c8cfb5e2ca78c2ee8819bf9f3:/cube.c

diff --git a/cube.c b/cube.c
index ffefa2f..6a867a4 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.0F
+#define GRID_SCALE (ds->gridscale)
 #define ROLLTIME 0.13F
 
 #define SQ(x) ( (x) * (x) )
@@ -585,7 +586,7 @@ static void classify_grid_square_callback(void *ctx, struct grid_square *sq)
 }
 
 static char *new_game_desc(game_params *params, random_state *rs,
-			   game_aux_info **aux, int interactive)
+			   char **aux, int interactive)
 {
     struct grid_data data;
     int i, j, k, m, area, facesperclass;
@@ -686,11 +687,6 @@ static char *new_game_desc(game_params *params, random_state *rs,
     return desc;
 }
 
-static void game_free_aux_info(game_aux_info *aux)
-{
-    assert(!"Shouldn't happen");
-}
-
 static void add_grid_square_callback(void *ctx, struct grid_square *sq)
 {
     game_state *state = (game_state *)ctx;
@@ -983,8 +979,8 @@ static void free_game(game_state *state)
     sfree(state);
 }
 
-static game_state *solve_game(game_state *state, game_aux_info *aux,
-			      char **error)
+static char *solve_game(game_state *state, game_state *currstate,
+			char *aux, char **error)
 {
     return NULL;
 }
@@ -1003,25 +999,85 @@ static void free_ui(game_ui *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,
                                game_state *newstate)
 {
 }
 
 struct game_drawstate {
+    float gridscale;
     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);
 
@@ -1054,8 +1110,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!  */
@@ -1080,7 +1136,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;
@@ -1090,7 +1146,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;
@@ -1100,7 +1156,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)
@@ -1111,54 +1167,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
@@ -1393,11 +1452,31 @@ static struct bbox find_bbox(game_params *params)
     return bb;
 }
 
-static void game_size(game_params *params, int *x, int *y)
+#define XSIZE(bb, solid) \
+    ((int)(((bb).r - (bb).l + 2*(solid)->border) * GRID_SCALE))
+#define YSIZE(bb, solid) \
+    ((int)(((bb).d - (bb).u + 2*(solid)->border) * GRID_SCALE))
+
+static void game_size(game_params *params, game_drawstate *ds, int *x, int *y,
+                      int expand)
 {
     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);
+    float gsx, gsy, gs;
+
+    gsx = *x / (bb.r - bb.l + 2*solids[params->solid]->border);
+    gsy = *y / (bb.d - bb.u + 2*solids[params->solid]->border);
+    gs = min(gsx, gsy);
+
+    if (expand)
+        ds->gridscale = gs;
+    else
+        ds->gridscale = min(gs, PREFERRED_GRID_SCALE);
+
+    ds->ox = (int)(-(bb.l - solids[params->solid]->border) * GRID_SCALE);
+    ds->oy = (int)(-(bb.u - solids[params->solid]->border) * GRID_SCALE);
+
+    *x = XSIZE(bb, solids[params->solid]);
+    *y = YSIZE(bb, solids[params->solid]);
 }
 
 static float *game_colours(frontend *fe, game_state *state, int *ncolours)
@@ -1421,10 +1500,8 @@ static float *game_colours(frontend *fe, game_state *state, int *ncolours)
 static game_drawstate *game_new_drawstate(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 = ds->gridscale = 0.0F;/* not decided yet */
 
     return ds;
 }
@@ -1435,8 +1512,8 @@ static void game_free_drawstate(game_drawstate *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)
+                        game_state *state, int dir, game_ui *ui,
+                        float animtime, float flashtime)
 {
     int i, j;
     struct bbox bb = find_bbox(&state->params);
@@ -1447,8 +1524,8 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
     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(fe, 0, 0, XSIZE(bb, state->solid), YSIZE(bb, state->solid),
+              COL_BACKGROUND);
 
     if (dir < 0) {
         game_state *t;
@@ -1491,9 +1568,9 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
 			     + 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(fe, coords, state->squares[i].npoints,
+                     state->squares[i].blue ? COL_BLUE : COL_BACKGROUND,
+		     COL_BORDER);
     }
 
     /*
@@ -1573,14 +1650,13 @@ 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(fe, coords, poly->order,
+                     state->facecolours[i] ? COL_BLUE : COL_BACKGROUND,
+		     COL_BORDER);
     }
     sfree(poly);
 
-    game_size(&state->params, &i, &j);
-    draw_update(fe, 0, 0, i, j);
+    draw_update(fe, 0, 0, XSIZE(bb, state->solid), YSIZE(bb, state->solid));
 
     /*
      * Update the status bar.
@@ -1633,7 +1709,6 @@ const struct game thegame = {
     TRUE, game_configure, custom_params,
     validate_params,
     new_game_desc,
-    game_free_aux_info,
     validate_desc,
     new_game,
     dup_game,
@@ -1642,8 +1717,11 @@ const struct game thegame = {
     FALSE, game_text_format,
     new_ui,
     free_ui,
+    encode_ui,
+    decode_ui,
     game_changed_state,
-    make_move,
+    interpret_move,
+    execute_move,
     game_size,
     game_colours,
     game_new_drawstate,