unsigned char *vedge; /* (w+1) x h */
unsigned char *hedge; /* w x (h+1) */
int completed, cheated;
+ unsigned char *correct;
};
static game_params *default_params(void)
return ret;
}
-static char *validate_params(game_params *params)
+static char *validate_params(game_params *params, int full)
{
if (params->w <= 0 || params->h <= 0)
return "Width and height must both be greater than zero";
r1.x++;
r1.w--;
break;
+ default: /* should never happen */
+ assert(!"invalid direction");
}
if (r1.h > 0 && r1.w > 0)
place_rect(params2, grid, r1);
return NULL;
}
-static game_state *new_game(midend_data *me, game_params *params, char *desc)
+static unsigned char *get_correct(game_state *state)
+{
+ unsigned char *ret;
+ int x, y;
+
+ ret = snewn(state->w * state->h, unsigned char);
+ memset(ret, 0xFF, state->w * state->h);
+
+ for (x = 0; x < state->w; x++)
+ for (y = 0; y < state->h; y++)
+ if (index(state,ret,x,y) == 0xFF) {
+ int rw, rh;
+ int xx, yy;
+ int num, area, valid;
+
+ /*
+ * Find a rectangle starting at this point.
+ */
+ rw = 1;
+ while (x+rw < state->w && !vedge(state,x+rw,y))
+ rw++;
+ rh = 1;
+ while (y+rh < state->h && !hedge(state,x,y+rh))
+ rh++;
+
+ /*
+ * We know what the dimensions of the rectangle
+ * should be if it's there at all. Find out if we
+ * really have a valid rectangle.
+ */
+ valid = TRUE;
+ /* Check the horizontal edges. */
+ for (xx = x; xx < x+rw; xx++) {
+ for (yy = y; yy <= y+rh; yy++) {
+ int e = !HRANGE(state,xx,yy) || hedge(state,xx,yy);
+ int ec = (yy == y || yy == y+rh);
+ if (e != ec)
+ valid = FALSE;
+ }
+ }
+ /* Check the vertical edges. */
+ for (yy = y; yy < y+rh; yy++) {
+ for (xx = x; xx <= x+rw; xx++) {
+ int e = !VRANGE(state,xx,yy) || vedge(state,xx,yy);
+ int ec = (xx == x || xx == x+rw);
+ if (e != ec)
+ valid = FALSE;
+ }
+ }
+
+ /*
+ * If this is not a valid rectangle with no other
+ * edges inside it, we just mark this square as not
+ * complete and proceed to the next square.
+ */
+ if (!valid) {
+ index(state, ret, x, y) = 0;
+ continue;
+ }
+
+ /*
+ * We have a rectangle. Now see what its area is,
+ * and how many numbers are in it.
+ */
+ num = 0;
+ area = 0;
+ for (xx = x; xx < x+rw; xx++) {
+ for (yy = y; yy < y+rh; yy++) {
+ area++;
+ if (grid(state,xx,yy)) {
+ if (num > 0)
+ valid = FALSE; /* two numbers */
+ num = grid(state,xx,yy);
+ }
+ }
+ }
+ if (num != area)
+ valid = FALSE;
+
+ /*
+ * Now fill in the whole rectangle based on the
+ * value of `valid'.
+ */
+ for (xx = x; xx < x+rw; xx++) {
+ for (yy = y; yy < y+rh; yy++) {
+ index(state, ret, xx, yy) = valid;
+ }
+ }
+ }
+
+ return ret;
+}
+
+static game_state *new_game(midend *me, game_params *params, char *desc)
{
game_state *state = snew(game_state);
int x, y, i, area;
for (x = 0; x < state->w; x++)
vedge(state,x,y) = hedge(state,x,y) = 0;
+ state->correct = get_correct(state);
+
return state;
}
ret->vedge = snewn(state->w * state->h, unsigned char);
ret->hedge = snewn(state->w * state->h, unsigned char);
ret->grid = snewn(state->w * state->h, int);
+ ret->correct = snewn(ret->w * ret->h, unsigned char);
ret->completed = state->completed;
ret->cheated = state->cheated;
memcpy(ret->vedge, state->vedge, state->w*state->h*sizeof(unsigned char));
memcpy(ret->hedge, state->hedge, state->w*state->h*sizeof(unsigned char));
+ memcpy(ret->correct, state->correct, state->w*state->h*sizeof(unsigned char));
+
return ret;
}
sfree(state->grid);
sfree(state->vedge);
sfree(state->hedge);
+ sfree(state->correct);
sfree(state);
}
return ret;
}
-static unsigned char *get_correct(game_state *state)
-{
- unsigned char *ret;
- int x, y;
-
- ret = snewn(state->w * state->h, unsigned char);
- memset(ret, 0xFF, state->w * state->h);
-
- for (x = 0; x < state->w; x++)
- for (y = 0; y < state->h; y++)
- if (index(state,ret,x,y) == 0xFF) {
- int rw, rh;
- int xx, yy;
- int num, area, valid;
-
- /*
- * Find a rectangle starting at this point.
- */
- rw = 1;
- while (x+rw < state->w && !vedge(state,x+rw,y))
- rw++;
- rh = 1;
- while (y+rh < state->h && !hedge(state,x,y+rh))
- rh++;
-
- /*
- * We know what the dimensions of the rectangle
- * should be if it's there at all. Find out if we
- * really have a valid rectangle.
- */
- valid = TRUE;
- /* Check the horizontal edges. */
- for (xx = x; xx < x+rw; xx++) {
- for (yy = y; yy <= y+rh; yy++) {
- int e = !HRANGE(state,xx,yy) || hedge(state,xx,yy);
- int ec = (yy == y || yy == y+rh);
- if (e != ec)
- valid = FALSE;
- }
- }
- /* Check the vertical edges. */
- for (yy = y; yy < y+rh; yy++) {
- for (xx = x; xx <= x+rw; xx++) {
- int e = !VRANGE(state,xx,yy) || vedge(state,xx,yy);
- int ec = (xx == x || xx == x+rw);
- if (e != ec)
- valid = FALSE;
- }
- }
-
- /*
- * If this is not a valid rectangle with no other
- * edges inside it, we just mark this square as not
- * complete and proceed to the next square.
- */
- if (!valid) {
- index(state, ret, x, y) = 0;
- continue;
- }
-
- /*
- * We have a rectangle. Now see what its area is,
- * and how many numbers are in it.
- */
- num = 0;
- area = 0;
- for (xx = x; xx < x+rw; xx++) {
- for (yy = y; yy < y+rh; yy++) {
- area++;
- if (grid(state,xx,yy)) {
- if (num > 0)
- valid = FALSE; /* two numbers */
- num = grid(state,xx,yy);
- }
- }
- }
- if (num != area)
- valid = FALSE;
-
- /*
- * Now fill in the whole rectangle based on the
- * value of `valid'.
- */
- for (xx = x; xx < x+rw; xx++) {
- for (yy = y; yy < y+rh; yy++) {
- index(state, ret, xx, yy) = valid;
- }
- }
- }
-
- return ret;
-}
-
struct game_ui {
/*
* These coordinates are 2 times the obvious grid coordinates.
coord_round(FROMCOORD((float)x), FROMCOORD((float)y), &xc, &yc);
- if (startdrag) {
+ if (startdrag &&
+ xc >= 0 && xc <= 2*from->w &&
+ yc >= 0 && yc <= 2*from->h) {
+
ui->drag_start_x = xc;
ui->drag_start_y = yc;
ui->drag_end_x = xc;
active = TRUE;
}
- if (xc != ui->drag_end_x || yc != ui->drag_end_y) {
+ if (ui->drag_start_x >= 0 &&
+ (xc != ui->drag_end_x || yc != ui->drag_end_y)) {
int t;
ui->drag_end_x = xc;
ret = NULL;
- if (enddrag) {
+ if (enddrag && (ui->drag_start_x >= 0)) {
if (xc >= 0 && xc <= 2*from->w &&
yc >= 0 && yc <= 2*from->h) {
if (*p) p++;
}
+ sfree(ret->correct);
+ ret->correct = get_correct(ret);
+
return ret;
} else if (move[0] == 'R' &&
vedge(ret,x1,y1) = !vedge(ret,x1,y1);
}
+ sfree(ret->correct);
+ ret->correct = get_correct(ret);
+
/*
* We've made a real change to the grid. Check to see
* if the game has been completed.
*/
if (!ret->completed) {
int x, y, ok;
- unsigned char *correct = get_correct(ret);
ok = TRUE;
for (x = 0; x < ret->w; x++)
for (y = 0; y < ret->h; y++)
- if (!index(ret, correct, x, y))
+ if (!index(ret, ret->correct, x, y))
ok = FALSE;
- sfree(correct);
-
if (ok)
ret->completed = TRUE;
}
#define COLOUR(k) ( (k)==1 ? COL_LINE : COL_DRAG )
#define MAX4(x,y,z,w) ( max(max(x,y),max(z,w)) )
-static void game_size(game_params *params, game_drawstate *ds,
- int *x, int *y, int expand)
+static void game_compute_size(game_params *params, int tilesize,
+ int *x, int *y)
{
- double tsx, tsy, ts;
- /*
- * Each window dimension equals the tile size times 1.5 more
- * than the grid dimension (the border is 3/4 the width of the
- * tiles).
- *
- * We must cast to unsigned before multiplying by two, because
- * *x might be INT_MAX.
- */
- tsx = 2.0 * (double)*x / (2.0 * (double)params->w + 3.0);
- tsy = 2.0 * (double)*y / (2.0 * (double)params->h + 3.0);
- ts = min(tsx, tsy);
- if (expand)
- ds->tilesize = (int)(ts + 0.5);
- else
- ds->tilesize = min((int)ts, PREFERRED_TILE_SIZE);
+ /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+ struct { int tilesize; } ads, *ds = &ads;
+ ads.tilesize = tilesize;
*x = params->w * TILE_SIZE + 2*BORDER + 1;
*y = params->h * TILE_SIZE + 2*BORDER + 1;
}
+static void game_set_size(drawing *dr, game_drawstate *ds,
+ game_params *params, int tilesize)
+{
+ ds->tilesize = tilesize;
+}
+
static float *game_colours(frontend *fe, game_state *state, int *ncolours)
{
float *ret = snewn(3 * NCOLOURS, float);
return ret;
}
-static game_drawstate *game_new_drawstate(game_state *state)
+static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
{
struct game_drawstate *ds = snew(struct game_drawstate);
int i;
return ds;
}
-static void game_free_drawstate(game_drawstate *ds)
+static void game_free_drawstate(drawing *dr, game_drawstate *ds)
{
sfree(ds->visible);
sfree(ds);
}
-static void draw_tile(frontend *fe, game_drawstate *ds, game_state *state,
+static void draw_tile(drawing *dr, game_drawstate *ds, game_state *state,
int x, int y, unsigned char *hedge, unsigned char *vedge,
unsigned char *corners, int correct)
{
int cx = COORD(x), cy = COORD(y);
char str[80];
- draw_rect(fe, cx, cy, TILE_SIZE+1, TILE_SIZE+1, COL_GRID);
- draw_rect(fe, cx+1, cy+1, TILE_SIZE-1, TILE_SIZE-1,
+ draw_rect(dr, cx, cy, TILE_SIZE+1, TILE_SIZE+1, COL_GRID);
+ draw_rect(dr, cx+1, cy+1, TILE_SIZE-1, TILE_SIZE-1,
correct ? COL_CORRECT : COL_BACKGROUND);
if (grid(state,x,y)) {
sprintf(str, "%d", grid(state,x,y));
- draw_text(fe, cx+TILE_SIZE/2, cy+TILE_SIZE/2, FONT_VARIABLE,
+ draw_text(dr, cx+TILE_SIZE/2, cy+TILE_SIZE/2, FONT_VARIABLE,
TILE_SIZE/2, ALIGN_HCENTRE | ALIGN_VCENTRE, COL_TEXT, str);
}
* Draw edges.
*/
if (!HRANGE(state,x,y) || index(state,hedge,x,y))
- draw_rect(fe, cx, cy, TILE_SIZE+1, 2,
+ draw_rect(dr, cx, cy, TILE_SIZE+1, 2,
HRANGE(state,x,y) ? COLOUR(index(state,hedge,x,y)) :
COL_LINE);
if (!HRANGE(state,x,y+1) || index(state,hedge,x,y+1))
- draw_rect(fe, cx, cy+TILE_SIZE-1, TILE_SIZE+1, 2,
+ draw_rect(dr, cx, cy+TILE_SIZE-1, TILE_SIZE+1, 2,
HRANGE(state,x,y+1) ? COLOUR(index(state,hedge,x,y+1)) :
COL_LINE);
if (!VRANGE(state,x,y) || index(state,vedge,x,y))
- draw_rect(fe, cx, cy, 2, TILE_SIZE+1,
+ draw_rect(dr, cx, cy, 2, TILE_SIZE+1,
VRANGE(state,x,y) ? COLOUR(index(state,vedge,x,y)) :
COL_LINE);
if (!VRANGE(state,x+1,y) || index(state,vedge,x+1,y))
- draw_rect(fe, cx+TILE_SIZE-1, cy, 2, TILE_SIZE+1,
+ draw_rect(dr, cx+TILE_SIZE-1, cy, 2, TILE_SIZE+1,
VRANGE(state,x+1,y) ? COLOUR(index(state,vedge,x+1,y)) :
COL_LINE);
* Draw corners.
*/
if (index(state,corners,x,y))
- draw_rect(fe, cx, cy, 2, 2,
+ draw_rect(dr, cx, cy, 2, 2,
COLOUR(index(state,corners,x,y)));
if (x+1 < state->w && index(state,corners,x+1,y))
- draw_rect(fe, cx+TILE_SIZE-1, cy, 2, 2,
+ draw_rect(dr, cx+TILE_SIZE-1, cy, 2, 2,
COLOUR(index(state,corners,x+1,y)));
if (y+1 < state->h && index(state,corners,x,y+1))
- draw_rect(fe, cx, cy+TILE_SIZE-1, 2, 2,
+ draw_rect(dr, cx, cy+TILE_SIZE-1, 2, 2,
COLOUR(index(state,corners,x,y+1)));
if (x+1 < state->w && y+1 < state->h && index(state,corners,x+1,y+1))
- draw_rect(fe, cx+TILE_SIZE-1, cy+TILE_SIZE-1, 2, 2,
+ draw_rect(dr, cx+TILE_SIZE-1, cy+TILE_SIZE-1, 2, 2,
COLOUR(index(state,corners,x+1,y+1)));
- draw_update(fe, cx, cy, TILE_SIZE+1, TILE_SIZE+1);
+ draw_update(dr, cx, cy, TILE_SIZE+1, TILE_SIZE+1);
}
-static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
+static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
game_state *state, int dir, game_ui *ui,
float animtime, float flashtime)
{
int x, y;
- unsigned char *correct;
unsigned char *hedge, *vedge, *corners;
- correct = get_correct(state);
-
if (ui->dragged) {
hedge = snewn(state->w*state->h, unsigned char);
vedge = snewn(state->w*state->h, unsigned char);
}
if (!ds->started) {
- draw_rect(fe, 0, 0,
+ draw_rect(dr, 0, 0,
state->w * TILE_SIZE + 2*BORDER + 1,
state->h * TILE_SIZE + 2*BORDER + 1, COL_BACKGROUND);
- draw_rect(fe, COORD(0)-1, COORD(0)-1,
+ draw_rect(dr, COORD(0)-1, COORD(0)-1,
ds->w*TILE_SIZE+3, ds->h*TILE_SIZE+3, COL_LINE);
ds->started = TRUE;
- draw_update(fe, 0, 0,
+ draw_update(dr, 0, 0,
state->w * TILE_SIZE + 2*BORDER + 1,
state->h * TILE_SIZE + 2*BORDER + 1);
}
if (x+1 < state->w && y+1 < state->h)
/* cast to prevent 2<<14 sign-extending on promotion to long */
c |= (unsigned long)index(state,corners,x+1,y+1) << 14;
- if (index(state, correct, x, y) && !flashtime)
+ if (index(state, state->correct, x, y) && !flashtime)
c |= CORRECT;
if (index(ds,ds->visible,x,y) != c) {
- draw_tile(fe, ds, state, x, y, hedge, vedge, corners,
+ draw_tile(dr, ds, state, x, y, hedge, vedge, corners,
(c & CORRECT) ? 1 : 0);
index(ds,ds->visible,x,y) = c;
}
else if (state->completed)
strcat(buf, "COMPLETED!");
- status_bar(fe, buf);
+ status_bar(dr, buf);
}
if (hedge != state->hedge) {
}
sfree(corners);
- sfree(correct);
}
static float game_anim_length(game_state *oldstate,
return TRUE;
}
-static int game_timing_state(game_state *state)
+static int game_timing_state(game_state *state, game_ui *ui)
{
return TRUE;
}
+static void game_print_size(game_params *params, float *x, float *y)
+{
+ int pw, ph;
+
+ /*
+ * I'll use 5mm squares by default.
+ */
+ game_compute_size(params, 500, &pw, &ph);
+ *x = pw / 100.0;
+ *y = ph / 100.0;
+}
+
+static void game_print(drawing *dr, game_state *state, int tilesize)
+{
+ int w = state->w, h = state->h;
+ int ink = print_mono_colour(dr, 0);
+ int x, y;
+
+ /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+ game_drawstate ads, *ds = &ads;
+ game_set_size(dr, ds, NULL, tilesize);
+
+ /*
+ * Border.
+ */
+ print_line_width(dr, TILE_SIZE / 10);
+ draw_rect_outline(dr, COORD(0), COORD(0), w*TILE_SIZE, h*TILE_SIZE, ink);
+
+ /*
+ * Grid. We have to make the grid lines particularly thin,
+ * because users will be drawing lines _along_ them and we want
+ * those lines to be visible.
+ */
+ print_line_width(dr, TILE_SIZE / 256);
+ for (x = 1; x < w; x++)
+ draw_line(dr, COORD(x), COORD(0), COORD(x), COORD(h), ink);
+ for (y = 1; y < h; y++)
+ draw_line(dr, COORD(0), COORD(y), COORD(w), COORD(y), ink);
+
+ /*
+ * Solution.
+ */
+ print_line_width(dr, TILE_SIZE / 10);
+ for (y = 0; y <= h; y++)
+ for (x = 0; x <= w; x++) {
+ if (HRANGE(state,x,y) && hedge(state,x,y))
+ draw_line(dr, COORD(x), COORD(y), COORD(x+1), COORD(y), ink);
+ if (VRANGE(state,x,y) && vedge(state,x,y))
+ draw_line(dr, COORD(x), COORD(y), COORD(x), COORD(y+1), ink);
+ }
+
+ /*
+ * Clues.
+ */
+ for (y = 0; y < h; y++)
+ for (x = 0; x < w; x++)
+ if (grid(state,x,y)) {
+ char str[80];
+ sprintf(str, "%d", grid(state,x,y));
+ draw_text(dr, COORD(x)+TILE_SIZE/2, COORD(y)+TILE_SIZE/2,
+ FONT_VARIABLE, TILE_SIZE/2,
+ ALIGN_HCENTRE | ALIGN_VCENTRE, ink, str);
+ }
+}
+
#ifdef COMBINED
#define thegame rect
#endif
game_changed_state,
interpret_move,
execute_move,
- game_size,
+ PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
game_colours,
game_new_drawstate,
game_free_drawstate,
game_redraw,
game_anim_length,
game_flash_length,
+ TRUE, FALSE, game_print_size, game_print,
game_wants_statusbar,
FALSE, game_timing_state,
- 0, /* mouse_priorities */
+ 0, /* flags */
};
~mdw / sgt / puzzles / blobdiff