X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?a=blobdiff_plain;f=keen.c;h=fdaae32e5dd263fd54a5724618b267a04dad6254;hb=db313b3948d27244dd7c34c2609c66d6204d8931;hp=69aebc447d528a6f69124c23df157b26248ae2a0;hpb=6482ed0e3c886afd6b44acf91450524ff70d102c;p=sgt-puzzles.git diff --git a/keen.c b/keen.c index 69aebc4..fdaae32 100644 --- a/keen.c +++ b/keen.c @@ -1,5 +1,6 @@ /* - * keen.c: an implementation of the Times's 'KenKen' puzzle. + * keen.c: an implementation of the Times's 'KenKen' puzzle, and + * also of Nikoli's very similar 'Inshi No Heya' puzzle. */ #include @@ -61,7 +62,7 @@ enum { }; struct game_params { - int w, diff; + int w, diff, multiplication_only; }; struct clues { @@ -85,19 +86,22 @@ static game_params *default_params(void) ret->w = 6; ret->diff = DIFF_NORMAL; + ret->multiplication_only = FALSE; return ret; } const static struct game_params keen_presets[] = { - { 4, DIFF_EASY }, - { 5, DIFF_EASY }, - { 6, DIFF_EASY }, - { 6, DIFF_NORMAL }, - { 6, DIFF_HARD }, - { 6, DIFF_EXTREME }, - { 6, DIFF_UNREASONABLE }, - { 9, DIFF_NORMAL }, + { 4, DIFF_EASY, FALSE }, + { 5, DIFF_EASY, FALSE }, + { 5, DIFF_EASY, TRUE }, + { 6, DIFF_EASY, FALSE }, + { 6, DIFF_NORMAL, FALSE }, + { 6, DIFF_NORMAL, TRUE }, + { 6, DIFF_HARD, FALSE }, + { 6, DIFF_EXTREME, FALSE }, + { 6, DIFF_UNREASONABLE, FALSE }, + { 9, DIFF_NORMAL, FALSE }, }; static int game_fetch_preset(int i, char **name, game_params **params) @@ -111,7 +115,8 @@ static int game_fetch_preset(int i, char **name, game_params **params) ret = snew(game_params); *ret = keen_presets[i]; /* structure copy */ - sprintf(buf, "%dx%d %s", ret->w, ret->w, keen_diffnames[ret->diff]); + sprintf(buf, "%dx%d %s%s", ret->w, ret->w, keen_diffnames[ret->diff], + ret->multiplication_only ? ", multiplication only" : ""); *name = dupstr(buf); *params = ret; @@ -149,6 +154,11 @@ static void decode_params(game_params *params, char const *string) p++; } } + + if (*p == 'm') { + p++; + params->multiplication_only = TRUE; + } } static char *encode_params(const game_params *params, int full) @@ -157,7 +167,8 @@ static char *encode_params(const game_params *params, int full) sprintf(ret, "%d", params->w); if (full) - sprintf(ret + strlen(ret), "d%c", keen_diffchars[params->diff]); + sprintf(ret + strlen(ret), "d%c%s", keen_diffchars[params->diff], + params->multiplication_only ? "m" : ""); return dupstr(ret); } @@ -167,7 +178,7 @@ static config_item *game_configure(const game_params *params) config_item *ret; char buf[80]; - ret = snewn(3, config_item); + ret = snewn(4, config_item); ret[0].name = "Grid size"; ret[0].type = C_STRING; @@ -180,10 +191,15 @@ static config_item *game_configure(const game_params *params) ret[1].sval = DIFFCONFIG; ret[1].ival = params->diff; - ret[2].name = NULL; - ret[2].type = C_END; + ret[2].name = "Multiplication only"; + ret[2].type = C_BOOLEAN; ret[2].sval = NULL; - ret[2].ival = 0; + ret[2].ival = params->multiplication_only; + + ret[3].name = NULL; + ret[3].type = C_END; + ret[3].sval = NULL; + ret[3].ival = 0; return ret; } @@ -194,6 +210,7 @@ static game_params *custom_params(const config_item *cfg) ret->w = atoi(cfg[0].sval); ret->diff = cfg[1].ival; + ret->multiplication_only = cfg[2].ival; return ret; } @@ -234,6 +251,36 @@ static void solver_clue_candidate(struct solver_ctx *ctx, int diff, int box) * digit constraints in that box. We expect to find the digits * of the candidate layout in ctx->dscratch, and we update * ctx->iscratch as appropriate. + * + * The contents of ctx->iscratch are completely different + * depending on whether diff == DIFF_HARD or not. This function + * uses iscratch completely differently between the two cases, and + * the code in solver_common() which consumes the result must + * likewise have an if statement with completely different + * branches for the two cases. + * + * In DIFF_EASY and DIFF_NORMAL modes, the valid entries in + * ctx->iscratch are 0,...,n-1, and each of those entries + * ctx->iscratch[i] gives a bitmap of the possible digits in the + * ith square of the clue box currently under consideration. So + * each entry of iscratch starts off as an empty bitmap, and we + * set bits in it as possible layouts for the clue box are + * considered (and the difference between DIFF_EASY and + * DIFF_NORMAL is just that in DIFF_EASY mode we deliberately set + * more bits than absolutely necessary, hence restricting our own + * knowledge). + * + * But in DIFF_HARD mode, the valid entries are 0,...,2*w-1 (at + * least outside *this* function - inside this function, we also + * use 2*w,...,4*w-1 as scratch space in the loop below); the + * first w of those give the possible digits in the intersection + * of the current clue box with each column of the puzzle, and the + * next w do the same for each row. In this mode, each iscratch + * entry starts off as a _full_ bitmap, and in this function we + * _clear_ bits for digits that are absent from a given row or + * column in each candidate layout, so that the only bits which + * remain set are those for digits which have to appear in a given + * row/column no matter how the clue box is laid out. */ if (diff == DIFF_EASY) { unsigned mask = 0; @@ -292,8 +339,14 @@ static int solver_common(struct latin_solver *solver, void *vctx, int diff) long value = ctx->clues[box] & ~CMASK; long op = ctx->clues[box] & CMASK; + /* + * Initialise ctx->iscratch for this clue box. At different + * difficulty levels we must initialise a different amount of + * it to different things; see the comments in + * solver_clue_candidate explaining what each version does. + */ if (diff == DIFF_HARD) { - for (i = 0; i < n; i++) + for (i = 0; i < 2*w; i++) ctx->iscratch[i] = (1 << (w+1)) - (1 << 1); } else { for (i = 0; i < n; i++) @@ -407,6 +460,13 @@ static int solver_common(struct latin_solver *solver, void *vctx, int diff) break; } + /* + * Do deductions based on the information we've now + * accumulated in ctx->iscratch. See the comments above in + * solver_clue_candidate explaining what data is left in here, + * and how it differs between DIFF_HARD and lower difficulty + * levels (hence the big if statement here). + */ if (diff < DIFF_HARD) { #ifdef STANDALONE_SOLVER char prefix[256]; @@ -912,7 +972,9 @@ done singletons[i] = 0; j = dsf_canonify(dsf, i); k = dsf_size(dsf, j); - if (j == i && k > 2) { + if (params->multiplication_only) + singletons[j] = F_MUL; + else if (j == i && k > 2) { singletons[j] |= F_ADD | F_MUL; } else if (j != i && k == 2) { /* Fetch the two numbers and sort them into order. */ @@ -1760,7 +1822,7 @@ static void game_free_drawstate(drawing *dr, game_drawstate *ds) } static void draw_tile(drawing *dr, game_drawstate *ds, struct clues *clues, - int x, int y, long tile) + int x, int y, long tile, int only_one_op) { int w = clues->w /* , a = w*w */; int tx, ty, tw, th; @@ -1830,7 +1892,7 @@ static void draw_tile(drawing *dr, game_drawstate *ds, struct clues *clues, * want to display them right if so. */ sprintf (str, "%ld%s", clueval, - (size == 1 ? "" : + (size == 1 || only_one_op ? "" : cluetype == C_ADD ? "+" : cluetype == C_SUB ? ds->minus_sign : cluetype == C_MUL ? ds->times_sign : @@ -2003,7 +2065,8 @@ static void game_redraw(drawing *dr, game_drawstate *ds, if (ds->tiles[y*w+x] != tile) { ds->tiles[y*w+x] = tile; - draw_tile(dr, ds, state->clues, x, y, tile); + draw_tile(dr, ds, state->clues, x, y, tile, + state->par.multiplication_only); } } } @@ -2277,7 +2340,7 @@ static void game_print(drawing *dr, const game_state *state, int tilesize) const struct game thegame = { "Keen", "games.keen", "keen", default_params, - game_fetch_preset, + game_fetch_preset, NULL, decode_params, encode_params, free_params,