Nathan Sanders : Journal

Final Fantasy X is about two things: story and boss battles.

The story is amazing–on the surface it’s (finally) about as complex and interesting as a well-done anime. This contrasts with the rest of the game, which is stripped down and simplified to support the story. Towns are few, weapons are really accessories, and freedom is limited.

But the story really grips you. I’m not certain why, although I have some ideas. The story permeates and shapes the whole game. As you travel through the mostly peaceful countryside, you can’t enjoy it. The impending doom is too strong, and you must journey forward. In this respect, the amazing linearity is a strength instead of a weakness. There is nowhere to go but forward, and that with all haste.

As the journey continues and the story develops, even the temples that you learn to accept at the beginning become sinister and the haunting and beautiful melody of the fayth no longer inspires–it signals danger. Maybe that’s why the story connects better than a movie; you have more time to digest the Way Things Are, and when Things change, it’s more disturbing. Or maybe it’s the fact that you connect with your characters after guiding them past so many dangers.

The dangers. That brings us to the boss battles. Random battles are mostly just a game of match-player-with-enemy that’s interesting for 10 minutes or so. But the bosses are actually interesting. The turn-based battles use an action point system much like Final Fantasy Tactics, and few bosses can be beaten with the standard configuration of two tanks and a healer pressing A repeatedly. I mean, X. The bosses are actually tough.

Too tough, actually. I am ashamed to admit this, and I almost didn’t write this review, but I didn’t actually beat FF X. I got stuck fighting Yunalesca four or five bosses before the end. I was demoralised; I’d been scraping by the last 5 hours fighting progressively harder bosses, and the landscape didn’t look any friendlier ahead. So I gave up. I turned to youtube (friend of the people) and watched some overpowered party squish the rest of the bosses so I could watch the rest of the story.

I may have missed a more moving emotional experience, or something, by letting somebody else play the game while I watched. But I thought the ending was still pretty good. And the story actually looks better on the small screen, due to technical problems (more on that later).

So do the bosses get in the way of the story? I don’t know. I look at FFX-2 and FF12 and wonder if their gameplay could support such a story, and I doubt it. I think such a strong story has to maintain its focus and FF X nearly gets there with its focus on simplicity. But with simplicity, missing the mark means failure is complete; the game really isn’t fun except for the grim satisfaction of putting away a difficult boss. When you get stuck on one that’s too hard, there’s nothing else to do but a dismal grind that probably won’t help much anyway.

Some technical notes:
Technically, the game hasn’t aged well. I have to wonder why the environments are so sparse when there’s usually only one moon-walking human on the screen. It’s probably because the designers blew so many polygons on the character faces. Nonetheless, the faces don’t animate well. They don’t show emotion much at all. Animation in general is bad–everybody has some kind of palsy and movements are jerky, sudden parodies of the emotion they are supposed to depict. The voice acting is great, but the timing is off just enough sometimes to mess up the feeling of conversation.

And now for something completely different: FFX-2 impressions.

Actually, FFX-2 is completely different than FFX. The only similar part is the voice actors and locales (though the graphics have improved a bit). Everything else is different. The battle and levelling system is a sped-up, simplified version of FF5. Bosses are pushovers and normal enemies are harder. Instead of complete linearity, you get missions, which, while not completely non-linear, is a lot more than most Japanese RPGs. And the story is like Saturday morning anime. Seriously. It’s really that bad.

It’s pure, weird fan-service. And it’s a lot of fun. I wonder how many fans of FFX like FFX-2 despite themselves and won’t admit it.

So when I was almost done with Final Fantasy 10, the last part was such dull going that I started to think wistfully of FF12 and how much more fun it was. So much more fun that it may not have been a “real Final Fantasy".

Anyway, the voice acting with accents was a nice touch of FF12, too. The system was a surprisingly consistent mapping of English dialects of the world, though the actors themselves didn’t get the accents quite right, except for American of course.

The viera accent was weird but I haven’t placed it. There was some funny devoicing that sounds vaguely Slavic but no palatalisation. Oh well, final devoicing pops up a lot in English dialects, probably it was just the voice actress trying to sound ‘foreign’. Some ridiculous forum discussion suggests Icelandic or Old Norse, which doesn’t sound quite right to me.

You’ve probably heard me say that if I had all the time in the world, I’d like to learn Dutch. I don’t, so it probably won’t happen. But if I had twice all the time in the world, I’d like to learn Dutch and Korean. Actually, I have quite a list.

1. Dutch
2. Korean
3. Japanese (properly)
4. A Mayan language of some kind
5. Russian

(German still isn’t on the list, and probably should be. Oh well.)

Note that this isn’t titled “Search for the perfect mouse” because I really haven’t started searching yet. But I will eventually move my current Microsoft mouse to my super-gaming-hand-me-down laptop I’m buying off my sister and brother-in-law for Christmas.

Anyway, I really like the Intellimouse Optical 1.1. The only thing I’d change (after a couple of years of using Apple mice) is adding back the asymmetric left/right button. The left button should be larger. But this went out of fashion (possibly for good reasons) almost a decade ago so I probably won’t get what I want.

1. Large
2. Wired | light
3. Glowy
4. Two Mac OS-compatible side buttons, preferably on opposite sides
5. Clicky scroll wheel, not the plastic-smooth or metal-smooth of high-end modern Microsoft/Logitech mice.
6. Cheap. Unless it’s somehow super awesome, $30 is my limit.
7. Left button larger. Do they even make these any more?

There are some strange requirements up there. Wired or light should be fairly obvious–I don’t play FPSes so I just care about not tiring out my hand. I have tried side buttons on the same side, but I’m not used to them. Same goes for the clicky scroll wheel. Well, I used Apple’s semi-smooth wheel/ball for a year and didn’t like it, so I’m pretty sure I want an old-style clicky one. Left button larger is just because I don’t right-click much in Mac OS and I got used to left-clicking with two fingers.

I want Glowy because of Steve Jobs’ aversion to status lights. My iMac gives no visible indication whether it’s really asleep or the screen is just off. That wouldn’t be a probem if sleep worked 100% of the time. But Safari prevents the machine from sleeping after it’s visited Youtube or any Flash-video site. So having a glowy mouse serves as a proxy status light, except that it’s off when the machine is off instead of the usual inverse. Again, overly glowy mice are generally a sign of bad taste, so even Microsoft has scaled back on it recently. My 1.1 version of the Intellimouse Optical, though, proudly flaunts its red glow.

Anyway, this is basically a brain dump, but if you have buying suggestions or reasoned critiques of my criteria, please let me know.

I promised some examples today. Let me know if it’s still not enough. I’m in the middle of this work so everything is still kind of muddy. Like I said before, if you want to cite me, you’ll have to find out how to cite blog posts…

OK, let’s start with the final output. This:

main = mapM_ (putStrLn . format . node) (greedy diffs)

produces this:

• [+Voice] → [-Voice] : 19.857142857152
• [Coronal] → [Labial] : 17.71428571426
• [+Atr] → [-Atr] : 17.49999999999501
• [-Voice] → [+Voice] : 10.64285714286
• [+Contin] → [-Contin] : 5.785714285716
• [-Atr] → [+Atr] : 5.6428571428576
• [-Back] → [+Back] : 5.499999999997
• [+Son] → [-Son] : 4.214285714283
• [+Cons] → [-Cons] : 2.714285714283
• [Dorsal] → [Coronal] : 2.5000000000030003
• [+Low] → [-Low] : 2.0
• [-Contin] → [+Contin] : 1.714285714286
• [-Son] → [+Son] : 1.714285714286
• [Labial] → [Coronal] : 1.5
• [] → [] : 1.5
• [+Lateral] → [-Lateral] : 1.357142857143
• [-High] → [+High] : 1.357142857143
• [] → [] : 1.35714285714
• [Coronal] → [Dorsal] : 1.2857142857146
• [-Low] → [+Low] : 1.214285714286
• [+Approx] → [-Approx] : 1.0
• [] → [] : 0.857142857143
• [Dorsal] → [Labial] : 0.5
• [+Strid] → [-Strid] : 0.5
• [-Anterior] → [+Anterior] : 0.428571428571
• [+Back] → [-Back] : 0.357142857143
• [-Approx] → [+Approx] : 0.357142857143
• [] → [] : 0.214285714286
• [+Round] → [-Round] : 7.14285714286e-2
• [-Round] → [+Round] : 7.14285714286e-2

Here’s the code for format. The important thing to notice is that, even though a forest (a list of trees) is produced by (greedy diffs), main only outputs the root node’s value in an attempt to summarise the results. I’ll show you the contents of an individual tree in a bit.

format :: Rewrite -> String
format (diff,freq) = format2 diff ++ " : " ++ show freq
format2 :: Set.Set (Feature, (Value,Value)) -> String
format2 = formatRewrite . both (intercalate " "  . map formatFeature) . unzip .
          map (\ (f,pair) -> both ((,) f) pair) . Set.toList
both f (x,y) = (f x, f y)
formatRewrite (str,str') = "["++str++ "] -> [" ++str'++"]"
formatFeature (f,Plus) = '+' : show f
formatFeature (f,Minus) = '-' : show f
formatFeature (_,v) = show v

As usual, this isn’t the greatest code in the world. For instance, both looks like monad lift to me, if pairs are a monad. Anyway, it’s fairly straightforward text processing; the only inobvious rule is that binary features are display as “+feature” or “-feature", while privative features just show their feature value, since the feature name itself is technically just there to satisfy the type system. (Though it is in fact useful for documentation.) You will notice that I have gone disgustingly overboard on the type annotations. I wrote them during development to help me remember what type I was manipulating and unfortunately could not stand to delete them. It’s like semi-colons in Javascript. Oh well, just to remind you here are the types we’re working with here:

data Tree a = Node a (Tree a) (Tree a) | Leaf a deriving (Eq, Ord, Show)
type Rewrite = (Set.Set (Feature, (Value,Value)), Double)
type Diff = Tree Rewrite
node (Leaf a) = a
node (Node a _ _) = a

OK, let’s look at the first diff and then compare it to the output, the first tree:

*Main> head diffs
Leaf (fromList [(Place,(Coronal,Labial))],11.0714285714)

So before processing, the first tree is a leaf (they all are) that rewrites Coronal to Labial 11.07 times on average. That matches the second line of output, which finds that the combined total for Coronal to Labial is 17.71. So the rewrite picked up an additional six and half points or so from diffs that rewrite other features besides place. Let’s look at the tree. (The Haskell pretty printer failed to Just Work so I manually formatted it, this is not real output.) The root data is what is displayed in the list above.

*Main> let output = greedy diffs
*Main> output !! 1
Node ([Coronal -> Labial],17.71)
     (Node ([Coronal -> Labial],17.21)
           (Node ([Coronal -> Labial],16.71)
                 (Node ([Coronal -> Labial],15.71)
                       (Leaf ([Coronal -> Labial],11.07))
                       (Leaf ([Coronal -> Labial,(Lateral,+ -> -)],4.64)))
                 (Leaf ([(Contin,+ -> -),(Approx,+ -> -),(Son,+ -> -),Coronal -> Labial],1.0)))
           (Leaf ([(Voice,- -> +)),(Contin,+ -> -),Coronal -> Labial],0.5)))
     (Leaf ([(Contin,- -> +),(Approx,- -> +),Coronal -> Labial],0.5))

Well, it’s still pretty noisy so I’ll summarise: the tree is mostly left branching, picking up most of its weight from that first diff I showed you, a plain Coronal to Labial change. The other main contributor is a change from Coronal to Labial that includes a lateral ([l] in this case turning into [w]). The other three leaves only contribute a total of 2.0 and are a giant bag of changes, so they are probably just noise.

As an aside, the linguistic analysis is pretty simple. Changes from coronal (ie [tdsznrl]) to labial (ie [pbmw]) are quite common in developing speech, especially for nearly deaf kids, because you actually do something visible with your mouth when you say [p] or [w]. Specifically, the data I’m working with here has another trait common to developing phonologies, production of liquids (ie [rl]) as glides (ie [wy]). My previous work picked up on this smaller [r → w]/[l → w] process quite well but missed this larger [Coronal → Labial] process. Which is cool.

Anyway, back to the code. Do you see how this tree is made up from the leaves in the original diffs? The 11.07 [Coronal → Labial] rewrite was high-ranked in the diff list and so merged early on with the 4.64 [l → w] rewrite. Next the 1.0 rewrite merged, trailed by the two 0.5s. However, all have in common that they have a [Coronal → Labial] somewhere.

The problem with this greedy approach is that it only picks some of the rewrites to highlight, based on the rewrites that are individually most prominent. For example, the example tree sorts the rewrites by [Coronal → Labial], but [+lateral → -lateral] is an important process in this phonology as well. Maybe it’s more distributed across segment types, though, and thus doesn’t start off so highly ranked in the diff list. I’m not sure how to fix the greediness problem; it will probably require a much slower and more complete algorithm.

This may not be a problem in practise; the highest-ranked change ([+Voice → -Voice]) in the output starts out at barely half the value of the second-ranked change we’ve been talking about. And its tree is almost 3 times as big, indicating that it was able to pick up support for a lot of low-ranking rewrites that happened to share that common devoicing feature.