In the last installment I talked about the overall goal I had in mind for Aotearoa, and the pros and cons of the various convenience features I included. This time I want to talk about some of the other technologies I included and cover some of the issues and lessons learned based on my development schedule and design choices. There will be some spoilers below, so consider this fair warning if you haven’t played yet!
Additional Game Features
Aside from the convenience features I talked about earlier, there were a few other things I included in Aotearoa. The first, and most obvious, was the animal naming feature. I’m embarrassed to say that despite many long hours playing Beyond Zork with my friends back in high school and college, I had completely forgotten that you were able to nickname items in that game. Now that I think back, of course I remember doing so (for some reason that is now [probably fortunately] lost, we named the sword ‘Bbob’), but at the time I couldn’t think of another game that had done it.
The basic technique is not particularly difficult — you attach a nickname to a thing (or in this case, an animal) and make the nickname property describe the thing. In fact, I think Emily has an example of doing this in the Inform documentation that I used as a starting point. There was a bit of tap-dancing required to get this to work cleanly — for example, when naming or unnaming, when do you refer to the actual name and when do you refer to the nickname? How do you avoid infinite loops when printing the name of something that is nicknamed? And of course, how does it interact with the keyword system? But it’s not really very difficult, and it seemed to get the most consistently positive reactions of any feature I included in the game.
I also worked up a foley system that didn’t really perform the way I thought it would. If you’re not familiar with the word, ‘foley’ is a filmmaking term that refers to sound effects that are recorded offstage and added into the film in post-production to enhance the quality of sound and enhance viewer immersion. My foley system was supposed to provide a framework for adding in short flavor-text messages that described what was happening in a particular scene or area.
The system was implemented as a table-driven mechanism that could key off of several different conditions, and iterated through a prioritized list of possible messages that were assigned different appearance probability levels. If that sounds complicated, it was! It ended up being quite a bit of effort to set up, for results that weren’t really measurably different than just picking randomly from a list. I used this mechanism for the boat and ocean scenes, and then abandoned it starting from the mainland.
I think that it worked fairly well in the scenes where I used it, but in a lot of cases, the last thing I needed was more text spewed out onto the screen, particularly where there were a lot of other actions going on. Too many one-sentence action blurbs and the text really starts to feel disjointed. Once the animals came into play, the extra foley was just too much.
I still think that atmospheric foley text is a good idea, but I would not go to such lengths to try to systematize it in the future. I think a dozen or so possibilities, tailored to the specific game state that exists at the time, would do the job just as well with much less work.
The radio was a late addition to the game. Up until very late beta, you had to return to Eruera every time you wanted to ask him about something. Since I wanted to emphasize the interactions with him, this caused some serious issues with either pacing (if they chose to return) or delivery of plot information (if they chose to go it alone). Also, once I decided to add the fear mechanic, Tim had to speak to Eruera, and there was a very real chance that folks would become stuck if they didn’t realize that.
Enter the radio mechanism. By doing a bit of manipulation with scope, I was able to allow communication via the survival radios. This allowed Tim to call back to Eruera at any point, and more importantly, allowed Eruera to call Tim at certain points of the story. This allowed me to hint more organically and push plot information without worrying about too much backtracking. Of course, the player could still drop the radio, but it would be clear what they were doing, so I wasn’t too worried about that.
There were some fairly significant technical issues to deal with (some of which weren’t dealt with and need to be fixed in the post-Comp release), including removing visual cues from the conversational sequences when communicating by radio, ensuring proper termination of conversations when moving with and without the radio, and handling conversational state when transitioning between scenes.
Finally, there was the mechanism used to ride the notoceratops. Originally I’d just plugged in Graham Nelson’s Rideable Animals extension. This worked — it was possible to hop on the dino and ride away, but as there was really only one way to go, the quasi-freedom actually served to interrupt the action, and frustrate the player.
I then tried to put the riding sequence on rails, and just carry the player through to the camp, but there ended up being no sense of agency, and the player just had to hit ‘z’ over and over again, which was unsatisfying. Sam Kabo Ashwell pointed out in late beta that a riding system where you had limited control over the beast, such as in The Edifice, might be a good compromise. I had never played The Edifice, but the idea was clear, and I implemented the mechanics that made it into the final release: you can turn the dino and spur it faster or slower, but you don’t have full movement abilities.
I really like the way this turned out — there’s a gentle challenge in figuring out the movement commands, and you have to use them appropriately to get to your destination, so a sequence that could be either “you can’t go that way” frustrating or “z.z.z.z” boring ends up building some involvement and excitement up to the climax of ramming your way into camp.
Design and Timeline
I have three young kids ranging in age from one up to nine, one of whom has autism, which means I don’t have vast stretches of excess time to put into hobbies. I plowed most of the free time I did have last year into working on Aotearoa, which pushed all my other activities into the shadows for the most part. This added up to hundreds of hours — my best guess is around 400, probably half of which came in the final month — writing and debugging Aotearoa, spread out over almost a full calendar year. This worked well in some respects and caused some serious problems in others.
One of the most obvious issues was sustaining interest in the project given the slow pace of development. I was highly motivated to pursue the project, but even so it was disheartening to look back over a week’s work and see very little progress. When I encountered infrastructure issues that required rewriting, it was intensely frustrating to see several weeks of work slide down the drain.
I tried to get around this by ensuring that I spent at least 4 hours a week working on the project, and by breaking down development tasks into very small, discrete milestones. This breakdown helped in two ways. First, it helped me to better analyze the requirements of individual tasks, which helped to reduce the number of times I got blindsided by something after getting halfway done. Second, it gave me a feeling of progress and accomplishment when I could get through a couple hours of coding and be able to check four bullet points off my list.
Another major issue was keeping a distinctive style throughout the game. Since Aotearoa was written in bite-sized chunks over the course of a year, it was very erratic in style. Early drafts were really rough, and it wasn’t until I got some really good writing advice from Sam Kabo Ashwell and Aaron Reed that I took the time to go over everything, tighten it up, and make sure it flowed well and had a consistent voice and vocabulary. Yes, I said “tighten it up”. I’m aware that it’s still pretty verbose — you should have seen it before!
Even if I hadn’t had a spread-out creative cycle, I’d still advocate a thorough rewrite. Just like static fiction, your first draft is rarely publication-worthy. I was much, much happier with the prose after cleaning it up.
Another major issue, which the extended development cycle just made worse, was the second-system syndrome in the game. In software development, there’s a well-known tendency to try to address every weakness in your first product when you design your second one. You’ve learned all the lessons and you’re ready to make something vastly better! In reality, that overdesigned second system often collapses under the weight of extra features packed into it.
I got lucky in that although I had tons of extra features in the game, most of them were derived from quality extensions and didn’t cause the system to collapse. Even so, the end of development and the beta period were full of frantic scrambling to address strange bugs and unintentional interactions that were the result of feature bloat. I got away with it this time, but my third game will pull back from the full cornucopia of features I stuffed into Aotearoa.
Finally, there’s one last consequence of the longer development cycle: looser, cruder code. This was intentional, and I feel it was a key to the success of the project. If you’ve programmed much, you likely know the phenomenon programmers call “flow”. You get into the zone, the world recedes, and the mental model of the software you’re trying to write becomes clear. You can accomplish amazing things when flowing, but often these things are not as easy to understand when you’re picking them up hours or days later, when you’re out of the flow state.
And getting into flow takes time. When you’re coding for an hour here or an hour there, it’s not easy to achieve and sustain flow, and you risk spending a lot of time staring at complicated code structures that made sense when you wrote them but seem incomprehensible now. The engine puzzle in 2009′s Grounded in Space was like this — so complex that I could only understand it after an involved process of coming back up to speed on it.
In writing Aotearoa, I knew it was going to be a long project and that I was going to be working on it piecemeal over a long stretch of calendar time. So I deliberately tried to avoid clever, complex coding tricks wherever possible. By keeping organized, sticking to straightforward, well-named rule-based code and resisting the temptation to write big blocks of complex logic, I helped to ensure that I could always pick the code back up, get to where I left off, and make progress right from the start. The resulting code isn’t always as cool or elegant, but it’s understandable and functional, and helped me make efficient use of my time. In the end, the important product is the game, not the source code for the game.
Writing Aotearoa was much more work than I thought it was going to be, even though I knew I was biting off a pretty large project. From designing puzzles while waiting in a Federal jury room to researching New Zealand plant and animal life, it’s been both fun and educational, and I’m very happy that most players have found that old-fashioned excitement and sense of wonder that I was hoping to convey. I hope these postmortem reports have been useful to other authors who are considering similar technologies or who are working under similar time constraints.