zakarya/puzzles
1
0
Fork 0
mirror of git://git.tartarus.org/simon/puzzles.git synced 2025-04-21 08:01:30 -07:00
Code Issues Packages Projects Releases Wiki Activity

Added an automatic `Solve' feature to most games. This is useful for

Browse Source 
various things:
 - if you haven't fully understood what a game is about, it gives
   you an immediate example of a puzzle plus its solution so you can
   understand it
 - in some games it's useful to compare your solution with the real
   one and see where you made a mistake
 - in the rearrangement games (Fifteen, Sixteen, Twiddle) it's handy
   to be able to get your hands on a pristine grid quickly so you
   can practise or experiment with manoeuvres on it
 - it provides a good way of debugging the games if you think you've
   encountered an unsolvable grid!

[originally from svn r5731]
This commit is contained in:
Simon Tatham
2005-05-02 13:17:10 +00:00
parent aea7b61815
commit 4f7b65de2e
16 changed files with 604 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
net.c
View File

@ -75,10 +75,18 @@ struct game_params {
float barrier_probability;
};
struct solved_game_state {
int width, height;
int refcount;
unsigned char *tiles;
};
struct game_state {
int width, height, cx, cy, wrapping, completed, last_rotate_dir;
int used_solve, just_used_solve;
unsigned char *tiles;
unsigned char *barriers;
struct solved_game_state *solution;
};
#define OFFSET(x2,y2,x1,y1,dir,state) \
@ -309,7 +317,7 @@ static char *new_game_seed(game_params *params, random_state *rs,
return dupstr(buf);
}
void game_free_aux_info(game_aux_info *aux)
static void game_free_aux_info(game_aux_info *aux)
{
assert(!"Shouldn't happen");
}
@ -347,7 +355,7 @@ static game_state *new_game(game_params *params, char *seed)
state->cy = state->height / 2;
state->wrapping = params->wrapping;
state->last_rotate_dir = 0;
state->completed = FALSE;
state->completed = state->used_solve = state->just_used_solve = FALSE;
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);
@ -558,6 +566,25 @@ static game_state *new_game(game_params *params, char *seed)
}
}
/*
* 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.
*/
{
struct solved_game_state *solution;
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);
state->solution = solution;
}
/*
* Now shuffle the grid.
*/
@ -689,22 +716,58 @@ static game_state *dup_game(game_state *state)
ret->cy = state->cy;
ret->wrapping = state->wrapping;
ret->completed = state->completed;
ret->used_solve = state->used_solve;
ret->just_used_solve = state->just_used_solve;
ret->last_rotate_dir = state->last_rotate_dir;
ret->tiles = snewn(state->width * state->height, unsigned char);
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)
{
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.
*/
*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 = TRUE;
return ret;
}
static char *game_text_format(game_state *state)
{
return NULL;
@ -877,6 +940,7 @@ static game_state *make_move(game_state *state, game_ui *ui,
if (button == MIDDLE_BUTTON) {
ret = dup_game(state);
ret->just_used_solve = FALSE;
tile(ret, tx, ty) ^= LOCKED;
ret->last_rotate_dir = 0;
return ret;
@ -895,6 +959,7 @@ static game_state *make_move(game_state *state, game_ui *ui,
* turns anticlockwise; right button turns clockwise.
*/
ret = dup_game(state);
ret->just_used_solve = FALSE;
orig = tile(ret, tx, ty);
if (button == LEFT_BUTTON) {
tile(ret, tx, ty) = A(orig);
@ -911,6 +976,7 @@ static game_state *make_move(game_state *state, game_ui *ui,
*/
int jx, jy;
ret = dup_game(state);
ret->just_used_solve = FALSE;
for (jy = 0; jy < ret->height; jy++) {
for (jx = 0; jx < ret->width; jx++) {
if (!(tile(ret, jx, jy) & LOCKED)) {
@ -1436,7 +1502,8 @@ static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
a++;
sprintf(statusbuf, "%sActive: %d/%d",
(state->completed ? "COMPLETED! " : ""), a, n);
(state->used_solve ? "Auto-solved. " :
state->completed ? "COMPLETED! " : ""), a, n);
status_bar(fe, statusbuf);
}
@ -1449,6 +1516,13 @@ static float game_anim_length(game_state *oldstate,
{
int x, y, last_rotate_dir;
/*
* Don't animate an auto-solve move.
*/
if ((dir > 0 && newstate->just_used_solve) ||
(dir < 0 && oldstate->just_used_solve))
return 0.0F;
/*
* Don't animate if last_rotate_dir is zero.
*/
@ -1478,7 +1552,8 @@ static float game_flash_length(game_state *oldstate,
* If the game has just been completed, we display a completion
* flash.
*/
if (!oldstate->completed && newstate->completed) {
if (!oldstate->completed && newstate->completed &&
!oldstate->used_solve && !newstate->used_solve) {
int size;
size = 0;
if (size < newstate->cx+1)
@ -1520,6 +1595,7 @@ const struct game thegame = {
new_game,
dup_game,
free_game,
TRUE, solve_game,
FALSE, game_text_format,
new_ui,
free_ui,