* factorial-time enumeration at a sensible rate. Easy puzzles
* higher than that would be possible, but more latin-squarey
* than skyscrapery, as it were.
- *
- * - UI work?
- * + Allow the user to mark a clue as 'spent' in some way once
- * it's no longer interesting (typically because no
- * arrangement of the remaining possibilities _can_ violate
- * it)?
*/
#include <stdio.h>
COL_HIGHLIGHT,
COL_ERROR,
COL_PENCIL,
+ COL_DONE,
NCOLOURS
};
struct game_state {
game_params par;
struct clues *clues;
+ unsigned char *clues_done;
digit *grid;
int *pencil; /* bitmaps using bits 1<<1..1<<n */
int completed, cheated;
sfree(params);
}
-static game_params *dup_params(game_params *params)
+static game_params *dup_params(const game_params *params)
{
game_params *ret = snew(game_params);
*ret = *params; /* structure copy */
}
}
-static char *encode_params(game_params *params, int full)
+static char *encode_params(const game_params *params, int full)
{
char ret[80];
return dupstr(ret);
}
-static config_item *game_configure(game_params *params)
+static config_item *game_configure(const game_params *params)
{
config_item *ret;
char buf[80];
return ret;
}
-static game_params *custom_params(config_item *cfg)
+static game_params *custom_params(const config_item *cfg)
{
game_params *ret = snew(game_params);
return ret;
}
-static char *validate_params(game_params *params, int full)
+static char *validate_params(const game_params *params, int full)
{
if (params->w < 3 || params->w > 9)
return "Grid size must be between 3 and 9";
* Grid generation.
*/
-static char *new_game_desc(game_params *params, random_state *rs,
+static char *new_game_desc(const game_params *params, random_state *rs,
char **aux, int interactive)
{
int w = params->w, a = w*w;
desc = snewn(40*a, char);
p = desc;
for (i = 0; i < 4*w; i++) {
- p += sprintf(p, "%s%.0d", i?"/":"", clues[i]);
+ if (i)
+ *p++ = '/';
+ if (clues[i])
+ p += sprintf(p, "%d", clues[i]);
}
for (i = 0; i < a; i++)
if (grid[i])
* Gameplay.
*/
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, const char *desc)
{
int w = params->w, a = w*w;
const char *p = desc;
return NULL;
}
-static game_state *new_game(midend *me, game_params *params, char *desc)
+static game_state *new_game(midend *me, const game_params *params,
+ const char *desc)
{
int w = params->w, a = w*w;
game_state *state = snew(game_state);
state->clues->clues = snewn(4*w, int);
state->clues->immutable = snewn(a, digit);
state->grid = snewn(a, digit);
+ state->clues_done = snewn(4*w, unsigned char);
state->pencil = snewn(a, int);
for (i = 0; i < a; i++) {
}
memset(state->clues->immutable, 0, a);
+ memset(state->clues_done, 0, 4*w*sizeof(unsigned char));
for (i = 0; i < 4*w; i++) {
if (i > 0) {
return state;
}
-static game_state *dup_game(game_state *state)
+static game_state *dup_game(const game_state *state)
{
int w = state->par.w, a = w*w;
game_state *ret = snew(game_state);
ret->grid = snewn(a, digit);
ret->pencil = snewn(a, int);
+ ret->clues_done = snewn(4*w, unsigned char);
memcpy(ret->grid, state->grid, a*sizeof(digit));
memcpy(ret->pencil, state->pencil, a*sizeof(int));
+ memcpy(ret->clues_done, state->clues_done, 4*w*sizeof(unsigned char));
ret->completed = state->completed;
ret->cheated = state->cheated;
{
sfree(state->grid);
sfree(state->pencil);
+ sfree(state->clues_done);
if (--state->clues->refcount <= 0) {
sfree(state->clues->immutable);
sfree(state->clues->clues);
sfree(state);
}
-static char *solve_game(game_state *state, game_state *currstate,
- char *aux, char **error)
+static char *solve_game(const game_state *state, const game_state *currstate,
+ const char *aux, char **error)
{
int w = state->par.w, a = w*w;
int i, ret;
return out;
}
-static int game_can_format_as_text_now(game_params *params)
+static int game_can_format_as_text_now(const game_params *params)
{
return TRUE;
}
-static char *game_text_format(game_state *state)
+static char *game_text_format(const game_state *state)
{
int w = state->par.w /* , a = w*w */;
char *ret;
int hcursor;
};
-static game_ui *new_ui(game_state *state)
+static game_ui *new_ui(const game_state *state)
{
game_ui *ui = snew(game_ui);
sfree(ui);
}
-static char *encode_ui(game_ui *ui)
+static char *encode_ui(const game_ui *ui)
{
return NULL;
}
-static void decode_ui(game_ui *ui, char *encoding)
+static void decode_ui(game_ui *ui, const char *encoding)
{
}
-static void game_changed_state(game_ui *ui, game_state *oldstate,
- game_state *newstate)
+static void game_changed_state(game_ui *ui, const game_state *oldstate,
+ const game_state *newstate)
{
int w = newstate->par.w;
/*
#define FLASH_TIME 0.4F
#define DF_PENCIL_SHIFT 16
+#define DF_CLUE_DONE 0x10000
#define DF_ERROR 0x8000
#define DF_HIGHLIGHT 0x4000
#define DF_HIGHLIGHT_PENCIL 0x2000
int *errtmp;
};
-static int check_errors(game_state *state, int *errors)
+static int check_errors(const game_state *state, int *errors)
{
int w = state->par.w /*, a = w*w */;
int W = w+2, A = W*W; /* the errors array is (w+2) square */
}
for (i = 0; i < 4*w; i++) {
- int start, step, j, k, n, best;
+ int start, step, j, n, best;
STARTSTEP(start, step, i, w);
if (!clues[i])
continue;
best = n = 0;
- k = 0;
for (j = 0; j < w; j++) {
int number = grid[start+j*step];
if (!number)
}
}
- if (n > clues[i] || (j == w && n < clues[i])) {
+ if (n > clues[i] || (best == w && n < clues[i]) ||
+ (best < w && n == clues[i])) {
if (errors) {
int x, y;
CLUEPOS(x, y, i, w);
return errs;
}
-static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
- int x, int y, int button)
+static int clue_index(const game_state *state, int x, int y)
+{
+ int w = state->par.w;
+
+ if (x == -1 || x == w)
+ return w * (x == -1 ? 2 : 3) + y;
+ else if (y == -1 || y == w)
+ return (y == -1 ? 0 : w) + x;
+
+ return -1;
+}
+
+static int is_clue(const game_state *state, int x, int y)
+{
+ int w = state->par.w;
+
+ if (((x == -1 || x == w) && y >= 0 && y < w) ||
+ ((y == -1 || y == w) && x >= 0 && x < w))
+ {
+ if (state->clues->clues[clue_index(state, x, y)] & DF_DIGIT_MASK)
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static char *interpret_move(const game_state *state, game_ui *ui,
+ const game_drawstate *ds,
+ int x, int y, int button)
{
int w = state->par.w;
+ int shift_or_control = button & (MOD_SHFT | MOD_CTRL);
int tx, ty;
char buf[80];
ui->hcursor = 0;
return ""; /* UI activity occurred */
}
+ } else if (button == LEFT_BUTTON) {
+ if (is_clue(state, tx, ty)) {
+ sprintf(buf, "%c%d,%d", 'D', tx, ty);
+ return dupstr(buf);
+ }
}
if (IS_CURSOR_MOVE(button)) {
+ if (shift_or_control) {
+ int x = ui->hx, y = ui->hy;
+ switch (button) {
+ case CURSOR_LEFT: x = -1; break;
+ case CURSOR_RIGHT: x = w; break;
+ case CURSOR_UP: y = -1; break;
+ case CURSOR_DOWN: y = w; break;
+ }
+ if (is_clue(state, x, y)) {
+ sprintf(buf, "%c%d,%d", 'D', x, y);
+ return dupstr(buf);
+ }
+ return NULL;
+ }
move_cursor(button, &ui->hx, &ui->hy, w, w, 0);
ui->hshow = ui->hcursor = 1;
return "";
return NULL;
}
-static game_state *execute_move(game_state *from, char *move)
+static game_state *execute_move(const game_state *from, const char *move)
{
int w = from->par.w, a = w*w;
- game_state *ret;
+ game_state *ret = dup_game(from);
int x, y, i, n;
if (move[0] == 'S') {
- ret = dup_game(from);
ret->completed = ret->cheated = TRUE;
for (i = 0; i < a; i++) {
- if (move[i+1] < '1' || move[i+1] > '0'+w) {
- free_game(ret);
- return NULL;
- }
+ if (move[i+1] < '1' || move[i+1] > '0'+w)
+ goto badmove;
ret->grid[i] = move[i+1] - '0';
ret->pencil[i] = 0;
}
- if (move[a+1] != '\0') {
- free_game(ret);
- return NULL;
- }
+ if (move[a+1] != '\0')
+ goto badmove;
return ret;
} else if ((move[0] == 'P' || move[0] == 'R') &&
sscanf(move+1, "%d,%d,%d", &x, &y, &n) == 3 &&
x >= 0 && x < w && y >= 0 && y < w && n >= 0 && n <= w) {
if (from->clues->immutable[y*w+x])
- return NULL;
+ goto badmove;
- ret = dup_game(from);
if (move[0] == 'P' && n > 0) {
ret->pencil[y*w+x] ^= 1L << n;
} else {
* starting point when following through a set of
* diagnostics output by the standalone solver.)
*/
- ret = dup_game(from);
for (i = 0; i < a; i++) {
if (!ret->grid[i])
ret->pencil[i] = (1L << (w+1)) - (1L << 1);
}
return ret;
- } else
- return NULL; /* couldn't parse move string */
+ } else if (move[0] == 'D' && sscanf(move+1, "%d,%d", &x, &y) == 2 &&
+ is_clue(from, x, y)) {
+ int index = clue_index(from, x, y);
+ ret->clues_done[index] = !ret->clues_done[index];
+ return ret;
+ }
+
+ badmove:
+ /* couldn't parse move string */
+ free_game(ret);
+ return NULL;
}
/* ----------------------------------------------------------------------
#define SIZE(w) ((w) * TILESIZE + 2*BORDER)
-static void game_compute_size(game_params *params, int tilesize,
- int *x, int *y)
+static void game_compute_size(const game_params *params, int tilesize,
+ int *x, int *y)
{
/* Ick: fake up `ds->tilesize' for macro expansion purposes */
struct { int tilesize; } ads, *ds = &ads;
}
static void game_set_size(drawing *dr, game_drawstate *ds,
- game_params *params, int tilesize)
+ const game_params *params, int tilesize)
{
ds->tilesize = tilesize;
}
ret[COL_PENCIL * 3 + 1] = 0.5F * ret[COL_BACKGROUND * 3 + 1];
ret[COL_PENCIL * 3 + 2] = ret[COL_BACKGROUND * 3 + 2];
+ ret[COL_DONE * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] / 1.5F;
+ ret[COL_DONE * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] / 1.5F;
+ ret[COL_DONE * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] / 1.5F;
+
*ncolours = NCOLOURS;
return ret;
}
-static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
+static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
{
int w = state->par.w /*, a = w*w */;
struct game_drawstate *ds = snew(struct game_drawstate);
/* new number needs drawing? */
if (tile & DF_DIGIT_MASK) {
+ int color;
+
str[1] = '\0';
str[0] = (tile & DF_DIGIT_MASK) + '0';
+
+ if (tile & DF_ERROR)
+ color = COL_ERROR;
+ else if (tile & DF_CLUE_DONE)
+ color = COL_DONE;
+ else if (x < 0 || y < 0 || x >= w || y >= w)
+ color = COL_GRID;
+ else if (tile & DF_IMMUTABLE)
+ color = COL_GRID;
+ else
+ color = COL_USER;
+
draw_text(dr, tx + TILESIZE/2, ty + TILESIZE/2, FONT_VARIABLE,
(tile & DF_PLAYAREA ? TILESIZE/2 : TILESIZE*2/5),
- ALIGN_VCENTRE | ALIGN_HCENTRE,
- (tile & DF_ERROR) ? COL_ERROR :
- (x < 0 || y < 0 || x >= w || y >= w) ? COL_GRID :
- (tile & DF_IMMUTABLE) ? COL_GRID : COL_USER, str);
+ ALIGN_VCENTRE | ALIGN_HCENTRE, color, str);
} else {
int i, j, npencil;
int pl, pr, pt, pb;
}
}
-static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
- game_state *state, int dir, game_ui *ui,
- float animtime, float flashtime)
+static void game_redraw(drawing *dr, game_drawstate *ds,
+ const game_state *oldstate, const game_state *state,
+ int dir, const game_ui *ui,
+ float animtime, float flashtime)
{
int w = state->par.w /*, a = w*w */;
int i, x, y;
if (ds->errtmp[(y+1)*(w+2)+(x+1)])
tile |= DF_ERROR;
+ else if (state->clues_done[i])
+ tile |= DF_CLUE_DONE;
ds->tiles[(y+1)*(w+2)+(x+1)] = tile;
}
}
}
-static float game_anim_length(game_state *oldstate, game_state *newstate,
- int dir, game_ui *ui)
+static float game_anim_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
return 0.0F;
}
-static float game_flash_length(game_state *oldstate, game_state *newstate,
- int dir, game_ui *ui)
+static float game_flash_length(const game_state *oldstate,
+ const game_state *newstate, int dir, game_ui *ui)
{
if (!oldstate->completed && newstate->completed &&
!oldstate->cheated && !newstate->cheated)
return 0.0F;
}
-static int game_timing_state(game_state *state, game_ui *ui)
+static int game_status(const game_state *state)
+{
+ return state->completed ? +1 : 0;
+}
+
+static int game_timing_state(const game_state *state, game_ui *ui)
{
if (state->completed)
return FALSE;
return TRUE;
}
-static void game_print_size(game_params *params, float *x, float *y)
+static void game_print_size(const game_params *params, float *x, float *y)
{
int pw, ph;
*y = ph / 100.0F;
}
-static void game_print(drawing *dr, game_state *state, int tilesize)
+static void game_print(drawing *dr, const game_state *state, int tilesize)
{
int w = state->par.w;
int ink = print_mono_colour(dr, 0);
game_redraw,
game_anim_length,
game_flash_length,
+ game_status,
TRUE, FALSE, game_print_size, game_print,
FALSE, /* wants_statusbar */
FALSE, game_timing_state,
~ian / sgt-puzzles.git / blobdiff