NCOLOURS
};
-#define DIFFLIST(A) \
- A(EASY,Easy,e) \
- A(NORMAL,Normal,n) \
+#define DIFFLIST(A) \
+ A(EASY,Easy,e) \
+ A(NORMAL,Normal,n) \
A(TRICKY,Tricky,t)
#define ENUM(upper,title,lower) DIFF_ ## upper,
#define TITLE(upper,title,lower) #title,
void get_unique(game_state *state, int counter, random_state *rs) {
- int p,i,c,count_uniques;
+ int p,i,c,pathlimit,count_uniques;
struct guess path_guess;
+ int *view_count;
struct entry {
struct entry *link;
struct {
struct entry *head;
struct entry *node;
- } views, single_views, loop_views, test_views;
+ } views, single_views, test_views;
struct entry test_entry;
-
+
path_guess.length = state->common->paths[counter].num_monsters;
path_guess.guess = snewn(path_guess.length,int);
path_guess.possible = snewn(path_guess.length,int);
path_guess.possible[p] =
state->guess[state->common->paths[counter].mapping[p]];
switch (path_guess.possible[p]) {
- case 1: path_guess.guess[p] = 1; break;
- case 2: path_guess.guess[p] = 2; break;
- case 3: path_guess.guess[p] = 1; break;
- case 4: path_guess.guess[p] = 4; break;
- case 5: path_guess.guess[p] = 1; break;
- case 6: path_guess.guess[p] = 2; break;
- case 7: path_guess.guess[p] = 1; break;
+ case 1: path_guess.guess[p] = 1; break;
+ case 2: path_guess.guess[p] = 2; break;
+ case 3: path_guess.guess[p] = 1; break;
+ case 4: path_guess.guess[p] = 4; break;
+ case 5: path_guess.guess[p] = 1; break;
+ case 6: path_guess.guess[p] = 2; break;
+ case 7: path_guess.guess[p] = 1; break;
}
}
views.head = NULL;
views.node = NULL;
+
+ pathlimit = state->common->paths[counter].length + 1;
+ view_count = snewn(pathlimit*pathlimit, int);
+ for (i = 0; i < pathlimit*pathlimit; i++)
+ view_count[i] = 0;
do {
- int mirror;
+ int mirror, start_view, end_view;
- views.node = snewn(1,struct entry);
- views.node->link = views.head;
- views.node->guess = snewn(path_guess.length,int);
- views.head = views.node;
- views.node->start_view = 0;
- views.node->end_view = 0;
- memcpy(views.node->guess, path_guess.guess,
- path_guess.length*sizeof(int));
-
mirror = FALSE;
+ start_view = 0;
for (p=0;p<state->common->paths[counter].length;p++) {
if (state->common->paths[counter].p[p] == -1) mirror = TRUE;
else {
if (state->common->paths[counter].p[p] ==
state->common->paths[counter].mapping[i]) {
if (path_guess.guess[i] == 1 && mirror == TRUE)
- views.node->start_view++;
+ start_view++;
if (path_guess.guess[i] == 2 && mirror == FALSE)
- views.node->start_view++;
+ start_view++;
if (path_guess.guess[i] == 4)
- views.node->start_view++;
+ start_view++;
break;
}
}
}
}
mirror = FALSE;
+ end_view = 0;
for (p=state->common->paths[counter].length-1;p>=0;p--) {
if (state->common->paths[counter].p[p] == -1) mirror = TRUE;
else {
if (state->common->paths[counter].p[p] ==
state->common->paths[counter].mapping[i]) {
if (path_guess.guess[i] == 1 && mirror == TRUE)
- views.node->end_view++;
+ end_view++;
if (path_guess.guess[i] == 2 && mirror == FALSE)
- views.node->end_view++;
+ end_view++;
if (path_guess.guess[i] == 4)
- views.node->end_view++;
+ end_view++;
break;
}
}
}
}
+
+ assert(start_view >= 0 && start_view < pathlimit);
+ assert(end_view >= 0 && end_view < pathlimit);
+ i = start_view * pathlimit + end_view;
+ view_count[i]++;
+ if (view_count[i] == 1) {
+ views.node = snewn(1,struct entry);
+ views.node->link = views.head;
+ views.node->guess = snewn(path_guess.length,int);
+ views.head = views.node;
+ views.node->start_view = start_view;
+ views.node->end_view = end_view;
+ memcpy(views.node->guess, path_guess.guess,
+ path_guess.length*sizeof(int));
+ }
} while (next_list(&path_guess, path_guess.length-1));
/* extract single entries from view list */
while (test_views.head != NULL) {
test_views.node = test_views.head;
test_views.head = test_views.head->link;
- c = 0;
- loop_views.head = views.head;
- loop_views.node = views.node;
- while (loop_views.head != NULL) {
- loop_views.node = loop_views.head;
- loop_views.head = loop_views.head->link;
- if (test_views.node->start_view == loop_views.node->start_view &&
- test_views.node->end_view == loop_views.node->end_view)
- c++;
- }
- if (c == 1) {
+ i = test_views.node->start_view * pathlimit + test_views.node->end_view;
+ if (view_count[i] == 1) {
single_views.node = snewn(1,struct entry);
single_views.node->link = single_views.head;
single_views.node->guess = snewn(path_guess.length,int);
}
}
+ sfree(view_count);
+
if (count_uniques > 0) {
test_entry.start_view = 0;
test_entry.end_view = 0;
for (i=0;i<paths[p].num_monsters;i++) {
switch (state->guess[paths[p].mapping[i]]) {
- case 1: loop.guess[i] = 1; break;
- case 2: loop.guess[i] = 2; break;
- case 3: loop.guess[i] = 1; break;
- case 4: loop.guess[i] = 4; break;
- case 5: loop.guess[i] = 1; break;
- case 6: loop.guess[i] = 2; break;
- case 7: loop.guess[i] = 1; break;
+ case 1: loop.guess[i] = 1; break;
+ case 2: loop.guess[i] = 2; break;
+ case 3: loop.guess[i] = 1; break;
+ case 4: loop.guess[i] = 4; break;
+ case 5: loop.guess[i] = 1; break;
+ case 6: loop.guess[i] = 2; break;
+ case 7: loop.guess[i] = 1; break;
}
loop.possible[i] = state->guess[paths[p].mapping[i]];
possible[paths[p].mapping[i]] = 0;
for (i=0;i<state->common->num_total;i++) {
loop.possible[i] = state->guess[i];
switch (state->guess[i]) {
- case 1: loop.guess[i] = 1; break;
- case 2: loop.guess[i] = 2; break;
- case 3: loop.guess[i] = 1; break;
- case 4: loop.guess[i] = 4; break;
- case 5: loop.guess[i] = 1; break;
- case 6: loop.guess[i] = 2; break;
- case 7: loop.guess[i] = 1; break;
+ case 1: loop.guess[i] = 1; break;
+ case 2: loop.guess[i] = 2; break;
+ case 3: loop.guess[i] = 1; break;
+ case 4: loop.guess[i] = 4; break;
+ case 5: loop.guess[i] = 1; break;
+ case 6: loop.guess[i] = 2; break;
+ case 7: loop.guess[i] = 1; break;
}
}
* empty monster cells */
count = 0;
for (h=1;h<new->common->params.h+1;h++)
- for (w=1;w<new->common->params.w+1;w++) {
- c = random_upto(rs,5);
- if (c >= 2) {
- new->common->grid[w+h*(new->common->params.w+2)] = CELL_EMPTY;
- new->common->xinfo[w+h*(new->common->params.w+2)] = count++;
- }
- else if (c == 0) {
- new->common->grid[w+h*(new->common->params.w+2)] =
- CELL_MIRROR_L;
- new->common->xinfo[w+h*(new->common->params.w+2)] = -1;
- }
- else {
- new->common->grid[w+h*(new->common->params.w+2)] =
- CELL_MIRROR_R;
- new->common->xinfo[w+h*(new->common->params.w+2)] = -1;
+ for (w=1;w<new->common->params.w+1;w++) {
+ c = random_upto(rs,5);
+ if (c >= 2) {
+ new->common->grid[w+h*(new->common->params.w+2)] = CELL_EMPTY;
+ new->common->xinfo[w+h*(new->common->params.w+2)] = count++;
+ }
+ else if (c == 0) {
+ new->common->grid[w+h*(new->common->params.w+2)] =
+ CELL_MIRROR_L;
+ new->common->xinfo[w+h*(new->common->params.w+2)] = -1;
+ }
+ else {
+ new->common->grid[w+h*(new->common->params.w+2)] =
+ CELL_MIRROR_R;
+ new->common->xinfo[w+h*(new->common->params.w+2)] = -1;
+ }
}
- }
new->common->num_total = count; /* Total number of monsters in maze */
/* Puzzle is boring if it has too few monster cells. Discard
/* Grid is invalid if max. path length > threshold. Discard
* grid, make new one */
switch (new->common->params.diff) {
- case DIFF_EASY: max_length = min(new->common->params.w,new->common->params.h) + 1; break;
- case DIFF_NORMAL: max_length = (max(new->common->params.w,new->common->params.h) * 3) / 2; break;
- case DIFF_TRICKY: max_length = 9; break;
- default: max_length = 9; break;
+ case DIFF_EASY: max_length = min(new->common->params.w,new->common->params.h) + 1; break;
+ case DIFF_NORMAL: max_length = (max(new->common->params.w,new->common->params.h) * 3) / 2; break;
+ case DIFF_TRICKY: max_length = 9; break;
+ default: max_length = 9; break;
}
for (p=0;p<new->common->num_paths;p++) {
even less paths with unique solutions */
switch (new->common->params.diff) {
- case DIFF_EASY: filling = 2; break;
- case DIFF_NORMAL: filling = min( (new->common->params.w+new->common->params.h) , (new->common->num_total)/2 ); break;
- case DIFF_TRICKY: filling = max( (new->common->params.w+new->common->params.h) , (new->common->num_total)/2 ); break;
- default: filling = 0; break;
+ case DIFF_EASY: filling = 2; break;
+ case DIFF_NORMAL: filling = min( (new->common->params.w+new->common->params.h) , (new->common->num_total)/2 ); break;
+ case DIFF_TRICKY: filling = max( (new->common->params.w+new->common->params.h) , (new->common->num_total)/2 ); break;
+ default: filling = 0; break;
}
count = 0;
}
for (w=1;w<new->common->params.w+1;w++)
- for (h=1;h<new->common->params.h+1;h++) {
- c = new->common->xinfo[w+h*(new->common->params.w+2)];
- if (c >= 0) {
- if (new->guess[c] == 1) new->common->grid[w+h*(new->common->params.w+2)] = CELL_GHOST;
- if (new->guess[c] == 2) new->common->grid[w+h*(new->common->params.w+2)] = CELL_VAMPIRE;
- if (new->guess[c] == 4) new->common->grid[w+h*(new->common->params.w+2)] = CELL_ZOMBIE;
+ for (h=1;h<new->common->params.h+1;h++) {
+ c = new->common->xinfo[w+h*(new->common->params.w+2)];
+ if (c >= 0) {
+ if (new->guess[c] == 1) new->common->grid[w+h*(new->common->params.w+2)] = CELL_GHOST;
+ if (new->guess[c] == 2) new->common->grid[w+h*(new->common->params.w+2)] = CELL_VAMPIRE;
+ if (new->guess[c] == 4) new->common->grid[w+h*(new->common->params.w+2)] = CELL_ZOMBIE;
+ }
}
- }
/* Prepare path information needed by the solver (containing all hints) */
for (p=0;p<new->common->num_paths;p++) {
/* Encode grid */
count = 0;
for (y=1;y<new->common->params.h+1;y++)
- for (x=1;x<new->common->params.w+1;x++) {
- c = new->common->grid[x+y*(new->common->params.w+2)];
- if (count > 25) {
- *e++ = 'z';
- count -= 26;
- }
- if (c != CELL_MIRROR_L && c != CELL_MIRROR_R) {
- count++;
- }
- else if (c == CELL_MIRROR_L) {
- if (count > 0) *e++ = (count-1 + 'a');
- *e++ = 'L';
- count = 0;
- }
- else {
- if (count > 0) *e++ = (count-1 + 'a');
- *e++ = 'R';
- count = 0;
+ for (x=1;x<new->common->params.w+1;x++) {
+ c = new->common->grid[x+y*(new->common->params.w+2)];
+ if (count > 25) {
+ *e++ = 'z';
+ count -= 26;
+ }
+ if (c != CELL_MIRROR_L && c != CELL_MIRROR_R) {
+ count++;
+ }
+ else if (c == CELL_MIRROR_L) {
+ if (count > 0) *e++ = (count-1 + 'a');
+ *e++ = 'L';
+ count = 0;
+ }
+ else {
+ if (count > 0) *e++ = (count-1 + 'a');
+ *e++ = 'R';
+ count = 0;
+ }
}
- }
if (count > 0) *e++ = (count-1 + 'a');
/* Encode hints */
};
#define TILESIZE (ds->tilesize)
-#define BORDER (TILESIZE/2)
+#define BORDER (TILESIZE/4)
-static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
- int x, int y, int button) {
+static char *interpret_move(game_state *state, game_ui *ui,
+ const game_drawstate *ds, int x, int y, int button)
+{
int gx,gy;
int g,xi;
char buf[80];
gy = ((y-BORDER-2) / TILESIZE ) - 1;
if (button == 'a' || button == 'A') {
- ds->ascii = ui->ascii ? FALSE : TRUE;
+ ui->ascii = !ui->ascii;
return "";
}
ui->hy = 1;
}
else switch (button) {
- case CURSOR_UP: ui->hy -= (ui->hy > 1) ? 1 : 0; break;
- case CURSOR_DOWN: ui->hy += (ui->hy < ds->h) ? 1 : 0; break;
- case CURSOR_RIGHT: ui->hx += (ui->hx < ds->w) ? 1 : 0; break;
- case CURSOR_LEFT: ui->hx -= (ui->hx > 1) ? 1 : 0; break;
- }
+ case CURSOR_UP: ui->hy -= (ui->hy > 1) ? 1 : 0; break;
+ case CURSOR_DOWN: ui->hy += (ui->hy < ds->h) ? 1 : 0; break;
+ case CURSOR_RIGHT: ui->hx += (ui->hx < ds->w) ? 1 : 0; break;
+ case CURSOR_LEFT: ui->hx -= (ui->hx > 1) ? 1 : 0; break;
+ }
ui->hshow = ui->hcursor = 1;
return "";
}
if (xi >= 0 && !state->common->fixed[xi]) {
if (button == 'g' || button == 'G' || button == '1') {
sprintf(buf,"g%d",xi);
- ui->hpencil = ui->hshow = 0;
+ if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
return dupstr(buf);
}
if (button == 'v' || button == 'V' || button == '2') {
sprintf(buf,"v%d",xi);
- ui->hpencil = ui->hshow = 0;
+ if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
return dupstr(buf);
}
if (button == 'z' || button == 'Z' || button == '3') {
sprintf(buf,"z%d",xi);
- ui->hpencil = ui->hshow = 0;
+ if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
return dupstr(buf);
}
if (button == 'e' || button == 'E' || button == CURSOR_SELECT2 ||
button == '0' || button == '\b') {
- if (!ui->hcursor) ui->hshow = 0;
sprintf(buf,"E%d",xi);
- ui->hpencil = ui->hshow = 0;
+ if (!ui->hcursor) ui->hpencil = ui->hshow = 0;
return dupstr(buf);
}
}
valid = FALSE;
state->count_errors[0] = TRUE;
for (x=1;x<state->common->params.w+1;x++)
- for (y=1;y<state->common->params.h+1;y++) {
- xy = x+y*(state->common->params.w+2);
- if (state->common->xinfo[xy] >= 0 &&
- guess[state->common->xinfo[xy]] == 1)
- state->cell_errors[xy] = TRUE;
- }
+ for (y=1;y<state->common->params.h+1;y++) {
+ xy = x+y*(state->common->params.w+2);
+ if (state->common->xinfo[xy] >= 0 &&
+ guess[state->common->xinfo[xy]] == 1)
+ state->cell_errors[xy] = TRUE;
+ }
}
if (count_vampires > state->common->num_vampires ||
(filled && count_vampires != state->common->num_vampires) ) {
valid = FALSE;
state->count_errors[1] = TRUE;
for (x=1;x<state->common->params.w+1;x++)
- for (y=1;y<state->common->params.h+1;y++) {
- xy = x+y*(state->common->params.w+2);
- if (state->common->xinfo[xy] >= 0 &&
- guess[state->common->xinfo[xy]] == 2)
- state->cell_errors[xy] = TRUE;
- }
+ for (y=1;y<state->common->params.h+1;y++) {
+ xy = x+y*(state->common->params.w+2);
+ if (state->common->xinfo[xy] >= 0 &&
+ guess[state->common->xinfo[xy]] == 2)
+ state->cell_errors[xy] = TRUE;
+ }
}
if (count_zombies > state->common->num_zombies ||
(filled && count_zombies != state->common->num_zombies) ) {
valid = FALSE;
state->count_errors[2] = TRUE;
for (x=1;x<state->common->params.w+1;x++)
- for (y=1;y<state->common->params.h+1;y++) {
- xy = x+y*(state->common->params.w+2);
- if (state->common->xinfo[xy] >= 0 &&
- guess[state->common->xinfo[xy]] == 4)
- state->cell_errors[xy] = TRUE;
- }
+ for (y=1;y<state->common->params.h+1;y++) {
+ xy = x+y*(state->common->params.w+2);
+ if (state->common->xinfo[xy] >= 0 &&
+ guess[state->common->xinfo[xy]] == 4)
+ state->cell_errors[xy] = TRUE;
+ }
}
return valid;
static void game_compute_size(game_params *params, int tilesize,
int *x, int *y) {
- *x = tilesize + (2 + params->w) * tilesize;
- *y = tilesize + (3 + params->h) * tilesize;
+ /* Ick: fake up `ds->tilesize' for macro expansion purposes */
+ struct { int tilesize; } ads, *ds = &ads;
+ ads.tilesize = tilesize;
+
+ *x = 2*BORDER+(params->w+2)*TILESIZE;
+ *y = 2*BORDER+(params->h+3)*TILESIZE;
return;
}
dh = TILESIZE;
dx = BORDER+(ds->w+2)*TILESIZE/2+TILESIZE/4;
switch (c) {
- case 0:
- sprintf(buf,"%d",state->common->num_ghosts);
- sprintf(bufm,"G");
- dx -= 3*TILESIZE/2;
- break;
- case 1:
- sprintf(buf,"%d",state->common->num_vampires);
- sprintf(bufm,"V");
- break;
- case 2:
- sprintf(buf,"%d",state->common->num_zombies);
- sprintf(bufm,"Z");
- dx += 3*TILESIZE/2;
- break;
+ case 0:
+ sprintf(buf,"%d",state->common->num_ghosts);
+ sprintf(bufm,"G");
+ dx -= 3*TILESIZE/2;
+ break;
+ case 1:
+ sprintf(buf,"%d",state->common->num_vampires);
+ sprintf(bufm,"V");
+ break;
+ case 2:
+ sprintf(buf,"%d",state->common->num_zombies);
+ sprintf(bufm,"Z");
+ dx += 3*TILESIZE/2;
+ break;
}
if (!ds->ascii) {
static void draw_pencils(drawing *dr, game_drawstate *ds, game_state *state,
int x, int y, int pencil) {
int dx, dy;
- int monsters[4];
- int i, j, px, py;
+ int monsters[4];
+ int i, j, px, py;
char buf[10];
dx = BORDER+(x* ds->tilesize)+(TILESIZE/4);
dy = BORDER+(y* ds->tilesize)+(TILESIZE/4)+TILESIZE;
- for (i = 0, j = 1; j < 8; j *= 2)
- if (pencil & j)
- monsters[i++] = j;
- while (i < 4)
- monsters[i++] = 0;
-
- for (py = 0; py < 2; py++)
- for (px = 0; px < 2; px++)
- if (monsters[py*2+px]) {
- if (!ds->ascii) {
- draw_monster(dr, ds,
- dx + TILESIZE/2 * px, dy + TILESIZE/2 * py,
- TILESIZE/2, 0, monsters[py*2+px]);
- }
- else {
- switch (monsters[py*2+px]) {
- case 1: sprintf(buf,"G"); break;
- case 2: sprintf(buf,"V"); break;
- case 4: sprintf(buf,"Z"); break;
- }
- draw_text(dr,dx + TILESIZE/2 * px,dy + TILESIZE/2 * py,
- FONT_FIXED,TILESIZE/4,ALIGN_HCENTRE|ALIGN_VCENTRE,
- COL_TEXT,buf);
+ for (i = 0, j = 1; j < 8; j *= 2)
+ if (pencil & j)
+ monsters[i++] = j;
+ while (i < 4)
+ monsters[i++] = 0;
+
+ for (py = 0; py < 2; py++)
+ for (px = 0; px < 2; px++)
+ if (monsters[py*2+px]) {
+ if (!ds->ascii) {
+ draw_monster(dr, ds,
+ dx + TILESIZE/2 * px, dy + TILESIZE/2 * py,
+ TILESIZE/2, 0, monsters[py*2+px]);
+ }
+ else {
+ switch (monsters[py*2+px]) {
+ case 1: sprintf(buf,"G"); break;
+ case 2: sprintf(buf,"V"); break;
+ case 4: sprintf(buf,"Z"); break;
}
+ draw_text(dr,dx + TILESIZE/2 * px,dy + TILESIZE/2 * py,
+ FONT_FIXED,TILESIZE/4,ALIGN_HCENTRE|ALIGN_VCENTRE,
+ COL_TEXT,buf);
}
+ }
draw_update(dr,dx-(TILESIZE/4)+2,dy-(TILESIZE/4)+2,
(TILESIZE/2)-3,(TILESIZE/2)-3);
#define FLASH_TIME 0.7F
static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
- game_state *state, int dir, game_ui *ui,
- float animtime, float flashtime) {
+ game_state *state, int dir, game_ui *ui,
+ float animtime, float flashtime) {
int i,j,x,y,xy;
- int stale, xi, c, hflash, hchanged;
+ int stale, xi, c, hflash, hchanged, changed_ascii;
hflash = (int)(flashtime * 5 / FLASH_TIME) % 2;
draw_rect(dr, BORDER+(ds->tilesize*(i+1))+1,
BORDER+(ds->tilesize*(j+2))+1, ds->tilesize-1,
ds->tilesize-1, COL_BACKGROUND);
- draw_update(dr,BORDER+TILESIZE-1,BORDER+2*TILESIZE-1,
- (ds->w)*TILESIZE+3, (ds->h)*TILESIZE+3);
+ draw_update(dr, 0, 0, 2*BORDER+(ds->w+2)*TILESIZE,
+ 2*BORDER+(ds->h+3)*TILESIZE);
}
hchanged = FALSE;
ds->hshow != ui->hshow || ds->hpencil != ui->hpencil)
hchanged = TRUE;
+ if (ds->ascii != ui->ascii) {
+ ds->ascii = ui->ascii;
+ changed_ascii = TRUE;
+ } else
+ changed_ascii = FALSE;
+
/* Draw monster count hints */
for (i=0;i<3;i++) {
stale = FALSE;
if (!ds->started) stale = TRUE;
if (ds->hflash != hflash) stale = TRUE;
- if (ds->ascii != ui->ascii) stale = TRUE;
+ if (changed_ascii) stale = TRUE;
if (ds->count_errors[i] != state->count_errors[i]) {
stale = TRUE;
ds->count_errors[i] = state->count_errors[i];
/* Draw puzzle grid contents */
for (x = 1; x < ds->w+1; x++)
- for (y = 1; y < ds->h+1; y++) {
- stale = FALSE;
- xy = x+y*(state->common->params.w+2);
- xi = state->common->xinfo[xy];
- c = state->common->grid[xy];
+ for (y = 1; y < ds->h+1; y++) {
+ stale = FALSE;
+ xy = x+y*(state->common->params.w+2);
+ xi = state->common->xinfo[xy];
+ c = state->common->grid[xy];
- if (!ds->started) stale = TRUE;
- if (ds->hflash != hflash) stale = TRUE;
- if (ds->ascii != ui->ascii) stale = TRUE;
+ if (!ds->started) stale = TRUE;
+ if (ds->hflash != hflash) stale = TRUE;
+ if (changed_ascii) stale = TRUE;
- if (hchanged) {
- if ((x == ui->hx && y == ui->hy) ||
- (x == ds->hx && y == ds->hy))
- stale = TRUE;
- }
+ if (hchanged) {
+ if ((x == ui->hx && y == ui->hy) ||
+ (x == ds->hx && y == ds->hy))
+ stale = TRUE;
+ }
- if (xi >= 0 && (state->guess[xi] != ds->monsters[xi]) ) {
- stale = TRUE;
- ds->monsters[xi] = state->guess[xi];
- }
+ if (xi >= 0 && (state->guess[xi] != ds->monsters[xi]) ) {
+ stale = TRUE;
+ ds->monsters[xi] = state->guess[xi];
+ }
- if (xi >= 0 && (state->pencils[xi] != ds->pencils[xi]) ) {
- stale = TRUE;
- ds->pencils[xi] = state->pencils[xi];
- }
+ if (xi >= 0 && (state->pencils[xi] != ds->pencils[xi]) ) {
+ stale = TRUE;
+ ds->pencils[xi] = state->pencils[xi];
+ }
- if (state->cell_errors[xy] != ds->cell_errors[xy]) {
- stale = TRUE;
- ds->cell_errors[xy] = state->cell_errors[xy];
- }
+ if (state->cell_errors[xy] != ds->cell_errors[xy]) {
+ stale = TRUE;
+ ds->cell_errors[xy] = state->cell_errors[xy];
+ }
- if (stale) {
- draw_cell_background(dr, ds, state, ui, x, y);
- if (xi < 0)
- draw_mirror(dr, ds, state, x, y, hflash, c);
- else if (state->guess[xi] == 1 || state->guess[xi] == 2 ||
- state->guess[xi] == 4)
- draw_big_monster(dr, ds, state, x, y, hflash, state->guess[xi]);
- else
- draw_pencils(dr, ds, state, x, y, state->pencils[xi]);
+ if (stale) {
+ draw_cell_background(dr, ds, state, ui, x, y);
+ if (xi < 0)
+ draw_mirror(dr, ds, state, x, y, hflash, c);
+ else if (state->guess[xi] == 1 || state->guess[xi] == 2 ||
+ state->guess[xi] == 4)
+ draw_big_monster(dr, ds, state, x, y, hflash, state->guess[xi]);
+ else
+ draw_pencils(dr, ds, state, x, y, state->pencils[xi]);
+ }
}
- }
ds->hx = ui->hx; ds->hy = ui->hy;
ds->hshow = ui->hshow;
ds->hpencil = ui->hpencil;
ds->hflash = hflash;
- ui->ascii = ds->ascii;
ds->started = TRUE;
return;
}
FALSE, game_timing_state,
0, /* flags */
};
-
~ian / sgt-puzzles.git / blobdiff