2 * 'same game' -- try to remove all the coloured squares by
3 * selecting regions of contiguous colours.
15 #define TILE_INNER (ds->tileinner)
16 #define TILE_GAP (ds->tilegap)
17 #define TILE_SIZE (TILE_INNER + TILE_GAP)
18 #define PREFERRED_TILE_SIZE 32
19 #define BORDER (TILE_SIZE / 2)
20 #define HIGHLIGHT_WIDTH 2
22 #define FLASH_FRAME 0.13F
24 #define COORD(x) ( (x) * TILE_SIZE + BORDER )
25 #define FROMCOORD(x) ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
27 #define X(state, i) ( (i) % (state)->params.w )
28 #define Y(state, i) ( (i) / (state)->params.w )
29 #define C(state, x, y) ( (y) * (state)->w + (x) )
33 COL_1, COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8, COL_9,
34 COL_IMPOSSIBLE, COL_SEL, COL_HIGHLIGHT, COL_LOWLIGHT,
38 /* scoresub is 1 or 2 (for (n-1)^2 or (n-2)^2) */
40 int w, h, ncols, scoresub;
43 /* These flags must be unique across all uses; in the game_state,
44 * the game_ui, and the drawstate (as they all get combined in the
46 #define TILE_COLMASK 0x00ff
47 #define TILE_SELECTED 0x0100 /* used in ui and drawstate */
48 #define TILE_JOINRIGHT 0x0200 /* used in drawstate */
49 #define TILE_JOINDOWN 0x0400 /* used in drawstate */
50 #define TILE_JOINDIAG 0x0800 /* used in drawstate */
51 #define TILE_HASSEL 0x1000 /* used in drawstate */
52 #define TILE_IMPOSSIBLE 0x2000 /* used in drawstate */
54 #define TILE(gs,x,y) ((gs)->tiles[(gs)->params.w*(y)+(x)])
55 #define COL(gs,x,y) (TILE(gs,x,y) & TILE_COLMASK)
56 #define ISSEL(gs,x,y) (TILE(gs,x,y) & TILE_SELECTED)
58 #define SWAPTILE(gs,x1,y1,x2,y2) do { \
59 int t = TILE(gs,x1,y1); \
60 TILE(gs,x1,y1) = TILE(gs,x2,y2); \
64 static int npoints(game_params *params, int nsel)
66 int sdiff = nsel - params->scoresub;
67 return (sdiff > 0) ? sdiff * sdiff : 0;
71 struct game_params params;
73 int *tiles; /* colour only */
75 int complete, impossible;
78 static game_params *default_params(void)
80 game_params *ret = snew(game_params);
88 static const struct game_params samegame_presets[] = {
96 static int game_fetch_preset(int i, char **name, game_params **params)
101 if (i < 0 || i >= lenof(samegame_presets))
104 ret = snew(game_params);
105 *ret = samegame_presets[i];
107 sprintf(str, "%dx%d, %d colours", ret->w, ret->h, ret->ncols);
114 static void free_params(game_params *params)
119 static game_params *dup_params(game_params *params)
121 game_params *ret = snew(game_params);
122 *ret = *params; /* structure copy */
126 static void decode_params(game_params *params, char const *string)
128 char const *p = string;
131 while (*p && isdigit((unsigned char)*p)) p++;
135 while (*p && isdigit((unsigned char)*p)) p++;
137 params->h = params->w;
140 params->ncols = atoi(p);
141 while (*p && isdigit((unsigned char)*p)) p++;
146 params->scoresub = atoi(p);
147 while (*p && isdigit((unsigned char)*p)) p++;
149 params->scoresub = 2;
153 static char *encode_params(game_params *params, int full)
157 sprintf(ret, "%dx%dc%ds%d",
158 params->w, params->h, params->ncols, params->scoresub);
162 static config_item *game_configure(game_params *params)
167 ret = snewn(5, config_item);
169 ret[0].name = "Width";
170 ret[0].type = C_STRING;
171 sprintf(buf, "%d", params->w);
172 ret[0].sval = dupstr(buf);
175 ret[1].name = "Height";
176 ret[1].type = C_STRING;
177 sprintf(buf, "%d", params->h);
178 ret[1].sval = dupstr(buf);
181 ret[2].name = "No. of colours";
182 ret[2].type = C_STRING;
183 sprintf(buf, "%d", params->ncols);
184 ret[2].sval = dupstr(buf);
187 ret[3].name = "Scoring system";
188 ret[3].type = C_CHOICES;
189 ret[3].sval = ":(n-1)^2:(n-2)^2";
190 ret[3].ival = params->scoresub-1;
200 static game_params *custom_params(config_item *cfg)
202 game_params *ret = snew(game_params);
204 ret->w = atoi(cfg[0].sval);
205 ret->h = atoi(cfg[1].sval);
206 ret->ncols = atoi(cfg[2].sval);
207 ret->scoresub = cfg[3].ival + 1;
212 static char *validate_params(game_params *params)
214 if (params->w < 1 || params->h < 1)
215 return "Width and height must both be positive";
216 if (params->ncols < 2)
217 return "It's too easy with only one colour...";
218 if (params->ncols > 9)
219 return "Maximum of 9 colours";
221 /* ...and we must make sure we can generate at least 2 squares
222 * of each colour so it's theoretically soluble. */
223 if ((params->w * params->h) < (params->ncols * 2))
224 return "Too many colours makes given grid size impossible";
226 if ((params->scoresub < 1) || (params->scoresub > 2))
227 return "Scoring system not recognised";
232 /* Currently this is a very very dumb game-generation engine; it
233 * just picks randomly from the tile space. I had a look at a few
234 * other same game implementations, and none of them attempt to do
235 * anything to try and make sure the grid started off with a nice
236 * set of large blocks.
238 * It does at least make sure that there are >= 2 of each colour
239 * present at the start.
242 static char *new_game_desc(game_params *params, random_state *rs,
243 game_aux_info **aux, int interactive)
246 int n, i, j, c, retlen, *tiles;
248 n = params->w * params->h;
249 tiles = snewn(n, int);
250 memset(tiles, 0, n*sizeof(int));
252 /* randomly place two of each colour */
253 for (c = 0; c < params->ncols; c++) {
254 for (j = 0; j < 2; j++) {
256 i = (int)random_upto(rs, n);
257 } while (tiles[i] != 0);
262 /* fill in the rest randomly */
263 for (i = 0; i < n; i++) {
265 tiles[i] = (int)random_upto(rs, params->ncols)+1;
270 for (i = 0; i < n; i++) {
274 k = sprintf(buf, "%d,", tiles[i]);
275 ret = sresize(ret, retlen + k + 1, char);
276 strcpy(ret + retlen, buf);
279 ret[retlen-1] = '\0'; /* delete last comma */
285 static void game_free_aux_info(game_aux_info *aux)
287 assert(!"Shouldn't happen");
290 static char *validate_desc(game_params *params, char *desc)
292 int area = params->w * params->h, i;
295 for (i = 0; i < area; i++) {
300 return "Not enough numbers in string";
301 while (isdigit(*p)) p++;
303 if (i < area-1 && *p != ',')
304 return "Expected comma after number";
305 else if (i == area-1 && *p)
306 return "Excess junk at end of string";
309 if (n < 0 || n > params->ncols)
310 return "Colour out of range";
312 if (*p) p++; /* eat comma */
317 static game_state *new_game(midend_data *me, game_params *params, char *desc)
319 game_state *state = snew(game_state);
323 state->params = *params; /* struct copy */
324 state->n = state->params.w * state->params.h;
325 state->tiles = snewn(state->n, int);
327 for (i = 0; i < state->n; i++) {
329 state->tiles[i] = atoi(p);
330 while (*p && *p != ',')
332 if (*p) p++; /* eat comma */
334 state->complete = state->impossible = 0;
340 static game_state *dup_game(game_state *state)
342 game_state *ret = snew(game_state);
344 *ret = *state; /* structure copy, except... */
346 ret->tiles = snewn(state->n, int);
347 memcpy(ret->tiles, state->tiles, state->n * sizeof(int));
352 static void free_game(game_state *state)
358 static char *solve_game(game_state *state, game_state *currstate,
359 game_aux_info *aux, char **error)
364 static char *game_text_format(game_state *state)
369 maxlen = state->params.h * (state->params.w + 1);
370 ret = snewn(maxlen+1, char);
373 for (y = 0; y < state->params.h; y++) {
374 for (x = 0; x < state->params.w; x++) {
375 int t = TILE(state,x,y);
376 if (t <= 0) *p++ = ' ';
377 else if (t < 10) *p++ = '0'+t;
378 else *p++ = 'a'+(t-10);
382 assert(p - ret == maxlen);
388 struct game_params params;
389 int *tiles; /* selected-ness only */
391 int xsel, ysel, displaysel;
394 static game_ui *new_ui(game_state *state)
396 game_ui *ui = snew(game_ui);
398 ui->params = state->params; /* structure copy */
399 ui->tiles = snewn(state->n, int);
400 memset(ui->tiles, 0, state->n*sizeof(int));
403 ui->xsel = ui->ysel = ui->displaysel = 0;
408 static void free_ui(game_ui *ui)
414 char *encode_ui(game_ui *ui)
419 void decode_ui(game_ui *ui, char *encoding)
423 static void sel_clear(game_ui *ui, game_state *state)
427 for (i = 0; i < state->n; i++)
428 ui->tiles[i] &= ~TILE_SELECTED;
433 static void game_changed_state(game_ui *ui, game_state *oldstate,
434 game_state *newstate)
436 sel_clear(ui, newstate);
439 static char *sel_movedesc(game_ui *ui, game_state *state)
442 char *ret, *sep, buf[80];
446 ret = snewn(retsize, char);
451 for (i = 0; i < state->n; i++) {
452 if (ui->tiles[i] & TILE_SELECTED) {
453 sprintf(buf, "%s%d", sep, i);
455 if (retlen + strlen(buf) >= retsize) {
456 retsize = retlen + strlen(buf) + 256;
457 ret = sresize(ret, retsize, char);
459 strcpy(ret + retlen, buf);
460 retlen += strlen(buf);
462 ui->tiles[i] &= ~TILE_SELECTED;
467 assert(retlen < retsize);
468 ret[retlen++] = '\0';
469 return sresize(ret, retlen, char);
472 static void sel_expand(game_ui *ui, game_state *state, int tx, int ty)
474 int ns = 1, nadded, x, y, c;
476 TILE(ui,tx,ty) |= TILE_SELECTED;
480 for (x = 0; x < state->params.w; x++) {
481 for (y = 0; y < state->params.h; y++) {
482 if (x == tx && y == ty) continue;
483 if (ISSEL(ui,x,y)) continue;
487 ISSEL(ui,x-1,y) && COL(state,x-1,y) == c) {
488 TILE(ui,x,y) |= TILE_SELECTED;
493 if ((x+1 < state->params.w) &&
494 ISSEL(ui,x+1,y) && COL(state,x+1,y) == c) {
495 TILE(ui,x,y) |= TILE_SELECTED;
501 ISSEL(ui,x,y-1) && COL(state,x,y-1) == c) {
502 TILE(ui,x,y) |= TILE_SELECTED;
507 if ((y+1 < state->params.h) &&
508 ISSEL(ui,x,y+1) && COL(state,x,y+1) == c) {
509 TILE(ui,x,y) |= TILE_SELECTED;
516 } while (nadded > 0);
521 sel_clear(ui, state);
525 static int sg_emptycol(game_state *ret, int x)
528 for (y = 0; y < ret->params.h; y++) {
529 if (COL(ret,x,y)) return 0;
535 static void sg_snuggle(game_state *ret)
539 /* make all unsupported tiles fall down. */
542 for (x = 0; x < ret->params.w; x++) {
543 for (y = ret->params.h-1; y > 0; y--) {
544 if (COL(ret,x,y) != 0) continue;
545 if (COL(ret,x,y-1) != 0) {
546 SWAPTILE(ret,x,y,x,y-1);
553 /* shuffle all columns as far left as they can go. */
556 for (x = 0; x < ret->params.w-1; x++) {
557 if (sg_emptycol(ret,x) && !sg_emptycol(ret,x+1)) {
559 for (y = 0; y < ret->params.h; y++) {
560 SWAPTILE(ret,x,y,x+1,y);
567 static void sg_check(game_state *ret)
569 int x,y, complete = 1, impossible = 1;
571 for (x = 0; x < ret->params.w; x++) {
572 for (y = 0; y < ret->params.h; y++) {
573 if (COL(ret,x,y) == 0)
576 if (x+1 < ret->params.w) {
577 if (COL(ret,x,y) == COL(ret,x+1,y))
580 if (y+1 < ret->params.h) {
581 if (COL(ret,x,y) == COL(ret,x,y+1))
586 ret->complete = complete;
587 ret->impossible = impossible;
590 struct game_drawstate {
591 int started, bgcolour;
592 int tileinner, tilegap;
593 int *tiles; /* contains colour and SELECTED. */
596 static game_state *execute_move(game_state *from, char *move);
598 static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
599 int x, int y, int button)
606 if (button == RIGHT_BUTTON || button == LEFT_BUTTON) {
607 tx = FROMCOORD(x); ty= FROMCOORD(y);
608 } else if (button == CURSOR_UP || button == CURSOR_DOWN ||
609 button == CURSOR_LEFT || button == CURSOR_RIGHT) {
612 dx = (button == CURSOR_LEFT) ? -1 : ((button == CURSOR_RIGHT) ? +1 : 0);
613 dy = (button == CURSOR_DOWN) ? +1 : ((button == CURSOR_UP) ? -1 : 0);
614 ui->xsel = (ui->xsel + state->params.w + dx) % state->params.w;
615 ui->ysel = (ui->ysel + state->params.h + dy) % state->params.h;
617 } else if (button == CURSOR_SELECT || button == ' ' || button == '\r' ||
625 if (tx < 0 || tx >= state->params.w || ty < 0 || ty >= state->params.h)
627 if (COL(state, tx, ty) == 0) return NULL;
629 if (ISSEL(ui,tx,ty)) {
630 if (button == RIGHT_BUTTON)
631 sel_clear(ui, state);
635 ret = sel_movedesc(ui, state);
638 * Unfortunately, we must check for completeness or
639 * impossibility now, in order to update the game_ui;
640 * and we can't do that without constructing the new
643 tmp = execute_move(state, ret);
644 if (tmp->complete || tmp->impossible)
649 sel_clear(ui, state); /* might be no-op */
650 sel_expand(ui, state, tx, ty);
656 static game_state *execute_move(game_state *from, char *move)
661 if (move[0] == 'M') {
662 ret = dup_game(from);
669 if (i < 0 || i >= ret->n) {
676 while (*move && isdigit((unsigned char)*move)) move++;
677 if (*move == ',') move++;
680 ret->score += npoints(&ret->params, n);
682 sg_snuggle(ret); /* shifts blanks down and to the left */
683 sg_check(ret); /* checks for completeness or impossibility */
687 return NULL; /* couldn't parse move string */
690 /* ----------------------------------------------------------------------
694 static void game_size(game_params *params, game_drawstate *ds, int *x, int *y,
700 * We could choose the tile gap dynamically as well if we
701 * wanted to; for example, at low tile sizes it might be
702 * sensible to leave it out completely. However, for the moment
703 * and for the sake of simplicity I'm just going to fix it at
709 * Each window dimension equals the tile size (inner plus gap)
710 * times the grid dimension, plus another tile size (border is
711 * half the width of a tile), minus one tile gap.
713 * We must cast to unsigned before adding to *x and *y, since
714 * they might be INT_MAX!
716 tsx = (unsigned)(*x + ds->tilegap) / (params->w + 1);
717 tsy = (unsigned)(*y + ds->tilegap) / (params->h + 1);
721 ds->tileinner = ts - ds->tilegap;
723 ds->tileinner = min(ts, PREFERRED_TILE_SIZE) - ds->tilegap;
725 *x = TILE_SIZE * params->w + 2 * BORDER - TILE_GAP;
726 *y = TILE_SIZE * params->h + 2 * BORDER - TILE_GAP;
729 static float *game_colours(frontend *fe, game_state *state, int *ncolours)
731 float *ret = snewn(3 * NCOLOURS, float);
733 frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
735 ret[COL_1 * 3 + 0] = 0.0F;
736 ret[COL_1 * 3 + 1] = 0.0F;
737 ret[COL_1 * 3 + 2] = 1.0F;
739 ret[COL_2 * 3 + 0] = 0.0F;
740 ret[COL_2 * 3 + 1] = 0.5F;
741 ret[COL_2 * 3 + 2] = 0.0F;
743 ret[COL_3 * 3 + 0] = 1.0F;
744 ret[COL_3 * 3 + 1] = 0.0F;
745 ret[COL_3 * 3 + 2] = 0.0F;
747 ret[COL_4 * 3 + 0] = 1.0F;
748 ret[COL_4 * 3 + 1] = 1.0F;
749 ret[COL_4 * 3 + 2] = 0.0F;
751 ret[COL_5 * 3 + 0] = 1.0F;
752 ret[COL_5 * 3 + 1] = 0.0F;
753 ret[COL_5 * 3 + 2] = 1.0F;
755 ret[COL_6 * 3 + 0] = 0.0F;
756 ret[COL_6 * 3 + 1] = 1.0F;
757 ret[COL_6 * 3 + 2] = 1.0F;
759 ret[COL_7 * 3 + 0] = 0.5F;
760 ret[COL_7 * 3 + 1] = 0.5F;
761 ret[COL_7 * 3 + 2] = 1.0F;
763 ret[COL_8 * 3 + 0] = 0.5F;
764 ret[COL_8 * 3 + 1] = 1.0F;
765 ret[COL_8 * 3 + 2] = 0.5F;
767 ret[COL_9 * 3 + 0] = 1.0F;
768 ret[COL_9 * 3 + 1] = 0.5F;
769 ret[COL_9 * 3 + 2] = 0.5F;
771 ret[COL_IMPOSSIBLE * 3 + 0] = 0.0F;
772 ret[COL_IMPOSSIBLE * 3 + 1] = 0.0F;
773 ret[COL_IMPOSSIBLE * 3 + 2] = 0.0F;
775 ret[COL_SEL * 3 + 0] = 1.0F;
776 ret[COL_SEL * 3 + 1] = 1.0F;
777 ret[COL_SEL * 3 + 2] = 1.0F;
779 ret[COL_HIGHLIGHT * 3 + 0] = 1.0F;
780 ret[COL_HIGHLIGHT * 3 + 1] = 1.0F;
781 ret[COL_HIGHLIGHT * 3 + 2] = 1.0F;
783 ret[COL_LOWLIGHT * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 2.0 / 3.0;
784 ret[COL_LOWLIGHT * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 2.0 / 3.0;
785 ret[COL_LOWLIGHT * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 2.0 / 3.0;
787 *ncolours = NCOLOURS;
791 static game_drawstate *game_new_drawstate(game_state *state)
793 struct game_drawstate *ds = snew(struct game_drawstate);
797 ds->tileinner = ds->tilegap = 0; /* not decided yet */
798 ds->tiles = snewn(state->n, int);
799 for (i = 0; i < state->n; i++)
805 static void game_free_drawstate(game_drawstate *ds)
811 /* Drawing routing for the tile at (x,y) is responsible for drawing
812 * itself and the gaps to its right and below. If we're the same colour
813 * as the tile to our right, then we fill in the gap; ditto below, and if
814 * both then we fill the teeny tiny square in the corner as well.
817 static void tile_redraw(frontend *fe, game_drawstate *ds,
818 int x, int y, int dright, int dbelow,
819 int tile, int bgcolour)
821 int outer = bgcolour, inner = outer, col = tile & TILE_COLMASK;
824 if (tile & TILE_IMPOSSIBLE) {
826 inner = COL_IMPOSSIBLE;
827 } else if (tile & TILE_SELECTED) {
834 draw_rect(fe, COORD(x), COORD(y), TILE_INNER, TILE_INNER, outer);
835 draw_rect(fe, COORD(x)+TILE_INNER/4, COORD(y)+TILE_INNER/4,
836 TILE_INNER/2, TILE_INNER/2, inner);
839 draw_rect(fe, COORD(x)+TILE_INNER, COORD(y), TILE_GAP, TILE_INNER,
840 (tile & TILE_JOINRIGHT) ? outer : bgcolour);
842 draw_rect(fe, COORD(x), COORD(y)+TILE_INNER, TILE_INNER, TILE_GAP,
843 (tile & TILE_JOINDOWN) ? outer : bgcolour);
844 if (dright && dbelow)
845 draw_rect(fe, COORD(x)+TILE_INNER, COORD(y)+TILE_INNER, TILE_GAP, TILE_GAP,
846 (tile & TILE_JOINDIAG) ? outer : bgcolour);
848 if (tile & TILE_HASSEL) {
849 int sx = COORD(x)+2, sy = COORD(y)+2, ssz = TILE_INNER-5;
850 int scol = (outer == COL_SEL) ? COL_LOWLIGHT : COL_HIGHLIGHT;
851 draw_line(fe, sx, sy, sx+ssz, sy, scol);
852 draw_line(fe, sx+ssz, sy, sx+ssz, sy+ssz, scol);
853 draw_line(fe, sx+ssz, sy+ssz, sx, sy+ssz, scol);
854 draw_line(fe, sx, sy+ssz, sx, sy, scol);
857 draw_update(fe, COORD(x), COORD(y), TILE_SIZE, TILE_SIZE);
860 static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
861 game_state *state, int dir, game_ui *ui,
862 float animtime, float flashtime)
866 /* This was entirely cloned from fifteen.c; it should probably be
867 * moved into some generic 'draw-recessed-rectangle' utility fn. */
872 TILE_SIZE * state->params.w + 2 * BORDER,
873 TILE_SIZE * state->params.h + 2 * BORDER, COL_BACKGROUND);
874 draw_update(fe, 0, 0,
875 TILE_SIZE * state->params.w + 2 * BORDER,
876 TILE_SIZE * state->params.h + 2 * BORDER);
879 * Recessed area containing the whole puzzle.
881 coords[0] = COORD(state->params.w) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
882 coords[1] = COORD(state->params.h) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
883 coords[2] = COORD(state->params.w) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
884 coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
885 coords[4] = coords[2] - TILE_SIZE;
886 coords[5] = coords[3] + TILE_SIZE;
887 coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
888 coords[9] = COORD(state->params.h) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
889 coords[6] = coords[8] + TILE_SIZE;
890 coords[7] = coords[9] - TILE_SIZE;
891 draw_polygon(fe, coords, 5, TRUE, COL_HIGHLIGHT);
892 draw_polygon(fe, coords, 5, FALSE, COL_HIGHLIGHT);
894 coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
895 coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
896 draw_polygon(fe, coords, 5, TRUE, COL_LOWLIGHT);
897 draw_polygon(fe, coords, 5, FALSE, COL_LOWLIGHT);
902 if (flashtime > 0.0) {
903 int frame = (int)(flashtime / FLASH_FRAME);
904 bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
906 bgcolour = COL_BACKGROUND;
908 for (x = 0; x < state->params.w; x++) {
909 for (y = 0; y < state->params.h; y++) {
910 int i = (state->params.w * y) + x;
911 int col = COL(state,x,y), tile = col;
912 int dright = (x+1 < state->params.w);
913 int dbelow = (y+1 < state->params.h);
915 tile |= ISSEL(ui,x,y);
916 if (state->impossible)
917 tile |= TILE_IMPOSSIBLE;
918 if (dright && COL(state,x+1,y) == col)
919 tile |= TILE_JOINRIGHT;
920 if (dbelow && COL(state,x,y+1) == col)
921 tile |= TILE_JOINDOWN;
922 if ((tile & TILE_JOINRIGHT) && (tile & TILE_JOINDOWN) &&
923 COL(state,x+1,y+1) == col)
924 tile |= TILE_JOINDIAG;
926 if (ui->displaysel && ui->xsel == x && ui->ysel == y)
929 /* For now we're never expecting oldstate at all (because we have
930 * no animation); when we do we might well want to be looking
931 * at the tile colours from oldstate, not state. */
932 if ((oldstate && COL(oldstate,x,y) != col) ||
934 (ds->bgcolour != bgcolour) ||
935 (tile != ds->tiles[i])) {
936 tile_redraw(fe, ds, x, y, dright, dbelow, tile, bgcolour);
941 ds->bgcolour = bgcolour;
944 char status[255], score[80];
946 sprintf(score, "Score: %d", state->score);
949 sprintf(status, "COMPLETE! %s", score);
950 else if (state->impossible)
951 sprintf(status, "Cannot move! %s", score);
952 else if (ui->nselected)
953 sprintf(status, "%s Selected: %d (%d)",
954 score, ui->nselected, npoints(&state->params, ui->nselected));
956 sprintf(status, "%s", score);
957 status_bar(fe, status);
961 static float game_anim_length(game_state *oldstate, game_state *newstate,
962 int dir, game_ui *ui)
967 static float game_flash_length(game_state *oldstate, game_state *newstate,
968 int dir, game_ui *ui)
970 if ((!oldstate->complete && newstate->complete) ||
971 (!oldstate->impossible && newstate->impossible))
972 return 2 * FLASH_FRAME;
977 static int game_wants_statusbar(void)
982 static int game_timing_state(game_state *state)
988 #define thegame samegame
991 const struct game thegame = {
992 "Same Game", "games.samegame",
999 TRUE, game_configure, custom_params,
1008 TRUE, game_text_format,
1019 game_free_drawstate,
1023 game_wants_statusbar,
1024 FALSE, game_timing_state,
1025 0, /* mouse_priorities */