#include "puzzles.h"
/* Turn this on for hints about which lines are considered possibilities. */
-#undef DRAW_HINTS
#undef DRAW_GRID
#undef DRAW_DSF
COL_SELECTED, COL_MARK,
COL_HINT, COL_GRID,
COL_WARNING,
+ COL_CURSOR,
NCOLOURS
};
#define G_REDRAW 0x0100
#define G_FLASH 0x0200
#define G_WARN 0x0400
+#define G_CURSOR 0x0800
/* flags used by the solver etc. */
-#define G_SWEEP 0x0800
+#define G_SWEEP 0x1000
#define G_FLAGSH (G_LINEH|G_MARKH|G_NOLINEH)
#define G_FLAGSV (G_LINEV|G_MARKV|G_NOLINEV)
}
}
+static int game_can_format_as_text_now(game_params *params)
+{
+ return TRUE;
+}
+
static char *game_text_format(game_state *state)
{
int x, y, len, nl;
assert(is_orth);
ifree = is_orth->count - island_countbridges(is_orth);
- if (ifree > 0)
- nsurrspc += min(ifree, MAXIMUM(is->state, dx,
- is->adj.points[i].x, is->adj.points[i].y));
+ if (ifree > 0) {
+ /*
+ * ifree is the number of bridges unfilled in the other
+ * island, which is clearly an upper bound on the number
+ * of extra bridges this island may run to it.
+ *
+ * Another upper bound is the number of bridges unfilled
+ * on the specific line between here and there. We must
+ * take the minimum of both.
+ */
+ int bmax = MAXIMUM(is->state, dx,
+ is->adj.points[i].x, is->adj.points[i].y);
+ int bcurr = GRIDCOUNT(is->state,
+ is->adj.points[i].x, is->adj.points[i].y,
+ dx ? G_LINEH : G_LINEV);
+ assert(bcurr <= bmax);
+ nsurrspc += min(ifree, bmax - bcurr);
+ }
}
if (nsurrspc < nspc) {
debug(("island at (%d,%d) impossible: surr. islands %d spc, need %d.\n",
static int map_hasloops(game_state *state, int mark)
{
- int x, y, ox, oy, nx, ny, loop = 0;
+ int x, y, ox, oy, nx = 0, ny = 0, loop = 0;
memcpy(state->scratch, state->grid, GRIDSZ(state));
struct island *is, *is_join;
/* Initialise dsf. */
- for (i = 0; i < wh; i++)
- dsf[i] = i;
+ dsf_init(dsf, wh);
/* For each island, find connected islands right or down
* and merge the dsf for the island squares as well as the
ret->solved = ret->completed = 0;
ret->solver = snew(struct solver_state);
- ret->solver->dsf = snewn(wh, int);
+ ret->solver->dsf = snew_dsf(wh);
ret->solver->tmpdsf = snewn(wh, int);
- for (i = 0; i < wh; i++) ret->solver->dsf[i] = i;
ret->solver->refcount = 1;
}
#define MAX_NEWISLAND_TRIES 50
+#define MIN_SENSIBLE_ISLANDS 3
#define ORDER(a,b) do { if (a < b) { int tmp=a; int a=b; int b=tmp; } } while(0)
game_state *tobuild = NULL;
int i, j, wh = params->w * params->h, x, y, dx, dy;
int minx, miny, maxx, maxy, joinx, joiny, newx, newy, diffx, diffy;
- int ni_req = max((params->islands * wh) / 100, 2), ni_curr, ni_bad;
+ int ni_req = max((params->islands * wh) / 100, MIN_SENSIBLE_ISLANDS), ni_curr, ni_bad;
struct island *is, *is2;
char *ret;
unsigned int echeck;
echeck = 0;
for (x = 0; x < params->w; x++) {
if (INDEX(tobuild, gridi, x, 0)) echeck |= 1;
- if (INDEX(tobuild, gridi, x, params->w-1)) echeck |= 2;
+ if (INDEX(tobuild, gridi, x, params->h-1)) echeck |= 2;
}
for (y = 0; y < params->h; y++) {
if (INDEX(tobuild, gridi, 0, y)) echeck |= 4;
- if (INDEX(tobuild, gridi, params->h-1, y)) echeck |= 8;
+ if (INDEX(tobuild, gridi, params->w-1, y)) echeck |= 8;
}
if (echeck != 15) {
debug(("Generated grid doesn't fill to sides, retrying.\n"));
map_find_orthogonal(tobuild);
if (params->difficulty > 0) {
- if (solve_from_scratch(tobuild, params->difficulty-1) > 0) {
+ if ((ni_curr > MIN_SENSIBLE_ISLANDS) &&
+ (solve_from_scratch(tobuild, params->difficulty-1) > 0)) {
debug(("Grid is solvable at difficulty %d (too easy); retrying.\n",
params->difficulty-1));
goto generate;
int dragx_dst, dragy_dst; /* src's closest orth island. */
grid_type todraw;
int dragging, drag_is_noline, nlines;
+
+ int cur_x, cur_y, cur_visible; /* cursor position */
+ int show_hints;
};
static char *ui_cancel_drag(game_ui *ui)
{
game_ui *ui = snew(game_ui);
ui_cancel_drag(ui);
+ ui->cur_x = state->islands[0].x;
+ ui->cur_y = state->islands[0].y;
+ ui->cur_visible = 0;
+ ui->show_hints = 0;
return ui;
}
grid_type *grid;
int *lv, *lh;
int started, dragging;
+ int show_hints;
};
static char *update_drag_dst(game_state *state, game_ui *ui, game_drawstate *ds,
if (button == LEFT_BUTTON || button == RIGHT_BUTTON) {
if (!INGRID(state, gx, gy)) return NULL;
+ ui->cur_visible = 0;
if ((ggrid & G_ISLAND) && !(ggrid & G_MARK)) {
ui->dragx_src = gx;
ui->dragy_src = gy;
ret = game_state_diff(state, solved);
free_game(solved);
return ret;
+ } else if (IS_CURSOR_MOVE(button)) {
+ ui->cur_visible = 1;
+ if (ui->dragging) {
+ int nx = ui->cur_x, ny = ui->cur_y;
+
+ move_cursor(button, &nx, &ny, state->w, state->h, 0);
+ update_drag_dst(state, ui, ds,
+ COORD(nx)+TILE_SIZE/2,
+ COORD(ny)+TILE_SIZE/2);
+ return finish_drag(state, ui);
+ } else {
+ int dx = (button == CURSOR_RIGHT) ? +1 : (button == CURSOR_LEFT) ? -1 : 0;
+ int dy = (button == CURSOR_DOWN) ? +1 : (button == CURSOR_UP) ? -1 : 0;
+ int dorthx = 1 - abs(dx), dorthy = 1 - abs(dy);
+ int dir, orth, nx = x, ny = y;
+
+ /* 'orthorder' is a tweak to ensure that if you press RIGHT and
+ * happen to move upwards, when you press LEFT you then tend
+ * downwards (rather than upwards again). */
+ int orthorder = (button == CURSOR_LEFT || button == CURSOR_UP) ? 1 : -1;
+
+ /* This attempts to find an island in the direction you're
+ * asking for, broadly speaking. If you ask to go right, for
+ * example, it'll look for islands to the right and slightly
+ * above or below your current horiz. position, allowing
+ * further above/below the further away it searches. */
+
+ assert(GRID(state, ui->cur_x, ui->cur_y) & G_ISLAND);
+ /* currently this is depth-first (so orthogonally-adjacent
+ * islands across the other side of the grid will be moved to
+ * before closer islands slightly offset). Swap the order of
+ * these two loops to change to breadth-first search. */
+ for (orth = 0; ; orth++) {
+ int oingrid = 0;
+ for (dir = 1; ; dir++) {
+ int dingrid = 0;
+
+ if (orth > dir) continue; /* only search in cone outwards. */
+
+ nx = ui->cur_x + dir*dx + orth*dorthx*orthorder;
+ ny = ui->cur_y + dir*dy + orth*dorthy*orthorder;
+ if (INGRID(state, nx, ny)) {
+ dingrid = oingrid = 1;
+ if (GRID(state, nx, ny) & G_ISLAND) goto found;
+ }
+
+ nx = ui->cur_x + dir*dx - orth*dorthx*orthorder;
+ ny = ui->cur_y + dir*dy - orth*dorthy*orthorder;
+ if (INGRID(state, nx, ny)) {
+ dingrid = oingrid = 1;
+ if (GRID(state, nx, ny) & G_ISLAND) goto found;
+ }
+
+ if (!dingrid) break;
+ }
+ if (!oingrid) return "";
+ }
+ /* not reached */
+
+found:
+ ui->cur_x = nx;
+ ui->cur_y = ny;
+ return "";
+ }
+ } else if (IS_CURSOR_SELECT(button)) {
+ if (!ui->cur_visible) {
+ ui->cur_visible = 1;
+ return "";
+ }
+ if (ui->dragging) {
+ ui_cancel_drag(ui);
+ if (ui->dragx_dst == -1 && ui->dragy_dst == -1) {
+ sprintf(buf, "M%d,%d", ui->cur_x, ui->cur_y);
+ return dupstr(buf);
+ } else
+ return "";
+ } else {
+ grid_type v = GRID(state, ui->cur_x, ui->cur_y);
+ if (v & G_ISLAND) {
+ ui->dragging = 1;
+ ui->dragx_src = ui->cur_x;
+ ui->dragy_src = ui->cur_y;
+ ui->dragx_dst = ui->dragy_dst = -1;
+ ui->drag_is_noline = (button == CURSOR_SELECT2) ? 1 : 0;
+ return "";
+ }
+ }
+ } else if (button == 'g' || button == 'G') {
+ ui->show_hints = 1 - ui->show_hints;
+ return "";
}
return NULL;
if (sscanf(move, "%d,%d,%d,%d,%d%n",
&x1, &y1, &x2, &y2, &nl, &n) != 5)
goto badmove;
+ if (!INGRID(ret, x1, y1) || !INGRID(ret, x2, y2))
+ goto badmove;
is1 = INDEX(ret, gridi, x1, y1);
is2 = INDEX(ret, gridi, x2, y2);
if (!is1 || !is2) goto badmove;
if (sscanf(move, "%d,%d,%d,%d%n",
&x1, &y1, &x2, &y2, &n) != 4)
goto badmove;
+ if (!INGRID(ret, x1, y1) || !INGRID(ret, x2, y2))
+ goto badmove;
is1 = INDEX(ret, gridi, x1, y1);
is2 = INDEX(ret, gridi, x2, y2);
if (!is1 || !is2) goto badmove;
if (sscanf(move, "%d,%d%n",
&x1, &y1, &n) != 2)
goto badmove;
+ if (!INGRID(ret, x1, y1))
+ goto badmove;
is1 = INDEX(ret, gridi, x1, y1);
if (!is1) goto badmove;
island_togglemark(is1);
ret[COL_SELECTED * 3 + 1] = 1.00F;
ret[COL_SELECTED * 3 + 2] = 0.25F;
+ ret[COL_CURSOR * 3 + 0] = min(ret[COL_BACKGROUND * 3 + 0] * 1.4F, 1.0F);
+ ret[COL_CURSOR * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 0.8F;
+ ret[COL_CURSOR * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 0.8F;
+
*ncolours = NCOLOURS;
return ret;
}
ds->lh = snewn(wh, int);
memset(ds->lv, 0, wh*sizeof(int));
memset(ds->lh, 0, wh*sizeof(int));
+ ds->show_hints = 0;
return ds;
}
#define OFFSET(thing) ((TILE_SIZE/2) - ((thing)/2))
-static void line_vert(drawing *dr, game_drawstate *ds,
- int ox, int oy, int col, grid_type v)
+static void lines_vert(drawing *dr, game_drawstate *ds,
+ int ox, int oy, int lv, int col, grid_type v)
{
- int lw = LINE_WIDTH;
+ int lw = LINE_WIDTH, gw = LINE_WIDTH, bw, i, loff;
+ while ((bw = lw * lv + gw * (lv+1)) > TILE_SIZE)
+ gw--;
+ loff = OFFSET(bw);
if (v & G_MARKV)
- draw_rect(dr, ox-lw, oy, lw*3, TILE_SIZE, COL_MARK);
- draw_rect(dr, ox, oy, lw, TILE_SIZE, col);
+ draw_rect(dr, ox + loff, oy, bw, TILE_SIZE, COL_MARK);
+ for (i = 0; i < lv; i++, loff += lw + gw)
+ draw_rect(dr, ox + loff + gw, oy, lw, TILE_SIZE, col);
}
-static void line_horiz(drawing *dr, game_drawstate *ds,
- int ox, int oy, int col, grid_type v)
+static void lines_horiz(drawing *dr, game_drawstate *ds,
+ int ox, int oy, int lh, int col, grid_type v)
{
- int lw = LINE_WIDTH;
+ int lw = LINE_WIDTH, gw = LINE_WIDTH, bw, i, loff;
+ while ((bw = lw * lh + gw * (lh+1)) > TILE_SIZE)
+ gw--;
+ loff = OFFSET(bw);
if (v & G_MARKH)
- draw_rect(dr, ox, oy-lw, TILE_SIZE, lw*3, COL_MARK);
- draw_rect(dr, ox, oy, TILE_SIZE, lw, col);
+ draw_rect(dr, ox, oy + loff, TILE_SIZE, bw, COL_MARK);
+ for (i = 0; i < lh; i++, loff += lw + gw)
+ draw_rect(dr, ox, oy + loff + gw, TILE_SIZE, lw, col);
}
static void line_cross(drawing *dr, game_drawstate *ds,
draw_line(dr, ox+off, oy, ox, oy+off, col);
}
-static void lines_lvlh(game_state *state, int x, int y, grid_type v,
+static int between_island(game_state *state, int sx, int sy, int dx, int dy)
+{
+ int x = sx - dx, y = sy - dy;
+
+ while (INGRID(state, x, y)) {
+ if (GRID(state, x, y) & G_ISLAND) goto found;
+ x -= dx; y -= dy;
+ }
+ return 0;
+found:
+ x = sx + dx, y = sy + dy;
+ while (INGRID(state, x, y)) {
+ if (GRID(state, x, y) & G_ISLAND) return 1;
+ x += dx; y += dy;
+ }
+ return 0;
+}
+
+static void lines_lvlh(game_state *state, game_ui *ui, int x, int y, grid_type v,
int *lv_r, int *lh_r)
{
int lh = 0, lv = 0;
if (v & G_LINEV) lv = INDEX(state,lines,x,y);
if (v & G_LINEH) lh = INDEX(state,lines,x,y);
-#ifdef DRAW_HINTS
- if (INDEX(state, possv, x, y) && !lv) {
- lv = INDEX(state, possv, x, y);
+ if (ui->show_hints) {
+ if (between_island(state, x, y, 0, 1) && !lv) lv = 1;
+ if (between_island(state, x, y, 1, 0) && !lh) lh = 1;
}
- if (INDEX(state, possh, x, y) && !lh) {
- lh = INDEX(state, possh, x, y);
- }
-#endif
/*debug(("lvlh: (%d,%d) v 0x%x lv %d lh %d.\n", x, y, v, lv, lh));*/
*lv_r = lv; *lh_r = lh;
}
#ifdef DRAW_DSF
int ts = TILE_SIZE/2;
int ox = COORD(x) + ts/2, oy = COORD(y) + ts/2;
- char str[10];
+ char str[32];
sprintf(str, "%d", dsf_canonify(state->solver->dsf, DINDEX(x,y)));
draw_text(dr, ox, oy, FONT_VARIABLE, ts,
game_state *state, game_drawstate *ds, game_ui *ui,
int x, int y, grid_type v, int lv, int lh)
{
- int lw = LINE_WIDTH, bw;
- int ox = COORD(x), oy = COORD(y), loff, i;
+ int ox = COORD(x), oy = COORD(y);
int vcol = (v & G_FLASH) ? COL_HIGHLIGHT :
(v & G_WARN) ? COL_WARNING : COL_FOREGROUND, hcol = vcol;
grid_type todraw = v & G_NOLINE;
}
draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE, COL_BACKGROUND);
+ /*if (v & G_CURSOR)
+ draw_rect(dr, ox+TILE_SIZE/4, oy+TILE_SIZE/4,
+ TILE_SIZE/2, TILE_SIZE/2, COL_CURSOR);*/
-#ifdef DRAW_HINTS
- if (INDEX(state, possv, x, y) && !(v & G_LINEV))
- vcol = COL_HINT;
- if (INDEX(state, possh, x, y) && !(v & G_LINEH))
- hcol = COL_HINT;
-#endif
+
+ if (ui->show_hints) {
+ if (between_island(state, x, y, 0, 1) && !(v & G_LINEV))
+ vcol = COL_HINT;
+ if (between_island(state, x, y, 1, 0) && !(v & G_LINEH))
+ hcol = COL_HINT;
+ }
#ifdef DRAW_GRID
draw_rect_outline(dr, ox, oy, TILE_SIZE, TILE_SIZE, COL_GRID);
#endif
line_cross(dr, ds, ox + TS8(1), oy + TS8(3), hcol, todraw);
line_cross(dr, ds, ox + TS8(5), oy + TS8(3), hcol, todraw);
}
- if (lv) {
- bw = (lv*2-1) * lw;
- for (i = 0, loff = OFFSET(bw); i < lv; i++, loff += lw*2)
- line_vert(dr, ds, ox + loff, oy, vcol, v);
- }
- if (lh) {
- bw = (lh*2-1) * lw;
- for (i = 0, loff = OFFSET(bw); i < lh; i++, loff += lw*2)
- line_horiz(dr, ds, ox, oy + loff, hcol, v);
- }
+ /* if we're drawing a real line and a hint, make sure we draw the real
+ * line on top. */
+ if (lv && vcol == COL_HINT) lines_vert(dr, ds, ox, oy, lv, vcol, v);
+ if (lh) lines_horiz(dr, ds, ox, oy, lh, hcol, v);
+ if (lv && vcol != COL_HINT) lines_vert(dr, ds, ox, oy, lv, vcol, v);
dsf_debug_draw(dr, state, ds, x, y);
draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
}
-#define ISLAND_RADIUS ((TILE_SIZE*13)/20)
+#define ISLAND_RADIUS ((TILE_SIZE*12)/20)
#define ISLAND_NUMSIZE(is) \
- (((is)->count < 10) ? TILE_SIZE : (TILE_SIZE*8)/10)
+ (((is)->count < 10) ? (TILE_SIZE*7)/10 : (TILE_SIZE*5)/10)
static void island_redraw(drawing *dr,
game_state *state, game_drawstate *ds,
int tcol = (v & G_FLASH) ? COL_HIGHLIGHT :
(v & G_WARN) ? COL_WARNING : COL_FOREGROUND;
int col = (v & G_ISSEL) ? COL_SELECTED : tcol;
- int bg = (v & G_MARK) ? COL_MARK : COL_BACKGROUND;
- char str[10];
+ int bg = (v & G_CURSOR) ? COL_CURSOR :
+ (v & G_MARK) ? COL_MARK : COL_BACKGROUND;
+ char str[32];
#ifdef DRAW_GRID
draw_rect_outline(dr, COORD(is->x), COORD(is->y),
} else
ds->dragging = 0;
+ if (ui->show_hints != ds->show_hints) {
+ force = 1;
+ ds->show_hints = ui->show_hints;
+ }
+
/* Draw all lines (and hints, if we want), but *not* islands. */
for (x = 0; x < ds->w; x++) {
for (y = 0; y < ds->h; y++) {
WITHIN(y,is_drag_src->y, is_drag_dst->y))
v |= G_ISSEL;
}
- lines_lvlh(state, x, y, v, &lv, &lh);
+ lines_lvlh(state, ui, x, y, v, &lv, &lh);
+
+ /*if (ui->cur_visible && ui->cur_x == x && ui->cur_y == y)
+ v |= G_CURSOR;*/
if (v != dsv ||
lv != INDEX(ds,lv,x,y) ||
if (island_impossible(is, v & G_MARK)) v |= G_WARN;
+ if (ui->cur_visible && ui->cur_x == is->x && ui->cur_y == is->y)
+ v |= G_CURSOR;
+
if ((v != GRID(ds, is->x, is->y)) || force || redraw) {
GRID(ds,is->x,is->y) = v;
island_redraw(dr, state, ds, is, v);
/* 10mm squares by default. */
game_compute_size(params, 1000, &pw, &ph);
- *x = pw / 100.0;
- *y = ph / 100.0;
+ *x = pw / 100.0F;
+ *y = ph / 100.0F;
}
static void game_print(drawing *dr, game_state *state, int ts)
int ink = print_mono_colour(dr, 0);
int paper = print_mono_colour(dr, 1);
int x, y, cx, cy, i, nl;
- int loff = ts/8;
+ int loff;
grid_type grid;
/* Ick: fake up `ds->tilesize' for macro expansion purposes */
/* I don't think this wants a border. */
/* Bridges */
+ loff = ts / (8 * sqrt((state->params.maxb - 1)));
print_line_width(dr, ts / 12);
for (x = 0; x < state->w; x++) {
for (y = 0; y < state->h; y++) {
if (grid & G_ISLAND) continue;
if (grid & G_LINEV) {
- if (nl > 1) {
- draw_line(dr, cx+ts/2-loff, cy, cx+ts/2-loff, cy+ts, ink);
- draw_line(dr, cx+ts/2+loff, cy, cx+ts/2+loff, cy+ts, ink);
- } else {
- draw_line(dr, cx+ts/2, cy, cx+ts/2, cy+ts, ink);
- }
+ for (i = 0; i < nl; i++)
+ draw_line(dr, cx+ts/2+(2*i-nl+1)*loff, cy,
+ cx+ts/2+(2*i-nl+1)*loff, cy+ts, ink);
}
if (grid & G_LINEH) {
- if (nl > 1) {
- draw_line(dr, cx, cy+ts/2-loff, cx+ts, cy+ts/2-loff, ink);
- draw_line(dr, cx, cy+ts/2+loff, cx+ts, cy+ts/2+loff, ink);
- } else {
- draw_line(dr, cx, cy+ts/2, cx+ts, cy+ts/2, ink);
- }
+ for (i = 0; i < nl; i++)
+ draw_line(dr, cx, cy+ts/2+(2*i-nl+1)*loff,
+ cx+ts, cy+ts/2+(2*i-nl+1)*loff, ink);
}
}
}
/* Islands */
for (i = 0; i < state->n_islands; i++) {
- char str[10];
+ char str[32];
struct island *is = &state->islands[i];
grid = GRID(state, is->x, is->y);
cx = COORD(is->x) + ts/2;
#endif
const struct game thegame = {
- "Bridges", "games.bridges",
+ "Bridges", "games.bridges", "bridges",
default_params,
game_fetch_preset,
decode_params,
dup_game,
free_game,
TRUE, solve_game,
- TRUE, game_text_format,
+ TRUE, game_can_format_as_text_now, game_text_format,
new_ui,
free_ui,
encode_ui,
TRUE, FALSE, game_print_size, game_print,
FALSE, /* wants_statusbar */
FALSE, game_timing_state,
- 0, /* flags */
+ REQUIRE_RBUTTON, /* flags */
};
/* vim: set shiftwidth=4 tabstop=8: */