Hello, everyone. You might like to know that my new book Make Your Own Programming Language is now also on itch.io. This version isn’t as pretty, but it’s more printable, with fewer pages and no syntax highlighting. The content is otherwise identical, and you get the same file formats.
In actual news, Emily Short’s RPS column for this week is a presentation of Texture, the hot new authoring system for interactive fiction. And you know… it bothers me to no end that people sing the praise of Texture’s input system after bashing two-word parsers for decades. Because that’s what Texture did: it reinvented the two-word parser. Which of course is perfectly fine, but can we please acknowledge and address the issue?
On a rather different note, via Vintage Is the New Old here’s a story about someone remastering a ZX Spectrum game after a quarter century — a very instructive, if overly technical, look at history. More approachable is an article about the masters of Commodore 64 games, but the moral is the same: we’re truly blessed nowadays. Why did the hardware makers from decades ago have to make their systems so damn quirky? In retrospect, the quirkiness appears to go way beyond what was needed to squeeze more features out of that limited hardware…
I’ll end with Hardware Gaming 101’s brief overview of Thomas Was Alone, the strange indie platformer from a few years ago that proved there was a huge market for games not driven by technology, and opened the way for more recent successes in the same vein — a most welcome trend if you ask me.
Until next time, consider the lessons of the past.
Hello, everyone. For once, I only have my own bad mood to blame for the shortness of this newsletter. As promised three weeks ago, my latest book, Make Your Own Programming Language, is live on Leanpub. It’s only of interest to programmers, especially those with a taste for retrocomputing and retrogaming. But you know my opinion: piecing blocks together in GameMaker is still programming, whether you realize it or not. And game design works best when you have at least a trace of process, as opposed to banging things together until they stick. So give it a try.
In unrelated news, all everyone’s been talking about lately is No Man’s Sky. That’s also the case of Michael Cook, who brings it up as an example of the language we use to discuss procedural generation. And you know… I couldn’t help but notice the fatigue of many reviewers when they mention how many millions of billions of planets there are in that game, and how they’re never going to see the vast majority of them. Which fortunately doesn’t really matter…
I guess the creators of No Man’s Sky forgot that the original 8-bit Elite was originally planned to have 282 trillion galaxies, or 2 to the power of 48 (presumably another byte was going to be used for the planets in each galaxy). And never mind that it would have made the artificiality obvious, especially on a home computer from the 1980s. But visiting 2000 star systems is a plausible goal for the determined player — there are just enough of them to make for a huge playground, yet few enough that you can actually remember some of your visits afterwards… and care. While enough content to fill millions of galaxies (a sizable chunk of the observable universe) just sort of blends into an amorphous mass. A statistic, if you will.
As an aside, let me underscore again than an 8-bit computer from the early 1980s, with just 64 kilobytes of RAM, could easily have handled a procedural universe on a scale comparable with the one in No Man’s Sky (if a lot less detailed). What exactly are we doing with a million times more memory and computing speed?
Hello, everyone. Not one week ago word got around the Web that old issues of their magazine were on the Internet Archive, and Nintendo promptly took them down. At least they have the decency to admit they’re just being control freaks, rather than pretending it’s somehow still about money. Oh well.
While on the topic of magazines, SPAG #64 is out is out — a very high-brow issue that’s about much more than just interactive fiction. So is Jason Dyer’s history of the original Adventure: an excellent illustration of why the public domain is as important in gaming as in any other artistic medium. Having recently reimplemented a public domain game myself (for my upcoming book), I can’t stress this enough.
Last but not least, over at Rock, Paper Shotgun Emily Short writes about the power of text as a medium. Knowing how little and poorly we make use of this power in most games (heck, most books), I welcome more discussion on this topic. Or preferably, more experimentation.
Thankfully, that’s happening aplenty. Stay tuned.
Hello, everyone. This week, Vintage Is the New Old notes that the Internet Archive just uploaded 13 years’ worth of Nintendo Power issues. Which reminded me of the times in 8th grade when all the boys would gather around a classmate whose parents were wealthy enough to get him issues of a similar magazine from France, along with Famicom games. It would be years before I got my own console, a Chinese clone, and by then everyone else had moved on to the SNES. But magazines still made people gather around in the classroom…
In unrelated news, we have a couple of rants, like this one about big game companies jumping into virtual reality feet first and messing things up, thus giving the medium a bad reputation. An interesting argument, but I predict that’s not what will kill VR again — rather it will be the realization that VR is still a gimmick with nothing new to say. And from a different source, here’s an opinion piece about what actually matters in procedurally-generated games. Gee, you mean some people play games for the (gasp) mechanics? As in, the one thing that’s unique to the medium? What a surprise… not.
I’ll end with an article on testing interactive fiction with automated gameplay, which contains some ideas easily applicable to other genres, like board games. It’s a kind of fuzzing, really, with comparable benefits and limitations. Also, the bit about repeating game states made me think about certain rules from the games of Chess and Go — it’s not just an issue for computers.
But you already know to take inspiration from the analog world, don’t you?
Is it a book? Is it a piece of software? It is a game? The second edition of Make Your Own Programming Language, that I finished writing today, has a little of all three. Most importantly, it tries to recapture the fun of making the computer follow your instructions, that forgotten quality of programming that used to lure so many people decades ago. It will soon be out to beta-readers, and then I’ll let you know.
In other news, Rock, Paper, Shotgun is running a series of articles on the future of procedural generation, specifically about spinning lore for computer role-playing games. Which would be pretty interesting, except for most roguelikes that would be overkill, while in more conventional CRPGs handcrafted characters, stories and settings are the whole point. Do games that aim to have emerging narratives even need that much detail, especially if it’s ultimately fluff?
Going forward, via Jay Barnson, here’s a Gamasutra article about Chrono Trigger’s Design Secrets, that manages to be useful even though I never played the game. And Jimmy Maher’s history of computer story games has reached the demise of Infocom; check out the quote from Marc Blank, who was stating who knows how long ago what myself and others have been blogging about all spring:
If all of a sudden you can ask any question, but there are really only three questions that are important to the story, you’re either going to spend all this time coming up with answers that don’t mean anything or you’re going to have a lot of “I don’t know that,” which is frustrating. I always suspected it was a dead end. The nice thing about the command-oriented game is that you can come up with a pretty complete vocabulary and a pretty complete set of responses. As soon as it becomes more open-ended — if I can say, “I’m hungry” or “I like blue rubber balls” — how do you respond to that?
To end on a nostalgic note, here’s a blog post about abandoned arcades, and the slow death game cabinets are sentenced to when left exposed to the elements. Thankfully, there is interest in rescuing these old machines as of late, so for the most part arcades are a bit of history we can expect to survive.
Until next time, don’t let the past be forgotten.
Hello, everyone. It turns out I missed a link last week, but it’s too good to pass up. Via Roguebase we get this interview with a co-author of Rogue, and it’s a wonderfully refreshing read. And via Vintage is the new old we learn of a new retrogaming zine, that provides a lot of content for a free publication. It’s clearly aimed at a North American audience, which kind of leaves me on the outside, but YMMV.
Last but not least, there are many books out there on how to get started with game development. I even wrote one myself. Not many of them are aimed at kids, though, and this is where Anna Anthropy’s new book comes in. (Hat tip to Emily Short for the link.) Which reminds me that back in the day, all those Basic programming books were squarely aimed at children, with colorful, whimsical covers depicting friendly computers as playmates, and full of references to whatever was popular in media at the time. When did game development turn all adult and serious?
Oh wait, I know: when the kids of the 1980s grew up. And that’s us. How did we manage to so thoroughly forget that programming was supposed to be a game?
Imagine the following scenario: you’re prototyping a game, and for now all you want is to put a colored box on the screen. It should be a simple function call, right? Wrong. For one thing, you can’t just draw anything you want, it has to come from an external image file. Which is in a complex, multi-layered format that can only be created with large specialized software suites, most of them expensive, and requiring semi-professional knowledge to use at all. Then there’s the code itself: you have to unpack the file, pick only the parts you need from it, and set up the display just so before sending any data to the screen…
Thankfully, various people have created more friendly wrappers, that let you load a 3rd-party image and blit it to the screen with just a couple of function calls. Then you discover that the image format you’re using does not, in fact, work on another operating system, contrary to what the library documentation claims…
A while later, a consortium of vendors releases a portable API that does, in fact, let you draw directly to the screen. Except it takes telling the machine exactly how to line up each pixel so that they form a box, for every color channel separately. And then you have to funnel the resulting data through the pathway described above…
Ridiculous? Absurd? Implausible?
You know, it’s funny. Usually when I’m working on something not related to games, the newsletter tends to be pretty thin, since my attention is directed elsewhere. This week is an exception, and a big one at that.
Let’s start with news from interactive fiction, where there’s a new authoring tool on the block. After years in development, Texture was just opened to the public, prompting Emily Short to interview co-author Jim Munroe. An interesting experiment, but I’d rather explore the interface from Infocom’s Journey, as detailed by Jimmy Maher
Moving from IF to retrocomputing, via Vintage Is the New Old we get an interview with a C64 developer from Sweden — an intriguing history lesson. And from the same source, Nintendo launches a NES clone with dozens of classic games built-in… more than ten years after cheap South Asian clones of the legendary console went out of fashion. Good morning, big N. Last but not least, the world’s first graphical MMORPG (it ran on the C64 nearly 30 years ago!) has been open sourced, and they’re trying to get it running again. Specifically, the server, which is a rather thorny problem, for reasons both technical and legal.
To end with a trio of random links, the annual Procjam conference and gamedev event just announced its upcoming zine (with a call for submissions), and for fans of tabletop roleplaying there’s a new web-based tool to make rule supplements that look just like official D&D books. And knowing the kind of work that goes into good-looking RPG books, I can only appreciate the effort. Last but not least, let me highlight ComboPool, a Pico-8 game that manages to blend billiards with 2048, of all things.
Goes to show that limitations really do spur creativity. So be creative.
Hello, everyone. This week I must confess to a couple of broken promises. I didn’t get around to uploading a fix for the bug found in the online version of Glittering Light. And last time I forgot to announce my decision to abandon the graphical port of Tomb of the Snake. Sorry, but an already overengineered game was only getting even more so, FreeBasic’s supposed portability turned out to be illusory where it mattered (though SDL carries part of the blame), and the community less than friendly. But I learned a few things; my next projects will be tools, not games. Hopefully you’ll find them useful.
In other news, early this week Konstantinos Dimopoulos alerted me about Procedural Content Generation in Games, an academic textbook on the topic that’s nevertheless an easy enough read overall. It seems the project was launched a few years ago, but it’s only now ready for publication. Grab it while it’s still free!
Also in the way of long reads, Hardcore Gaming 101 is running a six-part feature on the Fallout series. And for the impatient, my friend Chris Meadows compares two online games of Catan. Last but not least, a piece of news not related to games, but just too cool to pass up: the source code for the Apollo 11 mission is now on GitHub! Amusingly, lots of people have been submitting pull requests, some jocular, others not so much.
But that’s about it for the past week. See you around.
Hello, everyone. This week felt like very slow progress, but after a long coding session yesterday, the game ended up nearly complete:
Not depicted: the horrible screen flickering every time you make a move on higher zoom levels; hopefully it will go away on more powerful computers, because clearly double buffering in sdlBasic isn’t working the way I thought. But hey, it runs, and looks just fine too. Water is surprisingly nice for such a simple trick, and knowing the exact screen aspect ration enabled me to come up with a nice non-verbal HUD — the minimap is displayed on-demand like in the new online version. Speaking of which, I found a bug in the latter that made speed boosts basically useless by the time you found any. Going to upload a fix soon, along with the desktop port.
In other news, this week I found yet another HTML5 library to ease roguelike development. Unlike the competition, rl.js is a single 600-line file, and doesn’t try to include the kitchen sink. It handles input, output, tilesets — including procedural art features — and manages the map, including collisions. In other words, a focused (and very well documented) product. Only its use of the General Public License is a potential obstacle.
Still on the same topic, there’s a new roguelike review blog in town, and it might just be worth following for a fresh perspective. And speaking of perspectives, just yesterday I was pointed at an academic, yet quite readable, article on diversity in games with procedural generation. Tl;dr version: the data structures and algorithms we use, even the programming languages, encode biases and assumptions, of which we have to be aware, lest we end up conveying unintended messages.
Last but not least, the news surfaced a few days ago of the brand-new Interactive Fiction Technology Foundation, which aims to future-proof certain tools and services the IF community has come to depend on. A most welcome initiative.
But I’m over my quota again. Until next week, code mindfully.