Elision in generated interactive stories

I’ve been thinking about generating interactive stories as choice-based IF for a while, using that format as a liberating constraint, a reasonable and minimal model for many other forms of interactive entertainment, and as a tool to focus on interesting player choices. I wanted to do something for Procjam in 2014, but got overwhelmed by the problem. I was planning to tackle thing again in a similar but smaller project for ProcJam 2017. That is not going to happen in time, for personal reasons, but last night I realized that a) the problem I was stuck on with was the same problem that overwhelmed me back in 2014, and b) it might be possible to solve it by splitting it into two simpler problems. So I thought I’d write down some notes here.

Continue Reading »

Anime series recommendations

For no particular reason, and without claiming to be an expert at all, I thought I’d list some anime series I like. In no particular order:

Continue Reading »

Some game-designer-y thoughts on Bound

I’ve just played Bound, the game for the PlayStation 4 developed by Plastic and published by Sony. Apart from some images and a brief look at a trailer, I knew nothing about it. If you want to play it, I recommend you try to find out as little as possible too. Seeing the tag line and the briefest of descriptions while finding the previous link gave me information I would have preferred gathering myself.

Here are some reasonably non-spoilery thoughts on it, based on having played it for an hour or so:

Continue Reading »

Game animation logic in React

I’ve been working on a small minigame written in JavaScript using React. It’s similar to Robo Rally: you write a small program for a robot, it executes it, if it gets to the end without dying, you win. The actual robot logic is turn-based, the display isn’t. It’s split up like this:

One module contains a pure functional implementation of the actual robot / program execution logic. It exposes two functions: one that takes a level description and returns an initial game state, and one that takes the level description and a game state and produces a new game state.

The next module contains a Flux store (just something that holds data) which holds the level descriptions, the current game state, and can run a timer. If you tell the store to start, it starts the timer, runs the robot logic every tick, and emits an event when its data changes. (It also handles a whole bunch of other state, but that’s irrelevant for this description.)

Then there is a React component for the robot (obviously one of many components). React components are, ideally, pure functions of their inputs. They’re best written declaratively: you use React to declare what you want the user interface to be like. This usually works like a charm.

But game logic can be hard to fit into this model.

Continue Reading »

Announcing Choba, an experimental interactive storytelling engine

Over the last few weeks I have taken the interactive fiction engine inside Mainframe, the IF game Liz England and I made for Procjam last year, and have rewritten it in JavaScript. I’ve called it Choba, short for CHOice BAsed, and I’ve put it on GitHub and npm. It’s open source, just like Mainframe.

I’ve also backported it into Mainframe itself, so if you play it now, you’re no longer seeing a Python program running on Heroku, but a JavaScript program running inside your browser. (Doing just that has already been worth it. It means I no longer have to pay Heroku, it makes the game much easier to deploy, and I’ve already learned a lot starting a new JavaScript project.)

As you can see from the project’s readme file, I have future plans for this engine. Writing an actual parser, porting it to desktop and mobile, experimenting with different game types, better tools, and new procedural generation / narrative AI techniques: these are all things that have come a step closer.

I don’t recommend it for general use yet, but I do welcome feedback, and if you want to build a game with it, let me know how I can help.

More thoughts on tagging

I did some more thinking after yesterday’s blog post on tagging, and had an interesting discussion with Mike Cook and Chris Martens about how they approach similar problems. So here are some more thoughts on the subject.

Continue Reading »

Procedural content generation in Mainframe

The procedural content generation in Mainframe uses a very simple mechanism, which is both more powerful and trickier to implement and use than I expected at the outset. That mechanism is tagging. You tag bits of content, and then somewhere else you say you want something with a given set of tags.

One of my theses about interactive storytelling is that selecting, adapting, and combining bits of authored content is an approach that is powerful, underexplored, and pragmatic, in that it offers a smooth learning curve from simple and known to, I hope, complex and new. Mainframe is, among other things, an experiment with this approach.

Tagging is one of the more interesting ways to select content. I first saw it used in 2008 as the interface between the AI and the audio system in LMNO. Back then I was mostly impressed by how it reduced the production dependency between AI and audio.

In 2010 and 2011, I worked on an unreleased Diablo-like that used tagging to procedurally generate levels. I did a lot of work on the level design and tool chain. At GDC in 2012, I saw Elan Ruskin’s talk about the dynamic dialog system used at Valve, which used an advanced tagging approach to allow writers to create dialogues. In 2012, we used tagging to select texts in a mobile game. I remember vividly how the actual tagging logic consisted of one line of code, but it took three of us a day to write that line. (It was a LINQ expression in C#, if you’re curious.)

The system in Mainframe is really simple. The core logic is this function:

Continue Reading »

Repetition and procedural content generation

Last night I innocently tweeted:

And then I watched a movie (Pi! still great) and 90 minutes later I checked Twitter and suddenly I had 50 replies.

My tweet was a bit gnomic and lacked context, as tweets often do. I wasn’t talking about repetitiveness: I was talking about how PCG is used by game designers, beyond “hey look we can create a billion dungeons / planets”. Not that there’s anything wrong with that, but I am interested in using it in other ways.

In Mainframe, the IF game Liz England and I made for Procjam, one of my basic tenets was that we should design the game around repetition, because we were using procedural content generation (PCG). When you play it, you will quickly find the element of the game that repeats. Whether it feels repetitive is a different question, although we don’t claim it is not.

This tenet was something I intuitively picked as a design heuristic, but afterwards I started wondering how core it actually is. Is it essence or accident?

I had a lot of fascinating discussions about this last night, and I’ve thought about it some more, and I now think that using PCG as a game designer will always involve repetition in some way. (Again, I am not talking about repetitiveness. This is not about procedural content generation being “bad”.)

Continue Reading »

Mainframe, the procgen horror IF game Liz England and I made

Last year I wanted to do something for PROCJAM, Mike Cook’s “make something that makes something” one week game jam, but circumstances conspired against me. This year, I collaborated with Liz England, and we made a horror interactive fiction game called Mainframe. It’s about a spaceship and its mainframe and something is wrong and it needs help.

Making it was a great experience. I learned a lot, and I’m going to be talking about it more.

The texts, assets, and source code can be found on GitHub.

The conflict between game design and AI programming

A few days ago, Julian Togelius tweeted this:

I replied that I have an interest in AI, and I agree with the quote. Julian didn’t reply, but I was still motivated to write this small blog post. (Thanks Alex :))

I don’t, in fact, know the context of the slide in question, or Julian’s position. But it strongly reminded me of a problem I have encountered a number of times in my career: the conflict between game design and AI programming.

Continue Reading »