X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/f0ee053c2a4a214a0e77b22462d0c42806d0462b..11aeddcc37ecb38c8cfb5e2ca78c2ee8819bf9f3:/netslide.c diff --git a/netslide.c b/netslide.c index 6bac447..fe77794 100644 --- a/netslide.c +++ b/netslide.c @@ -13,8 +13,6 @@ #include "puzzles.h" #include "tree234.h" -#define PI 3.141592653589793238462643383279502884197169399 - #define MATMUL(xr,yr,m,x,y) do { \ float rx, ry, xx = (x), yy = (y), *mat = (m); \ rx = mat[0] * xx + mat[2] * yy; \ @@ -54,7 +52,8 @@ #define COUNT(x) ( (((x) & 0x08) >> 3) + (((x) & 0x04) >> 2) + \ (((x) & 0x02) >> 1) + ((x) & 0x01) ) -#define TILE_SIZE 48 +#define PREFERRED_TILE_SIZE 48 +#define TILE_SIZE (ds->tilesize) #define BORDER TILE_SIZE #define TILE_BORDER 1 #define WINDOW_OFFSET 0 @@ -80,17 +79,13 @@ struct game_params { int height; int wrapping; float barrier_probability; -}; - -struct game_aux_info { - int width, height; - unsigned char *tiles; + int movetarget; }; struct game_state { int width, height, cx, cy, wrapping, completed; int used_solve, just_used_solve; - int move_count; + int move_count, movetarget; /* position (row or col number, starting at 0) of last move. */ int last_move_row, last_move_col; @@ -130,7 +125,7 @@ static int xyd_cmp(void *av, void *bv) { if (a->direction > b->direction) return +1; return 0; -}; +} static struct xyd *new_xyd(int x, int y, int direction) { @@ -157,37 +152,40 @@ static game_params *default_params(void) ret->height = 3; ret->wrapping = FALSE; ret->barrier_probability = 1.0; + ret->movetarget = 0; return ret; } +static const struct { int x, y, wrap, bprob; const char* desc; } +netslide_presets[] = { + {3, 3, FALSE, 1.0, " easy"}, + {3, 3, FALSE, 0.0, " medium"}, + {3, 3, TRUE, 0.0, " hard"}, + {4, 4, FALSE, 1.0, " easy"}, + {4, 4, FALSE, 0.0, " medium"}, + {4, 4, TRUE, 0.0, " hard"}, + {5, 5, FALSE, 1.0, " easy"}, + {5, 5, FALSE, 0.0, " medium"}, + {5, 5, TRUE, 0.0, " hard"}, +}; + static int game_fetch_preset(int i, char **name, game_params **params) { game_params *ret; char str[80]; - static const struct { int x, y, wrap, bprob; const char* desc; } values[] = { - {3, 3, FALSE, 1.0, " easy"}, - {3, 3, FALSE, 0.0, " medium"}, - {3, 3, TRUE, 0.0, " hard"}, - {4, 4, FALSE, 1.0, " easy"}, - {4, 4, FALSE, 0.0, " medium"}, - {4, 4, TRUE, 0.0, " hard"}, - {5, 5, FALSE, 1.0, " easy"}, - {5, 5, FALSE, 0.0, " medium"}, - {5, 5, TRUE, 0.0, " hard"}, - }; - - if (i < 0 || i >= lenof(values)) + + if (i < 0 || i >= lenof(netslide_presets)) return FALSE; ret = snew(game_params); - ret->width = values[i].x; - ret->height = values[i].y; - ret->wrapping = values[i].wrap; - ret->barrier_probability = values[i].bprob; + ret->width = netslide_presets[i].x; + ret->height = netslide_presets[i].y; + ret->wrapping = netslide_presets[i].wrap; + ret->barrier_probability = netslide_presets[i].bprob; + ret->movetarget = 0; - sprintf(str, "%dx%d%s", ret->width, ret->height, - values[i].desc); + sprintf(str, "%dx%d%s", ret->width, ret->height, netslide_presets[i].desc); *name = dupstr(str); *params = ret; @@ -212,6 +210,7 @@ static void decode_params(game_params *ret, char const *string) ret->wrapping = FALSE; ret->barrier_probability = 0.0; + ret->movetarget = 0; ret->width = atoi(p); while (*p && isdigit(*p)) p++; @@ -221,8 +220,13 @@ static void decode_params(game_params *ret, char const *string) while (*p && isdigit(*p)) p++; if ( (ret->wrapping = (*p == 'w')) != 0 ) p++; - if (*p == 'b') - ret->barrier_probability = atof(p+1); + if (*p == 'b') { + ret->barrier_probability = atof(++p); + while (*p && (isdigit(*p) || *p == '.')) p++; + } + if (*p == 'm') { + ret->movetarget = atoi(++p); + } } else { ret->height = ret->width; } @@ -238,6 +242,10 @@ static char *encode_params(game_params *params, int full) ret[len++] = 'w'; if (full && params->barrier_probability) len += sprintf(ret+len, "b%g", params->barrier_probability); + /* Shuffle limit is part of the limited parameters, because we have to + * provide the target move count. */ + if (params->movetarget) + len += sprintf(ret+len, "m%d", params->movetarget); assert(len < lenof(ret)); ret[len] = '\0'; @@ -249,7 +257,7 @@ static config_item *game_configure(game_params *params) config_item *ret; char buf[80]; - ret = snewn(5, config_item); + ret = snewn(6, config_item); ret[0].name = "Width"; ret[0].type = C_STRING; @@ -274,11 +282,17 @@ static config_item *game_configure(game_params *params) ret[3].sval = dupstr(buf); ret[3].ival = 0; - ret[4].name = NULL; - ret[4].type = C_END; - ret[4].sval = NULL; + ret[4].name = "Number of shuffling moves"; + ret[4].type = C_STRING; + sprintf(buf, "%d", params->movetarget); + ret[4].sval = dupstr(buf); ret[4].ival = 0; + ret[5].name = NULL; + ret[5].type = C_END; + ret[5].sval = NULL; + ret[5].ival = 0; + return ret; } @@ -290,18 +304,15 @@ static game_params *custom_params(config_item *cfg) ret->height = atoi(cfg[1].sval); ret->wrapping = cfg[2].ival; ret->barrier_probability = (float)atof(cfg[3].sval); + ret->movetarget = atoi(cfg[4].sval); return ret; } static char *validate_params(game_params *params) { - if (params->width <= 1 && params->height <= 1) + if (params->width <= 1 || params->height <= 1) return "Width and height must both be greater than one"; - if (params->width <= 1) - return "Width must be greater than one"; - if (params->height <= 1) - return "Height must be greater than one"; if (params->barrier_probability < 0) return "Barrier probability may not be negative"; if (params->barrier_probability > 1) @@ -314,7 +325,7 @@ static char *validate_params(game_params *params) */ static char *new_game_desc(game_params *params, random_state *rs, - game_aux_info **aux) + char **aux, int interactive) { tree234 *possibilities, *barriertree; int w, h, x, y, cx, cy, nbarriers; @@ -402,7 +413,7 @@ static char *new_game_desc(game_params *params, random_state *rs, OFFSET(x2, y2, x1, y1, d1, params); d2 = F(d1); -#ifdef DEBUG +#ifdef GENERATION_DIAGNOSTICS printf("picked (%d,%d,%c) <-> (%d,%d,%c)\n", x1, y1, "0RU3L567D9abcdef"[d1], x2, y2, "0RU3L567D9abcdef"[d2]); #endif @@ -429,7 +440,7 @@ static char *new_game_desc(game_params *params, random_state *rs, xydp = find234(possibilities, &xyd1, NULL); if (xydp) { -#ifdef DEBUG +#ifdef GENERATION_DIAGNOSTICS printf("T-piece; removing (%d,%d,%c)\n", xydp->x, xydp->y, "0RU3L567D9abcdef"[xydp->direction]); #endif @@ -456,7 +467,7 @@ static char *new_game_desc(game_params *params, random_state *rs, xydp = find234(possibilities, &xyd1, NULL); if (xydp) { -#ifdef DEBUG +#ifdef GENERATION_DIAGNOSTICS printf("Loop avoidance; removing (%d,%d,%c)\n", xydp->x, xydp->y, "0RU3L567D9abcdef"[xydp->direction]); #endif @@ -491,7 +502,7 @@ static char *new_game_desc(game_params *params, random_state *rs, if (index(params, tiles, x3, y3)) continue; /* this would create a loop */ -#ifdef DEBUG +#ifdef GENERATION_DIAGNOSTICS printf("New frontier; adding (%d,%d,%c)\n", x2, y2, "0RU3L567D9abcdef"[d]); #endif @@ -519,26 +530,33 @@ static char *new_game_desc(game_params *params, random_state *rs, } /* - * Save the unshuffled grid. We do this using a separate - * reference-counted structure since it's a large chunk of - * memory which we don't want to have to replicate in every - * game state while playing. + * Save the unshuffled grid in aux. */ { - game_aux_info *solution; + char *solution; + int i; - solution = snew(game_aux_info); - solution->width = w; - solution->height = h; - solution->tiles = snewn(w * h, unsigned char); - memcpy(solution->tiles, tiles, w * h); + /* + * String format is exactly the same as a solve move, so we + * can just dupstr this in solve_game(). + */ + + solution = snewn(w * h + 2, char); + solution[0] = 'S'; + for (i = 0; i < w * h; i++) + solution[i+1] = "0123456789abcdef"[tiles[i] & 0xF]; + solution[w*h+1] = '\0'; *aux = solution; } /* * Now shuffle the grid. - * FIXME - this simply does a set of random moves to shuffle the pieces. + * FIXME - this simply does a set of random moves to shuffle the pieces, + * although we make a token effort to avoid boring cases by avoiding moves + * that directly undo the previous one, or that repeat so often as to + * turn into fewer moves. + * * A better way would be to number all the pieces, generate a placement * for all the numbers as for "sixteen", observing parity constraints if * neccessary, and then place the pieces according to their numbering. @@ -549,18 +567,43 @@ static char *new_game_desc(game_params *params, random_state *rs, int i; int cols = w - 1; int rows = h - 1; - for (i = 0; i < cols * rows * 2; i++) { + int moves = params->movetarget; + int prevdir = -1, prevrowcol = -1, nrepeats = 0; + if (!moves) moves = cols * rows * 2; + for (i = 0; i < moves; /* incremented conditionally */) { /* Choose a direction: 0,1,2,3 = up, right, down, left. */ int dir = random_upto(rs, 4); + int rowcol; if (dir % 2 == 0) { int col = random_upto(rs, cols); - if (col >= cx) col += 1; + if (col >= cx) col += 1; /* avoid centre */ + if (col == prevrowcol) { + if (dir == 2-prevdir) + continue; /* undoes last move */ + else if (dir == prevdir && (nrepeats+1)*2 > h) + continue; /* makes fewer moves */ + } slide_col_int(w, h, tiles, 1 - dir, col); + rowcol = col; } else { int row = random_upto(rs, rows); - if (row >= cy) row += 1; + if (row >= cy) row += 1; /* avoid centre */ + if (row == prevrowcol) { + if (dir == 4-prevdir) + continue; /* undoes last move */ + else if (dir == prevdir && (nrepeats+1)*2 > w) + continue; /* makes fewer moves */ + } slide_row_int(w, h, tiles, 2 - dir, row); + rowcol = row; } + if (dir == prevdir && rowcol == prevrowcol) + nrepeats++; + else + nrepeats = 1; + prevdir = dir; + prevrowcol = rowcol; + i++; /* if we got here, the move was accepted */ } } @@ -653,12 +696,6 @@ static char *new_game_desc(game_params *params, random_state *rs, return desc; } -static void game_free_aux_info(game_aux_info *aux) -{ - sfree(aux->tiles); - sfree(aux); -} - static char *validate_desc(game_params *params, char *desc) { int w = params->width, h = params->height; @@ -689,7 +726,7 @@ static char *validate_desc(game_params *params, char *desc) * Construct an initial game state, given a description and parameters. */ -static game_state *new_game(game_params *params, char *desc) +static game_state *new_game(midend_data *me, game_params *params, char *desc) { game_state *state; int w, h, x, y; @@ -706,6 +743,7 @@ static game_state *new_game(game_params *params, char *desc) state->cx = state->width / 2; state->cy = state->height / 2; state->wrapping = params->wrapping; + state->movetarget = params->movetarget; state->completed = 0; state->used_solve = state->just_used_solve = FALSE; state->move_count = 0; @@ -824,6 +862,7 @@ static game_state *dup_game(game_state *state) ret->cx = state->cx; ret->cy = state->cy; ret->wrapping = state->wrapping; + ret->movetarget = state->movetarget; ret->completed = state->completed; ret->used_solve = state->used_solve; ret->just_used_solve = state->just_used_solve; @@ -846,24 +885,15 @@ static void free_game(game_state *state) 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, + char *aux, char **error) { - game_state *ret; - if (!aux) { *error = "Solution not known for this puzzle"; return NULL; } - assert(aux->width == state->width); - assert(aux->height == state->height); - ret = dup_game(state); - memcpy(ret->tiles, aux->tiles, ret->width * ret->height); - ret->used_solve = ret->just_used_solve = TRUE; - ret->completed = ret->move_count = 1; - - return ret; + return dupstr(aux); } static char *game_text_format(game_state *state) @@ -957,6 +987,15 @@ static void free_ui(game_ui *ui) sfree(ui); } +static char *encode_ui(game_ui *ui) +{ + return NULL; +} + +static void decode_ui(game_ui *ui, char *encoding) +{ +} + /* ---------------------------------------------------------------------- * Process a move. */ @@ -999,12 +1038,24 @@ static void slide_col(game_state *state, int dir, int col) slide_col_int(state->width, state->height, state->tiles, dir, col); } -static game_state *make_move(game_state *state, game_ui *ui, - int x, int y, int button) +static void game_changed_state(game_ui *ui, game_state *oldstate, + game_state *newstate) +{ +} + +struct game_drawstate { + int started; + int width, height; + int tilesize; + unsigned char *visible; +}; + +static char *interpret_move(game_state *state, game_ui *ui, + game_drawstate *ds, int x, int y, int button) { int cx, cy; int n, dx, dy; - game_state *ret; + char buf[80]; button &= ~MOD_MASK; @@ -1040,16 +1091,59 @@ static game_state *make_move(game_state *state, game_ui *ui, dy = -dy; } - ret = dup_game(state); + if (dx == 0) + sprintf(buf, "C%d,%d", cx, dy); + else + sprintf(buf, "R%d,%d", cy, dx); + return dupstr(buf); +} + +static game_state *execute_move(game_state *from, char *move) +{ + game_state *ret; + int c, d, col; + + if ((move[0] == 'C' || move[0] == 'R') && + sscanf(move+1, "%d,%d", &c, &d) == 2 && + c >= 0 && c < (move[0] == 'C' ? from->width : from->height)) { + col = (move[0] == 'C'); + } else if (move[0] == 'S' && + strlen(move) == from->width * from->height + 1) { + int i; + ret = dup_game(from); + ret->used_solve = ret->just_used_solve = TRUE; + ret->completed = ret->move_count = 1; + + for (i = 0; i < from->width * from->height; i++) { + c = move[i+1]; + if (c >= '0' && c <= '9') + c -= '0'; + else if (c >= 'A' && c <= 'F') + c -= 'A' - 10; + else if (c >= 'a' && c <= 'f') + c -= 'a' - 10; + else { + free_game(ret); + return NULL; + } + ret->tiles[i] = c; + } + return ret; + } else + return NULL; /* can't parse move string */ + + ret = dup_game(from); ret->just_used_solve = FALSE; - if (dx == 0) slide_col(ret, dy, cx); - else slide_row(ret, dx, cy); + if (col) + slide_col(ret, d, c); + else + slide_row(ret, d, c); ret->move_count++; - ret->last_move_row = dx ? cy : -1; - ret->last_move_col = dx ? -1 : cx; - ret->last_move_dir = dx + dy; + ret->last_move_row = col ? -1 : c; + ret->last_move_col = col ? c : -1; + ret->last_move_dir = d; /* * See if the game has been completed. @@ -1080,12 +1174,6 @@ static game_state *make_move(game_state *state, game_ui *ui, * Routines for drawing the game position on the screen. */ -struct game_drawstate { - int started; - int width, height; - unsigned char *visible; -}; - static game_drawstate *game_new_drawstate(game_state *state) { game_drawstate *ds = snew(game_drawstate); @@ -1094,6 +1182,7 @@ static game_drawstate *game_new_drawstate(game_state *state) ds->width = state->width; ds->height = state->height; ds->visible = snewn(state->width * state->height, unsigned char); + ds->tilesize = 0; /* not decided yet */ memset(ds->visible, 0xFF, state->width * state->height); return ds; @@ -1105,8 +1194,25 @@ static void game_free_drawstate(game_drawstate *ds) sfree(ds); } -static void game_size(game_params *params, int *x, int *y) +static void game_size(game_params *params, game_drawstate *ds, int *x, int *y, + int expand) { + int tsx, tsy, ts; + /* + * Each window dimension equals the tile size times two more + * than the grid dimension (the border containing the arrows is + * the same width as the tiles), plus TILE_BORDER, plus twice + * WINDOW_OFFSET. + */ + tsx = (*x - 2*WINDOW_OFFSET - TILE_BORDER) / (params->width + 2); + tsy = (*y - 2*WINDOW_OFFSET - TILE_BORDER) / (params->height + 2); + ts = min(tsx, tsy); + + if (expand) + ds->tilesize = ts; + else + ds->tilesize = min(ts, PREFERRED_TILE_SIZE); + *x = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->width + TILE_BORDER; *y = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->height + TILE_BORDER; } @@ -1197,7 +1303,8 @@ static void draw_rect_coords(frontend *fe, int x1, int y1, int x2, int y2, draw_rect(fe, mx, my, dx, dy, colour); } -static void draw_barrier_corner(frontend *fe, int x, int y, int dir, int phase) +static void draw_barrier_corner(frontend *fe, game_drawstate *ds, + int x, int y, int dir, int phase) { int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x; int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y; @@ -1225,7 +1332,8 @@ static void draw_barrier_corner(frontend *fe, int x, int y, int dir, int phase) } } -static void draw_barrier(frontend *fe, int x, int y, int dir, int phase) +static void draw_barrier(frontend *fe, game_drawstate *ds, + int x, int y, int dir, int phase) { int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x; int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y; @@ -1243,8 +1351,8 @@ static void draw_barrier(frontend *fe, int x, int y, int dir, int phase) } } -static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, - float xshift, float yshift) +static void draw_tile(frontend *fe, game_drawstate *ds, game_state *state, + int x, int y, int tile, float xshift, float yshift) { int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x + (xshift * TILE_SIZE); int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y + (yshift * TILE_SIZE); @@ -1328,8 +1436,7 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, points[i+1] = by+(int)(cy+ey); } - draw_polygon(fe, points, 4, TRUE, col); - draw_polygon(fe, points, 4, FALSE, COL_WIRE); + draw_polygon(fe, points, 4, col, COL_WIRE); } /* @@ -1382,7 +1489,8 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, draw_update(fe, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER); } -static void draw_tile_barriers(frontend *fe, game_state *state, int x, int y) +static void draw_tile_barriers(frontend *fe, game_drawstate *ds, + game_state *state, int x, int y) { int phase; int dir; @@ -1394,16 +1502,17 @@ static void draw_tile_barriers(frontend *fe, game_state *state, int x, int y) for (phase = 0; phase < 2; phase++) { for (dir = 1; dir < 0x10; dir <<= 1) if (barrier(state, x, y) & (dir << 4)) - draw_barrier_corner(fe, x, y, dir << 4, phase); + draw_barrier_corner(fe, ds, x, y, dir << 4, phase); for (dir = 1; dir < 0x10; dir <<= 1) if (barrier(state, x, y) & dir) - draw_barrier(fe, x, y, dir, phase); + draw_barrier(fe, ds, x, y, dir, phase); } draw_update(fe, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER); } -static void draw_arrow(frontend *fe, int x, int y, int xdx, int xdy) +static void draw_arrow(frontend *fe, game_drawstate *ds, + int x, int y, int xdx, int xdy) { int coords[14]; int ydy = -xdx, ydx = xdy; @@ -1423,8 +1532,7 @@ static void draw_arrow(frontend *fe, int x, int y, int xdx, int xdy) POINT(5, 3 * TILE_SIZE / 8, TILE_SIZE / 2); /* left concave */ POINT(6, TILE_SIZE / 4, TILE_SIZE / 2); /* left corner */ - draw_polygon(fe, coords, 7, TRUE, COL_LOWLIGHT); - draw_polygon(fe, coords, 7, FALSE, COL_TEXT); + draw_polygon(fe, coords, 7, COL_LOWLIGHT, COL_TEXT); } static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, @@ -1456,32 +1564,32 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, for (x = 0; x < ds->width; x++) { if (barrier(state, x, 0) & UL) - draw_barrier_corner(fe, x, -1, LD, phase); + draw_barrier_corner(fe, ds, x, -1, LD, phase); if (barrier(state, x, 0) & RU) - draw_barrier_corner(fe, x, -1, DR, phase); + draw_barrier_corner(fe, ds, x, -1, DR, phase); if (barrier(state, x, 0) & U) - draw_barrier(fe, x, -1, D, phase); + draw_barrier(fe, ds, x, -1, D, phase); if (barrier(state, x, ds->height-1) & DR) - draw_barrier_corner(fe, x, ds->height, RU, phase); + draw_barrier_corner(fe, ds, x, ds->height, RU, phase); if (barrier(state, x, ds->height-1) & LD) - draw_barrier_corner(fe, x, ds->height, UL, phase); + draw_barrier_corner(fe, ds, x, ds->height, UL, phase); if (barrier(state, x, ds->height-1) & D) - draw_barrier(fe, x, ds->height, U, phase); + draw_barrier(fe, ds, x, ds->height, U, phase); } for (y = 0; y < ds->height; y++) { if (barrier(state, 0, y) & UL) - draw_barrier_corner(fe, -1, y, RU, phase); + draw_barrier_corner(fe, ds, -1, y, RU, phase); if (barrier(state, 0, y) & LD) - draw_barrier_corner(fe, -1, y, DR, phase); + draw_barrier_corner(fe, ds, -1, y, DR, phase); if (barrier(state, 0, y) & L) - draw_barrier(fe, -1, y, R, phase); + draw_barrier(fe, ds, -1, y, R, phase); if (barrier(state, ds->width-1, y) & RU) - draw_barrier_corner(fe, ds->width, y, UL, phase); + draw_barrier_corner(fe, ds, ds->width, y, UL, phase); if (barrier(state, ds->width-1, y) & DR) - draw_barrier_corner(fe, ds->width, y, LD, phase); + draw_barrier_corner(fe, ds, ds->width, y, LD, phase); if (barrier(state, ds->width-1, y) & R) - draw_barrier(fe, ds->width, y, L, phase); + draw_barrier(fe, ds, ds->width, y, L, phase); } } @@ -1490,13 +1598,13 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, */ for (x = 0; x < ds->width; x++) { if (x == state->cx) continue; - draw_arrow(fe, x, 0, +1, 0); - draw_arrow(fe, x+1, ds->height, -1, 0); + draw_arrow(fe, ds, x, 0, +1, 0); + draw_arrow(fe, ds, x+1, ds->height, -1, 0); } for (y = 0; y < ds->height; y++) { if (y == state->cy) continue; - draw_arrow(fe, ds->width, y, 0, +1); - draw_arrow(fe, 0, y+1, 0, -1); + draw_arrow(fe, ds, ds->width, y, 0, +1); + draw_arrow(fe, ds, 0, y+1, 0, -1); } } @@ -1576,15 +1684,15 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, float xs = (y == state->last_move_row ? xshift : 0.0); float ys = (x == state->last_move_col ? yshift : 0.0); - draw_tile(fe, state, x, y, c, xs, ys); + draw_tile(fe, ds, state, x, y, c, xs, ys); if (xs < 0 && x == 0) - draw_tile(fe, state, state->width, y, c, xs, ys); + draw_tile(fe, ds, state, state->width, y, c, xs, ys); else if (xs > 0 && x == state->width - 1) - draw_tile(fe, state, -1, y, c, xs, ys); + draw_tile(fe, ds, state, -1, y, c, xs, ys); else if (ys < 0 && y == 0) - draw_tile(fe, state, x, state->height, c, xs, ys); + draw_tile(fe, ds, state, x, state->height, c, xs, ys); else if (ys > 0 && y == state->height - 1) - draw_tile(fe, state, x, -1, c, xs, ys); + draw_tile(fe, ds, state, x, -1, c, xs, ys); if (x == state->last_move_col || y == state->last_move_row) index(state, ds->visible, x, y) = 0xFF; @@ -1595,7 +1703,7 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, for (x = 0; x < ds->width; x++) for (y = 0; y < ds->height; y++) - draw_tile_barriers(fe, state, x, y); + draw_tile_barriers(fe, ds, state, x, y); unclip(fe); @@ -1619,6 +1727,10 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, (state->completed ? "COMPLETED! " : ""), (state->completed ? state->completed : state->move_count)); + if (state->movetarget) + sprintf(statusbuf + strlen(statusbuf), " (target %d)", + state->movetarget); + sprintf(statusbuf + strlen(statusbuf), " Active: %d/%d", a, n); status_bar(fe, statusbuf); @@ -1628,7 +1740,7 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, } static float game_anim_length(game_state *oldstate, - game_state *newstate, int dir) + game_state *newstate, int dir, game_ui *ui) { /* * Don't animate an auto-solve move. @@ -1641,7 +1753,7 @@ static float game_anim_length(game_state *oldstate, } static float game_flash_length(game_state *oldstate, - game_state *newstate, int dir) + game_state *newstate, int dir, game_ui *ui) { /* * If the game has just been completed, we display a completion @@ -1670,6 +1782,11 @@ static int game_wants_statusbar(void) return TRUE; } +static int game_timing_state(game_state *state) +{ + return FALSE; +} + #ifdef COMBINED #define thegame netslide #endif @@ -1685,7 +1802,6 @@ const struct game thegame = { TRUE, game_configure, custom_params, validate_params, new_game_desc, - game_free_aux_info, validate_desc, new_game, dup_game, @@ -1694,7 +1810,11 @@ const struct game thegame = { FALSE, game_text_format, new_ui, free_ui, - make_move, + encode_ui, + decode_ui, + game_changed_state, + interpret_move, + execute_move, game_size, game_colours, game_new_drawstate, @@ -1703,4 +1823,6 @@ const struct game thegame = { game_anim_length, game_flash_length, game_wants_statusbar, + FALSE, game_timing_state, + 0, /* mouse_priorities */ };