X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/puzzles/blobdiff_plain/c380832d0b832bcfbd16e760ade393f9adab02b6..1a47546fb131305875f590ba827075ac6e10fb03:/midend.c

diff --git a/midend.c b/midend.c
index e31ce26..e545841 100644
--- a/midend.c
+++ b/midend.c
@@ -25,7 +25,29 @@ struct midend_data {
     random_state *random;
     const game *ourgame;
 
-    char *desc, *seedstr;
+    /*
+     * `desc' and `privdesc' deserve a comment.
+     * 
+     * `desc' is the game description as presented to the user when
+     * they ask for Game -> Specific. `privdesc', if non-NULL, is a
+     * different game description used to reconstruct the initial
+     * game_state when de-serialising. If privdesc is NULL, `desc'
+     * is used for both.
+     * 
+     * For almost all games, `privdesc' is NULL and never used. The
+     * exception (as usual) is Mines: the initial game state has no
+     * squares open at all, but after the first click `desc' is
+     * rewritten to describe a game state with an initial click and
+     * thus a bunch of squares open. If we used that desc to
+     * serialise and deserialise, then the initial game state after
+     * deserialisation would look unlike the initial game state
+     * beforehand, and worse still execute_move() might fail on the
+     * attempted first click. So `privdesc' is also used in this
+     * case, to provide a game description describing the same
+     * fixed mine layout _but_ no initial click. (These game IDs
+     * may also be typed directly into Mines if you like.)
+     */
+    char *desc, *privdesc, *seedstr;
     game_aux_info *aux_info;
     enum { GOT_SEED, GOT_DESC, GOT_NOTHING } genmode;
     int nstates, statesize, statepos;
@@ -43,7 +65,13 @@ struct midend_data {
     float flash_time, flash_pos;
     int dir;
 
+    int timing;
+    float elapsed;
+    char *laststatus;
+
     int pressed_mouse_button;
+
+    int winwidth, winheight;
 };
 
 #define ensure(me) do { \
@@ -69,7 +97,7 @@ midend_data *midend_new(frontend *fe, const game *ourgame)
     me->states = NULL;
     me->params = ourgame->default_params();
     me->curparams = NULL;
-    me->desc = NULL;
+    me->desc = me->privdesc = NULL;
     me->seedstr = NULL;
     me->aux_info = NULL;
     me->genmode = GOT_NOTHING;
@@ -83,29 +111,59 @@ midend_data *midend_new(frontend *fe, const game *ourgame)
     me->dir = 0;
     me->ui = NULL;
     me->pressed_mouse_button = 0;
+    me->laststatus = NULL;
+    me->timing = FALSE;
+    me->elapsed = 0.0F;
+    me->winwidth = me->winheight = 0;
 
     sfree(randseed);
 
     return me;
 }
 
+static void midend_free_game(midend_data *me)
+{
+    while (me->nstates > 0)
+	me->ourgame->free_game(me->states[--me->nstates].state);
+
+    if (me->drawstate)
+        me->ourgame->free_drawstate(me->drawstate);
+}
+
 void midend_free(midend_data *me)
 {
+    int i;
+
+    midend_free_game(me);
+
+    random_free(me->random);
     sfree(me->states);
     sfree(me->desc);
     sfree(me->seedstr);
-    random_free(me->random);
     if (me->aux_info)
 	me->ourgame->free_aux_info(me->aux_info);
     me->ourgame->free_params(me->params);
+    if (me->npresets) {
+	for (i = 0; i < me->npresets; i++) {
+	    sfree(me->presets[i]);
+	    sfree(me->preset_names[i]);
+	}
+	sfree(me->presets);
+	sfree(me->preset_names);
+    }
+    if (me->ui)
+        me->ourgame->free_ui(me->ui);
     if (me->curparams)
         me->ourgame->free_params(me->curparams);
+    sfree(me->laststatus);
     sfree(me);
 }
 
-void midend_size(midend_data *me, int *x, int *y)
+void midend_size(midend_data *me, int *x, int *y, int expand)
 {
-    me->ourgame->size(me->params, x, y);
+    me->ourgame->size(me->params, me->drawstate, x, y, expand);
+    me->winwidth = *x;
+    me->winheight = *y;
 }
 
 void midend_set_params(midend_data *me, game_params *params)
@@ -114,13 +172,34 @@ void midend_set_params(midend_data *me, game_params *params)
     me->params = me->ourgame->dup_params(params);
 }
 
-void midend_new_game(midend_data *me)
+static void midend_set_timer(midend_data *me)
 {
-    while (me->nstates > 0)
-	me->ourgame->free_game(me->states[--me->nstates].state);
+    me->timing = (me->ourgame->is_timed &&
+		  me->ourgame->timing_state(me->states[me->statepos-1].state));
+    if (me->timing || me->flash_time || me->anim_time)
+	activate_timer(me->frontend);
+    else
+	deactivate_timer(me->frontend);
+}
+
+static void midend_size_new_drawstate(midend_data *me)
+{
+    me->ourgame->size(me->params, me->drawstate, &me->winwidth, &me->winheight,
+                      TRUE);
+}
 
+void midend_force_redraw(midend_data *me)
+{
     if (me->drawstate)
         me->ourgame->free_drawstate(me->drawstate);
+    me->drawstate = me->ourgame->new_drawstate(me->states[0].state);
+    midend_size_new_drawstate(me);
+    midend_redraw(me);
+}
+
+void midend_new_game(midend_data *me)
+{
+    midend_free_game(me);
 
     assert(me->nstates == 0);
 
@@ -155,12 +234,15 @@ void midend_new_game(midend_data *me)
         }
 
 	sfree(me->desc);
+	sfree(me->privdesc);
 	if (me->aux_info)
 	    me->ourgame->free_aux_info(me->aux_info);
 	me->aux_info = NULL;
 
         rs = random_init(me->seedstr, strlen(me->seedstr));
-        me->desc = me->ourgame->new_desc(me->curparams, rs, &me->aux_info);
+        me->desc = me->ourgame->new_desc(me->curparams, rs,
+					 &me->aux_info, TRUE);
+	me->privdesc = NULL;
         random_free(rs);
     }
 
@@ -171,6 +253,9 @@ void midend_new_game(midend_data *me)
     me->nstates++;
     me->statepos = 1;
     me->drawstate = me->ourgame->new_drawstate(me->states[0].state);
+    midend_size_new_drawstate(me);
+    me->elapsed = 0.0F;
+    midend_set_timer(me);
     if (me->ui)
         me->ourgame->free_ui(me->ui);
     me->ui = me->ourgame->new_ui(me->states[0].state);
@@ -180,6 +265,10 @@ void midend_new_game(midend_data *me)
 static int midend_undo(midend_data *me)
 {
     if (me->statepos > 1) {
+        if (me->ui)
+            me->ourgame->changed_state(me->ui,
+                                       me->states[me->statepos-1].state,
+                                       me->states[me->statepos-2].state);
 	me->statepos--;
         me->dir = -1;
         return 1;
@@ -190,6 +279,10 @@ static int midend_undo(midend_data *me)
 static int midend_redo(midend_data *me)
 {
     if (me->statepos < me->nstates) {
+        if (me->ui)
+            me->ourgame->changed_state(me->ui,
+                                       me->states[me->statepos-1].state,
+                                       me->states[me->statepos].state);
 	me->statepos++;
         me->dir = +1;
         return 1;
@@ -227,13 +320,10 @@ static void midend_finish_move(midend_data *me)
     me->anim_pos = me->anim_time = 0;
     me->dir = 0;
 
-    if (me->flash_time == 0 && me->anim_time == 0)
-	deactivate_timer(me->frontend);
-    else
-	activate_timer(me->frontend);
+    midend_set_timer(me);
 }
 
-static void midend_stop_anim(midend_data *me)
+void midend_stop_anim(midend_data *me)
 {
     if (me->oldstate || me->anim_time) {
 	midend_finish_move(me);
@@ -251,7 +341,14 @@ void midend_restart_game(midend_data *me)
     if (me->statepos == 1)
         return;                        /* no point doing anything at all! */
 
-    s = me->ourgame->dup_game(me->states[0].state);
+    /*
+     * During restart, we reconstruct the game from the (public)
+     * game description rather than from states[0], because that
+     * way Mines gets slightly more sensible behaviour (restart
+     * goes to _after_ the first click so you don't have to
+     * remember where you clicked).
+     */
+    s = me->ourgame->new_game(me, me->params, me->desc);
 
     /*
      * Now enter the restarted state as the next move.
@@ -263,43 +360,60 @@ void midend_restart_game(midend_data *me)
     me->states[me->nstates].state = s;
     me->states[me->nstates].special = TRUE;   /* we just restarted */
     me->statepos = ++me->nstates;
+    if (me->ui)
+        me->ourgame->changed_state(me->ui,
+                                   me->states[me->statepos-2].state,
+                                   me->states[me->statepos-1].state);
     me->anim_time = 0.0;
     midend_finish_move(me);
     midend_redraw(me);
-    activate_timer(me->frontend);
+    midend_set_timer(me);
 }
 
 static int midend_really_process_key(midend_data *me, int x, int y, int button)
 {
     game_state *oldstate =
         me->ourgame->dup_game(me->states[me->statepos - 1].state);
-    int special = FALSE, gotspecial = FALSE;
+    int special = FALSE, gotspecial = FALSE, ret = 1;
     float anim_time;
 
     if (button == 'n' || button == 'N' || button == '\x0E') {
 	midend_stop_anim(me);
 	midend_new_game(me);
         midend_redraw(me);
-        return 1;                      /* never animate */
+	goto done;		       /* never animate */
     } else if (button == 'u' || button == 'u' ||
                button == '\x1A' || button == '\x1F') {
 	midend_stop_anim(me);
         special = me->states[me->statepos-1].special;
         gotspecial = TRUE;
 	if (!midend_undo(me))
-            return 1;
+	    goto done;
     } else if (button == 'r' || button == 'R' ||
-               button == '\x12') {
+               button == '\x12' || button == '\x19') {
 	midend_stop_anim(me);
 	if (!midend_redo(me))
-            return 1;
+            goto done;
     } else if (button == 'q' || button == 'Q' || button == '\x11') {
-	me->ourgame->free_game(oldstate);
-        return 0;
+	ret = 0;
+	goto done;
     } else {
-        game_state *s =
-            me->ourgame->make_move(me->states[me->statepos-1].state,
-                                   me->ui, x, y, button);
+        game_state *s;
+	char *movestr;
+	
+	movestr =
+            me->ourgame->interpret_move(me->states[me->statepos-1].state,
+					me->ui, me->drawstate, x, y, button);
+	if (!movestr)
+	    s = NULL;
+	else if (!*movestr)
+	    s = me->states[me->statepos-1].state;
+	else {
+	    s = me->ourgame->execute_move(me->states[me->statepos-1].state,
+					  movestr);
+	    assert(s != NULL);
+	    sfree(movestr);
+	}
 
         if (s == me->states[me->statepos-1].state) {
             /*
@@ -308,7 +422,7 @@ static int midend_really_process_key(midend_data *me, int x, int y, int button)
              * state has been updated and a redraw is called for.
              */
             midend_redraw(me);
-            return 1;
+            goto done;
         } else if (s) {
 	    midend_stop_anim(me);
             while (me->nstates > me->statepos)
@@ -319,8 +433,7 @@ static int midend_really_process_key(midend_data *me, int x, int y, int button)
             me->statepos = ++me->nstates;
             me->dir = +1;
         } else {
-            me->ourgame->free_game(oldstate);
-            return 1;
+          goto done;
         }
     }
 
@@ -338,7 +451,7 @@ static int midend_really_process_key(midend_data *me, int x, int y, int button)
                                              me->dir, me->ui);
     }
 
-    me->oldstate = oldstate;
+    me->oldstate = oldstate; oldstate = NULL;
     if (anim_time > 0) {
         me->anim_time = anim_time;
     } else {
@@ -349,9 +462,11 @@ static int midend_really_process_key(midend_data *me, int x, int y, int button)
 
     midend_redraw(me);
 
-    activate_timer(me->frontend);
+    midend_set_timer(me);
 
-    return 1;
+    done:
+    if (oldstate) me->ourgame->free_game(oldstate);
+    return ret;
 }
 
 int midend_process_key(midend_data *me, int x, int y, int button)
@@ -415,6 +530,14 @@ int midend_process_key(midend_data *me, int x, int y, int button)
      *    pressed, invent a button-up for the first one and then
      *    pass the button-down through as before.
      * 
+     * 2005-05-31: An addendum to the above. Some games might want
+     * a `priority order' among buttons, such that if one button is
+     * pressed while another is down then a fixed one of the
+     * buttons takes priority no matter what order they're pressed
+     * in. Mines, in particular, wants to treat a left+right click
+     * like a left click for the benefit of users of other
+     * implementations. So the last of the above points is modified
+     * in the presence of an (optional) button priority order.
      */
     if (IS_MOUSE_DRAG(button) || IS_MOUSE_RELEASE(button)) {
         if (me->pressed_mouse_button) {
@@ -428,6 +551,14 @@ int midend_process_key(midend_data *me, int x, int y, int button)
         } else
             return ret;                /* ignore it */
     } else if (IS_MOUSE_DOWN(button) && me->pressed_mouse_button) {
+	/*
+	 * If the new button has lower priority than the old one,
+	 * don't bother doing this.
+	 */
+	if (me->ourgame->mouse_priorities &
+	    BUTTON_BEATS(me->pressed_mouse_button, button))
+	    return ret;		       /* just ignore it */
+
         /*
          * Fabricate a button-up for the previously pressed button.
          */
@@ -479,13 +610,22 @@ void midend_timer(midend_data *me, float tplus)
 	if (me->anim_time > 0)
 	    midend_finish_move(me);
     }
+
     me->flash_pos += tplus;
     if (me->flash_pos >= me->flash_time || me->flash_time == 0) {
 	me->flash_pos = me->flash_time = 0;
     }
-    if (me->flash_time == 0 && me->anim_time == 0)
-	deactivate_timer(me->frontend);
+
     midend_redraw(me);
+
+    if (me->timing) {
+	float oldelapsed = me->elapsed;
+	me->elapsed += tplus;
+	if ((int)oldelapsed != (int)me->elapsed)
+	    status_bar(me->frontend, me->laststatus ? me->laststatus : "");
+    }
+
+    midend_set_timer(me);
 }
 
 float *midend_colours(midend_data *me, int *ncolours)
@@ -495,7 +635,8 @@ float *midend_colours(midend_data *me, int *ncolours)
 
     if (me->nstates == 0) {
 	game_aux_info *aux = NULL;
-        char *desc = me->ourgame->new_desc(me->params, me->random, &aux);
+        char *desc = me->ourgame->new_desc(me->params, me->random,
+					   &aux, TRUE);
         state = me->ourgame->new_game(me, me->params, desc);
         sfree(desc);
 	if (aux)
@@ -627,29 +768,37 @@ int midend_wants_statusbar(midend_data *me)
     return me->ourgame->wants_statusbar();
 }
 
-void midend_supersede_game_desc(midend_data *me, char *desc)
+void midend_supersede_game_desc(midend_data *me, char *desc, char *privdesc)
 {
     sfree(me->desc);
+    sfree(me->privdesc);
     me->desc = dupstr(desc);
+    me->privdesc = privdesc ? dupstr(privdesc) : NULL;
 }
 
 config_item *midend_get_config(midend_data *me, int which, char **wintitle)
 {
-    char *titlebuf, *parstr;
+    char *titlebuf, *parstr, *rest;
     config_item *ret;
+    char sep;
 
+    assert(wintitle);
     titlebuf = snewn(40 + strlen(me->ourgame->name), char);
 
     switch (which) {
       case CFG_SETTINGS:
 	sprintf(titlebuf, "%s configuration", me->ourgame->name);
-	*wintitle = dupstr(titlebuf);
+	*wintitle = titlebuf;
 	return me->ourgame->configure(me->params);
       case CFG_SEED:
       case CFG_DESC:
-	sprintf(titlebuf, "%s %s selection", me->ourgame->name,
+        if (!me->curparams) {
+          sfree(titlebuf);
+          return NULL;
+        }
+        sprintf(titlebuf, "%s %s selection", me->ourgame->name,
                 which == CFG_SEED ? "random" : "game");
-	*wintitle = dupstr(titlebuf);
+        *wintitle = titlebuf;
 
 	ret = snewn(2, config_item);
 
@@ -669,21 +818,16 @@ config_item *midend_get_config(midend_data *me, int which, char **wintitle)
          * changes).
          */
         parstr = me->ourgame->encode_params(me->curparams, which == CFG_SEED);
+        assert(parstr);
         if (which == CFG_DESC) {
-            ret[0].sval = snewn(strlen(parstr) + strlen(me->desc) + 2, char);
-            sprintf(ret[0].sval, "%s:%s", parstr, me->desc);
-        } else if (me->seedstr) {
-            ret[0].sval = snewn(strlen(parstr) + strlen(me->seedstr) + 2, char);
-            sprintf(ret[0].sval, "%s#%s", parstr, me->seedstr);
+            rest = me->desc ? me->desc : "";
+            sep = ':';
         } else {
-            /*
-             * If the current game was not randomly generated, the
-             * best we can do is to give a template for typing a
-             * new seed in.
-             */
-            ret[0].sval = snewn(strlen(parstr) + 2, char);
-            sprintf(ret[0].sval, "%s#", parstr);
+            rest = me->seedstr ? me->seedstr : "";
+            sep = '#';
         }
+        ret[0].sval = snewn(strlen(parstr) + strlen(rest) + 2, char);
+        sprintf(ret[0].sval, "%s%c%s", parstr, sep, rest);
         sfree(parstr);
 
 	ret[1].type = C_END;
@@ -769,7 +913,8 @@ static char *midend_game_id_int(midend_data *me, char *id, int defmode)
     }
 
     sfree(me->desc);
-    me->desc = NULL;
+    sfree(me->privdesc);
+    me->desc = me->privdesc = NULL;
     sfree(me->seedstr);
     me->seedstr = NULL;
 
@@ -840,7 +985,7 @@ char *midend_text_format(midend_data *me)
 char *midend_solve(midend_data *me)
 {
     game_state *s;
-    char *msg;
+    char *msg, *movestr;
 
     if (!me->ourgame->can_solve)
 	return "This game does not support the Solve operation";
@@ -849,9 +994,14 @@ char *midend_solve(midend_data *me)
 	return "No game set up to solve";   /* _shouldn't_ happen! */
 
     msg = "Solve operation failed";    /* game _should_ overwrite on error */
-    s = me->ourgame->solve(me->states[0].state, me->aux_info, &msg);
-    if (!s)
+    movestr = me->ourgame->solve(me->states[0].state,
+				 me->states[me->statepos-1].state,
+				 me->aux_info, &msg);
+    if (!movestr)
 	return msg;
+    s = me->ourgame->execute_move(me->states[me->statepos-1].state, movestr);
+    assert(s);
+    sfree(movestr);
 
     /*
      * Now enter the solved state as the next move.
@@ -863,9 +1013,43 @@ char *midend_solve(midend_data *me)
     me->states[me->nstates].state = s;
     me->states[me->nstates].special = TRUE;   /* created using solve */
     me->statepos = ++me->nstates;
+    if (me->ui)
+        me->ourgame->changed_state(me->ui,
+                                   me->states[me->statepos-2].state,
+                                   me->states[me->statepos-1].state);
     me->anim_time = 0.0;
     midend_finish_move(me);
     midend_redraw(me);
-    activate_timer(me->frontend);
+    midend_set_timer(me);
     return NULL;
 }
+
+char *midend_rewrite_statusbar(midend_data *me, char *text)
+{
+    /*
+     * An important special case is that we are occasionally called
+     * with our own laststatus, to update the timer.
+     */
+    if (me->laststatus != text) {
+	sfree(me->laststatus);
+	me->laststatus = dupstr(text);
+    }
+
+    if (me->ourgame->is_timed) {
+	char timebuf[100], *ret;
+	int min, sec;
+
+	sec = me->elapsed;
+	min = sec / 60;
+	sec %= 60;
+	sprintf(timebuf, "[%d:%02d] ", min, sec);
+
+	ret = snewn(strlen(timebuf) + strlen(text) + 1, char);
+	strcpy(ret, timebuf);
+	strcat(ret, text);
+	return ret;
+
+    } else {
+	return dupstr(text);
+    }
+}