#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 { \
#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,
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
* 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.
*/
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.
* 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;
* 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) {
/*
* 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;
}
/*
* 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);
}
}
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);
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);
}
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;
}
tx = ty = -1;
- frame = -1;
if (oldstate && (t < ROTATE_TIME)) {
/*
* We're animating a tile rotation. Find the turning tile,
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);
}
/*
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
}
}
+ /*
+ * 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;
/*
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;
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;
}
~ian / sgt-puzzles.git / blobdiff