Increase the window size a bit

Display all unfound, obscure words in blue at the end of a puzzle.

Don't display slots for target words less than 5 letters long

It was just too overwhelming to see dozens of 3- and 4-letter words
every time. It's now actually feasible to try to get all the words
when you've only got the 5-, 6-, and 7-letter words to attempt.

Switch from 6-letter rack to 7-letter rack

Fix typo in copyright/licensing blurb.

Ensure that there's at least one full-length word that's not obscure

Reduce number of tiles to 6 for a slightly easier game

Remove penalty for not guessing obscure words.

The list of obscure words is in obscure.txt. It consists of words
that are also in words.txt, but for which blanks lines will not
appear on the game board. If an obscure word is guessed, it will
still be considered valid---a new space for it will be inserted
into the game board and the word will be displayed in green.

Many thanks to Kevin Atkinson and Alan Beale for providing the
2of12inf.txt list from which an attempt at identifying 'obscure'
words in OWL2+LWL could be identified. The 2of12inf.tx list was
obtained from:

http://wordlist.sourceforge.net/12dicts-readme.html

and details on its copyright and license status are included in
COPYING-wordlists.

dict: Fix bug in for_each iterations with no max_length limit

We've been using an idiom of min_length == 0, max_length == 0 to
indicate no length limit, but this has apparently been broken since
the rework of the for_each interfaces that introduced this.

Ensure that there is at least one word using all letters in the rack.

Fix to not give hints by putting answers found so far in their alphabetical position.

Instead all found answers now appear alphabetically before the blanks
corresponding to all unfound answers.

Part of implementing this was adding new of_length interfaces to dict
in place (or in addition) to the previous by_length interfaces. The
new interfaces are much more useful, (allowing length-limited queries
without any implicit looping).

Allow a new game to be started by pressing Enter after Control-C

This took a fair amount of refactoring, but things are generally much
cleaner now, (even if the rack_t structure has long since outgrown its
name---it should be game_t now or so).

Add display of all missed words with control-C

rack-fancy: Ignore any blank tiles drawn from the bag

Restrict solution to words of 3 or more letters

Switch to mono font for solution and give it a bit more room

Cleanup code to remove file-scope the_rack

Fix refresh bug for solution widget

All we were missing was a simple call to goo_canvas_item_simple_changed

Only show solution words after found (with refresh bug)

Initially, all words shown are just blanks. Then after words are
found they will be drawn on the next update, (which is not yet
being triggered).

Pass the dict entry flags to the for_each callback

Add verification of the word

Currently just printing to stdout, no yet providing graphical verification.

Add keypress handler for Return

Currently just sends the guessed letters back to the rack.
Does not yet do any checking of the guess.

Add display of solution to the canvas

This is currently displaying all possible words, (which is kind
of pointless for actually playing the game), but is useful
progress worth recording.

dict: Add dict_for_each functions

These new functions allow the caller to pass a callback to act on
all entries within a dictionary.

Abstract tile-specific code out of demo-item.c

We now accomplish painting by simply passing in a callback
function to do the painting. This will allow the single item
class to be shared for all canvas items.

Add key press handling (letter guessing and backspace)

Add back randomization

Add a 3D "etched" effect to the lettering.

Fix randomizing of letter positions to never end up on top of each other

We had some confusion over who was in charge of the letter position,
(whether the matrix as manipulated by the core animate code, or
whether private fields in our demo-item structure). We now do all
positioning based on the matrix. As a regression, animation is now
disabled.

Add letter scrambling animation to rack-fancy

Currently this is triggered by clicking on a letter. Should
switch this to use the spacebar instead soon.

Make rack-fancy select and display a rack of 7 random letters

The letter display uses a very cheesy effect with a radial gradient.
I'll have to come up with something reasonable later.

Abstract subanagram code from rack into new bag.c

This will allow for some simpler sharing with the new rack-fancy

Abstract bag code from rack into new bag.c

This will allow for some simpler sharing with the new rack-fancy

Add shell for rack-fancy (graphical version of rack)

So far, this is basically just a cleaned up version of
simple-demo from goocanvas/demo.

Report the time limit expiration, but don't end the game.

Add the ability to specify grid letters on the command line.

Add grid5 game in addition to grid4

Print the per-word statistics at the end of the game.

grid: Generalize to allow either 4x4 or 5x5 grid.

Split grid into main program in grid4.c and library functions in grid.c

grid: Rename "board" to "grid"

grid: Don't consider 2-letter words as valid.

Don't print empty found/missed sections

Prefer capital letters in puzzle presentation

Add new rack game as well

Add new drill2 game for drilling 2-letter words.

Fix games wiithout time limit. Don't add empty repsonse to history. Don't expect puzzle to end in newline.

Move the main game logic from grid.c to new word-game.c

The idea here is to make it very easy to have many games
which are basically variations of the same theme.

grid: Add the ability to print stats at any point in the game.

Print board before result summary

Move IS_WORD flag from trie to dict layer

Add -Wmissing-prototypes and add a bunch of missing static qualifiers.

Move private portions of dict from dict-impl.h back to dict.c

This is the punch line in the recent series of commits which removed
trie_t and string_t code from grid.c. We now finally have a nice,
clean dict_t interface for new programs to use.

Remove dependence on string_t functions from grid.c

Add printing to dict interface. Breakup grid prints by letter count.

Complete the dict layer by adding dict_cursor_t and dict_entry_t

Some might argue that this is a gratuitous layer and that it
hides the elegance of the trie implementation where pointers
to the entire structure and pointers to a single node are
equivalent.

But I think the elegance is still all there in the implementation,
and I think there's some real benefit in making separate notions
of the entire structure (dict_t) and a pointer to a single element
for navigating (dict_cursor_t) since the operations one might want
to perform on one or the other are entirely separate.

With this change, the only remaining dependence of grid.c on any
trie or TRIE symbols is a single flag definition (which I want to
put entirely in grid.c) and the print functionality.

Begin to wean grid.c away from trie and toward dict.

Eliminate useless layer of dict wrapping trie.

Hide implementation details of dict in dict-impl.h. Add automatic dependency computation to Makefile.

Break wordgame.c into dict.c and grid.c in preparation for more programs

Ignore *.o and *~ files.

Add input, verification, and scoring.

I think the game is basically complete at this point.

Add board and solver.

Initial comit of wordgame