X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?a=blobdiff_plain;f=unequal.c;h=1c8984a14eceb790543fc8484e42c8b9ce79b0b7;hb=3ce69e84cad15844282d691fa03e711c5353c05e;hp=8c56509d99dd940ba8ce2696e4940f17df0c1a31;hpb=b629e34beb60fcf2e880012e00cca52d0cf2fe39;p=sgt-puzzles.git diff --git a/unequal.c b/unequal.c index 8c56509..1c8984a 100644 --- a/unequal.c +++ b/unequal.c @@ -51,7 +51,7 @@ enum { COL_BACKGROUND, COL_GRID, COL_TEXT, COL_GUESS, COL_ERROR, COL_PENCIL, - COL_HIGHLIGHT, COL_LOWLIGHT, + COL_HIGHLIGHT, COL_LOWLIGHT, COL_SPENT = COL_LOWLIGHT, NCOLOURS }; @@ -72,6 +72,12 @@ struct game_params { #define F_ERROR_RIGHT 128 #define F_ERROR_DOWN 256 #define F_ERROR_LEFT 512 +#define F_SPENT_UP 1024 +#define F_SPENT_RIGHT 2048 +#define F_SPENT_DOWN 4096 +#define F_SPENT_LEFT 8192 + +#define ADJ_TO_SPENT(x) ((x) << 9) #define F_ERROR_MASK (F_ERROR|F_ERROR_UP|F_ERROR_RIGHT|F_ERROR_DOWN|F_ERROR_LEFT) @@ -98,10 +104,9 @@ struct game_state { #define TITLE(upper,title,func,lower) #title, #define ENCODE(upper,title,func,lower) #lower #define CONFIG(upper,title,func,lower) ":" #title -enum { DIFFLIST(ENUM) DIFF_IMPOSSIBLE = diff_impossible, DIFF_AMBIGUOUS = diff_ambiguous, DIFF_UNFINISHED = diff_unfinished }; +enum { DIFFLIST(ENUM) DIFFCOUNT, DIFF_IMPOSSIBLE = diff_impossible, DIFF_AMBIGUOUS = diff_ambiguous, DIFF_UNFINISHED = diff_unfinished }; static char const *const unequal_diffnames[] = { DIFFLIST(TITLE) }; static char const unequal_diffchars[] = DIFFLIST(ENCODE); -#define DIFFCOUNT lenof(unequal_diffchars) #define DIFFCONFIG DIFFLIST(CONFIG) #define DEFAULT_PRESET 0 @@ -157,7 +162,7 @@ static void free_params(game_params *params) sfree(params); } -static game_params *dup_params(game_params *params) +static game_params *dup_params(const game_params *params) { game_params *ret = snew(game_params); *ret = *params; /* structure copy */ @@ -191,7 +196,7 @@ static void decode_params(game_params *ret, char const *string) } } -static char *encode_params(game_params *params, int full) +static char *encode_params(const game_params *params, int full) { char ret[80]; @@ -204,7 +209,7 @@ static char *encode_params(game_params *params, int full) return dupstr(ret); } -static config_item *game_configure(game_params *params) +static config_item *game_configure(const game_params *params) { config_item *ret; char buf[80]; @@ -235,7 +240,7 @@ static config_item *game_configure(game_params *params) return ret; } -static game_params *custom_params(config_item *cfg) +static game_params *custom_params(const config_item *cfg) { game_params *ret = snew(game_params); @@ -246,7 +251,7 @@ static game_params *custom_params(config_item *cfg) return ret; } -static char *validate_params(game_params *params, int full) +static char *validate_params(const game_params *params, int full) { if (params->order < 3 || params->order > 32) return "Order must be between 3 and 32"; @@ -289,7 +294,7 @@ static game_state *blank_game(int order, int adjacent) return state; } -static game_state *dup_game(game_state *state) +static game_state *dup_game(const game_state *state) { game_state *ret = blank_game(state->order, state->adjacent); int o2 = state->order*state->order, o3 = o2*state->order; @@ -447,12 +452,12 @@ static int c2n(int c, int order) { return -1; } -static int game_can_format_as_text_now(game_params *params) +static int game_can_format_as_text_now(const game_params *params) { return TRUE; } -static char *game_text_format(game_state *state) +static char *game_text_format(const game_state *state) { int x, y, len, n; char *ret, *p; @@ -830,7 +835,8 @@ static int solver_state(game_state *state, int maxdiff) return 1; } -static game_state *solver_hint(game_state *state, int *diff_r, int mindiff, int maxdiff) +static game_state *solver_hint(const game_state *state, int *diff_r, + int mindiff, int maxdiff) { game_state *ret = dup_game(state); int diff, r = 0; @@ -952,7 +958,7 @@ static int gg_best_clue(game_state *state, int *scratch, digit *latin) { int ls = state->order * state->order * 5; int maxposs = 0, minclues = 5, best = -1, i, j; - int nposs, nclues, loc, x, y; + int nposs, nclues, loc; #ifdef STANDALONE_SOLVER if (solver_show_working) { @@ -965,7 +971,6 @@ static int gg_best_clue(game_state *state, int *scratch, digit *latin) if (!gg_place_clue(state, scratch[i], latin, 1)) continue; loc = scratch[i] / 5; - x = loc % state->order; y = loc / state->order; for (j = nposs = 0; j < state->order; j++) { if (state->hints[loc*state->order + j]) nposs++; } @@ -976,9 +981,11 @@ static int gg_best_clue(game_state *state, int *scratch, digit *latin) (nposs == maxposs && nclues < minclues)) { best = i; maxposs = nposs; minclues = nclues; #ifdef STANDALONE_SOLVER - if (solver_show_working) + if (solver_show_working) { + int x = loc % state->order, y = loc / state->order; printf("gg_best_clue: b%d (%d,%d) new best [%d poss, %d clues].\n", best, x+1, y+1, nposs, nclues); + } #endif } } @@ -1094,9 +1101,11 @@ static void add_adjacent_flags(game_state *state, digit *latin) } } -static char *new_game_desc(game_params *params, random_state *rs, +static char *new_game_desc(const game_params *params_in, random_state *rs, char **aux, int interactive) { + game_params params_copy = *params_in; /* structure copy */ + game_params *params = ¶ms_copy; digit *sq = NULL; int i, x, y, retlen, k, nsol; int o2 = params->order * params->order, ntries = 1; @@ -1188,11 +1197,11 @@ generate: return ret; } -static game_state *load_game(game_params *params, char *desc, +static game_state *load_game(const game_params *params, const char *desc, char **why_r) { game_state *state = blank_game(params->order, params->adjacent); - char *p = desc; + const char *p = desc; int i = 0, n, o = params->order, x, y; char *why = NULL; @@ -1274,7 +1283,8 @@ fail: return NULL; } -static game_state *new_game(midend *me, game_params *params, char *desc) +static game_state *new_game(midend *me, const game_params *params, + const char *desc) { game_state *state = load_game(params, desc, NULL); if (!state) { @@ -1284,7 +1294,7 @@ static game_state *new_game(midend *me, game_params *params, char *desc) return state; } -static char *validate_desc(game_params *params, char *desc) +static char *validate_desc(const game_params *params, const char *desc) { char *why = NULL; game_state *dummy = load_game(params, desc, &why); @@ -1296,8 +1306,8 @@ static char *validate_desc(game_params *params, char *desc) return why; } -static char *solve_game(game_state *state, game_state *currstate, - char *aux, char **error) +static char *solve_game(const game_state *state, const game_state *currstate, + const char *aux, char **error) { game_state *solved; int r; @@ -1310,7 +1320,7 @@ static char *solve_game(game_state *state, game_state *currstate, if (!(solved->flags[r] & F_IMMUTABLE)) solved->nums[r] = 0; } - r = solver_state(solved, DIFFCOUNT); + r = solver_state(solved, DIFFCOUNT-1); /* always use full solver */ if (r > 0) ret = latin_desc(solved->nums, solved->order); free_game(solved); return ret; @@ -1325,7 +1335,7 @@ struct game_ui { int hshow, hpencil, hcursor; /* show state, type, and ?cursor. */ }; -static game_ui *new_ui(game_state *state) +static game_ui *new_ui(const game_state *state) { game_ui *ui = snew(game_ui); @@ -1340,17 +1350,17 @@ static void free_ui(game_ui *ui) sfree(ui); } -static char *encode_ui(game_ui *ui) +static char *encode_ui(const game_ui *ui) { return NULL; } -static void decode_ui(game_ui *ui, char *encoding) +static void decode_ui(game_ui *ui, const char *encoding) { } -static void game_changed_state(game_ui *ui, game_state *oldstate, - game_state *newstate) +static void game_changed_state(game_ui *ui, const game_state *oldstate, + const game_state *newstate) { /* See solo.c; if we were pencil-mode highlighting and * somehow a square has just been properly filled, cancel @@ -1371,16 +1381,38 @@ struct game_drawstate { int hflash; }; -static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, - int ox, int oy, int button) +static char *interpret_move(const game_state *state, game_ui *ui, + const game_drawstate *ds, + int ox, int oy, int button) { int x = FROMCOORD(ox), y = FROMCOORD(oy), n; char buf[80]; + int shift_or_control = button & (MOD_SHFT | MOD_CTRL); button &= ~MOD_MASK; - if (x >= 0 && x < ds->order && ((ox - COORD(x)) <= TILE_SIZE) && - y >= 0 && y < ds->order && ((oy - COORD(y)) <= TILE_SIZE)) { + if (x >= 0 && x < ds->order && y >= 0 && y < ds->order && IS_MOUSE_DOWN(button)) { + if (oy - COORD(y) > TILE_SIZE && ox - COORD(x) > TILE_SIZE) + return NULL; + + if (oy - COORD(y) > TILE_SIZE) { + if (GRID(state, flags, x, y) & F_ADJ_DOWN) + sprintf(buf, "F%d,%d,%d", x, y, F_SPENT_DOWN); + else if (y + 1 < ds->order && GRID(state, flags, x, y + 1) & F_ADJ_UP) + sprintf(buf, "F%d,%d,%d", x, y + 1, F_SPENT_UP); + else return NULL; + return dupstr(buf); + } + + if (ox - COORD(x) > TILE_SIZE) { + if (GRID(state, flags, x, y) & F_ADJ_RIGHT) + sprintf(buf, "F%d,%d,%d", x, y, F_SPENT_RIGHT); + else if (x + 1 < ds->order && GRID(state, flags, x + 1, y) & F_ADJ_LEFT) + sprintf(buf, "F%d,%d,%d", x + 1, y, F_SPENT_LEFT); + else return NULL; + return dupstr(buf); + } + if (button == LEFT_BUTTON) { /* normal highlighting for non-immutable squares */ if (GRID(state, flags, x, y) & F_IMMUTABLE) @@ -1412,9 +1444,39 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, } if (IS_CURSOR_MOVE(button)) { - move_cursor(button, &ui->hx, &ui->hy, ds->order, ds->order, 0); - ui->hshow = ui->hcursor = 1; - return ""; + if (shift_or_control) { + int nx = ui->hx, ny = ui->hy, i, self; + move_cursor(button, &nx, &ny, ds->order, ds->order, FALSE); + ui->hshow = ui->hcursor = 1; + + for (i = 0; i < 4 && (nx != ui->hx + adjthan[i].dx || + ny != ui->hy + adjthan[i].dy); ++i); + + if (i == 4) + return ""; /* invalid direction, i.e. out of the board */ + + if (!(GRID(state, flags, ui->hx, ui->hy) & adjthan[i].f || + GRID(state, flags, nx, ny ) & adjthan[i].fo)) + return ""; /* no clue to toggle */ + + if (state->adjacent) + self = (adjthan[i].dx >= 0 && adjthan[i].dy >= 0); + else + self = (GRID(state, flags, ui->hx, ui->hy) & adjthan[i].f); + + if (self) + sprintf(buf, "F%d,%d,%d", ui->hx, ui->hy, + ADJ_TO_SPENT(adjthan[i].f)); + else + sprintf(buf, "F%d,%d,%d", nx, ny, + ADJ_TO_SPENT(adjthan[i].fo)); + + return dupstr(buf); + } else { + move_cursor(button, &ui->hx, &ui->hy, ds->order, ds->order, FALSE); + ui->hshow = ui->hcursor = 1; + return ""; + } } if (ui->hshow && IS_CURSOR_SELECT(button)) { ui->hpencil = 1 - ui->hpencil; @@ -1422,18 +1484,15 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, return ""; } - - if (ui->hshow) { + n = c2n(button, state->order); + if (ui->hshow && n >= 0 && n <= ds->order) { debug(("button %d, cbutton %d", button, (int)((char)button))); - n = c2n(button, state->order); debug(("n %d, h (%d,%d) p %d flags 0x%x nums %d", n, ui->hx, ui->hy, ui->hpencil, GRID(state, flags, ui->hx, ui->hy), GRID(state, nums, ui->hx, ui->hy))); - if (n < 0 || n > ds->order) - return NULL; /* out of range */ if (GRID(state, flags, ui->hx, ui->hy) & F_IMMUTABLE) return NULL; /* can't edit immutable square (!) */ if (ui->hpencil && GRID(state, nums, ui->hx, ui->hy) > 0) @@ -1456,7 +1515,7 @@ static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds, return NULL; } -static game_state *execute_move(game_state *state, char *move) +static game_state *execute_move(const game_state *state, const char *move) { game_state *ret = NULL; int x, y, n, i, rc; @@ -1481,7 +1540,7 @@ static game_state *execute_move(game_state *state, char *move) } return ret; } else if (move[0] == 'S') { - char *p; + const char *p; ret = dup_game(state); ret->completed = ret->cheated = TRUE; @@ -1510,6 +1569,11 @@ static game_state *execute_move(game_state *state, char *move) return ret; } else if (move[0] == 'H') { return solver_hint(state, NULL, DIFF_EASY, DIFF_EASY); + } else if (move[0] == 'F' && sscanf(move+1, "%d,%d,%d", &x, &y, &n) == 3 && + x >= 0 && x < state->order && y >= 0 && y < state->order) { + ret = dup_game(state); + GRID(ret, flags, x, y) ^= n; + return ret; } badmove: @@ -1523,8 +1587,8 @@ badmove: #define DRAW_SIZE (TILE_SIZE*ds->order + GAP_SIZE*(ds->order-1) + BORDER*2) -static void game_compute_size(game_params *params, int tilesize, - int *x, int *y) +static void game_compute_size(const game_params *params, int tilesize, + int *x, int *y) { /* Ick: fake up `ds->tilesize' for macro expansion purposes */ struct { int tilesize, order; } ads, *ds = &ads; @@ -1535,7 +1599,7 @@ static void game_compute_size(game_params *params, int tilesize, } static void game_set_size(drawing *dr, game_drawstate *ds, - game_params *params, int tilesize) + const game_params *params, int tilesize) { ds->tilesize = tilesize; } @@ -1569,7 +1633,7 @@ static float *game_colours(frontend *fe, int *ncolours) return ret; } -static game_drawstate *game_new_drawstate(drawing *dr, game_state *state) +static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state) { struct game_drawstate *ds = snew(struct game_drawstate); int o2 = state->order*state->order, o3 = o2*state->order; @@ -1602,41 +1666,57 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds) static void draw_gt(drawing *dr, int ox, int oy, int dx1, int dy1, int dx2, int dy2, int col) { - draw_line(dr, ox, oy, ox+dx1, oy+dy1, col); - draw_line(dr, ox+dx1, oy+dy1, ox+dx1+dx2, oy+dy1+dy2, col); -} + int coords[12]; + int xdx = (dx1+dx2 ? 0 : 1), xdy = (dx1+dx2 ? 1 : 0); + coords[0] = ox + xdx; + coords[1] = oy + xdy; + coords[2] = ox + xdx + dx1; + coords[3] = oy + xdy + dy1; + coords[4] = ox + xdx + dx1 + dx2; + coords[5] = oy + xdy + dy1 + dy2; + coords[6] = ox - xdx + dx1 + dx2; + coords[7] = oy - xdy + dy1 + dy2; + coords[8] = ox - xdx + dx1; + coords[9] = oy - xdy + dy1; + coords[10] = ox - xdx; + coords[11] = oy - xdy; + draw_polygon(dr, coords, 6, col, col); +} + +#define COLOUR(direction) (f & (F_ERROR_##direction) ? COL_ERROR : \ + f & (F_SPENT_##direction) ? COL_SPENT : fg) static void draw_gts(drawing *dr, game_drawstate *ds, int ox, int oy, - unsigned int f, int col) + unsigned int f, int bg, int fg) { int g = GAP_SIZE, g2 = (g+1)/2, g4 = (g+1)/4; /* Draw all the greater-than signs emanating from this tile. */ if (f & F_ADJ_UP) { - draw_gt(dr, ox+g2, oy-g4, g2, -g2, g2, g2, - (f & F_ERROR_UP) ? COL_ERROR : col); + if (bg >= 0) draw_rect(dr, ox, oy - g, TILE_SIZE, g, bg); + draw_gt(dr, ox+g2, oy-g4, g2, -g2, g2, g2, COLOUR(UP)); draw_update(dr, ox, oy-g, TILE_SIZE, g); } if (f & F_ADJ_RIGHT) { - draw_gt(dr, ox+TILE_SIZE+g4, oy+g2, g2, g2, -g2, g2, - (f & F_ERROR_RIGHT) ? COL_ERROR : col); + if (bg >= 0) draw_rect(dr, ox + TILE_SIZE, oy, g, TILE_SIZE, bg); + draw_gt(dr, ox+TILE_SIZE+g4, oy+g2, g2, g2, -g2, g2, COLOUR(RIGHT)); draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE); } if (f & F_ADJ_DOWN) { - draw_gt(dr, ox+g2, oy+TILE_SIZE+g4, g2, g2, g2, -g2, - (f & F_ERROR_DOWN) ? COL_ERROR : col); + if (bg >= 0) draw_rect(dr, ox, oy + TILE_SIZE, TILE_SIZE, g, bg); + draw_gt(dr, ox+g2, oy+TILE_SIZE+g4, g2, g2, g2, -g2, COLOUR(DOWN)); draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g); } if (f & F_ADJ_LEFT) { - draw_gt(dr, ox-g4, oy+g2, -g2, g2, g2, g2, - (f & F_ERROR_LEFT) ? COL_ERROR : col); + if (bg >= 0) draw_rect(dr, ox - g, oy, g, TILE_SIZE, bg); + draw_gt(dr, ox-g4, oy+g2, -g2, g2, g2, g2, COLOUR(LEFT)); draw_update(dr, ox-g, oy, g, TILE_SIZE); } } static void draw_adjs(drawing *dr, game_drawstate *ds, int ox, int oy, - unsigned int f, int col) + unsigned int f, int bg, int fg) { int g = GAP_SIZE, g38 = 3*(g+1)/8, g4 = (g+1)/4; @@ -1649,31 +1729,30 @@ static void draw_adjs(drawing *dr, game_drawstate *ds, int ox, int oy, if (f & (F_ADJ_RIGHT|F_ERROR_RIGHT)) { if (f & F_ADJ_RIGHT) { - draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, - (f & F_ERROR_RIGHT) ? COL_ERROR : col); + draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, COLOUR(RIGHT)); } else { draw_rect_outline(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, COL_ERROR); } - } else { - draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, COL_BACKGROUND); + } else if (bg >= 0) { + draw_rect(dr, ox+TILE_SIZE+g38, oy, g4, TILE_SIZE, bg); } draw_update(dr, ox+TILE_SIZE, oy, g, TILE_SIZE); if (f & (F_ADJ_DOWN|F_ERROR_DOWN)) { if (f & F_ADJ_DOWN) { - draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, - (f & F_ERROR_DOWN) ? COL_ERROR : col); + draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, COLOUR(DOWN)); } else { draw_rect_outline(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, COL_ERROR); } - } else { - draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, COL_BACKGROUND); + } else if (bg >= 0) { + draw_rect(dr, ox, oy+TILE_SIZE+g38, TILE_SIZE, g4, bg); } draw_update(dr, ox, oy+TILE_SIZE, TILE_SIZE, g); } -static void draw_furniture(drawing *dr, game_drawstate *ds, game_state *state, - game_ui *ui, int x, int y, int hflash) +static void draw_furniture(drawing *dr, game_drawstate *ds, + const game_state *state, const game_ui *ui, + int x, int y, int hflash) { int ox = COORD(x), oy = COORD(y), bg, hon; unsigned int f = GRID(state, flags, x, y); @@ -1705,9 +1784,9 @@ static void draw_furniture(drawing *dr, game_drawstate *ds, game_state *state, /* Draw the adjacent clue signs. */ if (ds->adjacent) - draw_adjs(dr, ds, ox, oy, f, COL_GRID); + draw_adjs(dr, ds, ox, oy, f, COL_BACKGROUND, COL_GRID); else - draw_gts(dr, ds, ox, oy, f, COL_TEXT); + draw_gts(dr, ds, ox, oy, f, COL_BACKGROUND, COL_TEXT); } static void draw_num(drawing *dr, game_drawstate *ds, int x, int y) @@ -1763,9 +1842,10 @@ static void draw_hints(drawing *dr, game_drawstate *ds, int x, int y) } } -static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, - game_state *state, int dir, game_ui *ui, - float animtime, float flashtime) +static void game_redraw(drawing *dr, game_drawstate *ds, + const game_state *oldstate, const game_state *state, + int dir, const game_ui *ui, + float animtime, float flashtime) { int x, y, i, hchanged = 0, stale, hflash = 0; @@ -1833,14 +1913,14 @@ static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, ds->hflash = hflash; } -static float game_anim_length(game_state *oldstate, game_state *newstate, - int dir, game_ui *ui) +static float game_anim_length(const game_state *oldstate, + const game_state *newstate, int dir, game_ui *ui) { return 0.0F; } -static float game_flash_length(game_state *oldstate, game_state *newstate, - int dir, game_ui *ui) +static float game_flash_length(const game_state *oldstate, + const game_state *newstate, int dir, game_ui *ui) { if (!oldstate->completed && newstate->completed && !oldstate->cheated && !newstate->cheated) @@ -1848,12 +1928,17 @@ static float game_flash_length(game_state *oldstate, game_state *newstate, return 0.0F; } -static int game_timing_state(game_state *state, game_ui *ui) +static int game_status(const game_state *state) +{ + return state->completed ? +1 : 0; +} + +static int game_timing_state(const game_state *state, game_ui *ui) { return TRUE; } -static void game_print_size(game_params *params, float *x, float *y) +static void game_print_size(const game_params *params, float *x, float *y) { int pw, ph; @@ -1863,7 +1948,7 @@ static void game_print_size(game_params *params, float *x, float *y) *y = ph / 100.0F; } -static void game_print(drawing *dr, game_state *state, int tilesize) +static void game_print(drawing *dr, const game_state *state, int tilesize) { int ink = print_mono_colour(dr, 0); int x, y, o = state->order, ox, oy, n; @@ -1889,10 +1974,10 @@ static void game_print(drawing *dr, game_state *state, int tilesize) FONT_VARIABLE, TILE_SIZE/2, ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str); - if (ds->adjacent) - draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), ink); + if (state->adjacent) + draw_adjs(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink); else - draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), ink); + draw_gts(dr, ds, ox, oy, GRID(state, flags, x, y), -1, ink); } } } @@ -1936,6 +2021,7 @@ const struct game thegame = { game_redraw, game_anim_length, game_flash_length, + game_status, TRUE, FALSE, game_print_size, game_print, FALSE, /* wants_statusbar */ FALSE, game_timing_state,