const game *ourgame;
char *seed;
+ game_aux_info *aux_info;
int fresh_seed;
int nstates, statesize, statepos;
me->states = NULL;
me->params = ourgame->default_params();
me->seed = NULL;
+ me->aux_info = NULL;
me->fresh_seed = FALSE;
me->drawstate = NULL;
me->oldstate = NULL;
{
sfree(me->states);
sfree(me->seed);
+ if (me->aux_info)
+ me->ourgame->free_aux_info(me->aux_info);
me->ourgame->free_params(me->params);
sfree(me);
}
if (!me->fresh_seed) {
sfree(me->seed);
- me->seed = me->ourgame->new_seed(me->params, me->random);
+ if (me->aux_info)
+ me->ourgame->free_aux_info(me->aux_info);
+ me->aux_info = NULL;
+ me->seed = me->ourgame->new_seed(me->params, me->random,
+ &me->aux_info);
} else
me->fresh_seed = FALSE;
* fix it _here_ in the common midend code so that it only has
* to be done once.
*
- * Semantics:
+ * The possible ways in which things can go screwy in the front
+ * end are:
*
- * - when we receive a button down message, we remember which
- * button went down.
+ * - in a system containing multiple physical buttons button
+ * presses can inadvertently overlap. We can see ABab (caps
+ * meaning button-down and lowercase meaning button-up) when
+ * the user had semantically intended AaBb.
*
- * - if we receive a drag or release message for a button we
- * don't currently think is pressed, we fabricate a
- * button-down for it before sending it.
+ * - in a system where one button is simulated by means of a
+ * modifier key and another button, buttons can mutate
+ * between press and release (possibly during drag). So we
+ * can see Ab instead of Aa.
*
- * - if we receive (or fabricate) a button down message
- * without having seen a button up for the previously
- * pressed button, we invent the button up before sending
- * the button down.
+ * Definite requirements are:
+ *
+ * - button _presses_ must never be invented or destroyed. If
+ * the user presses two buttons in succession, the button
+ * presses must be transferred to the backend unchanged. So
+ * if we see AaBb , that's fine; if we see ABab (the button
+ * presses inadvertently overlapped) we must somehow
+ * `correct' it to AaBb.
+ *
+ * - every mouse action must end up looking like a press, zero
+ * or more drags, then a release. This allows back ends to
+ * make the _assumption_ that incoming mouse data will be
+ * sane in this regard, and not worry about the details.
+ *
+ * So my policy will be:
+ *
+ * - treat any button-up as a button-up for the currently
+ * pressed button, or ignore it if there is no currently
+ * pressed button.
+ *
+ * - treat any drag as a drag for the currently pressed
+ * button, or ignore it if there is no currently pressed
+ * button.
+ *
+ * - if we see a button-down while another button is currently
+ * pressed, invent a button-up for the first one and then
+ * pass the button-down through as before.
*
- * Therefore, front ends can just send whatever data they
- * happen to be conveniently able to get, and back ends can be
- * guaranteed of always receiving a down, zero or more drags
- * and an up for a single button at a time.
*/
if (IS_MOUSE_DRAG(button) || IS_MOUSE_RELEASE(button)) {
- int which;
-
- if (IS_MOUSE_DRAG(button))
- which = button + (LEFT_BUTTON - LEFT_DRAG);
- else
- which = button + (LEFT_BUTTON - LEFT_RELEASE);
-
- if (which != me->pressed_mouse_button) {
- /*
- * Fabricate a button-up for the currently pressed
- * button, if any.
- */
- if (me->pressed_mouse_button) {
- ret = ret && midend_really_process_key
- (me, x, y, (me->pressed_mouse_button +
- (LEFT_RELEASE - LEFT_BUTTON)));
+ if (me->pressed_mouse_button) {
+ if (IS_MOUSE_DRAG(button)) {
+ button = me->pressed_mouse_button +
+ (LEFT_DRAG - LEFT_BUTTON);
+ } else {
+ button = me->pressed_mouse_button +
+ (LEFT_RELEASE - LEFT_BUTTON);
}
-
- /*
- * Now fabricate a button-down for this one.
- */
- ret = ret && midend_really_process_key(me, x, y, which);
-
- /*
- * And set the currently pressed button to this one.
- */
- me->pressed_mouse_button = which;
- }
+ } else
+ return ret; /* ignore it */
} else if (IS_MOUSE_DOWN(button) && me->pressed_mouse_button) {
/*
* Fabricate a button-up for the previously pressed button.
float *ret;
if (me->nstates == 0) {
- char *seed = me->ourgame->new_seed(me->params, me->random);
+ game_aux_info *aux = NULL;
+ char *seed = me->ourgame->new_seed(me->params, me->random, &aux);
state = me->ourgame->new_game(me->params, seed);
sfree(seed);
+ if (aux)
+ me->ourgame->free_aux_info(aux);
} else
state = me->states[0];
sfree(me->seed);
me->seed = dupstr(seed);
me->fresh_seed = TRUE;
+ if (me->aux_info)
+ me->ourgame->free_aux_info(me->aux_info);
+ me->aux_info = NULL;
}
return NULL;
return NULL;
}
+
+char *midend_text_format(midend_data *me)
+{
+ if (me->ourgame->can_format_as_text && me->statepos > 0)
+ return me->ourgame->text_format(me->states[me->statepos-1]);
+ else
+ return NULL;
+}
+
+char *midend_solve(midend_data *me)
+{
+ game_state *s;
+ char *msg;
+
+ if (!me->ourgame->can_solve)
+ return "This game does not support the Solve operation";
+
+ if (me->statepos < 1)
+ 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], me->aux_info, &msg);
+ if (!s)
+ return msg;
+
+ /*
+ * Now enter the solved state as the next move.~|~
+ */
+ midend_stop_anim(me);
+ while (me->nstates > me->statepos)
+ me->ourgame->free_game(me->states[--me->nstates]);
+ ensure(me);
+ me->states[me->nstates] = s;
+ me->statepos = ++me->nstates;
+ me->anim_time = 0.0;
+ midend_finish_move(me);
+ midend_redraw(me);
+ activate_timer(me->frontend);
+ return NULL;
+}
~mdw / sgt / puzzles / blobdiff