Anyway, sorry. I just don’t have much to say about this.

Gleaming the Cube

In short, everything works! It’s wonderful. Except that I really never had a chance to do anything other than the story written by the authors. For some reason, it didn’t work for me. Totally subjective. I guess after going to all the trouble to learn how the virtual environment works, I wanted to be able to have some degrees of freedom. Instead, I’m just on rails — whether I throw the ship off, whether I kill the robots, etc. we still get to the same ending. Some slight variations in the foliage on the way there, but ultimately the same destination.

Why this works in a Photopia, and not in Rover, beats me. It’s just how it is. This game will get good marks from me, and presumably from many others, but it missed the sweet spot for me.

Rover’s Day Out

Interactive fiction is lively more or less only when the world appears even somehow plausible, if objects and environment can be manipulated for the sheer do-ability of it. If there’s a chair, let me sit in it! If there’s a torch, let me hold it (I understand, in retrospect, why the torch couldn’t be held, for the sake of the central puzzle, but arbitrary limitations like that annoy me). SQ features a spare environment, full of objects that are more or less off-limits. To its credit, the most annoying objects that aren’t manipulatable (see above, torch) have something to do with the puzzle landscape of the work, and I’ll give it some credit for that.

I managed to get through this game in about 20 minutes with the non-complete score (I have to admit, I appreciated the ridiculous implausibility of the last 8 points, since it completely affirms what I wrote in the previous paragraph — if you can arbitrarily interact with the environment, then hide stuff where most players are unlikely to look, as long as those things are unnecessary to the completion of the game), but I needed a partial hint on the final puzzle (once I found the object, I figured out how to use it without further help, although I misunderstood what it was for at first).

So, this game is not great, has 0 replay value, doesn’t really inspire with its puzzle design or writing. As a quick, escape-from-a-cave lunchtime diversion, it probably does its thing, but I generally am looking for something with a bit more oomph, either in the story, puzzle, atmosphere or writing department.

Finally, the use of ‘!’ when announcing that you’ve found something gets old kind of fast. Ecstatic announcements aren’t really necessary. Grump grump.

Spelunker’s Quest

I’m embarassed to say that I didn’t figure out the central puzzle without looking at the walkthrough. I blame myself though – I was doing too many things at the same time.

There’s really not too much else to say about this one. It’s reasonably well-written, reasonably well-implemented. It’s a single-puzzle game, finishable in about 3 minutes, once you’ve oriented yourself. In the world of ‘casual gaming’, it rates as a great lunchtime distraction. As anything more than that, well, why does it need to be more than that?

If you don’t like puzzles, or only like hard puzzles, or require story or motivation or plausibility or anything like that, seek your fortune elsewhere. If you’re looking for a cute bit of text-game fun, load it on up.

Byzantine Perpective

The premise of the game is that you can manipulate your environment by means of a magical ‘runebag’, which permits you to ‘knock’ letters out of word or ‘cast’ them into others. For instance: “knock brain” might turn a heavy ‘brain’ into heavy ‘rain’, or maybe just heavy ‘bran’, and “cast p into pro” might turn a ‘pro tennis player’ into a ‘prop tennis player’. You get the idea.

So far, so good. It’s a good premise for a puzzle game. However, the more I played, the more I could imagine the authors wracking their rains, er, brains, in order to come up with logical, grammatical puzzles that made any sense whatsoever. And not necessarily succeeding. The situations suffer a bit from a sort of arbitrary surrealism, and offer no particular motivation to solve the puzzles, other than curiosity about what might come next. In several places, you might not even realize there’s a puzzle, except that you’re stopped by an invisible force until you’ve solved whatever the authors think you should be solving.

Along the way, you’re offered a number of hints as to what you could be doing, via the numerous figures you’ll encounter as you move from space to space in the game. Mostly, though, you just have to keep ‘talk’ing to them until they run out of stuff to say. Which is kind of boring and not particularly satisfying. I’d prefer to assemble the outline of the puzzle at hand from hints in the environment, rather than be vaguely spoon-fed insinuations of potential directions to act in.

But therein lies another problem. Once you get finished with the initial levels, you enter a level featuring a) difficult puzzles — ok, ’sea ions’ into ’sea lions’ wasn’t rocket science, but ‘crown’ to ‘crow’ to ‘cow’ isn’t at all obvious from the context, with b) a turn-based time limit, after which your poor sea ions, er lions, have drowned and you’re informed by the (very good, +1 for this) lower pane ‘interior monologue’ that you probably should have saved the poor things.

At that point, I consulted the walkthrough, realized the “error” of my ways, and saw how difficult the end of the game is, given the timing constraints and realized that, lacking some insider knowledge of how the world should appear at the end, with little guidance, there was no chance in hell I was going to complete this game without simply typing in the walkthrough, so I stopped.

Plusses: the game is well implemented, I couldn’t discover too many unimplemented objects (although there are plenty of potentially ‘knockable’ and ‘castable’ objects which remain immune to my runebag’s powers). The writing is pretty good, and I particularly appreciated the ‘interior monologue’ pane, which, although sometimes a bit too drollish, offered a nice running commentary of what I was doing.

Earl Grey is not bad, it’s just too hard, without enough effort put into guiding the dear reader through what appears to be an open, exploratory game, but is, in fact, a very strict puzzle with a fairly unique, abitrary solution.

Earl Grey

So… to build Multilink, check out the following instructions. If you just want to use my pre-built binaries, I’ve zipped them up and you can get them here. See below for more information.

Building Multilink

Step 1: Install Cygwin

1. Download Cygwin and run Setup.exe.

2. In addition to the default packages, you should select at least the following (others may be required, but I don’t think so):

   • binutils
   • gcc (selects gcc-core and gcc-g++)
   • gcc-mingw (selects gcc-mingw-core and gcc-mingw-g++)
   • gdb
   • gdbm
   • make
   • patch
   • pkg-config

3. Let Cygwin do its thing, and you’re good.

Step 2: Install prc-tools

There are two options for this: use the prebuilt Cygwin packages or build it from scratch. I’m only going to deal with the first option (but don’t worry — we’ll be compiling some stuff soon).

1. Go to the prc-tools site and download the 2.3 releases called

   • prc-tools-2.3-cygwin.tar.bz2
   • prc-tools-arm-2.3-cygwin.tar.bz22.

Put these into a folder call ‘cyginstall’ or whatever you want to call it at an easy to find location.

1. Run the Cygwin installer (setup.exe) again. This time, instead of using the default “Install from Internet”, choose “Install from Local Directory”, click through the next screen (keep the defaults), and then at the field called “Local Package Directory”, enter or browse to the folder you used to store the .bz2 files in step 2.

2. At the next screen, you should see the two packages (prc-tools and prc-tools-arm). Enable them and complete the installer.

Step 3: Get the Palm SDK

You need an account at ACCESS (and potentially at Palm, depending on what OS features you’re using). For now, I’m going to assume a simple install of the ACCESS SDK (adding the Palm headers is easy, if you need to do it later).

1. Once you’re in the the top secret developer area of ACCESS, follow the link labelled “Garnet OS Development Tools”. Then the link (under ACCESS SDKs) called “Core Garnet OS SDK”

2. Get these two downloads: – Garnet OS SDK (68K) R3 PRC tools Generic UNIX – Garnet OS 68K API SDK (Fall 2004 Update) (for PRC-Tools)

3. Create a folder at C:\PalmDev

4. Untar the “Garnet OS SDK (68K) R3 PRC tools Generic UNIX” download into your PalmDev folder. It should have resolved to a folder called “sdk-5r3″.

5. Rename it to “sdk-5r4″.

6. Unzip the “Garnet OS 68K API SDK (Fall 2004 Update)” to the PalmDev folder. Overwrite any older files with the newer ones.

7. Open a Cygwin terminal window and type: mount c:\\PalmDev /PalmDev to create a Cygwin “mountpoint” for your PalmDev folder.

8. Now type (still in Cygwin)

   palmdev-prep

   You should see:

   Checking SDKs in /PalmDev
  sdk-5r4 headers in 'include', libraries in 'lib'

   When GCC is given no -palmos options, SDK '5r4' will be used by default
Writing SDK details to configuration files...
...done

   Presuming that you do, you’re in good shape, and can probably compile Palm code as-is. All that remains is getting Multilink setup.

Step 4: Download and build some source code

In order to successfully build Multilink, we need to build new versions of a couple of libraries and a header file related to the ‘bintools’ package. The trick is, we need to build them for the m68k-palmos target. These files are automatically built when compiling prc-tools yourself, but since we took the easy way out, we don’t have them.

To solve this, we’re going to do a partial build of prc-tools (the bintools part), and get the libraries and header file in question.

1. Download these two archives:

   • prc-tools-2.3.tar.gz
   • binutils-2.14.tar.bz2

2. Copy them to your Cygwin home folder (C:\cygwin\home\(username))

3. Perform the following sequence of commands in a Cygwin terminal window

   cd
tar xf binutils-2.14.tar.bz2
tar xfz prc-tools-2.3.tar.gz
cat prc-tools-2.3/binutils-2.14.palmos.diff | patch -p0
cd prc-tools-2.3
ln -s ../binutils-2.14 binutils
cd ..
mkdir build
cd build
../prc-tools-2.3/configure --target=m68k-palmos --enable-languages=c,c++  (note: all on one line!)
   cd binutils
make all info

4. If it worked and you don’t have any errors, congratulations! If it didn’t work, you might be missing some system libraries, in which case you should examine the error, determine which package is missing (it should be pretty obvious) and install it via Cygwin’s setup.exe installer.

5. You need the following files:

   • bfd.h
   • libbfd.a
   • libintl.a

   cd
cp build/binutils/bfd/bfd.h /PalmDev/sdk-5r4/include/
cp build/binutils/bfd/libbfd.a /PalmDev/sdk-5r4/lib/
cp build/binutils/intl/libintl.a /PalmDev/sdk-5r4/lib/

Step 5: Download, build and install Multilink

Almost done. All we need to do is get Multilink built and installed.

1. Download Multilink and copy it to your Cygwin home directory.

2. Open the archive with:

   cd
tar xfz multilink.tgz
cd multilink

3. There are a few things we have to fix in the Makefile before we build. Use the editor of your choice (I would recommend that you use something which won’t mangle the Unix line endings like metapad or e, but it might not matter):

   • Change the line:

      PILOT_DIR = /usr/local/pilot
     

     to read:

      PILOT_DIR = /PalmDev/sdk-5r4
     

   • Change the line:

      LIBS = -L${PILOT_DIR}/lib -lbfd -liberty
     

     to read:

      LIBS = -L${PILOT_DIR}/lib -lbfd -liberty -lintl
     

• Change:

       CC = gcc
  

  to:

       CC = gcc -Dfalse=0
  

• And put a ‘#’ character at the beginning of the line:

       @test `whoami` = root || (echo "Must be root to install"; false)
  

  to disable it (Cygwin doesn’t support sudo). It now looks like:

       # @test `whoami` = root || (echo "Must be root to install"; false)
  

• Done. Save it and return to the Cygwin terminal (if you’re not already there).

1. Build Multilink:

   make
make install

DONE!

The pre-compiled binaries

Inside the archive are two folders, “buildstuff” and “dist”.

“buildstuff” contains the header and 2 library files the above instructions generate. Presuming that you’re using the prc-tools 2.3 Cygwin distro, you can use them to build your own Multilink, without needing to build them yourself.

“dist” contains the built Multilink .o, .exe and .man files. Again, presuming that you’re using the 2.3 Cygwin distro, you can probably bypass all of the above, and simply put these at the indicated locations. YMMV.

So, I’ve played these things off and on my whole life, I guess, although I hadn’t really looked at them for a long while. Anyway, the announcement of a decent Mac interpreter got me interested again. And then I started looking around for a decent Palm interpreter. Yes, I still have one of those.

One thing led to another, and I started rebuilding my favorite of the available interpreters, CliFrotz, adding a bunch of new features along the way. So, that’s nearly done and called CellarDoor. You can find it here. Check it out sometime…

Here’s the thing I like about IF: more than any other storytelling medium that I know, it most resembles ORAL storytelling. The direction of the story can be influenced by the audience/player, through a questioning of the teller/program. Despite the stasis of the texts (texts aren’t produced, per se, but culled from a large assortment of pre-written source texts). By accumulating knowledge about the story or environment being told or described, I increasingly gain fluency of movement within the environment and increased understanding of the underlying story (if there is one). Unlike a book or DVD, it’s not random-access: the pacing and access to different elements of the storytelling is controlled by the teller.

There are a reasonably large number of people still producing this kind of work, with free programming tools available. Some of the work barely resembles the original Infocom models: literary experiments, “straight” fiction without game-like elements or pedagogy are also possibly using these tools. I’ll post a short list of my current faves in a different entry.

Enter GTD, which you can google if you’re up to it. Check out 43folders for lots of articles on the subject. No, I never read or even bought or even saw David Allen’s book, figuring that I seem to teach myself everything else, why not this?

Anyway, the idea is that you have projects and contexts. Projects are, for instance:

• Cycling ‘74
  • Bugs
  • Jitter
    • Current version
    • Next version
  • Max
    • Current version
    • Next version
  • Email
  • Research
• Tax Year 2005 (US)
• Tax Year 2005 (DE)
• Teaching in Hamburg
  • Some subprojects
• German Class
• Musicmaking
• Phototaking

and so on.

Contexts are things like:

• Home
• Office
• Shopping
• Writing
• Reading
• Computer
• Email/Call
• Go/Meet

So under each project header, I have a number of tasks. Think of the project as the thing to accomplish, and the tasks as the steps to get there. Each task gets a context. The idea being that I can view this all as a hierarchical list of projects, or as a flat list of tasks belonging to a specific context.

The basic idea is that you plan in projects, but do in contexts (e.g. “I am at the OFFICE, what is on my OFFICE list?” or “I have a few moments which I could use to send an EMAIL. Who do I have on my EMAIL list?”). It seems totally bone-headed, right? The thing is, it’s an enormous relief to write something down and be able to forget about it until the moment when you need something to do. At which point, you dial up your context and there you are.

So, naturally, there are plenty of tools for this stuff. I’ve been using TextMate a lot recently, and had this weird idea that I wanted my entire life to exist in the one program (I am, in fact, writing this blog entry using their MarkDown module, but that’s another story). There are in fact 2 GTD bundles for TextMate, and I was having some luck with the GTDAlt bundle, although I was spending a lot of time making modifications in Ruby so that it worked with Remind, let me set up repeated types of tasks, etc. Anyway, after a couple of weeks, I moved over to Kinkless, which, although imperfect, does the trick for me, and syncs nicely with iCal (although I can’t get the freaking alarms working). Actually, this is the entire point of this post.

Because the iCal alarms weren’t working for me, I ended up spending a good 24 hours of time modifying and hacking together found bits of Perl code to parse iCal calendar files, format the to-dos so that Remind could read them and send notifications to Growl, and so that I could display the info on my desktop using GeekTool.

And I guess this is the sad truth of the entire matter. One spends so much time working ON the system, that the work WITH the system becomes secondary. Perhaps I exaggerate, and perhaps this is a specific “programmer’s problem”, whereby one believes that efficiency and direction in life is just a few lines of Perl away, but nevertheless… I must admit, I have been “Getting (some) Things Done”, and in a less rough and tumble fashion than I have my entire life up to this point.

I hope the perfect solution comes around eventually (in the form of a charming companion who will simply tell me what to do, perhaps?), but until then, I think it’s all working well enough that I can get back to work.

If anyone wants my iCal->Remind scripts or my Remind->GeekTool recipe or my Remind->Growl script, give a shout. I do highly recommend Kinkless for this stuff. OmniOutliner Pro isn’t the perfect info manager (I want to be able to attach multiple notes to entries in my system, which isn’t really allowed, although I can work around that), but it’s serving my (admittedly modest) purposes.

The projects area of the bootsquad website has been slowly filling out, with lots of excerpts of newer work. I’m still missing some documentation of a couple of projects, like some work I did with Paulo Raposo, but I think it’s forgivable. I’m going to begin posting excerpts of the music I’m working on, once I feel like it’s not too embarrassing to do so. I’d like to hook up with a designer and do some animations for a DVD, but it’s a little early to make plans – not until the sounds are a bit more fleshed out.