One of the really great things about WPF is its composable UI structure and dynamic layouts — the ability to replace one set of controls with another on the fly as things happen (eg. when something is selected by the user) and have everything adjust accordingly. The data binding engine is one of the most important elements in this, but closely linked to it is the templating engine.

In this post I’ll cover a little bit of background behind DataTemplates, but the primary focus is going to be on the DataTemplateSelector — what it is, why you might want to use it, a way to make it easier to use, and finally a better alternative to using them at all.

So, first: DataTemplates. I’m not going to go into too much detail here (there are better references around for people who want to know more); suffice it to say that they are a means of defining a set of controls (or other UI elements, such as text or pictures) which somehow represent a particular model or presentation layer object. Sometimes they create controls that allow the user to edit the data object (via data binding), other times they’re purely for display; often a mix of both.

Many controls in WPF can be linked to DataTemplates to control the display of their contents; the most commonly used is the ItemTemplate property of ItemsControl (or its descendants, such as ListBox and ListView). And most commonly, the link is made directly, like so:

  <Window.Resources>
    <DataTemplate x:Key="FooTemplate">
      <WrapPanel>
        <TextBlock Text="Foo data: " />
        <TextBlock Text="{Binding Data}" />
      </WrapPanel>
    </DataTemplate>
  </Window.Resources>
  ...
  <ListBox ItemsSource="{Binding FooList}" ItemTemplate="{StaticResource FooTemplate}" />

This is a very basic example showing how to link a presentation control directly to a named template; it’s probably the most common type you’ll encounter in WPF code. But this is a bit restrictive — it only lets you define one template per collection. This is ok if your collection is uniform: it contains the same types of data and that data all needs to be rendered the same way; and of course that is indeed the most common case. But what if you have a heterogeneous collection, containing multiple types of items? WPF supports that too — if you don’t specify a template specifically, it will look for a template corresponding to the type of the data item:

  <Window.Resources>
    <DataTemplate DataType="{x:Type app:Foo}">
      <WrapPanel>
        <TextBlock Text="Foo: " />
        <TextBlock Text="{Binding Data}" />
      </WrapPanel>
    </DataTemplate>
    <DataTemplate DataType="{x:Type app:Bar}">
      <WrapPanel>
        <TextBlock Text="Bar: " />
        <CheckBox IsChecked="{Binding State}" Content="Active" />
      </WrapPanel>
    </DataTemplate>
  </Window.Resources>
  ...
  <ListBox ItemsSource="{Binding FooList}" />

A useful tip to know with this technique is that WPF starts searching for templates at the container itself (in this case, the ListBox) and works its way out to its parents; since any control can contain resources, this means that you can define several templates for the Foo type, and have them chosen by context. (It’s first to last, child to parent, and the first matching template wins, so if you want to define templates for derived classes and have a base class template as a fallback, the base class template should either be listed last in the same scope or listed in one of the parent scopes.)

Lists aren’t the only way to use templates, of course. One of the most handy (and seemingly overlooked) controls is the ContentPresenter, which is the “basic presenter” of the template system. You can use it wherever you have a single item of content to present:

  <ContentPresenter Content="{Binding MyFoo}" ContentTemplate="{StaticResource FooTemplate}" />

And of course, it also supports the DataType-based lookup as well.

Another useful ability of the ContentPresenter is that it can be used to “chain” templates, which is particularly handy if you have something in common between your templates (eg. if you have a base class with two derived classes, and want to show data from all three):

  <Window.Resources>
    <DataTemplate x:Key="BaseTemplate">
        ... whatever presentation you want for the base class (common to both derived classes) ...
    </DataTemplate>
    <DataTemplate DataType="{x:Type app:DerivedA}">
      <StackPanel>
        <ContentPresenter Content="{Binding}" ContentTemplate="{StaticResource BaseTemplate}" />
        ... whatever other presentation you want for DerivedA ...
      </StackPanel>
    </DataTemplate>
    <DataTemplate DataType="{x:Type app:DerivedB}">
      <StackPanel>
        <ContentPresenter Content="{Binding}" ContentTemplate="{StaticResource BaseTemplate}" />
        ... whatever other presentation you want for DerivedB ...
      </StackPanel>
    </DataTemplate>

The downside of this is that layout can’t be shared between templates, so you can’t split multiple cells of a grid between two templates (though you can contain a complete child object within one cell of the grid, as normal).

If you’re using it for the base class, as shown here, you have to use {Binding} and bind to a named template (you can’t use the type, since that’d be the derived type again and it’d get into a loop). If you’re using it for some common member (ie. you’re specifying a binding path) then you can use either kind of lookup.

So, to recap thus far, we’ve seen how to locate a template by name or by the type of the data object. But what if your requirements are more complicated? What if some property on the object needs to define which template to use? For example, let’s say that you have a ReadOnlyTemplate (display controls only) and an EditableTemplate (with editing controls), and you want to show one or the other depending on the ReadOnly property of the data item.

One way to do this is to use a DataTemplateSelector. I’m not going to post a full example of this (it’s long and boring), but basically the way this works is that you have to create a new class in your code that inherits from DataTemplateSelector, define an instance of that class in your Resources, and then reference that on your presentation control (via ItemTemplateSelector for item controls or ContentTemplateSelector for the ContentPresenter, for example), instead of specifying the template directly.

Once you’ve done that, at runtime WPF will call the SelectTemplate method of your class with each data item so that you can evaluate whatever you need to in order to decide which template it should be using. This concept is powerful, of course, but it can get tedious to write all those selector classes, especially if the decision is fairly simple (as with our ReadOnly property example).

So now I’m going to introduce a handy little class that should mean you’ll almost never need to write your own template selector classes again — the GenericDataTemplateSelector (the link is to the complete source file).

This class is based on one I found here; I’ve simplified some parts and added some new features. For the most part, it will let you select between your templates with just a bit of XAML:

  <Window.Resources>
    <DataTemplate x:Key="ReadOnlyTemplate">...</DataTemplate>
    <DataTemplate x:Key="EditableTemplate">...</DataTemplate>
    <DataTemplate x:Key="BarTemplate">...</DataTemplate>
    <msi:GenericDataTemplateSelector x:Key="FooTemplates">
      <msi:GenericDataTemplateSelectorItem Template="{StaticResource BarTemplate}"
                                           TemplatedType="{x:Type app:Bar}" />
      <msi:GenericDataTemplateSelectorItem Template="{StaticResource EditableTemplate}"
                                           PropertyName="ReadOnly" Value="false" />
      <msi:GenericDataTemplateSelectorItem Template="{StaticResource ReadOnlyTemplate}" />
    </msi:GenericDataTemplateSelector>
  </Window.Resources>
  ...
  <ListBox Items="{Binding FooList}" ItemTemplateSelector="{StaticResource FooTemplates}" />

Essentially, you’re listing all the possible templates in turn (any number can be listed; the first one that matches the conditions will “win”). Each selector item must have one Template and can have various conditions imposed on it; specifying no conditions will make that template always win when it is reached, so is best used as a catch-all default template at the end of the list. Possible conditions:

If possible, you should use PropertyName over PropertyPath, as the former is more efficient. The latter is more flexible, though, since it allows you to specify indexers and subproperties, just like in bindings. In either case, the selector will try to convert the Value you’ve specified to the appropriate type before comparison, so you should be able to use simple strings in place of enums, bools, and other more complex types that provide conversion (such as Color).

This works best when the properties are fairly fixed — eg. any given Foo never changes between ReadOnly and editable. This is because the template selector is only called once for any given item — if you toggle the ReadOnly property of an existing object, by default it won’t update the UI (and show/hide the editable controls).

If you do need to have it changing on the fly (perhaps ReadOnly has been bound to a checkbox, so the user can toggle the state, and you want it to dynamically switch between the editable and readonly templates accordingly), then there are a couple of solutions.

The first was mentioned on the original blog page I linked to earlier — you need to write a bit of code that gets called whenever something changes that may affect which templates need to be used:

  DataTemplateSelector old = listbox.DataTemplateSelector;
  listbox.DataTemplateSelector = null;
  listbox.DataTemplateSelector = old;

“Pulsing” the selector like this will force WPF to update the templates on all of the items; it’s a bit ugly though. Worse than that, if the presentation control is itself within a template then it’s much harder to get a reference to it from code, making this approach a lot more painful.

Finally, here’s an alternative to the whole DataTemplateSelector thing, using another set of WPF’s powerful features: Styles and Triggers.

  <Window.Resources>
    <DataTemplate x:Key="ReadOnlyTemplate">...</DataTemplate>
    <DataTemplate x:Key="EditableTemplate">...</DataTemplate>
    <DataTemplate DataType="{x:Type app:Bar}">...</DataTemplate>
    <DataTemplate DataType="{x:Type app:Foo}">
      <ContentPresenter Content="{Binding}">
        <ContentPresenter.Resources>
          <!-- this is just to help prevent cycles; you can skip it if this
                ContentPresenter is in a named template -->
          <DataTemplate DataType="{x:Type app:Foo}" />
        </ContentPresenter.Resources>
        <ContentPresenter.Style>
          <Style TargetType="{x:Type ContentPresenter}">
            <Setter Property="ContentTemplate" Value="{StaticResource ReadOnlyTemplate}" />
            <Style.Triggers>
              <DataTrigger Binding="{Binding ReadOnly}" Value="false">
                <Setter Property="ContentTemplate" Value="{StaticResource EditableTemplate}" />
              </DataTrigger>
            </Style.Triggers>
          </Style>
        </ContentPresenter.Style>
      </ContentPresenter>
    </DataTemplate>
  </Window.Resources>
  ...
  <ListBox Items="{Binding FooList}" />

This is a bit more wordy than the earlier examples, of course (although some of that can be removed if you’re using named templates, which is the best option provided you don’t need to also select templates by type). But because you’re going through the style and binding engine, WPF will be watching the ReadOnly property specifically, and will automatically switch templates if it changes (assuming that the property is observable, of course — but anything you bind to the UI should be made observable). With this sort of responsiveness, you can do all kinds of cool things with your UI. (The ReadOnlyTemplate is the default, since it appears outside of any triggers.)

Hopefully that all made sense to people. Any questions?

Oh, and it’s now on sale via Steam’s Midweek Madness for US$2. So anyone who doesn’t get it is crazy. (Or already has it, or didn’t see it in time.)

And I promise I’ll make a real post sometime soon. It’ll probably end up being another Games post though; I’m a bit out of ideas for Programming topics at the moment.

Ok, I’ll stop this now. (But just so that these posts aren’t a total loss, here are some significant events on this day in history…)

I promise I’ll get around to posting something real sometime soon. Ish.

Not that anyone will notice for a long while later…

One unfortunate side-effect of the change is that the generated wavatars will now be different (it uses a slightly different algorithm than it did before), but I don’t have too many commenters yet so you probably haven’t grown too attached to them…

I’m still not entirely convinced about the layout of some of the things in the sidebars (eg. which should be on the left and which on the right), so I might still do some tweaks in the future. But for now I’m reasonably happy with it. Feedback is welcomed.

Another offer comes from Telltale themselves: if you use the coupon code EPK-9VX-3ZN-WRH at their store then you can get any individual episodes for US$5 instead of the regular US$9ish. (Note that this doesn’t apply to the full-season packs though, sadly — though it does work on more than just Sam & Max.) This one lasts until June 17th (US time).

Ok, now that that’s out of the way, let’s move on to a discussion of the games themselves.

With the Sam & Max games, Telltale essentially invented the whole episodic game concept. Well, ok, that’s not entirely fair — other games before them (including a couple from Telltale themselves, and several from other companies) have claimed to be episodic — but Telltale were the first (and as far as I am aware still the only) company to get it really “right” on a regular basis. (”On a regular basis” being the key thing that they’re getting right.)

In terms of structure, each season has consisted of five or six games released approximately one per month (approximately, because both seasons were released across the Christmas break, so there was a two-month gap between the first and second episodes). They’re sold both individually and in a season bundle, priced such that the whole-season bundle is significantly cheaper than buying every episode individually. They have, however, made two additional decisions that I believe are really good: firstly, you can buy one episode individually to try it out and see if you like it, and then upgrade to the whole season set by just paying the difference. And secondly, if you have bought the season set then you can get it on disc as well as download for “free” (aka “cost of shipping only”). Very user friendly. (The download versions require online activation; the disc versions do not. The bad news: savegames tend not to be compatible between the two either.)

Each episode is relatively short (two or three hours — basically Portal length), but the season as a whole adds up to a fairly decent length for an adventure game, and at a comparable price.

The games themselves fall smack into the adventure genre (story based, third person, inventory); controls are mouse-based point & click for the most part, although each season also contains at least one “arcade” segment that is better played with the keyboard (though the mouse still works). Each episode is complete in itself (the “mission” is introduced, pursued, and wrapped up within a single episode), and they fit together to create an overall plot that links the whole season together. Season 2 does follow on from Season 1; though you can probably enjoy S2 by itself it does contain quite a few references to events in S1, so playing them in order is probably best.

The stars are of course Sam & Max themselves, probably best known from their appearance in the earlier LucasArts game Sam & Max Hit the Road (you know, back when LucasArts games were actually good). Sam is a suit-wearing anthropomorphic dog; Max is a “hyperkinetic rabbity thing”. Both are “freelance police”; essentially private investigators who are prone to excessive displays of property damage and violence — and yet it’s all very good-natured and played (successfully) for humour. They’re a lot of fun.

So, that’s probably enough of generalities. I’m just going to post a quick synopsis of each of the episodes, and my lasting impressions of them — it’s been a fair while since I’ve played some of these, so the details are a little vague in places.

Season 1

1. Culture Shock
   The duo investigate a case of hypnotism, seemingly being pushed by a group of child stars. There’s nothing particularly spectacular that I recall about this episode, but it does provide a decent introduction to the series.
2. Situation Comedy
   A crazed talk-show host keeps her audience captive; it’s up to the duo to get them released. Again, a good game but nothing spectacular.
3. The Mole, the Mob, and the Meatball
   Sam & Max must infiltrate the Toy Mafia. The puzzles in this one were a bit lacking (and the initial release was plagued by performance problems, although those have since been corrected) — but it did introduce the “Ted E Bear” musical number, which remains my favourite.
4. Abe Lincoln Must Die!
   The president has gone insane, and it’s up to Sam & Max to sort him out. Along the way, there’s another musical number (fairly gratuitous, I thought; I didn’t like it as much), Max runs for office (the horror!), and they face off against a robotic Abe Lincoln! Much fun to be had.
5. Reality 2.0
   The Internet is on the blink; an aggressive virus has taken control. In this, Sam & Max actually have to enter the Internet (think VR or Tron) to fix the problem — and the whole thing finishes up with a mini text-based adventure. This is easily my favourite episode out of the whole season. (But then, I’m a bit of a sucker when it comes to Tron-like environments.)
6. Bright Side of the Moon
   A trip to the Moon (in their car, of course) leads to the final reveal and face-off with the main villain of the season (who I won’t name, to avoid spoilers). Fairly decent, and it ties the season off nicely. I can say that it was very satisfying to finally finish off the villain — they get really annoying.

Season 2

1. Ice Station Santa
   A trip into Christmas Past, Present, and Future, in order to save Christmas. A little cliché, perhaps, but still fun. (And yes, Christmas Future gives a bit of foreshadowing for a later episode.) The strangely-warped Christmas toys are a particular favourite (”Torture-Me Elmer”…).
2. Moai Better Blues
   Easter Island and the great Moai statues. What are they really for? Can Sam & Max win the support of not just the locals, but the gods as well? And what is up with that volcano?
3. Night of the Raving Dead
   An army of zombies, led by an emo vampire. My least favourite of the series, although I’m not entirely sure why. (Resurrecting a Frankenstein’s-monster lookalike had some fun moments, though.)
4. Chariots of the Dogs
   A search for the missing Bosco… perhaps there was some truth in his crazy conspiracy theories? My favourite in this season; the sheer amount of time-foolery is simply brilliant.
5. What’s New, Beelzebub
   And the series closer: the final confrontation — in Hell itself! (And you’ve really got to see this depiction of Hell-as-corporate-wasteland. It’s quite funny.)

Supposedly Season 3 will be coming out sometime later this year. Something to look forward to!

As you may or may not know, for a while now Steam have been running weekend deals, wherein each weekend they will offer a game (or sometimes a game bundle) at an extreme discount (usually over 50% off). Obviously, if you’re even remotely interested in the game being offered, these deals are hard to pass up.

This weekend, it’s the Orange Box. At 66% off. Or US$10.

The only conceivable reason I can think of for someone to not immediately buy that (assuming of course that you didn’t miss the sale) is if you’ve already got it. Portal alone is definitely worth it, let alone all that Half-Life goodness.

(Why are you still here?)

Windows Presentation Foundation. WPF. Essentially it’s a long-overdue reboot of the child window model coupled with a powerful data binding engine (though not without its own quirks). And I love it.

The data binding model, though, does tend to result in the proliferation of little helper classes. In this case, I’m referring to value converters, those classes built solely to take a property value, convert it for display purposes (usually to a string), and optionally back the other way again.

Many of these are fairly basic, and it irritates me to have so many little “throwaway” classes that are all so similar to each other. So here is a kind of “catch-all” converter class that I’ve built for general formatting. It won’t completely replace the need to make custom converters on occasion, of course, but it will replace a reasonable chunk of them:

[ValueConversion(typeof(object), typeof(string))]
public class StringFormatConverter : IValueConverter, IMultiValueConverter
{
  public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
  {
    return Convert(new object[] { value }, targetType, parameter, culture);
  }
 
  public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
  {
    System.Diagnostics.Trace.TraceError("StringFormatConverter: does not support TwoWay or OneWayToSource bindings.");
    return DependencyProperty.UnsetValue;
  }
 
  public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
  {
    try
    {
      string format = (parameter == null) ? null : parameter.ToString();
      if (String.IsNullOrEmpty(format))
      {
        System.Text.StringBuilder builder = new System.Text.StringBuilder();
        for (int index = 0; index < values.Length; ++index)
        {
          builder.Append("{" + index + "}");
        }
        format = builder.ToString();
      }
      return String.Format(/*culture,*/ (string)parameter, values);
    }
    catch (Exception ex)
    {
      System.Diagnostics.Trace.TraceError("StringFormatConverter({0}): {1}", parameter, ex.Message);
      return DependencyProperty.UnsetValue;
    }
  }
 
  public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
  {
    System.Diagnostics.Trace.TraceError("StringFormatConverter: does not support TwoWay or OneWayToSource bindings.");
    return null;
  }
}

The usage is fairly straightforward; simply add one to your window or application resources, and then use like so for a standard binding:

ToolTip="{Binding Path=Hostname,
    Converter={StaticResource StringFormatConverter},
    ConverterParameter=Connected to {0}}"

Or like this as a multi-binding:

<TextBlock>
  <TextBlock.Text>
    <Binding Converter="{StaticResource StringFormatConverter}"
             ConverterParameter="{}{0}: {1}">
      <Binding Path="When" />
      <Binding Path="Message" />
    </Binding>
  </TextBlock.Text>
</TextBlock>

(Note that you need to use an initial {} escape for the multi-binding if your format string begins with a replacement placeholder.)

Points worth mentioning:

• Because this just uses String.Format under the covers, you can use format strings like {0:s} or {0:##0.00} if you like.
• If you don’t specify a ConverterParameter, then the multi-bind converter will default to simply appending all of the values together (without any extra spacing). (The single-bind converter will just format what you gave it, which should be equivalent to not using the converter at all.)
• Only one-way conversion is supported (though I guess it wouldn’t be impossible to implement a two-way binding, given certain constraints).
• I’ve tried to make it fairly robust in the face of misuse; it’ll log an error to the trace (usually only visible in the IDE, though that can be configured) if it’s used improperly, or if something throws an exception. Either way it’ll use the previously-valid value for the binding.
• Because Binding and MultiBinding are markup extensions, you (unfortunately) can’t bind any of their own properties. So you can’t directly calculate the ConverterParameter or get it from another property, although you can get it from a static resource. You can indirectly do it, though — you can give it a static resource object whose ToString returns the format you desire.

And that about wraps it up, except for one final point that I’d like to have a little bit of a rant about

In WPF, the culture parameter passed to the converter’s Convert method comes from the ConverterCulture attribute specified on the binding in the XAML, which is fair enough, and so far fairly analogous to the classic case.

Where things go horribly, horribly wrong, though, is that if there is no ConverterCulture specified against the binding in the XAML, then it defaults to the lang of the XAML document as a whole — and there are two really big problems with that:

1. If not specified, the document language always defaults to “en-us“. This means in turn that the ConverterCulture will default to the US culture, which will greatly annoy those users not in the US (particularly those who don’t like US-format dates).
2. The document language is always a concrete language; if you construct a Culture off this (as it will do behind the scenes) then you will get the defaults for that culture — in particular, you will not get any customisations that the user has made in the Control Panel, which will greatly annoy those users as well.

I’ve seen some code that tries to work around this problem by overriding the metadata on the language property, thereby forcing it to the root language of the current culture. Unfortunately, while this fixes the first problem, it still suffers from the second.

Only by using CultureInfo.CurrentCulture can you get the settings that the user has customised (and thus the ones that they prefer and are expecting). And conveniently, the standard behaviour of String.Format (and friends) when you pass in a null culture (or don’t pass it in at all) is to use the current culture settings. So that’s really the only sensible choice.

Long story short: don’t use the culture parameter in converters unless you are definitely explicitly specifying the ConverterCulture in the XAML and don’t mind using fixed settings instead of what the user would normally be expecting.

One thing about it that does seriously aggravate me though is the dumbed-down (and fundamentally broken) Network and Sharing Center. Everything works wonderfully if you have exactly one network adaptor which acts as your gateway to the Internet — which admittedly probably covers at least 60% of the public (with most of the remainder being covered by people with one wired and one wireless connection [eg. laptops], each of which could be the gateway to the Internet, but only one at a time).

Stray from this model, though, and you’re in for a world of pain. As it happens, my work PC has an extra network card (used to connect to embedded devices on a dedicated subnet, both to avoid cluttering the main network and to more easily talk to devices with fixed IPs), and it also has VMware installed, which creates two or three extra adaptors of its own.

Vista has a fairly simple classification model for its firewall. Each individual adaptor (or “connection”) can be specified as either Public or Private. Public is intended for insecure locations (eg. Internet cafes or stray wireless access points), while Private is intended for secure locations (home or office LAN). Unsurprisingly, in order to be secure by default, any new connection is considered Public by default, and if any connection is Public, then your computer as a whole is considered to be in a Public location and certain services are disabled. To resolve this, you can just go into the network control panel and change the connection to Private, then you’re good to go.

Or are you? The problem I’ve been having (and I’m not alone) is that Vista seems to have a very bad memory for connections that don’t actually lead to real networks (I’m not entirely sure what its criteria is, but I suspect it involves whether it can find a DHCP server on the network or not). Because of this, it has a tendency to flip connections back to Unidentified and Public again whenever you reboot — which in turn will go disable those services that aren’t considered public-safe. (This includes file sharing, which is very handy to have available, especially at work.)

Now, it is possible to change around the public profile in the firewall settings, so that the services are still available even if it does flip to public mode. That’s not very clean, though, especially if sometimes you really do want to go Public (eg. with a wireless adaptor) and keep things secure.

From a bit of investigation (and Googling), I’ve discovered the following workaround to the problem. This essentially “hides” the connections from the networking control panel — you can still see them in the Network Connections folder, but they won’t appear in the Network and Sharing Center and they won’t be considered when Vista is deciding whether the computer as a whole is Public or Private.

This procedure requires a regedit hack, so it’s not for the faint of heart (and don’t forget to take backups, etc etc):

1. Run regedit.
2. Go to HKLM\SYSTEM\CurrentControlSet\Class\{4D36E972-E325-11CE-BFC1-08002BE10318}.
   Under here, you’ll find a list of 0000 to 00nn (it went up to 0017 in my case; it’s likely to be different on your PC depending on how many adaptors you have).
3. Look through each of the keys in turn until you find the one that refers to the specific Adaptor that’s causing the problem.
4. Add a DWORD value called “*NdisDeviceType” (don’t forget the leading *) and give it the value 1.
5. From Network Connections, disable the adaptor, then re-enable it.
6. The adaptor should no longer be visible in the Network and Sharing Center, and (if there aren’t any more) you should be back to the Private profile.

What this will do is to tell the network discovery component that this adaptor connects directly to a single host rather than to a network, so it won’t try and look for DHCP servers (or whatever it is that it actually does) on there and go mental when it can’t find any. It won’t affect the bit of Windows that actually lets you talk to devices on that network, though, so everything else should still work fine.

Note: you should only disable a connection like this if you’ve experienced this problem and if the connection is never used to connect to the Internet. It’s strictly for secondary mini-networks.

Let me get the obvious stuff out of the way first: yes, it was dumb to re-use the name; yes, it’s a “reset” of the franchise (and an attempt to start a new trilogy) — which means that yes, it has new characters.

I didn’t actually pre-order it, but I bought it sufficiently close to the NZ release date that the pre-order packs were still available (one of the benefits of staggered release dates, I guess — since the game had already been out in the US for quite a while at that point, I had a fair idea of what to expect going into it). The pre-order pack was fairly weak, though. There was a mini-comic (admittedly a very nice one, though no doubt someone has scanned and uploaded it by now), a bonus content DVD (which contained a bunch of useless fluff and about six minutes worth of video — the rest of which you had to go download off the website like everyone else), and a code card to unlock some character skins for the old Sands of Time characters (which have definitely been broadcast far and wide). What’s more, the code cards were misprinted — they have a nine-digit code, but the game only accepts eight digits. (Fortunately, the first eight digits work.)

The skins are a mildly interesting touch; they’re basically just a wardrobe change (they don’t affect the facial model), but they do have a certain amusement value. Having said that, given the choice between the standard characters and the SoT-garbed characters, my preference was definitely for the standard ones.

But anyway, enough about the fluff and on to the gameplay itself.

It is, of course, a platform game at heart, requiring a fair amount of jumping skills and quick reactions. I’ve always had an odd sort of fascination with the Prince of Persia series; while I despise timed puzzles and generally dislike precision jumping puzzles, for some reason I keep coming back to this series, which is full of both. Of course, to date I haven’t actually finished any of the previous games — there’d always come a point where I got sick of falling to my death for the millionth time at a certain spot, take a break from it for a while, and just never get around to playing it again.

This game was different somehow. Your sidekick Elika has the ability to rescue you from certain doom — if you’re falling to your death, she’ll grab you and drop you back on the last flat surface you had reached; if you were in combat, then she’ll pull you away from the deathblow and give you some space to recover. It’s effectively the same as frequent quick-saves and quick-loads, checkpoints, or a rewind power (the mechanisms used in the previous games, albeit sometimes limited), but the automatic nature of it and the way it was integrated into the gameplay instead of being an out-of-game action really made it work, I think.

This feature has caused quite a bit of grumbling from some corners, with claims that it dumbs the game down or makes it “too easy”, or removes the sense of challenge since you can never really “fail”. While there is some truth in this (it certainly makes the game feel easier), there are still plenty of opportunities for failure, whether it’s missing the mark in a wall-run and having to repeat the (sometimes lengthy) manoeuvres to try again, or nearly getting sliced in half by an enemy and retreating while they gain back some (sometimes a lot) of their health. Consequently, there’s a feeling of success and accomplishment when you finally do get past a tricky section. In the end, there really is little difference between this and a quicksave/quickload system, except that this is less disruptive to the gameplay “flow”.

The gameworld itself is semi-open; you’re presented with a map showing the areas that you need to explore and cleanse (more on that in a moment), and for the most part you’re free to choose the order in which to solve them. There are some constraints, however. The repeating theme is in fours — there are four gateway areas that require nothing special, each leading to four areas; two require one magic power to solve, two require a different power. Once you’ve solved all four, there’s one final area in each section that requires both powers; and then the finale (once you’ve solved everything else) requires all four powers at once. They’re arranged in a consistent pattern so that you can acquire the four powers in whatever order you like without being disadvantaged by it.

So, the cleansing. The initial goal of the game is to “cleanse” each of the areas by fighting, jumping, and running your way to a special spot called the “Fertile Ground”. Sometimes this doesn’t take much, but other times it’s quite a trek to get there (especially in the areas that the Mechanist has claimed, where there’s usually some kind of gear-based puzzle to solve). The path is usually fairly obvious, though — most of the side paths are blocked off by the Corruption, and if you do get lost you can always ask Elika to show you where to go next (although sometimes she does get it wrong). When you do get there, though, you’re almost always enmeshed in a fight against one of the four lieutenants of the Big Bad, which tend to escalate as you progress. After (temporarily) defeating the bad guy, once you get Elika over to the Fertile Ground itself you’re treated to the very cool cleansing animation. I’m admittedly a bit of a sucker for this sort of premise — and while this particular effect is nowhere near as cool as the one in Okami (PS2, Wii), it’s still pretty enjoyable.

After cleansing an area, you then need to traipse all over it again (now with a much more pleasant atmosphere and some additional paths opened up) to gather enough Light Seeds to take back to the temple and activate another of the powers, which will in turn let you access more areas. (Each power unlocks four areas, with a pair of powers needed for the final area in each section and all four powers needed for the finale.) This isn’t too complicated, though — there are 1001 Light Seeds in the game (1000 in the body of the game and 1 in the finale) and you only need about half that number to unlock all four powers. (If you do gather all 1001 then you’re rewarded with some additional skins. Which might not excite some people, but I quite liked them. Also, the Jade skin you get just for completing the game [with any number of seeds] is pretty sweet, and reminds me that BG&E 2 will be out soon. Yay, I hope!)

A downside of the semi-open-world style is that once you get used to the basic moves (and you have to get used to them fairly quick) then the areas do get a little same-y. Mitigating that somewhat are the powers (each of which has quite a different effect) and the way that the lieutenants introduce hazards into the areas you haven’t cleansed yet when you get too close to them, and new combat moves you have to guard against. (Though that can be a little annoying as well.) Also, while the mechanics (wall-run, ring-extend, grip-fall, jump, double-jump, roof-run) are fairly constant, the arrangement within each area is usually fairly unique and interesting (in some cases — like the two Towers — they’re deliberately similar), so while you quickly get used to (and hopefully proficient at) the moves, they never really get boring.

I have mixed feelings on the combat. You only ever face one enemy at a time (whether that’s one of the lieutenants or one of the soldiers that pops up whenever you reach the midway point between two areas), and while the fights are animated reasonably well and seem suitably heroic, they can be quite frustrating at times — such as the boss you can only defeat by leading to a specific place and jumping aside at just the right moment, or when the enemies learn the gauntlet shield (where only a gauntlet attack — an extreme short range attack — will work on them; if you’re not fairly good at the block-and-counterattack manoeuvre at that point then you’re in for a world of pain). And if you do make the wrong move then you’re treated to the joy of a quick-time-event, where you’ll either have to hit one specific attack button (or the block button) to avoid a death-blow (and Elika save, and giving the enemy some time to recover health), or you’ll have to button-mash something (usually the sword button) like crazy — except when even that doesn’t work. You see, most of the time it seems to want you to just hit the button as fast as you possibly can (and it does have to be pretty darn fast), but every once in a while it seems to decide to pulse a bit slower and will then fail you if you mash it too fast. Just to keep you on your toes, I guess. Still, no question that QTEs (or as Yahtzee calls them “press X to not die”) truly suck.

Speaking of Yahtzee: one of the points he made in his review referred to his dislike of the dialogue, character interactions, and the character of Elika in general. I couldn’t disagree with that particular assessment more. I quite enjoyed the dialogue and the glimpses it gave into the main characters and their motivations — although it was a little surprising how much Elika shared given how little the Prince reciprocated (not even his name — nor whether he really is a Prince or not; he certainly implied that he isn’t, though it’s probably still a fairly safe assumption). The banter between them was quite amusing as well — comedy (and a certain amount of snarkiness) is definitely an underused technique in games. I also appreciated the way that most of the sideline or “flavour” dialogue is optional — while I personally listened to all of it, I know that some people would prefer to skip the whole thing and just get on with the game.

There were two things in particular that I didn’t like about the dialogue. One is that you had to wait for the little flashing icon to show that Elika had something more to say, and press the Talk button again — you couldn’t just hold it down to hear everything at once. The other is that when you were near one of the puzzles the game made no distinction between Elika having some interesting bit of conversation to add (perhaps some description of the backstory, or just a bit of banter) or a (usually blatantly and pointlessly obvious) hint about the solution to the puzzle, resulting in Elika seeming to nag uselessly about the puzzle several times in a row at the end of a normal conversation about the history of the place or whatever.

Another thing that irritated me a bit is that while the map screen (which you can call up whenever you want) quite nicely shows your progress in cleansing the lands, the matching mosaic at the temple that it’s supposed to represent doesn’t change at all as you progress. It also bothers me the way that Elika pronounces “Ahura”; it’s entirely possible that she’s pronouncing it correctly, but it’s certainly not the way that it sounds in my head.

The basic story is fairly straightforward; cleanse the corrupted areas, get rid of the dark lieutenants, and finally defeat the Big Bad. Once you accomplish that, though, the finale gets a bit weird. Something happens (which clearly came as a surprise to the Prince, though I saw it coming since about half way through), and then you’re given no choice but to completely undo all the work you’ve accomplished in the game thus far, and (apparently) release the Big Bad (Ahriman) on the world. Of course, it all fairly screams “sequel”, so it should come as no surprise that this game is planned to be the first in a new trilogy.

Technical issues also cropped up; I played through the first couple of hours of the game only seeing subtitles for the main characters and not hearing any voices. I can’t completely blame the game for that — my onboard graphics drivers are a bit flaky; they claim to support 3D sound but choke if something actually tries to use it — and the game evidently believes what it’s been told. (Previous games I’ve played that supported 3D sound at least had a checkbox to disable it — and I can fault the game for not having that — but it’s still ultimately my sound card’s fault.) I eventually managed to work around this and get the voices back by completely disabling hardware acceleration for the sound card; but that in turn led to sound effects occasionally getting “stuck” and endlessly repeating themselves (which could be interrupted relatively easily, but it also eventually caused the frame rate to suffer), which was just as irritating.

Overall, though, I liked it, and it’s the first Prince of Persia game that I actually finished — in fact (being of a completionist mindset), I even took the time to hunt down all 1001 Light Seeds for a 100% finish. (According to Xfire, I spent 31 hours in total playing this; though that probably includes some time with the game paused.)