Stop the analysis pass in Loopy's redraw routine from being

[sgt/puzzles] / guess.c

diff --git a/guess.c b/guess.c
index 9117e8e..15cf0d9 100644 (file)
--- a/guess.c
+++ b/guess.c
@@ -43,7 +43,7 @@ struct game_state {
     pegrow solution;
     int next_go; /* from 0 to nguesses-1;
                     if next_go == nguesses then they've lost. */
-    int solved;
+    int solved;   /* +1 = win, -1 = lose, 0 = still playing */
 };
 
 static game_params *default_params(void)
@@ -632,7 +632,7 @@ static char *encode_move(game_state *from, game_ui *ui)
     return buf;
 }
 
-static char *interpret_move(game_state *from, game_ui *ui, game_drawstate *ds,
+static char *interpret_move(game_state *from, game_ui *ui, const game_drawstate *ds,
                            int x, int y, int button)
 {
     int over_col = 0;           /* one-indexed */
@@ -655,20 +655,24 @@ static char *interpret_move(game_state *from, game_ui *ui, game_drawstate *ds,
 
     if (from->solved) return NULL;
 
-    if (x >= COL_OX && x <= (COL_OX + COL_W) &&
-        y >= COL_OY && y <= (COL_OY + COL_H)) {
+    if (x >= COL_OX && x < (COL_OX + COL_W) &&
+        y >= COL_OY && y < (COL_OY + COL_H)) {
         over_col = ((y - COL_OY) / PEGOFF) + 1;
+        assert(over_col >= 1 && over_col <= ds->colours->npegs);
     } else if (x >= guess_ox &&
-               y >= guess_oy && y <= (guess_oy + GUESS_H)) {
-        if (x <= (guess_ox + GUESS_W)) {
+               y >= guess_oy && y < (guess_oy + GUESS_H)) {
+        if (x < (guess_ox + GUESS_W)) {
             over_guess = (x - guess_ox) / PEGOFF;
+            assert(over_guess >= 0 && over_guess < ds->solution->npegs);
         } else {
             over_hint = 1;
         }
-    } else if (x >= guess_ox && x <= (guess_ox + GUESS_W) &&
+    } else if (x >= guess_ox && x < (guess_ox + GUESS_W) &&
                y >= GUESS_OY && y < guess_oy) {
         over_past_guess_y = (y - GUESS_OY) / PEGOFF;
         over_past_guess_x = (x - guess_ox) / PEGOFF;
+        assert(over_past_guess_y >= 0 && over_past_guess_y < from->next_go);
+        assert(over_past_guess_x >= 0 && over_past_guess_x < ds->solution->npegs);
     }
     debug(("make_move: over_col %d, over_guess %d, over_hint %d,"
            " over_past_guess (%d,%d)", over_col, over_guess, over_hint,
@@ -758,8 +762,7 @@ static char *interpret_move(game_state *from, game_ui *ui, game_drawstate *ds,
         if (button == CURSOR_LEFT && ui->peg_cur > 0)
             ui->peg_cur--;
         ret = "";
-    } else if (button == CURSOR_SELECT || button == ' ' || button == '\r' ||
-               button == '\n') {
+    } else if (IS_CURSOR_SELECT(button)) {
         ui->display_cur = 1;
         if (ui->peg_cur == from->params.npegs) {
             ret = encode_move(from, ui);
@@ -787,7 +790,7 @@ static game_state *execute_move(game_state *from, char *move)
 
     if (!strcmp(move, "S")) {
        ret = dup_game(from);
-       ret->solved = 1;
+       ret->solved = -1;
        return ret;
     } else if (move[0] == 'G') {
        p = move+1;
@@ -814,11 +817,11 @@ static game_state *execute_move(game_state *from, char *move)
        nc_place = mark_pegs(ret->guesses[from->next_go], ret->solution, ret->params.ncolours);
 
        if (nc_place == ret->solution->npegs) {
-           ret->solved = 1; /* win! */
+           ret->solved = +1; /* win! */
        } else {
            ret->next_go = from->next_go + 1;
            if (ret->next_go >= ret->params.nguesses)
-               ret->solved = 1; /* 'lose' so we show the pegs. */
+               ret->solved = -1; /* lose, meaning we show the pegs. */
        }
 
        return ret;
@@ -894,7 +897,7 @@ static void game_set_size(drawing *dr, game_drawstate *ds,
 
     assert(ds->pegsz > 0);
     assert(!ds->blit_peg);             /* set_size is never called twice */
-    ds->blit_peg = blitter_new(dr, ds->pegsz, ds->pegsz);
+    ds->blit_peg = blitter_new(dr, ds->pegsz+2, ds->pegsz+2);
 }
 
 static float *game_colours(frontend *fe, int *ncolours)
@@ -993,9 +996,9 @@ static float *game_colours(frontend *fe, int *ncolours)
 
     /* We also want to be able to tell the difference between BACKGROUND
      * and EMPTY, for similar distinguishing-hint reasons. */
-    ret[COL_EMPTY * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 2.0 / 3.0;
-    ret[COL_EMPTY * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 2.0 / 3.0;
-    ret[COL_EMPTY * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 2.0 / 3.0;
+    ret[COL_EMPTY * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 2.0F / 3.0F;
+    ret[COL_EMPTY * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 2.0F / 3.0F;
+    ret[COL_EMPTY * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 2.0F / 3.0F;
 
     *ncolours = NCOLOURS;
     return ret;
@@ -1207,10 +1210,9 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
                        game_state *state, int dir, game_ui *ui,
                        float animtime, float flashtime)
 {
-    int i, new_move, last_go;
+    int i, new_move;
 
     new_move = (state->next_go != ds->next_go) || !ds->started;
-    last_go = (state->next_go == state->params.nguesses-1);
 
     if (!ds->started) {
       draw_rect(dr, 0, 0, ds->w, ds->h, COL_BACKGROUND);
@@ -1271,7 +1273,7 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
         currmove_redraw(dr, ds, state->next_go, COL_HOLD);
 
     /* draw the solution (or the big rectangle) */
-    if ((state->solved != ds->solved) || !ds->started) {
+    if ((!state->solved ^ !ds->solved) || !ds->started) {
         draw_rect(dr, SOLN_OX, SOLN_OY, SOLN_W, SOLN_H,
                   state->solved ? COL_BACKGROUND : COL_EMPTY);
         draw_update(dr, SOLN_OX, SOLN_OY, SOLN_W, SOLN_H);
@@ -1288,11 +1290,10 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
     if (ui->drag_col != 0) {
         int ox = ui->drag_x - (PEGSZ/2);
         int oy = ui->drag_y - (PEGSZ/2);
-        debug(("Saving to blitter at (%d,%d)", ox, oy));
-        blitter_save(dr, ds->blit_peg, ox, oy);
+        ds->blit_ox = ox - 1; ds->blit_oy = oy - 1;
+        debug(("Saving to blitter at (%d,%d)", ds->blit_ox, ds->blit_oy));
+        blitter_save(dr, ds->blit_peg, ds->blit_ox, ds->blit_oy);
         draw_peg(dr, ds, ox, oy, TRUE, ui->show_labels, ui->drag_col);
-
-        ds->blit_ox = ox; ds->blit_oy = oy;
     }
     ds->drag_col = ui->drag_col;
 
@@ -1311,6 +1312,17 @@ static float game_flash_length(game_state *oldstate, game_state *newstate,
     return 0.0F;
 }
 
+static int game_status(game_state *state)
+{
+    /*
+     * We return nonzero whenever the solution has been revealed, even
+     * (on spoiler grounds) if it wasn't guessed correctly. The
+     * correct return value from this function is already in
+     * state->solved.
+     */
+    return state->solved;
+}
+
 static int game_timing_state(game_state *state, game_ui *ui)
 {
     return TRUE;
@@ -1359,6 +1371,7 @@ const struct game thegame = {
     game_redraw,
     game_anim_length,
     game_flash_length,
+    game_status,
     FALSE, FALSE, game_print_size, game_print,
     FALSE,                            /* wants_statusbar */
     FALSE, game_timing_state,