chiark / gitweb /
Re-architecting of the game backend interface. make_move() has been
[sgt-puzzles.git] / fifteen.c
1 /*
2  * fifteen.c: standard 15-puzzle.
3  */
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include <assert.h>
9 #include <ctype.h>
10 #include <math.h>
11
12 #include "puzzles.h"
13
14 #define PREFERRED_TILE_SIZE 48
15 #define TILE_SIZE (ds->tilesize)
16 #define BORDER    (TILE_SIZE / 2)
17 #define HIGHLIGHT_WIDTH (TILE_SIZE / 20)
18 #define COORD(x)  ( (x) * TILE_SIZE + BORDER )
19 #define FROMCOORD(x)  ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
20
21 #define ANIM_TIME 0.13F
22 #define FLASH_FRAME 0.13F
23
24 #define X(state, i) ( (i) % (state)->w )
25 #define Y(state, i) ( (i) / (state)->w )
26 #define C(state, x, y) ( (y) * (state)->w + (x) )
27
28 enum {
29     COL_BACKGROUND,
30     COL_TEXT,
31     COL_HIGHLIGHT,
32     COL_LOWLIGHT,
33     NCOLOURS
34 };
35
36 struct game_params {
37     int w, h;
38 };
39
40 struct game_state {
41     int w, h, n;
42     int *tiles;
43     int gap_pos;
44     int completed;
45     int just_used_solve;               /* used to suppress undo animation */
46     int used_solve;                    /* used to suppress completion flash */
47     int movecount;
48 };
49
50 static game_params *default_params(void)
51 {
52     game_params *ret = snew(game_params);
53
54     ret->w = ret->h = 4;
55
56     return ret;
57 }
58
59 static int game_fetch_preset(int i, char **name, game_params **params)
60 {
61     return FALSE;
62 }
63
64 static void free_params(game_params *params)
65 {
66     sfree(params);
67 }
68
69 static game_params *dup_params(game_params *params)
70 {
71     game_params *ret = snew(game_params);
72     *ret = *params;                    /* structure copy */
73     return ret;
74 }
75
76 static void decode_params(game_params *ret, char const *string)
77 {
78     ret->w = ret->h = atoi(string);
79     while (*string && isdigit(*string)) string++;
80     if (*string == 'x') {
81         string++;
82         ret->h = atoi(string);
83     }
84 }
85
86 static char *encode_params(game_params *params, int full)
87 {
88     char data[256];
89
90     sprintf(data, "%dx%d", params->w, params->h);
91
92     return dupstr(data);
93 }
94
95 static config_item *game_configure(game_params *params)
96 {
97     config_item *ret;
98     char buf[80];
99
100     ret = snewn(3, config_item);
101
102     ret[0].name = "Width";
103     ret[0].type = C_STRING;
104     sprintf(buf, "%d", params->w);
105     ret[0].sval = dupstr(buf);
106     ret[0].ival = 0;
107
108     ret[1].name = "Height";
109     ret[1].type = C_STRING;
110     sprintf(buf, "%d", params->h);
111     ret[1].sval = dupstr(buf);
112     ret[1].ival = 0;
113
114     ret[2].name = NULL;
115     ret[2].type = C_END;
116     ret[2].sval = NULL;
117     ret[2].ival = 0;
118
119     return ret;
120 }
121
122 static game_params *custom_params(config_item *cfg)
123 {
124     game_params *ret = snew(game_params);
125
126     ret->w = atoi(cfg[0].sval);
127     ret->h = atoi(cfg[1].sval);
128
129     return ret;
130 }
131
132 static char *validate_params(game_params *params)
133 {
134     if (params->w < 2 || params->h < 2)
135         return "Width and height must both be at least two";
136
137     return NULL;
138 }
139
140 static int perm_parity(int *perm, int n)
141 {
142     int i, j, ret;
143
144     ret = 0;
145
146     for (i = 0; i < n-1; i++)
147         for (j = i+1; j < n; j++)
148             if (perm[i] > perm[j])
149                 ret = !ret;
150
151     return ret;
152 }
153
154 static char *new_game_desc(game_params *params, random_state *rs,
155                            game_aux_info **aux, int interactive)
156 {
157     int gap, n, i, x;
158     int x1, x2, p1, p2, parity;
159     int *tiles, *used;
160     char *ret;
161     int retlen;
162
163     n = params->w * params->h;
164
165     tiles = snewn(n, int);
166     used = snewn(n, int);
167
168     for (i = 0; i < n; i++) {
169         tiles[i] = -1;
170         used[i] = FALSE;
171     }
172
173     gap = random_upto(rs, n);
174     tiles[gap] = 0;
175     used[0] = TRUE;
176
177     /*
178      * Place everything else except the last two tiles.
179      */
180     for (x = 0, i = n-1; i > 2; i--) {
181         int k = random_upto(rs, i);
182         int j;
183
184         for (j = 0; j < n; j++)
185             if (!used[j] && (k-- == 0))
186                 break;
187
188         assert(j < n && !used[j]);
189         used[j] = TRUE;
190
191         while (tiles[x] >= 0)
192             x++;
193         assert(x < n);
194         tiles[x] = j;
195     }
196
197     /*
198      * Find the last two locations, and the last two pieces.
199      */
200     while (tiles[x] >= 0)
201         x++;
202     assert(x < n);
203     x1 = x;
204     x++;
205     while (tiles[x] >= 0)
206         x++;
207     assert(x < n);
208     x2 = x;
209
210     for (i = 0; i < n; i++)
211         if (!used[i])
212             break;
213     p1 = i;
214     for (i = p1+1; i < n; i++)
215         if (!used[i])
216             break;
217     p2 = i;
218
219     /*
220      * Determine the required parity of the overall permutation.
221      * This is the XOR of:
222      * 
223      *  - The chessboard parity ((x^y)&1) of the gap square. The
224      *    bottom right counts as even.
225      * 
226      *  - The parity of n. (The target permutation is 1,...,n-1,0
227      *    rather than 0,...,n-1; this is a cyclic permutation of
228      *    the starting point and hence is odd iff n is even.)
229      */
230     parity = ((X(params, gap) - (params->w-1)) ^
231               (Y(params, gap) - (params->h-1)) ^
232               (n+1)) & 1;
233
234     /*
235      * Try the last two tiles one way round. If that fails, swap
236      * them.
237      */
238     tiles[x1] = p1;
239     tiles[x2] = p2;
240     if (perm_parity(tiles, n) != parity) {
241         tiles[x1] = p2;
242         tiles[x2] = p1;
243         assert(perm_parity(tiles, n) == parity);
244     }
245
246     /*
247      * Now construct the game description, by describing the tile
248      * array as a simple sequence of comma-separated integers.
249      */
250     ret = NULL;
251     retlen = 0;
252     for (i = 0; i < n; i++) {
253         char buf[80];
254         int k;
255
256         k = sprintf(buf, "%d,", tiles[i]);
257
258         ret = sresize(ret, retlen + k + 1, char);
259         strcpy(ret + retlen, buf);
260         retlen += k;
261     }
262     ret[retlen-1] = '\0';              /* delete last comma */
263
264     sfree(tiles);
265     sfree(used);
266
267     return ret;
268 }
269
270 static void game_free_aux_info(game_aux_info *aux)
271 {
272     assert(!"Shouldn't happen");
273 }
274
275 static char *validate_desc(game_params *params, char *desc)
276 {
277     char *p, *err;
278     int i, area;
279     int *used;
280
281     area = params->w * params->h;
282     p = desc;
283     err = NULL;
284
285     used = snewn(area, int);
286     for (i = 0; i < area; i++)
287         used[i] = FALSE;
288
289     for (i = 0; i < area; i++) {
290         char *q = p;
291         int n;
292
293         if (*p < '0' || *p > '9') {
294             err = "Not enough numbers in string";
295             goto leave;
296         }
297         while (*p >= '0' && *p <= '9')
298             p++;
299         if (i < area-1 && *p != ',') {
300             err = "Expected comma after number";
301             goto leave;
302         }
303         else if (i == area-1 && *p) {
304             err = "Excess junk at end of string";
305             goto leave;
306         }
307         n = atoi(q);
308         if (n < 0 || n >= area) {
309             err = "Number out of range";
310             goto leave;
311         }
312         if (used[n]) {
313             err = "Number used twice";
314             goto leave;
315         }
316         used[n] = TRUE;
317
318         if (*p) p++;                   /* eat comma */
319     }
320
321     leave:
322     sfree(used);
323     return err;
324 }
325
326 static game_state *new_game(midend_data *me, game_params *params, char *desc)
327 {
328     game_state *state = snew(game_state);
329     int i;
330     char *p;
331
332     state->w = params->w;
333     state->h = params->h;
334     state->n = params->w * params->h;
335     state->tiles = snewn(state->n, int);
336
337     state->gap_pos = 0;
338     p = desc;
339     i = 0;
340     for (i = 0; i < state->n; i++) {
341         assert(*p);
342         state->tiles[i] = atoi(p);
343         if (state->tiles[i] == 0)
344             state->gap_pos = i;
345         while (*p && *p != ',')
346             p++;
347         if (*p) p++;                   /* eat comma */
348     }
349     assert(!*p);
350     assert(state->tiles[state->gap_pos] == 0);
351
352     state->completed = state->movecount = 0;
353     state->used_solve = state->just_used_solve = FALSE;
354
355     return state;
356 }
357
358 static game_state *dup_game(game_state *state)
359 {
360     game_state *ret = snew(game_state);
361
362     ret->w = state->w;
363     ret->h = state->h;
364     ret->n = state->n;
365     ret->tiles = snewn(state->w * state->h, int);
366     memcpy(ret->tiles, state->tiles, state->w * state->h * sizeof(int));
367     ret->gap_pos = state->gap_pos;
368     ret->completed = state->completed;
369     ret->movecount = state->movecount;
370     ret->used_solve = state->used_solve;
371     ret->just_used_solve = state->just_used_solve;
372
373     return ret;
374 }
375
376 static void free_game(game_state *state)
377 {
378     sfree(state->tiles);
379     sfree(state);
380 }
381
382 static char *solve_game(game_state *state, game_state *currstate,
383                         game_aux_info *aux, char **error)
384 {
385     return dupstr("S");
386 }
387
388 static char *game_text_format(game_state *state)
389 {
390     char *ret, *p, buf[80];
391     int x, y, col, maxlen;
392
393     /*
394      * First work out how many characters we need to display each
395      * number.
396      */
397     col = sprintf(buf, "%d", state->n-1);
398
399     /*
400      * Now we know the exact total size of the grid we're going to
401      * produce: it's got h rows, each containing w lots of col, w-1
402      * spaces and a trailing newline.
403      */
404     maxlen = state->h * state->w * (col+1);
405
406     ret = snewn(maxlen+1, char);
407     p = ret;
408
409     for (y = 0; y < state->h; y++) {
410         for (x = 0; x < state->w; x++) {
411             int v = state->tiles[state->w*y+x];
412             if (v == 0)
413                 sprintf(buf, "%*s", col, "");
414             else
415                 sprintf(buf, "%*d", col, v);
416             memcpy(p, buf, col);
417             p += col;
418             if (x+1 == state->w)
419                 *p++ = '\n';
420             else
421                 *p++ = ' ';
422         }
423     }
424
425     assert(p - ret == maxlen);
426     *p = '\0';
427     return ret;
428 }
429
430 static game_ui *new_ui(game_state *state)
431 {
432     return NULL;
433 }
434
435 static void free_ui(game_ui *ui)
436 {
437 }
438
439 static void game_changed_state(game_ui *ui, game_state *oldstate,
440                                game_state *newstate)
441 {
442 }
443
444 struct game_drawstate {
445     int started;
446     int w, h, bgcolour;
447     int *tiles;
448     int tilesize;
449 };
450
451 static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
452                             int x, int y, int button)
453 {
454     int gx, gy, dx, dy;
455     char buf[80];
456
457     button &= ~MOD_MASK;
458
459     gx = X(state, state->gap_pos);
460     gy = Y(state, state->gap_pos);
461
462     if (button == CURSOR_RIGHT && gx > 0)
463         dx = gx - 1, dy = gy;
464     else if (button == CURSOR_LEFT && gx < state->w-1)
465         dx = gx + 1, dy = gy;
466     else if (button == CURSOR_DOWN && gy > 0)
467         dy = gy - 1, dx = gx;
468     else if (button == CURSOR_UP && gy < state->h-1)
469         dy = gy + 1, dx = gx;
470     else if (button == LEFT_BUTTON) {
471         dx = FROMCOORD(x);
472         dy = FROMCOORD(y);
473         if (dx < 0 || dx >= state->w || dy < 0 || dy >= state->h)
474             return NULL;               /* out of bounds */
475         /*
476          * Any click location should be equal to the gap location
477          * in _precisely_ one coordinate.
478          */
479         if ((dx == gx && dy == gy) || (dx != gx && dy != gy))
480             return NULL;
481     } else
482         return NULL;                   /* no move */
483
484     sprintf(buf, "M%d,%d", dx, dy);
485     return dupstr(buf);
486 }
487
488 static game_state *execute_move(game_state *from, char *move)
489 {
490     int gx, gy, dx, dy, ux, uy, up, p;
491     game_state *ret;
492
493     if (!strcmp(move, "S")) {
494         int i;
495
496         ret = dup_game(from);
497
498         /*
499          * Simply replace the grid with a solved one. For this game,
500          * this isn't a useful operation for actually telling the user
501          * what they should have done, but it is useful for
502          * conveniently being able to get hold of a clean state from
503          * which to practise manoeuvres.
504          */
505         for (i = 0; i < ret->n; i++)
506             ret->tiles[i] = (i+1) % ret->n;
507         ret->gap_pos = ret->n-1;
508         ret->used_solve = ret->just_used_solve = TRUE;
509         ret->completed = ret->movecount = 1;
510
511         return ret;
512     }
513
514     gx = X(from, from->gap_pos);
515     gy = Y(from, from->gap_pos);
516
517     if (move[0] != 'M' ||
518         sscanf(move+1, "%d,%d", &dx, &dy) != 2 ||
519         (dx == gx && dy == gy) || (dx != gx && dy != gy) ||
520         dx < 0 || dx >= from->w || dy < 0 || dy >= from->h)
521         return NULL;
522
523     /*
524      * Find the unit displacement from the original gap
525      * position towards this one.
526      */
527     ux = (dx < gx ? -1 : dx > gx ? +1 : 0);
528     uy = (dy < gy ? -1 : dy > gy ? +1 : 0);
529     up = C(from, ux, uy);
530
531     ret = dup_game(from);
532     ret->just_used_solve = FALSE;      /* zero this in a hurry */
533
534     ret->gap_pos = C(from, dx, dy);
535     assert(ret->gap_pos >= 0 && ret->gap_pos < ret->n);
536
537     ret->tiles[ret->gap_pos] = 0;
538
539     for (p = from->gap_pos; p != ret->gap_pos; p += up) {
540         assert(p >= 0 && p < from->n);
541         ret->tiles[p] = from->tiles[p + up];
542         ret->movecount++;
543     }
544
545     /*
546      * See if the game has been completed.
547      */
548     if (!ret->completed) {
549         ret->completed = ret->movecount;
550         for (p = 0; p < ret->n; p++)
551             if (ret->tiles[p] != (p < ret->n-1 ? p+1 : 0))
552                 ret->completed = 0;
553     }
554
555     return ret;
556 }
557
558 /* ----------------------------------------------------------------------
559  * Drawing routines.
560  */
561
562 static void game_size(game_params *params, game_drawstate *ds,
563                       int *x, int *y, int expand)
564 {
565     int tsx, tsy, ts;
566     /*
567      * Each window dimension equals the tile size times one more
568      * than the grid dimension (the border is half the width of the
569      * tiles).
570      */
571     tsx = *x / (params->w + 1);
572     tsy = *y / (params->h + 1);
573     ts = min(tsx, tsy);
574     if (expand)
575         ds->tilesize = ts;
576     else
577         ds->tilesize = min(ts, PREFERRED_TILE_SIZE);
578
579     *x = TILE_SIZE * params->w + 2 * BORDER;
580     *y = TILE_SIZE * params->h + 2 * BORDER;
581 }
582
583 static float *game_colours(frontend *fe, game_state *state, int *ncolours)
584 {
585     float *ret = snewn(3 * NCOLOURS, float);
586     int i;
587     float max;
588
589     frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
590
591     /*
592      * Drop the background colour so that the highlight is
593      * noticeably brighter than it while still being under 1.
594      */
595     max = ret[COL_BACKGROUND*3];
596     for (i = 1; i < 3; i++)
597         if (ret[COL_BACKGROUND*3+i] > max)
598             max = ret[COL_BACKGROUND*3+i];
599     if (max * 1.2F > 1.0F) {
600         for (i = 0; i < 3; i++)
601             ret[COL_BACKGROUND*3+i] /= (max * 1.2F);
602     }
603
604     for (i = 0; i < 3; i++) {
605         ret[COL_HIGHLIGHT * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 1.2F;
606         ret[COL_LOWLIGHT * 3 + i] = ret[COL_BACKGROUND * 3 + i] * 0.8F;
607         ret[COL_TEXT * 3 + i] = 0.0;
608     }
609
610     *ncolours = NCOLOURS;
611     return ret;
612 }
613
614 static game_drawstate *game_new_drawstate(game_state *state)
615 {
616     struct game_drawstate *ds = snew(struct game_drawstate);
617     int i;
618
619     ds->started = FALSE;
620     ds->w = state->w;
621     ds->h = state->h;
622     ds->bgcolour = COL_BACKGROUND;
623     ds->tiles = snewn(ds->w*ds->h, int);
624     ds->tilesize = 0;                  /* haven't decided yet */
625     for (i = 0; i < ds->w*ds->h; i++)
626         ds->tiles[i] = -1;
627
628     return ds;
629 }
630
631 static void game_free_drawstate(game_drawstate *ds)
632 {
633     sfree(ds->tiles);
634     sfree(ds);
635 }
636
637 static void draw_tile(frontend *fe, game_drawstate *ds, game_state *state,
638                       int x, int y, int tile, int flash_colour)
639 {
640     if (tile == 0) {
641         draw_rect(fe, x, y, TILE_SIZE, TILE_SIZE,
642                   flash_colour);
643     } else {
644         int coords[6];
645         char str[40];
646
647         coords[0] = x + TILE_SIZE - 1;
648         coords[1] = y + TILE_SIZE - 1;
649         coords[2] = x + TILE_SIZE - 1;
650         coords[3] = y;
651         coords[4] = x;
652         coords[5] = y + TILE_SIZE - 1;
653         draw_polygon(fe, coords, 3, TRUE, COL_LOWLIGHT);
654         draw_polygon(fe, coords, 3, FALSE, COL_LOWLIGHT);
655
656         coords[0] = x;
657         coords[1] = y;
658         draw_polygon(fe, coords, 3, TRUE, COL_HIGHLIGHT);
659         draw_polygon(fe, coords, 3, FALSE, COL_HIGHLIGHT);
660
661         draw_rect(fe, x + HIGHLIGHT_WIDTH, y + HIGHLIGHT_WIDTH,
662                   TILE_SIZE - 2*HIGHLIGHT_WIDTH, TILE_SIZE - 2*HIGHLIGHT_WIDTH,
663                   flash_colour);
664
665         sprintf(str, "%d", tile);
666         draw_text(fe, x + TILE_SIZE/2, y + TILE_SIZE/2,
667                   FONT_VARIABLE, TILE_SIZE/3, ALIGN_VCENTRE | ALIGN_HCENTRE,
668                   COL_TEXT, str);
669     }
670     draw_update(fe, x, y, TILE_SIZE, TILE_SIZE);
671 }
672
673 static void game_redraw(frontend *fe, game_drawstate *ds, game_state *oldstate,
674                  game_state *state, int dir, game_ui *ui,
675                  float animtime, float flashtime)
676 {
677     int i, pass, bgcolour;
678
679     if (flashtime > 0) {
680         int frame = (int)(flashtime / FLASH_FRAME);
681         bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
682     } else
683         bgcolour = COL_BACKGROUND;
684
685     if (!ds->started) {
686         int coords[10];
687
688         draw_rect(fe, 0, 0,
689                   TILE_SIZE * state->w + 2 * BORDER,
690                   TILE_SIZE * state->h + 2 * BORDER, COL_BACKGROUND);
691         draw_update(fe, 0, 0,
692                     TILE_SIZE * state->w + 2 * BORDER,
693                     TILE_SIZE * state->h + 2 * BORDER);
694
695         /*
696          * Recessed area containing the whole puzzle.
697          */
698         coords[0] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
699         coords[1] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
700         coords[2] = COORD(state->w) + HIGHLIGHT_WIDTH - 1;
701         coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
702         coords[4] = coords[2] - TILE_SIZE;
703         coords[5] = coords[3] + TILE_SIZE;
704         coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
705         coords[9] = COORD(state->h) + HIGHLIGHT_WIDTH - 1;
706         coords[6] = coords[8] + TILE_SIZE;
707         coords[7] = coords[9] - TILE_SIZE;
708         draw_polygon(fe, coords, 5, TRUE, COL_HIGHLIGHT);
709         draw_polygon(fe, coords, 5, FALSE, COL_HIGHLIGHT);
710
711         coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
712         coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
713         draw_polygon(fe, coords, 5, TRUE, COL_LOWLIGHT);
714         draw_polygon(fe, coords, 5, FALSE, COL_LOWLIGHT);
715
716         ds->started = TRUE;
717     }
718
719     /*
720      * Now draw each tile. We do this in two passes to make
721      * animation easy.
722      */
723     for (pass = 0; pass < 2; pass++) {
724         for (i = 0; i < state->n; i++) {
725             int t, t0;
726             /*
727              * Figure out what should be displayed at this
728              * location. It's either a simple tile, or it's a
729              * transition between two tiles (in which case we say
730              * -1 because it must always be drawn).
731              */
732
733             if (oldstate && oldstate->tiles[i] != state->tiles[i])
734                 t = -1;
735             else
736                 t = state->tiles[i];
737
738             t0 = t;
739
740             if (ds->bgcolour != bgcolour ||   /* always redraw when flashing */
741                 ds->tiles[i] != t || ds->tiles[i] == -1 || t == -1) {
742                 int x, y;
743
744                 /*
745                  * Figure out what to _actually_ draw, and where to
746                  * draw it.
747                  */
748                 if (t == -1) {
749                     int x0, y0, x1, y1;
750                     int j;
751
752                     /*
753                      * On the first pass, just blank the tile.
754                      */
755                     if (pass == 0) {
756                         x = COORD(X(state, i));
757                         y = COORD(Y(state, i));
758                         t = 0;
759                     } else {
760                         float c;
761
762                         t = state->tiles[i];
763
764                         /*
765                          * Don't bother moving the gap; just don't
766                          * draw it.
767                          */
768                         if (t == 0)
769                             continue;
770
771                         /*
772                          * Find the coordinates of this tile in the old and
773                          * new states.
774                          */
775                         x1 = COORD(X(state, i));
776                         y1 = COORD(Y(state, i));
777                         for (j = 0; j < oldstate->n; j++)
778                             if (oldstate->tiles[j] == state->tiles[i])
779                                 break;
780                         assert(j < oldstate->n);
781                         x0 = COORD(X(state, j));
782                         y0 = COORD(Y(state, j));
783
784                         c = (animtime / ANIM_TIME);
785                         if (c < 0.0F) c = 0.0F;
786                         if (c > 1.0F) c = 1.0F;
787
788                         x = x0 + (int)(c * (x1 - x0));
789                         y = y0 + (int)(c * (y1 - y0));
790                     }
791
792                 } else {
793                     if (pass == 0)
794                         continue;
795                     x = COORD(X(state, i));
796                     y = COORD(Y(state, i));
797                 }
798
799                 draw_tile(fe, ds, state, x, y, t, bgcolour);
800             }
801             ds->tiles[i] = t0;
802         }
803     }
804     ds->bgcolour = bgcolour;
805
806     /*
807      * Update the status bar.
808      */
809     {
810         char statusbuf[256];
811
812         /*
813          * Don't show the new status until we're also showing the
814          * new _state_ - after the game animation is complete.
815          */
816         if (oldstate)
817             state = oldstate;
818
819         if (state->used_solve)
820             sprintf(statusbuf, "Moves since auto-solve: %d",
821                     state->movecount - state->completed);
822         else
823             sprintf(statusbuf, "%sMoves: %d",
824                     (state->completed ? "COMPLETED! " : ""),
825                     (state->completed ? state->completed : state->movecount));
826
827         status_bar(fe, statusbuf);
828     }
829 }
830
831 static float game_anim_length(game_state *oldstate,
832                               game_state *newstate, int dir, game_ui *ui)
833 {
834     if ((dir > 0 && newstate->just_used_solve) ||
835         (dir < 0 && oldstate->just_used_solve))
836         return 0.0F;
837     else
838         return ANIM_TIME;
839 }
840
841 static float game_flash_length(game_state *oldstate,
842                                game_state *newstate, int dir, game_ui *ui)
843 {
844     if (!oldstate->completed && newstate->completed &&
845         !oldstate->used_solve && !newstate->used_solve)
846         return 2 * FLASH_FRAME;
847     else
848         return 0.0F;
849 }
850
851 static int game_wants_statusbar(void)
852 {
853     return TRUE;
854 }
855
856 static int game_timing_state(game_state *state)
857 {
858     return TRUE;
859 }
860
861 #ifdef COMBINED
862 #define thegame fifteen
863 #endif
864
865 const struct game thegame = {
866     "Fifteen", "games.fifteen",
867     default_params,
868     game_fetch_preset,
869     decode_params,
870     encode_params,
871     free_params,
872     dup_params,
873     TRUE, game_configure, custom_params,
874     validate_params,
875     new_game_desc,
876     game_free_aux_info,
877     validate_desc,
878     new_game,
879     dup_game,
880     free_game,
881     TRUE, solve_game,
882     TRUE, game_text_format,
883     new_ui,
884     free_ui,
885     game_changed_state,
886     interpret_move,
887     execute_move,
888     game_size,
889     game_colours,
890     game_new_drawstate,
891     game_free_drawstate,
892     game_redraw,
893     game_anim_length,
894     game_flash_length,
895     game_wants_statusbar,
896     FALSE, game_timing_state,
897     0,                                 /* mouse_priorities */
898 };