mdw@git.distorted.org.uk Git - sgt/puzzles/blob - 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/restart/quit.
   6  */
   7
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <assert.h>
  11
  12 #include "puzzles.h"
  13
  14 struct midend_data {
  15     frontend *frontend;
  16     random_state *random;
  17     const game *ourgame;
  18
  19     char *seed;
  20     int fresh_seed;
  21     int nstates, statesize, statepos;
  22
  23     game_params **presets;
  24     char **preset_names;
  25     int npresets, presetsize;
  26
  27     game_params *params;
  28     game_state **states;
  29     game_drawstate *drawstate;
  30     game_state *oldstate;
  31     game_ui *ui;
  32     float anim_time, anim_pos;
  33     float flash_time, flash_pos;
  34     int dir;
  35 };
  36
  37 #define ensure(me) do { \
  38     if ((me)->nstates >= (me)->statesize) { \
  39         (me)->statesize = (me)->nstates + 128; \
  40         (me)->states = sresize((me)->states, (me)->statesize, game_state *); \
  41     } \
  42 } while (0)
  43
  44 midend_data *midend_new(frontend *fe, const game *ourgame)
  45 {
  46     midend_data *me = snew(midend_data);
  47     void *randseed;
  48     int randseedsize;
  49
  50     get_random_seed(&randseed, &randseedsize);
  51
  52     me->frontend = fe;
  53     me->ourgame = ourgame;
  54     me->random = random_init(randseed, randseedsize);
  55     me->nstates = me->statesize = me->statepos = 0;
  56     me->states = NULL;
  57     me->params = ourgame->default_params();
  58     me->seed = NULL;
  59     me->fresh_seed = FALSE;
  60     me->drawstate = NULL;
  61     me->oldstate = NULL;
  62     me->presets = NULL;
  63     me->preset_names = NULL;
  64     me->npresets = me->presetsize = 0;
  65     me->anim_time = me->anim_pos = 0.0F;
  66     me->flash_time = me->flash_pos = 0.0F;
  67     me->dir = 0;
  68     me->ui = NULL;
  69
  70     sfree(randseed);
  71
  72     return me;
  73 }
  74
  75 void midend_free(midend_data *me)
  76 {
  77     sfree(me->states);
  78     sfree(me->seed);
  79     me->ourgame->free_params(me->params);
  80     sfree(me);
  81 }
  82
  83 void midend_size(midend_data *me, int *x, int *y)
  84 {
  85     me->ourgame->size(me->params, x, y);
  86 }
  87
  88 void midend_set_params(midend_data *me, game_params *params)
  89 {
  90     me->ourgame->free_params(me->params);
  91     me->params = me->ourgame->dup_params(params);
  92 }
  93
  94 void midend_new_game(midend_data *me)
  95 {
  96     while (me->nstates > 0)
  97         me->ourgame->free_game(me->states[--me->nstates]);
  98
  99     if (me->drawstate)
 100         me->ourgame->free_drawstate(me->drawstate);
 101
 102     assert(me->nstates == 0);
 103
 104     if (!me->fresh_seed) {
 105         sfree(me->seed);
 106         me->seed = me->ourgame->new_seed(me->params, me->random);
 107     } else
 108         me->fresh_seed = FALSE;
 109
 110     ensure(me);
 111     me->states[me->nstates++] = me->ourgame->new_game(me->params, me->seed);
 112     me->statepos = 1;
 113     me->drawstate = me->ourgame->new_drawstate(me->states[0]);
 114     if (me->ui)
 115         me->ourgame->free_ui(me->ui);
 116     me->ui = me->ourgame->new_ui(me->states[0]);
 117 }
 118
 119 void midend_restart_game(midend_data *me)
 120 {
 121     while (me->nstates > 1)
 122         me->ourgame->free_game(me->states[--me->nstates]);
 123     me->statepos = me->nstates;
 124     me->ourgame->free_ui(me->ui);
 125     me->ui = me->ourgame->new_ui(me->states[0]);
 126 }
 127
 128 static int midend_undo(midend_data *me)
 129 {
 130     if (me->statepos > 1) {
 131         me->statepos--;
 132         me->dir = -1;
 133         return 1;
 134     } else
 135         return 0;
 136 }
 137
 138 static int midend_redo(midend_data *me)
 139 {
 140     if (me->statepos < me->nstates) {
 141         me->statepos++;
 142         me->dir = +1;
 143         return 1;
 144     } else
 145         return 0;
 146 }
 147
 148 static void midend_finish_move(midend_data *me)
 149 {
 150     float flashtime;
 151
 152     if (me->oldstate || me->statepos > 1) {
 153         flashtime = me->ourgame->flash_length(me->oldstate ? me->oldstate :
 154                                               me->states[me->statepos-2],
 155                                               me->states[me->statepos-1],
 156                                               me->oldstate ? me->dir : +1);
 157         if (flashtime > 0) {
 158             me->flash_pos = 0.0F;
 159             me->flash_time = flashtime;
 160         }
 161     }
 162
 163     if (me->oldstate)
 164         me->ourgame->free_game(me->oldstate);
 165     me->oldstate = NULL;
 166     me->anim_pos = me->anim_time = 0;
 167     me->dir = 0;
 168
 169     if (me->flash_time == 0 && me->anim_time == 0)
 170         deactivate_timer(me->frontend);
 171     else
 172         activate_timer(me->frontend);
 173 }
 174
 175 static void midend_stop_anim(midend_data *me)
 176 {
 177     if (me->oldstate || me->anim_time) {
 178         midend_finish_move(me);
 179         midend_redraw(me);
 180     }
 181 }
 182
 183 int midend_process_key(midend_data *me, int x, int y, int button)
 184 {
 185     game_state *oldstate = me->ourgame->dup_game(me->states[me->statepos - 1]);
 186     float anim_time;
 187
 188     if (button == 'n' || button == 'N' || button == '\x0E') {
 189         midend_stop_anim(me);
 190         midend_new_game(me);
 191         midend_redraw(me);
 192         return 1;                      /* never animate */
 193     } else if (button == 'r' || button == 'R') {
 194         midend_stop_anim(me);
 195         midend_restart_game(me);
 196         midend_redraw(me);
 197         return 1;                      /* never animate */
 198     } else if (button == 'u' || button == 'u' ||
 199                button == '\x1A' || button == '\x1F') {
 200         midend_stop_anim(me);
 201         if (!midend_undo(me))
 202             return 1;
 203     } else if (button == '\x12') {
 204         midend_stop_anim(me);
 205         if (!midend_redo(me))
 206             return 1;
 207     } else if (button == 'q' || button == 'Q' || button == '\x11') {
 208         me->ourgame->free_game(oldstate);
 209         return 0;
 210     } else {
 211         game_state *s = me->ourgame->make_move(me->states[me->statepos-1],
 212                                                me->ui, x, y, button);
 213
 214         if (s == me->states[me->statepos-1]) {
 215             /*
 216              * make_move() is allowed to return its input state to
 217              * indicate that although no move has been made, the UI
 218              * state has been updated and a redraw is called for.
 219              */
 220             midend_redraw(me);
 221             return 1;
 222         } else if (s) {
 223             midend_stop_anim(me);
 224             while (me->nstates > me->statepos)
 225                 me->ourgame->free_game(me->states[--me->nstates]);
 226             ensure(me);
 227             me->states[me->nstates] = s;
 228             me->statepos = ++me->nstates;
 229             me->dir = +1;
 230         } else {
 231             me->ourgame->free_game(oldstate);
 232             return 1;
 233         }
 234     }
 235
 236     /*
 237      * See if this move requires an animation.
 238      */
 239     anim_time = me->ourgame->anim_length(oldstate, me->states[me->statepos-1],
 240                                          me->dir);
 241
 242     me->oldstate = oldstate;
 243     if (anim_time > 0) {
 244         me->anim_time = anim_time;
 245     } else {
 246         me->anim_time = 0.0;
 247         midend_finish_move(me);
 248     }
 249     me->anim_pos = 0.0;
 250
 251     midend_redraw(me);
 252
 253     activate_timer(me->frontend);
 254
 255     return 1;
 256 }
 257
 258 void midend_redraw(midend_data *me)
 259 {
 260     if (me->statepos > 0 && me->drawstate) {
 261         start_draw(me->frontend);
 262         if (me->oldstate && me->anim_time > 0 &&
 263             me->anim_pos < me->anim_time) {
 264             assert(me->dir != 0);
 265             me->ourgame->redraw(me->frontend, me->drawstate, me->oldstate,
 266                                 me->states[me->statepos-1], me->dir,
 267                                 me->ui, me->anim_pos, me->flash_pos);
 268         } else {
 269             me->ourgame->redraw(me->frontend, me->drawstate, NULL,
 270                                 me->states[me->statepos-1], +1 /*shrug*/,
 271                                 me->ui, 0.0, me->flash_pos);
 272         }
 273         end_draw(me->frontend);
 274     }
 275 }
 276
 277 void midend_timer(midend_data *me, float tplus)
 278 {
 279     me->anim_pos += tplus;
 280     if (me->anim_pos >= me->anim_time ||
 281         me->anim_time == 0 || !me->oldstate) {
 282         if (me->anim_time > 0)
 283             midend_finish_move(me);
 284     }
 285     me->flash_pos += tplus;
 286     if (me->flash_pos >= me->flash_time || me->flash_time == 0) {
 287         me->flash_pos = me->flash_time = 0;
 288     }
 289     if (me->flash_time == 0 && me->anim_time == 0)
 290         deactivate_timer(me->frontend);
 291     midend_redraw(me);
 292 }
 293
 294 float *midend_colours(midend_data *me, int *ncolours)
 295 {
 296     game_state *state = NULL;
 297     float *ret;
 298
 299     if (me->nstates == 0) {
 300         char *seed = me->ourgame->new_seed(me->params, me->random);
 301         state = me->ourgame->new_game(me->params, seed);
 302         sfree(seed);
 303     } else
 304         state = me->states[0];
 305
 306     ret = me->ourgame->colours(me->frontend, state, ncolours);
 307
 308     if (me->nstates == 0)
 309         me->ourgame->free_game(state);
 310
 311     return ret;
 312 }
 313
 314 int midend_num_presets(midend_data *me)
 315 {
 316     if (!me->npresets) {
 317         char *name;
 318         game_params *preset;
 319
 320         while (me->ourgame->fetch_preset(me->npresets, &name, &preset)) {
 321             if (me->presetsize <= me->npresets) {
 322                 me->presetsize = me->npresets + 10;
 323                 me->presets = sresize(me->presets, me->presetsize,
 324                                       game_params *);
 325                 me->preset_names = sresize(me->preset_names, me->presetsize,
 326                                            char *);
 327             }
 328
 329             me->presets[me->npresets] = preset;
 330             me->preset_names[me->npresets] = name;
 331             me->npresets++;
 332         }
 333     }
 334
 335     return me->npresets;
 336 }
 337
 338 void midend_fetch_preset(midend_data *me, int n,
 339                          char **name, game_params **params)
 340 {
 341     assert(n >= 0 && n < me->npresets);
 342     *name = me->preset_names[n];
 343     *params = me->presets[n];
 344 }
 345
 346 int midend_wants_statusbar(midend_data *me)
 347 {
 348     return me->ourgame->wants_statusbar();
 349 }
 350
 351 config_item *midend_get_config(midend_data *me, int which, char **wintitle)
 352 {
 353     char *titlebuf, *parstr;
 354     config_item *ret;
 355
 356     titlebuf = snewn(40 + strlen(me->ourgame->name), char);
 357
 358     switch (which) {
 359       case CFG_SETTINGS:
 360         sprintf(titlebuf, "%s configuration", me->ourgame->name);
 361         *wintitle = dupstr(titlebuf);
 362         return me->ourgame->configure(me->params);
 363       case CFG_SEED:
 364         sprintf(titlebuf, "%s game selection", me->ourgame->name);
 365         *wintitle = dupstr(titlebuf);
 366
 367         ret = snewn(2, config_item);
 368
 369         ret[0].type = C_STRING;
 370         ret[0].name = "Game ID";
 371         ret[0].ival = 0;
 372         /*
 373          * The text going in here will be a string encoding of the
 374          * parameters, plus a colon, plus the game seed. This is a
 375          * full game ID.
 376          */
 377         parstr = me->ourgame->encode_params(me->params);
 378         ret[0].sval = snewn(strlen(parstr) + strlen(me->seed) + 2, char);
 379         sprintf(ret[0].sval, "%s:%s", parstr, me->seed);
 380         sfree(parstr);
 381
 382         ret[1].type = C_END;
 383         ret[1].name = ret[1].sval = NULL;
 384         ret[1].ival = 0;
 385
 386         return ret;
 387     }
 388
 389     assert(!"We shouldn't be here");
 390     return NULL;
 391 }
 392
 393 char *midend_game_id(midend_data *me, char *id, int def_seed)
 394 {
 395     char *error, *par, *seed;
 396     game_params *params;
 397
 398     seed = strchr(id, ':');
 399
 400     if (seed) {
 401         /*
 402          * We have a colon separating parameters from game seed. So
 403          * `par' now points to the parameters string, and `seed' to
 404          * the seed string.
 405          */
 406         *seed++ = '\0';
 407         par = id;
 408     } else {
 409         /*
 410          * We only have one string. Depending on `def_seed', we
 411          * take it to be either parameters or seed.
 412          */
 413         if (def_seed) {
 414             seed = id;
 415             par = NULL;
 416         } else {
 417             seed = NULL;
 418             par = id;
 419         }
 420     }
 421
 422     if (par) {
 423         params = me->ourgame->decode_params(par);
 424         error = me->ourgame->validate_params(params);
 425         if (error) {
 426             me->ourgame->free_params(params);
 427             return error;
 428         }
 429         me->ourgame->free_params(me->params);
 430         me->params = params;
 431     }
 432
 433     if (seed) {
 434         error = me->ourgame->validate_seed(me->params, seed);
 435         if (error)
 436             return error;
 437
 438         sfree(me->seed);
 439         me->seed = dupstr(seed);
 440         me->fresh_seed = TRUE;
 441     }
 442
 443     return NULL;
 444 }
 445
 446 char *midend_set_config(midend_data *me, int which, config_item *cfg)
 447 {
 448     char *error;
 449     game_params *params;
 450
 451     switch (which) {
 452       case CFG_SETTINGS:
 453         params = me->ourgame->custom_params(cfg);
 454         error = me->ourgame->validate_params(params);
 455
 456         if (error) {
 457             me->ourgame->free_params(params);
 458             return error;
 459         }
 460
 461         me->ourgame->free_params(me->params);
 462         me->params = params;
 463         break;
 464
 465       case CFG_SEED:
 466         error = midend_game_id(me, cfg[0].sval, TRUE);
 467         if (error)
 468             return error;
 469         break;
 470     }
 471
 472     return NULL;
 473 }