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"},
+ {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)
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->barrier_probability = (float)netslide_presets[i].bprob;
ret->movetarget = 0;
sprintf(str, "%dx%d%s", ret->width, ret->height, netslide_presets[i].desc);
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 */
if ( (ret->wrapping = (*p == 'w')) != 0 )
p++;
if (*p == 'b') {
- ret->barrier_probability = atof(++p);
+ ret->barrier_probability = (float)atof(++p);
while (*p && (isdigit((unsigned char)*p) || *p == '.')) p++;
}
if (*p == 'm') {
}
}
-static char *encode_params(game_params *params, int full)
+static char *encode_params(const game_params *params, int full)
{
char ret[400];
int len;
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];
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);
return ret;
}
-static char *validate_params(game_params *params, int full)
+static char *validate_params(const game_params *params, int full)
{
if (params->width <= 1 || params->height <= 1)
return "Width and height must both be greater than one";
* Randomly select a new game description.
*/
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
char **aux, int interactive)
{
tree234 *possibilities, *barriertree;
return desc;
}
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, const char *desc)
{
int w = params->width, h = params->height;
int i;
* Construct an initial game state, given a description and parameters.
*/
-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;
int w, h, x, y;
return state;
}
-static game_state *dup_game(game_state *state)
+static game_state *dup_game(const game_state *state)
{
game_state *ret;
sfree(state);
}
-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)
{
if (!aux) {
*error = "Solution not known for this puzzle";
return dupstr(aux);
}
-static char *game_text_format(game_state *state)
+static int game_can_format_as_text_now(const game_params *params)
+{
+ return TRUE;
+}
+
+static char *game_text_format(const game_state *state)
{
return NULL;
}
* squares in the moving_row and moving_col are always inactive - this
* is so that "current" doesn't appear to jump across moving lines.
*/
-static unsigned char *compute_active(game_state *state,
+static unsigned char *compute_active(const game_state *state,
int moving_row, int moving_col)
{
unsigned char *active;
int cur_visible;
};
-static game_ui *new_ui(game_state *state)
+static game_ui *new_ui(const 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;
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)
{
}
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)
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+ const game_state *newstate)
{
}
int width, height;
int tilesize;
unsigned char *visible;
+ int cur_x, cur_y;
};
-static char *interpret_move(game_state *state, game_ui *ui,
- game_drawstate *ds, int x, int y, int button)
+static char *interpret_move(const game_state *state, game_ui *ui,
+ const game_drawstate *ds,
+ int x, int y, int button)
{
int cx, cy;
- int n, dx, dy;
+ int dx, dy;
char buf[80];
button &= ~MOD_MASK;
- if (button != LEFT_BUTTON && button != RIGHT_BUTTON)
- return NULL;
+ 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);
- 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 (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)
if (cy == -1) dy = +1;
else if (cy == state->height) dy = -1;
else return NULL;
- n = state->height;
dx = 0;
}
else
return dupstr(buf);
}
-static game_state *execute_move(game_state *from, char *move)
+static game_state *execute_move(const game_state *from, const char *move)
{
game_state *ret;
int c, d, col;
* Routines for drawing the game position on the screen.
*/
-static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
{
game_drawstate *ds = snew(game_drawstate);
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;
}
sfree(ds);
}
-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; } ads, *ds = &ads;
}
static void game_set_size(drawing *dr, game_drawstate *ds,
- game_params *params, int tilesize)
+ const game_params *params, int tilesize)
{
ds->tilesize = tilesize;
}
return ret;
}
-static void draw_thick_line(drawing *dr, 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(dr, x1-1, y1, x2-1, y2, COL_WIRE);
draw_line(dr, x1+1, y1, x2+1, y2, COL_WIRE);
}
}
-static void draw_tile(drawing *dr, game_drawstate *ds, game_state *state,
+static void draw_tile(drawing *dr, game_drawstate *ds, const 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;
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(dr, 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) {
}
static void draw_tile_barriers(drawing *dr, game_drawstate *ds,
- game_state *state, int x, int y)
+ const game_state *state, int x, int y)
{
int phase;
int dir;
}
static void draw_arrow(drawing *dr, game_drawstate *ds,
- int x, int y, int xdx, int xdy)
+ int x, int y, int xdx, int xdy, int cur)
{
int coords[14];
int ydy = -xdx, ydx = xdy;
POINT(5, 3 * TILE_SIZE / 8, TILE_SIZE / 2); /* left concave */
POINT(6, TILE_SIZE / 4, TILE_SIZE / 2); /* left corner */
- draw_polygon(dr, coords, 7, COL_LOWLIGHT, COL_TEXT);
+ draw_polygon(dr, coords, 7, cur ? COL_POWERED : COL_LOWLIGHT, COL_TEXT);
}
-static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
- game_state *state, int dir, game_ui *ui, float t, float ft)
+static void draw_arrow_for_cursor(drawing *dr, game_drawstate *ds,
+ int cur_x, int cur_y, int cur)
{
- int x, y, tx, ty, frame;
+ 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,
+ const game_state *oldstate, const game_state *state,
+ int dir, const game_ui *ui,
+ float t, float ft)
+{
+ 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
*/
for (x = 0; x < ds->width; x++) {
if (x == state->cx) continue;
- draw_arrow(dr, ds, x, 0, +1, 0);
- draw_arrow(dr, ds, 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(dr, ds, ds->width, y, 0, +1);
- draw_arrow(dr, ds, 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.
*/
if (oldstate && oldstate->move_count > state->move_count) {
- game_state * tmpstate = state;
+ const game_state * tmpstate = state;
state = oldstate;
oldstate = tmpstate;
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;
}
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(dr, ds, state, x, y, c, xs, ys);
if (xs < 0 && x == 0)
sfree(active);
}
-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 ANIM_TIME;
}
-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 the game has just been completed, we display a completion
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 FALSE;
}
-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)
{
}
-static void game_print(drawing *dr, game_state *state, int tilesize)
+static void game_print(drawing *dr, const game_state *state, int tilesize)
{
}
#endif
const struct game thegame = {
- "Netslide", "games.netslide",
+ "Netslide", "games.netslide", "netslide",
default_params,
game_fetch_preset,
decode_params,
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,
encode_ui,
game_redraw,
game_anim_length,
game_flash_length,
+ game_status,
FALSE, FALSE, game_print_size, game_print,
TRUE, /* wants_statusbar */
FALSE, game_timing_state,
0, /* flags */
};
+
+/* vim: set shiftwidth=4 tabstop=8: */
~ian / sgt-puzzles.git / blobdiff