Tools and scripts

VASTT for translation
ffd.py plugin written for import/export to VASTT's native XML format
QQC is used for editing support
Subversion is used to manage and share the work

Attached files

Supported game version

The current "standard" edition, comes on a single DVD in a standard movie-style case
- 18+ content
- Unvoiced
The original 2-CD version (unconfirmed)
- You can apparently use the attached update patch (lw02_patch_se100.exe) to bring it in-line with the standard edition
- 18+ content (TBC)
- Unvoiced (TBC)

File format

Will document it here, I think zalas did that work

Translation

AstCd2 solo'd it

Editing

This is all furinkan's, performing grammer/spelling, as well as bubble positioning (see notes in the Game Engine section).

QQC! and VASTT

QQC! is a custom webapp written by furinkan for editors to report translation issues.

Interface

The interface is focused on making it very fast to isolate the problematic line, enter a description of the problem, then submit the report
Editors are encouraged to offer a suggested improvement
There's an option to attach a single screenshot if the error is difficult to describe

Usage assumptions

QQC! supports a scenario with a single translator, and multiple editors
- Multiple translators are possible, but not necessarily useful
The privilege model is similarly simple. The translator and editors can all submit new reports, and see existing reports
The translator can also dismiss reports once they've been dealt with
- There's no function to document what was done, dismissing a report simply removes it from view

Gaining access

QQC! is a webapp: https://qqc.meidokon.net/Quartett/qqc_report.py
Access is granted through the use of client-side SSL certificates
- This provides a convenient authentication and access-control mechanism in one. Once setup, there's no passwords to remember
furinkan controls access to QQC!, you'll need to get a certificate issued, and be granted Editor or Translator access. Everything should Just Work once you install the certificate in your browser
Find out how to setup your certs once furinkan has issued you one

Backend and updating

QQC! keeps an index of all lines in the scripts, so they can be found quickly when an editor needs to report an error
Once a correction has been made (usually the result of a report), the index will need to be updated with the corrected lines
furinkan has a script for this, it's just a python script that looks for newly updated files in SVN, then injects them into the index
This should really be automated, eg. an svn post-commit hook

Bubble positioning

This forms the bulk of the editing work. By nature, Japanese text is more compact than English, so the bubbles are smaller. Once translated, the bubbles need to be resized and repositioned.

In most cases, the resizing can be automated thanks to a feature of the engine. The repositioning however requires actual work. The editor plays through each script correcting the text as needed (using QQC and VASTT), repositioning the bubbles, and adjusting the direction of the bubble-tails as needed.

The bubble adjustments are stored as a big lookup-dictionary in the compiler scripts. The editor will typically have a few windows open to do their work:

The game itself
VASTT with the current script loaded up
A text-editor with the python compiler scripts
- It's recommended to use a good programmer's editor, as it'll help reduce the number of syntax errors you make. I use ConTEXT because I'm lazy and haven't investigated anything better
A shell window with the script-dumper helper running; this is needed to find the correct line numbers to enter in the lookup tables
- This is quite perverse because it means you need a linux-type machine, but it works well. The script-dumper shows the decoded "tokens" in pretty much the same format as the orignal script the developers would have written
- The command you use is something like
```
qqc_tools/unlex.py originals/4A999901.tkn | less
```
- You'll find the line-number of the spoken line in VASTT, then find the corresponding line number of the bubble coordinates, usually 2 or 3 lines before the spoken words
A window with the batchfile (Makefile), ready to compile and archive the edited scripts
A shortcut to running Quartett!, you'll be closing it and re-launching it very frequently
A browser window with QQC!, you'll occasionally be reporting translation issues

Game engine

Quartett! is unique in that it uses Littlewitch's Floating Frame Director engine. The game plays out much like a comic book, and the bubbles appear one after another in sequence. The FFD engine also allows a lot of flexibility in exactly how things are presented. The scripting language looks a bit like C++, but it literally works like a script. It's imperative and pretty easy to follow.

The scripting language has a limited set of basic functions, such as setting up bubbles/images/lines of text, then manipulating them. The most important aspect of this is the speech bubbles.

Bubbles are assigned width and height values, and placed on the canvas with (x,y) coordinates
The canvas is 800x600, with (0,0) in the top left corner
The bubble is anchored according to the logical top left of the bubble (most bubbles are rounded, so this is something of a guess)
Most bubbles will have a "tail" pointing towards the speaker
The direction is specified in degrees, starting from 0 degrees at (1,0) (ie. due east) if you imagine a unit-circle on the cartesian plane

XXX: insert an example sketch here to demonstrate how it works

Spellchecking

furinkan has hacked up a little command-line tool based around PyEnchant, a spellchecking library.

Written in a hurry with an emphasis on Just Working (enough to get the job done sooner rather than later). enchant.checker.CmdLineChecker is a ready-to-use interactive spellchecker for larger blocks of text. Wrapped in a little bit of smarts, you feed it a Quartett! script, and it prompts you with potential errors.

Has a "local dictionary" feature for holding words that the system dictionary doesn't know about. When prompted for action, you have a few choices, as documented in the official tutorial.

i: ignore this word
I: always ignore this word
a: add word to personal dictionary
e: edit the word
q: quit checking

I don't know how "edit the word" works, I prefer to edit the script myself using VASTT.

Building translated files

furinkan wrote a few python scripts to handle this. They take the native VASTT files, coupled with the original binary script files, and produce a translated binary script file.

Testing the work

You'll have a batchfile that does all the hard work (if only windows had Make, sigh)

"Compile" the translated scripts according to a glob
Jam the scripts into an FFD archive
Copy the resulting file to the game directory