The basic idea is pretty simple: present a word, and ask users to retype the word as fast as possible. Highest score to the fastest typer, with some penalty for spelling errors.

While this can be a funny game in itself, we also collect the data:  presented word and retyped word together with the age range of the user (anonymously, of course). This will - if the game is successfull - over time collect a large set of natural misspellings. The main purpose of the game, from our point of view, is thus to collect real misspellings, which we then can use to improve our spellers and correction algorithms.

To be successful, the game needs to:
* have a low barrier to entry (ie it should be easy to start playing)
* look inviting
* let users see how they fare (ie have some sort of top score list, + personal score)
* present new words all the time (ie with a very long time between each time the same word is presented)
* be located on a page frequently visited by many users
* support all the languages we support
* have a user interface in all languages we support

!!!Integration

* the browser part needs to be easily integratable in other pages
* on the server it should use one transducer for each supported language
* it needs to store the collected data in easily parsed files, preferably text files, one file pr language
* the server should be able to support several instances of (html pages with) the game simultaneously
* some persistence should be stored in the browser (e.g. in a cookie), to recognise a certain user from one gaming session to another (to e.g. be able to improve one's position on the high score list)

!!!User interface

The user interface is pretty simple, essentially a square split horisontally in three:

{{{
+-------------------------------+
| Settings: GamingLang   UILang |
+-------------------------------+
|                               |
|  * high score list            |
|                               |
|                               |
|                               |
+-------------------------------+
|                               |
|                               |
|    Gaming area                |
|                               |
|                               |
|                               |
+-------------------------------+
}}}

!!Settings

There are two settings:
* GamingLang = Gaming language - determines the language for the speed typing game; this list should be easily expandable, basically by adding one more hook for the required transducer
* UILang = User Interface language - the language of the user interface elements of the game; this should by default be selected based on browser preferences, or language of the host site (ie if the game is included in a Facebook page, use the language the user has selected for Facebook), but it must be possible for the user to override this

!!High Score List

The list is gaming language dependent, ie there is one list for each gaming language. It might also give a better user experience if the high score list also follows the age span for the user, so that one competes with people roughly on the same level. If so, the age span needs to be displayed on the top of the high score list.

!!Gaming area - registering

The gaming area has two views: a register view, and the real game view. One must register before being able to play, but registering is very simple:

* type in a user id (just a random string) - a generated suggestion should be available, which can then be accepted without further action
* specify the correct age range
* click a button "Start playing"

The __user id__ is used to give some identity to the entries on the high score list, and should be stored in a cookie, so that the same user is recognised from one game session to another.

The __age range__ list should be as follows:
* < 15 (pupils)
* 15-20 (high scool-ish)
* 20-30 (students)
* 30-45 (adult/experienced writers)
* 45 <  (in the Sámi area, this is roughly the lower age of those that have not received education in writing their own language; obviously this age goes up each year)

The selected age range should be stored both in a cookie, and together with the collected data. The hyphothesis is that typing speed and spelling errors will vary considerably between the groups (possibly except between 20-30 and 30-45), and associating age with the data can be potentially very useful.

!!Gaming area - playing

{{{
|                               |
+-------------------------------+
|  Personal score       ID+AgeR |
|  -------------------------    |
|  Given word               (?) |
|                               |
|  __TYPE_HERE________  ENTER   |
|                               |
+-------------------------------+
}}}

Each element described:

* The __(?)__ button should give a popup with some simple instructions/help.
* __Given word__ is the word to be typed in, coming from Divvun/GT transducer.
* __TYPE HERE__ is the input area
* __ENTER__ is the enter button (but the user should really just press return if (s)he wants to get decent scores)
* __Personal score__ is the last or best score of the user, preferably both
* __ID+AgeR__ is the user name/ID and age range of the user

!!!Score calculation

Since this is a speed game, registering speed is essential. The speed is calculated from the time the user press the first letter in the input field, until the user presses Enter (on the keyboard or using the mouse).

The speed is calculated as characters/second.

When the user presses Enter, three things are sent to the server:
* the given word
* the typed string
* the typing time

From this, one can calculate:
* speed as characters/second
* misspellings as editing distance between given word and typed word
* misspelling rate as number of misspellings/characters

The final score is then calculated as speed minus misspelling rate. This score is sent back to the browser, and presented to the user.