One feature of Simple Sudoku is that it automatically shows the candidates for a square. This takes away the tedium of having to manually eliminate the obvious candidates, like 9′s in a row that already has a 9. Still, the candidates sometimes look like a mess.
Simple Sudoku solves this with a feature called candidate filtering. What it does is highlight all squares that might be a particular number, e.g. all possible 9′s. This makes it easy to see, for example, when there’s only one possible 9 left in a column.

Candidate filtering is good for slightly more advanced deductions, as well. Let’s say you have one 3×3 cell where all the possible 6′s are in the same row. You can eliminate 6 as a candidate from the rest of the row. Or, visually, you can do this:

There is an advanced Sudoku technique called coloring or linked candidates. It involves forming a chain of candidate squares where you know that some of the squares contain the candidate, and the rest do not. However, which set of squares contains the candidate is unknown at the start. The technique involves “coloring in” the candidate squares in an alternating pattern, e.g. with blue and pink. If any pink square contains the number, then all pink squares will contain the same number, and all blue squares will not. The reverse is true as well.

The technique can be difficult to understand from a description, but in Simple Sudoku, it’s really easy to do. Filter candidates so that, say, all 5′s are shown. Find a place where there are only two 5 candidates in a row, column, or large cell. Color one of the squares pink, and one blue. Then continue the chain as long as you can find links where there are only two 5′s. If you see two pink neighboring each other, then the pinks don’t have 5′s and the blues are the ones with 5′s.

Coloring turns a painstaking deduction problem into a simple pattern-recognition problem. Going through the chain of logic step-by-step takes a while and can be prone to error, but marking squares as colors is easy. And on the computer, it’s easily reversible. I’ll often start coloring squares even when “simpler” deductions can be made because in Simple Sudoku, coloring is a simple deduction.

In general, as you get better at a type of logic puzzle, you start recognizing common sequences of deductions. Internally, you formulate a series of rules: “If this, then do that.” What Simple Sudoku and other good puzzle interfaces do is 1) Make it easier to notice common deductions, and 2) Make it easier to spot the “If this” part of your rules.

When you code scan something, it adds a page to the book that describes the object and shows its “codes”. Codes are blocks of different shapes and sizes that represent various qualities, such as Fire, Snake, or Justice. The codes are arranged on a grid (the “mental map”), and you can “rewrite” the codes by swapping them around.

The Sword page and the 4 hot-swap code slots.

You’ll find item bases scattered through the game, and you modify them by swapping codes. The above picture shows the Sword base with one Fire code, making it a “Fire Sword”. There are also recipes for specific items, e.g. the set of codes you’ll need to make the Sword into a “Champion Gladius”.

Making the recipes is a painstaking process. You have 4 slots of “holding” space to transfer codes between pages — all other codes have to be on a page. So if you decide you want that Champion Gladius, you have to:

1. Look through all of your pages to see if you have enough codes to make it
2. Empty the Sword of codes not in the recipe and dump them on other pages
3. Transfer the desired codes onto the Sword, 4 at a time

Like I said, painful. I wound up entering a list of all my codes and their pages into a spreadsheet with columns for code type, size, and which page it’s on. Basically, a database. For step 1, I sort the columns by code type and size, and look through them to see if I have sufficient codes. Then comes the transfer process.

There are two issues with transferring: keeping the database synchronized, and locating the pages referenced in the database. The first is just tedious. The “proper” way would be to update the database for each transfer between page and hot-swap bar, but I usually skip recording the transfer to the swap bar and just change the code’s location from source page to destination page.

When attempting to locate pages, I often find myself wishing the book were a densely-linked website.

The Table of Contents

There are a few ways to navigate the book:

1. Click on either of the bottom corners (where the page numbers are) to turn the page in that direction. Hold down the corner to make the pages keep turning until you let go.
2. Click on one of the labeled buttons at the top of the screen: “Index” goes to the table of contents, “Player” goes to the player info page, “Data” goes to the save/load screen, and “Map” goes to the map of the current area.
3. The Table of Contents page has a list of links to broad sections, like “Monsters” and “Weapons”. The first page of each section is a table of contents with links to sub-sections, e.g. “Sword” and “Bomb” for Weapons.
4. The four colored buttons at the top are “Spirit Bookmarks” which you can place on any page that doesn’t already have a bookmark. Clicking the button will take you directly to that page. By default the Spirit Bookmarks are placed on the pages of their respective spirits.

Some issues:

1. When holding down a corner to keep flipping pages, the pages don’t load until you let go — all you see is a blank page. I can understand not loading all the information, but at least loading the page titles would have been helpful.
2. There’s no button to go to the section table of contents from a page.
3. Pages don’t indicate which subsection they’re in. This is largely an issue with the monsters, since it’s not immediately obvious whether something like the “Wood Bone” monster is a “Construct”, “Undead”, or “Humanoid”. (The number of monsters doesn’t help.)

So what would my ideal user interface for this system look like? There would be more views of the data, for one:

1. Text-only lists of pages (items, codes, monsters, etc.), with options to sort alphabetically or by page type. Entries would link to the page.
2. Lists of available codes, sortable by code type, size, or assigned page. A bonus would be small images of the code blocks, since they have different shapes.
3. Breadcrumbs or tree-style navigation, so you can always see what category a page is in and quickly navigate up and down the hierarchy.

Here’s a mockup of one way to make code browsing more pleasant:

An item page with an added pop-up code browser

This is an item page. I’ve added a window with a scrollable list of available size 3 Silver codes. Breadcrumbs let you go up to search for a different size of Silver codes, or a different code type altogether. Each entry in the list states what page it’s on, and shows the shape of the code. The idea is that you can drag a code straight from the list onto the page you’re viewing. There’s still a swap area so you can rotate the code before placing it.

As for browsing, I think the game would benefit from (at least) one level of “go back”, so you can always return to the page you were just looking at. With that functionality available, clicking on a page name in the code browser list should take you to the page. This is useful if there’s more than one code of a particular type on a page and you’re wondering which one to take. Then you can just click the back button and go back to the page for the item you’re trying to assemble.

And here’s a mockup of page browser:

I’ve added a page browser window that pops up like the code browser. It’s a simple, scrollable tree-style navigation list. There are headings for the major categories; double-click one of them, or click on the “expand” icon next to it, and the list will expand to show the subcategories. Double-click a subcategory or click its “expand” icon, and it’ll show a list of pages. Click on a page name to go to that page.

This strays pretty far from the book interface model that Avalon Code is trying to use, but you do a lot of things with the Book of Prophecy that you would never do with a real book. If I did want to stick closer to the book model for browsing, just two improvements would go a long way:

1. Alphabetize the pages within categories. Dictionaries and encyclopedias are easy to browse because they use a well-known, easy-to-remember ordering. You know if you open a dictionary to the middle you’ll be in the M’s. I do wonder if the pages have a similarly meaningful order in the original Japanese, that wasn’t carried over during the localization.
2. When flipping pages by holding down one of the corners, show page titles. The flipping-pages action is similar to “leafing” through a book, but with no information during the page-flipping, it’s like leafing through a book with your eyes closed. Sure, you might get to the right page if you’re lucky, but it’s more likely you’ll have to stop and peek several times.

In the end, Avalon Code has some pretty neat game elements, but I can’t help but wish for a better interface.