Annoying special cases for Mines.
[sgt/puzzles] / cube.c
diff --git a/cube.c b/cube.c
index 2bce1bd..4f26df7 100644 (file)
--- 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) )
@@ -300,10 +301,9 @@ static char *encode_params(game_params *params, int full)
 
     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];
 
@@ -979,11 +979,13 @@ static game_state *dup_game(game_state *state)
 
 static void free_game(game_state *state)
 {
+    sfree(state->squares);
+    sfree(state->facecolours);
     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,
+                       game_aux_info *aux, char **error)
 {
     return NULL;
 }
@@ -1002,40 +1004,24 @@ 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 void game_changed_state(game_ui *ui, game_state *oldstate,
+                               game_state *newstate)
 {
-    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;
+}
 
-    button = button & (~MOD_MASK | MOD_NUM_KEYPAD);
+struct game_drawstate {
+    float gridscale;
+    int ox, oy;                        /* pixel position of float origin */
+};
 
-    /*
-     * All moves are made with the cursor keys or numeric keypad.
-     */
-    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
-        return NULL;
+/*
+ * 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
@@ -1043,7 +1029,7 @@ static game_state *make_move(game_state *from, game_ui *ui,
      */
     mask = from->squares[from->current].directions[direction];
     if (mask == 0)
-        return NULL;
+        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];
@@ -1080,11 +1066,154 @@ static game_state *make_move(game_state *from, game_ui *ui,
             }
         }
 
+    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);
+
+    /*
+     * 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 = 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!  */
+        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->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->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->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->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->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
@@ -1165,6 +1294,7 @@ static game_state *make_move(game_state *from, game_ui *ui,
         success = align_poly(poly, &from->squares[ret->current], all_pkey);
 
         if (!success) {
+            sfree(poly);
             angle = -angle;
             poly = transform_poly(from->solid,
                                   from->squares[from->current].flip,
@@ -1288,10 +1418,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;
@@ -1322,11 +1448,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)
@@ -1350,10 +1496,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;
 }
@@ -1364,8 +1508,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);
@@ -1376,8 +1520,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;
@@ -1508,8 +1652,7 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
     }
     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(fe, 0, 0, XSIZE(bb, state->solid), YSIZE(bb, state->solid));
 
     /*
      * Update the status bar.
@@ -1571,7 +1714,9 @@ const struct game thegame = {
     FALSE, game_text_format,
     new_ui,
     free_ui,
-    make_move,
+    game_changed_state,
+    interpret_move,
+    execute_move,
     game_size,
     game_colours,
     game_new_drawstate,
@@ -1581,4 +1726,5 @@ const struct game thegame = {
     game_flash_length,
     game_wants_statusbar,
     FALSE, game_timing_state,
+    0,                                /* mouse_priorities */
 };