exolve
v1.50
Exolve can help you create online interactively solvable crosswords (simple ones with blocks and/or bars as well as those that are jumbles or are diagramless or are 3-D, etc.) in any language.
The file exolve.html contains all the code you need: just
make a copy and then replace the part that contains the example grid with your
own puzzle specification, starting at the exolve-begin line and ending at the
exolve-end line.
The files exolve-m.html, exolve-m.css, exolve-m.js have the same content as exolve.html, except that it is split into separate parts: HTML (including the puzzle specification), CSS, and JavaScript. This allows the JavaScript and CSS to be reused across multiple puzzles.
Another simple option is to just use the exolve-m-simple.html file: this is essentially a copy of exolve-m.html, but it does not require you to host the exolve-m.css and exolve-m.js files, as it links to their latest copies on a website that I maintain, hosted on GitHub.
Yet another option is to embed the Exolve puzzle within arbitrary web pages (like blog posts) in a "widget". See the details in the Exolve widget section.
The Exolve Player web app can be used to play crossword files in several formats (including .puz and even just the clues copied from a PDF in many cases). An easy-to-remember URL for this web app is exolve.app.
You can also use the file exolve-embedder.html to serve .puz and .ipuz files using Exolve. See the details in the Exolve Embedder section.
Here is an example of the puzzle specification:
exolve-begin
exolve-width: 5
exolve-height: 5
exolve-grid:
HELLO
O.A.L
WORLD
L.G.E
STEER
exolve-across:
1 Greeting (5)
4 Earth (5)
5 Guide (5)
exolve-down:
1 Emits cry (5)
2 Big (5)
3 More ancient (5)
exolve-end
The format is very simple and uses plain text (but the parsing code is also occasionally simplistic and not very forgiving, so please go through the format documentation). The setter has the option to provide solutions (as in the example above), or to just use 0 to indicate a square that needs to be filled (i.e., is a part of a "light," in crossword terms).
A few example puzzles are also included in this directory, each in a file with
the ".exolve" extension. These showcase some of the available features, such as
ninas, additional clues or questions, submission, barred puzzles, diagramless
puzzles, etc. To try one of these, create a copy of exolve.html
and edit it as described above, splicing in the whole .exolve file from
exolve-begin to exolve-end. A whole suite of test-*.html files is also
available in this directory. I use them to test new releases, but you can use
them to see examples of usage of most Exolve features.
The basic control is to click on a square and enter a letter in it. If a square is a part of both an across clue and a down clue, then clicking on that square while it is the current square (or pressing the Enter key) will toggle the active direction (unless the shift key is also pressed with a click, in which case no directon-toggling will happen, which is useful when navigating back to the grid from some other input element).
The control buttons (Clear this, Clear all!, Check this, Check all!, Reveal this, and Reveal all!) work as suggested by their names ("this" refers to the currently selected light(s)). You can click on a clue to jump to its squares. If the setter has not provided all solutions, then only the "Clear this/all" control buttons are shown, the "Check/Reveal" buttons do not get shown.
The "Clear this" button at first only clears letters that do not cross other fully filled lights, if there are any. If there are none (i.e., if all remaining letters in the current light also cross other fully filled lights), only then will these remaining letters get cleared.
A long click on either of "Check this" or "Reveal this" will toggle the text "this" to "cell," and the checking/revealing will then only happen on the current cell (as opposed to the whole light), for that particular activation of the button. Caveat: this does not seem to work on phones and tablets (only tested on Android devices though).
Setters can use exolve-option show-cell-level-buttons
to additionally show an extra row of buttons containing these two cell-level
buttons: "Check cell" and "Reveal cell."
Exolve supports diagramless puzzles, where the blocked squares are not identified and the solver has to figure out their locations. In fact, exolve supports partially diagramless puzzless, where only some squares or some partial areas of the grid do not show where the blocked squares are. While solving such a puzzle, the solver can press the space bar in a diagramless square to posit that it is a blocked square (the dark square character, ⬛, will get placed in that square. It can be deleted just like any other regular entry). Further, when a user enters or clears a blocked square in a diagramless cell, the appropriate action will also be taken in the square that is the symmetric counterpart of the current square.
If the setter has provided annotations by appending annotations at the end of some clues, then these annotations get shown when the solver clicks "Reveal all!". Clue-specific annotations get revealed/hidden with "Reveal/Clear this" buttons (unless the clue only has diagramless cells). Additionally, "Check this" and "Check all!" behave like "Reveal this" and "Reveal all!" respectively, if they find no mistakes. In a puzzle in which solutions are not provided, the "Reveal this" button will still get shown if there are any clues for which annotations are present (these annotations may be full solutions or just hints, possibly).
If the setter has provided the location of one or more ninas (through
exolve-nina sections), then an additional button control,
Show ninas, gets shown, for the solver to see where the ninas are. The button
can be clicked again to hide the nina locations. Ninas also get shown on
clicking "Reveal all".
If the setter has asked additional questions in the puzzle (through
exolve-question sections), then input fields for these get
shown too. "Reveal/Clear all" controls buttons also include revealing/clearing
answers to these questions apart from showing/hiding annos/explanations/ninas.
If the setter has set up a submit URL (with an exolve-submit
section—the URL can be set up using a Google Form, for instance), then there is
a Submit buttion.
When the solver enters a letter in a square, the cursor automatically jumps to the next square for the currently active clue (the next square can be from a different clue, when there are linked clues that "cover" multiple clues).
If the solver changes a cell entry from a non-blank letter to a different
non-blank letter, then that changed letter is highlighted by showing in a
different colour for a short while. This animation's
start/end colours (overwritten-start and overwritten-end)
and the duration (highlight-overwritten-seconds) can be
configured.
If the solver hits the delete key, it will erase the contents of the current square without advancing.
The solver can press Tab/Shift-Tab to navigate to the next/previous clue. The solver can use the arrow keys to navigate to the next/previous light cells in the direction of the arrow.
The software tries to keep the current clue visible when scrolling, as long as the square with the cursor is visible.
"Clear/Check/Reveal all" buttons, the "Show ninas" button, and the "Submit" button solicit additional confirmation from the solver.
Clicking on a clue in the clues table makes that clue active. If that clue was not the previously active clue, then the keyboard focus goes to the first letter of that clue, in the grid. If the clue was already active, then the focus stays with the clue, letting you select and copy parts of the clue/anno if needed.
You can click on the black background or on the puzzle title, setter, or preamble (if present) to unhighlight the current clue (for printing or screenshotting, for example).
In a few cases (such as when specifying colouring or ninas or locations of some clue numbers in diagramless puzzles), you might need to specify the location of a square in the grid. You can do that in one of the following ways:
a3 (column "a": the 1st column from the left, and row 3 from the bottom)
f11 (column "f": the 6th column from the left, and row 11 from the bottom)
The letters (a-z) must be in lower case and must precede the row number, with no intervening space.
This chessboard notation is insufficient if your grid has more than 26 columns. You can directly specify the row and the column too, like this:
c1r3 (the 1st column from the left, and row 3 from the bottom)
r11c6 (the 6th column from the left, and row 11 from the bottom)
The puzzle can contain the following "sections" between the exolve-begin line
and the exolve-end line:
exolve-widthexolve-heightexolve-gridexolve-titleexolve-setterexolve-emailexolve-idexolve-copyrightexolve-creditsexolve-preamble / exolve-prelude
exolve-acrossexolve-downexolve-nodirexolve-reversalsexolve-3dexolve-3d-acrossexolve-3d-awayexolve-3d-downexolve-explanationsexolve-ninaexolve-colour / exolve-color
exolve-questionexolve-submitexolve-optionexolve-languageexolve-relabelexolve-makerexolve-force-hyphen-rightexolve-force-hyphen-belowexolve-force-bar-rightexolve-force-bar-belowexolve-cell-sizeexolve-postscriptEach section has the section name (exolve-something), followed by a colon.
Other than the exolve-preamble/exolve-prelude, exolve-grid,
exolve-across, exolve-down, exolve-nodir, exolve-explanations, and
exolve-postscript sections, all other sections occupy a single line (some can
be repeated though). For such single-line sections, the "value" of the section
is the text following the colon on the same line.
The bolded sections, namely, exolve-width, exolve-height, and
exolve-grid are required. The other sections are optional, but
exolve-across, exolve-down, exolve-title, exolve-setter should probably
be present in most puzzles.
Any line (or trailing part of a line) that begins with a "# " is treated
as a comment and is ignored. A "#" with an end-of-line after it is also treated
as a comment. Note that a "#" with a non-space character after it is NOT treated
as a somment (this is so because we may have HTML colour names such as #FF00FF
in exolve-colour sections, and we may have clues in which their grid-location
is indicated in the #xN
notation—see this section). I did not use
"//" as the comment marker as it is used in URLs.
Any text appearing before exolve-begin or after exolve-end is ingored.
exolve-width, exolve-height
The width and height of the puzzle—i.e., how many squares across and how many squares down is the crossword grid. Example:
exolve-width: 15
exolve-height: 15
exolve-gridThe grid specification starts from the line after the exolve-grid line and
goes all the way to the next exolve-something section. There should be exactly
as many lines in this section as the height of the grid. On each line, the
squares in that row of the grid are specified.
There are two kinds of puzzles: with solutions provided and without solutions provided. Here are simple examples of both:
Grid with solutions provided:
exolve-grid:
ACE
R.R
EAR
This is a 3x3 grid with one blocked square in the center ("." is used to indicate blocked squares). In this grid, 1 Across = ACE, 1 Down = ARE, 3 Down = ERR, and 3 Across = EAR. When solution letters are included like this, the control buttons for checking/revealing answers get shown.
In a grid with solutions provided, setters may use the letter '?' as a placeholder in any light square for which they have not yet decided what letter to place.
Grid without solutions provided:
exolve-grid:
000
0.0
000
This is also a 3x3 grid, but no solutions have been provided (every light is shown using the letter "0"). In such a grid, the control buttons for checking/ revealing answers do not get shown.
It is also possible to specify barred grids, instead of blocked ones. In fact, it is possible to specify a a grid that uses both bars and blocks. Bars (and some other special treatments) are specified using letters that follow the main grid square specifier, which we'll refer to as decorators. A bar to the right of a square is specified using the decorator |. A bar under a square is specified using the decorator _. A square that has both a bar after and a bar under can use "|_" or the shortcut for that, "+". Arbitrary many spaces are allowed between grid square specifications, and spaces can (should!) be used to line up the squares in the presence of decorators. Here is an example 3x3 grid that uses both bars and blocked squares:
exolve-grid:
A M|B
X . E
E|A T
The decorator "@" can also be used to inscribe circles inside some squares, and the decorator "*" can be used to indicate that a square is to be diagramless. Here's the last example again, this time with circles around some cells, and some cells being diagramless:
exolve-grid:
A M|@B
X* . E*
E| A T
The decorator "!" can be used to mark a cell as pre-filled (its solution letter must be provided). The solution letter will be pre-filled and will not be editable. If all entries in a light are prefilled, and an anno is provided for that clue, the anno will be shown automatically at start-up. Even if no anno is given for a fully prefilled clue, the solution will be displayed at the end of the clue (unless the no-auto-solution-in-anno option is set).
The decorator "~" can be used to mark a cell that starts an across/down clue as one in which normal clue numbering should be skipped. Such a cell gets no clue number. The clue number that it would have got will instead be used for the next cell that starts a clue. The light(s) that start at such "skipped number" cells would have to be clued in some other way (for example, with a clue that is specified or revealed separately). One way the clue can be provided is with a nodir clue or a non-numerically labelled clue, as described later.
As a convenient reference, here again is the complete list of decorators:
| Decorator | Meaning |
|---|---|
| |
Has a bar after it, to the right. |
_ |
Has a bar under it. at the bottom. |
+ |
Has bars both after and under. |
@ |
Has an inscribed circle. |
* |
Is diagramless. |
! |
Is prefilled. |
~ |
Skips normal numbering |
If you use a language/Script that uses compound letters made up of multiple
Unicode characters (for example, Devanagari—see the
exolve-language section), or if you have
rebus cells, then your must separate grid
letters (when specifying a grid with solutions) with a space (unless they are
already separated by a decorator). For example, this will not work:
exolve-grid:
सेहत
This will work:
exolve-grid:
से ह त
Normally, only the letters of the alphabet (A-Z, or script-specific) can be
used in solution letters. However using exolve-option
allow-digits or allow-chars:<chars>, you may allow some non-alphabetic
characters. If any of these characters is also a decorator or has a special
meaning in grid specifications (i.e., is one of |_+@!~*.?), then it should
be prefixed with & in the grid specifications. If & itself needs to be used
in the grid, then it too should be prefixed with an &. For example:
exolve-option: allow-chars:@.&
exolve-grid:
A &@ B &. C O M
&& . . . . . .
Even though 0 has a special meaning in grid specifications, you do not
have to escape 0 using an & prefix if 0 has been allowed in the grid via
allow-digits or allow-chars. A technical caveat (for the sake of
completeness) is that you cannot create a degenerate grid that has all entries
made up entirely of 0s.
If you want the crossword solution to include some cells that have multiple
letters (aka "rebus cells"), then you have to use exolve-option: rebus-cells
(and you have to separate grid solution entries with spaces as mentioned
earlier).
For example:
exolve-width: 3
exolve-height: 3
exolve-option: rebus-cells
exolve-grid:
RAN G E
DO . A
M E T
If there are rebus cells, then you can enter multiple letters into any cell after double-clicking on it, or by pressing down the Shift key while entering a letter. If a cell already has previously entered multiple letters, then when you come to it again (by clicking on it or auto-advancing from an adjacent cell), you will be able to enter multiple letters into it (without having to use the Shift key or double-click).
When multiple letters are entered into a cell, the font size of cell text is
adjusted to try to fit all the letters. If you have some long rebus entries
that do not fit the default cell size then you should use bigger cells, using
exolve-cell-size.
If there are rebus cells, then the across-direction indicator arrow in the current cell is placed below the text intsead of to the right of it, to leave more space for the text.
You cannot have rebus cells in crosswords that use languages with max-char-codes greater than one and in crosswords with diagramless cells (this allows us to keep the code simpler).
Note that "diagramlessness" only hides from the solver whether a square is in a light or is a blocked square—if the setter has used any bars, they do get displayed to the solver, even in diagramless cells.
If a puzzle with diagramless squares has specified all solutions, then check/reveal controls get displayed. For example, revealing a blocked diagramless square will show the dark square character, ⬛, in that square.
If the setter wants to not provide solutions for a puzzle that has some diagramless squares, then the blocked square marker (".") should not be used in the blocked squares that are also diagramless (otherwise the solver can peak into the HTML source and see where the blocked squares are). Each diagramless square in such a puzzle should be specified with a "0" followed by the diagramless decorator, i.e., as "0*". But then, even the Exolve software has no way of knowing which grid square any clue starts on. However, sometimes, even in a puzzle with diagramless squares, the setter may want to provide the clue start locations for some clues. Exolve provides a way to do this: the setter can optionally include the location of the square where a clue starts for any clue, using the extended chessboard notation. Details are provided in the next section.
exolve-title, exolve-setter
The title of the puzzle and the name/pseudonym of the crossword setter. Example:
exolve-title: My Lovely Crossword
exolve-setter: Narsi Sus
exolve-emailOptional email address (or comma-separated addresses) where solvers can contact the crossword creator(s). From the "Notes" panel, you can send your notes to this email address.
exolve-idOptionally provide a unique id for this crossword puzzle. This id is used as
the key for saving/restoring state and also to distinguish between multiple
puzzles on a single page. You can create an unsolved version of a puzzle (to
run a contest, for example) and, later, a version of the same puzzle that has
the solutions, giving them both the same exolve-id. Then, when solvers visit
the version with solutions, they can see their own entries and see which
mistakes they made, if any. Example:
exolve-id: tiny-42
If you do not provide an id, the software will create one from a signature of the grid and the clues. This will ensure that if you load the same crossword without making any changes to the clues or the grid, then you will recover the state, even without an explicit id.
exolve-copyrightIf your provide this, it will be displayed with the copyright symbol, under the rendered puzzle grid. Example:
exolve-copyright: 2019 Viresh Ratnakar
exolve-creditsIf your provide this, it will be displayed under the copyright. You can provide multiple instance of this. Example:
exolve-credits: Test solver: Zaphod Beeblebrox
exolve-credits: Custom code: H. A. C. Ker
exolve-preamble, exolve-prelude
Crossword puzzles often come with a preamble that contains special instructions
and/or hints. The preamble text occupies multiple lines—starting from the
line after the exolve-preamble (or exolve-prelude) line, and going all the
way down to the line preceding the next exolve-something section. The preamble
may include HTML tags. The preamble is rendered just above the grid, in the
rendered puzzle. Example:
exolve-preamble:
Words should be entered in the grid <i>after</i> deleting one letter. The
letters thus deleted, in clue order, form the name of a famous farm
animal.
exolve-across, exolve-down, exolve-nodir
The exolve-across and exolve-down sections should be used to specify the
across and down clues, respectively (exolve-nodir is for the special/rare case
of clues that do not have a specified direction; we will describe it at the end
of this section). There should be one clue per line, and there should not be any
blank lines. The clues should start with the clue number, and end with the
enum (the enum is not strictly required). Example:
exolve-across:
1 Untouchable service (3)
3 Listener (3)
exolve-down:
1 Happen to be (3)
2 Make a mistake (3)
If the enum indicates multiple words (for example, (4,3) or (6 7)), or if the enum indicates hyphenated words (for example, (4-2)), then the word boundary or the hyphen gets displayed in the grid, to help solvers. The software uses the following criteria to decide what constitutes the enum part of a clue: a pair of opening and closing parentheses, containing only numbers, hyphens, commas, apostrophes, spaces, and periods, starting with a number. The software also treats a pair of parentheses containing the text "words" or "letters" (or any subword beginning with "w" or "l", such as "wrds" or "l" or "ltrs") or containing "?" with anything before it, as an enum (to allow the setter to specify the enum as "(two words)" or "(?)" or "(7, 2w)", for example). Within these special cases, in the corner cases of "(7, 2words)" and "(6 letters)", the parsing interprets 7 and 6 respectively to be the length of the entry, and will check it against the length of the light as with a normal enum.
In the rare case that there are multiple candidate enum parts in a clue, the
last one is used. However, this can be overridden by explicitly using "[]"
to mark the end of the clue (see Annotations below).
In a 3-D crossword, instead of exolve-across and exolve-down you should use
exolve-3d-across and exolve-3d-away sections, respectively, with an
exolve-3d-down section providing the clues for the vertical lights through
the layers. You can find the details in the exolve-3d section.
If the enum is immediately followed by a *, then it is not displayed to the
user. Examples:
1 Satellite (4)* MOON
2 Star (?)*
There might be puzzles where, even though the enum indicates multiple or hyphenated words, you do not want a word-separator bar or a hyphen to be drawn in the grid. An example would be a grid where the special instructions ask for a letter to be removed before entering a solution into the grid. You can achieve this effect using the following bit of trickery:
1 Clue with enum that implies hyphens and dashes, but they are suppressed
using trickery (<span>3,2-2,5-3</span>) (15)* Anno here...
Note that the enum numbers are wrapped in a <span> tag, which tricks Exolve into not parsing them. The length of the entry is specified after that, using the enum spec (15)* that does not get displayed (but serves as a way to let Exolve know that what follows is the anno).
If there is a missing clue, or if the provided enum for a clue does not
match the number of cells in the clue as per the grid (including any linked
children clues), then a warning message gets shown. If the anomaly is
deliberate rather than an oversight, the warning generation can be suppressed
using exolve-option: ignore-unclued and/or
exolve-option: ignore-enum-mismatch. Checking for missing clues is not
done if there are any nodir clues, and checking for mismatched enums is
not done if there are any diagramless cells.
You can include hints in clues (in some clues or in all clues). This is done
by providing a sequence of lines immediately under the clue, each one carrying
the prefix, Hint: (case-insensitive). Each hint can include HTML formatting.
Example:
exolve-across:
1 Some clue without a hint (9)
5 A clue with two hints (5)
Hint: The <i>first</i> hint!
Hint: The second hint is noticeably longer.
6 A clue with one snarky hint (6)
Hint: Try using your brain for a change?
Note that these hints are completely independent of the post-reveal annotation desribed below (if present). When hints are available for the current clue, and not all hints have yet been shown, a lightbulb icon is shown at the end of the clue (above the grid only, not in the clues table). Clicking on this icon will reveal the next hint. Clicking on any hint will hide all the hints once again.
Exolve does not save state about how many hints were shown for various clues, so if you reload the puzzle then all hints restart in the not-shown state.
In a grid with solutions provided, the setter may include annotations for explaining how a clue works or for providing hints. Any text located after the enum in a clue is treated as annotation. The annotation is displayed when the solver clicks on the "Reveal all" button or on the "Reveal this" button when that clue is the current clue. Example:
exolve-across:
28 Replace bottles containing questionable medicine (7) Def: questionable medicine. Hidden word: (-re)PLACE BO(-ttles).
If a clue does not provide its anno, the software still creates a minimal anno consisting of just the solution text (that it infers from the grid and the enum). Even if the anno is provided, the software prefixes it with the inferred solution text. This might have meant that if in an older grid the solution was explicitly included in the anno, it would have got duplicated. So, the code does check to see if the solution string (punctuation/markup notwithstanding) is present at the head of the anno, and avoids duplicating it if so. If the setter wants to present the solution in some other way, they can suppress the automatic addition of the solution to the anno by adding this line to the puzzle specs:
exolve-option: no-auto-solution-in-anno
This option only suprresses the solution getting added to the anno appearing after the clue. The solution does still get added to the placeholder blank slot of an orphan clue, upon "Reveal this," even with this option.
If the leading part of the anno needs to be something in square brackets, such as "... (6) [t]WITTER ...," then setters should include the solution before that (even if it can be inferred from the grid), to avoid misinterpreting the leading part as the solution, like "... (6) [WITTER] [t]WITTER ..." Or, they can use an empty pair of square brackets to mark the end of the clue, like "... (6) [] [t]WITTER ..." The special "[]" clue-end marker string is also useful if there is any ambiguity about where the clue ends (perhaps because of multiple enum-like substrings) that cannot be resolved by providing the solution in square brackets.
Here are some more complex examples of enum/annotation parsing.
1 This (13) clue ends (word) here! (4)
2 This (13) clue also ends (1 word) here! (4) Some annotation follows.
3 This (13) clue also ends (2 letters) here! (8) [SOLUTION] Some annotation follows.
4 This (13) clue also ends (words) here! (8) [] [t]WITTER The anno has (3) enum-like parts.
5 This is an enum-less and anno-less clue that ends here!
6 This is also an enum-less and anno-less clue that also ends here! (?)*
7 This is also an enum-less but with-anno clue that also ends here! (?)* [] [t]WITTER Here is the anno.
8 This clue, even though its anno contains an enum-like substring, ends here! (4) The (word) and (4 letters) enum-like parts here are not numeric.
9 This clue (13) does not end now (4) as [square brackets do not follow immediately]; it ends here! (4)
You can also decorate sub-phrases in the clue with underlines, different styles,
colours, backgrounds, etc., by enclosing specific substrings with the special
markers, ~{ and }~, like this:
28 Replace bottles containing ~{questionable medicine}~ (7) Hidden word: (-re)PLACE BO(-ttles).
The default styling for such "in-clue annotations" is to underline the text with a "darkgreen" underline. This styling will get revealed when the solver clicks on "Reveal this" or "Reveal all" (and will get cleared with "Clear this/all").
You can apply different in-clue annotation styles (instead of underlining), by providing an HTML element class name, like this:
28 ~{{xlv-blue}Replace}~ bottles ~{{my-style}containing}~ ~{questionable medicine}~ (7) Hidden word: (-re)PLACE BO(-ttles).
Here, "xlv-blue" is a class name that Exolve has set up in its CSS (some others are "xlv-red", "xlv-yellow-bg", and "xlv-pink-bg"). But you can use your own class names too (such as "my-style" above) and specify their stylings with your own custom CSS rules.
If a linked clue includes other "children clues," this can be indicated by appending a comma-separated (or &-separated) list of children clue numbers to the parent clue number. Example:
exolve-across:
1, 5, 2d In spite of adverse circumstances (7,3,4)
5 See 1 Across
...
exolve-down:
2 See 1 Across
3 & 7 See neck (4,3)
7 See 3 Down
As shown in the above examples, if a child clue (2d in the first example) has a different direction from the parent, the direction can be specified with a one-letter suffix ("a" or "d" or "b" or "u"), or, in 3-D crosswords, with a two-letter suffix ("ac" or "aw" or "dn" or "ba" or "to" or "up").
Linking lights can create two corner cases that are noteworthy. (1) When a light ends on the same cell where the next linked light starts, then that cell is not counted twice. So, in a 3x3 grid with 3-letter lights 1a and 2d linked, where 2d starts on the same cell as where 1a ends (cell r3c3), the total length of the linked lights would be 5 not 6. (2) If you link a sequence of lights (including some reversed lights) such that the last cell of the linked group is exactly its starting cell, then that cell is also not counted twice. Further, the interface lets you type letters in a loop along the sequence (as that seems to be the fun thing to do for this corner case). For backspacing (when erasing) cells in such a snake-swallowing-its-own-head loopy linked group, the interface stops the backspacing at the first cell.
While solving, when a light is fully filled in, its clue number changes colour (to a light shade of blue, making the unsolved clue numbers stand out). There are some minor exceptions when this does not happen (diagramless cells or other reasons that don't let us determine when a clue's light is fully filled). For such clues, the solver can click on the clue number to set (or unset) its "has-been-solved" state manually.
As mentioned in the previous section, in a grid that has diagramless squares
and that does not provide solutions, if the setter wants to display some clue
numbers in squares, they can do so by prepending the clue (in the
exolve-across or exolve-down section) with "#<L>", where <L> is
the location of the square in the
extended chessboard notation.
Examples:
exolve-across:
#a9 15 Imprison and tie perhaps
#c17r42 31 Greeting
Here, the clue number 15 will get displayed in the square that is in the first column and the 9th row from the bottom, and 31 will get displayed in the 17th column and 31st row.
Any line in a clues section (i.e., in
exolve-across/exolve-down/exolve-nodir) that cannot be parsed as a clue or
hint is treated as a filler line. It is simply displayed in that position in the
list of clues. It is an error to place a filler line after the last clue in a
clues section. Filler lines can be used to demarcate sections within clues, if
needed. Example:
exolve-across:
1 Communication device (5)
7 Greeting (5)
<i>The following entries all begin with B.</i>
9 Unreachable sound in 1 (4,4)
15 Zaphod (10)
Any line in a clues section that starts with --- initiates the rendering of a new table of clues. If any text follows --- then it gets shown as the heading of the new table.
The order in which the exolve-across, exolve-down, and exolve-nodir sections appear in the puzzle specs is the order in which they will be displayed. Additionally, direction-toggling will also follow the same sequence. Thus, if you list nodir clues before across and down clues, and the solver clicks on a cell that does not have a light in the currently active direction (say Across), but does have both a nodir light and an across light going through it, the nodir light will become active (as nodir clues are listed before across clues in the specs).
If you want to use non-numeric clue labels (such as A, B, C, etc.), you can do that by enclosing the non-numeric clue label in square brackets, like this: Example:
exolve-across:
2 Imprison and tie perhaps (6)
[F] Enjoyable (3)
5 Hitchhiker's accessory (5)
#a12 [G], 4, [H] Fitting reply (3,3,3)
...
For non-numeric clue labels, the software does not know which cell the clue begins in, unless it is specified explicitly by the setter using a "#xN" prefix as described above and shown in the fourth clue example above.
A trailing period after a clue number or label is considered to be just a punctuation mark and is ignored. The first five periods in the following example get ignored. If you have consecutive periods, they do not get ignored (as you're presumably using an ellipsis).
2. Clue (4)
3.Ignorance is _____ (5)
4 . Time for every one to end, finally (6)
[Q.]. Hop... (4)
[R] ... aboard! (6)
Across and down clue numbers within the grid are automatically inferred from the grid, except in two cases. The first is when there are diagramless cells and solutions have not been provided. The second is in jigsaw-style puzzles, where the setter opts to deliberately not provide associations between grid squares and clues, by using non-numeric clue labels without providing their grid locations. When the solver is entering a value in a light for which the clue association is not known, the highlighted "current clue" browsable interface runs through all the clues for which all grid cells are not known.
Clue numbering can be affected by the following additional factors covered in other sections:
exolve-grid section.exolve-reversalsexolve-3dIf you want to create a section of clues without a specified across/down
direction, you can use an exolve-nodir section, which has the same structure
as exolve-across and exolve-down, but the direction of each clue in this
section is considered unspecified. Setters would probably want to use this
section with non-numeric clue labels. Example:
exolve-nodir:
[P] Direct (5)
[Q] Server spilling one's drink (5)
...
The clue label in [] can be numeric too, (like [42]), and the starting cell can also be specified using a "#<L>" prefix (with <L> being a cell location in the extended chessboard notation) as described above.
If the setter is using nun-numeric clue labels or clues without a specified
direction, then they should probably also use the option "hide-inferred-numbers"
in an exolve-option section. Alternatively, they can use
the "~" decorator in the grid to skip numbering the cells using normal
numbering.
You can provide a heading for nodir section by placing it after
exolve-nodir:, like this:
exolve-nodir: Alphabetic clues
[P] Direct (5)
[Q] Server spilling one's drink (5)
...
In a nodir clue, you can specify not just the starting cell, but all the cells using the chessboard notation. If you do that, then clicking on a cell in that clue will highlight and allow entry in all the cells for that clue (cells in a nodir clue can be scattered arbitrarily in the grid). Example:
exolve-nodir:
#c3 #c5 #c8 #f6 [A] One hundred years lived in prison (4)
Note that this technique can be used to create multidimensional (like 4-D!)
puzzles: use a nodir section for specifiying lights along all the extra
dimensions, explicitly specifying their cells. For 3-D crosswords, Exolve
provides better and more complete support, including a nice 3-D appearance
(see the exolve-3d section).
If an across/down clue's start cell has the decorator "~", its normal numbering gets skipped. If there is another clue that is either an across/down clue with a non-numeric label and with its start cell specified, or is a nodir clue with all its cells specified, and all the cells of the two clues are the same, then the clues get merged. The label specified for the second clue gets shown in the skipped-number cell. For example:
exolve-grid:
0~0 0
0 . 0
0~0 0
exolve-across:
#a1 [B] Bottom row (3)
exolve-down:
1 Third column (3)
exolve-nodir:
#a3 #b3 #c3 [Q] Top row [3]
Here, the top-left and bottom-left cells are skipped-number cells. The [B] across clue gets merged with the bottom row light, and the [Q] nodir clue gets merged with the top row light. The light in the first column is unclued.
If there is any nodir clue without cells explicitly specified, or an across/down clue with a non-numeric label whose start/cells are not specified, then the clue is shown with a text entry area next to it. Solvers can record their solutions here, until they figure out where in the grid those letters should be entered. Solvers can transfer recorded letters from these placeholder areas by simply clicking the "copy-placeholder" button (that looks like [⇲]) next to the placeholder area, whenever they have some squares highlighted for entry in the grid.
You can force a placeholder blank to appear after any clue (not just "orphan" ones that qualify using the criteria listed above). See the next sub-section.
The placeholder entries do NOT get cleared with 'Clear this/all' (they can simply by erased directly by clicking on them and deleting though). For clearing all placeholder entries forcibly, click on the 'Clear all' button when there are no entries in the grid (eg, by clicking on it a second time). This option is only there in puzzles that have such placeholder entries, and in such puzzles, a tooltip is shown over the 'Clear all' button to let the user know.
The same placeholder text and the copy-placeholder button ([⇲]) are also shown in the highlighted scrollable 'orphan' clues widget, whenever the currently highlighed squares do not have a known clue association.
The copy-placeholder button feature does not get activated if there are any diagramless cells (as only one diagramless cell is active at a time generally).
The copy-placeholder buttons can be disabled (i.e., not shown at all) by
specifying exolve-option: hide-copy-placeholder-buttons. This is useful if
you find the buttons distracting in appearance, or if copying from the
placeholder is not very useful for some other reason (for eg., lights are split
into parts).
Within such clues, in grids with solutions provided, it is possible to indicate
which cells in the grid belong to the clue, for use in "Reveal this" and "Check
this." This is done by listing in square brackets a space-separated sequence of
clue indices and/or cell locations. Clue indices can be like 12a or 12A or 13d
or 13D (must include direction, just like the way these are specified in
exolve-nina and exolve-colour). If any clue indices are used in the
specified sequence, then those clues themselves must have some of their cell
locations known. This listing should be present right after the enum part, if at
all. Examples:
exolve-nodir:
[A] Some clue (5) [1a]
[B] One hundred years lived in prison (4) [2d]
[C] Some other clue ... (?) [3d 4a c4 c5 r5c3] [SOLUTION HERE] Anno...
In the last clue above, there is no enum provided. Even though the software knows all the cells of this clue, it does not know if there are multiple words or hyphens. The solution in such cases can be provided in square brackets at the beginning of the anno.
The inferred or provided solution for an orphan clue gets revealed in its placeholder blank upon "Reveal this" and "Reveal all."
Individually listed cells, if highlighted just by themselves (which would be the case if they are diagramless) do not let solvers reveal/check the whole orphan clue: a single cell may be a part of multiple clues.
There are some subtle implications of providing revelations for orphan clues in this manner. In the above example, say a light in the grid (such as 1a) that belongs to some orphan clue (A in this case) is highlighted by clicking on one of its cells. The current clue shown in the clues list will be last orphan clue that the solver looked at, say B (different from A). If the solver clicks "Reveal this" then 1a will be revealed in the grid, and A will get highlighted in the clues list.
If, after clicking on 1a in the grid, say the solver clicks on clue C in the clues list and then clicks "Reveal this." We infer the solver's intent from their last click. In this case, C in the clues list will get revealed, and the highlighting in the grid will change from 1a to whatever is the correct light for C.
Another subtle point is that in a puzzle with diagramless cells, it's possible for a clue to have specified some of its cells (the first few), but not all. Its cells can be revealed by naming itself, and listing the additional cells. For example:
15 Imprison and tie perhaps (one word) [15a e9 f9] DETAIN.
Note also that "Reveal all" does not reveal orphan-clue-to-grid-light associations. But, even after "Reveal all," solvers may go through orphan clues, clicking "Reveal this" for each.
A common ruse in cryptics is to make each clue somehow yield an extra letter
and to make a meta out of those letters. Exolve allows you to add a column
of "extraction slots" before each clue. Solvers can record letters/numbers
in these slots (and these are saved in the state too). You can do this
by specifying exolve-option: add-extraction-slots. By default, if you
specify this option, then a one-letter slot is added. But you can specify
the number of letters in the slot with an optional parameter (e.g.,
exolve-option: add-extraction-slots:3).
Placeholder blanks normally get displayed only in front of "orphan" clues whose light locations are not provided to the solver. However, you can force a placeholder blank next to any clue by following it with one or more underscores. If you're providing annotations, place the undescrores before the annotations.
This can be useful to solvers when, for example, the puzzle instructions call for some modification (such as letter omissions) to solutions before they can be entered into the grid.
Examples:
exolve-across:
5 This clue will get placeholder blanks (4) _
6 Here we're specifying that there should be 7 blanks, regardless of enum (4) _______
7 The underscores can have intervening spaces and can be followed by annos (8) _ _ _ Some anno.
If you place just one underscore, then the actual displayed size of the blank will be determined using the enum. If you place more than one underscore, then the displayed size of the blank will equal the number of underscores that you have provided. You can have spaces between these underscores just to help you count them more easily.
The placeholder blank, when empty, will show (as the light gray "placeholder" text that indicates a hint for what the solver needs to enter) the text pattern implied by the enum, such as "??? ??-??" for (3, 3-3). You can override this placeholder text by specifying what should get displayed within square brackets, right after the last underscore. For example:
exolve-down:
3 This will have 8 placeholder blanks showing "??? ??" instead of
"????" (4) _ _ _ _ _ _ _ _ [??? ??] Some anno.
3 For this piece of cake, we customize the placeholder text shown
in the placeholder blank to be "EAT ME" instead of "??? ??" (3,2) _[EAT ME]
The length of a placeholder blank (the number of letters that it can hold) will be the maximum of the number of underscores and the length of the gray placeholder text (from the enum or from the overridden text).
Just like the placeholder blanks that appear in orphan clues, these forced placeholder blanks will also be accompanied by "copy-placeholder buttons" (that looks like [⇲]), unless disab
