[I7] Thoughts on game presentation

[Andrew Hunter]

The thread on raif about packaging games has had me thinking about how  
to add this as a feature to Zoom. My first thought was to  
automatically add files in a particular subdirectory of the Resources  
folder to the iFiction window. This would be far from ideal, though -  
the user would be presented with a list containing a single game, and  
would work out that they need to double-click it.

This does address a particular issue with packaging games, though: the  
interpreter is often much larger than the game itself (especially with  
multimedia interpreters like Zoom), so packaging games on a one-shot  
basis is very wasteful. Packaging them with a complete interpreter is  
a lot better, especially when the player can just click the 'Find  
More' button to go to the IFDB and find similar games.

Ideally, we'd like a packaged game to start up immediately, or at  
least present itself in its own way, so when the player starts up the  
interpreter for the first time they are presented straight away with  
the game they downloaded, with the seamless ability to find more later  
on. My thoughts on how this should be achieved is where the compiler  
comes in. Games that wish to be packaged in this way should provide a  
new blorb chunk that contains an HTML title page (and an arbitrary  
number of extra 'files' to contain images, style sheets, etc - these  
could be accessed through a scheme similar to the inform:/ URLs we use  
to access documentation at the moment). This would effectively be an  
extension to the cover image system already in place.

The interpreter, on finding it has a library of exactly one game  
containing a title page would display this by default instead of the  
list of games. The user would click a link, or press a key, and be  
taken to the game itself. Once they'd played the game, they could use  
the same page to navigate to the 'related games' in the IFDB: perfect  
for introducing newcomers to IF.

There's a further step, though. While thinking about embedding HTML in  
games, I started wondering about doing the opposite: embedding the  
game in HTML. The idea is that the game provide a 'gameplay' page,  
which embeds a plugin provided by the interpreter to display the  
game's content: this would allow the game to create a unique look for  
itself, and would also allow the designer to use standard tools to  
create it.

The plugin could provide for communication via javascript - the  
simplest way perhaps to just expose something like CocoaGlk's existing  
automation system, which would be adequate to create something like  
the BBC's hitchhiker's game.

Perhaps communication could also be done directly via requests on a  
custom URL scheme - this would require some interpreter support, but  
such requests could be presented as glk streams to the game. This  
would allow the page surrounding the game to update itself using  
techniques like AJAX. Embedding flash or Silverlight content would be  
possible, too, which would make it possible to relatively easily  
create very rich interfaces.

Something that really makes this appealing to me is that it would be  
very easy to implement, at least with CocoaGlk, as the GlkView class  
could be dropped into a WebKit plugin pretty much unaltered.

Thoughts?

Andrew.