1 files changed, 92 insertions, 92 deletions

diff --git a/apps/plugins/puzzles/src/flood.c b/apps/plugins/puzzles/src/flood.c
index 74214a50b6..fe809745db 100644
--- a/apps/plugins/puzzles/src/flood.c
+++ b/apps/plugins/puzzles/src/flood.c
@@ -31,7 +31,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"
 
@@ -140,13 +145,13 @@ static void decode_params(game_params *ret, char const *string)
         if (*string == 'c') {
             string++;
             ret->colours = atoi(string);
-            while (string[1] && isdigit((unsigned char)string[1])) string++;
+            while (*string && isdigit((unsigned char)*string)) string++;
         } else if (*string == 'm') {
             string++;
             ret->leniency = atoi(string);
-            while (string[1] && isdigit((unsigned char)string[1])) string++;
-        }
-        string++;
+            while (*string && isdigit((unsigned char)*string)) string++;
+        } else
+            string++;
     }
 }
 
@@ -210,7 +215,9 @@ static const char *validate_params(const game_params *params, bool full)
     if (params->w * params->h < 2)
         return "Grid must contain at least two squares";
     if (params->w < 1 || params->h < 1)
-        return "Width and height must both be at least one";
+        return "Width and height must be at least one";
+    if (params->w > INT_MAX / params->h)
+        return "Width times height must not be unreasonably large";
     if (params->colours < 3 || params->colours > 10)
         return "Must have between 3 and 10 colours";
     if (params->leniency < 0)
@@ -554,8 +561,10 @@ static char *new_game_desc(const game_params *params, random_state *rs,
     /*
      * Invent a random grid.
      */
-    for (i = 0; i < wh; i++)
-        scratch->grid[i] = random_upto(rs, params->colours);
+    do {
+        for (i = 0; i < wh; i++)
+            scratch->grid[i] = random_upto(rs, params->colours);
+    } while (completed(w, h, scratch->grid));
 
     /*
      * Run the solver, and count how many moves it uses.
@@ -770,7 +779,7 @@ struct game_ui {
 static game_ui *new_ui(const game_state *state)
 {
     struct game_ui *ui = snew(struct game_ui);
-    ui->cursor_visible = false;
+    ui->cursor_visible = getenv_bool("PUZZLES_SHOW_CURSOR", false);
     ui->cx = FILLX;
     ui->cy = FILLY;
     return ui;
@@ -781,18 +790,21 @@ 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)
 {
 }
 
-static void game_changed_state(game_ui *ui, const game_state *oldstate,
-                               const game_state *newstate)
+static const char *current_key_label(const game_ui *ui,
+                                     const game_state *state, int button)
 {
+    if (button == CURSOR_SELECT &&
+        state->grid[0] != state->grid[ui->cy*state->w+ui->cx])
+        return "Fill";
+    if (button == CURSOR_SELECT2 &&
+        state->soln && state->solnpos < state->soln->nmoves)
+        return "Advance";
+    return "";
 }
 
 struct game_drawstate {
@@ -818,35 +830,26 @@ static char *interpret_move(const game_state *state, game_ui *ui,
 {
     int w = state->w, h = state->h;
     int tx = -1, ty = -1, move = -1;
+    char *nullret = MOVE_NO_EFFECT;
 
     if (button == LEFT_BUTTON) {
         tx = FROMCOORD(x);
         ty = FROMCOORD(y);
-        ui->cursor_visible = false;
-    } else if (button == CURSOR_LEFT && ui->cx > 0) {
-        ui->cx--;
-        ui->cursor_visible = true;
-        return UI_UPDATE;
-    } else if (button == CURSOR_RIGHT && ui->cx+1 < w) {
-        ui->cx++;
-        ui->cursor_visible = true;
-        return UI_UPDATE;
-    } else if (button == CURSOR_UP && ui->cy > 0) {
-        ui->cy--;
-        ui->cursor_visible = true;
-        return UI_UPDATE;
-    } else if (button == CURSOR_DOWN && ui->cy+1 < h) {
-        ui->cy++;
-        ui->cursor_visible = true;
-        return UI_UPDATE;
+        if (ui->cursor_visible) {
+            ui->cursor_visible = false;
+            nullret = MOVE_UI_UPDATE;
+        }
+    } else if (IS_CURSOR_MOVE(button)) {
+        return move_cursor(button, &ui->cx, &ui->cy, w, h, false,
+                           &ui->cursor_visible);
     } else if (button == CURSOR_SELECT) {
         tx = ui->cx;
         ty = ui->cy;
-    } else if (button == CURSOR_SELECT2 &&
-               state->soln && state->solnpos < state->soln->nmoves) {
-        move = state->soln->moves[state->solnpos];
+    } else if (button == CURSOR_SELECT2) {
+        if (state->soln && state->solnpos < state->soln->nmoves)
+            move = state->soln->moves[state->solnpos];
     } else {
-        return NULL;
+        return MOVE_UNUSED;
     }
 
     if (tx >= 0 && tx < w && ty >= 0 && ty < h &&
@@ -859,7 +862,7 @@ static char *interpret_move(const game_state *state, game_ui *ui,
         return dupstr(buf);
     }
 
-    return NULL;
+    return nullret;
 }
 
 static game_state *execute_move(const game_state *state, const char *move)
@@ -869,7 +872,8 @@ static game_state *execute_move(const game_state *state, const char *move)
 
     if (move[0] == 'M' &&
         sscanf(move+1, "%d", &c) == 1 &&
-        c >= 0 &&
+        c >= 0 && c < state->colours &&
+        c != state->grid[FILLY * state->w + FILLX] &&
         !state->complete) {
         int *queue = snewn(state->w * state->h, int);
         ret = dup_game(state);
@@ -920,11 +924,23 @@ static game_state *execute_move(const game_state *state, const char *move)
 
         sol->moves = snewn(sol->nmoves, char);
         for (i = 0, p = move; i < sol->nmoves; i++) {
-            assert(*p);
+            if (!*p) {
+              badsolve:
+                sfree(sol->moves);
+                sfree(sol);
+                return NULL;
+            };
             sol->moves[i] = atoi(p);
+            if (sol->moves[i] < 0 || sol->moves[i] >= state->colours ||
+                (i == 0 ?
+                 sol->moves[i] == state->grid[FILLY * state->w + FILLX] :
+                 sol->moves[i] == sol->moves[i-1]))
+                /* Solution contains a fill with an invalid colour or
+                 * the current colour. */
+                goto badsolve;
             p += strspn(p, "0123456789");
             if (*p) {
-                assert(*p == ',');
+                if (*p != ',') goto badsolve;
                 p++;
             }
         }
@@ -949,7 +965,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;
@@ -1076,31 +1092,33 @@ static void draw_tile(drawing *dr, game_drawstate *ds,
         colour += COL_1;
     draw_rect(dr, tx, ty, TILESIZE, TILESIZE, colour);
 
-    if (tile & BORDER_L)
-        draw_rect(dr, tx, ty,
-                  SEP_WIDTH, TILESIZE, COL_SEPARATOR);
-    if (tile & BORDER_R)
-        draw_rect(dr, tx + TILESIZE - SEP_WIDTH, ty,
-                  SEP_WIDTH, TILESIZE, COL_SEPARATOR);
-    if (tile & BORDER_U)
-        draw_rect(dr, tx, ty,
-                  TILESIZE, SEP_WIDTH, COL_SEPARATOR);
-    if (tile & BORDER_D)
-        draw_rect(dr, tx, ty + TILESIZE - SEP_WIDTH,
-                  TILESIZE, SEP_WIDTH, COL_SEPARATOR);
-
-    if (tile & CORNER_UL)
-        draw_rect(dr, tx, ty,
-                  SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
-    if (tile & CORNER_UR)
-        draw_rect(dr, tx + TILESIZE - SEP_WIDTH, ty,
-                  SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
-    if (tile & CORNER_DL)
-        draw_rect(dr, tx, ty + TILESIZE - SEP_WIDTH,
-                  SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
-    if (tile & CORNER_DR)
-        draw_rect(dr, tx + TILESIZE - SEP_WIDTH, ty + TILESIZE - SEP_WIDTH,
-                  SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
+    if (SEP_WIDTH > 0) {
+        if (tile & BORDER_L)
+            draw_rect(dr, tx, ty,
+                      SEP_WIDTH, TILESIZE, COL_SEPARATOR);
+        if (tile & BORDER_R)
+            draw_rect(dr, tx + TILESIZE - SEP_WIDTH, ty,
+                      SEP_WIDTH, TILESIZE, COL_SEPARATOR);
+        if (tile & BORDER_U)
+            draw_rect(dr, tx, ty,
+                      TILESIZE, SEP_WIDTH, COL_SEPARATOR);
+        if (tile & BORDER_D)
+            draw_rect(dr, tx, ty + TILESIZE - SEP_WIDTH,
+                      TILESIZE, SEP_WIDTH, COL_SEPARATOR);
+
+        if (tile & CORNER_UL)
+            draw_rect(dr, tx, ty,
+                      SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
+        if (tile & CORNER_UR)
+            draw_rect(dr, tx + TILESIZE - SEP_WIDTH, ty,
+                      SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
+        if (tile & CORNER_DL)
+            draw_rect(dr, tx, ty + TILESIZE - SEP_WIDTH,
+                      SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
+        if (tile & CORNER_DR)
+            draw_rect(dr, tx + TILESIZE - SEP_WIDTH, ty + TILESIZE - SEP_WIDTH,
+                      SEP_WIDTH, SEP_WIDTH, COL_SEPARATOR);
+    }
 
     if (tile & CURSOR)
         draw_rect_outline(dr, tx + CURSOR_INSET, ty + CURSOR_INSET,
@@ -1130,13 +1148,6 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
     if (!ds->started) {
         int coords[10];
 
-        draw_rect(dr, 0, 0,
-                  TILESIZE * w + 2 * BORDER,
-                  TILESIZE * h + 2 * BORDER, COL_BACKGROUND);
-        draw_update(dr, 0, 0,
-                    TILESIZE * w + 2 * BORDER,
-                    TILESIZE * h + 2 * BORDER);
-
         /*
          * Recessed area containing the whole puzzle.
          */
@@ -1326,19 +1337,6 @@ static float game_flash_length(const game_state *oldstate,
     return 0.0F;
 }
 
-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 flood
 #endif
@@ -1360,12 +1358,14 @@ const struct game thegame = {
     free_game,
     true, solve_game,
     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_TILESIZE, game_compute_size, game_set_size,
@@ -1377,8 +1377,8 @@ 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 */
     true,                              /* wants_statusbar */
-    false, game_timing_state,
+    false, NULL,                       /* timing_state */
     0,                                 /* flags */
 };