mirror of
git://git.tartarus.org/simon/puzzles.git
synced 2025-04-21 08:01:30 -07:00
Files
af59dcf685
as seen by the back ends from the one implemented by the front end, and shoved a piece of middleware (drawing.c) in between to permit interchange of multiple kinds of the latter. I've also added a number of functions to the drawing API to permit printing as well as on-screen drawing, and retired print.py in favour of integrated printing done by means of that API. The immediate visible change is that print.py is dead, and each puzzle now does its own printing: where you would previously have typed `print.py solo 2x3', you now type `solo --print 2x3' and it should work in much the same way. Advantages of the new mechanism available right now: - Map is now printable, because the new print function can make use of the output from the existing game ID decoder rather than me having to replicate all those fiddly algorithms in Python. - the new print functions can cope with non-initial game states, which means each puzzle supporting --print also supports --with-solutions. - there's also a --scale option permitting users to adjust the size of the printed puzzles. Advantages which will be available at some point: - the new API should permit me to implement native printing mechanisms on Windows and OS X. [originally from svn r6190]
1669 lines
48 KiB
C
1669 lines
48 KiB
C
/*
|
|
* 'same game' -- try to remove all the coloured squares by
|
|
* selecting regions of contiguous colours.
|
|
*/
|
|
|
|
/*
|
|
* TODO on grid generation:
|
|
*
|
|
* - Generation speed could still be improved.
|
|
* * 15x10c3 is the only really difficult one of the existing
|
|
* presets. The others are all either small enough, or have
|
|
* the great flexibility given by four colours, that they
|
|
* don't take long at all.
|
|
* * I still suspect many problems arise from separate
|
|
* subareas. I wonder if we can also somehow prioritise left-
|
|
* or rightmost insertions so as to avoid area splitting at
|
|
* all where feasible? It's not easy, though, because the
|
|
* current shuffle-then-try-all-options approach to move
|
|
* choice doesn't leave room for `soft' probabilistic
|
|
* prioritisation: we either try all class A moves before any
|
|
* class B ones, or we don't.
|
|
*
|
|
* - The current generation algorithm inserts exactly two squares
|
|
* at a time, with a single exception at the beginning of
|
|
* generation for grids of odd overall size. An obvious
|
|
* extension would be to permit larger inverse moves during
|
|
* generation.
|
|
* * this might reduce the number of failed generations by
|
|
* making the insertion algorithm more flexible
|
|
* * on the other hand, it would be significantly more complex
|
|
* * if I do this I'll need to take out the odd-subarea
|
|
* avoidance
|
|
* * a nice feature of the current algorithm is that the
|
|
* computer's `intended' solution always receives the minimum
|
|
* possible score, so that pretty much the player's entire
|
|
* score represents how much better they did than the
|
|
* computer.
|
|
*
|
|
* - Is it possible we can _temporarily_ tolerate neighbouring
|
|
* squares of the same colour, until we've finished setting up
|
|
* our inverse move?
|
|
* * or perhaps even not choose the colour of our inserted
|
|
* region until we have finished placing it, and _then_ look
|
|
* at what colours border on it?
|
|
* * I don't think this is currently meaningful unless we're
|
|
* placing more than a domino at a time.
|
|
*
|
|
* - possibly write out a full solution so that Solve can somehow
|
|
* show it step by step?
|
|
* * aux_info would have to encode the click points
|
|
* * solve_game() would have to encode not only those click
|
|
* points but also give a move string which reconstructed the
|
|
* initial state
|
|
* * the game_state would include a pointer to a solution move
|
|
* list, plus an index into that list
|
|
* * game_changed_state would auto-select the next move if
|
|
* handed a new state which had a solution move list active
|
|
* * execute_move, if passed such a state as input, would check
|
|
* to see whether the move being made was the same as the one
|
|
* stated by the solution, and if so would advance the move
|
|
* index. Failing that it would return a game_state without a
|
|
* solution move list active at all.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <math.h>
|
|
|
|
#include "puzzles.h"
|
|
|
|
#define TILE_INNER (ds->tileinner)
|
|
#define TILE_GAP (ds->tilegap)
|
|
#define TILE_SIZE (TILE_INNER + TILE_GAP)
|
|
#define PREFERRED_TILE_SIZE 32
|
|
#define BORDER (TILE_SIZE / 2)
|
|
#define HIGHLIGHT_WIDTH 2
|
|
|
|
#define FLASH_FRAME 0.13F
|
|
|
|
#define COORD(x) ( (x) * TILE_SIZE + BORDER )
|
|
#define FROMCOORD(x) ( ((x) - BORDER + TILE_SIZE) / TILE_SIZE - 1 )
|
|
|
|
#define X(state, i) ( (i) % (state)->params.w )
|
|
#define Y(state, i) ( (i) / (state)->params.w )
|
|
#define C(state, x, y) ( (y) * (state)->w + (x) )
|
|
|
|
enum {
|
|
COL_BACKGROUND,
|
|
COL_1, COL_2, COL_3, COL_4, COL_5, COL_6, COL_7, COL_8, COL_9,
|
|
COL_IMPOSSIBLE, COL_SEL, COL_HIGHLIGHT, COL_LOWLIGHT,
|
|
NCOLOURS
|
|
};
|
|
|
|
/* scoresub is 1 or 2 (for (n-1)^2 or (n-2)^2) */
|
|
struct game_params {
|
|
int w, h, ncols, scoresub;
|
|
int soluble; /* choose generation algorithm */
|
|
};
|
|
|
|
/* These flags must be unique across all uses; in the game_state,
|
|
* the game_ui, and the drawstate (as they all get combined in the
|
|
* drawstate). */
|
|
#define TILE_COLMASK 0x00ff
|
|
#define TILE_SELECTED 0x0100 /* used in ui and drawstate */
|
|
#define TILE_JOINRIGHT 0x0200 /* used in drawstate */
|
|
#define TILE_JOINDOWN 0x0400 /* used in drawstate */
|
|
#define TILE_JOINDIAG 0x0800 /* used in drawstate */
|
|
#define TILE_HASSEL 0x1000 /* used in drawstate */
|
|
#define TILE_IMPOSSIBLE 0x2000 /* used in drawstate */
|
|
|
|
#define TILE(gs,x,y) ((gs)->tiles[(gs)->params.w*(y)+(x)])
|
|
#define COL(gs,x,y) (TILE(gs,x,y) & TILE_COLMASK)
|
|
#define ISSEL(gs,x,y) (TILE(gs,x,y) & TILE_SELECTED)
|
|
|
|
#define SWAPTILE(gs,x1,y1,x2,y2) do { \
|
|
int t = TILE(gs,x1,y1); \
|
|
TILE(gs,x1,y1) = TILE(gs,x2,y2); \
|
|
TILE(gs,x2,y2) = t; \
|
|
} while (0)
|
|
|
|
static int npoints(game_params *params, int nsel)
|
|
{
|
|
int sdiff = nsel - params->scoresub;
|
|
return (sdiff > 0) ? sdiff * sdiff : 0;
|
|
}
|
|
|
|
struct game_state {
|
|
struct game_params params;
|
|
int n;
|
|
int *tiles; /* colour only */
|
|
int score;
|
|
int complete, impossible;
|
|
};
|
|
|
|
static game_params *default_params(void)
|
|
{
|
|
game_params *ret = snew(game_params);
|
|
ret->w = 5;
|
|
ret->h = 5;
|
|
ret->ncols = 3;
|
|
ret->scoresub = 2;
|
|
ret->soluble = TRUE;
|
|
return ret;
|
|
}
|
|
|
|
static const struct game_params samegame_presets[] = {
|
|
{ 5, 5, 3, 2, TRUE },
|
|
{ 10, 5, 3, 2, TRUE },
|
|
#ifdef SLOW_SYSTEM
|
|
{ 10, 10, 3, 2, TRUE },
|
|
#else
|
|
{ 15, 10, 3, 2, TRUE },
|
|
#endif
|
|
{ 15, 10, 4, 2, TRUE },
|
|
{ 20, 15, 4, 2, TRUE }
|
|
};
|
|
|
|
static int game_fetch_preset(int i, char **name, game_params **params)
|
|
{
|
|
game_params *ret;
|
|
char str[80];
|
|
|
|
if (i < 0 || i >= lenof(samegame_presets))
|
|
return FALSE;
|
|
|
|
ret = snew(game_params);
|
|
*ret = samegame_presets[i];
|
|
|
|
sprintf(str, "%dx%d, %d colours", ret->w, ret->h, ret->ncols);
|
|
|
|
*name = dupstr(str);
|
|
*params = ret;
|
|
return TRUE;
|
|
}
|
|
|
|
static void free_params(game_params *params)
|
|
{
|
|
sfree(params);
|
|
}
|
|
|
|
static game_params *dup_params(game_params *params)
|
|
{
|
|
game_params *ret = snew(game_params);
|
|
*ret = *params; /* structure copy */
|
|
return ret;
|
|
}
|
|
|
|
static void decode_params(game_params *params, char const *string)
|
|
{
|
|
char const *p = string;
|
|
|
|
params->w = atoi(p);
|
|
while (*p && isdigit((unsigned char)*p)) p++;
|
|
if (*p == 'x') {
|
|
p++;
|
|
params->h = atoi(p);
|
|
while (*p && isdigit((unsigned char)*p)) p++;
|
|
} else {
|
|
params->h = params->w;
|
|
}
|
|
if (*p == 'c') {
|
|
p++;
|
|
params->ncols = atoi(p);
|
|
while (*p && isdigit((unsigned char)*p)) p++;
|
|
} else {
|
|
params->ncols = 3;
|
|
}
|
|
if (*p == 's') {
|
|
p++;
|
|
params->scoresub = atoi(p);
|
|
while (*p && isdigit((unsigned char)*p)) p++;
|
|
} else {
|
|
params->scoresub = 2;
|
|
}
|
|
if (*p == 'r') {
|
|
p++;
|
|
params->soluble = FALSE;
|
|
}
|
|
}
|
|
|
|
static char *encode_params(game_params *params, int full)
|
|
{
|
|
char ret[80];
|
|
|
|
sprintf(ret, "%dx%dc%ds%d%s",
|
|
params->w, params->h, params->ncols, params->scoresub,
|
|
full && !params->soluble ? "r" : "");
|
|
return dupstr(ret);
|
|
}
|
|
|
|
static config_item *game_configure(game_params *params)
|
|
{
|
|
config_item *ret;
|
|
char buf[80];
|
|
|
|
ret = snewn(6, config_item);
|
|
|
|
ret[0].name = "Width";
|
|
ret[0].type = C_STRING;
|
|
sprintf(buf, "%d", params->w);
|
|
ret[0].sval = dupstr(buf);
|
|
ret[0].ival = 0;
|
|
|
|
ret[1].name = "Height";
|
|
ret[1].type = C_STRING;
|
|
sprintf(buf, "%d", params->h);
|
|
ret[1].sval = dupstr(buf);
|
|
ret[1].ival = 0;
|
|
|
|
ret[2].name = "No. of colours";
|
|
ret[2].type = C_STRING;
|
|
sprintf(buf, "%d", params->ncols);
|
|
ret[2].sval = dupstr(buf);
|
|
ret[2].ival = 0;
|
|
|
|
ret[3].name = "Scoring system";
|
|
ret[3].type = C_CHOICES;
|
|
ret[3].sval = ":(n-1)^2:(n-2)^2";
|
|
ret[3].ival = params->scoresub-1;
|
|
|
|
ret[4].name = "Ensure solubility";
|
|
ret[4].type = C_BOOLEAN;
|
|
ret[4].sval = NULL;
|
|
ret[4].ival = params->soluble;
|
|
|
|
ret[5].name = NULL;
|
|
ret[5].type = C_END;
|
|
ret[5].sval = NULL;
|
|
ret[5].ival = 0;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static game_params *custom_params(config_item *cfg)
|
|
{
|
|
game_params *ret = snew(game_params);
|
|
|
|
ret->w = atoi(cfg[0].sval);
|
|
ret->h = atoi(cfg[1].sval);
|
|
ret->ncols = atoi(cfg[2].sval);
|
|
ret->scoresub = cfg[3].ival + 1;
|
|
ret->soluble = cfg[4].ival;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static char *validate_params(game_params *params, int full)
|
|
{
|
|
if (params->w < 1 || params->h < 1)
|
|
return "Width and height must both be positive";
|
|
|
|
if (params->ncols > 9)
|
|
return "Maximum of 9 colours";
|
|
|
|
if (params->soluble) {
|
|
if (params->ncols < 3)
|
|
return "Number of colours must be at least three";
|
|
if (params->w * params->h <= 1)
|
|
return "Grid area must be greater than 1";
|
|
} else {
|
|
if (params->ncols < 2)
|
|
return "Number of colours must be at least three";
|
|
/* ...and we must make sure we can generate at least 2 squares
|
|
* of each colour so it's theoretically soluble. */
|
|
if ((params->w * params->h) < (params->ncols * 2))
|
|
return "Too many colours makes given grid size impossible";
|
|
}
|
|
|
|
if ((params->scoresub < 1) || (params->scoresub > 2))
|
|
return "Scoring system not recognised";
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Guaranteed-soluble grid generator.
|
|
*/
|
|
static void gen_grid(int w, int h, int nc, int *grid, random_state *rs)
|
|
{
|
|
int wh = w*h, tc = nc+1;
|
|
int i, j, k, c, x, y, pos, n;
|
|
int *list, *grid2;
|
|
int ok, failures = 0;
|
|
|
|
/*
|
|
* We'll use `list' to track the possible places to put our
|
|
* next insertion. There are up to h places to insert in each
|
|
* column: in a column of height n there are n+1 places because
|
|
* we can insert at the very bottom or the very top, but a
|
|
* column of height h can't have anything at all inserted in it
|
|
* so we have up to h in each column. Likewise, with n columns
|
|
* present there are n+1 places to fit a new one in between but
|
|
* we can't insert a column if there are already w; so there
|
|
* are a maximum of w new columns too. Total is wh + w.
|
|
*/
|
|
list = snewn(wh + w, int);
|
|
grid2 = snewn(wh, int);
|
|
|
|
do {
|
|
/*
|
|
* Start with two or three squares - depending on parity of w*h
|
|
* - of a random colour.
|
|
*/
|
|
for (i = 0; i < wh; i++)
|
|
grid[i] = 0;
|
|
j = 2 + (wh % 2);
|
|
c = 1 + random_upto(rs, nc);
|
|
if (j <= w) {
|
|
for (i = 0; i < j; i++)
|
|
grid[(h-1)*w+i] = c;
|
|
} else {
|
|
assert(j <= h);
|
|
for (i = 0; i < j; i++)
|
|
grid[(h-1-i)*w] = c;
|
|
}
|
|
|
|
/*
|
|
* Now repeatedly insert a two-square blob in the grid, of
|
|
* whatever colour will go at the position we chose.
|
|
*/
|
|
while (1) {
|
|
n = 0;
|
|
|
|
/*
|
|
* Build up a list of insertion points. Each point is
|
|
* encoded as y*w+x; insertion points between columns are
|
|
* encoded as h*w+x.
|
|
*/
|
|
|
|
if (grid[wh - 1] == 0) {
|
|
/*
|
|
* The final column is empty, so we can insert new
|
|
* columns.
|
|
*/
|
|
for (i = 0; i < w; i++) {
|
|
list[n++] = wh + i;
|
|
if (grid[(h-1)*w + i] == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now look for places to insert within columns.
|
|
*/
|
|
for (i = 0; i < w; i++) {
|
|
if (grid[(h-1)*w+i] == 0)
|
|
break; /* no more columns */
|
|
|
|
if (grid[i] != 0)
|
|
continue; /* this column is full */
|
|
|
|
for (j = h; j-- > 0 ;) {
|
|
list[n++] = j*w+i;
|
|
if (grid[j*w+i] == 0)
|
|
break; /* this column is exhausted */
|
|
}
|
|
}
|
|
|
|
if (n == 0)
|
|
break; /* we're done */
|
|
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
printf("initial grid:\n");
|
|
{
|
|
int x,y;
|
|
for (y = 0; y < h; y++) {
|
|
for (x = 0; x < w; x++) {
|
|
if (grid[y*w+x] == 0)
|
|
printf("-");
|
|
else
|
|
printf("%d", grid[y*w+x]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Now go through the list one element at a time in
|
|
* random order, and actually attempt to insert
|
|
* something there.
|
|
*/
|
|
while (n-- > 0) {
|
|
int dirs[4], ndirs, dir;
|
|
|
|
i = random_upto(rs, n+1);
|
|
pos = list[i];
|
|
list[i] = list[n];
|
|
|
|
x = pos % w;
|
|
y = pos / w;
|
|
|
|
memcpy(grid2, grid, wh * sizeof(int));
|
|
|
|
if (y == h) {
|
|
/*
|
|
* Insert a column at position x.
|
|
*/
|
|
for (i = w-1; i > x; i--)
|
|
for (j = 0; j < h; j++)
|
|
grid2[j*w+i] = grid2[j*w+(i-1)];
|
|
/*
|
|
* Clear the new column.
|
|
*/
|
|
for (j = 0; j < h; j++)
|
|
grid2[j*w+x] = 0;
|
|
/*
|
|
* Decrement y so that our first square is actually
|
|
* inserted _in_ the grid rather than just below it.
|
|
*/
|
|
y--;
|
|
}
|
|
|
|
/*
|
|
* Insert a square within column x at position y.
|
|
*/
|
|
for (i = 0; i+1 <= y; i++)
|
|
grid2[i*w+x] = grid2[(i+1)*w+x];
|
|
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
printf("trying at n=%d (%d,%d)\n", n, x, y);
|
|
grid2[y*w+x] = tc;
|
|
{
|
|
int x,y;
|
|
for (y = 0; y < h; y++) {
|
|
for (x = 0; x < w; x++) {
|
|
if (grid2[y*w+x] == 0)
|
|
printf("-");
|
|
else if (grid2[y*w+x] <= nc)
|
|
printf("%d", grid2[y*w+x]);
|
|
else
|
|
printf("*");
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Pick our square colour so that it doesn't match any
|
|
* of its neighbours.
|
|
*/
|
|
{
|
|
int wrongcol[4], nwrong = 0;
|
|
|
|
/*
|
|
* List the neighbouring colours.
|
|
*/
|
|
if (x > 0)
|
|
wrongcol[nwrong++] = grid2[y*w+(x-1)];
|
|
if (x+1 < w)
|
|
wrongcol[nwrong++] = grid2[y*w+(x+1)];
|
|
if (y > 0)
|
|
wrongcol[nwrong++] = grid2[(y-1)*w+x];
|
|
if (y+1 < h)
|
|
wrongcol[nwrong++] = grid2[(y+1)*w+x];
|
|
|
|
/*
|
|
* Eliminate duplicates. We can afford a shoddy
|
|
* algorithm here because the problem size is
|
|
* bounded.
|
|
*/
|
|
for (i = j = 0 ;; i++) {
|
|
int pos = -1, min = 0;
|
|
if (j > 0)
|
|
min = wrongcol[j-1];
|
|
for (k = i; k < nwrong; k++)
|
|
if (wrongcol[k] > min &&
|
|
(pos == -1 || wrongcol[k] < wrongcol[pos]))
|
|
pos = k;
|
|
if (pos >= 0) {
|
|
int v = wrongcol[pos];
|
|
wrongcol[pos] = wrongcol[j];
|
|
wrongcol[j++] = v;
|
|
} else
|
|
break;
|
|
}
|
|
nwrong = j;
|
|
|
|
/*
|
|
* If no colour will go here, stop trying.
|
|
*/
|
|
if (nwrong == nc)
|
|
continue;
|
|
|
|
/*
|
|
* Otherwise, pick a colour from the remaining
|
|
* ones.
|
|
*/
|
|
c = 1 + random_upto(rs, nc - nwrong);
|
|
for (i = 0; i < nwrong; i++) {
|
|
if (c >= wrongcol[i])
|
|
c++;
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Place the new square.
|
|
*
|
|
* Although I've _chosen_ the new region's colour
|
|
* (so that we can check adjacency), I'm going to
|
|
* actually place it as an invalid colour (tc)
|
|
* until I'm sure it's viable. This is so that I
|
|
* can conveniently check that I really have made a
|
|
* _valid_ inverse move later on.
|
|
*/
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
printf("picked colour %d\n", c);
|
|
#endif
|
|
grid2[y*w+x] = tc;
|
|
|
|
/*
|
|
* Now attempt to extend it in one of three ways: left,
|
|
* right or up.
|
|
*/
|
|
ndirs = 0;
|
|
if (x > 0 &&
|
|
grid2[y*w+(x-1)] != c &&
|
|
grid2[x-1] == 0 &&
|
|
(y+1 >= h || grid2[(y+1)*w+(x-1)] != c) &&
|
|
(y+1 >= h || grid2[(y+1)*w+(x-1)] != 0) &&
|
|
(x <= 1 || grid2[y*w+(x-2)] != c))
|
|
dirs[ndirs++] = -1; /* left */
|
|
if (x+1 < w &&
|
|
grid2[y*w+(x+1)] != c &&
|
|
grid2[x+1] == 0 &&
|
|
(y+1 >= h || grid2[(y+1)*w+(x+1)] != c) &&
|
|
(y+1 >= h || grid2[(y+1)*w+(x+1)] != 0) &&
|
|
(x+2 >= w || grid2[y*w+(x+2)] != c))
|
|
dirs[ndirs++] = +1; /* right */
|
|
if (y > 0 &&
|
|
grid2[x] == 0 &&
|
|
(x <= 0 || grid2[(y-1)*w+(x-1)] != c) &&
|
|
(x+1 >= w || grid2[(y-1)*w+(x+1)] != c)) {
|
|
/*
|
|
* We add this possibility _twice_, so that the
|
|
* probability of placing a vertical domino is
|
|
* about the same as that of a horizontal. This
|
|
* should yield less bias in the generated
|
|
* grids.
|
|
*/
|
|
dirs[ndirs++] = 0; /* up */
|
|
dirs[ndirs++] = 0; /* up */
|
|
}
|
|
|
|
if (ndirs == 0)
|
|
continue;
|
|
|
|
dir = dirs[random_upto(rs, ndirs)];
|
|
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
printf("picked dir %d\n", dir);
|
|
#endif
|
|
|
|
/*
|
|
* Insert a square within column (x+dir) at position y.
|
|
*/
|
|
for (i = 0; i+1 <= y; i++)
|
|
grid2[i*w+x+dir] = grid2[(i+1)*w+x+dir];
|
|
grid2[y*w+x+dir] = tc;
|
|
|
|
/*
|
|
* See if we've divided the remaining grid squares
|
|
* into sub-areas. If so, we need every sub-area to
|
|
* have an even area or we won't be able to
|
|
* complete generation.
|
|
*
|
|
* If the height is odd and not all columns are
|
|
* present, we can increase the area of a subarea
|
|
* by adding a new column in it, so in that
|
|
* situation we don't mind having as many odd
|
|
* subareas as there are spare columns.
|
|
*
|
|
* If the height is even, we can't fix it at all.
|
|
*/
|
|
{
|
|
int nerrs = 0, nfix = 0;
|
|
k = 0; /* current subarea size */
|
|
for (i = 0; i < w; i++) {
|
|
if (grid2[(h-1)*w+i] == 0) {
|
|
if (h % 2)
|
|
nfix++;
|
|
continue;
|
|
}
|
|
for (j = 0; j < h && grid2[j*w+i] == 0; j++);
|
|
assert(j < h);
|
|
if (j == 0) {
|
|
/*
|
|
* End of previous subarea.
|
|
*/
|
|
if (k % 2)
|
|
nerrs++;
|
|
k = 0;
|
|
} else {
|
|
k += j;
|
|
}
|
|
}
|
|
if (k % 2)
|
|
nerrs++;
|
|
if (nerrs > nfix)
|
|
continue; /* try a different placement */
|
|
}
|
|
|
|
/*
|
|
* We've made a move. Verify that it is a valid
|
|
* move and that if made it would indeed yield the
|
|
* previous grid state. The criteria are:
|
|
*
|
|
* (a) removing all the squares of colour tc (and
|
|
* shuffling the columns up etc) from grid2
|
|
* would yield grid
|
|
* (b) no square of colour tc is adjacent to one
|
|
* of colour c
|
|
* (c) all the squares of colour tc form a single
|
|
* connected component
|
|
*
|
|
* We verify the latter property at the same time
|
|
* as checking that removing all the tc squares
|
|
* would yield the previous grid. Then we colour
|
|
* the tc squares in colour c by breadth-first
|
|
* search, which conveniently permits us to test
|
|
* that they're all connected.
|
|
*/
|
|
{
|
|
int x1, x2, y1, y2;
|
|
int ok = TRUE;
|
|
int fillstart = -1, ntc = 0;
|
|
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
{
|
|
int x,y;
|
|
printf("testing move (new, old):\n");
|
|
for (y = 0; y < h; y++) {
|
|
for (x = 0; x < w; x++) {
|
|
if (grid2[y*w+x] == 0)
|
|
printf("-");
|
|
else if (grid2[y*w+x] <= nc)
|
|
printf("%d", grid2[y*w+x]);
|
|
else
|
|
printf("*");
|
|
}
|
|
printf(" ");
|
|
for (x = 0; x < w; x++) {
|
|
if (grid[y*w+x] == 0)
|
|
printf("-");
|
|
else
|
|
printf("%d", grid[y*w+x]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
for (x1 = x2 = 0; x2 < w; x2++) {
|
|
int usedcol = FALSE;
|
|
|
|
for (y1 = y2 = h-1; y2 >= 0; y2--) {
|
|
if (grid2[y2*w+x2] == tc) {
|
|
ntc++;
|
|
if (fillstart == -1)
|
|
fillstart = y2*w+x2;
|
|
if ((y2+1 < h && grid2[(y2+1)*w+x2] == c) ||
|
|
(y2-1 >= 0 && grid2[(y2-1)*w+x2] == c) ||
|
|
(x2+1 < w && grid2[y2*w+x2+1] == c) ||
|
|
(x2-1 >= 0 && grid2[y2*w+x2-1] == c)) {
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
printf("adjacency failure at %d,%d\n",
|
|
x2, y2);
|
|
#endif
|
|
ok = FALSE;
|
|
}
|
|
continue;
|
|
}
|
|
if (grid2[y2*w+x2] == 0)
|
|
break;
|
|
usedcol = TRUE;
|
|
if (grid2[y2*w+x2] != grid[y1*w+x1]) {
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
printf("matching failure at %d,%d vs %d,%d\n",
|
|
x2, y2, x1, y1);
|
|
#endif
|
|
ok = FALSE;
|
|
}
|
|
y1--;
|
|
}
|
|
|
|
/*
|
|
* If we've reached the top of the column
|
|
* in grid2, verify that we've also reached
|
|
* the top of the column in `grid'.
|
|
*/
|
|
if (usedcol) {
|
|
while (y1 >= 0) {
|
|
if (grid[y1*w+x1] != 0) {
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
printf("junk at column top (%d,%d)\n",
|
|
x1, y1);
|
|
#endif
|
|
ok = FALSE;
|
|
}
|
|
y1--;
|
|
}
|
|
}
|
|
|
|
if (!ok)
|
|
break;
|
|
|
|
if (usedcol)
|
|
x1++;
|
|
}
|
|
|
|
if (!ok) {
|
|
assert(!"This should never happen");
|
|
|
|
/*
|
|
* If this game is compiled NDEBUG so that
|
|
* the assertion doesn't bring it to a
|
|
* crashing halt, the only thing we can do
|
|
* is to give up, loop round again, and
|
|
* hope to randomly avoid making whatever
|
|
* type of move just caused this failure.
|
|
*/
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Now use bfs to fill in the tc section as
|
|
* colour c. We use `list' to store the set of
|
|
* squares we have to process.
|
|
*/
|
|
i = j = 0;
|
|
assert(fillstart >= 0);
|
|
list[i++] = fillstart;
|
|
#ifdef OUTPUT_SOLUTION
|
|
printf("M");
|
|
#endif
|
|
while (j < i) {
|
|
k = list[j];
|
|
x = k % w;
|
|
y = k / w;
|
|
#ifdef OUTPUT_SOLUTION
|
|
printf("%s%d", j ? "," : "", k);
|
|
#endif
|
|
j++;
|
|
|
|
assert(grid2[k] == tc);
|
|
grid2[k] = c;
|
|
|
|
if (x > 0 && grid2[k-1] == tc)
|
|
list[i++] = k-1;
|
|
if (x+1 < w && grid2[k+1] == tc)
|
|
list[i++] = k+1;
|
|
if (y > 0 && grid2[k-w] == tc)
|
|
list[i++] = k-w;
|
|
if (y+1 < h && grid2[k+w] == tc)
|
|
list[i++] = k+w;
|
|
}
|
|
#ifdef OUTPUT_SOLUTION
|
|
printf("\n");
|
|
#endif
|
|
|
|
/*
|
|
* Check that we've filled the same number of
|
|
* tc squares as we originally found.
|
|
*/
|
|
assert(j == ntc);
|
|
}
|
|
|
|
memcpy(grid, grid2, wh * sizeof(int));
|
|
|
|
break; /* done it! */
|
|
}
|
|
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
{
|
|
int x,y;
|
|
printf("n=%d\n", n);
|
|
for (y = 0; y < h; y++) {
|
|
for (x = 0; x < w; x++) {
|
|
if (grid[y*w+x] == 0)
|
|
printf("-");
|
|
else
|
|
printf("%d", grid[y*w+x]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (n < 0)
|
|
break;
|
|
}
|
|
|
|
ok = TRUE;
|
|
for (i = 0; i < wh; i++)
|
|
if (grid[i] == 0) {
|
|
ok = FALSE;
|
|
failures++;
|
|
#if defined GENERATION_DIAGNOSTICS || defined SHOW_INCOMPLETE
|
|
{
|
|
int x,y;
|
|
printf("incomplete grid:\n");
|
|
for (y = 0; y < h; y++) {
|
|
for (x = 0; x < w; x++) {
|
|
if (grid[y*w+x] == 0)
|
|
printf("-");
|
|
else
|
|
printf("%d", grid[y*w+x]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
} while (!ok);
|
|
|
|
#if defined GENERATION_DIAGNOSTICS || defined COUNT_FAILURES
|
|
printf("%d failures\n", failures);
|
|
#endif
|
|
#ifdef GENERATION_DIAGNOSTICS
|
|
{
|
|
int x,y;
|
|
printf("final grid:\n");
|
|
for (y = 0; y < h; y++) {
|
|
for (x = 0; x < w; x++) {
|
|
printf("%d", grid[y*w+x]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
sfree(grid2);
|
|
sfree(list);
|
|
}
|
|
|
|
/*
|
|
* Not-guaranteed-soluble grid generator; kept as a legacy, and in
|
|
* case someone finds the slightly odd quality of the guaranteed-
|
|
* soluble grids to be aesthetically displeasing or finds its CPU
|
|
* utilisation to be excessive.
|
|
*/
|
|
static void gen_grid_random(int w, int h, int nc, int *grid, random_state *rs)
|
|
{
|
|
int i, j, c;
|
|
int n = w * h;
|
|
|
|
for (i = 0; i < n; i++)
|
|
grid[i] = 0;
|
|
|
|
/*
|
|
* Our sole concession to not gratuitously generating insoluble
|
|
* grids is to ensure we have at least two of every colour.
|
|
*/
|
|
for (c = 1; c <= nc; c++) {
|
|
for (j = 0; j < 2; j++) {
|
|
do {
|
|
i = (int)random_upto(rs, n);
|
|
} while (grid[i] != 0);
|
|
grid[i] = c;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Fill in the rest of the grid at random.
|
|
*/
|
|
for (i = 0; i < n; i++) {
|
|
if (grid[i] == 0)
|
|
grid[i] = (int)random_upto(rs, nc)+1;
|
|
}
|
|
}
|
|
|
|
static char *new_game_desc(game_params *params, random_state *rs,
|
|
char **aux, int interactive)
|
|
{
|
|
char *ret;
|
|
int n, i, retlen, *tiles;
|
|
|
|
n = params->w * params->h;
|
|
tiles = snewn(n, int);
|
|
|
|
if (params->soluble)
|
|
gen_grid(params->w, params->h, params->ncols, tiles, rs);
|
|
else
|
|
gen_grid_random(params->w, params->h, params->ncols, tiles, rs);
|
|
|
|
ret = NULL;
|
|
retlen = 0;
|
|
for (i = 0; i < n; i++) {
|
|
char buf[80];
|
|
int k;
|
|
|
|
k = sprintf(buf, "%d,", tiles[i]);
|
|
ret = sresize(ret, retlen + k + 1, char);
|
|
strcpy(ret + retlen, buf);
|
|
retlen += k;
|
|
}
|
|
ret[retlen-1] = '\0'; /* delete last comma */
|
|
|
|
sfree(tiles);
|
|
return ret;
|
|
}
|
|
|
|
static char *validate_desc(game_params *params, char *desc)
|
|
{
|
|
int area = params->w * params->h, i;
|
|
char *p = desc;
|
|
|
|
for (i = 0; i < area; i++) {
|
|
char *q = p;
|
|
int n;
|
|
|
|
if (!isdigit((unsigned char)*p))
|
|
return "Not enough numbers in string";
|
|
while (isdigit((unsigned char)*p)) p++;
|
|
|
|
if (i < area-1 && *p != ',')
|
|
return "Expected comma after number";
|
|
else if (i == area-1 && *p)
|
|
return "Excess junk at end of string";
|
|
|
|
n = atoi(q);
|
|
if (n < 0 || n > params->ncols)
|
|
return "Colour out of range";
|
|
|
|
if (*p) p++; /* eat comma */
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static game_state *new_game(midend *me, game_params *params, char *desc)
|
|
{
|
|
game_state *state = snew(game_state);
|
|
char *p = desc;
|
|
int i;
|
|
|
|
state->params = *params; /* struct copy */
|
|
state->n = state->params.w * state->params.h;
|
|
state->tiles = snewn(state->n, int);
|
|
|
|
for (i = 0; i < state->n; i++) {
|
|
assert(*p);
|
|
state->tiles[i] = atoi(p);
|
|
while (*p && *p != ',')
|
|
p++;
|
|
if (*p) p++; /* eat comma */
|
|
}
|
|
state->complete = state->impossible = 0;
|
|
state->score = 0;
|
|
|
|
return state;
|
|
}
|
|
|
|
static game_state *dup_game(game_state *state)
|
|
{
|
|
game_state *ret = snew(game_state);
|
|
|
|
*ret = *state; /* structure copy, except... */
|
|
|
|
ret->tiles = snewn(state->n, int);
|
|
memcpy(ret->tiles, state->tiles, state->n * sizeof(int));
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void free_game(game_state *state)
|
|
{
|
|
sfree(state->tiles);
|
|
sfree(state);
|
|
}
|
|
|
|
static char *solve_game(game_state *state, game_state *currstate,
|
|
char *aux, char **error)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static char *game_text_format(game_state *state)
|
|
{
|
|
char *ret, *p;
|
|
int x, y, maxlen;
|
|
|
|
maxlen = state->params.h * (state->params.w + 1);
|
|
ret = snewn(maxlen+1, char);
|
|
p = ret;
|
|
|
|
for (y = 0; y < state->params.h; y++) {
|
|
for (x = 0; x < state->params.w; x++) {
|
|
int t = TILE(state,x,y);
|
|
if (t <= 0) *p++ = ' ';
|
|
else if (t < 10) *p++ = '0'+t;
|
|
else *p++ = 'a'+(t-10);
|
|
}
|
|
*p++ = '\n';
|
|
}
|
|
assert(p - ret == maxlen);
|
|
*p = '\0';
|
|
return ret;
|
|
}
|
|
|
|
struct game_ui {
|
|
struct game_params params;
|
|
int *tiles; /* selected-ness only */
|
|
int nselected;
|
|
int xsel, ysel, displaysel;
|
|
};
|
|
|
|
static game_ui *new_ui(game_state *state)
|
|
{
|
|
game_ui *ui = snew(game_ui);
|
|
|
|
ui->params = state->params; /* structure copy */
|
|
ui->tiles = snewn(state->n, int);
|
|
memset(ui->tiles, 0, state->n*sizeof(int));
|
|
ui->nselected = 0;
|
|
|
|
ui->xsel = ui->ysel = ui->displaysel = 0;
|
|
|
|
return ui;
|
|
}
|
|
|
|
static void free_ui(game_ui *ui)
|
|
{
|
|
sfree(ui->tiles);
|
|
sfree(ui);
|
|
}
|
|
|
|
static char *encode_ui(game_ui *ui)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static void decode_ui(game_ui *ui, char *encoding)
|
|
{
|
|
}
|
|
|
|
static void sel_clear(game_ui *ui, game_state *state)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < state->n; i++)
|
|
ui->tiles[i] &= ~TILE_SELECTED;
|
|
ui->nselected = 0;
|
|
}
|
|
|
|
|
|
static void game_changed_state(game_ui *ui, game_state *oldstate,
|
|
game_state *newstate)
|
|
{
|
|
sel_clear(ui, newstate);
|
|
|
|
/*
|
|
* If the game state has just changed into an unplayable one
|
|
* (either completed or impossible), we vanish the keyboard-
|
|
* control cursor.
|
|
*/
|
|
if (newstate->complete || newstate->impossible)
|
|
ui->displaysel = 0;
|
|
}
|
|
|
|
static char *sel_movedesc(game_ui *ui, game_state *state)
|
|
{
|
|
int i;
|
|
char *ret, *sep, buf[80];
|
|
int retlen, retsize;
|
|
|
|
retsize = 256;
|
|
ret = snewn(retsize, char);
|
|
retlen = 0;
|
|
ret[retlen++] = 'M';
|
|
sep = "";
|
|
|
|
for (i = 0; i < state->n; i++) {
|
|
if (ui->tiles[i] & TILE_SELECTED) {
|
|
sprintf(buf, "%s%d", sep, i);
|
|
sep = ",";
|
|
if (retlen + strlen(buf) >= retsize) {
|
|
retsize = retlen + strlen(buf) + 256;
|
|
ret = sresize(ret, retsize, char);
|
|
}
|
|
strcpy(ret + retlen, buf);
|
|
retlen += strlen(buf);
|
|
|
|
ui->tiles[i] &= ~TILE_SELECTED;
|
|
}
|
|
}
|
|
ui->nselected = 0;
|
|
|
|
assert(retlen < retsize);
|
|
ret[retlen++] = '\0';
|
|
return sresize(ret, retlen, char);
|
|
}
|
|
|
|
static void sel_expand(game_ui *ui, game_state *state, int tx, int ty)
|
|
{
|
|
int ns = 1, nadded, x, y, c;
|
|
|
|
TILE(ui,tx,ty) |= TILE_SELECTED;
|
|
do {
|
|
nadded = 0;
|
|
|
|
for (x = 0; x < state->params.w; x++) {
|
|
for (y = 0; y < state->params.h; y++) {
|
|
if (x == tx && y == ty) continue;
|
|
if (ISSEL(ui,x,y)) continue;
|
|
|
|
c = COL(state,x,y);
|
|
if ((x > 0) &&
|
|
ISSEL(ui,x-1,y) && COL(state,x-1,y) == c) {
|
|
TILE(ui,x,y) |= TILE_SELECTED;
|
|
nadded++;
|
|
continue;
|
|
}
|
|
|
|
if ((x+1 < state->params.w) &&
|
|
ISSEL(ui,x+1,y) && COL(state,x+1,y) == c) {
|
|
TILE(ui,x,y) |= TILE_SELECTED;
|
|
nadded++;
|
|
continue;
|
|
}
|
|
|
|
if ((y > 0) &&
|
|
ISSEL(ui,x,y-1) && COL(state,x,y-1) == c) {
|
|
TILE(ui,x,y) |= TILE_SELECTED;
|
|
nadded++;
|
|
continue;
|
|
}
|
|
|
|
if ((y+1 < state->params.h) &&
|
|
ISSEL(ui,x,y+1) && COL(state,x,y+1) == c) {
|
|
TILE(ui,x,y) |= TILE_SELECTED;
|
|
nadded++;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
ns += nadded;
|
|
} while (nadded > 0);
|
|
|
|
if (ns > 1) {
|
|
ui->nselected = ns;
|
|
} else {
|
|
sel_clear(ui, state);
|
|
}
|
|
}
|
|
|
|
static int sg_emptycol(game_state *ret, int x)
|
|
{
|
|
int y;
|
|
for (y = 0; y < ret->params.h; y++) {
|
|
if (COL(ret,x,y)) return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
static void sg_snuggle(game_state *ret)
|
|
{
|
|
int x,y, ndone;
|
|
|
|
/* make all unsupported tiles fall down. */
|
|
do {
|
|
ndone = 0;
|
|
for (x = 0; x < ret->params.w; x++) {
|
|
for (y = ret->params.h-1; y > 0; y--) {
|
|
if (COL(ret,x,y) != 0) continue;
|
|
if (COL(ret,x,y-1) != 0) {
|
|
SWAPTILE(ret,x,y,x,y-1);
|
|
ndone++;
|
|
}
|
|
}
|
|
}
|
|
} while (ndone);
|
|
|
|
/* shuffle all columns as far left as they can go. */
|
|
do {
|
|
ndone = 0;
|
|
for (x = 0; x < ret->params.w-1; x++) {
|
|
if (sg_emptycol(ret,x) && !sg_emptycol(ret,x+1)) {
|
|
ndone++;
|
|
for (y = 0; y < ret->params.h; y++) {
|
|
SWAPTILE(ret,x,y,x+1,y);
|
|
}
|
|
}
|
|
}
|
|
} while (ndone);
|
|
}
|
|
|
|
static void sg_check(game_state *ret)
|
|
{
|
|
int x,y, complete = 1, impossible = 1;
|
|
|
|
for (x = 0; x < ret->params.w; x++) {
|
|
for (y = 0; y < ret->params.h; y++) {
|
|
if (COL(ret,x,y) == 0)
|
|
continue;
|
|
complete = 0;
|
|
if (x+1 < ret->params.w) {
|
|
if (COL(ret,x,y) == COL(ret,x+1,y))
|
|
impossible = 0;
|
|
}
|
|
if (y+1 < ret->params.h) {
|
|
if (COL(ret,x,y) == COL(ret,x,y+1))
|
|
impossible = 0;
|
|
}
|
|
}
|
|
}
|
|
ret->complete = complete;
|
|
ret->impossible = impossible;
|
|
}
|
|
|
|
struct game_drawstate {
|
|
int started, bgcolour;
|
|
int tileinner, tilegap;
|
|
int *tiles; /* contains colour and SELECTED. */
|
|
};
|
|
|
|
static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
|
|
int x, int y, int button)
|
|
{
|
|
int tx, ty;
|
|
char *ret = "";
|
|
|
|
ui->displaysel = 0;
|
|
|
|
if (button == RIGHT_BUTTON || button == LEFT_BUTTON) {
|
|
tx = FROMCOORD(x); ty= FROMCOORD(y);
|
|
} else if (button == CURSOR_UP || button == CURSOR_DOWN ||
|
|
button == CURSOR_LEFT || button == CURSOR_RIGHT) {
|
|
int dx = 0, dy = 0;
|
|
ui->displaysel = 1;
|
|
dx = (button == CURSOR_LEFT) ? -1 : ((button == CURSOR_RIGHT) ? +1 : 0);
|
|
dy = (button == CURSOR_DOWN) ? +1 : ((button == CURSOR_UP) ? -1 : 0);
|
|
ui->xsel = (ui->xsel + state->params.w + dx) % state->params.w;
|
|
ui->ysel = (ui->ysel + state->params.h + dy) % state->params.h;
|
|
return ret;
|
|
} else if (button == CURSOR_SELECT || button == ' ' || button == '\r' ||
|
|
button == '\n') {
|
|
ui->displaysel = 1;
|
|
tx = ui->xsel;
|
|
ty = ui->ysel;
|
|
} else
|
|
return NULL;
|
|
|
|
if (tx < 0 || tx >= state->params.w || ty < 0 || ty >= state->params.h)
|
|
return NULL;
|
|
if (COL(state, tx, ty) == 0) return NULL;
|
|
|
|
if (ISSEL(ui,tx,ty)) {
|
|
if (button == RIGHT_BUTTON)
|
|
sel_clear(ui, state);
|
|
else
|
|
ret = sel_movedesc(ui, state);
|
|
} else {
|
|
sel_clear(ui, state); /* might be no-op */
|
|
sel_expand(ui, state, tx, ty);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static game_state *execute_move(game_state *from, char *move)
|
|
{
|
|
int i, n;
|
|
game_state *ret;
|
|
|
|
if (move[0] == 'M') {
|
|
ret = dup_game(from);
|
|
|
|
n = 0;
|
|
move++;
|
|
|
|
while (*move) {
|
|
i = atoi(move);
|
|
if (i < 0 || i >= ret->n) {
|
|
free_game(ret);
|
|
return NULL;
|
|
}
|
|
n++;
|
|
ret->tiles[i] = 0;
|
|
|
|
while (*move && isdigit((unsigned char)*move)) move++;
|
|
if (*move == ',') move++;
|
|
}
|
|
|
|
ret->score += npoints(&ret->params, n);
|
|
|
|
sg_snuggle(ret); /* shifts blanks down and to the left */
|
|
sg_check(ret); /* checks for completeness or impossibility */
|
|
|
|
return ret;
|
|
} else
|
|
return NULL; /* couldn't parse move string */
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* Drawing routines.
|
|
*/
|
|
|
|
static void game_set_size(drawing *dr, game_drawstate *ds,
|
|
game_params *params, int tilesize)
|
|
{
|
|
ds->tilegap = 2;
|
|
ds->tileinner = tilesize - ds->tilegap;
|
|
}
|
|
|
|
static void game_compute_size(game_params *params, int tilesize,
|
|
int *x, int *y)
|
|
{
|
|
/* Ick: fake up tile size variables for macro expansion purposes */
|
|
game_drawstate ads, *ds = &ads;
|
|
game_set_size(NULL, ds, params, tilesize);
|
|
|
|
*x = TILE_SIZE * params->w + 2 * BORDER - TILE_GAP;
|
|
*y = TILE_SIZE * params->h + 2 * BORDER - TILE_GAP;
|
|
}
|
|
|
|
static float *game_colours(frontend *fe, game_state *state, int *ncolours)
|
|
{
|
|
float *ret = snewn(3 * NCOLOURS, float);
|
|
|
|
frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
|
|
|
|
ret[COL_1 * 3 + 0] = 0.0F;
|
|
ret[COL_1 * 3 + 1] = 0.0F;
|
|
ret[COL_1 * 3 + 2] = 1.0F;
|
|
|
|
ret[COL_2 * 3 + 0] = 0.0F;
|
|
ret[COL_2 * 3 + 1] = 0.5F;
|
|
ret[COL_2 * 3 + 2] = 0.0F;
|
|
|
|
ret[COL_3 * 3 + 0] = 1.0F;
|
|
ret[COL_3 * 3 + 1] = 0.0F;
|
|
ret[COL_3 * 3 + 2] = 0.0F;
|
|
|
|
ret[COL_4 * 3 + 0] = 1.0F;
|
|
ret[COL_4 * 3 + 1] = 1.0F;
|
|
ret[COL_4 * 3 + 2] = 0.0F;
|
|
|
|
ret[COL_5 * 3 + 0] = 1.0F;
|
|
ret[COL_5 * 3 + 1] = 0.0F;
|
|
ret[COL_5 * 3 + 2] = 1.0F;
|
|
|
|
ret[COL_6 * 3 + 0] = 0.0F;
|
|
ret[COL_6 * 3 + 1] = 1.0F;
|
|
ret[COL_6 * 3 + 2] = 1.0F;
|
|
|
|
ret[COL_7 * 3 + 0] = 0.5F;
|
|
ret[COL_7 * 3 + 1] = 0.5F;
|
|
ret[COL_7 * 3 + 2] = 1.0F;
|
|
|
|
ret[COL_8 * 3 + 0] = 0.5F;
|
|
ret[COL_8 * 3 + 1] = 1.0F;
|
|
ret[COL_8 * 3 + 2] = 0.5F;
|
|
|
|
ret[COL_9 * 3 + 0] = 1.0F;
|
|
ret[COL_9 * 3 + 1] = 0.5F;
|
|
ret[COL_9 * 3 + 2] = 0.5F;
|
|
|
|
ret[COL_IMPOSSIBLE * 3 + 0] = 0.0F;
|
|
ret[COL_IMPOSSIBLE * 3 + 1] = 0.0F;
|
|
ret[COL_IMPOSSIBLE * 3 + 2] = 0.0F;
|
|
|
|
ret[COL_SEL * 3 + 0] = 1.0F;
|
|
ret[COL_SEL * 3 + 1] = 1.0F;
|
|
ret[COL_SEL * 3 + 2] = 1.0F;
|
|
|
|
ret[COL_HIGHLIGHT * 3 + 0] = 1.0F;
|
|
ret[COL_HIGHLIGHT * 3 + 1] = 1.0F;
|
|
ret[COL_HIGHLIGHT * 3 + 2] = 1.0F;
|
|
|
|
ret[COL_LOWLIGHT * 3 + 0] = ret[COL_BACKGROUND * 3 + 0] * 2.0 / 3.0;
|
|
ret[COL_LOWLIGHT * 3 + 1] = ret[COL_BACKGROUND * 3 + 1] * 2.0 / 3.0;
|
|
ret[COL_LOWLIGHT * 3 + 2] = ret[COL_BACKGROUND * 3 + 2] * 2.0 / 3.0;
|
|
|
|
*ncolours = NCOLOURS;
|
|
return ret;
|
|
}
|
|
|
|
static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
|
|
{
|
|
struct game_drawstate *ds = snew(struct game_drawstate);
|
|
int i;
|
|
|
|
ds->started = 0;
|
|
ds->tileinner = ds->tilegap = 0; /* not decided yet */
|
|
ds->tiles = snewn(state->n, int);
|
|
ds->bgcolour = -1;
|
|
for (i = 0; i < state->n; i++)
|
|
ds->tiles[i] = -1;
|
|
|
|
return ds;
|
|
}
|
|
|
|
static void game_free_drawstate(drawing *dr, game_drawstate *ds)
|
|
{
|
|
sfree(ds->tiles);
|
|
sfree(ds);
|
|
}
|
|
|
|
/* Drawing routing for the tile at (x,y) is responsible for drawing
|
|
* itself and the gaps to its right and below. If we're the same colour
|
|
* as the tile to our right, then we fill in the gap; ditto below, and if
|
|
* both then we fill the teeny tiny square in the corner as well.
|
|
*/
|
|
|
|
static void tile_redraw(drawing *dr, game_drawstate *ds,
|
|
int x, int y, int dright, int dbelow,
|
|
int tile, int bgcolour)
|
|
{
|
|
int outer = bgcolour, inner = outer, col = tile & TILE_COLMASK;
|
|
|
|
if (col) {
|
|
if (tile & TILE_IMPOSSIBLE) {
|
|
outer = col;
|
|
inner = COL_IMPOSSIBLE;
|
|
} else if (tile & TILE_SELECTED) {
|
|
outer = COL_SEL;
|
|
inner = col;
|
|
} else {
|
|
outer = inner = col;
|
|
}
|
|
}
|
|
draw_rect(dr, COORD(x), COORD(y), TILE_INNER, TILE_INNER, outer);
|
|
draw_rect(dr, COORD(x)+TILE_INNER/4, COORD(y)+TILE_INNER/4,
|
|
TILE_INNER/2, TILE_INNER/2, inner);
|
|
|
|
if (dright)
|
|
draw_rect(dr, COORD(x)+TILE_INNER, COORD(y), TILE_GAP, TILE_INNER,
|
|
(tile & TILE_JOINRIGHT) ? outer : bgcolour);
|
|
if (dbelow)
|
|
draw_rect(dr, COORD(x), COORD(y)+TILE_INNER, TILE_INNER, TILE_GAP,
|
|
(tile & TILE_JOINDOWN) ? outer : bgcolour);
|
|
if (dright && dbelow)
|
|
draw_rect(dr, COORD(x)+TILE_INNER, COORD(y)+TILE_INNER, TILE_GAP, TILE_GAP,
|
|
(tile & TILE_JOINDIAG) ? outer : bgcolour);
|
|
|
|
if (tile & TILE_HASSEL) {
|
|
int sx = COORD(x)+2, sy = COORD(y)+2, ssz = TILE_INNER-5;
|
|
int scol = (outer == COL_SEL) ? COL_LOWLIGHT : COL_HIGHLIGHT;
|
|
draw_line(dr, sx, sy, sx+ssz, sy, scol);
|
|
draw_line(dr, sx+ssz, sy, sx+ssz, sy+ssz, scol);
|
|
draw_line(dr, sx+ssz, sy+ssz, sx, sy+ssz, scol);
|
|
draw_line(dr, sx, sy+ssz, sx, sy, scol);
|
|
}
|
|
|
|
draw_update(dr, COORD(x), COORD(y), TILE_SIZE, TILE_SIZE);
|
|
}
|
|
|
|
static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
|
|
game_state *state, int dir, game_ui *ui,
|
|
float animtime, float flashtime)
|
|
{
|
|
int bgcolour, x, y;
|
|
|
|
/* This was entirely cloned from fifteen.c; it should probably be
|
|
* moved into some generic 'draw-recessed-rectangle' utility fn. */
|
|
if (!ds->started) {
|
|
int coords[10];
|
|
|
|
draw_rect(dr, 0, 0,
|
|
TILE_SIZE * state->params.w + 2 * BORDER,
|
|
TILE_SIZE * state->params.h + 2 * BORDER, COL_BACKGROUND);
|
|
draw_update(dr, 0, 0,
|
|
TILE_SIZE * state->params.w + 2 * BORDER,
|
|
TILE_SIZE * state->params.h + 2 * BORDER);
|
|
|
|
/*
|
|
* Recessed area containing the whole puzzle.
|
|
*/
|
|
coords[0] = COORD(state->params.w) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
|
|
coords[1] = COORD(state->params.h) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
|
|
coords[2] = COORD(state->params.w) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
|
|
coords[3] = COORD(0) - HIGHLIGHT_WIDTH;
|
|
coords[4] = coords[2] - TILE_SIZE;
|
|
coords[5] = coords[3] + TILE_SIZE;
|
|
coords[8] = COORD(0) - HIGHLIGHT_WIDTH;
|
|
coords[9] = COORD(state->params.h) + HIGHLIGHT_WIDTH - 1 - TILE_GAP;
|
|
coords[6] = coords[8] + TILE_SIZE;
|
|
coords[7] = coords[9] - TILE_SIZE;
|
|
draw_polygon(dr, coords, 5, COL_HIGHLIGHT, COL_HIGHLIGHT);
|
|
|
|
coords[1] = COORD(0) - HIGHLIGHT_WIDTH;
|
|
coords[0] = COORD(0) - HIGHLIGHT_WIDTH;
|
|
draw_polygon(dr, coords, 5, COL_LOWLIGHT, COL_LOWLIGHT);
|
|
|
|
ds->started = 1;
|
|
}
|
|
|
|
if (flashtime > 0.0) {
|
|
int frame = (int)(flashtime / FLASH_FRAME);
|
|
bgcolour = (frame % 2 ? COL_LOWLIGHT : COL_HIGHLIGHT);
|
|
} else
|
|
bgcolour = COL_BACKGROUND;
|
|
|
|
for (x = 0; x < state->params.w; x++) {
|
|
for (y = 0; y < state->params.h; y++) {
|
|
int i = (state->params.w * y) + x;
|
|
int col = COL(state,x,y), tile = col;
|
|
int dright = (x+1 < state->params.w);
|
|
int dbelow = (y+1 < state->params.h);
|
|
|
|
tile |= ISSEL(ui,x,y);
|
|
if (state->impossible)
|
|
tile |= TILE_IMPOSSIBLE;
|
|
if (dright && COL(state,x+1,y) == col)
|
|
tile |= TILE_JOINRIGHT;
|
|
if (dbelow && COL(state,x,y+1) == col)
|
|
tile |= TILE_JOINDOWN;
|
|
if ((tile & TILE_JOINRIGHT) && (tile & TILE_JOINDOWN) &&
|
|
COL(state,x+1,y+1) == col)
|
|
tile |= TILE_JOINDIAG;
|
|
|
|
if (ui->displaysel && ui->xsel == x && ui->ysel == y)
|
|
tile |= TILE_HASSEL;
|
|
|
|
/* For now we're never expecting oldstate at all (because we have
|
|
* no animation); when we do we might well want to be looking
|
|
* at the tile colours from oldstate, not state. */
|
|
if ((oldstate && COL(oldstate,x,y) != col) ||
|
|
(ds->bgcolour != bgcolour) ||
|
|
(tile != ds->tiles[i])) {
|
|
tile_redraw(dr, ds, x, y, dright, dbelow, tile, bgcolour);
|
|
ds->tiles[i] = tile;
|
|
}
|
|
}
|
|
}
|
|
ds->bgcolour = bgcolour;
|
|
|
|
{
|
|
char status[255], score[80];
|
|
|
|
sprintf(score, "Score: %d", state->score);
|
|
|
|
if (state->complete)
|
|
sprintf(status, "COMPLETE! %s", score);
|
|
else if (state->impossible)
|
|
sprintf(status, "Cannot move! %s", score);
|
|
else if (ui->nselected)
|
|
sprintf(status, "%s Selected: %d (%d)",
|
|
score, ui->nselected, npoints(&state->params, ui->nselected));
|
|
else
|
|
sprintf(status, "%s", score);
|
|
status_bar(dr, status);
|
|
}
|
|
}
|
|
|
|
static float game_anim_length(game_state *oldstate, 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)
|
|
{
|
|
if ((!oldstate->complete && newstate->complete) ||
|
|
(!oldstate->impossible && newstate->impossible))
|
|
return 2 * FLASH_FRAME;
|
|
else
|
|
return 0.0F;
|
|
}
|
|
|
|
static int game_wants_statusbar(void)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
static int game_timing_state(game_state *state, game_ui *ui)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
static void game_print_size(game_params *params, float *x, float *y)
|
|
{
|
|
}
|
|
|
|
static void game_print(drawing *dr, game_state *state, int tilesize)
|
|
{
|
|
}
|
|
|
|
#ifdef COMBINED
|
|
#define thegame samegame
|
|
#endif
|
|
|
|
const struct game thegame = {
|
|
"Same Game", "games.samegame",
|
|
default_params,
|
|
game_fetch_preset,
|
|
decode_params,
|
|
encode_params,
|
|
free_params,
|
|
dup_params,
|
|
TRUE, game_configure, custom_params,
|
|
validate_params,
|
|
new_game_desc,
|
|
validate_desc,
|
|
new_game,
|
|
dup_game,
|
|
free_game,
|
|
FALSE, solve_game,
|
|
TRUE, game_text_format,
|
|
new_ui,
|
|
free_ui,
|
|
encode_ui,
|
|
decode_ui,
|
|
game_changed_state,
|
|
interpret_move,
|
|
execute_move,
|
|
PREFERRED_TILE_SIZE, game_compute_size, game_set_size,
|
|
game_colours,
|
|
game_new_drawstate,
|
|
game_free_drawstate,
|
|
game_redraw,
|
|
game_anim_length,
|
|
game_flash_length,
|
|
FALSE, FALSE, game_print_size, game_print,
|
|
game_wants_statusbar,
|
|
FALSE, game_timing_state,
|
|
0, /* mouse_priorities */
|
|
};
|