char *lines;
unsigned char *line_errors;
+ int exactly_one_loop;
int solved;
int cheated;
char *clue_satisfied;
};
-static char *validate_desc(game_params *params, char *desc);
+static char *validate_desc(const game_params *params, const char *desc);
static int dot_order(const game_state* state, int i, char line_type);
static int face_order(const game_state* state, int i, char line_type);
static solver_state *solve_game_rec(const solver_state *sstate);
#define check_caches(s)
#endif
-/* ------- List of grid generators ------- */
-#define GRIDLIST(A) \
- A(Squares,GRID_SQUARE,3,3) \
- A(Triangular,GRID_TRIANGULAR,3,3) \
- A(Honeycomb,GRID_HONEYCOMB,3,3) \
- A(Snub-Square,GRID_SNUBSQUARE,3,3) \
- A(Cairo,GRID_CAIRO,3,4) \
- A(Great-Hexagonal,GRID_GREATHEXAGONAL,3,3) \
- A(Octagonal,GRID_OCTAGONAL,3,3) \
- A(Kites,GRID_KITE,3,3) \
- A(Floret,GRID_FLORET,1,2) \
- A(Dodecagonal,GRID_DODECAGONAL,2,2) \
- A(Great-Dodecagonal,GRID_GREATDODECAGONAL,2,2) \
- A(Penrose (kite/dart),GRID_PENROSE_P2,3,3) \
- A(Penrose (rhombs),GRID_PENROSE_P3,3,3)
-
-#define GRID_NAME(title,type,amin,omin) #title,
-#define GRID_CONFIG(title,type,amin,omin) ":" #title
-#define GRID_TYPE(title,type,amin,omin) type,
+/*
+ * Grid type config options available in Loopy.
+ *
+ * Annoyingly, we have to use an enum here which doesn't match up
+ * exactly to the grid-type enum in grid.h. Values in params->types
+ * are given by names such as LOOPY_GRID_SQUARE, which shouldn't be
+ * confused with GRID_SQUARE which is the value you pass to grid_new()
+ * and friends. So beware!
+ *
+ * (This is partly for historical reasons - Loopy's version of the
+ * enum is encoded in game parameter strings, so we keep it for
+ * backwards compatibility. But also, we need to store additional data
+ * here alongside each enum value, such as names for the presets menu,
+ * which isn't stored in grid.h; so we have to have our own list macro
+ * here anyway, and C doesn't make it easy to enforce that that lines
+ * up exactly with grid.h.)
+ *
+ * Do not add values to this list _except_ at the end, or old game ids
+ * will stop working!
+ */
+#define GRIDLIST(A) \
+ A("Squares",SQUARE,3,3) \
+ A("Triangular",TRIANGULAR,3,3) \
+ A("Honeycomb",HONEYCOMB,3,3) \
+ A("Snub-Square",SNUBSQUARE,3,3) \
+ A("Cairo",CAIRO,3,4) \
+ A("Great-Hexagonal",GREATHEXAGONAL,3,3) \
+ A("Octagonal",OCTAGONAL,3,3) \
+ A("Kites",KITE,3,3) \
+ A("Floret",FLORET,1,2) \
+ A("Dodecagonal",DODECAGONAL,2,2) \
+ A("Great-Dodecagonal",GREATDODECAGONAL,2,2) \
+ A("Penrose (kite/dart)",PENROSE_P2,3,3) \
+ A("Penrose (rhombs)",PENROSE_P3,3,3) \
+ A("Great-Great-Dodecagonal",GREATGREATDODECAGONAL,2,2) \
+ /* end of list */
+
+#define GRID_NAME(title,type,amin,omin) title,
+#define GRID_CONFIG(title,type,amin,omin) ":" title
+#define GRID_LOOPYTYPE(title,type,amin,omin) LOOPY_GRID_ ## type,
+#define GRID_GRIDTYPE(title,type,amin,omin) GRID_ ## type,
#define GRID_SIZES(title,type,amin,omin) \
{amin, omin, \
"Width and height for this grid type must both be at least " #amin, \
"At least one of width and height for this grid type must be at least " #omin,},
+enum { GRIDLIST(GRID_LOOPYTYPE) };
static char const *const gridnames[] = { GRIDLIST(GRID_NAME) };
#define GRID_CONFIGS GRIDLIST(GRID_CONFIG)
-static grid_type grid_types[] = { GRIDLIST(GRID_TYPE) };
+static grid_type grid_types[] = { GRIDLIST(GRID_GRIDTYPE) };
#define NUM_GRID_TYPES (sizeof(grid_types) / sizeof(grid_types[0]))
static const struct {
int amin, omin;
/* Generates a (dynamically allocated) new grid, according to the
* type and size requested in params. Does nothing if the grid is already
* generated. */
-static grid *loopy_generate_grid(game_params *params, char *grid_desc)
+static grid *loopy_generate_grid(const game_params *params,
+ const char *grid_desc)
{
return grid_new(grid_types[params->type], params->w, params->h, grid_desc);
}
* General struct manipulation and other straightforward code
*/
-static game_state *dup_game(game_state *state)
+static game_state *dup_game(const game_state *state)
{
game_state *ret = snew(game_state);
ret->line_errors = snewn(state->game_grid->num_edges, unsigned char);
memcpy(ret->line_errors, state->line_errors, state->game_grid->num_edges);
+ ret->exactly_one_loop = state->exactly_one_loop;
ret->grid_type = state->grid_type;
return ret;
}
}
-static solver_state *new_solver_state(game_state *state, int diff) {
+static solver_state *new_solver_state(const game_state *state, int diff) {
int i;
int num_dots = state->game_grid->num_dots;
int num_faces = state->game_grid->num_faces;
return ret;
}
-static game_params *dup_params(game_params *params)
+static game_params *dup_params(const game_params *params)
{
game_params *ret = snew(game_params);
return ret;
}
-static const game_params presets[] = {
+static const game_params loopy_presets_top[] = {
#ifdef SMALL_SCREEN
- { 7, 7, DIFF_EASY, 0 },
- { 7, 7, DIFF_NORMAL, 0 },
- { 7, 7, DIFF_HARD, 0 },
- { 7, 7, DIFF_HARD, 1 },
- { 7, 7, DIFF_HARD, 2 },
- { 5, 5, DIFF_HARD, 3 },
- { 7, 7, DIFF_HARD, 4 },
- { 5, 4, DIFF_HARD, 5 },
- { 5, 5, DIFF_HARD, 6 },
- { 5, 5, DIFF_HARD, 7 },
- { 3, 3, DIFF_HARD, 8 },
- { 3, 3, DIFF_HARD, 9 },
- { 3, 3, DIFF_HARD, 10 },
- { 6, 6, DIFF_HARD, 11 },
- { 6, 6, DIFF_HARD, 12 },
+ { 7, 7, DIFF_EASY, LOOPY_GRID_SQUARE },
+ { 7, 7, DIFF_NORMAL, LOOPY_GRID_SQUARE },
+ { 7, 7, DIFF_HARD, LOOPY_GRID_SQUARE },
+ { 7, 7, DIFF_HARD, LOOPY_GRID_TRIANGULAR },
+ { 5, 5, DIFF_HARD, LOOPY_GRID_SNUBSQUARE },
+ { 7, 7, DIFF_HARD, LOOPY_GRID_CAIRO },
+ { 5, 5, DIFF_HARD, LOOPY_GRID_KITE },
+ { 6, 6, DIFF_HARD, LOOPY_GRID_PENROSE_P2 },
+ { 6, 6, DIFF_HARD, LOOPY_GRID_PENROSE_P3 },
#else
- { 7, 7, DIFF_EASY, 0 },
- { 10, 10, DIFF_EASY, 0 },
- { 7, 7, DIFF_NORMAL, 0 },
- { 10, 10, DIFF_NORMAL, 0 },
- { 7, 7, DIFF_HARD, 0 },
- { 10, 10, DIFF_HARD, 0 },
- { 10, 10, DIFF_HARD, 1 },
- { 12, 10, DIFF_HARD, 2 },
- { 7, 7, DIFF_HARD, 3 },
- { 9, 9, DIFF_HARD, 4 },
- { 5, 4, DIFF_HARD, 5 },
- { 7, 7, DIFF_HARD, 6 },
- { 5, 5, DIFF_HARD, 7 },
- { 5, 5, DIFF_HARD, 8 },
- { 5, 4, DIFF_HARD, 9 },
- { 5, 4, DIFF_HARD, 10 },
- { 10, 10, DIFF_HARD, 11 },
- { 10, 10, DIFF_HARD, 12 }
+ { 7, 7, DIFF_EASY, LOOPY_GRID_SQUARE },
+ { 10, 10, DIFF_EASY, LOOPY_GRID_SQUARE },
+ { 7, 7, DIFF_NORMAL, LOOPY_GRID_SQUARE },
+ { 10, 10, DIFF_NORMAL, LOOPY_GRID_SQUARE },
+ { 7, 7, DIFF_HARD, LOOPY_GRID_SQUARE },
+ { 10, 10, DIFF_HARD, LOOPY_GRID_SQUARE },
+ { 12, 10, DIFF_HARD, LOOPY_GRID_TRIANGULAR },
+ { 7, 7, DIFF_HARD, LOOPY_GRID_SNUBSQUARE },
+ { 9, 9, DIFF_HARD, LOOPY_GRID_CAIRO },
+ { 5, 5, DIFF_HARD, LOOPY_GRID_KITE },
+ { 10, 10, DIFF_HARD, LOOPY_GRID_PENROSE_P2 },
+ { 10, 10, DIFF_HARD, LOOPY_GRID_PENROSE_P3 },
#endif
};
-static int game_fetch_preset(int i, char **name, game_params **params)
+static const game_params loopy_presets_more[] = {
+#ifdef SMALL_SCREEN
+ { 7, 7, DIFF_HARD, LOOPY_GRID_HONEYCOMB },
+ { 5, 4, DIFF_HARD, LOOPY_GRID_GREATHEXAGONAL },
+ { 5, 5, DIFF_HARD, LOOPY_GRID_OCTAGONAL },
+ { 3, 3, DIFF_HARD, LOOPY_GRID_FLORET },
+ { 3, 3, DIFF_HARD, LOOPY_GRID_DODECAGONAL },
+ { 3, 3, DIFF_HARD, LOOPY_GRID_GREATDODECAGONAL },
+ { 3, 2, DIFF_HARD, LOOPY_GRID_GREATGREATDODECAGONAL },
+#else
+ { 10, 10, DIFF_HARD, LOOPY_GRID_HONEYCOMB },
+ { 5, 4, DIFF_HARD, LOOPY_GRID_GREATHEXAGONAL },
+ { 7, 7, DIFF_HARD, LOOPY_GRID_OCTAGONAL },
+ { 5, 5, DIFF_HARD, LOOPY_GRID_FLORET },
+ { 5, 4, DIFF_HARD, LOOPY_GRID_DODECAGONAL },
+ { 5, 4, DIFF_HARD, LOOPY_GRID_GREATDODECAGONAL },
+ { 5, 3, DIFF_HARD, LOOPY_GRID_GREATGREATDODECAGONAL },
+#endif
+};
+
+static void preset_menu_add_preset_with_title(struct preset_menu *menu,
+ const game_params *params)
{
- game_params *tmppar;
char buf[80];
+ game_params *dup_params;
- if (i < 0 || i >= lenof(presets))
- return FALSE;
+ sprintf(buf, "%dx%d %s - %s", params->h, params->w,
+ gridnames[params->type], diffnames[params->diff]);
- tmppar = snew(game_params);
- *tmppar = presets[i];
- *params = tmppar;
- sprintf(buf, "%dx%d %s - %s", tmppar->h, tmppar->w,
- gridnames[tmppar->type], diffnames[tmppar->diff]);
- *name = dupstr(buf);
+ dup_params = snew(game_params);
+ *dup_params = *params;
- return TRUE;
+ preset_menu_add_preset(menu, dupstr(buf), dup_params);
+}
+
+static struct preset_menu *game_preset_menu(void)
+{
+ struct preset_menu *top, *more;
+ int i;
+
+ top = preset_menu_new();
+ for (i = 0; i < lenof(loopy_presets_top); i++)
+ preset_menu_add_preset_with_title(top, &loopy_presets_top[i]);
+
+ more = preset_menu_add_submenu(top, dupstr("More..."));
+ for (i = 0; i < lenof(loopy_presets_more); i++)
+ preset_menu_add_preset_with_title(more, &loopy_presets_more[i]);
+
+ return top;
}
static void free_params(game_params *params)
}
}
-static char *encode_params(game_params *params, int full)
+static char *encode_params(const game_params *params, int full)
{
char str[80];
sprintf(str, "%dx%dt%d", params->w, params->h, params->type);
return dupstr(str);
}
-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->type < 0 || params->type >= NUM_GRID_TYPES)
return "Illegal grid type";
/* Splits up a (optional) grid_desc from the game desc. Returns the
* grid_desc (which needs freeing) and updates the desc pointer to
* start of real desc, or returns NULL if no desc. */
-static char *extract_grid_desc(char **desc)
+static char *extract_grid_desc(const char **desc)
{
char *sep = strchr(*desc, GRID_DESC_SEP), *gd;
int gd_len;
/* We require that the params pass the test in validate_params and that the
* description fills the entire game area */
-static char *validate_desc(game_params *params, char *desc)
+static char *validate_desc(const game_params *params, const char *desc)
{
int count = 0;
grid *g;
return ret;
}
-static game_ui *new_ui(game_state *state)
+static game_ui *new_ui(const game_state *state)
{
return NULL;
}
{
}
-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)
{
}
-static void game_compute_size(game_params *params, int tilesize,
+static void game_compute_size(const game_params *params, int tilesize,
int *x, int *y)
{
int grid_width, grid_height, rendered_width, rendered_height;
}
static void game_set_size(drawing *dr, game_drawstate *ds,
- game_params *params, int tilesize)
+ const game_params *params, int tilesize)
{
ds->tilesize = tilesize;
}
static float *game_colours(frontend *fe, int *ncolours)
{
- float *ret = snewn(4 * NCOLOURS, float);
+ float *ret = snewn(3 * NCOLOURS, float);
frontend_default_colour(fe, &ret[COL_BACKGROUND * 3]);
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)
{
struct game_drawstate *ds = snew(struct game_drawstate);
int num_faces = state->game_grid->num_faces;
sfree(ds);
}
-static int game_timing_state(game_state *state, game_ui *ui)
+static int game_timing_state(const game_state *state, game_ui *ui)
{
return TRUE;
}
-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 int game_can_format_as_text_now(game_params *params)
+static int game_can_format_as_text_now(const game_params *params)
{
if (params->type != 0)
return FALSE;
return TRUE;
}
-static char *game_text_format(game_state *state)
+static char *game_text_format(const game_state *state)
{
int w, h, W, H;
int x, y, i;
}
-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)
{
/* solution and description both use run-length encoding in obvious ways */
state->clues = snewn(g->num_faces, signed char);
state->lines = snewn(g->num_edges, char);
state->line_errors = snewn(g->num_edges, unsigned char);
+ state->exactly_one_loop = FALSE;
state->grid_type = params->type;
return retval;
}
-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 i;
game_state *state = snew(game_state);
state->clues = snewn(num_faces, signed char);
state->lines = snewn(num_edges, char);
state->line_errors = snewn(num_edges, unsigned char);
+ state->exactly_one_loop = FALSE;
state->solved = state->cheated = FALSE;
static int check_completion(game_state *state)
{
grid *g = state->game_grid;
- int *dsf;
- int num_faces = g->num_faces;
- int i;
- int infinite_area, finite_area;
- int loops_found = 0;
- int found_edge_not_in_loop = FALSE;
+ int i, ret;
+ int *dsf, *component_state;
+ int nsilly, nloop, npath, largest_comp, largest_size, total_pathsize;
+ enum { COMP_NONE, COMP_LOOP, COMP_PATH, COMP_SILLY, COMP_EMPTY };
memset(state->line_errors, 0, g->num_edges);
- /* LL implementation of SGT's idea:
- * A loop will partition the grid into an inside and an outside.
- * If there is more than one loop, the grid will be partitioned into
- * even more distinct regions. We can therefore track equivalence of
- * faces, by saying that two faces are equivalent when there is a non-YES
- * edge between them.
- * We could keep track of the number of connected components, by counting
- * the number of dsf-merges that aren't no-ops.
- * But we're only interested in 3 separate cases:
- * no loops, one loop, more than one loop.
+ /*
+ * Find loops in the grid, and determine whether the puzzle is
+ * solved.
+ *
+ * Loopy is a bit more complicated than most puzzles that care
+ * about loop detection. In most of them, loops are simply
+ * _forbidden_; so the obviously right way to do
+ * error-highlighting during play is to light up a graph edge red
+ * iff it is part of a loop, which is exactly what the centralised
+ * findloop.c makes easy.
+ *
+ * But Loopy is unusual in that you're _supposed_ to be making a
+ * loop - and yet _some_ loops are not the right loop. So we need
+ * to be more discriminating, by identifying loops one by one and
+ * then thinking about which ones to highlight, and so findloop.c
+ * isn't quite the right tool for the job in this case.
+ *
+ * Worse still, consider situations in which the grid contains a
+ * loop and also some non-loop edges: there are some cases like
+ * this in which the user's intuitive expectation would be to
+ * highlight the loop (if you're only about half way through the
+ * puzzle and have accidentally made a little loop in some corner
+ * of the grid), and others in which they'd be more likely to
+ * expect you to highlight the non-loop edges (if you've just
+ * closed off a whole loop that you thought was the entire
+ * solution, but forgot some disconnected edges in a corner
+ * somewhere). So while it's easy enough to check whether the
+ * solution is _right_, highlighting the wrong parts is a tricky
+ * problem for this puzzle!
*
- * No loops: all faces are equivalent to the infinite face.
- * One loop: only two equivalence classes - finite and infinite.
- * >= 2 loops: there are 2 distinct finite regions.
+ * I'd quite like, in some situations, to identify the largest
+ * loop among the player's YES edges, and then light up everything
+ * other than that. But finding the longest cycle in a graph is an
+ * NP-complete problem (because, in particular, it must return a
+ * Hamilton cycle if one exists).
*
- * So we simply make two passes through all the edges.
- * In the first pass, we dsf-merge the two faces bordering each non-YES
- * edge.
- * In the second pass, we look for YES-edges bordering:
- * a) two non-equivalent faces.
- * b) two non-equivalent faces, and one of them is part of a different
- * finite area from the first finite area we've seen.
+ * However, I think we can make the problem tractable by
+ * exercising the Puzzles principle that it isn't absolutely
+ * necessary to highlight _all_ errors: the key point is that by
+ * the time the user has filled in the whole grid, they should
+ * either have seen a completion flash, or have _some_ error
+ * highlight showing them why the solution isn't right. So in
+ * principle it would be *just about* good enough to highlight
+ * just one error in the whole grid, if there was really no better
+ * way. But we'd like to highlight as many errors as possible.
*
- * An occurrence of a) means there is at least one loop.
- * An occurrence of b) means there is more than one loop.
- * Edges satisfying a) are marked as errors.
+ * In this case, I think the simple approach is to make use of the
+ * fact that no vertex may have degree > 2, and that's really
+ * simple to detect. So the plan goes like this:
*
- * While we're at it, we set a flag if we find a YES edge that is not
- * part of a loop.
- * This information will help decide, if there's a single loop, whether it
- * is a candidate for being a solution (that is, all YES edges are part of
- * this loop).
+ * - Form the dsf of connected components of the graph vertices.
*
- * If there is a candidate loop, we then go through all clues and check
- * they are all satisfied. If so, we have found a solution and we can
- * unmark all line_errors.
+ * - Highlight an error at any vertex with degree > 2. (It so
+ * happens that we do this by lighting up all the edges
+ * incident to that vertex, but that's an output detail.)
+ *
+ * - Any component that contains such a vertex is now excluded
+ * from further consideration, because it already has a
+ * highlight.
+ *
+ * - The remaining components have no vertex with degree > 2, and
+ * hence they all consist of either a simple loop, or a simple
+ * path with two endpoints.
+ *
+ * - For these purposes, group together all the paths and imagine
+ * them to be a single component (because in most normal
+ * situations the player will gradually build up the solution
+ * _not_ all in one connected segment, but as lots of separate
+ * little path pieces that gradually connect to each other).
+ *
+ * - After doing that, if there is exactly one (sensible)
+ * component - be it a collection of paths or a loop - then
+ * highlight no further edge errors. (The former case is normal
+ * during play, and the latter is a potentially solved puzzle.)
+ *
+ * - Otherwise, find the largest of the sensible components,
+ * leave that one unhighlighted, and light the rest up in red.
*/
-
- /* Infinite face is at the end - its index is num_faces.
- * This macro is just to make this obvious! */
- #define INF_FACE num_faces
- dsf = snewn(num_faces + 1, int);
- dsf_init(dsf, num_faces + 1);
-
- /* First pass */
- for (i = 0; i < g->num_edges; i++) {
- grid_edge *e = g->edges + i;
- int f1 = e->face1 ? e->face1 - g->faces : INF_FACE;
- int f2 = e->face2 ? e->face2 - g->faces : INF_FACE;
- if (state->lines[i] != LINE_YES)
- dsf_merge(dsf, f1, f2);
- }
-
- /* Second pass */
- infinite_area = dsf_canonify(dsf, INF_FACE);
- finite_area = -1;
- for (i = 0; i < g->num_edges; i++) {
- grid_edge *e = g->edges + i;
- int f1 = e->face1 ? e->face1 - g->faces : INF_FACE;
- int can1 = dsf_canonify(dsf, f1);
- int f2 = e->face2 ? e->face2 - g->faces : INF_FACE;
- int can2 = dsf_canonify(dsf, f2);
- if (state->lines[i] != LINE_YES) continue;
-
- if (can1 == can2) {
- /* Faces are equivalent, so this edge not part of a loop */
- found_edge_not_in_loop = TRUE;
- continue;
- }
- state->line_errors[i] = TRUE;
- if (loops_found == 0) loops_found = 1;
- /* Don't bother with further checks if we've already found 2 loops */
- if (loops_found == 2) continue;
+ dsf = snew_dsf(g->num_dots);
- if (finite_area == -1) {
- /* Found our first finite area */
- if (can1 != infinite_area)
- finite_area = can1;
- else
- finite_area = can2;
- }
-
- /* Have we found a second area? */
- if (finite_area != -1) {
- if (can1 != infinite_area && can1 != finite_area) {
- loops_found = 2;
- continue;
- }
- if (can2 != infinite_area && can2 != finite_area) {
- loops_found = 2;
- }
+ /* Build the dsf. */
+ for (i = 0; i < g->num_edges; i++) {
+ if (state->lines[i] == LINE_YES) {
+ grid_edge *e = g->edges + i;
+ int d1 = e->dot1 - g->dots, d2 = e->dot2 - g->dots;
+ dsf_merge(dsf, d1, d2);
}
}
-/*
- printf("loops_found = %d\n", loops_found);
- printf("found_edge_not_in_loop = %s\n",
- found_edge_not_in_loop ? "TRUE" : "FALSE");
-*/
-
- sfree(dsf); /* No longer need the dsf */
-
- /* Have we found a candidate loop? */
- if (loops_found == 1 && !found_edge_not_in_loop) {
- /* Yes, so check all clues are satisfied */
- int found_clue_violation = FALSE;
- for (i = 0; i < num_faces; i++) {
- int c = state->clues[i];
- if (c >= 0) {
- if (face_order(state, i, LINE_YES) != c) {
- found_clue_violation = TRUE;
- break;
- }
- }
- }
-
- if (!found_clue_violation) {
- /* The loop is good */
- memset(state->line_errors, 0, g->num_edges);
- return TRUE; /* No need to bother checking for dot violations */
- }
+ /* Initialise a state variable for each connected component. */
+ component_state = snewn(g->num_dots, int);
+ for (i = 0; i < g->num_dots; i++) {
+ if (dsf_canonify(dsf, i) == i)
+ component_state[i] = COMP_LOOP;
+ else
+ component_state[i] = COMP_NONE;
}
- /* Check for dot violations */
+ /* Check for dots with degree > 3. Here we also spot dots of
+ * degree 1 in which the user has marked all the non-edges as
+ * LINE_NO, because those are also clear vertex-level errors, so
+ * we give them the same treatment of excluding their connected
+ * component from the subsequent loop analysis. */
for (i = 0; i < g->num_dots; i++) {
+ int comp = dsf_canonify(dsf, i);
int yes = dot_order(state, i, LINE_YES);
int unknown = dot_order(state, i, LINE_UNKNOWN);
if ((yes == 1 && unknown == 0) || (yes >= 3)) {
if (state->lines[e] == LINE_YES)
state->line_errors[e] = TRUE;
}
+ /* And mark this component as not worthy of further
+ * consideration. */
+ component_state[comp] = COMP_SILLY;
+
+ } else if (yes == 0) {
+ /* A completely isolated dot must also be excluded it from
+ * the subsequent loop highlighting pass, but we tag it
+ * with a different enum value to avoid it counting
+ * towards the components that inhibit returning a win
+ * status. */
+ component_state[comp] = COMP_EMPTY;
+ } else if (yes == 1) {
+ /* A dot with degree 1 that didn't fall into the 'clearly
+ * erroneous' case above indicates that this connected
+ * component will be a path rather than a loop - unless
+ * something worse elsewhere in the component has
+ * classified it as silly. */
+ if (component_state[comp] != COMP_SILLY)
+ component_state[comp] = COMP_PATH;
}
}
- return FALSE;
+
+ /* Count up the components. Also, find the largest sensible
+ * component. (Tie-breaking condition is derived from the order of
+ * vertices in the grid data structure, which is fairly arbitrary
+ * but at least stays stable throughout the game.) */
+ nsilly = nloop = npath = 0;
+ total_pathsize = 0;
+ largest_comp = largest_size = -1;
+ for (i = 0; i < g->num_dots; i++) {
+ if (component_state[i] == COMP_SILLY) {
+ nsilly++;
+ } else if (component_state[i] == COMP_PATH) {
+ total_pathsize += dsf_size(dsf, i);
+ npath = 1;
+ } else if (component_state[i] == COMP_LOOP) {
+ int this_size;
+
+ nloop++;
+
+ if ((this_size = dsf_size(dsf, i)) > largest_size) {
+ largest_comp = i;
+ largest_size = this_size;
+ }
+ }
+ }
+ if (largest_size < total_pathsize) {
+ largest_comp = -1; /* means the paths */
+ largest_size = total_pathsize;
+ }
+
+ if (nloop > 0 && nloop + npath > 1) {
+ /*
+ * If there are at least two sensible components including at
+ * least one loop, highlight all edges in every sensible
+ * component that is not the largest one.
+ */
+ for (i = 0; i < g->num_edges; i++) {
+ if (state->lines[i] == LINE_YES) {
+ grid_edge *e = g->edges + i;
+ int d1 = e->dot1 - g->dots; /* either endpoint is good enough */
+ int comp = dsf_canonify(dsf, d1);
+ if ((component_state[comp] == COMP_PATH &&
+ -1 != largest_comp) ||
+ (component_state[comp] == COMP_LOOP &&
+ comp != largest_comp))
+ state->line_errors[i] = TRUE;
+ }
+ }
+ }
+
+ if (nloop == 1 && npath == 0 && nsilly == 0) {
+ /*
+ * If there is exactly one component and it is a loop, then
+ * the puzzle is potentially complete, so check the clues.
+ */
+ ret = TRUE;
+
+ for (i = 0; i < g->num_faces; i++) {
+ int c = state->clues[i];
+ if (c >= 0 && face_order(state, i, LINE_YES) != c) {
+ ret = FALSE;
+ break;
+ }
+ }
+
+ /*
+ * Also, whether or not the puzzle is actually complete, set
+ * the flag that says this game_state has exactly one loop and
+ * nothing else, which will be used to vary the semantics of
+ * clue highlighting at display time.
+ */
+ state->exactly_one_loop = TRUE;
+ } else {
+ ret = FALSE;
+ state->exactly_one_loop = FALSE;
+ }
+
+ sfree(component_state);
+ sfree(dsf);
+
+ return ret;
}
/* ----------------------------------------------------------------------
return sstate;
}
-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)
{
char *soln = NULL;
solver_state *sstate, *new_sstate;
* Drawing and mouse-handling
*/
-static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
+static char *interpret_move(const game_state *state, game_ui *ui,
+ const game_drawstate *ds,
int x, int y, int button)
{
grid *g = state->game_grid;
grid_edge *e;
int i;
- char *ret, buf[80];
+ char *movebuf;
+ int movelen, movesize;
char button_char = ' ';
enum line_state old_state;
return NULL;
}
+ movelen = 0;
+ movesize = 80;
+ movebuf = snewn(movesize, char);
+ movelen = sprintf(movebuf, "%d%c", i, (int)button_char);
+ {
+ static enum { OFF, FIXED, ADAPTIVE, DUNNO } autofollow = DUNNO;
+ if (autofollow == DUNNO) {
+ const char *env = getenv("LOOPY_AUTOFOLLOW");
+ if (env && !strcmp(env, "off"))
+ autofollow = OFF;
+ else if (env && !strcmp(env, "fixed"))
+ autofollow = FIXED;
+ else if (env && !strcmp(env, "adaptive"))
+ autofollow = ADAPTIVE;
+ else
+ autofollow = OFF;
+ }
+
+ if (autofollow != OFF) {
+ int dotid;
+ for (dotid = 0; dotid < 2; dotid++) {
+ grid_dot *dot = (dotid == 0 ? e->dot1 : e->dot2);
+ grid_edge *e_this = e;
+
+ while (1) {
+ int j, n_found;
+ grid_edge *e_next = NULL;
+
+ for (j = n_found = 0; j < dot->order; j++) {
+ grid_edge *e_candidate = dot->edges[j];
+ int i_candidate = e_candidate - g->edges;
+ if (e_candidate != e_this &&
+ (autofollow == FIXED ||
+ state->lines[i] == LINE_NO ||
+ state->lines[i_candidate] != LINE_NO)) {
+ e_next = e_candidate;
+ n_found++;
+ }
+ }
- sprintf(buf, "%d%c", i, (int)button_char);
- ret = dupstr(buf);
+ if (n_found != 1 ||
+ state->lines[e_next - g->edges] != state->lines[i])
+ break;
+
+ if (e_next == e) {
+ /*
+ * Special case: we might have come all the
+ * way round a loop and found our way back to
+ * the same edge we started from. In that
+ * situation, we must terminate not only this
+ * while loop, but the 'for' outside it that
+ * was tracing in both directions from the
+ * starting edge, because if we let it trace
+ * in the second direction then we'll only
+ * find ourself traversing the same loop in
+ * the other order and generate an encoded
+ * move string that mentions the same set of
+ * edges twice.
+ */
+ goto autofollow_done;
+ }
- return ret;
+ dot = (e_next->dot1 != dot ? e_next->dot1 : e_next->dot2);
+ if (movelen > movesize - 40) {
+ movesize = movesize * 5 / 4 + 128;
+ movebuf = sresize(movebuf, movesize, char);
+ }
+ e_this = e_next;
+ movelen += sprintf(movebuf+movelen, "%d%c",
+ (int)(e_this - g->edges), button_char);
+ }
+ }
+ autofollow_done:;
+ }
+ }
+
+ return sresize(movebuf, movelen+1, char);
}
-static game_state *execute_move(game_state *state, char *move)
+static game_state *execute_move(const game_state *state, const char *move)
{
int i;
game_state *newstate = dup_game(state);
}
static void game_redraw_clue(drawing *dr, game_drawstate *ds,
- game_state *state, int i)
+ const game_state *state, int i)
{
grid *g = state->game_grid;
grid_face *f = g->faces + i;
int x, y;
- char c[3];
+ char c[20];
- if (state->clues[i] < 10) {
- c[0] = CLUE2CHAR(state->clues[i]);
- c[1] = '\0';
- } else {
- sprintf(c, "%d", state->clues[i]);
- }
+ sprintf(c, "%d", state->clues[i]);
face_text_pos(ds, g, f, &x, &y);
draw_text(dr, x, y,
#define NPHASES lenof(loopy_line_redraw_phases)
static void game_redraw_line(drawing *dr, game_drawstate *ds,
- game_state *state, int i, int phase)
+ const game_state *state, int i, int phase)
{
grid *g = state->game_grid;
grid_edge *e = g->edges + i;
}
static void game_redraw_dot(drawing *dr, game_drawstate *ds,
- game_state *state, int i)
+ const game_state *state, int i)
{
grid *g = state->game_grid;
grid_dot *d = g->dots + i;
}
static void game_redraw_in_rect(drawing *dr, game_drawstate *ds,
- game_state *state, int x, int y, int w, int h)
+ const game_state *state,
+ int x, int y, int w, int h)
{
grid *g = state->game_grid;
int i, phase;
draw_update(dr, x, y, w, h);
}
-static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
- game_state *state, int dir, game_ui *ui,
+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)
{
#define REDRAW_OBJECTS_LIMIT 16 /* Somewhat arbitrary tradeoff */
* what needs doing, and the second actually does it.
*/
- if (!ds->started)
+ if (!ds->started) {
redraw_everything = TRUE;
- else {
-
- /* First, trundle through the faces. */
- for (i = 0; i < g->num_faces; i++) {
- grid_face *f = g->faces + i;
- int sides = f->order;
- int clue_mistake;
- int clue_satisfied;
- int n = state->clues[i];
- if (n < 0)
- continue;
-
- clue_mistake = (face_order(state, i, LINE_YES) > n ||
- face_order(state, i, LINE_NO ) > (sides-n));
- clue_satisfied = (face_order(state, i, LINE_YES) == n &&
- face_order(state, i, LINE_NO ) == (sides-n));
-
- if (clue_mistake != ds->clue_error[i] ||
- clue_satisfied != ds->clue_satisfied[i]) {
- ds->clue_error[i] = clue_mistake;
- ds->clue_satisfied[i] = clue_satisfied;
- if (nfaces == REDRAW_OBJECTS_LIMIT)
- redraw_everything = TRUE;
- else
- faces[nfaces++] = i;
- }
- }
+ /*
+ * But we must still go through the upcoming loops, so that we
+ * set up stuff in ds correctly for the initial redraw.
+ */
+ }
- /* Work out what the flash state needs to be. */
- if (flashtime > 0 &&
- (flashtime <= FLASH_TIME/3 ||
- flashtime >= FLASH_TIME*2/3)) {
- flash_changed = !ds->flashing;
- ds->flashing = TRUE;
- } else {
- flash_changed = ds->flashing;
- ds->flashing = FALSE;
- }
+ /* First, trundle through the faces. */
+ for (i = 0; i < g->num_faces; i++) {
+ grid_face *f = g->faces + i;
+ int sides = f->order;
+ int yes_order, no_order;
+ int clue_mistake;
+ int clue_satisfied;
+ int n = state->clues[i];
+ if (n < 0)
+ continue;
- /* Now, trundle through the edges. */
- for (i = 0; i < g->num_edges; i++) {
- char new_ds =
- state->line_errors[i] ? DS_LINE_ERROR : state->lines[i];
- if (new_ds != ds->lines[i] ||
- (flash_changed && state->lines[i] == LINE_YES)) {
- ds->lines[i] = new_ds;
- if (nedges == REDRAW_OBJECTS_LIMIT)
- redraw_everything = TRUE;
- else
- edges[nedges++] = i;
- }
- }
+ yes_order = face_order(state, i, LINE_YES);
+ if (state->exactly_one_loop) {
+ /*
+ * Special case: if the set of LINE_YES edges in the grid
+ * consists of exactly one loop and nothing else, then we
+ * switch to treating LINE_UNKNOWN the same as LINE_NO for
+ * purposes of clue checking.
+ *
+ * This is because some people like to play Loopy without
+ * using the right-click, i.e. never setting anything to
+ * LINE_NO. Without this special case, if a person playing
+ * in that style fills in what they think is a correct
+ * solution loop but in fact it has an underfilled clue,
+ * then we will display no victory flash and also no error
+ * highlight explaining why not. With this special case,
+ * we light up underfilled clues at the instant the loop
+ * is closed. (Of course, *overfilled* clues are fine
+ * either way.)
+ *
+ * (It might still be considered unfortunate that we can't
+ * warn this style of player any earlier, if they make a
+ * mistake very near the beginning which doesn't show up
+ * until they close the last edge of the loop. One other
+ * thing we _could_ do here is to treat any LINE_UNKNOWN
+ * as LINE_NO if either of its endpoints has yes-degree 2,
+ * reflecting the fact that setting that line to YES would
+ * be an obvious error. But I don't think even that could
+ * catch _all_ clue errors in a timely manner; I think
+ * there are some that won't be displayed until the loop
+ * is filled in, even so, and there's no way to avoid that
+ * with complete reliability except to switch to being a
+ * player who sets things to LINE_NO.)
+ */
+ no_order = sides - yes_order;
+ } else {
+ no_order = face_order(state, i, LINE_NO);
+ }
+
+ clue_mistake = (yes_order > n || no_order > (sides-n));
+ clue_satisfied = (yes_order == n && no_order == (sides-n));
+
+ if (clue_mistake != ds->clue_error[i] ||
+ clue_satisfied != ds->clue_satisfied[i]) {
+ ds->clue_error[i] = clue_mistake;
+ ds->clue_satisfied[i] = clue_satisfied;
+ if (nfaces == REDRAW_OBJECTS_LIMIT)
+ redraw_everything = TRUE;
+ else
+ faces[nfaces++] = i;
+ }
+ }
+
+ /* Work out what the flash state needs to be. */
+ if (flashtime > 0 &&
+ (flashtime <= FLASH_TIME/3 ||
+ flashtime >= FLASH_TIME*2/3)) {
+ flash_changed = !ds->flashing;
+ ds->flashing = TRUE;
+ } else {
+ flash_changed = ds->flashing;
+ ds->flashing = FALSE;
+ }
+
+ /* Now, trundle through the edges. */
+ for (i = 0; i < g->num_edges; i++) {
+ char new_ds =
+ state->line_errors[i] ? DS_LINE_ERROR : state->lines[i];
+ if (new_ds != ds->lines[i] ||
+ (flash_changed && state->lines[i] == LINE_YES)) {
+ ds->lines[i] = new_ds;
+ if (nedges == REDRAW_OBJECTS_LIMIT)
+ redraw_everything = TRUE;
+ else
+ edges[nedges++] = i;
+ }
}
/* Pass one is now done. Now we do the actual drawing. */
ds->started = TRUE;
}
-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->solved && newstate->solved &&
!oldstate->cheated && !newstate->cheated) {
return 0.0F;
}
-static int game_status(game_state *state)
+static int game_status(const game_state *state)
{
return state->solved ? +1 : 0;
}
-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 ink = print_mono_colour(dr, 0);
int i;
grid_face *f = g->faces + i;
int clue = state->clues[i];
if (clue >= 0) {
- char c[2];
+ char c[20];
int x, y;
- c[0] = CLUE2CHAR(clue);
- c[1] = '\0';
+ sprintf(c, "%d", state->clues[i]);
face_text_pos(ds, g, f, &x, &y);
draw_text(dr, x, y,
FONT_VARIABLE, ds->tilesize / 2,
const struct game thegame = {
"Loopy", "games.loopy", "loopy",
default_params,
- game_fetch_preset,
+ NULL, game_preset_menu,
decode_params,
encode_params,
free_params,
~ian / sgt-puzzles.git / blobdiff