#include "puzzles.h"
#include "latin.h" /* contains typedef for digit */
-static void assert_f(p)
-{
- assert(p);
-}
-
/* ----------------------------------------------------------
* Constant and structure definitions
*/
if (params->order < 3 || params->order > 32)
return "Order must be between 3 and 32";
if (params->diff >= DIFFCOUNT)
- return "Unknown difficulty rating.";
+ return "Unknown difficulty rating";
return NULL;
}
return -1;
}
+static int game_can_format_as_text_now(game_params *params)
+{
+ return TRUE;
+}
+
static char *game_text_format(game_state *state)
{
int x, y, len, n;
}
#endif
- for (i = 0; i < ls; i++) {
+ for (i = ls; i-- > 0 ;) {
if (!gg_place_clue(state, scratch[i], latin, 1)) continue;
loc = scratch[i] / 5;
best = i; maxposs = nposs; minclues = nclues;
#ifdef STANDALONE_SOLVER
if (solver_show_working)
- printf("gg_best_clue: b%d (%d,%d) new best [%d poss, %d clues].",
+ printf("gg_best_clue: b%d (%d,%d) new best [%d poss, %d clues].\n",
best, x, y, nposs, nclues);
#endif
}
gg_solved++;
if (solver_state(copy, difficulty) != 1) {
/* put clue back, we can't solve without it. */
- assert_f(gg_place_clue(new, scratch[i], latin, 0) == 1);
+ int ret = gg_place_clue(new, scratch[i], latin, 0);
+ assert(ret == 1);
} else {
#ifdef STANDALONE_SOLVER
if (solver_show_working)
{
digit *sq = NULL;
int i, x, y, retlen, k, nsol;
- int o2 = params->order * params->order, ntries = 0;
+ int o2 = params->order * params->order, ntries = 1;
int *scratch, lscratch = o2*5;
char *ret, buf[80];
game_state *state = blank_game(params->order);
/* Generate a list of 'things to strip' (randomised later) */
scratch = snewn(lscratch, int);
- for (i = 0; i < lscratch; i++) scratch[i] = i;
+ /* Put the numbers (4 mod 5) before the inequalities (0-3 mod 5) */
+ for (i = 0; i < lscratch; i++) scratch[i] = (i%o2)*5 + 4 - (i/o2);
generate:
#ifdef STANDALONE_SOLVER
if (sq) sfree(sq);
sq = latin_generate(params->order, rs);
latin_debug(sq, params->order);
- shuffle(scratch, lscratch, sizeof(int), rs);
+ /* Separately shuffle the numeric and inequality clues */
+ shuffle(scratch, lscratch/5, sizeof(int), rs);
+ shuffle(scratch+lscratch/5, 4*lscratch/5, sizeof(int), rs);
memset(state->nums, 0, o2 * sizeof(digit));
memset(state->flags, 0, o2 * sizeof(unsigned int));
if (nsol > 0) {
#ifdef STANDALONE_SOLVER
if (solver_show_working)
- printf("game_assemble: puzzle as generated is too easy.");
+ printf("game_assemble: puzzle as generated is too easy.\n");
#endif
if (ntries < MAXTRIES) {
ntries++;
}
#ifdef STANDALONE_SOLVER
if (solver_show_working)
- printf("Unable to generate %s %dx%d after %d attempts.",
+ printf("Unable to generate %s %dx%d after %d attempts.\n",
unequal_diffnames[params->diff],
params->order, params->order, MAXTRIES);
#endif
}
#ifdef STANDALONE_SOLVER
if (solver_show_working)
- printf("new_game_desc: generated %s puzzle; %d attempts (%d solver).",
+ printf("new_game_desc: generated %s puzzle; %d attempts (%d solver).\n",
unequal_diffnames[params->diff], ntries, gg_solved);
#endif
*/
struct game_ui {
- int hx, hy, hpencil; /* as for solo.c, highlight pos and type */
- int cx, cy; /* cursor position (-1,-1 for none) */
+ int hx, hy; /* as for solo.c, highlight pos */
+ int hshow, hpencil, hcursor; /* show state, type, and ?cursor. */
};
static game_ui *new_ui(game_state *state)
{
game_ui *ui = snew(game_ui);
- ui->hx = ui->hy = -1;
- ui->hpencil = 0;
-
- ui->cx = ui->cy = -1;
+ ui->hx = ui->hy = 0;
+ ui->hpencil = ui->hshow = ui->hcursor = 0;
return ui;
}
/* See solo.c; if we were pencil-mode highlighting and
* somehow a square has just been properly filled, cancel
* pencil mode. */
- if (ui->hx >= 0 && ui->hy >= 0 && ui->hpencil &&
+ if (ui->hshow && ui->hpencil && !ui->hcursor &&
GRID(newstate, nums, ui->hx, ui->hy) != 0) {
- ui->hx = ui->hy = -1;
+ ui->hshow = 0;
}
}
struct game_drawstate {
int tilesize, order, started;
- digit *nums; /* copy of nums, o^2 */
- unsigned char *hints; /* copy of hints, o^3 */
+ digit *nums; /* copy of nums, o^2 */
+ unsigned char *hints; /* copy of hints, o^3 */
unsigned int *flags; /* o^2 */
- int hx, hy, hpencil;
- int cx, cy;
+ int hx, hy, hshow, hpencil; /* as for game_ui. */
int hflash;
};
button &= ~MOD_MASK;
- if (x >= 0 && x < ds->order && y >= 0 && y < ds->order) {
+ if (x >= 0 && x < ds->order && ((ox - COORD(x)) <= TILE_SIZE) &&
+ y >= 0 && y < ds->order && ((oy - COORD(y)) <= TILE_SIZE)) {
if (button == LEFT_BUTTON) {
/* normal highlighting for non-immutable squares */
if (GRID(state, flags, x, y) & F_IMMUTABLE)
- ui->hx = ui->hy = -1;
- else if (x == ui->hx && y == ui->hy && ui->hpencil == 0)
- ui->hx = ui->hy = -1;
+ ui->hshow = 0;
+ else if (x == ui->hx && y == ui->hy &&
+ ui->hshow && ui->hpencil == 0)
+ ui->hshow = 0;
else {
ui->hx = x; ui->hy = y; ui->hpencil = 0;
+ ui->hshow = 1;
}
+ ui->hcursor = 0;
return "";
}
if (button == RIGHT_BUTTON) {
/* pencil highlighting for non-filled squares */
if (GRID(state, nums, x, y) != 0)
- ui->hx = ui->hy = -1;
- else if (x == ui->hx && y == ui->hy && ui->hpencil)
- ui->hx = ui->hy = -1;
+ ui->hshow = 0;
+ else if (x == ui->hx && y == ui->hy &&
+ ui->hshow && ui->hpencil)
+ ui->hshow = 0;
else {
ui->hx = x; ui->hy = y; ui->hpencil = 1;
+ ui->hshow = 1;
}
+ ui->hcursor = 0;
return "";
}
}
if (button == 'H' || button == 'h')
return dupstr("H");
+ if (button == 'M' || button == 'm')
+ return dupstr("M");
+
+ if (IS_CURSOR_MOVE(button)) {
+ move_cursor(button, &ui->hx, &ui->hy, ds->order, ds->order, 0);
+ ui->hshow = ui->hcursor = 1;
+ return "";
+ }
+ if (ui->hshow && IS_CURSOR_SELECT(button)) {
+ ui->hpencil = 1 - ui->hpencil;
+ ui->hcursor = 1;
+ return "";
+ }
- if (ui->hx != -1 && ui->hy != -1) {
+
+ if (ui->hshow) {
debug(("button %d, cbutton %d", button, (int)((char)button)));
n = c2n(button, state->order);
sprintf(buf, "%c%d,%d,%d",
(char)(ui->hpencil && n > 0 ? 'P' : 'R'), ui->hx, ui->hy, n);
- ui->hx = ui->hy = -1;
+ if (!ui->hcursor) ui->hshow = 0;
return dupstr(buf);
}
static game_state *execute_move(game_state *state, char *move)
{
game_state *ret = NULL;
- int x, y, n, i;
+ int x, y, n, i, rc;
debug(("execute_move: %s", move));
p++;
}
if (*p) goto badmove;
- assert_f(check_complete(ret->nums, ret, 1) > 0);
+ rc = check_complete(ret->nums, ret, 1);
+ assert(rc > 0);
+ return ret;
+ } else if (move[0] == 'M') {
+ ret = dup_game(state);
+ for (x = 0; x < state->order; x++) {
+ for (y = 0; y < state->order; y++) {
+ for (n = 0; n < state->order; n++) {
+ HINT(ret, x, y, n) = 1;
+ }
+ }
+ }
return ret;
} else if (move[0] == 'H') {
return solver_hint(state, NULL, DIFF_EASY, DIFF_EASY);
memset(ds->hints, 0, o3);
memset(ds->flags, 0, o2*sizeof(unsigned int));
- ds->hx = ds->hy = ds->cx = ds->cy = -1;
- ds->started = ds->hpencil = ds->hflash = 0;
+ ds->hx = ds->hy = 0;
+ ds->started = ds->hshow = ds->hpencil = ds->hflash = 0;
return ds;
}
static void draw_furniture(drawing *dr, game_drawstate *ds, game_state *state,
game_ui *ui, int x, int y, int hflash)
{
- int ox = COORD(x), oy = COORD(y), bg, hon, con;
+ int ox = COORD(x), oy = COORD(y), bg, hon;
unsigned int f = GRID(state, flags, x, y);
bg = hflash ? COL_HIGHLIGHT : COL_BACKGROUND;
- hon = (x == ui->hx && y == ui->hy);
- con = (x == ui->cx && y == ui->cy);
+ hon = (ui->hshow && x == ui->hx && y == ui->hy);
/* Clear square. */
draw_rect(dr, ox, oy, TILE_SIZE, TILE_SIZE,
}
/* Draw the square outline (which is the cursor, if we're the cursor). */
- draw_rect_outline(dr, ox, oy, TILE_SIZE, TILE_SIZE,
- con ? COL_GUESS : COL_GRID);
+ draw_rect_outline(dr, ox, oy, TILE_SIZE, TILE_SIZE, COL_GRID);
draw_update(dr, ox, oy, TILE_SIZE, TILE_SIZE);
game_state *state, int dir, game_ui *ui,
float animtime, float flashtime)
{
- int x, y, i, hchanged = 0, cchanged = 0, stale, hflash = 0;
+ int x, y, i, hchanged = 0, stale, hflash = 0;
debug(("highlight old (%d,%d), new (%d,%d)", ds->hx, ds->hy, ui->hx, ui->hy));
draw_rect(dr, 0, 0, DRAW_SIZE, DRAW_SIZE, COL_BACKGROUND);
draw_update(dr, 0, 0, DRAW_SIZE, DRAW_SIZE);
}
- if (ds->hx != ui->hx || ds->hy != ui->hy || ds->hpencil != ui->hpencil)
+ if (ds->hx != ui->hx || ds->hy != ui->hy ||
+ ds->hshow != ui->hshow || ds->hpencil != ui->hpencil)
hchanged = 1;
- if (ds->cx != ui->cx || ds->cy != ui->cy)
- cchanged = 1;
for (x = 0; x < ds->order; x++) {
for (y = 0; y < ds->order; y++) {
(x == ds->hx && y == ds->hy))
stale = 1;
}
- if (cchanged) {
- if ((x == ui->cx && y == ui->cy) ||
- (x == ds->cx && y == ds->cy))
- stale = 1;
- }
if (GRID(state, nums, x, y) != GRID(ds, nums, x, y)) {
GRID(ds, nums, x, y) = GRID(state, nums, x, y);
}
}
}
- ds->hx = ui->hx; ds->hy = ui->hy; ds->hpencil = ui->hpencil;
- ds->cx = ui->cx; ds->cy = ui->cy;
+ ds->hx = ui->hx; ds->hy = ui->hy;
+ ds->hshow = ui->hshow;
+ ds->hpencil = ui->hpencil;
+
ds->started = 1;
ds->hflash = hflash;
}
dup_game,
free_game,
TRUE, solve_game,
- TRUE, game_text_format,
+ TRUE, game_can_format_as_text_now, game_text_format,
new_ui,
free_ui,
encode_ui,
~mdw / sgt / puzzles / blobdiff