1 files changed, 103 insertions, 69 deletions

diff --git a/apps/plugins/puzzles/src/pegs.c b/apps/plugins/puzzles/src/pegs.c
index ec12aa9552..c770bf3076 100644
--- a/apps/plugins/puzzles/src/pegs.c
+++ b/apps/plugins/puzzles/src/pegs.c
@@ -7,7 +7,12 @@
 #include <string.h>
 #include <assert.h>
 #include <ctype.h>
-#include <math.h>
+#include <limits.h>
+#ifdef NO_TGMATH_H
+#  include <math.h>
+#else
+#  include <tgmath.h>
+#endif
 
 #include "puzzles.h"
 #include "tree234.h"
@@ -70,7 +75,11 @@ static game_params *default_params(void)
 }
 
 static const struct game_params pegs_presets[] = {
+    {5, 7, TYPE_CROSS},
     {7, 7, TYPE_CROSS},
+    {5, 9, TYPE_CROSS},
+    {7, 9, TYPE_CROSS},
+    {9, 9, TYPE_CROSS},
     {7, 7, TYPE_OCTAGON},
     {5, 5, TYPE_RANDOM},
     {7, 7, TYPE_RANDOM},
@@ -89,7 +98,7 @@ static bool game_fetch_preset(int i, char **name, game_params **params)
     *ret = pegs_presets[i];
 
     strcpy(str, pegs_titletypes[ret->type]);
-    if (ret->type == TYPE_RANDOM)
+    if (ret->type == TYPE_CROSS || ret->type == TYPE_RANDOM)
         sprintf(str + strlen(str), " %dx%d", ret->w, ret->h);
 
     *name = dupstr(str);
@@ -182,14 +191,38 @@ static const char *validate_params(const game_params *params, bool full)
 {
     if (full && (params->w <= 3 || params->h <= 3))
         return "Width and height must both be greater than three";
+    if (params->w < 1 || params->h < 1)
+        return "Width and height must both be at least one";
+    if (params->w > INT_MAX / params->h)
+        return "Width times height must not be unreasonably large";
+
+    /*
+     * At http://www.gibell.net/pegsolitaire/GenCross/GenCrossBoards0.html
+     * George I. Bell asserts that various generalised cross-shaped
+     * boards are soluble starting (and finishing) with the centre
+     * hole.  We permit the symmetric ones.  Bell's notation for each
+     * soluble board is listed.
+     */
+    if (full && params->type == TYPE_CROSS) {
+        if (!((params->w == 9 && params->h == 5) || /* (3,1,3,1) */
+              (params->w == 5 && params->h == 9) || /* (1,3,1,3) */
+              (params->w == 9 && params->h == 9) || /* (3,3,3,3) */
+              (params->w == 7 && params->h == 5) || /* (2,1,2,1) */
+              (params->w == 5 && params->h == 7) || /* (1,2,1,2) */
+              (params->w == 9 && params->h == 7) || /* (3,2,3,2) */
+              (params->w == 7 && params->h == 9) || /* (2,3,2,3) */
+              (params->w == 7 && params->h == 7)))  /* (2,2,2,2) */
+            return "This board type is only supported at "
+                "5x7, 5x9, 7x7, 7x9, and 9x9";
+    }
 
     /*
-     * It might be possible to implement generalisations of Cross
-     * and Octagon, but only if I can find a proof that they're all
+     * It might be possible to implement generalisations of
+     * Octagon, but only if I can find a proof that they're all
      * soluble. For the moment, therefore, I'm going to disallow
-     * them at any size other than the standard one.
+     * it at any size other than the standard one.
      */
-    if (full && (params->type == TYPE_CROSS || params->type == TYPE_OCTAGON)) {
+    if (full && params->type == TYPE_OCTAGON) {
         if (params->w != 7 || params->h != 7)
             return "This board type is only supported at 7x7";
     }
@@ -658,12 +691,23 @@ static char *new_game_desc(const game_params *params, random_state *rs,
 
 static const char *validate_desc(const game_params *params, const char *desc)
 {
-    int len = params->w * params->h;
+    int len, i, npeg = 0, nhole = 0;
+
+    len = params->w * params->h;
 
     if (len != strlen(desc))
         return "Game description is wrong length";
     if (len != strspn(desc, "PHO"))
         return "Invalid character in game description";
+    for (i = 0; i < len; i++) {
+        npeg += desc[i] == 'P';
+        nhole += desc[i] == 'H';
+    }
+    /* The minimal soluble game has two pegs and a hole: "3x1:PPH". */
+    if (npeg < 2)
+        return "Too few pegs in game description";
+    if (nhole < 1)
+        return "Too few holes in game description";
 
     return NULL;
 }
@@ -706,12 +750,6 @@ static void free_game(game_state *state)
     sfree(state);
 }
 
-static char *solve_game(const game_state *state, const game_state *currstate,
-                        const char *aux, const char **error)
-{
-    return NULL;
-}
-
 static bool game_can_format_as_text_now(const game_params *params)
 {
     return true;
@@ -751,7 +789,7 @@ static game_ui *new_ui(const game_state *state)
 
     ui->sx = ui->sy = ui->dx = ui->dy = 0;
     ui->dragging = false;
-    ui->cur_visible = false;
+    ui->cur_visible = getenv_bool("PUZZLES_SHOW_CURSOR", false);
     ui->cur_jumping = false;
 
     /* make sure we start the cursor somewhere on the grid. */
@@ -775,15 +813,6 @@ static void free_ui(game_ui *ui)
     sfree(ui);
 }
 
-static char *encode_ui(const game_ui *ui)
-{
-    return NULL;
-}
-
-static void decode_ui(game_ui *ui, const char *encoding)
-{
-}
-
 static void game_changed_state(game_ui *ui, const game_state *oldstate,
                                const game_state *newstate)
 {
@@ -800,6 +829,19 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
     ui->cur_jumping = false;
 }
 
+static const char *current_key_label(const game_ui *ui,
+                                     const game_state *state, int button)
+{
+    int w = state->w;
+
+    if (IS_CURSOR_SELECT(button)) {
+        if (!ui->cur_visible) return "";
+        if (ui->cur_jumping) return "Cancel";
+        if (state->grid[ui->cur_y*w+ui->cur_x] == GRID_PEG) return "Select";
+    }
+    return "";
+}
+
 #define PREFERRED_TILE_SIZE 33
 #define TILESIZE (ds->tilesize)
 #define BORDER (TILESIZE / 2)
@@ -845,16 +887,23 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 
         tx = FROMCOORD(x);
         ty = FROMCOORD(y);
-        if (tx >= 0 && tx < w && ty >= 0 && ty < h &&
-            state->grid[ty*w+tx] == GRID_PEG) {
-            ui->dragging = true;
-            ui->sx = tx;
-            ui->sy = ty;
-            ui->dx = x;
-            ui->dy = y;
-            ui->cur_visible = false;
-            ui->cur_jumping = false;
-            return UI_UPDATE;
+        if (tx >= 0 && tx < w && ty >= 0 && ty < h) {
+            switch (state->grid[ty*w+tx]) {
+            case GRID_PEG:
+                ui->dragging = true;
+                ui->sx = tx;
+                ui->sy = ty;
+                ui->dx = x;
+                ui->dy = y;
+                ui->cur_visible = false;
+                ui->cur_jumping = false;
+                return MOVE_UI_UPDATE;
+            case GRID_HOLE:
+                return MOVE_NO_EFFECT;
+            case GRID_OBST:
+            default:
+                return MOVE_UNUSED;
+            }
         }
     } else if (button == LEFT_DRAG && ui->dragging) {
         /*
@@ -862,7 +911,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
          */
         ui->dx = x;
         ui->dy = y;
-        return UI_UPDATE;
+        return MOVE_UI_UPDATE;
     } else if (button == LEFT_RELEASE && ui->dragging) {
         int tx, ty, dx, dy;
 
@@ -874,18 +923,18 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         tx = FROMCOORD(x);
         ty = FROMCOORD(y);
         if (tx < 0 || tx >= w || ty < 0 || ty >= h)
-            return UI_UPDATE;          /* target out of range */
+            return MOVE_UI_UPDATE;             /* target out of range */
         dx = tx - ui->sx;
         dy = ty - ui->sy;
         if (max(abs(dx),abs(dy)) != 2 || min(abs(dx),abs(dy)) != 0)
-            return UI_UPDATE;          /* move length was wrong */
+            return MOVE_UI_UPDATE;             /* move length was wrong */
         dx /= 2;
         dy /= 2;
 
         if (state->grid[ty*w+tx] != GRID_HOLE ||
             state->grid[(ty-dy)*w+(tx-dx)] != GRID_PEG ||
             state->grid[ui->sy*w+ui->sx] != GRID_PEG)
-            return UI_UPDATE;          /* grid contents were invalid */
+            return MOVE_UI_UPDATE;             /* grid contents were invalid */
 
         /*
          * We have a valid move. Encode it simply as source and
@@ -898,14 +947,14 @@ static char *interpret_move(const game_state *state, game_ui *ui,
             /* Not jumping; move cursor as usual, making sure we don't
              * leave the gameboard (which may be an irregular shape) */
             int cx = ui->cur_x, cy = ui->cur_y;
-            move_cursor(button, &cx, &cy, w, h, false);
+            move_cursor(button, &cx, &cy, w, h, false, NULL);
             ui->cur_visible = true;
             if (state->grid[cy*w+cx] == GRID_HOLE ||
                 state->grid[cy*w+cx] == GRID_PEG) {
                 ui->cur_x = cx;
                 ui->cur_y = cy;
             }
-            return UI_UPDATE;
+            return MOVE_UI_UPDATE;
         } else {
             int dx, dy, mx, my, jx, jy;
 
@@ -928,26 +977,26 @@ static char *interpret_move(const game_state *state, game_ui *ui,
                 ui->cur_x = jx; ui->cur_y = jy;
                 return dupstr(buf);
             }
-            return UI_UPDATE;
+            return MOVE_UI_UPDATE;
         }
     } else if (IS_CURSOR_SELECT(button)) {
         if (!ui->cur_visible) {
             ui->cur_visible = true;
-            return UI_UPDATE;
+            return MOVE_UI_UPDATE;
         }
         if (ui->cur_jumping) {
             ui->cur_jumping = false;
-            return UI_UPDATE;
+            return MOVE_UI_UPDATE;
         }
         if (state->grid[ui->cur_y*w+ui->cur_x] == GRID_PEG) {
-            /* cursor is on peg: next arrow-move wil jump. */
+            /* cursor is on peg: next arrow-move will jump. */
             ui->cur_jumping = true;
-            return UI_UPDATE;
+            return MOVE_UI_UPDATE;
         }
-        return NULL;
+        return MOVE_NO_EFFECT;
     }
 
-    return NULL;
+    return MOVE_UNUSED;
 }
 
 static game_state *execute_move(const game_state *state, const char *move)
@@ -1006,7 +1055,7 @@ static game_state *execute_move(const game_state *state, const char *move)
  */
 
 static void game_compute_size(const game_params *params, int tilesize,
-                              int *x, int *y)
+                              const game_ui *ui, int *x, int *y)
 {
     /* Ick: fake up `ds->tilesize' for macro expansion purposes */
     struct { int tilesize; } ads, *ds = &ads;
@@ -1135,10 +1184,6 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     }
 
     if (!ds->started) {
-        draw_rect(dr, 0, 0,
-                  TILESIZE * state->w + 2 * BORDER,
-                  TILESIZE * state->h + 2 * BORDER, COL_BACKGROUND);
-
         /*
          * Draw relief marks around all the squares that aren't
          * GRID_OBST.
@@ -1302,19 +1347,6 @@ static int game_status(const game_state *state)
     return state->completed ? +1 : 0;
 }
 
-static bool game_timing_state(const game_state *state, game_ui *ui)
-{
-    return true;
-}
-
-static void game_print_size(const game_params *params, float *x, float *y)
-{
-}
-
-static void game_print(drawing *dr, const game_state *state, int tilesize)
-{
-}
-
 #ifdef COMBINED
 #define thegame pegs
 #endif
@@ -1334,14 +1366,16 @@ const struct game thegame = {
     new_game,
     dup_game,
     free_game,
-    false, solve_game,
+    false, NULL, /* solve */
     true, game_can_format_as_text_now, game_text_format,
+    NULL, NULL, /* get_prefs, set_prefs */
     new_ui,
     free_ui,
-    encode_ui,
-    decode_ui,
+    NULL, /* encode_ui */
+    NULL, /* decode_ui */
     NULL, /* game_request_keys */
     game_changed_state,
+    current_key_label,
     interpret_move,
     execute_move,
     PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
@@ -1353,9 +1387,9 @@ const struct game thegame = {
     game_flash_length,
     game_get_cursor_location,
     game_status,
-    false, false, game_print_size, game_print,
+    false, false, NULL, NULL,          /* print_size, print */
     false,                             /* wants_statusbar */
-    false, game_timing_state,
+    false, NULL,                       /* timing_state */
     0,                                 /* flags */
 };