• Quartett

http://charlotte.is.moelicious.be/

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)

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