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
  18     char *seed;
  19     int fresh_seed;
  20     int nstates, statesize, statepos;
  21
  22     game_params **presets;
  23     char **preset_names;
  24     int npresets, presetsize;
  25
  26     game_params *params;
  27     game_state **states;
  28     game_drawstate *drawstate;
  29     game_state *oldstate;
  30     float anim_time, anim_pos;
  31     float flash_time, flash_pos;
  32 };
  33
  34 #define ensure(me) do { \
  35     if ((me)->nstates >= (me)->statesize) { \
  36         (me)->statesize = (me)->nstates + 128; \
  37         (me)->states = sresize((me)->states, (me)->statesize, game_state *); \
  38     } \
  39 } while (0)
  40
  41 midend_data *midend_new(frontend *fe, void *randseed, int randseedsize)
  42 {
  43     midend_data *me = snew(midend_data);
  44
  45     me->frontend = fe;
  46     me->random = random_init(randseed, randseedsize);
  47     me->nstates = me->statesize = me->statepos = 0;
  48     me->states = NULL;
  49     me->params = default_params();
  50     me->seed = NULL;
  51     me->fresh_seed = FALSE;
  52     me->drawstate = NULL;
  53     me->oldstate = NULL;
  54     me->presets = NULL;
  55     me->preset_names = NULL;
  56     me->npresets = me->presetsize = 0;
  57     me->anim_time = me->anim_pos = 0.0F;
  58     me->flash_time = me->flash_pos = 0.0F;
  59
  60     return me;
  61 }
  62
  63 void midend_free(midend_data *me)
  64 {
  65     sfree(me->states);
  66     sfree(me->seed);
  67     free_params(me->params);
  68     sfree(me);
  69 }
  70
  71 void midend_size(midend_data *me, int *x, int *y)
  72 {
  73     game_size(me->params, x, y);
  74 }
  75
  76 void midend_set_params(midend_data *me, game_params *params)
  77 {
  78     free_params(me->params);
  79     me->params = dup_params(params);
  80 }
  81
  82 void midend_new_game(midend_data *me)
  83 {
  84     while (me->nstates > 0)
  85         free_game(me->states[--me->nstates]);
  86
  87     if (me->drawstate)
  88         game_free_drawstate(me->drawstate);
  89
  90     assert(me->nstates == 0);
  91
  92     if (!me->fresh_seed) {
  93         sfree(me->seed);
  94         me->seed = new_game_seed(me->params, me->random);
  95     } else
  96         me->fresh_seed = FALSE;
  97
  98     ensure(me);
  99     me->states[me->nstates++] = new_game(me->params, me->seed);
 100     me->statepos = 1;
 101     me->drawstate = game_new_drawstate(me->states[0]);
 102 }
 103
 104 void midend_restart_game(midend_data *me)
 105 {
 106     while (me->nstates > 1)
 107         free_game(me->states[--me->nstates]);
 108     me->statepos = me->nstates;
 109 }
 110
 111 static int midend_undo(midend_data *me)
 112 {
 113     if (me->statepos > 1) {
 114         me->statepos--;
 115         return 1;
 116     } else
 117         return 0;
 118 }
 119
 120 static int midend_redo(midend_data *me)
 121 {
 122     if (me->statepos < me->nstates) {
 123         me->statepos++;
 124         return 1;
 125     } else
 126         return 0;
 127 }
 128
 129 static void midend_finish_move(midend_data *me)
 130 {
 131     float flashtime;
 132
 133     if (me->oldstate || me->statepos > 1) {
 134         flashtime = game_flash_length(me->oldstate ? me->oldstate :
 135                                       me->states[me->statepos-2],
 136                                       me->states[me->statepos-1]);
 137         if (flashtime > 0) {
 138             me->flash_pos = 0.0F;
 139             me->flash_time = flashtime;
 140         }
 141     }
 142
 143     if (me->oldstate)
 144         free_game(me->oldstate);
 145     me->oldstate = NULL;
 146     me->anim_pos = me->anim_time = 0;
 147
 148     if (me->flash_time == 0 && me->anim_time == 0)
 149         deactivate_timer(me->frontend);
 150     else
 151         activate_timer(me->frontend);
 152 }
 153
 154 int midend_process_key(midend_data *me, int x, int y, int button)
 155 {
 156     game_state *oldstate = dup_game(me->states[me->statepos - 1]);
 157     float anim_time;
 158
 159     if (me->oldstate || me->anim_time) {
 160         midend_finish_move(me);
 161         midend_redraw(me);
 162     }
 163
 164     if (button == 'n' || button == 'N' || button == '\x0E') {
 165         midend_new_game(me);
 166         midend_redraw(me);
 167         return 1;                      /* never animate */
 168     } else if (button == 'r' || button == 'R') {
 169         midend_restart_game(me);
 170         midend_redraw(me);
 171         return 1;                      /* never animate */
 172     } else if (button == 'u' || button == 'u' ||
 173                button == '\x1A' || button == '\x1F') {
 174         if (!midend_undo(me))
 175             return 1;
 176     } else if (button == '\x12') {
 177         if (!midend_redo(me))
 178             return 1;
 179     } else if (button == 'q' || button == 'Q' || button == '\x11') {
 180         free_game(oldstate);
 181         return 0;
 182     } else {
 183         game_state *s = make_move(me->states[me->statepos-1], x, y, button);
 184
 185         if (s) {
 186             while (me->nstates > me->statepos)
 187                 free_game(me->states[--me->nstates]);
 188             ensure(me);
 189             me->states[me->nstates] = s;
 190             me->statepos = ++me->nstates;
 191         } else {
 192             free_game(oldstate);
 193             return 1;
 194         }
 195     }
 196
 197     /*
 198      * See if this move requires an animation.
 199      */
 200     anim_time = game_anim_length(oldstate, me->states[me->statepos-1]);
 201
 202     me->oldstate = oldstate;
 203     if (anim_time > 0) {
 204         me->anim_time = anim_time;
 205     } else {
 206         me->anim_time = 0.0;
 207         midend_finish_move(me);
 208     }
 209     me->anim_pos = 0.0;
 210
 211     midend_redraw(me);
 212
 213     activate_timer(me->frontend);
 214
 215     return 1;
 216 }
 217
 218 void midend_redraw(midend_data *me)
 219 {
 220     if (me->statepos > 0 && me->drawstate) {
 221         start_draw(me->frontend);
 222         if (me->oldstate && me->anim_time > 0 &&
 223             me->anim_pos < me->anim_time) {
 224             game_redraw(me->frontend, me->drawstate, me->oldstate,
 225                         me->states[me->statepos-1], me->anim_pos,
 226                         me->flash_pos);
 227         } else {
 228             game_redraw(me->frontend, me->drawstate, NULL,
 229                         me->states[me->statepos-1], 0.0, me->flash_pos);
 230         }
 231         end_draw(me->frontend);
 232     }
 233 }
 234
 235 void midend_timer(midend_data *me, float tplus)
 236 {
 237     me->anim_pos += tplus;
 238     if (me->anim_pos >= me->anim_time ||
 239         me->anim_time == 0 || !me->oldstate) {
 240         if (me->anim_time > 0)
 241             midend_finish_move(me);
 242     }
 243     me->flash_pos += tplus;
 244     if (me->flash_pos >= me->flash_time || me->flash_time == 0) {
 245         me->flash_pos = me->flash_time = 0;
 246     }
 247     if (me->flash_time == 0 && me->anim_time == 0)
 248         deactivate_timer(me->frontend);
 249     midend_redraw(me);
 250 }
 251
 252 float *midend_colours(midend_data *me, int *ncolours)
 253 {
 254     game_state *state = NULL;
 255     float *ret;
 256
 257     if (me->nstates == 0) {
 258         char *seed = new_game_seed(me->params, me->random);
 259         state = new_game(me->params, seed);
 260         sfree(seed);
 261     } else
 262         state = me->states[0];
 263
 264     ret = game_colours(me->frontend, state, ncolours);
 265
 266     if (me->nstates == 0)
 267         free_game(state);
 268
 269     return ret;
 270 }
 271
 272 int midend_num_presets(midend_data *me)
 273 {
 274     if (!me->npresets) {
 275         char *name;
 276         game_params *preset;
 277
 278         while (game_fetch_preset(me->npresets, &name, &preset)) {
 279             if (me->presetsize <= me->npresets) {
 280                 me->presetsize = me->npresets + 10;
 281                 me->presets = sresize(me->presets, me->presetsize,
 282                                       game_params *);
 283                 me->preset_names = sresize(me->preset_names, me->presetsize,
 284                                            char *);
 285             }
 286
 287             me->presets[me->npresets] = preset;
 288             me->preset_names[me->npresets] = name;
 289             me->npresets++;
 290         }
 291     }
 292
 293     return me->npresets;
 294 }
 295
 296 void midend_fetch_preset(midend_data *me, int n,
 297                          char **name, game_params **params)
 298 {
 299     assert(n >= 0 && n < me->npresets);
 300     *name = me->preset_names[n];
 301     *params = me->presets[n];
 302 }
 303
 304 int midend_wants_statusbar(midend_data *me)
 305 {
 306     return game_wants_statusbar();
 307 }
 308
 309 config_item *midend_get_config(midend_data *me, int which, char **wintitle)
 310 {
 311     char *titlebuf;
 312     config_item *ret;
 313
 314     titlebuf = snewn(40 + strlen(game_name), char);
 315
 316     switch (which) {
 317       case CFG_SETTINGS:
 318         sprintf(titlebuf, "%s configuration", game_name);
 319         *wintitle = dupstr(titlebuf);
 320         return game_configure(me->params);
 321       case CFG_SEED:
 322         sprintf(titlebuf, "%s game selection", game_name);
 323         *wintitle = dupstr(titlebuf);
 324
 325         ret = snewn(2, config_item);
 326
 327         ret[0].type = C_STRING;
 328         ret[0].name = "Game ID";
 329         ret[0].ival = 0;
 330         ret[0].sval = dupstr(me->seed);
 331
 332         ret[1].type = C_END;
 333         ret[1].name = ret[1].sval = NULL;
 334         ret[1].ival = 0;
 335
 336         return ret;
 337     }
 338
 339     assert(!"We shouldn't be here");
 340     return NULL;
 341 }
 342
 343 char *midend_set_config(midend_data *me, int which, config_item *cfg)
 344 {
 345     char *error;
 346     game_params *params;
 347
 348     switch (which) {
 349       case CFG_SETTINGS:
 350         params = custom_params(cfg);
 351         error = validate_params(params);
 352
 353         if (error) {
 354             free_params(params);
 355             return error;
 356         }
 357
 358         free_params(me->params);
 359         me->params = params;
 360         break;
 361
 362       case CFG_SEED:
 363         error = validate_seed(me->params, cfg[0].sval);
 364         if (error)
 365             return error;
 366
 367         sfree(me->seed);
 368         me->seed = dupstr(cfg[0].sval);
 369         me->fresh_seed = TRUE;
 370
 371         break;
 372     }
 373
 374     return NULL;
 375 }