X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/2ac6d24e968232e9040ee0bca5e605b3a75e9c39..HEAD:/netslide.c diff --git a/netslide.c b/netslide.c index f367621..8d18652 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,18 +79,13 @@ struct game_params { int height; int wrapping; float barrier_probability; -}; - -struct solved_game_state { - int width, height; - int refcount; - 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 used_solve; + int move_count, movetarget; /* position (row or col number, starting at 0) of last move. */ int last_move_row, last_move_col; @@ -101,7 +95,6 @@ struct game_state { unsigned char *tiles; unsigned char *barriers; - struct solved_game_state *solution; }; #define OFFSET(x2,y2,x1,y1,dir,state) \ @@ -132,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) { @@ -144,7 +137,9 @@ static struct xyd *new_xyd(int x, int y, int direction) } static void slide_col(game_state *state, int dir, int col); +static void slide_col_int(int w, int h, unsigned char *tiles, int dir, int col); static void slide_row(game_state *state, int dir, int row); +static void slide_row_int(int w, int h, unsigned char *tiles, int dir, int row); /* ---------------------------------------------------------------------- * Manage game parameters. @@ -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, " easy"}, + {3, 3, FALSE, 0, " medium"}, + {3, 3, TRUE, 0, " hard"}, + {4, 4, FALSE, 1, " easy"}, + {4, 4, FALSE, 0, " medium"}, + {4, 4, TRUE, 0, " hard"}, + {5, 5, FALSE, 1, " easy"}, + {5, 5, FALSE, 0, " medium"}, + {5, 5, TRUE, 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 = (float)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; @@ -206,32 +204,35 @@ static game_params *dup_params(game_params *params) return ret; } -static game_params *decode_params(char const *string) +static void decode_params(game_params *ret, char const *string) { - game_params *ret = default_params(); char const *p = string; ret->wrapping = FALSE; ret->barrier_probability = 0.0; + ret->movetarget = 0; ret->width = atoi(p); - while (*p && isdigit(*p)) p++; + while (*p && isdigit((unsigned char)*p)) p++; if (*p == 'x') { p++; ret->height = atoi(p); - while (*p && isdigit(*p)) p++; + while (*p && isdigit((unsigned char)*p)) p++; if ( (ret->wrapping = (*p == 'w')) != 0 ) p++; - if (*p == 'b') - ret->barrier_probability = atof(p+1); + if (*p == 'b') { + ret->barrier_probability = (float)atof(++p); + while (*p && (isdigit((unsigned char)*p) || *p == '.')) p++; + } + if (*p == 'm') { + ret->movetarget = atoi(++p); + } } else { ret->height = ret->width; } - - return ret; } -static char *encode_params(game_params *params) +static char *encode_params(game_params *params, int full) { char ret[400]; int len; @@ -239,8 +240,12 @@ static char *encode_params(game_params *params) len = sprintf(ret, "%dx%d", params->width, params->height); if (params->wrapping) ret[len++] = 'w'; - if (params->barrier_probability) + 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'; @@ -252,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; @@ -277,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; } @@ -293,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) +static char *validate_params(game_params *params, int full) { - 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) @@ -313,94 +321,27 @@ static char *validate_params(game_params *params) } /* ---------------------------------------------------------------------- - * Randomly select a new game seed. + * Randomly select a new game description. */ -static char *new_game_seed(game_params *params, random_state *rs, - game_aux_info **aux) +static char *new_game_desc(game_params *params, random_state *rs, + char **aux, int interactive) { - /* - * The full description of a Net game is far too large to - * encode directly in the seed, so by default we'll have to go - * for the simple approach of providing a random-number seed. - * - * (This does not restrict me from _later on_ inventing a seed - * string syntax which can never be generated by this code - - * for example, strings beginning with a letter - allowing me - * to type in a precise game, and have new_game detect it and - * understand it and do something completely different.) - */ - char buf[40]; - sprintf(buf, "%lu", random_bits(rs, 32)); - return dupstr(buf); -} + tree234 *possibilities, *barriertree; + int w, h, x, y, cx, cy, nbarriers; + unsigned char *tiles, *barriers; + char *desc, *p; -static void game_free_aux_info(game_aux_info *aux) -{ - assert(!"Shouldn't happen"); -} + w = params->width; + h = params->height; -static char *validate_seed(game_params *params, char *seed) -{ - /* - * Since any string at all will suffice to seed the RNG, there - * is no validation required. - */ - return NULL; -} + tiles = snewn(w * h, unsigned char); + memset(tiles, 0, w * h); + barriers = snewn(w * h, unsigned char); + memset(barriers, 0, w * h); -/* ---------------------------------------------------------------------- - * Construct an initial game state, given a seed and parameters. - */ - -static game_state *new_game(game_params *params, char *seed) -{ - random_state *rs; - game_state *state; - tree234 *possibilities, *barriers; - int w, h, x, y, nbarriers; - - assert(params->width > 0 && params->height > 0); - assert(params->width > 1 || params->height > 1); - - /* - * Create a blank game state. - */ - state = snew(game_state); - w = state->width = params->width; - h = state->height = params->height; - state->cx = state->width / 2; - state->cy = state->height / 2; - state->wrapping = params->wrapping; - state->completed = 0; - state->used_solve = state->just_used_solve = FALSE; - state->move_count = 0; - state->last_move_row = -1; - state->last_move_col = -1; - state->last_move_dir = 0; - state->tiles = snewn(state->width * state->height, unsigned char); - memset(state->tiles, 0, state->width * state->height); - state->barriers = snewn(state->width * state->height, unsigned char); - memset(state->barriers, 0, state->width * state->height); - - /* - * Set up border barriers if this is a non-wrapping game. - */ - if (!state->wrapping) { - for (x = 0; x < state->width; x++) { - barrier(state, x, 0) |= U; - barrier(state, x, state->height-1) |= D; - } - for (y = 0; y < state->height; y++) { - barrier(state, 0, y) |= L; - barrier(state, state->width-1, y) |= R; - } - } - - /* - * Seed the internal random number generator. - */ - rs = random_init(seed, strlen(seed)); + cx = w / 2; + cy = h / 2; /* * Construct the unshuffled grid. @@ -446,14 +387,14 @@ static game_state *new_game(game_params *params, char *seed) */ possibilities = newtree234(xyd_cmp); - if (state->cx+1 < state->width) - add234(possibilities, new_xyd(state->cx, state->cy, R)); - if (state->cy-1 >= 0) - add234(possibilities, new_xyd(state->cx, state->cy, U)); - if (state->cx-1 >= 0) - add234(possibilities, new_xyd(state->cx, state->cy, L)); - if (state->cy+1 < state->height) - add234(possibilities, new_xyd(state->cx, state->cy, D)); + if (cx+1 < w) + add234(possibilities, new_xyd(cx, cy, R)); + if (cy-1 >= 0) + add234(possibilities, new_xyd(cx, cy, U)); + if (cx-1 >= 0) + add234(possibilities, new_xyd(cx, cy, L)); + if (cy+1 < h) + add234(possibilities, new_xyd(cx, cy, D)); while (count234(possibilities) > 0) { int i; @@ -470,9 +411,9 @@ static game_state *new_game(game_params *params, char *seed) d1 = xyd->direction; sfree(xyd); - OFFSET(x2, y2, x1, y1, d1, state); + 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 @@ -481,25 +422,25 @@ static game_state *new_game(game_params *params, char *seed) * Make the connection. (We should be moving to an as yet * unused tile.) */ - tile(state, x1, y1) |= d1; - assert(tile(state, x2, y2) == 0); - tile(state, x2, y2) |= d2; + index(params, tiles, x1, y1) |= d1; + assert(index(params, tiles, x2, y2) == 0); + index(params, tiles, x2, y2) |= d2; /* * If we have created a T-piece, remove its last * possibility. */ - if (COUNT(tile(state, x1, y1)) == 3) { + if (COUNT(index(params, tiles, x1, y1)) == 3) { struct xyd xyd1, *xydp; xyd1.x = x1; xyd1.y = y1; - xyd1.direction = 0x0F ^ tile(state, x1, y1); + xyd1.direction = 0x0F ^ index(params, tiles, x1, y1); 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 @@ -516,7 +457,7 @@ static game_state *new_game(game_params *params, char *seed) int x3, y3, d3; struct xyd xyd1, *xydp; - OFFSET(x3, y3, x2, y2, d, state); + OFFSET(x3, y3, x2, y2, d, params); d3 = F(d); xyd1.x = x3; @@ -526,7 +467,7 @@ static game_state *new_game(game_params *params, char *seed) 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 @@ -545,23 +486,23 @@ static game_state *new_game(game_params *params, char *seed) if (d == d2) continue; /* we've got this one already */ - if (!state->wrapping) { + if (!params->wrapping) { if (d == U && y2 == 0) continue; - if (d == D && y2 == state->height-1) + if (d == D && y2 == h-1) continue; if (d == L && x2 == 0) continue; - if (d == R && x2 == state->width-1) + if (d == R && x2 == w-1) continue; } - OFFSET(x3, y3, x2, y2, d, state); + OFFSET(x3, y3, x2, y2, d, params); - if (tile(state, x3, y3)) + 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 @@ -575,41 +516,47 @@ static game_state *new_game(game_params *params, char *seed) /* * Now compute a list of the possible barrier locations. */ - barriers = newtree234(xyd_cmp); - for (y = 0; y < state->height; y++) { - for (x = 0; x < state->width; x++) { - - if (!(tile(state, x, y) & R) && - (state->wrapping || x < state->width-1)) - add234(barriers, new_xyd(x, y, R)); - if (!(tile(state, x, y) & D) && - (state->wrapping || y < state->height-1)) - add234(barriers, new_xyd(x, y, D)); + barriertree = newtree234(xyd_cmp); + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) { + + if (!(index(params, tiles, x, y) & R) && + (params->wrapping || x < w-1)) + add234(barriertree, new_xyd(x, y, R)); + if (!(index(params, tiles, x, y) & D) && + (params->wrapping || y < h-1)) + add234(barriertree, new_xyd(x, y, D)); } } /* - * 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. */ { - struct solved_game_state *solution; + char *solution; + int i; + + /* + * String format is exactly the same as a solve move, so we + * can just dupstr this in solve_game(). + */ - solution = snew(struct solved_game_state); - solution->width = state->width; - solution->height = state->height; - solution->refcount = 1; - solution->tiles = snewn(state->width * state->height, unsigned char); - memcpy(solution->tiles, state->tiles, state->width * state->height); + 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'; - state->solution = solution; + *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. @@ -618,27 +565,52 @@ static game_state *new_game(game_params *params, char *seed) */ { int i; - int cols = state->width - 1; - int rows = state->height - 1; - for (i = 0; i < cols * rows * 2; i++) { + int cols = w - 1; + int rows = h - 1; + 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 >= state->cx) col += 1; - slide_col(state, 1 - dir, col); + 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 >= state->cy) row += 1; - slide_row(state, 2 - dir, row); + 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 */ } } /* * And now choose barrier locations. (We carefully do this * _after_ shuffling, so that changing the barrier rate in the - * params while keeping the game seed the same will give the + * params while keeping the random seed the same will give the * same shuffled grid and _only_ change the barrier locations. * Also the way we choose barrier locations, by repeatedly * choosing one possibility from the list until we have enough, @@ -649,8 +621,8 @@ static game_state *new_game(game_params *params, char *seed) * the original 10 plus 10 more, rather than getting 20 new * ones and the chance of remembering your first 10.) */ - nbarriers = (int)(params->barrier_probability * count234(barriers)); - assert(nbarriers >= 0 && nbarriers <= count234(barriers)); + nbarriers = (int)(params->barrier_probability * count234(barriertree)); + assert(nbarriers >= 0 && nbarriers <= count234(barriertree)); while (nbarriers > 0) { int i; @@ -660,8 +632,8 @@ static game_state *new_game(game_params *params, char *seed) /* * Extract a randomly chosen barrier from the list. */ - i = random_upto(rs, count234(barriers)); - xyd = delpos234(barriers, i); + i = random_upto(rs, count234(barriertree)); + xyd = delpos234(barriertree, i); assert(xyd != NULL); @@ -670,11 +642,11 @@ static game_state *new_game(game_params *params, char *seed) d1 = xyd->direction; sfree(xyd); - OFFSET(x2, y2, x1, y1, d1, state); + OFFSET(x2, y2, x1, y1, d1, params); d2 = F(d1); - barrier(state, x1, y1) |= d1; - barrier(state, x2, y2) |= d2; + index(params, barriers, x1, y1) |= d1; + index(params, barriers, x2, y2) |= d2; nbarriers--; } @@ -685,10 +657,148 @@ static game_state *new_game(game_params *params, char *seed) { struct xyd *xyd; - while ( (xyd = delpos234(barriers, 0)) != NULL) + while ( (xyd = delpos234(barriertree, 0)) != NULL) sfree(xyd); - freetree234(barriers); + freetree234(barriertree); + } + + /* + * Finally, encode the grid into a string game description. + * + * My syntax is extremely simple: each square is encoded as a + * hex digit in which bit 0 means a connection on the right, + * bit 1 means up, bit 2 left and bit 3 down. (i.e. the same + * encoding as used internally). Each digit is followed by + * optional barrier indicators: `v' means a vertical barrier to + * the right of it, and `h' means a horizontal barrier below + * it. + */ + desc = snewn(w * h * 3 + 1, char); + p = desc; + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) { + *p++ = "0123456789abcdef"[index(params, tiles, x, y)]; + if ((params->wrapping || x < w-1) && + (index(params, barriers, x, y) & R)) + *p++ = 'v'; + if ((params->wrapping || y < h-1) && + (index(params, barriers, x, y) & D)) + *p++ = 'h'; + } + } + assert(p - desc <= w*h*3); + *p = '\0'; + + sfree(tiles); + sfree(barriers); + + return desc; +} + +static char *validate_desc(game_params *params, char *desc) +{ + int w = params->width, h = params->height; + int i; + + for (i = 0; i < w*h; i++) { + if (*desc >= '0' && *desc <= '9') + /* OK */; + else if (*desc >= 'a' && *desc <= 'f') + /* OK */; + else if (*desc >= 'A' && *desc <= 'F') + /* OK */; + else if (!*desc) + return "Game description shorter than expected"; + else + return "Game description contained unexpected character"; + desc++; + while (*desc == 'h' || *desc == 'v') + desc++; + } + if (*desc) + return "Game description longer than expected"; + + return NULL; +} + +/* ---------------------------------------------------------------------- + * Construct an initial game state, given a description and parameters. + */ + +static game_state *new_game(midend *me, game_params *params, char *desc) +{ + game_state *state; + int w, h, x, y; + + assert(params->width > 0 && params->height > 0); + assert(params->width > 1 || params->height > 1); + + /* + * Create a blank game state. + */ + state = snew(game_state); + w = state->width = params->width; + h = state->height = params->height; + state->cx = state->width / 2; + state->cy = state->height / 2; + state->wrapping = params->wrapping; + state->movetarget = params->movetarget; + state->completed = 0; + state->used_solve = FALSE; + state->move_count = 0; + state->last_move_row = -1; + state->last_move_col = -1; + state->last_move_dir = 0; + state->tiles = snewn(state->width * state->height, unsigned char); + memset(state->tiles, 0, state->width * state->height); + state->barriers = snewn(state->width * state->height, unsigned char); + memset(state->barriers, 0, state->width * state->height); + + + /* + * Parse the game description into the grid. + */ + for (y = 0; y < h; y++) { + for (x = 0; x < w; x++) { + if (*desc >= '0' && *desc <= '9') + tile(state, x, y) = *desc - '0'; + else if (*desc >= 'a' && *desc <= 'f') + tile(state, x, y) = *desc - 'a' + 10; + else if (*desc >= 'A' && *desc <= 'F') + tile(state, x, y) = *desc - 'A' + 10; + if (*desc) + desc++; + while (*desc == 'h' || *desc == 'v') { + int x2, y2, d1, d2; + if (*desc == 'v') + d1 = R; + else + d1 = D; + + OFFSET(x2, y2, x, y, d1, state); + d2 = F(d1); + + barrier(state, x, y) |= d1; + barrier(state, x2, y2) |= d2; + + desc++; + } + } + } + + /* + * Set up border barriers if this is a non-wrapping game. + */ + if (!state->wrapping) { + for (x = 0; x < state->width; x++) { + barrier(state, x, 0) |= U; + barrier(state, x, state->height-1) |= D; + } + for (y = 0; y < state->height; y++) { + barrier(state, 0, y) |= L; + barrier(state, state->width-1, y) |= R; + } } /* @@ -739,8 +849,6 @@ static game_state *new_game(game_params *params, char *seed) } } - random_free(rs); - return state; } @@ -754,9 +862,9 @@ 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; ret->move_count = state->move_count; ret->last_move_row = state->last_move_row; ret->last_move_col = state->last_move_col; @@ -765,49 +873,31 @@ static game_state *dup_game(game_state *state) memcpy(ret->tiles, state->tiles, state->width * state->height); ret->barriers = snewn(state->width * state->height, unsigned char); memcpy(ret->barriers, state->barriers, state->width * state->height); - ret->solution = state->solution; - if (ret->solution) - ret->solution->refcount++; return ret; } static void free_game(game_state *state) { - if (state->solution && --state->solution->refcount <= 0) { - sfree(state->solution->tiles); - sfree(state->solution); - } sfree(state->tiles); sfree(state->barriers); 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 (!state->solution) { - /* - * 2005-05-02: This shouldn't happen, at the time of - * writing, because Net is incapable of receiving a puzzle - * description from outside. If in future it becomes so, - * then we will have puzzles for which we don't know the - * solution. - */ + if (!aux) { *error = "Solution not known for this puzzle"; return NULL; } - assert(state->solution->width == state->width); - assert(state->solution->height == state->height); - ret = dup_game(state); - memcpy(ret->tiles, state->solution->tiles, ret->width * ret->height); - ret->used_solve = ret->just_used_solve = TRUE; - ret->completed = ret->move_count; + return dupstr(aux); +} - return ret; +static int game_can_format_as_text_now(game_params *params) +{ + return TRUE; } static char *game_text_format(game_state *state) @@ -889,8 +979,8 @@ struct game_ui { static game_ui *new_ui(game_state *state) { game_ui *ui = snew(game_ui); - ui->cur_x = state->width / 2; - ui->cur_y = state->height / 2; + ui->cur_x = 0; + ui->cur_y = -1; ui->cur_visible = FALSE; return ui; @@ -901,57 +991,116 @@ 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. */ -static void slide_row(game_state *state, int dir, int row) +static void slide_row_int(int w, int h, unsigned char *tiles, int dir, int row) { - int x = dir > 0 ? -1 : state->width; + int x = dir > 0 ? -1 : w; int tx = x + dir; - int n = state->width - 1; - unsigned char endtile = state->tiles[T(state, tx, row)]; + int n = w - 1; + unsigned char endtile = tiles[row * w + tx]; do { x = tx; - tx = (x + dir + state->width) % state->width; - state->tiles[T(state, x, row)] = state->tiles[T(state, tx, row)]; + tx = (x + dir + w) % w; + tiles[row * w + x] = tiles[row * w + tx]; } while (--n > 0); - state->tiles[T(state, tx, row)] = endtile; + tiles[row * w + tx] = endtile; } -static void slide_col(game_state *state, int dir, int col) +static void slide_col_int(int w, int h, unsigned char *tiles, int dir, int col) { - int y = dir > 0 ? -1 : state->height; + int y = dir > 0 ? -1 : h; int ty = y + dir; - int n = state->height - 1; - unsigned char endtile = state->tiles[T(state, col, ty)]; + int n = h - 1; + unsigned char endtile = tiles[ty * w + col]; do { y = ty; - ty = (y + dir + state->height) % state->height; - state->tiles[T(state, col, y)] = state->tiles[T(state, col, ty)]; + ty = (y + dir + h) % h; + tiles[y * w + col] = tiles[ty * w + col]; } while (--n > 0); - state->tiles[T(state, col, ty)] = endtile; + tiles[ty * w + col] = endtile; +} + +static void slide_row(game_state *state, int dir, int row) +{ + slide_row_int(state->width, state->height, state->tiles, dir, row); } -static game_state *make_move(game_state *state, game_ui *ui, - int x, int y, int button) +static void slide_col(game_state *state, int dir, int col) +{ + slide_col_int(state->width, state->height, state->tiles, dir, col); +} + +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; + int cur_x, cur_y; +}; + +static char *interpret_move(game_state *state, game_ui *ui, + const game_drawstate *ds, int x, int y, int button) { int cx, cy; - int n, dx, dy; - game_state *ret; + int dx, dy; + char buf[80]; - if (button != LEFT_BUTTON && button != RIGHT_BUTTON) - return NULL; + button &= ~MOD_MASK; - cx = (x - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2; - cy = (y - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2; + if (IS_CURSOR_MOVE(button)) { + int cpos, diff = 0; + cpos = c2pos(state->width, state->height, ui->cur_x, ui->cur_y); + diff = c2diff(state->width, state->height, ui->cur_x, ui->cur_y, button); + + if (diff != 0) { + do { /* we might have to do this more than once to skip missing arrows */ + cpos += diff; + pos2c(state->width, state->height, cpos, &ui->cur_x, &ui->cur_y); + } while (ui->cur_x == state->cx || ui->cur_y == state->cy); + } + + ui->cur_visible = 1; + return ""; + } + + if (button == LEFT_BUTTON || button == RIGHT_BUTTON) { + cx = (x - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2; + cy = (y - (BORDER + WINDOW_OFFSET + TILE_BORDER) + 2*TILE_SIZE) / TILE_SIZE - 2; + ui->cur_visible = 0; + } else if (IS_CURSOR_SELECT(button)) { + if (ui->cur_visible) { + cx = ui->cur_x; + cy = ui->cur_y; + } else { + /* 'click' when cursor is invisible just makes cursor visible. */ + ui->cur_visible = 1; + return ""; + } + } else + return NULL; if (cy >= 0 && cy < state->height && cy != state->cy) { if (cx == -1) dx = +1; else if (cx == state->width) dx = -1; else return NULL; - n = state->width; dy = 0; } else if (cx >= 0 && cx < state->width && cx != state->cx) @@ -959,7 +1108,6 @@ static game_state *make_move(game_state *state, game_ui *ui, if (cy == -1) dy = +1; else if (cy == state->height) dy = -1; else return NULL; - n = state->height; dx = 0; } else @@ -972,16 +1120,58 @@ static game_state *make_move(game_state *state, game_ui *ui, dy = -dy; } - ret = dup_game(state); - ret->just_used_solve = FALSE; + if (dx == 0) + sprintf(buf, "C%d,%d", cx, dy); + else + sprintf(buf, "R%d,%d", cy, dx); + return dupstr(buf); +} - if (dx == 0) slide_col(ret, dy, cx); - else slide_row(ret, dx, cy); +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 = 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); + + 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. @@ -1012,13 +1202,7 @@ 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) +static game_drawstate *game_new_drawstate(drawing *dr, game_state *state) { game_drawstate *ds = snew(game_drawstate); @@ -1026,24 +1210,37 @@ 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); + ds->cur_x = ds->cur_y = -1; return ds; } -static void game_free_drawstate(game_drawstate *ds) +static void game_free_drawstate(drawing *dr, game_drawstate *ds) { sfree(ds->visible); sfree(ds); } -static void game_size(game_params *params, int *x, int *y) +static void game_compute_size(game_params *params, int tilesize, + int *x, int *y) { + /* Ick: fake up `ds->tilesize' for macro expansion purposes */ + struct { int tilesize; } ads, *ds = &ads; + ads.tilesize = tilesize; + *x = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->width + TILE_BORDER; *y = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->height + TILE_BORDER; } -static float *game_colours(frontend *fe, game_state *state, int *ncolours) +static void game_set_size(drawing *dr, game_drawstate *ds, + game_params *params, int tilesize) +{ + ds->tilesize = tilesize; +} + +static float *game_colours(frontend *fe, int *ncolours) { float *ret; @@ -1108,17 +1305,17 @@ static float *game_colours(frontend *fe, game_state *state, int *ncolours) return ret; } -static void draw_thick_line(frontend *fe, int x1, int y1, int x2, int y2, - int colour) +static void draw_filled_line(drawing *dr, int x1, int y1, int x2, int y2, + int colour) { - draw_line(fe, x1-1, y1, x2-1, y2, COL_WIRE); - draw_line(fe, x1+1, y1, x2+1, y2, COL_WIRE); - draw_line(fe, x1, y1-1, x2, y2-1, COL_WIRE); - draw_line(fe, x1, y1+1, x2, y2+1, COL_WIRE); - draw_line(fe, x1, y1, x2, y2, colour); + draw_line(dr, x1-1, y1, x2-1, y2, COL_WIRE); + draw_line(dr, x1+1, y1, x2+1, y2, COL_WIRE); + draw_line(dr, x1, y1-1, x2, y2-1, COL_WIRE); + draw_line(dr, x1, y1+1, x2, y2+1, COL_WIRE); + draw_line(dr, x1, y1, x2, y2, colour); } -static void draw_rect_coords(frontend *fe, int x1, int y1, int x2, int y2, +static void draw_rect_coords(drawing *dr, int x1, int y1, int x2, int y2, int colour) { int mx = (x1 < x2 ? x1 : x2); @@ -1126,10 +1323,11 @@ static void draw_rect_coords(frontend *fe, int x1, int y1, int x2, int y2, int dx = (x2 + x1 - 2*mx + 1); int dy = (y2 + y1 - 2*my + 1); - draw_rect(fe, mx, my, dx, dy, colour); + draw_rect(dr, 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(drawing *dr, 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; @@ -1144,20 +1342,21 @@ static void draw_barrier_corner(frontend *fe, int x, int y, int dir, int phase) y1 = (dy > 0 ? TILE_SIZE+TILE_BORDER-1 : 0); if (phase == 0) { - draw_rect_coords(fe, bx+x1, by+y1, + draw_rect_coords(dr, bx+x1, by+y1, bx+x1-TILE_BORDER*dx, by+y1-(TILE_BORDER-1)*dy, COL_WIRE); - draw_rect_coords(fe, bx+x1, by+y1, + draw_rect_coords(dr, bx+x1, by+y1, bx+x1-(TILE_BORDER-1)*dx, by+y1-TILE_BORDER*dy, COL_WIRE); } else { - draw_rect_coords(fe, bx+x1, by+y1, + draw_rect_coords(dr, bx+x1, by+y1, bx+x1-(TILE_BORDER-1)*dx, by+y1-(TILE_BORDER-1)*dy, COL_BARRIER); } } -static void draw_barrier(frontend *fe, int x, int y, int dir, int phase) +static void draw_barrier(drawing *dr, 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; @@ -1169,17 +1368,17 @@ static void draw_barrier(frontend *fe, int x, int y, int dir, int phase) h = (Y(dir) ? TILE_BORDER : TILE_SIZE - TILE_BORDER); if (phase == 0) { - draw_rect(fe, bx+x1-X(dir), by+y1-Y(dir), w, h, COL_WIRE); + draw_rect(dr, bx+x1-X(dir), by+y1-Y(dir), w, h, COL_WIRE); } else { - draw_rect(fe, bx+x1, by+y1, w, h, COL_BARRIER); + draw_rect(dr, bx+x1, by+y1, w, h, COL_BARRIER); } } -static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, - float xshift, float yshift) +static void draw_tile(drawing *dr, 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); + int bx = BORDER + WINDOW_OFFSET + TILE_SIZE * x + (int)(xshift * TILE_SIZE); + int by = BORDER + WINDOW_OFFSET + TILE_SIZE * y + (int)(yshift * TILE_SIZE); float cx, cy, ex, ey; int dir, col; @@ -1204,9 +1403,9 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, * rectangle in border colour, and a smaller rectangle in * background colour to fill it in. */ - draw_rect(fe, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER, + draw_rect(dr, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER, COL_BORDER); - draw_rect(fe, bx+TILE_BORDER, by+TILE_BORDER, + draw_rect(dr, bx+TILE_BORDER, by+TILE_BORDER, TILE_SIZE-TILE_BORDER, TILE_SIZE-TILE_BORDER, tile & FLASHING ? COL_FLASHING : COL_BACKGROUND); @@ -1219,16 +1418,16 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, if (tile & dir) { ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir); ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir); - draw_thick_line(fe, bx+(int)cx, by+(int)cy, - bx+(int)(cx+ex), by+(int)(cy+ey), - COL_WIRE); + draw_filled_line(dr, bx+(int)cx, by+(int)cy, + bx+(int)(cx+ex), by+(int)(cy+ey), + COL_WIRE); } } for (dir = 1; dir < 0x10; dir <<= 1) { if (tile & dir) { ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir); ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir); - draw_line(fe, bx+(int)cx, by+(int)cy, + draw_line(dr, bx+(int)cx, by+(int)cy, bx+(int)(cx+ex), by+(int)(cy+ey), col); } } @@ -1260,8 +1459,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(dr, points, 4, col, COL_WIRE); } /* @@ -1298,8 +1496,8 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, * in: if we are fully connected to the other tile then * the two ACTIVE states will be the same.) */ - draw_rect_coords(fe, px-vx, py-vy, px+lx+vx, py+ly+vy, COL_WIRE); - draw_rect_coords(fe, px, py, px+lx, py+ly, + draw_rect_coords(dr, px-vx, py-vy, px+lx+vx, py+ly+vy, COL_WIRE); + draw_rect_coords(dr, px, py, px+lx, py+ly, (tile & ACTIVE) ? COL_POWERED : COL_WIRE); } else { /* @@ -1307,14 +1505,15 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, * actually connected to us. Just draw a single black * dot. */ - draw_rect_coords(fe, px, py, px, py, COL_WIRE); + draw_rect_coords(dr, px, py, px, py, COL_WIRE); } } - draw_update(fe, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER); + draw_update(dr, 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(drawing *dr, game_drawstate *ds, + game_state *state, int x, int y) { int phase; int dir; @@ -1326,16 +1525,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(dr, 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(dr, ds, x, y, dir, phase); } - draw_update(fe, bx, by, TILE_SIZE+TILE_BORDER, TILE_SIZE+TILE_BORDER); + draw_update(dr, 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(drawing *dr, game_drawstate *ds, + int x, int y, int xdx, int xdy, int cur) { int coords[14]; int ydy = -xdx, ydx = xdy; @@ -1355,17 +1555,39 @@ 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(dr, coords, 7, cur ? COL_POWERED : COL_LOWLIGHT, COL_TEXT); } -static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, +static void draw_arrow_for_cursor(drawing *dr, game_drawstate *ds, + int cur_x, int cur_y, int cur) +{ + if (cur_x == -1 && cur_y == -1) + return; /* 'no cursur here */ + else if (cur_x == -1) /* LH column. */ + draw_arrow(dr, ds, 0, cur_y+1, 0, -1, cur); + else if (cur_x == ds->width) /* RH column */ + draw_arrow(dr, ds, ds->width, cur_y, 0, +1, cur); + else if (cur_y == -1) /* Top row */ + draw_arrow(dr, ds, cur_x, 0, +1, 0, cur); + else if (cur_y == ds->height) /* Bottom row */ + draw_arrow(dr, ds, cur_x+1, ds->height, -1, 0, cur); + else + assert(!"Invalid cursor position"); + + draw_update(dr, + cur_x * TILE_SIZE + BORDER + WINDOW_OFFSET, + cur_y * TILE_SIZE + BORDER + WINDOW_OFFSET, + TILE_SIZE, TILE_SIZE); +} + +static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate, game_state *state, int dir, game_ui *ui, float t, float ft) { - int x, y, tx, ty, frame; + int x, y, frame; unsigned char *active; float xshift = 0.0; float yshift = 0.0; + int cur_x = -1, cur_y = -1; /* * Clear the screen and draw the exterior barrier lines if this @@ -1376,11 +1598,11 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, ds->started = TRUE; - draw_rect(fe, 0, 0, + draw_rect(dr, 0, 0, BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * state->width + TILE_BORDER, BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * state->height + TILE_BORDER, COL_BACKGROUND); - draw_update(fe, 0, 0, + draw_update(dr, 0, 0, BORDER * 2 + WINDOW_OFFSET*2 + TILE_SIZE*state->width + TILE_BORDER, BORDER * 2 + WINDOW_OFFSET*2 + TILE_SIZE*state->height + TILE_BORDER); @@ -1388,32 +1610,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(dr, ds, x, -1, LD, phase); if (barrier(state, x, 0) & RU) - draw_barrier_corner(fe, x, -1, DR, phase); + draw_barrier_corner(dr, ds, x, -1, DR, phase); if (barrier(state, x, 0) & U) - draw_barrier(fe, x, -1, D, phase); + draw_barrier(dr, 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(dr, 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(dr, ds, x, ds->height, UL, phase); if (barrier(state, x, ds->height-1) & D) - draw_barrier(fe, x, ds->height, U, phase); + draw_barrier(dr, 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(dr, ds, -1, y, RU, phase); if (barrier(state, 0, y) & LD) - draw_barrier_corner(fe, -1, y, DR, phase); + draw_barrier_corner(dr, ds, -1, y, DR, phase); if (barrier(state, 0, y) & L) - draw_barrier(fe, -1, y, R, phase); + draw_barrier(dr, 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(dr, 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(dr, ds, ds->width, y, LD, phase); if (barrier(state, ds->width-1, y) & R) - draw_barrier(fe, ds->width, y, L, phase); + draw_barrier(dr, ds, ds->width, y, L, phase); } } @@ -1422,15 +1644,26 @@ 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(dr, ds, x, 0, +1, 0, 0); + draw_arrow(dr, ds, x+1, ds->height, -1, 0, 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(dr, ds, ds->width, y, 0, +1, 0); + draw_arrow(dr, ds, 0, y+1, 0, -1, 0); } } + if (ui->cur_visible) { + cur_x = ui->cur_x; cur_y = ui->cur_y; + } + if (cur_x != ds->cur_x || cur_y != ds->cur_y) { + /* Cursor has changed; redraw two (prev and curr) arrows. */ + assert(cur_x != state->cx && cur_y != state->cy); + + draw_arrow_for_cursor(dr, ds, cur_x, cur_y, 1); + draw_arrow_for_cursor(dr, ds, ds->cur_x, ds->cur_y, 0); + ds->cur_x = cur_x; ds->cur_y = cur_y; + } /* Check if this is an undo. If so, we will need to run any animation * backwards. @@ -1442,16 +1675,15 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, t = ANIM_TIME - t; } - tx = ty = -1; if (oldstate && (t < ANIM_TIME)) { /* * We're animating a slide, of row/column number * state->last_move_pos, in direction * state->last_move_dir */ - xshift = state->last_move_row == -1 ? 0.0 : + xshift = state->last_move_row == -1 ? 0.0F : (1 - t / ANIM_TIME) * state->last_move_dir; - yshift = state->last_move_col == -1 ? 0.0 : + yshift = state->last_move_col == -1 ? 0.0F : (1 - t / ANIM_TIME) * state->last_move_dir; } @@ -1474,7 +1706,7 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, active = compute_active(state, -1, -1); } - clip(fe, + clip(dr, BORDER + WINDOW_OFFSET, BORDER + WINDOW_OFFSET, TILE_SIZE * state->width + TILE_BORDER, TILE_SIZE * state->height + TILE_BORDER); @@ -1505,18 +1737,18 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, index(state, ds->visible, x, y) == 0xFF || (x == state->last_move_col || y == state->last_move_row)) { - float xs = (y == state->last_move_row ? xshift : 0.0); - float ys = (x == state->last_move_col ? yshift : 0.0); + float xs = (y == state->last_move_row ? xshift : (float)0.0); + float ys = (x == state->last_move_col ? yshift : (float)0.0); - draw_tile(fe, state, x, y, c, xs, ys); + draw_tile(dr, ds, state, x, y, c, xs, ys); if (xs < 0 && x == 0) - draw_tile(fe, state, state->width, y, c, xs, ys); + draw_tile(dr, 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(dr, 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(dr, 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(dr, 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; @@ -1527,9 +1759,9 @@ 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(dr, ds, state, x, y); - unclip(fe); + unclip(dr); /* * Update the status bar. @@ -1551,29 +1783,26 @@ 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); + status_bar(dr, statusbuf); } sfree(active); } 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. - */ - if ((dir > 0 && newstate->just_used_solve) || - (dir < 0 && oldstate->just_used_solve)) - return 0.0F; - return ANIM_TIME; } 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 @@ -1597,9 +1826,22 @@ static float game_flash_length(game_state *oldstate, return 0.0F; } -static int game_wants_statusbar(void) +static int game_status(game_state *state) +{ + return state->completed ? +1 : 0; +} + +static int game_timing_state(game_state *state, game_ui *ui) +{ + return FALSE; +} + +static void game_print_size(game_params *params, float *x, float *y) +{ +} + +static void game_print(drawing *dr, game_state *state, int tilesize) { - return TRUE; } #ifdef COMBINED @@ -1607,7 +1849,7 @@ static int game_wants_statusbar(void) #endif const struct game thegame = { - "Netslide", "games.netslide", + "Netslide", "games.netslide", "netslide", default_params, game_fetch_preset, decode_params, @@ -1616,23 +1858,32 @@ const struct game thegame = { dup_params, TRUE, game_configure, custom_params, validate_params, - new_game_seed, - game_free_aux_info, - validate_seed, + new_game_desc, + validate_desc, new_game, dup_game, free_game, TRUE, solve_game, - FALSE, game_text_format, + FALSE, game_can_format_as_text_now, game_text_format, new_ui, free_ui, - make_move, - game_size, + encode_ui, + decode_ui, + game_changed_state, + interpret_move, + execute_move, + PREFERRED_TILE_SIZE, game_compute_size, game_set_size, game_colours, game_new_drawstate, game_free_drawstate, game_redraw, game_anim_length, game_flash_length, - game_wants_statusbar, + game_status, + FALSE, FALSE, game_print_size, game_print, + TRUE, /* wants_statusbar */ + FALSE, game_timing_state, + 0, /* flags */ }; + +/* vim: set shiftwidth=4 tabstop=8: */