X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/2ef96bd6ebb0e89bc054d2edb1ef280c97faa955..42132f2d662cd51e696af7923f7331bfb636b0cd:/net.c diff --git a/net.c b/net.c index 6fd90aa..0774de3 100644 --- a/net.c +++ b/net.c @@ -11,6 +11,9 @@ #include "puzzles.h" #include "tree234.h" +const char *const game_name = "Net"; +const int game_can_configure = TRUE; + #define PI 3.141592653589793238462643383279502884197169399 #define MATMUL(xr,yr,m,x,y) do { \ @@ -53,8 +56,8 @@ #define TILE_BORDER 1 #define WINDOW_OFFSET 16 -#define ROTATE_TIME 0.1 -#define FLASH_FRAME 0.05 +#define ROTATE_TIME 0.13F +#define FLASH_FRAME 0.07F enum { COL_BACKGROUND, @@ -126,24 +129,132 @@ game_params *default_params(void) { game_params *ret = snew(game_params); - ret->width = 11; - ret->height = 11; - ret->wrapping = TRUE; - ret->barrier_probability = 0.1; + ret->width = 5; + ret->height = 5; + ret->wrapping = FALSE; + ret->barrier_probability = 0.0; return ret; } +int game_fetch_preset(int i, char **name, game_params **params) +{ + game_params *ret; + char str[80]; + static const struct { int x, y, wrap; } values[] = { + {5, 5, FALSE}, + {7, 7, FALSE}, + {9, 9, FALSE}, + {11, 11, FALSE}, + {13, 11, FALSE}, + {5, 5, TRUE}, + {7, 7, TRUE}, + {9, 9, TRUE}, + {11, 11, TRUE}, + {13, 11, TRUE}, + }; + + if (i < 0 || i >= lenof(values)) + return FALSE; + + ret = snew(game_params); + ret->width = values[i].x; + ret->height = values[i].y; + ret->wrapping = values[i].wrap; + ret->barrier_probability = 0.0; + + sprintf(str, "%dx%d%s", ret->width, ret->height, + ret->wrapping ? " wrapping" : ""); + + *name = dupstr(str); + *params = ret; + return TRUE; +} + void free_params(game_params *params) { sfree(params); } +game_params *dup_params(game_params *params) +{ + game_params *ret = snew(game_params); + *ret = *params; /* structure copy */ + return ret; +} + +config_item *game_configure(game_params *params) +{ + config_item *ret; + char buf[80]; + + ret = snewn(5, config_item); + + ret[0].name = "Width"; + ret[0].type = C_STRING; + sprintf(buf, "%d", params->width); + ret[0].sval = dupstr(buf); + ret[0].ival = 0; + + ret[1].name = "Height"; + ret[1].type = C_STRING; + sprintf(buf, "%d", params->height); + ret[1].sval = dupstr(buf); + ret[1].ival = 0; + + ret[2].name = "Walls wrap around"; + ret[2].type = C_BOOLEAN; + ret[2].sval = NULL; + ret[2].ival = params->wrapping; + + ret[3].name = "Barrier probability"; + ret[3].type = C_STRING; + sprintf(buf, "%g", params->barrier_probability); + ret[3].sval = dupstr(buf); + ret[3].ival = 0; + + ret[4].name = NULL; + ret[4].type = C_END; + ret[4].sval = NULL; + ret[4].ival = 0; + + return ret; +} + +game_params *custom_params(config_item *cfg) +{ + game_params *ret = snew(game_params); + + ret->width = atoi(cfg[0].sval); + ret->height = atoi(cfg[1].sval); + ret->wrapping = cfg[2].ival; + ret->barrier_probability = (float)atof(cfg[3].sval); + + return ret; +} + +char *validate_params(game_params *params) +{ + if (params->width <= 0 && params->height <= 0) + return "Width and height must both be greater than zero"; + if (params->width <= 0) + return "Width must be greater than zero"; + if (params->height <= 0) + return "Height must be greater than zero"; + if (params->width <= 1 && params->height <= 1) + return "At least one of width and height must be greater than one"; + if (params->barrier_probability < 0) + return "Barrier probability may not be negative"; + if (params->barrier_probability > 1) + return "Barrier probability may not be greater than 1"; + return NULL; +} + /* ---------------------------------------------------------------------- * Randomly select a new game seed. */ -char *new_game_seed(game_params *params) +char *new_game_seed(game_params *params, random_state *rs) { /* * The full description of a Net game is far too large to @@ -157,10 +268,19 @@ char *new_game_seed(game_params *params) * understand it and do something completely different.) */ char buf[40]; - sprintf(buf, "%d", rand()); + sprintf(buf, "%lu", random_bits(rs, 32)); return dupstr(buf); } +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; +} + /* ---------------------------------------------------------------------- * Construct an initial game state, given a seed and parameters. */ @@ -172,8 +292,8 @@ game_state *new_game(game_params *params, char *seed) tree234 *possibilities, *barriers; int w, h, x, y, nbarriers; - assert(params->width > 2); - assert(params->height > 2); + assert(params->width > 0 && params->height > 0); + assert(params->width > 1 || params->height > 1); /* * Create a blank game state. @@ -253,11 +373,15 @@ game_state *new_game(game_params *params, char *seed) * closed loops. [] */ possibilities = newtree234(xyd_cmp); - - add234(possibilities, new_xyd(state->cx, state->cy, R)); - add234(possibilities, new_xyd(state->cx, state->cy, U)); - add234(possibilities, new_xyd(state->cx, state->cy, L)); - add234(possibilities, new_xyd(state->cx, state->cy, D)); + + 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)); while (count234(possibilities) > 0) { int i; @@ -417,7 +541,7 @@ 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 = params->barrier_probability * count234(barriers); + nbarriers = (int)(params->barrier_probability * count234(barriers)); assert(nbarriers >= 0 && nbarriers <= count234(barriers)); while (nbarriers > 0) { @@ -480,27 +604,27 @@ game_state *new_game(game_params *params, char *seed) x1 = x + X(dir), y1 = y + Y(dir); if (x1 >= 0 && x1 < state->width && - y1 >= 0 && y1 < state->width && + y1 >= 0 && y1 < state->height && (barrier(state, x1, y1) & dir2)) corner = TRUE; x2 = x + X(dir2), y2 = y + Y(dir2); if (x2 >= 0 && x2 < state->width && - y2 >= 0 && y2 < state->width && + y2 >= 0 && y2 < state->height && (barrier(state, x2, y2) & dir)) corner = TRUE; if (corner) { barrier(state, x, y) |= (dir << 4); if (x1 >= 0 && x1 < state->width && - y1 >= 0 && y1 < state->width) + y1 >= 0 && y1 < state->height) barrier(state, x1, y1) |= (A(dir) << 4); if (x2 >= 0 && x2 < state->width && - y2 >= 0 && y2 < state->width) + y2 >= 0 && y2 < state->height) barrier(state, x2, y2) |= (C(dir) << 4); x3 = x + X(dir) + X(dir2), y3 = y + Y(dir) + Y(dir2); if (x3 >= 0 && x3 < state->width && - y3 >= 0 && y3 < state->width) + y3 >= 0 && y3 < state->height) barrier(state, x3, y3) |= (F(dir) << 4); } } @@ -627,8 +751,8 @@ game_state *make_move(game_state *state, int x, int y, int button) ty = y / TILE_SIZE; if (tx >= state->width || ty >= state->height) return NULL; - if (tx % TILE_SIZE >= TILE_SIZE - TILE_BORDER || - ty % TILE_SIZE >= TILE_SIZE - TILE_BORDER) + if (x % TILE_SIZE >= TILE_SIZE - TILE_BORDER || + y % TILE_SIZE >= TILE_SIZE - TILE_BORDER) return NULL; /* @@ -744,44 +868,44 @@ float *game_colours(frontend *fe, game_state *state, int *ncolours) /* * Wires are black. */ - ret[COL_WIRE * 3 + 0] = 0.0; - ret[COL_WIRE * 3 + 1] = 0.0; - ret[COL_WIRE * 3 + 2] = 0.0; + ret[COL_WIRE * 3 + 0] = 0.0F; + ret[COL_WIRE * 3 + 1] = 0.0F; + ret[COL_WIRE * 3 + 2] = 0.0F; /* * Powered wires and powered endpoints are cyan. */ - ret[COL_POWERED * 3 + 0] = 0.0; - ret[COL_POWERED * 3 + 1] = 1.0; - ret[COL_POWERED * 3 + 2] = 1.0; + ret[COL_POWERED * 3 + 0] = 0.0F; + ret[COL_POWERED * 3 + 1] = 1.0F; + ret[COL_POWERED * 3 + 2] = 1.0F; /* * Barriers are red. */ - ret[COL_BARRIER * 3 + 0] = 1.0; - ret[COL_BARRIER * 3 + 1] = 0.0; - ret[COL_BARRIER * 3 + 2] = 0.0; + ret[COL_BARRIER * 3 + 0] = 1.0F; + ret[COL_BARRIER * 3 + 1] = 0.0F; + ret[COL_BARRIER * 3 + 2] = 0.0F; /* * Unpowered endpoints are blue. */ - ret[COL_ENDPOINT * 3 + 0] = 0.0; - ret[COL_ENDPOINT * 3 + 1] = 0.0; - ret[COL_ENDPOINT * 3 + 2] = 1.0; + ret[COL_ENDPOINT * 3 + 0] = 0.0F; + ret[COL_ENDPOINT * 3 + 1] = 0.0F; + ret[COL_ENDPOINT * 3 + 2] = 1.0F; /* * Tile borders are a darker grey than the background. */ - ret[COL_BORDER * 3 + 0] = 0.5 * ret[COL_BACKGROUND * 3 + 0]; - ret[COL_BORDER * 3 + 1] = 0.5 * ret[COL_BACKGROUND * 3 + 1]; - ret[COL_BORDER * 3 + 2] = 0.5 * ret[COL_BACKGROUND * 3 + 2]; + ret[COL_BORDER * 3 + 0] = 0.5F * ret[COL_BACKGROUND * 3 + 0]; + ret[COL_BORDER * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1]; + ret[COL_BORDER * 3 + 2] = 0.5F * ret[COL_BACKGROUND * 3 + 2]; /* * Locked tiles are a grey in between those two. */ - ret[COL_LOCKED * 3 + 0] = 0.75 * ret[COL_BACKGROUND * 3 + 0]; - ret[COL_LOCKED * 3 + 1] = 0.75 * ret[COL_BACKGROUND * 3 + 1]; - ret[COL_LOCKED * 3 + 2] = 0.75 * ret[COL_BACKGROUND * 3 + 2]; + ret[COL_LOCKED * 3 + 0] = 0.75F * ret[COL_BACKGROUND * 3 + 0]; + ret[COL_LOCKED * 3 + 1] = 0.75F * ret[COL_BACKGROUND * 3 + 1]; + ret[COL_LOCKED * 3 + 2] = 0.75F * ret[COL_BACKGROUND * 3 + 2]; return ret; } @@ -892,31 +1016,33 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, /* * Set up the rotation matrix. */ - matrix[0] = cos(angle * PI / 180.0); - matrix[1] = -sin(angle * PI / 180.0); - matrix[2] = sin(angle * PI / 180.0); - matrix[3] = cos(angle * PI / 180.0); + matrix[0] = (float)cos(angle * PI / 180.0); + matrix[1] = (float)-sin(angle * PI / 180.0); + matrix[2] = (float)sin(angle * PI / 180.0); + matrix[3] = (float)cos(angle * PI / 180.0); /* * Draw the wires. */ - cx = cy = TILE_BORDER + (TILE_SIZE-TILE_BORDER) / 2.0 - 0.5; + cx = cy = TILE_BORDER + (TILE_SIZE-TILE_BORDER) / 2.0F - 0.5F; col = (tile & ACTIVE ? COL_POWERED : COL_WIRE); for (dir = 1; dir < 0x10; dir <<= 1) { if (tile & dir) { - ex = (TILE_SIZE - TILE_BORDER - 1.0) / 2.0 * X(dir); - ey = (TILE_SIZE - TILE_BORDER - 1.0) / 2.0 * Y(dir); + ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir); + ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir); MATMUL(tx, ty, matrix, ex, ey); - draw_thick_line(fe, bx+cx, by+cy, bx+(cx+tx), by+(cy+ty), + draw_thick_line(fe, bx+(int)cx, by+(int)cy, + bx+(int)(cx+tx), by+(int)(cy+ty), COL_WIRE); } } for (dir = 1; dir < 0x10; dir <<= 1) { if (tile & dir) { - ex = (TILE_SIZE - TILE_BORDER - 1.0) / 2.0 * X(dir); - ey = (TILE_SIZE - TILE_BORDER - 1.0) / 2.0 * Y(dir); + ex = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * X(dir); + ey = (TILE_SIZE - TILE_BORDER - 1.0F) / 2.0F * Y(dir); MATMUL(tx, ty, matrix, ex, ey); - draw_line(fe, bx+cx, by+cy, bx+(cx+tx), by+(cy+ty), col); + draw_line(fe, bx+(int)cx, by+(int)cy, + bx+(int)(cx+tx), by+(int)(cy+ty), col); } } @@ -941,11 +1067,11 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, points[6] = -1; points[7] = +1; for (i = 0; i < 8; i += 2) { - ex = (TILE_SIZE * 0.24) * points[i]; - ey = (TILE_SIZE * 0.24) * points[i+1]; + ex = (TILE_SIZE * 0.24F) * points[i]; + ey = (TILE_SIZE * 0.24F) * points[i+1]; MATMUL(tx, ty, matrix, ex, ey); - points[i] = bx+cx+tx; - points[i+1] = by+cy+ty; + points[i] = bx+(int)(cx+tx); + points[i+1] = by+(int)(cy+ty); } draw_polygon(fe, points, 4, TRUE, col); @@ -971,8 +1097,8 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, if (!(tile(state, ox, oy) & F(dir))) continue; - px = bx + (dx>0 ? TILE_SIZE + TILE_BORDER - 1 : dx<0 ? 0 : cx); - py = by + (dy>0 ? TILE_SIZE + TILE_BORDER - 1 : dy<0 ? 0 : cy); + px = bx + (int)(dx>0 ? TILE_SIZE + TILE_BORDER - 1 : dx<0 ? 0 : cx); + py = by + (int)(dy>0 ? TILE_SIZE + TILE_BORDER - 1 : dy<0 ? 0 : cy); lx = dx * (TILE_BORDER-1); ly = dy * (TILE_BORDER-1); vx = (dy ? 1 : 0); @@ -1015,7 +1141,7 @@ static void draw_tile(frontend *fe, game_state *state, int x, int y, int tile, } void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, - game_state *state, float t) + game_state *state, float t, float ft) { int x, y, tx, ty, frame; unsigned char *active; @@ -1073,7 +1199,6 @@ void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, } tx = ty = -1; - frame = -1; if (oldstate && (t < ROTATE_TIME)) { /* * We're animating a tile rotation. Find the turning tile, @@ -1090,17 +1215,20 @@ void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, if (tx >= 0) { if (tile(state, tx, ty) == ROT(tile(oldstate, tx, ty), state->last_rotate_dir)) - angle = state->last_rotate_dir * 90.0 * (t / ROTATE_TIME); + angle = state->last_rotate_dir * 90.0F * (t / ROTATE_TIME); else - angle = state->last_rotate_dir * -90.0 * (t / ROTATE_TIME); + angle = state->last_rotate_dir * -90.0F * (t / ROTATE_TIME); state = oldstate; } - } else if (t > ROTATE_TIME) { + } + + frame = -1; + if (ft > 0) { /* * We're animating a completion flash. Find which frame * we're at. */ - frame = (t - ROTATE_TIME) / FLASH_FRAME; + frame = (int)(ft / FLASH_FRAME); } /* @@ -1134,7 +1262,7 @@ void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, index(state, ds->visible, x, y) == 0xFF || (x == tx && y == ty)) { draw_tile(fe, state, x, y, c, - (x == tx && y == ty ? angle : 0.0)); + (x == tx && y == ty ? angle : 0.0F)); if (x == tx && y == ty) index(state, ds->visible, x, y) = 0xFF; else @@ -1142,12 +1270,29 @@ void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate, } } + /* + * Update the status bar. + */ + { + char statusbuf[256]; + int i, n, a; + + n = state->width * state->height; + for (i = a = 0; i < n; i++) + if (active[i]) + a++; + + sprintf(statusbuf, "%sActive: %d/%d", + (state->completed ? "COMPLETED! " : ""), a, n); + + status_bar(fe, statusbuf); + } + sfree(active); } float game_anim_length(game_state *oldstate, game_state *newstate) { - float ret = 0.0; int x, y; /* @@ -1157,14 +1302,17 @@ float game_anim_length(game_state *oldstate, game_state *newstate) for (x = 0; x < oldstate->width; x++) for (y = 0; y < oldstate->height; y++) if ((tile(oldstate, x, y) ^ tile(newstate, x, y)) & 0xF) { - ret = ROTATE_TIME; - goto break_label; /* leave both loops at once */ + return ROTATE_TIME; } - break_label: + return 0.0F; +} + +float game_flash_length(game_state *oldstate, game_state *newstate) +{ /* - * Also, if the game has just been completed, allow time for a - * completion flash. + * If the game has just been completed, we display a completion + * flash. */ if (!oldstate->completed && newstate->completed) { int size; @@ -1177,8 +1325,13 @@ float game_anim_length(game_state *oldstate, game_state *newstate) size = newstate->width - newstate->cx; if (size < newstate->height - newstate->cy) size = newstate->height - newstate->cy; - ret += FLASH_FRAME * (size+4); + return FLASH_FRAME * (size+4); } - return ret; + return 0.0F; +} + +int game_wants_statusbar(void) +{ + return TRUE; }