mirror of
git://git.tartarus.org/simon/puzzles.git
synced 2025-04-21 16:05:44 -07:00
Fix antialiasing artifacts around edges of Bridges islands.
When an island changes colour (because it becomes locked or highlighted, or goes back to plain COL_FOREGROUND from one of those states), we were just redrawing a filled circle over the previous one, which only really worked before antialiasing was introduced. Fixed by reworking the entire drawing edifice to be grid-square based, so that every grid square is either redrawn in full or left alone. Grid squares come in two types - island and bridge - but a bridge square can have neighbouring islands overlap into it, and the bridges entering an island overlap the island square too, so we end up with quite a large collection of bitfields describing each square's contents, and some care must be taken to draw each square in the right order. [originally from svn r10282]
This commit is contained in:
Simon Tatham
602
bridges.c
602
bridges.c
@ -78,7 +78,6 @@
|
|||||||
|
|
||||||
/* Turn this on for hints about which lines are considered possibilities. */
|
/* Turn this on for hints about which lines are considered possibilities. */
|
||||||
#undef DRAW_GRID
|
#undef DRAW_GRID
|
||||||
#undef DRAW_DSF
|
|
||||||
|
|
||||||
/* --- structures for params, state, etc. --- */
|
/* --- structures for params, state, etc. --- */
|
||||||
|
|
||||||
@ -122,12 +121,8 @@ struct game_params {
|
|||||||
#define G_NOLINEH 0x0040
|
#define G_NOLINEH 0x0040
|
||||||
#define G_NOLINE (G_NOLINEV|G_NOLINEH)
|
#define G_NOLINE (G_NOLINEV|G_NOLINEH)
|
||||||
|
|
||||||
/* flags used by the drawstate */
|
/* flags used by the error checker */
|
||||||
#define G_ISSEL 0x0080
|
#define G_WARN 0x0080
|
||||||
#define G_REDRAW 0x0100
|
|
||||||
#define G_FLASH 0x0200
|
|
||||||
#define G_WARN 0x0400
|
|
||||||
#define G_CURSOR 0x0800
|
|
||||||
|
|
||||||
/* flags used by the solver etc. */
|
/* flags used by the solver etc. */
|
||||||
#define G_SWEEP 0x1000
|
#define G_SWEEP 0x1000
|
||||||
@ -2152,12 +2147,89 @@ static void game_changed_state(game_ui *ui, const game_state *oldstate,
|
|||||||
struct game_drawstate {
|
struct game_drawstate {
|
||||||
int tilesize;
|
int tilesize;
|
||||||
int w, h;
|
int w, h;
|
||||||
grid_type *grid;
|
unsigned long *grid, *newgrid;
|
||||||
int *lv, *lh;
|
int *lv, *lh;
|
||||||
int started, dragging;
|
int started, dragging;
|
||||||
int show_hints;
|
|
||||||
};
|
};
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The contents of ds->grid are complicated, because of the circular
|
||||||
|
* islands which overlap their own grid square into neighbouring
|
||||||
|
* squares. An island square can contain pieces of the bridges in all
|
||||||
|
* directions, and conversely a bridge square can be intruded on by
|
||||||
|
* islands from any direction.
|
||||||
|
*
|
||||||
|
* So we define one group of flags describing what's important about
|
||||||
|
* an island, and another describing a bridge. Island squares' entries
|
||||||
|
* in ds->grid contain one of the former and four of the latter; bridge
|
||||||
|
* squares, four of the former and _two_ of the latter - because a
|
||||||
|
* horizontal and vertical 'bridge' can cross, when one of them is a
|
||||||
|
* 'no bridge here' pencil mark.
|
||||||
|
*
|
||||||
|
* Bridge flags need to indicate 0-4 actual bridges (3 bits), a 'no
|
||||||
|
* bridge' row of crosses, or a grey hint line; that's 7
|
||||||
|
* possibilities, so 3 bits suffice. But then we also need to vary the
|
||||||
|
* colours: the bridges can turn COL_WARNING if they're part of a loop
|
||||||
|
* in no-loops mode, COL_HIGHLIGHT during a victory flash, or
|
||||||
|
* COL_SELECTED if they're the bridge the user is currently dragging,
|
||||||
|
* so that's 2 more bits for foreground colour. Also bridges can be
|
||||||
|
* backed by COL_MARK if they're locked by the user, so that's one
|
||||||
|
* more bit, making 6 bits per bridge direction.
|
||||||
|
*
|
||||||
|
* Island flags omit the actual island clue (it never changes during
|
||||||
|
* the game, so doesn't have to be stored in ds->grid to check against
|
||||||
|
* the previous version), so they just need to include 2 bits for
|
||||||
|
* foreground colour (an island can be normal, COL_HIGHLIGHT during
|
||||||
|
* victory, COL_WARNING if its clue is unsatisfiable, or COL_SELECTED
|
||||||
|
* if it's part of the user's drag) and 2 bits for background (normal,
|
||||||
|
* COL_MARK for a locked island, COL_CURSOR for the keyboard cursor).
|
||||||
|
* That's 4 bits per island direction. We must also indicate whether
|
||||||
|
* no island is present at all (in the case where the island is
|
||||||
|
* potentially intruding into the side of a line square), which we do
|
||||||
|
* using the unused 4th value of the background field.
|
||||||
|
*
|
||||||
|
* So an island square needs 4 + 4*6 = 28 bits, while a bridge square
|
||||||
|
* needs 4*4 + 2*6 = 28 bits too. Both only just fit in 32 bits, which
|
||||||
|
* is handy, because otherwise we'd have to faff around forever with
|
||||||
|
* little structs!
|
||||||
|
*/
|
||||||
|
/* Flags for line data */
|
||||||
|
#define DL_COUNTMASK 0x07
|
||||||
|
#define DL_COUNT_CROSS 0x06
|
||||||
|
#define DL_COUNT_HINT 0x07
|
||||||
|
#define DL_COLMASK 0x18
|
||||||
|
#define DL_COL_NORMAL 0x00
|
||||||
|
#define DL_COL_WARNING 0x08
|
||||||
|
#define DL_COL_FLASH 0x10
|
||||||
|
#define DL_COL_SELECTED 0x18
|
||||||
|
#define DL_LOCK 0x20
|
||||||
|
#define DL_MASK 0x3F
|
||||||
|
/* Flags for island data */
|
||||||
|
#define DI_COLMASK 0x03
|
||||||
|
#define DI_COL_NORMAL 0x00
|
||||||
|
#define DI_COL_FLASH 0x01
|
||||||
|
#define DI_COL_WARNING 0x02
|
||||||
|
#define DI_COL_SELECTED 0x03
|
||||||
|
#define DI_BGMASK 0x0C
|
||||||
|
#define DI_BG_NO_ISLAND 0x00
|
||||||
|
#define DI_BG_NORMAL 0x04
|
||||||
|
#define DI_BG_MARK 0x08
|
||||||
|
#define DI_BG_CURSOR 0x0C
|
||||||
|
#define DI_MASK 0x0F
|
||||||
|
/* Shift counts for the format of a 32-bit word in an island square */
|
||||||
|
#define D_I_ISLAND_SHIFT 0
|
||||||
|
#define D_I_LINE_SHIFT_L 4
|
||||||
|
#define D_I_LINE_SHIFT_R 10
|
||||||
|
#define D_I_LINE_SHIFT_U 16
|
||||||
|
#define D_I_LINE_SHIFT_D 24
|
||||||
|
/* Shift counts for the format of a 32-bit word in a line square */
|
||||||
|
#define D_L_ISLAND_SHIFT_L 0
|
||||||
|
#define D_L_ISLAND_SHIFT_R 4
|
||||||
|
#define D_L_ISLAND_SHIFT_U 8
|
||||||
|
#define D_L_ISLAND_SHIFT_D 12
|
||||||
|
#define D_L_LINE_SHIFT_H 16
|
||||||
|
#define D_L_LINE_SHIFT_V 22
|
||||||
|
|
||||||
static char *update_drag_dst(const game_state *state, game_ui *ui,
|
static char *update_drag_dst(const game_state *state, game_ui *ui,
|
||||||
const game_drawstate *ds, int nx, int ny)
|
const game_drawstate *ds, int nx, int ny)
|
||||||
{
|
{
|
||||||
@ -2543,18 +2615,21 @@ static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
|
|||||||
{
|
{
|
||||||
struct game_drawstate *ds = snew(struct game_drawstate);
|
struct game_drawstate *ds = snew(struct game_drawstate);
|
||||||
int wh = state->w*state->h;
|
int wh = state->w*state->h;
|
||||||
|
int i;
|
||||||
|
|
||||||
ds->tilesize = 0;
|
ds->tilesize = 0;
|
||||||
ds->w = state->w;
|
ds->w = state->w;
|
||||||
ds->h = state->h;
|
ds->h = state->h;
|
||||||
ds->started = 0;
|
ds->started = 0;
|
||||||
ds->grid = snewn(wh, grid_type);
|
ds->dragging = 0;
|
||||||
memset(ds->grid, -1, wh*sizeof(grid_type));
|
ds->grid = snewn(wh, unsigned long);
|
||||||
|
for (i = 0; i < wh; i++)
|
||||||
|
ds->grid[i] = ~0UL;
|
||||||
|
ds->newgrid = snewn(wh, unsigned long);
|
||||||
ds->lv = snewn(wh, int);
|
ds->lv = snewn(wh, int);
|
||||||
ds->lh = snewn(wh, int);
|
ds->lh = snewn(wh, int);
|
||||||
memset(ds->lv, 0, wh*sizeof(int));
|
memset(ds->lv, 0, wh*sizeof(int));
|
||||||
memset(ds->lh, 0, wh*sizeof(int));
|
memset(ds->lh, 0, wh*sizeof(int));
|
||||||
ds->show_hints = 0;
|
|
||||||
|
|
||||||
return ds;
|
return ds;
|
||||||
}
|
}
|
||||||
@ -2563,6 +2638,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
|
|||||||
{
|
{
|
||||||
sfree(ds->lv);
|
sfree(ds->lv);
|
||||||
sfree(ds->lh);
|
sfree(ds->lh);
|
||||||
|
sfree(ds->newgrid);
|
||||||
sfree(ds->grid);
|
sfree(ds->grid);
|
||||||
sfree(ds);
|
sfree(ds);
|
||||||
}
|
}
|
||||||
@ -2572,40 +2648,6 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds)
|
|||||||
|
|
||||||
#define OFFSET(thing) ((TILE_SIZE/2) - ((thing)/2))
|
#define OFFSET(thing) ((TILE_SIZE/2) - ((thing)/2))
|
||||||
|
|
||||||
static void lines_vert(drawing *dr, game_drawstate *ds,
|
|
||||||
int ox, int oy, int lv, int col, grid_type v)
|
|
||||||
{
|
|
||||||
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 + 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 lines_horiz(drawing *dr, game_drawstate *ds,
|
|
||||||
int ox, int oy, int lh, int col, grid_type v)
|
|
||||||
{
|
|
||||||
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 + 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,
|
|
||||||
int ox, int oy, int col, grid_type v)
|
|
||||||
{
|
|
||||||
int off = TS8(2);
|
|
||||||
draw_line(dr, ox, oy, ox+off, oy+off, col);
|
|
||||||
draw_line(dr, ox+off, oy, ox, oy+off, col);
|
|
||||||
}
|
|
||||||
|
|
||||||
static int between_island(const game_state *state, int sx, int sy,
|
static int between_island(const game_state *state, int sx, int sy,
|
||||||
int dx, int dy)
|
int dx, int dy)
|
||||||
{
|
{
|
||||||
@ -2641,107 +2683,220 @@ static void lines_lvlh(const game_state *state, const game_ui *ui,
|
|||||||
*lv_r = lv; *lh_r = lh;
|
*lv_r = lv; *lh_r = lh;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void dsf_debug_draw(drawing *dr,
|
static void draw_cross(drawing *dr, game_drawstate *ds,
|
||||||
const game_state *state, game_drawstate *ds,
|
int ox, int oy, int col)
|
||||||
int x, int y)
|
|
||||||
{
|
{
|
||||||
#ifdef DRAW_DSF
|
int off = TS8(2);
|
||||||
int ts = TILE_SIZE/2;
|
draw_line(dr, ox, oy, ox+off, oy+off, col);
|
||||||
int ox = COORD(x) + ts/2, oy = COORD(y) + ts/2;
|
draw_line(dr, ox+off, oy, ox, oy+off, col);
|
||||||
char str[32];
|
|
||||||
|
|
||||||
sprintf(str, "%d", dsf_canonify(state->solver->dsf, DINDEX(x,y)));
|
|
||||||
draw_text(dr, ox, oy, FONT_VARIABLE, ts,
|
|
||||||
ALIGN_VCENTRE | ALIGN_HCENTRE, COL_WARNING, str);
|
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
|
|
||||||
static void lines_redraw(drawing *dr, const game_state *state,
|
static void draw_general_line(drawing *dr, game_drawstate *ds,
|
||||||
game_drawstate *ds, const game_ui *ui,
|
int ox, int oy, int fx, int fy, int ax, int ay,
|
||||||
int x, int y, grid_type v, int lv, int lh)
|
int len, unsigned long ldata, int which)
|
||||||
{
|
{
|
||||||
int ox = COORD(x), oy = COORD(y);
|
/*
|
||||||
int vcol = (v & G_FLASH) ? COL_HIGHLIGHT :
|
* Draw one direction of lines in a square. To permit the same
|
||||||
(v & G_WARN) ? COL_WARNING : COL_FOREGROUND, hcol = vcol;
|
* code to handle horizontal and vertical lines, fx,fy are the
|
||||||
grid_type todraw = v & G_NOLINE;
|
* 'forward' direction (along the lines) and ax,ay are the
|
||||||
|
* 'across' direction.
|
||||||
|
*
|
||||||
|
* We draw the white background for a locked bridge if (which &
|
||||||
|
* 1), and draw the bridges themselves if (which & 2). This
|
||||||
|
* permits us to get two overlapping locked bridges right without
|
||||||
|
* one of them erasing part of the other.
|
||||||
|
*/
|
||||||
|
int fg;
|
||||||
|
|
||||||
if (v & G_ISSEL) {
|
fg = ((ldata & DL_COUNTMASK) == DL_COUNT_HINT ? COL_HINT :
|
||||||
if (ui->todraw & G_FLAGSH) hcol = COL_SELECTED;
|
(ldata & DL_COLMASK) == DL_COL_SELECTED ? COL_SELECTED :
|
||||||
if (ui->todraw & G_FLAGSV) vcol = COL_SELECTED;
|
(ldata & DL_COLMASK) == DL_COL_FLASH ? COL_HIGHLIGHT :
|
||||||
todraw |= ui->todraw;
|
(ldata & DL_COLMASK) == DL_COL_WARNING ? COL_WARNING :
|
||||||
|
COL_FOREGROUND);
|
||||||
|
|
||||||
|
if ((ldata & DL_COUNTMASK) == DL_COUNT_CROSS) {
|
||||||
|
draw_cross(dr, ds,
|
||||||
|
ox + TS8(1)*fx + TS8(3)*ax,
|
||||||
|
oy + TS8(1)*fy + TS8(3)*ay, fg);
|
||||||
|
draw_cross(dr, ds,
|
||||||
|
ox + TS8(5)*fx + TS8(3)*ax,
|
||||||
|
oy + TS8(5)*fy + TS8(3)*ay, fg);
|
||||||
|
} else if ((ldata & DL_COUNTMASK) != 0) {
|
||||||
|
int lh, lw, gw, bw, i, loff;
|
||||||
|
|
||||||
|
lh = (ldata & DL_COUNTMASK);
|
||||||
|
if (lh == DL_COUNT_HINT)
|
||||||
|
lh = 1;
|
||||||
|
|
||||||
|
lw = gw = LINE_WIDTH;
|
||||||
|
while ((bw = lw * lh + gw * (lh+1)) > TILE_SIZE)
|
||||||
|
gw--;
|
||||||
|
|
||||||
|
loff = OFFSET(bw);
|
||||||
|
|
||||||
|
if (which & 1) {
|
||||||
|
if ((ldata & DL_LOCK) && fg != COL_HINT)
|
||||||
|
draw_rect(dr, ox + loff*ax, oy + loff*ay,
|
||||||
|
len*fx+bw*ax, len*fy+bw*ay, COL_MARK);
|
||||||
|
}
|
||||||
|
if (which & 2) {
|
||||||
|
for (i = 0; i < lh; i++, loff += lw + gw)
|
||||||
|
draw_rect(dr, ox + (loff+gw)*ax, oy + (loff+gw)*ay,
|
||||||
|
len*fx+lw*ax, len*fy+lw*ay, fg);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE, COL_BACKGROUND);
|
static void draw_hline(drawing *dr, game_drawstate *ds,
|
||||||
/*if (v & G_CURSOR)
|
int ox, int oy, int w, unsigned long vdata, int which)
|
||||||
draw_rect(dr, ox+TILE_SIZE/4, oy+TILE_SIZE/4,
|
{
|
||||||
TILE_SIZE/2, TILE_SIZE/2, COL_CURSOR);*/
|
draw_general_line(dr, ds, ox, oy, 1, 0, 0, 1, w, vdata, which);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void draw_vline(drawing *dr, game_drawstate *ds,
|
||||||
if (ui->show_hints) {
|
int ox, int oy, int h, unsigned long vdata, int which)
|
||||||
if (between_island(state, x, y, 0, 1) && !(v & G_LINEV))
|
{
|
||||||
vcol = COL_HINT;
|
draw_general_line(dr, ds, ox, oy, 0, 1, 1, 0, h, vdata, which);
|
||||||
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
|
|
||||||
|
|
||||||
if (todraw & G_NOLINEV) {
|
|
||||||
line_cross(dr, ds, ox + TS8(3), oy + TS8(1), vcol, todraw);
|
|
||||||
line_cross(dr, ds, ox + TS8(3), oy + TS8(5), vcol, todraw);
|
|
||||||
}
|
|
||||||
if (todraw & G_NOLINEH) {
|
|
||||||
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 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*12)/20)
|
#define ISLAND_RADIUS ((TILE_SIZE*12)/20)
|
||||||
#define ISLAND_NUMSIZE(is) \
|
#define ISLAND_NUMSIZE(clue) \
|
||||||
(((is)->count < 10) ? (TILE_SIZE*7)/10 : (TILE_SIZE*5)/10)
|
(((clue) < 10) ? (TILE_SIZE*7)/10 : (TILE_SIZE*5)/10)
|
||||||
|
|
||||||
static void island_redraw(drawing *dr,
|
static void draw_island(drawing *dr, game_drawstate *ds,
|
||||||
const game_state *state, game_drawstate *ds,
|
int ox, int oy, int clue, unsigned long idata)
|
||||||
struct island *is, grid_type v)
|
|
||||||
{
|
{
|
||||||
/* These overlap the edges of their squares, which is why they're drawn later.
|
int half, orad, irad, fg, bg;
|
||||||
* We know they can't overlap each other because they're not allowed within 2
|
|
||||||
* squares of each other. */
|
|
||||||
int half = TILE_SIZE/2;
|
|
||||||
int ox = COORD(is->x) + half, oy = COORD(is->y) + half;
|
|
||||||
int orad = ISLAND_RADIUS, irad = orad - LINE_WIDTH;
|
|
||||||
int updatesz = orad*2+1;
|
|
||||||
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_CURSOR) ? COL_CURSOR :
|
|
||||||
(v & G_MARK) ? COL_MARK : COL_BACKGROUND;
|
|
||||||
char str[32];
|
|
||||||
|
|
||||||
#ifdef DRAW_GRID
|
if ((idata & DI_BGMASK) == DI_BG_NO_ISLAND)
|
||||||
draw_rect_outline(dr, COORD(is->x), COORD(is->y),
|
return;
|
||||||
TILE_SIZE, TILE_SIZE, COL_GRID);
|
|
||||||
#endif
|
half = TILE_SIZE/2;
|
||||||
|
orad = ISLAND_RADIUS;
|
||||||
|
irad = orad - LINE_WIDTH;
|
||||||
|
fg = ((idata & DI_COLMASK) == DI_COL_SELECTED ? COL_SELECTED :
|
||||||
|
(idata & DI_COLMASK) == DI_COL_WARNING ? COL_WARNING :
|
||||||
|
(idata & DI_COLMASK) == DI_COL_FLASH ? COL_HIGHLIGHT :
|
||||||
|
COL_FOREGROUND);
|
||||||
|
bg = ((idata & DI_BGMASK) == DI_BG_CURSOR ? COL_CURSOR :
|
||||||
|
(idata & DI_BGMASK) == DI_BG_MARK ? COL_MARK :
|
||||||
|
COL_BACKGROUND);
|
||||||
|
|
||||||
/* draw a thick circle */
|
/* draw a thick circle */
|
||||||
draw_circle(dr, ox, oy, orad, col, col);
|
draw_circle(dr, ox+half, oy+half, orad, fg, fg);
|
||||||
draw_circle(dr, ox, oy, irad, bg, bg);
|
draw_circle(dr, ox+half, oy+half, irad, bg, bg);
|
||||||
|
|
||||||
sprintf(str, "%d", is->count);
|
if (clue > 0) {
|
||||||
draw_text(dr, ox, oy, FONT_VARIABLE, ISLAND_NUMSIZE(is),
|
char str[32];
|
||||||
ALIGN_VCENTRE | ALIGN_HCENTRE, tcol, str);
|
int textcolour = (fg == COL_SELECTED ? COL_FOREGROUND : fg);
|
||||||
|
sprintf(str, "%d", clue);
|
||||||
|
draw_text(dr, ox+half, oy+half, FONT_VARIABLE, ISLAND_NUMSIZE(clue),
|
||||||
|
ALIGN_VCENTRE | ALIGN_HCENTRE, textcolour, str);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
dsf_debug_draw(dr, state, ds, is->x, is->y);
|
static void draw_island_tile(drawing *dr, game_drawstate *ds,
|
||||||
draw_update(dr, ox - orad, oy - orad, updatesz, updatesz);
|
int x, int y, int clue, unsigned long data)
|
||||||
|
{
|
||||||
|
int ox = COORD(x), oy = COORD(y);
|
||||||
|
int which;
|
||||||
|
|
||||||
|
clip(dr, ox, oy, TILE_SIZE, TILE_SIZE);
|
||||||
|
draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE, COL_BACKGROUND);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Because of the possibility of incoming bridges just about
|
||||||
|
* meeting at one corner, we must split the line-drawing into
|
||||||
|
* background and foreground segments.
|
||||||
|
*/
|
||||||
|
for (which = 1; which <= 2; which <<= 1) {
|
||||||
|
draw_hline(dr, ds, ox, oy, TILE_SIZE/2,
|
||||||
|
(data >> D_I_LINE_SHIFT_L) & DL_MASK, which);
|
||||||
|
draw_hline(dr, ds, ox + TILE_SIZE - TILE_SIZE/2, oy, TILE_SIZE/2,
|
||||||
|
(data >> D_I_LINE_SHIFT_R) & DL_MASK, which);
|
||||||
|
draw_vline(dr, ds, ox, oy, TILE_SIZE/2,
|
||||||
|
(data >> D_I_LINE_SHIFT_U) & DL_MASK, which);
|
||||||
|
draw_vline(dr, ds, ox, oy + TILE_SIZE - TILE_SIZE/2, TILE_SIZE/2,
|
||||||
|
(data >> D_I_LINE_SHIFT_D) & DL_MASK, which);
|
||||||
|
}
|
||||||
|
draw_island(dr, ds, ox, oy, clue, (data >> D_I_ISLAND_SHIFT) & DI_MASK);
|
||||||
|
|
||||||
|
unclip(dr);
|
||||||
|
draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void draw_line_tile(drawing *dr, game_drawstate *ds,
|
||||||
|
int x, int y, unsigned long data)
|
||||||
|
{
|
||||||
|
int ox = COORD(x), oy = COORD(y);
|
||||||
|
unsigned long hdata, vdata;
|
||||||
|
|
||||||
|
clip(dr, ox, oy, TILE_SIZE, TILE_SIZE);
|
||||||
|
draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE, COL_BACKGROUND);
|
||||||
|
|
||||||
|
/*
|
||||||
|
* We have to think about which of the horizontal and vertical
|
||||||
|
* line to draw first, if both exist.
|
||||||
|
*
|
||||||
|
* The rule is that hint lines are drawn at the bottom, then
|
||||||
|
* NOLINE crosses, then actual bridges. The enumeration in the
|
||||||
|
* DL_COUNTMASK field is set up so that this drops out of a
|
||||||
|
* straight comparison between the two.
|
||||||
|
*
|
||||||
|
* Since lines crossing in this type of square cannot both be
|
||||||
|
* actual bridges, there's no need to pass a nontrivial 'which'
|
||||||
|
* parameter to draw_[hv]line.
|
||||||
|
*/
|
||||||
|
hdata = (data >> D_L_LINE_SHIFT_H) & DL_MASK;
|
||||||
|
vdata = (data >> D_L_LINE_SHIFT_V) & DL_MASK;
|
||||||
|
if ((hdata & DL_COUNTMASK) > (vdata & DL_COUNTMASK)) {
|
||||||
|
draw_hline(dr, ds, ox, oy, TILE_SIZE, hdata, 3);
|
||||||
|
draw_vline(dr, ds, ox, oy, TILE_SIZE, vdata, 3);
|
||||||
|
} else {
|
||||||
|
draw_vline(dr, ds, ox, oy, TILE_SIZE, vdata, 3);
|
||||||
|
draw_hline(dr, ds, ox, oy, TILE_SIZE, hdata, 3);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The islands drawn at the edges of a line tile don't need clue
|
||||||
|
* numbers.
|
||||||
|
*/
|
||||||
|
draw_island(dr, ds, ox - TILE_SIZE, oy, -1,
|
||||||
|
(data >> D_L_ISLAND_SHIFT_L) & DI_MASK);
|
||||||
|
draw_island(dr, ds, ox + TILE_SIZE, oy, -1,
|
||||||
|
(data >> D_L_ISLAND_SHIFT_R) & DI_MASK);
|
||||||
|
draw_island(dr, ds, ox, oy - TILE_SIZE, -1,
|
||||||
|
(data >> D_L_ISLAND_SHIFT_U) & DI_MASK);
|
||||||
|
draw_island(dr, ds, ox, oy + TILE_SIZE, -1,
|
||||||
|
(data >> D_L_ISLAND_SHIFT_D) & DI_MASK);
|
||||||
|
|
||||||
|
unclip(dr);
|
||||||
|
draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void draw_edge_tile(drawing *dr, game_drawstate *ds,
|
||||||
|
int x, int y, int dx, int dy, unsigned long data)
|
||||||
|
{
|
||||||
|
int ox = COORD(x), oy = COORD(y);
|
||||||
|
int cx = ox, cy = oy, cw = TILE_SIZE, ch = TILE_SIZE;
|
||||||
|
|
||||||
|
if (dy) {
|
||||||
|
if (dy > 0)
|
||||||
|
cy += TILE_SIZE/2;
|
||||||
|
ch -= TILE_SIZE/2;
|
||||||
|
} else {
|
||||||
|
if (dx > 0)
|
||||||
|
cx += TILE_SIZE/2;
|
||||||
|
cw -= TILE_SIZE/2;
|
||||||
|
}
|
||||||
|
clip(dr, cx, cy, cw, ch);
|
||||||
|
draw_rect(dr, cx, cy, cw, ch, COL_BACKGROUND);
|
||||||
|
|
||||||
|
draw_island(dr, ds, ox + TILE_SIZE*dx, oy + TILE_SIZE*dy, -1,
|
||||||
|
(data >> D_I_ISLAND_SHIFT) & DI_MASK);
|
||||||
|
|
||||||
|
unclip(dr);
|
||||||
|
draw_update(dr, cx, cy, cw, ch);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void game_redraw(drawing *dr, game_drawstate *ds,
|
static void game_redraw(drawing *dr, game_drawstate *ds,
|
||||||
@ -2749,13 +2904,13 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
|
|||||||
int dir, const game_ui *ui,
|
int dir, const game_ui *ui,
|
||||||
float animtime, float flashtime)
|
float animtime, float flashtime)
|
||||||
{
|
{
|
||||||
int x, y, force = 0, i, j, redraw, lv, lh;
|
int x, y, lv, lh;
|
||||||
grid_type v, dsv, flash = 0;
|
grid_type v, flash = 0;
|
||||||
struct island *is, *is_drag_src = NULL, *is_drag_dst = NULL;
|
struct island *is, *is_drag_src = NULL, *is_drag_dst = NULL;
|
||||||
|
|
||||||
if (flashtime) {
|
if (flashtime) {
|
||||||
int f = (int)(flashtime * 5 / FLASH_TIME);
|
int f = (int)(flashtime * 5 / FLASH_TIME);
|
||||||
if (f == 1 || f == 3) flash = G_FLASH;
|
if (f == 1 || f == 3) flash = TRUE;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Clear screen, if required. */
|
/* Clear screen, if required. */
|
||||||
@ -2773,7 +2928,6 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
|
|||||||
TILE_SIZE * ds->w + 2 * BORDER,
|
TILE_SIZE * ds->w + 2 * BORDER,
|
||||||
TILE_SIZE * ds->h + 2 * BORDER);
|
TILE_SIZE * ds->h + 2 * BORDER);
|
||||||
ds->started = 1;
|
ds->started = 1;
|
||||||
force = 1;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ui->dragx_src != -1 && ui->dragy_src != -1) {
|
if (ui->dragx_src != -1 && ui->dragy_src != -1) {
|
||||||
@ -2787,70 +2941,146 @@ static void game_redraw(drawing *dr, game_drawstate *ds,
|
|||||||
} else
|
} else
|
||||||
ds->dragging = 0;
|
ds->dragging = 0;
|
||||||
|
|
||||||
if (ui->show_hints != ds->show_hints) {
|
/*
|
||||||
force = 1;
|
* Set up ds->newgrid with the current grid contents.
|
||||||
ds->show_hints = ui->show_hints;
|
*/
|
||||||
}
|
for (x = 0; x < ds->w; x++)
|
||||||
|
for (y = 0; y < ds->h; y++)
|
||||||
|
INDEX(ds,newgrid,x,y) = 0;
|
||||||
|
|
||||||
/* Draw all lines (and hints, if we want), but *not* islands. */
|
|
||||||
for (x = 0; x < ds->w; x++) {
|
for (x = 0; x < ds->w; x++) {
|
||||||
for (y = 0; y < ds->h; y++) {
|
for (y = 0; y < ds->h; y++) {
|
||||||
v = GRID(state, x, y) | flash;
|
v = GRID(state, x, y);
|
||||||
dsv = GRID(ds,x,y) & ~G_REDRAW;
|
|
||||||
|
|
||||||
if (v & G_ISLAND) continue;
|
if (v & G_ISLAND) {
|
||||||
|
/*
|
||||||
|
* An island square. Compute the drawing data for the
|
||||||
|
* island, and put it in this square and surrounding
|
||||||
|
* squares.
|
||||||
|
*/
|
||||||
|
unsigned long idata = 0;
|
||||||
|
|
||||||
if (is_drag_dst) {
|
is = INDEX(state, gridi, x, y);
|
||||||
if (WITHIN(x,is_drag_src->x, is_drag_dst->x) &&
|
|
||||||
WITHIN(y,is_drag_src->y, is_drag_dst->y))
|
if (flash)
|
||||||
v |= G_ISSEL;
|
idata |= DI_COL_FLASH;
|
||||||
|
if (is_drag_src && (is == is_drag_src ||
|
||||||
|
(is_drag_dst && is == is_drag_dst)))
|
||||||
|
idata |= DI_COL_SELECTED;
|
||||||
|
else if (island_impossible(is, v & G_MARK))
|
||||||
|
idata |= DI_COL_WARNING;
|
||||||
|
else
|
||||||
|
idata |= DI_COL_NORMAL;
|
||||||
|
|
||||||
|
if (ui->cur_visible &&
|
||||||
|
ui->cur_x == is->x && ui->cur_y == is->y)
|
||||||
|
idata |= DI_BG_CURSOR;
|
||||||
|
else if (v & G_MARK)
|
||||||
|
idata |= DI_BG_MARK;
|
||||||
|
else
|
||||||
|
idata |= DI_BG_NORMAL;
|
||||||
|
|
||||||
|
INDEX(ds,newgrid,x,y) |= idata << D_I_ISLAND_SHIFT;
|
||||||
|
if (x > 0 && !(GRID(state,x-1,y) & G_ISLAND))
|
||||||
|
INDEX(ds,newgrid,x-1,y) |= idata << D_L_ISLAND_SHIFT_R;
|
||||||
|
if (x+1 < state->w && !(GRID(state,x+1,y) & G_ISLAND))
|
||||||
|
INDEX(ds,newgrid,x+1,y) |= idata << D_L_ISLAND_SHIFT_L;
|
||||||
|
if (y > 0 && !(GRID(state,x,y-1) & G_ISLAND))
|
||||||
|
INDEX(ds,newgrid,x,y-1) |= idata << D_L_ISLAND_SHIFT_D;
|
||||||
|
if (y+1 < state->h && !(GRID(state,x,y+1) & G_ISLAND))
|
||||||
|
INDEX(ds,newgrid,x,y+1) |= idata << D_L_ISLAND_SHIFT_U;
|
||||||
|
} else {
|
||||||
|
unsigned long hdata, vdata;
|
||||||
|
int selh = FALSE, selv = FALSE;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* A line (non-island) square. Compute the drawing
|
||||||
|
* data for any horizontal and vertical lines in the
|
||||||
|
* square, and put them in this square's entry and
|
||||||
|
* optionally those for neighbouring islands too.
|
||||||
|
*/
|
||||||
|
|
||||||
|
if (is_drag_dst &&
|
||||||
|
WITHIN(x,is_drag_src->x, is_drag_dst->x) &&
|
||||||
|
WITHIN(y,is_drag_src->y, is_drag_dst->y)) {
|
||||||
|
if (is_drag_src->x != is_drag_dst->x)
|
||||||
|
selh = TRUE;
|
||||||
|
else
|
||||||
|
selv = TRUE;
|
||||||
|
}
|
||||||
|
lines_lvlh(state, ui, x, y, v, &lv, &lh);
|
||||||
|
|
||||||
|
hdata = (v & G_NOLINEH ? DL_COUNT_CROSS :
|
||||||
|
v & G_LINEH ? lh :
|
||||||
|
(ui->show_hints &&
|
||||||
|
between_island(state,x,y,1,0)) ? DL_COUNT_HINT : 0);
|
||||||
|
vdata = (v & G_NOLINEV ? DL_COUNT_CROSS :
|
||||||
|
v & G_LINEV ? lv :
|
||||||
|
(ui->show_hints &&
|
||||||
|
between_island(state,x,y,0,1)) ? DL_COUNT_HINT : 0);
|
||||||
|
|
||||||
|
hdata |= (flash ? DL_COL_FLASH :
|
||||||
|
v & G_WARN ? DL_COL_WARNING :
|
||||||
|
selh ? DL_COL_SELECTED :
|
||||||
|
DL_COL_NORMAL);
|
||||||
|
vdata |= (flash ? DL_COL_FLASH :
|
||||||
|
v & G_WARN ? DL_COL_WARNING :
|
||||||
|
selv ? DL_COL_SELECTED :
|
||||||
|
DL_COL_NORMAL);
|
||||||
|
|
||||||
|
if (v & G_MARKH)
|
||||||
|
hdata |= DL_LOCK;
|
||||||
|
if (v & G_MARKV)
|
||||||
|
vdata |= DL_LOCK;
|
||||||
|
|
||||||
|
INDEX(ds,newgrid,x,y) |= hdata << D_L_LINE_SHIFT_H;
|
||||||
|
INDEX(ds,newgrid,x,y) |= vdata << D_L_LINE_SHIFT_V;
|
||||||
|
if (x > 0 && (GRID(state,x-1,y) & G_ISLAND))
|
||||||
|
INDEX(ds,newgrid,x-1,y) |= hdata << D_I_LINE_SHIFT_R;
|
||||||
|
if (x+1 < state->w && (GRID(state,x+1,y) & G_ISLAND))
|
||||||
|
INDEX(ds,newgrid,x+1,y) |= hdata << D_I_LINE_SHIFT_L;
|
||||||
|
if (y > 0 && (GRID(state,x,y-1) & G_ISLAND))
|
||||||
|
INDEX(ds,newgrid,x,y-1) |= vdata << D_I_LINE_SHIFT_D;
|
||||||
|
if (y+1 < state->h && (GRID(state,x,y+1) & G_ISLAND))
|
||||||
|
INDEX(ds,newgrid,x,y+1) |= vdata << D_I_LINE_SHIFT_U;
|
||||||
}
|
}
|
||||||
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) ||
|
|
||||||
lh != INDEX(ds,lh,x,y) ||
|
|
||||||
force) {
|
|
||||||
GRID(ds, x, y) = v | G_REDRAW;
|
|
||||||
INDEX(ds,lv,x,y) = lv;
|
|
||||||
INDEX(ds,lh,x,y) = lh;
|
|
||||||
lines_redraw(dr, state, ds, ui, x, y, v, lv, lh);
|
|
||||||
} else
|
|
||||||
GRID(ds,x,y) &= ~G_REDRAW;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Draw islands. */
|
/*
|
||||||
for (i = 0; i < state->n_islands; i++) {
|
* Now go through and draw any changed grid square.
|
||||||
is = &state->islands[i];
|
*/
|
||||||
v = GRID(state, is->x, is->y) | flash;
|
for (x = 0; x < ds->w; x++) {
|
||||||
|
for (y = 0; y < ds->h; y++) {
|
||||||
|
unsigned long newval = INDEX(ds,newgrid,x,y);
|
||||||
|
if (INDEX(ds,grid,x,y) != newval) {
|
||||||
|
v = GRID(state, x, y);
|
||||||
|
if (v & G_ISLAND) {
|
||||||
|
is = INDEX(state, gridi, x, y);
|
||||||
|
draw_island_tile(dr, ds, x, y, is->count, newval);
|
||||||
|
|
||||||
redraw = 0;
|
/*
|
||||||
for (j = 0; j < is->adj.npoints; j++) {
|
* If this tile is right at the edge of the grid,
|
||||||
if (GRID(ds,is->adj.points[j].x,is->adj.points[j].y) & G_REDRAW) {
|
* we must also draw the part of the island that
|
||||||
redraw = 1;
|
* goes completely out of bounds. We don't bother
|
||||||
|
* keeping separate entries in ds->newgrid for
|
||||||
|
* these tiles; it's easier just to redraw them
|
||||||
|
* iff we redraw their parent island tile.
|
||||||
|
*/
|
||||||
|
if (x == 0)
|
||||||
|
draw_edge_tile(dr, ds, x-1, y, +1, 0, newval);
|
||||||
|
if (y == 0)
|
||||||
|
draw_edge_tile(dr, ds, x, y-1, 0, +1, newval);
|
||||||
|
if (x == state->w-1)
|
||||||
|
draw_edge_tile(dr, ds, x+1, y, -1, 0, newval);
|
||||||
|
if (y == state->h-1)
|
||||||
|
draw_edge_tile(dr, ds, x, y+1, 0, -1, newval);
|
||||||
|
} else {
|
||||||
|
draw_line_tile(dr, ds, x, y, newval);
|
||||||
|
}
|
||||||
|
INDEX(ds,grid,x,y) = newval;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (is_drag_src) {
|
|
||||||
if (is == is_drag_src)
|
|
||||||
v |= G_ISSEL;
|
|
||||||
else if (is_drag_dst && is == is_drag_dst)
|
|
||||||
v |= G_ISSEL;
|
|
||||||
}
|
|
||||||
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -2938,7 +3168,7 @@ static void game_print(drawing *dr, const game_state *state, int ts)
|
|||||||
draw_circle(dr, cx, cy, ISLAND_RADIUS, paper, ink);
|
draw_circle(dr, cx, cy, ISLAND_RADIUS, paper, ink);
|
||||||
|
|
||||||
sprintf(str, "%d", is->count);
|
sprintf(str, "%d", is->count);
|
||||||
draw_text(dr, cx, cy, FONT_VARIABLE, ISLAND_NUMSIZE(is),
|
draw_text(dr, cx, cy, FONT_VARIABLE, ISLAND_NUMSIZE(is->count),
|
||||||
ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
|
ALIGN_VCENTRE | ALIGN_HCENTRE, ink, str);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
Reference in New Issue
Block a user