midend.c

   1 /*
   2  * midend.c: general middle fragment sitting between the
   3  * platform-specific front end and game-specific back end.
   4  * Maintains a move list, takes care of Undo and Redo commands, and
   5  * processes standard keystrokes for undo/redo/new/quit.
   6  */
   7
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <assert.h>
  11 #include <stdlib.h>
  12 #include <ctype.h>
  13
  14 #include "puzzles.h"
  15
  16 enum { DEF_PARAMS, DEF_SEED, DEF_DESC };   /* for midend_game_id_int */
  17
  18 enum { NEWGAME, MOVE, SOLVE, RESTART };/* for midend_state_entry.movetype */
  19
  20 #define special(type) ( (type) != MOVE )
  21
  22 struct midend_state_entry {
  23     game_state *state;
  24     char *movestr;
  25     int movetype;
  26 };
  27
  28 struct midend_data {
  29     frontend *frontend;
  30     random_state *random;
  31     const game *ourgame;
  32
  33     game_params **presets;
  34     char **preset_names;
  35     int npresets, presetsize;
  36
  37     /*
  38      * `desc' and `privdesc' deserve a comment.
  39      *
  40      * `desc' is the game description as presented to the user when
  41      * they ask for Game -> Specific. `privdesc', if non-NULL, is a
  42      * different game description used to reconstruct the initial
  43      * game_state when de-serialising. If privdesc is NULL, `desc'
  44      * is used for both.
  45      *
  46      * For almost all games, `privdesc' is NULL and never used. The
  47      * exception (as usual) is Mines: the initial game state has no
  48      * squares open at all, but after the first click `desc' is
  49      * rewritten to describe a game state with an initial click and
  50      * thus a bunch of squares open. If we used that desc to
  51      * serialise and deserialise, then the initial game state after
  52      * deserialisation would look unlike the initial game state
  53      * beforehand, and worse still execute_move() might fail on the
  54      * attempted first click. So `privdesc' is also used in this
  55      * case, to provide a game description describing the same
  56      * fixed mine layout _but_ no initial click. (These game IDs
  57      * may also be typed directly into Mines if you like.)
  58      */
  59     char *desc, *privdesc, *seedstr;
  60     char *aux_info;
  61     enum { GOT_SEED, GOT_DESC, GOT_NOTHING } genmode;
  62
  63     int nstates, statesize, statepos;
  64     struct midend_state_entry *states;
  65
  66     game_params *params, *curparams;
  67     game_drawstate *drawstate;
  68     game_ui *ui;
  69
  70     game_state *oldstate;
  71     float anim_time, anim_pos;
  72     float flash_time, flash_pos;
  73     int dir;
  74
  75     int timing;
  76     float elapsed;
  77     char *laststatus;
  78
  79     int pressed_mouse_button;
  80
  81     int winwidth, winheight;
  82 };
  83
  84 #define ensure(me) do { \
  85     if ((me)->nstates >= (me)->statesize) { \
  86         (me)->statesize = (me)->nstates + 128; \
  87         (me)->states = sresize((me)->states, (me)->statesize, \
  88                                struct midend_state_entry); \
  89     } \
  90 } while (0)
  91
  92 midend_data *midend_new(frontend *fe, const game *ourgame)
  93 {
  94     midend_data *me = snew(midend_data);
  95     void *randseed;
  96     int randseedsize;
  97
  98     get_random_seed(&randseed, &randseedsize);
  99
 100     me->frontend = fe;
 101     me->ourgame = ourgame;
 102     me->random = random_init(randseed, randseedsize);
 103     me->nstates = me->statesize = me->statepos = 0;
 104     me->states = NULL;
 105     me->params = ourgame->default_params();
 106     me->curparams = NULL;
 107     me->desc = me->privdesc = NULL;
 108     me->seedstr = NULL;
 109     me->aux_info = NULL;
 110     me->genmode = GOT_NOTHING;
 111     me->drawstate = NULL;
 112     me->oldstate = NULL;
 113     me->presets = NULL;
 114     me->preset_names = NULL;
 115     me->npresets = me->presetsize = 0;
 116     me->anim_time = me->anim_pos = 0.0F;
 117     me->flash_time = me->flash_pos = 0.0F;
 118     me->dir = 0;
 119     me->ui = NULL;
 120     me->pressed_mouse_button = 0;
 121     me->laststatus = NULL;
 122     me->timing = FALSE;
 123     me->elapsed = 0.0F;
 124     me->winwidth = me->winheight = 0;
 125
 126     sfree(randseed);
 127
 128     return me;
 129 }
 130
 131 static void midend_free_game(midend_data *me)
 132 {
 133     while (me->nstates > 0) {
 134         me->nstates--;
 135         me->ourgame->free_game(me->states[me->nstates].state);
 136         sfree(me->states[me->nstates].movestr);
 137     }
 138
 139     if (me->drawstate)
 140         me->ourgame->free_drawstate(me->drawstate);
 141 }
 142
 143 void midend_free(midend_data *me)
 144 {
 145     int i;
 146
 147     midend_free_game(me);
 148
 149     random_free(me->random);
 150     sfree(me->states);
 151     sfree(me->desc);
 152     sfree(me->privdesc);
 153     sfree(me->seedstr);
 154     sfree(me->aux_info);
 155     me->ourgame->free_params(me->params);
 156     if (me->npresets) {
 157         for (i = 0; i < me->npresets; i++) {
 158             sfree(me->presets[i]);
 159             sfree(me->preset_names[i]);
 160         }
 161         sfree(me->presets);
 162         sfree(me->preset_names);
 163     }
 164     if (me->ui)
 165         me->ourgame->free_ui(me->ui);
 166     if (me->curparams)
 167         me->ourgame->free_params(me->curparams);
 168     sfree(me->laststatus);
 169     sfree(me);
 170 }
 171
 172 void midend_size(midend_data *me, int *x, int *y, int expand)
 173 {
 174     me->ourgame->size(me->params, me->drawstate, x, y, expand);
 175     me->winwidth = *x;
 176     me->winheight = *y;
 177 }
 178
 179 void midend_set_params(midend_data *me, game_params *params)
 180 {
 181     me->ourgame->free_params(me->params);
 182     me->params = me->ourgame->dup_params(params);
 183 }
 184
 185 static void midend_set_timer(midend_data *me)
 186 {
 187     me->timing = (me->ourgame->is_timed &&
 188                   me->ourgame->timing_state(me->states[me->statepos-1].state));
 189     if (me->timing || me->flash_time || me->anim_time)
 190         activate_timer(me->frontend);
 191     else
 192         deactivate_timer(me->frontend);
 193 }
 194
 195 static void midend_size_new_drawstate(midend_data *me)
 196 {
 197     me->ourgame->size(me->params, me->drawstate, &me->winwidth, &me->winheight,
 198                       TRUE);
 199 }
 200
 201 void midend_force_redraw(midend_data *me)
 202 {
 203     if (me->drawstate)
 204         me->ourgame->free_drawstate(me->drawstate);
 205     me->drawstate = me->ourgame->new_drawstate(me->states[0].state);
 206     midend_size_new_drawstate(me);
 207     midend_redraw(me);
 208 }
 209
 210 void midend_new_game(midend_data *me)
 211 {
 212     midend_free_game(me);
 213
 214     assert(me->nstates == 0);
 215
 216     if (me->genmode == GOT_DESC) {
 217         me->genmode = GOT_NOTHING;
 218     } else {
 219         random_state *rs;
 220
 221         if (me->genmode == GOT_SEED) {
 222             me->genmode = GOT_NOTHING;
 223         } else {
 224             /*
 225              * Generate a new random seed. 15 digits comes to about
 226              * 48 bits, which should be more than enough.
 227              *
 228              * I'll avoid putting a leading zero on the number,
 229              * just in case it confuses anybody who thinks it's
 230              * processed as an integer rather than a string.
 231              */
 232             char newseed[16];
 233             int i;
 234             newseed[15] = '\0';
 235             newseed[0] = '1' + random_upto(me->random, 9);
 236             for (i = 1; i < 15; i++)
 237                 newseed[i] = '0' + random_upto(me->random, 10);
 238             sfree(me->seedstr);
 239             me->seedstr = dupstr(newseed);
 240
 241             if (me->curparams)
 242                 me->ourgame->free_params(me->curparams);
 243             me->curparams = me->ourgame->dup_params(me->params);
 244         }
 245
 246         sfree(me->desc);
 247         sfree(me->privdesc);
 248         sfree(me->aux_info);
 249         me->aux_info = NULL;
 250
 251         rs = random_init(me->seedstr, strlen(me->seedstr));
 252         me->desc = me->ourgame->new_desc(me->curparams, rs,
 253                                          &me->aux_info, TRUE);
 254         me->privdesc = NULL;
 255         random_free(rs);
 256     }
 257
 258     ensure(me);
 259     me->states[me->nstates].state =
 260         me->ourgame->new_game(me, me->params, me->desc);
 261     me->states[me->nstates].movestr = NULL;
 262     me->states[me->nstates].movetype = NEWGAME;
 263     me->nstates++;
 264     me->statepos = 1;
 265     me->drawstate = me->ourgame->new_drawstate(me->states[0].state);
 266     midend_size_new_drawstate(me);
 267     me->elapsed = 0.0F;
 268     midend_set_timer(me);
 269     if (me->ui)
 270         me->ourgame->free_ui(me->ui);
 271     me->ui = me->ourgame->new_ui(me->states[0].state);
 272     me->pressed_mouse_button = 0;
 273 }
 274
 275 static int midend_undo(midend_data *me)
 276 {
 277     if (me->statepos > 1) {
 278         if (me->ui)
 279             me->ourgame->changed_state(me->ui,
 280                                        me->states[me->statepos-1].state,
 281                                        me->states[me->statepos-2].state);
 282         me->statepos--;
 283         me->dir = -1;
 284         return 1;
 285     } else
 286         return 0;
 287 }
 288
 289 static int midend_redo(midend_data *me)
 290 {
 291     if (me->statepos < me->nstates) {
 292         if (me->ui)
 293             me->ourgame->changed_state(me->ui,
 294                                        me->states[me->statepos-1].state,
 295                                        me->states[me->statepos].state);
 296         me->statepos++;
 297         me->dir = +1;
 298         return 1;
 299     } else
 300         return 0;
 301 }
 302
 303 static void midend_finish_move(midend_data *me)
 304 {
 305     float flashtime;
 306
 307     /*
 308      * We do not flash if the later of the two states is special.
 309      * This covers both forward Solve moves and backward (undone)
 310      * Restart moves.
 311      */
 312     if ((me->oldstate || me->statepos > 1) &&
 313         ((me->dir > 0 && !special(me->states[me->statepos-1].movetype)) ||
 314          (me->dir < 0 && me->statepos < me->nstates &&
 315           !special(me->states[me->statepos].movetype)))) {
 316         flashtime = me->ourgame->flash_length(me->oldstate ? me->oldstate :
 317                                               me->states[me->statepos-2].state,
 318                                               me->states[me->statepos-1].state,
 319                                               me->oldstate ? me->dir : +1,
 320                                               me->ui);
 321         if (flashtime > 0) {
 322             me->flash_pos = 0.0F;
 323             me->flash_time = flashtime;
 324         }
 325     }
 326
 327     if (me->oldstate)
 328         me->ourgame->free_game(me->oldstate);
 329     me->oldstate = NULL;
 330     me->anim_pos = me->anim_time = 0;
 331     me->dir = 0;
 332
 333     midend_set_timer(me);
 334 }
 335
 336 void midend_stop_anim(midend_data *me)
 337 {
 338     if (me->oldstate || me->anim_time) {
 339         midend_finish_move(me);
 340         midend_redraw(me);
 341     }
 342 }
 343
 344 void midend_restart_game(midend_data *me)
 345 {
 346     game_state *s;
 347
 348     midend_stop_anim(me);
 349
 350     assert(me->statepos >= 1);
 351     if (me->statepos == 1)
 352         return;                        /* no point doing anything at all! */
 353
 354     /*
 355      * During restart, we reconstruct the game from the (public)
 356      * game description rather than from states[0], because that
 357      * way Mines gets slightly more sensible behaviour (restart
 358      * goes to _after_ the first click so you don't have to
 359      * remember where you clicked).
 360      */
 361     s = me->ourgame->new_game(me, me->params, me->desc);
 362
 363     /*
 364      * Now enter the restarted state as the next move.
 365      */
 366     midend_stop_anim(me);
 367     while (me->nstates > me->statepos)
 368         me->ourgame->free_game(me->states[--me->nstates].state);
 369     ensure(me);
 370     me->states[me->nstates].state = s;
 371     me->states[me->nstates].movestr = dupstr(me->desc);
 372     me->states[me->nstates].movetype = RESTART;
 373     me->statepos = ++me->nstates;
 374     if (me->ui)
 375         me->ourgame->changed_state(me->ui,
 376                                    me->states[me->statepos-2].state,
 377                                    me->states[me->statepos-1].state);
 378     me->anim_time = 0.0;
 379     midend_finish_move(me);
 380     midend_redraw(me);
 381     midend_set_timer(me);
 382 }
 383
 384 static int midend_really_process_key(midend_data *me, int x, int y, int button)
 385 {
 386     game_state *oldstate =
 387         me->ourgame->dup_game(me->states[me->statepos - 1].state);
 388     int special = FALSE, gotspecial = FALSE, ret = 1;
 389     float anim_time;
 390
 391     if (button == 'n' || button == 'N' || button == '\x0E') {
 392         midend_stop_anim(me);
 393         midend_new_game(me);
 394         midend_redraw(me);
 395         goto done;                     /* never animate */
 396     } else if (button == 'u' || button == 'u' ||
 397                button == '\x1A' || button == '\x1F') {
 398         midend_stop_anim(me);
 399         special = special(me->states[me->statepos-1].movetype);
 400         gotspecial = TRUE;
 401         if (!midend_undo(me))
 402             goto done;
 403     } else if (button == 'r' || button == 'R' ||
 404                button == '\x12' || button == '\x19') {
 405         midend_stop_anim(me);
 406         if (!midend_redo(me))
 407             goto done;
 408     } else if (button == 'q' || button == 'Q' || button == '\x11') {
 409         ret = 0;
 410         goto done;
 411     } else {
 412         game_state *s;
 413         char *movestr;
 414
 415         movestr =
 416             me->ourgame->interpret_move(me->states[me->statepos-1].state,
 417                                         me->ui, me->drawstate, x, y, button);
 418         if (!movestr)
 419             s = NULL;
 420         else if (!*movestr)
 421             s = me->states[me->statepos-1].state;
 422         else {
 423             s = me->ourgame->execute_move(me->states[me->statepos-1].state,
 424                                           movestr);
 425             assert(s != NULL);
 426         }
 427
 428         if (s == me->states[me->statepos-1].state) {
 429             /*
 430              * make_move() is allowed to return its input state to
 431              * indicate that although no move has been made, the UI
 432              * state has been updated and a redraw is called for.
 433              */
 434             midend_redraw(me);
 435             goto done;
 436         } else if (s) {
 437             midend_stop_anim(me);
 438             while (me->nstates > me->statepos)
 439                 me->ourgame->free_game(me->states[--me->nstates].state);
 440             ensure(me);
 441             assert(movestr != NULL);
 442             me->states[me->nstates].state = s;
 443             me->states[me->nstates].movestr = movestr;
 444             me->states[me->nstates].movetype = MOVE;
 445             me->statepos = ++me->nstates;
 446             me->dir = +1;
 447         } else {
 448             goto done;
 449         }
 450     }
 451
 452     if (!gotspecial)
 453         special = special(me->states[me->statepos-1].movetype);
 454
 455     /*
 456      * See if this move requires an animation.
 457      */
 458     if (special) {
 459         anim_time = 0;
 460     } else {
 461         anim_time = me->ourgame->anim_length(oldstate,
 462                                              me->states[me->statepos-1].state,
 463                                              me->dir, me->ui);
 464     }
 465
 466     me->oldstate = oldstate; oldstate = NULL;
 467     if (anim_time > 0) {
 468         me->anim_time = anim_time;
 469     } else {
 470         me->anim_time = 0.0;
 471         midend_finish_move(me);
 472     }
 473     me->anim_pos = 0.0;
 474
 475     midend_redraw(me);
 476
 477     midend_set_timer(me);
 478
 479     done:
 480     if (oldstate) me->ourgame->free_game(oldstate);
 481     return ret;
 482 }
 483
 484 int midend_process_key(midend_data *me, int x, int y, int button)
 485 {
 486     int ret = 1;
 487
 488     /*
 489      * Harmonise mouse drag and release messages.
 490      *
 491      * Some front ends might accidentally switch from sending, say,
 492      * RIGHT_DRAG messages to sending LEFT_DRAG, half way through a
 493      * drag. (This can happen on the Mac, for example, since
 494      * RIGHT_DRAG is usually done using Command+drag, and if the
 495      * user accidentally releases Command half way through the drag
 496      * then there will be trouble.)
 497      *
 498      * It would be an O(number of front ends) annoyance to fix this
 499      * in the front ends, but an O(number of back ends) annoyance
 500      * to have each game capable of dealing with it. Therefore, we
 501      * fix it _here_ in the common midend code so that it only has
 502      * to be done once.
 503      *
 504      * The possible ways in which things can go screwy in the front
 505      * end are:
 506      *
 507      *  - in a system containing multiple physical buttons button
 508      *    presses can inadvertently overlap. We can see ABab (caps
 509      *    meaning button-down and lowercase meaning button-up) when
 510      *    the user had semantically intended AaBb.
 511      *
 512      *  - in a system where one button is simulated by means of a
 513      *    modifier key and another button, buttons can mutate
 514      *    between press and release (possibly during drag). So we
 515      *    can see Ab instead of Aa.
 516      *
 517      * Definite requirements are:
 518      *
 519      *  - button _presses_ must never be invented or destroyed. If
 520      *    the user presses two buttons in succession, the button
 521      *    presses must be transferred to the backend unchanged. So
 522      *    if we see AaBb , that's fine; if we see ABab (the button
 523      *    presses inadvertently overlapped) we must somehow
 524      *    `correct' it to AaBb.
 525      *
 526      *  - every mouse action must end up looking like a press, zero
 527      *    or more drags, then a release. This allows back ends to
 528      *    make the _assumption_ that incoming mouse data will be
 529      *    sane in this regard, and not worry about the details.
 530      *
 531      * So my policy will be:
 532      *
 533      *  - treat any button-up as a button-up for the currently
 534      *    pressed button, or ignore it if there is no currently
 535      *    pressed button.
 536      *
 537      *  - treat any drag as a drag for the currently pressed
 538      *    button, or ignore it if there is no currently pressed
 539      *    button.
 540      *
 541      *  - if we see a button-down while another button is currently
 542      *    pressed, invent a button-up for the first one and then
 543      *    pass the button-down through as before.
 544      *
 545      * 2005-05-31: An addendum to the above. Some games might want
 546      * a `priority order' among buttons, such that if one button is
 547      * pressed while another is down then a fixed one of the
 548      * buttons takes priority no matter what order they're pressed
 549      * in. Mines, in particular, wants to treat a left+right click
 550      * like a left click for the benefit of users of other
 551      * implementations. So the last of the above points is modified
 552      * in the presence of an (optional) button priority order.
 553      */
 554     if (IS_MOUSE_DRAG(button) || IS_MOUSE_RELEASE(button)) {
 555         if (me->pressed_mouse_button) {
 556             if (IS_MOUSE_DRAG(button)) {
 557                 button = me->pressed_mouse_button +
 558                     (LEFT_DRAG - LEFT_BUTTON);
 559             } else {
 560                 button = me->pressed_mouse_button +
 561                     (LEFT_RELEASE - LEFT_BUTTON);
 562             }
 563         } else
 564             return ret;                /* ignore it */
 565     } else if (IS_MOUSE_DOWN(button) && me->pressed_mouse_button) {
 566         /*
 567          * If the new button has lower priority than the old one,
 568          * don't bother doing this.
 569          */
 570         if (me->ourgame->mouse_priorities &
 571             BUTTON_BEATS(me->pressed_mouse_button, button))
 572             return ret;                /* just ignore it */
 573
 574         /*
 575          * Fabricate a button-up for the previously pressed button.
 576          */
 577         ret = ret && midend_really_process_key
 578             (me, x, y, (me->pressed_mouse_button +
 579                         (LEFT_RELEASE - LEFT_BUTTON)));
 580     }
 581
 582     /*
 583      * Now send on the event we originally received.
 584      */
 585     ret = ret && midend_really_process_key(me, x, y, button);
 586
 587     /*
 588      * And update the currently pressed button.
 589      */
 590     if (IS_MOUSE_RELEASE(button))
 591         me->pressed_mouse_button = 0;
 592     else if (IS_MOUSE_DOWN(button))
 593         me->pressed_mouse_button = button;
 594
 595     return ret;
 596 }
 597
 598 void midend_redraw(midend_data *me)
 599 {
 600     if (me->statepos > 0 && me->drawstate) {
 601         start_draw(me->frontend);
 602         if (me->oldstate && me->anim_time > 0 &&
 603             me->anim_pos < me->anim_time) {
 604             assert(me->dir != 0);
 605             me->ourgame->redraw(me->frontend, me->drawstate, me->oldstate,
 606                                 me->states[me->statepos-1].state, me->dir,
 607                                 me->ui, me->anim_pos, me->flash_pos);
 608         } else {
 609             me->ourgame->redraw(me->frontend, me->drawstate, NULL,
 610                                 me->states[me->statepos-1].state, +1 /*shrug*/,
 611                                 me->ui, 0.0, me->flash_pos);
 612         }
 613         end_draw(me->frontend);
 614     }
 615 }
 616
 617 void midend_timer(midend_data *me, float tplus)
 618 {
 619     me->anim_pos += tplus;
 620     if (me->anim_pos >= me->anim_time ||
 621         me->anim_time == 0 || !me->oldstate) {
 622         if (me->anim_time > 0)
 623             midend_finish_move(me);
 624     }
 625
 626     me->flash_pos += tplus;
 627     if (me->flash_pos >= me->flash_time || me->flash_time == 0) {
 628         me->flash_pos = me->flash_time = 0;
 629     }
 630
 631     midend_redraw(me);
 632
 633     if (me->timing) {
 634         float oldelapsed = me->elapsed;
 635         me->elapsed += tplus;
 636         if ((int)oldelapsed != (int)me->elapsed)
 637             status_bar(me->frontend, me->laststatus ? me->laststatus : "");
 638     }
 639
 640     midend_set_timer(me);
 641 }
 642
 643 float *midend_colours(midend_data *me, int *ncolours)
 644 {
 645     game_state *state = NULL;
 646     float *ret;
 647
 648     if (me->nstates == 0) {
 649         char *aux = NULL;
 650         char *desc = me->ourgame->new_desc(me->params, me->random,
 651                                            &aux, TRUE);
 652         state = me->ourgame->new_game(me, me->params, desc);
 653         sfree(desc);
 654         sfree(aux);
 655     } else
 656         state = me->states[0].state;
 657
 658     ret = me->ourgame->colours(me->frontend, state, ncolours);
 659
 660     {
 661         int i;
 662
 663         /*
 664          * Allow environment-based overrides for the standard
 665          * colours by defining variables along the lines of
 666          * `NET_COLOUR_4=6000c0'.
 667          */
 668
 669         for (i = 0; i < *ncolours; i++) {
 670             char buf[80], *e;
 671             unsigned int r, g, b;
 672             int j;
 673
 674             sprintf(buf, "%s_COLOUR_%d", me->ourgame->name, i);
 675             for (j = 0; buf[j]; j++)
 676                 buf[j] = toupper((unsigned char)buf[j]);
 677             if ((e = getenv(buf)) != NULL &&
 678                 sscanf(e, "%2x%2x%2x", &r, &g, &b) == 3) {
 679                 ret[i*3 + 0] = r / 255.0;
 680                 ret[i*3 + 1] = g / 255.0;
 681                 ret[i*3 + 2] = b / 255.0;
 682             }
 683         }
 684     }
 685
 686     if (me->nstates == 0)
 687         me->ourgame->free_game(state);
 688
 689     return ret;
 690 }
 691
 692 int midend_num_presets(midend_data *me)
 693 {
 694     if (!me->npresets) {
 695         char *name;
 696         game_params *preset;
 697
 698         while (me->ourgame->fetch_preset(me->npresets, &name, &preset)) {
 699             if (me->presetsize <= me->npresets) {
 700                 me->presetsize = me->npresets + 10;
 701                 me->presets = sresize(me->presets, me->presetsize,
 702                                       game_params *);
 703                 me->preset_names = sresize(me->preset_names, me->presetsize,
 704                                            char *);
 705             }
 706
 707             me->presets[me->npresets] = preset;
 708             me->preset_names[me->npresets] = name;
 709             me->npresets++;
 710         }
 711     }
 712
 713     {
 714         /*
 715          * Allow environment-based extensions to the preset list by
 716          * defining a variable along the lines of `SOLO_PRESETS=2x3
 717          * Advanced:2x3da'. Colon-separated list of items,
 718          * alternating between textual titles in the menu and
 719          * encoded parameter strings.
 720          */
 721         char buf[80], *e, *p;
 722         int j;
 723
 724         sprintf(buf, "%s_PRESETS", me->ourgame->name);
 725         for (j = 0; buf[j]; j++)
 726             buf[j] = toupper((unsigned char)buf[j]);
 727
 728         if ((e = getenv(buf)) != NULL) {
 729             p = e = dupstr(e);
 730
 731             while (*p) {
 732                 char *name, *val;
 733                 game_params *preset;
 734
 735                 name = p;
 736                 while (*p && *p != ':') p++;
 737                 if (*p) *p++ = '\0';
 738                 val = p;
 739                 while (*p && *p != ':') p++;
 740                 if (*p) *p++ = '\0';
 741
 742                 preset = me->ourgame->default_params();
 743                 me->ourgame->decode_params(preset, val);
 744
 745                 if (me->ourgame->validate_params(preset)) {
 746                     /* Drop this one from the list. */
 747                     me->ourgame->free_params(preset);
 748                     continue;
 749                 }
 750
 751                 if (me->presetsize <= me->npresets) {
 752                     me->presetsize = me->npresets + 10;
 753                     me->presets = sresize(me->presets, me->presetsize,
 754                                           game_params *);
 755                     me->preset_names = sresize(me->preset_names,
 756                                                me->presetsize, char *);
 757                 }
 758
 759                 me->presets[me->npresets] = preset;
 760                 me->preset_names[me->npresets] = dupstr(name);
 761                 me->npresets++;
 762             }
 763         }
 764     }
 765
 766     return me->npresets;
 767 }
 768
 769 void midend_fetch_preset(midend_data *me, int n,
 770                          char **name, game_params **params)
 771 {
 772     assert(n >= 0 && n < me->npresets);
 773     *name = me->preset_names[n];
 774     *params = me->presets[n];
 775 }
 776
 777 int midend_wants_statusbar(midend_data *me)
 778 {
 779     return me->ourgame->wants_statusbar();
 780 }
 781
 782 void midend_supersede_game_desc(midend_data *me, char *desc, char *privdesc)
 783 {
 784     sfree(me->desc);
 785     sfree(me->privdesc);
 786     me->desc = dupstr(desc);
 787     me->privdesc = privdesc ? dupstr(privdesc) : NULL;
 788 }
 789
 790 config_item *midend_get_config(midend_data *me, int which, char **wintitle)
 791 {
 792     char *titlebuf, *parstr, *rest;
 793     config_item *ret;
 794     char sep;
 795
 796     assert(wintitle);
 797     titlebuf = snewn(40 + strlen(me->ourgame->name), char);
 798
 799     switch (which) {
 800       case CFG_SETTINGS:
 801         sprintf(titlebuf, "%s configuration", me->ourgame->name);
 802         *wintitle = titlebuf;
 803         return me->ourgame->configure(me->params);
 804       case CFG_SEED:
 805       case CFG_DESC:
 806         if (!me->curparams) {
 807           sfree(titlebuf);
 808           return NULL;
 809         }
 810         sprintf(titlebuf, "%s %s selection", me->ourgame->name,
 811                 which == CFG_SEED ? "random" : "game");
 812         *wintitle = titlebuf;
 813
 814         ret = snewn(2, config_item);
 815
 816         ret[0].type = C_STRING;
 817         if (which == CFG_SEED)
 818             ret[0].name = "Game random seed";
 819         else
 820             ret[0].name = "Game ID";
 821         ret[0].ival = 0;
 822         /*
 823          * For CFG_DESC the text going in here will be a string
 824          * encoding of the restricted parameters, plus a colon,
 825          * plus the game description. For CFG_SEED it will be the
 826          * full parameters, plus a hash, plus the random seed data.
 827          * Either of these is a valid full game ID (although only
 828          * the former is likely to persist across many code
 829          * changes).
 830          */
 831         parstr = me->ourgame->encode_params(me->curparams, which == CFG_SEED);
 832         assert(parstr);
 833         if (which == CFG_DESC) {
 834             rest = me->desc ? me->desc : "";
 835             sep = ':';
 836         } else {
 837             rest = me->seedstr ? me->seedstr : "";
 838             sep = '#';
 839         }
 840         ret[0].sval = snewn(strlen(parstr) + strlen(rest) + 2, char);
 841         sprintf(ret[0].sval, "%s%c%s", parstr, sep, rest);
 842         sfree(parstr);
 843
 844         ret[1].type = C_END;
 845         ret[1].name = ret[1].sval = NULL;
 846         ret[1].ival = 0;
 847
 848         return ret;
 849     }
 850
 851     assert(!"We shouldn't be here");
 852     return NULL;
 853 }
 854
 855 static char *midend_game_id_int(midend_data *me, char *id, int defmode)
 856 {
 857     char *error, *par, *desc, *seed;
 858     game_params *newcurparams, *newparams, *oldparams1, *oldparams2;
 859     int free_params;
 860
 861     seed = strchr(id, '#');
 862     desc = strchr(id, ':');
 863
 864     if (desc && (!seed || desc < seed)) {
 865         /*
 866          * We have a colon separating parameters from game
 867          * description. So `par' now points to the parameters
 868          * string, and `desc' to the description string.
 869          */
 870         *desc++ = '\0';
 871         par = id;
 872         seed = NULL;
 873     } else if (seed && (!desc || seed < desc)) {
 874         /*
 875          * We have a hash separating parameters from random seed.
 876          * So `par' now points to the parameters string, and `seed'
 877          * to the seed string.
 878          */
 879         *seed++ = '\0';
 880         par = id;
 881         desc = NULL;
 882     } else {
 883         /*
 884          * We only have one string. Depending on `defmode', we take
 885          * it to be either parameters, seed or description.
 886          */
 887         if (defmode == DEF_SEED) {
 888             seed = id;
 889             par = desc = NULL;
 890         } else if (defmode == DEF_DESC) {
 891             desc = id;
 892             par = seed = NULL;
 893         } else {
 894             par = id;
 895             seed = desc = NULL;
 896         }
 897     }
 898
 899     /*
 900      * We must be reasonably careful here not to modify anything in
 901      * `me' until we have finished validating things. This function
 902      * must either return an error and do nothing to the midend, or
 903      * return success and do everything; nothing in between is
 904      * acceptable.
 905      */
 906     newcurparams = newparams = oldparams1 = oldparams2 = NULL;
 907
 908     if (par) {
 909         newcurparams = me->ourgame->dup_params(me->params);
 910         me->ourgame->decode_params(newcurparams, par);
 911         error = me->ourgame->validate_params(newcurparams);
 912         if (error) {
 913             me->ourgame->free_params(newcurparams);
 914             return error;
 915         }
 916         oldparams1 = me->curparams;
 917
 918         /*
 919          * Now filter only the persistent parts of this state into
 920          * the long-term params structure, unless we've _only_
 921          * received a params string in which case the whole lot is
 922          * persistent.
 923          */
 924         oldparams2 = me->params;
 925         if (seed || desc) {
 926             char *tmpstr;
 927
 928             newparams = me->ourgame->dup_params(me->params);
 929
 930             tmpstr = me->ourgame->encode_params(newcurparams, FALSE);
 931             me->ourgame->decode_params(newparams, tmpstr);
 932
 933             sfree(tmpstr);
 934         } else {
 935             newparams = me->ourgame->dup_params(newcurparams);
 936         }
 937         free_params = TRUE;
 938     } else {
 939         newcurparams = me->curparams;
 940         newparams = me->params;
 941         free_params = FALSE;
 942     }
 943
 944     if (desc) {
 945         error = me->ourgame->validate_desc(newparams, desc);
 946         if (error) {
 947             if (free_params) {
 948                 if (newcurparams)
 949                     me->ourgame->free_params(newcurparams);
 950                 if (newparams)
 951                     me->ourgame->free_params(newparams);
 952             }
 953             return error;
 954         }
 955     }
 956
 957     /*
 958      * Now we've got past all possible error points. Update the
 959      * midend itself.
 960      */
 961     me->params = newparams;
 962     me->curparams = newcurparams;
 963     if (oldparams1)
 964         me->ourgame->free_params(oldparams1);
 965     if (oldparams2)
 966         me->ourgame->free_params(oldparams2);
 967
 968     sfree(me->desc);
 969     sfree(me->privdesc);
 970     me->desc = me->privdesc = NULL;
 971     sfree(me->seedstr);
 972     me->seedstr = NULL;
 973
 974     if (desc) {
 975         me->desc = dupstr(desc);
 976         me->genmode = GOT_DESC;
 977         sfree(me->aux_info);
 978         me->aux_info = NULL;
 979     }
 980
 981     if (seed) {
 982         me->seedstr = dupstr(seed);
 983         me->genmode = GOT_SEED;
 984     }
 985
 986     return NULL;
 987 }
 988
 989 char *midend_game_id(midend_data *me, char *id)
 990 {
 991     return midend_game_id_int(me, id, DEF_PARAMS);
 992 }
 993
 994 char *midend_set_config(midend_data *me, int which, config_item *cfg)
 995 {
 996     char *error;
 997     game_params *params;
 998
 999     switch (which) {
1000       case CFG_SETTINGS:
1001         params = me->ourgame->custom_params(cfg);
1002         error = me->ourgame->validate_params(params);
1003
1004         if (error) {
1005             me->ourgame->free_params(params);
1006             return error;
1007         }
1008
1009         me->ourgame->free_params(me->params);
1010         me->params = params;
1011         break;
1012
1013       case CFG_SEED:
1014       case CFG_DESC:
1015         error = midend_game_id_int(me, cfg[0].sval,
1016                                    (which == CFG_SEED ? DEF_SEED : DEF_DESC));
1017         if (error)
1018             return error;
1019         break;
1020     }
1021
1022     return NULL;
1023 }
1024
1025 char *midend_text_format(midend_data *me)
1026 {
1027     if (me->ourgame->can_format_as_text && me->statepos > 0)
1028         return me->ourgame->text_format(me->states[me->statepos-1].state);
1029     else
1030         return NULL;
1031 }
1032
1033 char *midend_solve(midend_data *me)
1034 {
1035     game_state *s;
1036     char *msg, *movestr;
1037
1038     if (!me->ourgame->can_solve)
1039         return "This game does not support the Solve operation";
1040
1041     if (me->statepos < 1)
1042         return "No game set up to solve";   /* _shouldn't_ happen! */
1043
1044     msg = "Solve operation failed";    /* game _should_ overwrite on error */
1045     movestr = me->ourgame->solve(me->states[0].state,
1046                                  me->states[me->statepos-1].state,
1047                                  me->aux_info, &msg);
1048     if (!movestr)
1049         return msg;
1050     s = me->ourgame->execute_move(me->states[me->statepos-1].state, movestr);
1051     assert(s);
1052
1053     /*
1054      * Now enter the solved state as the next move.
1055      */
1056     midend_stop_anim(me);
1057     while (me->nstates > me->statepos)
1058         me->ourgame->free_game(me->states[--me->nstates].state);
1059     ensure(me);
1060     me->states[me->nstates].state = s;
1061     me->states[me->nstates].movestr = movestr;
1062     me->states[me->nstates].movetype = SOLVE;
1063     me->statepos = ++me->nstates;
1064     if (me->ui)
1065         me->ourgame->changed_state(me->ui,
1066                                    me->states[me->statepos-2].state,
1067                                    me->states[me->statepos-1].state);
1068     me->anim_time = 0.0;
1069     midend_finish_move(me);
1070     midend_redraw(me);
1071     midend_set_timer(me);
1072     return NULL;
1073 }
1074
1075 char *midend_rewrite_statusbar(midend_data *me, char *text)
1076 {
1077     /*
1078      * An important special case is that we are occasionally called
1079      * with our own laststatus, to update the timer.
1080      */
1081     if (me->laststatus != text) {
1082         sfree(me->laststatus);
1083         me->laststatus = dupstr(text);
1084     }
1085
1086     if (me->ourgame->is_timed) {
1087         char timebuf[100], *ret;
1088         int min, sec;
1089
1090         sec = me->elapsed;
1091         min = sec / 60;
1092         sec %= 60;
1093         sprintf(timebuf, "[%d:%02d] ", min, sec);
1094
1095         ret = snewn(strlen(timebuf) + strlen(text) + 1, char);
1096         strcpy(ret, timebuf);
1097         strcat(ret, text);
1098         return ret;
1099
1100     } else {
1101         return dupstr(text);
1102     }
1103 }
1104
1105 #define SERIALISE_MAGIC "Simon Tatham's Portable Puzzle Collection"
1106 #define SERIALISE_VERSION "1"
1107
1108 void midend_serialise(midend_data *me,
1109                       void (*write)(void *ctx, void *buf, int len),
1110                       void *wctx)
1111 {
1112     int i;
1113
1114     /*
1115      * Each line of the save file contains three components. First
1116      * exactly 8 characters of header word indicating what type of
1117      * data is contained on the line; then a colon followed by a
1118      * decimal integer giving the length of the main string on the
1119      * line; then a colon followed by the string itself (exactly as
1120      * many bytes as previously specified, no matter what they
1121      * contain). Then a newline (of reasonably flexible form).
1122      */
1123 #define wr(h,s) do { \
1124     char hbuf[80]; \
1125     char *str = (s); \
1126     sprintf(hbuf, "%-8.8s:%d:", (h), (int)strlen(str)); \
1127     write(wctx, hbuf, strlen(hbuf)); \
1128     write(wctx, str, strlen(str)); \
1129     write(wctx, "\n", 1); \
1130 } while (0)
1131
1132     /*
1133      * Magic string identifying the file, and version number of the
1134      * file format.
1135      */
1136     wr("SAVEFILE", SERIALISE_MAGIC);
1137     wr("VERSION", SERIALISE_VERSION);
1138
1139     /*
1140      * The game name. (Copied locally to avoid const annoyance.)
1141      */
1142     {
1143         char *s = dupstr(me->ourgame->name);
1144         wr("GAME", s);
1145         sfree(s);
1146     }
1147
1148     /*
1149      * The current long-term parameters structure, in full.
1150      */
1151     if (me->params) {
1152         char *s = me->ourgame->encode_params(me->params, TRUE);
1153         wr("PARAMS", s);
1154         sfree(s);
1155     }
1156
1157     /*
1158      * The current short-term parameters structure, in full.
1159      */
1160     if (me->curparams) {
1161         char *s = me->ourgame->encode_params(me->curparams, TRUE);
1162         wr("CPARAMS", s);
1163         sfree(s);
1164     }
1165
1166     /*
1167      * The current game description, the privdesc, and the random seed.
1168      */
1169     if (me->seedstr)
1170         wr("SEED", me->seedstr);
1171     if (me->desc)
1172         wr("DESC", me->desc);
1173     if (me->privdesc)
1174         wr("PRIVDESC", me->privdesc);
1175
1176     /*
1177      * The game's aux_info. We obfuscate this to prevent spoilers
1178      * (people are likely to run `head' or similar on a saved game
1179      * file simply to find out what it is, and don't necessarily
1180      * want to be told the answer to the puzzle!)
1181      */
1182     if (me->aux_info) {
1183         unsigned char *s1;
1184         char *s2;
1185         int len;
1186
1187         len = strlen(me->aux_info);
1188         s1 = snewn(len, unsigned char);
1189         memcpy(s1, me->aux_info, len);
1190         obfuscate_bitmap(s1, len*8, FALSE);
1191         s2 = bin2hex(s1, len);
1192
1193         wr("AUXINFO", s2);
1194
1195         sfree(s2);
1196         sfree(s1);
1197     }
1198
1199     /*
1200      * Any required serialisation of the game_ui.
1201      */
1202     if (me->ui) {
1203         char *s = me->ourgame->encode_ui(me->ui);
1204         if (s) {
1205             wr("UI", s);
1206             sfree(s);
1207         }
1208     }
1209
1210     /*
1211      * The game time, if it's a timed game.
1212      */
1213     if (me->ourgame->is_timed) {
1214         char buf[80];
1215         sprintf(buf, "%g", me->elapsed);
1216         wr("TIME", buf);
1217     }
1218
1219     /*
1220      * The length of, and position in, the states list.
1221      */
1222     {
1223         char buf[80];
1224         sprintf(buf, "%d", me->nstates);
1225         wr("NSTATES", buf);
1226         sprintf(buf, "%d", me->statepos);
1227         wr("STATEPOS", buf);
1228     }
1229
1230     /*
1231      * For each state after the initial one (which we know is
1232      * constructed from either privdesc or desc), enough
1233      * information for execute_move() to reconstruct it from the
1234      * previous one.
1235      */
1236     for (i = 1; i < me->nstates; i++) {
1237         assert(me->states[i].movetype != NEWGAME);   /* only state 0 */
1238         switch (me->states[i].movetype) {
1239           case MOVE:
1240             wr("MOVE", me->states[i].movestr);
1241             break;
1242           case SOLVE:
1243             wr("SOLVE", me->states[i].movestr);
1244             break;
1245           case RESTART:
1246             wr("RESTART", me->states[i].movestr);
1247             break;
1248         }
1249     }
1250
1251 #undef wr
1252 }
1253
1254 /*
1255  * This function returns NULL on success, or an error message.
1256  */
1257 char *midend_deserialise(midend_data *me,
1258                          int (*read)(void *ctx, void *buf, int len),
1259                          void *rctx)
1260 {
1261     int nstates = 0, statepos = -1, gotstates = 0;
1262     int started = FALSE;
1263     int i;
1264
1265     char *val = NULL;
1266     /* Initially all errors give the same report */
1267     char *ret = "Data does not appear to be a saved game file";
1268
1269     /*
1270      * We construct all the new state in local variables while we
1271      * check its sanity. Only once we have finished reading the
1272      * serialised data and detected no errors at all do we start
1273      * modifying stuff in the midend_data passed in.
1274      */
1275     char *seed = NULL, *parstr = NULL, *desc = NULL, *privdesc = NULL;
1276     char *auxinfo = NULL, *uistr = NULL, *cparstr = NULL;
1277     float elapsed = 0.0F;
1278     game_params *params = NULL, *cparams = NULL;
1279     game_ui *ui = NULL;
1280     struct midend_state_entry *states = NULL;
1281
1282     /*
1283      * Loop round and round reading one key/value pair at a time
1284      * from the serialised stream, until we have enough game states
1285      * to finish.
1286      */
1287     while (nstates <= 0 || statepos < 0 || gotstates < nstates-1) {
1288         char key[9], c;
1289         int len;
1290
1291         do {
1292             if (!read(rctx, key, 1)) {
1293                 /* unexpected EOF */
1294                 goto cleanup;
1295             }
1296         } while (key[0] == '\r' || key[0] == '\n');
1297
1298         if (!read(rctx, key+1, 8)) {
1299             /* unexpected EOF */
1300             goto cleanup;
1301         }
1302
1303         if (key[8] != ':') {
1304             if (started)
1305                 ret = "Data was incorrectly formatted for a saved game file";
1306         }
1307         len = strcspn(key, ": ");
1308         assert(len <= 8);
1309         key[len] = '\0';
1310
1311         len = 0;
1312         while (1) {
1313             if (!read(rctx, &c, 1)) {
1314                 /* unexpected EOF */
1315                 goto cleanup;
1316             }
1317
1318             if (c == ':') {
1319                 break;
1320             } else if (c >= '0' && c <= '9') {
1321                 len = (len * 10) + (c - '0');
1322             } else {
1323                 if (started)
1324                     ret = "Data was incorrectly formatted for a"
1325                     " saved game file";
1326                 goto cleanup;
1327             }
1328         }
1329
1330         val = snewn(len+1, char);
1331         if (!read(rctx, val, len)) {
1332             if (started)
1333             goto cleanup;
1334         }
1335         val[len] = '\0';
1336
1337         if (!started) {
1338             if (strcmp(key, "SAVEFILE") || strcmp(val, SERIALISE_MAGIC)) {
1339                 /* ret already has the right message in it */
1340                 goto cleanup;
1341             }
1342             /* Now most errors are this one, unless otherwise specified */
1343             ret = "Saved data ended unexpectedly";
1344             started = TRUE;
1345         } else {
1346             if (!strcmp(key, "VERSION")) {
1347                 if (strcmp(val, SERIALISE_VERSION)) {
1348                     ret = "Cannot handle this version of the saved game"
1349                         " file format";
1350                     goto cleanup;
1351                 }
1352             } else if (!strcmp(key, "GAME")) {
1353                 if (strcmp(val, me->ourgame->name)) {
1354                     ret = "Save file is from a different game";
1355                     goto cleanup;
1356                 }
1357             } else if (!strcmp(key, "PARAMS")) {
1358                 sfree(parstr);
1359                 parstr = val;
1360                 val = NULL;
1361             } else if (!strcmp(key, "CPARAMS")) {
1362                 sfree(cparstr);
1363                 cparstr = val;
1364                 val = NULL;
1365             } else if (!strcmp(key, "SEED")) {
1366                 sfree(seed);
1367                 seed = val;
1368                 val = NULL;
1369             } else if (!strcmp(key, "DESC")) {
1370                 sfree(desc);
1371                 desc = val;
1372                 val = NULL;
1373             } else if (!strcmp(key, "PRIVDESC")) {
1374                 sfree(privdesc);
1375                 privdesc = val;
1376                 val = NULL;
1377             } else if (!strcmp(key, "AUXINFO")) {
1378                 unsigned char *tmp;
1379                 int len = strlen(val) / 2;   /* length in bytes */
1380                 tmp = hex2bin(val, len);
1381                 obfuscate_bitmap(tmp, len*8, TRUE);
1382
1383                 sfree(auxinfo);
1384                 auxinfo = snewn(len + 1, char);
1385                 memcpy(auxinfo, tmp, len);
1386                 auxinfo[len] = '\0';
1387                 sfree(tmp);
1388             } else if (!strcmp(key, "UI")) {
1389                 sfree(uistr);
1390                 uistr = val;
1391                 val = NULL;
1392             } else if (!strcmp(key, "TIME")) {
1393                 elapsed = atof(val);
1394             } else if (!strcmp(key, "NSTATES")) {
1395                 nstates = atoi(val);
1396                 if (nstates <= 0) {
1397                     ret = "Number of states in save file was negative";
1398                     goto cleanup;
1399                 }
1400                 if (states) {
1401                     ret = "Two state counts provided in save file";
1402                     goto cleanup;
1403                 }
1404                 states = snewn(nstates, struct midend_state_entry);
1405                 for (i = 0; i < nstates; i++) {
1406                     states[i].state = NULL;
1407                     states[i].movestr = NULL;
1408                     states[i].movetype = NEWGAME;
1409                 }
1410             } else if (!strcmp(key, "STATEPOS")) {
1411                 statepos = atoi(val);
1412             } else if (!strcmp(key, "MOVE")) {
1413                 gotstates++;
1414                 states[gotstates].movetype = MOVE;
1415                 states[gotstates].movestr = val;
1416                 val = NULL;
1417             } else if (!strcmp(key, "SOLVE")) {
1418                 gotstates++;
1419                 states[gotstates].movetype = SOLVE;
1420                 states[gotstates].movestr = val;
1421                 val = NULL;
1422             } else if (!strcmp(key, "RESTART")) {
1423                 gotstates++;
1424                 states[gotstates].movetype = RESTART;
1425                 states[gotstates].movestr = val;
1426                 val = NULL;
1427             }
1428         }
1429
1430         sfree(val);
1431         val = NULL;
1432     }
1433
1434     params = me->ourgame->default_params();
1435     me->ourgame->decode_params(params, parstr);
1436     if (me->ourgame->validate_params(params)) {
1437         ret = "Long-term parameters in save file are invalid";
1438         goto cleanup;
1439     }
1440     cparams = me->ourgame->default_params();
1441     me->ourgame->decode_params(cparams, cparstr);
1442     if (me->ourgame->validate_params(cparams)) {
1443         ret = "Short-term parameters in save file are invalid";
1444         goto cleanup;
1445     }
1446     if (!desc) {
1447         ret = "Game description in save file is missing";
1448         goto cleanup;
1449     } else if (me->ourgame->validate_desc(params, desc)) {
1450         ret = "Game description in save file is invalid";
1451         goto cleanup;
1452     }
1453     if (privdesc && me->ourgame->validate_desc(params, privdesc)) {
1454         ret = "Game private description in save file is invalid";
1455         goto cleanup;
1456     }
1457     if (statepos < 0 || statepos >= nstates) {
1458         ret = "Game position in save file is out of range";
1459     }
1460
1461     states[0].state = me->ourgame->new_game(me, params,
1462                                             privdesc ? privdesc : desc);
1463     for (i = 1; i < nstates; i++) {
1464         assert(states[i].movetype != NEWGAME);
1465         switch (states[i].movetype) {
1466           case MOVE:
1467           case SOLVE:
1468             states[i].state = me->ourgame->execute_move(states[i-1].state,
1469                                                         states[i].movestr);
1470             if (states[i].state == NULL) {
1471                 ret = "Save file contained an invalid move";
1472                 goto cleanup;
1473             }
1474             break;
1475           case RESTART:
1476             if (me->ourgame->validate_desc(params, states[i].movestr)) {
1477                 ret = "Save file contained an invalid restart move";
1478                 goto cleanup;
1479             }
1480             states[i].state = me->ourgame->new_game(me, params,
1481                                                     states[i].movestr);
1482             break;
1483         }
1484     }
1485
1486     ui = me->ourgame->new_ui(states[0].state);
1487     me->ourgame->decode_ui(ui, uistr);
1488
1489     /*
1490      * Now we've run out of possible error conditions, so we're
1491      * ready to start overwriting the real data in the current
1492      * midend. We'll do this by swapping things with the local
1493      * variables, so that the same cleanup code will free the old
1494      * stuff.
1495      */
1496     {
1497         char *tmp;
1498
1499         tmp = me->desc;
1500         me->desc = desc;
1501         desc = tmp;
1502
1503         tmp = me->privdesc;
1504         me->privdesc = privdesc;
1505         privdesc = tmp;
1506
1507         tmp = me->seedstr;
1508         me->seedstr = seed;
1509         seed = tmp;
1510
1511         tmp = me->aux_info;
1512         me->aux_info = auxinfo;
1513         auxinfo = tmp;
1514     }
1515
1516     me->genmode = GOT_NOTHING;
1517
1518     me->statesize = nstates;
1519     nstates = me->nstates;
1520     me->nstates = me->statesize;
1521     {
1522         struct midend_state_entry *tmp;
1523         tmp = me->states;
1524         me->states = states;
1525         states = tmp;
1526     }
1527     me->statepos = statepos;
1528
1529     {
1530         game_params *tmp;
1531
1532         tmp = me->params;
1533         me->params = params;
1534         params = tmp;
1535
1536         tmp = me->curparams;
1537         me->curparams = cparams;
1538         cparams = tmp;
1539     }
1540
1541     me->oldstate = NULL;
1542     me->anim_time = me->anim_pos = me->flash_time = me->flash_pos = 0.0F;
1543     me->dir = 0;
1544
1545     {
1546         game_ui *tmp;
1547
1548         tmp = me->ui;
1549         me->ui = ui;
1550         ui = tmp;
1551     }
1552
1553     me->elapsed = elapsed;
1554     me->pressed_mouse_button = 0;
1555
1556     midend_set_timer(me);
1557
1558     if (me->drawstate)
1559         me->ourgame->free_drawstate(me->drawstate);
1560     me->drawstate =
1561         me->ourgame->new_drawstate(me->states[me->statepos-1].state);
1562     midend_size_new_drawstate(me);
1563
1564     ret = NULL;                        /* success! */
1565
1566     cleanup:
1567     sfree(val);
1568     sfree(seed);
1569     sfree(parstr);
1570     sfree(cparstr);
1571     sfree(desc);
1572     sfree(privdesc);
1573     sfree(auxinfo);
1574     sfree(uistr);
1575     if (params)
1576         me->ourgame->free_params(params);
1577     if (cparams)
1578         me->ourgame->free_params(cparams);
1579     if (ui)
1580         me->ourgame->free_ui(ui);
1581     if (states) {
1582         int i;
1583
1584         for (i = 0; i < nstates; i++) {
1585             if (states[i].state)
1586                 me->ourgame->free_game(states[i].state);
1587             sfree(states[i].movestr);
1588         }
1589         sfree(states);
1590     }
1591
1592     return ret;
1593 }