#include "puzzles.h"
#include "tree234.h"
-const char *const game_name = "Netslide";
-const char *const game_winhelp_topic = "games.netslide";
-const int game_can_configure = TRUE;
-
#define PI 3.141592653589793238462643383279502884197169399
#define MATMUL(xr,yr,m,x,y) do { \
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;
+ int used_solve, just_used_solve;
int move_count;
/* position (row or col number, starting at 0) of last move. */
unsigned char *tiles;
unsigned char *barriers;
+ struct solved_game_state *solution;
};
#define OFFSET(x2,y2,x1,y1,dir,state) \
return xyd;
}
-void slide_col(game_state *state, int dir, int col);
-void slide_row(game_state *state, int dir, int row);
+static void slide_col(game_state *state, int dir, int col);
+static void slide_row(game_state *state, int dir, int row);
/* ----------------------------------------------------------------------
* Manage game parameters.
*/
-game_params *default_params(void)
+static game_params *default_params(void)
{
game_params *ret = snew(game_params);
return ret;
}
-int game_fetch_preset(int i, char **name, game_params **params)
+static int game_fetch_preset(int i, char **name, game_params **params)
{
game_params *ret;
char str[80];
return TRUE;
}
-void free_params(game_params *params)
+static void free_params(game_params *params)
{
sfree(params);
}
-game_params *dup_params(game_params *params)
+static game_params *dup_params(game_params *params)
{
game_params *ret = snew(game_params);
*ret = *params; /* structure copy */
return ret;
}
-game_params *decode_params(char const *string)
+static game_params *decode_params(char const *string)
{
game_params *ret = default_params();
char const *p = string;
return ret;
}
-char *encode_params(game_params *params)
+static char *encode_params(game_params *params)
{
char ret[400];
int len;
return dupstr(ret);
}
-config_item *game_configure(game_params *params)
+static config_item *game_configure(game_params *params)
{
config_item *ret;
char buf[80];
return ret;
}
-game_params *custom_params(config_item *cfg)
+static game_params *custom_params(config_item *cfg)
{
game_params *ret = snew(game_params);
return ret;
}
-char *validate_params(game_params *params)
+static char *validate_params(game_params *params)
{
if (params->width <= 1 && params->height <= 1)
return "Width and height must both be greater than one";
* Randomly select a new game seed.
*/
-char *new_game_seed(game_params *params, random_state *rs)
+static char *new_game_seed(game_params *params, random_state *rs,
+ game_aux_info **aux)
{
/*
* The full description of a Net game is far too large to
return dupstr(buf);
}
-char *validate_seed(game_params *params, char *seed)
+static void game_free_aux_info(game_aux_info *aux)
+{
+ assert(!"Shouldn't happen");
+}
+
+static char *validate_seed(game_params *params, char *seed)
{
/*
* Since any string at all will suffice to seed the RNG, there
* Construct an initial game state, given a seed and parameters.
*/
-game_state *new_game(game_params *params, char *seed)
+static game_state *new_game(game_params *params, char *seed)
{
random_state *rs;
game_state *state;
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;
}
/*
+ * 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.
* FIXME - this simply does a set of random moves to shuffle the pieces.
* A better way would be to number all the pieces, generate a placement
return state;
}
-game_state *dup_game(game_state *state)
+static game_state *dup_game(game_state *state)
{
game_state *ret;
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->move_count = state->move_count;
ret->last_move_row = state->last_move_row;
ret->last_move_col = state->last_move_col;
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;
}
-void free_game(game_state *state)
+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 = ret->move_count;
+
+ return ret;
+}
+
+static char *game_text_format(game_state *state)
+{
+ return NULL;
+}
+
/* ----------------------------------------------------------------------
* Utility routine.
*/
int cur_visible;
};
-game_ui *new_ui(game_state *state)
+static game_ui *new_ui(game_state *state)
{
game_ui *ui = snew(game_ui);
ui->cur_x = state->width / 2;
return ui;
}
-void free_ui(game_ui *ui)
+static void free_ui(game_ui *ui)
{
sfree(ui);
}
* Process a move.
*/
-void slide_row(game_state *state, int dir, int row)
+static void slide_row(game_state *state, int dir, int row)
{
int x = dir > 0 ? -1 : state->width;
int tx = x + dir;
state->tiles[T(state, tx, row)] = endtile;
}
-void slide_col(game_state *state, int dir, int col)
+static void slide_col(game_state *state, int dir, int col)
{
int y = dir > 0 ? -1 : state->height;
int ty = y + dir;
state->tiles[T(state, col, ty)] = endtile;
}
-game_state *make_move(game_state *state, game_ui *ui, int x, int y, int button)
+static game_state *make_move(game_state *state, game_ui *ui,
+ int x, int y, int button)
{
int cx, cy;
int n, dx, dy;
}
ret = dup_game(state);
+ ret->just_used_solve = FALSE;
if (dx == 0) slide_col(ret, dy, cx);
else slide_row(ret, dx, cy);
unsigned char *visible;
};
-game_drawstate *game_new_drawstate(game_state *state)
+static game_drawstate *game_new_drawstate(game_state *state)
{
game_drawstate *ds = snew(game_drawstate);
return ds;
}
-void game_free_drawstate(game_drawstate *ds)
+static void game_free_drawstate(game_drawstate *ds)
{
sfree(ds->visible);
sfree(ds);
}
-void game_size(game_params *params, int *x, int *y)
+static void game_size(game_params *params, int *x, int *y)
{
*x = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->width + TILE_BORDER;
*y = BORDER * 2 + WINDOW_OFFSET * 2 + TILE_SIZE * params->height + TILE_BORDER;
}
-float *game_colours(frontend *fe, game_state *state, int *ncolours)
+static float *game_colours(frontend *fe, game_state *state, int *ncolours)
{
float *ret;
draw_polygon(fe, coords, 7, FALSE, COL_TEXT);
}
-void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
- game_state *state, game_ui *ui, float t, float ft)
+static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
+ game_state *state, int dir, game_ui *ui, float t, float ft)
{
int x, y, tx, ty, frame;
unsigned char *active;
if (active[i])
a++;
- sprintf(statusbuf, "%sMoves: %d Active: %d/%d",
- (state->completed ? "COMPLETED! " : ""),
- (state->completed ? state->completed : state->move_count),
- a, n);
+ if (state->used_solve)
+ sprintf(statusbuf, "Moves since auto-solve: %d",
+ state->move_count - state->completed);
+ else
+ sprintf(statusbuf, "%sMoves: %d",
+ (state->completed ? "COMPLETED! " : ""),
+ (state->completed ? state->completed : state->move_count));
+
+ sprintf(statusbuf + strlen(statusbuf), " Active: %d/%d", a, n);
status_bar(fe, statusbuf);
}
sfree(active);
}
-float game_anim_length(game_state *oldstate, game_state *newstate)
+static float game_anim_length(game_state *oldstate,
+ game_state *newstate, int dir)
{
+ /*
+ * 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;
}
-float game_flash_length(game_state *oldstate, game_state *newstate)
+static float game_flash_length(game_state *oldstate,
+ game_state *newstate, int dir)
{
/*
* 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)
return 0.0F;
}
-int game_wants_statusbar(void)
+static int game_wants_statusbar(void)
{
return TRUE;
}
+
+#ifdef COMBINED
+#define thegame netslide
+#endif
+
+const struct game thegame = {
+ "Netslide", "games.netslide",
+ default_params,
+ game_fetch_preset,
+ decode_params,
+ encode_params,
+ free_params,
+ dup_params,
+ TRUE, game_configure, custom_params,
+ validate_params,
+ new_game_seed,
+ game_free_aux_info,
+ validate_seed,
+ new_game,
+ dup_game,
+ free_game,
+ TRUE, solve_game,
+ FALSE, game_text_format,
+ new_ui,
+ free_ui,
+ make_move,
+ game_size,
+ game_colours,
+ game_new_drawstate,
+ game_free_drawstate,
+ game_redraw,
+ game_anim_length,
+ game_flash_length,
+ game_wants_statusbar,
+};
~mdw / sgt / puzzles / blobdiff