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