#include "puzzles.h"
#include "tree234.h"
+const char *const game_name = "Net";
+
#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.1F
+#define FLASH_FRAME 0.05F
enum {
COL_BACKGROUND,
* 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;
}