Anyway!  I had a lot of fun with a game last night, and I wanted to share it.

I’m very MMO weary; World of Warcraft ultimately left me with a really bad taste in my mouth.  Mostly because it was very competitive in ways that I did not enjoy.  Competitive being the polite way to put it; in short, in a world without consequence where having a selfish attitude ultimately saves you time and energy, it makes more sense to run up and take things from other people than to help them.  This has been my experience at least.

Since I dropped WoW years ago now, I never really played another MMO.  I gave a couple of free ones a shot, but found them all depressingly WoW-like.  However, an MMO has finally come along that has convinced me to purchase it.  And indeed, after playing the stress test for it, I can’t help but wonder if this is the next thing that’s going to be copied and imitated by the rest.

Specifically, I picked up Guild Wars 2.  I never played Guild Wars 1; it just didn’t really seem like my cup of tea, I wasn’t very interested.  However, after hearing a description of GW2 and watching over someone’s shoulder during the open beta, I decided to give it a shot.

Part of why I was willing to give it a chance was because of its pricing model.  With GW2, you pay for it once.  You buy the game and that’s it; no monthly subscription.  They have a cash shop and do the “micro-transaction” thing where you can buy stuff you don’t technically need instead.  I’m actually okay with this; one of my problems with a game like World of Warcraft, is if I’m playing $15.00 a month to play, I feel an obligation.  I’m “throwing money away” if I don’t want to play it for a month or two.  With Guild Wars 2, I’ll feel okay putting it down for awhile if I want/need to; it’s considerably less committed.

So!  What’s the game like?  For one thing, there’s no “factions”.  There’s PvP (which I did not attempt) that is “realm vs. realm” (or rather, server vs. server) but when you’re running around questing, there’s no “other team” running around out there with you.

Secondly, the game plays more or less like you’re all in one group.  Most MMO’s have a concept of “grouping”, getting together with other players to do something.  The big benefits are shared loot and shared quest objectives, among other things (safety in numbers, the ability to do bigger things, etc.)  GW2 has groups, but if you’re just running around by yourself, you are sort of implicitly grouped with the people around you.

So, if you run up and help someone who’s in trouble — you actually get rewarded!  In fact, anybody can “resurrect” anybody else in the field — and get experience for it!  This is the first time I’ve played an MMO and actually felt … well, like a part of the world.  My natural desire to be helpful and good to the people around me is actually rewarded; and in turn, I get treated likewise.  This game actually fosters camaraderie; we are really in this thing together, and by rewarding “good Samaritan” behavior, its making being part of the team a core part of the game.

Secondly, and this is something Mass Effect 3 touched on and I think we’ll see more of in RPGs, quests are more about your location than about talking to an NPC with a ! over his head.  Quests have kind of “radii” around them; when you enter a “quest radius” you get a little notification in the corner of your screen.  What I said before about implicit grouping?  That works for quests, too.  Everyone gets rated a “medal” for participation; bronze, silver, or gold.  If you walk in at the end of the quest, you still complete the quest — you just get “bronze” level participation.

I didn’t get to play long enough to really know the implication of the different “participation” levels, but I found the basic concept really compelling.  The world is dynamic, too; NPCs run up to you and ask for help.  You can ignore them if you want, but if you query them, they will tell you where quests are nearby.  While the game does mark places on the map where there are NPCs that have quest information, most of the quests I did I just found by wandering around.

The world feels rich and alive.  There’s just “stuff” going on, and you can join in whenever and however you want.  And when other people are around, doing the same quest, you don’t think “aww damn, they’re going to take all the pigs I have to kill and make me have to wait for the respawn”.  It’s more of a relief thing; now you’ve got someone watching your back.

On the topic of quests, GW2 has this concept of sort of … “quest tools” I think is the best way to put it.  You can pick things off the ground — some of them are silly, like broken bottles at a bar (I guess for bar fights?  I never quite figured that out) but other things are fun.  For instance, there’s a “Ghost Busters” style quest where you pick up a staff and you get a bunch of new abilities.  You use the staff to capture ghosts.  Other things are kind of silly, too — like there’s a quest where you pick up unexploded mortar shells and return them to the NPCs.  If a bad guy interrupts you, you can throw the mortar at them and it will explode!

The quest tools override your normal ability-set and give you something fun and new to explore.  Which brings another interesting point; your “ability menu” is based on the weapon you’re holding.  Each weapon type has a different set of skills available to it.  Your skills are therefore a combination of weapon type and class, which means each class has a LOT of different play styles.  It’s not so much about “rotations” of buttons — WoW Simon — you get to pick how you want to play your class and use the abilities that make sense to you.

This kind of feels like the tip of the iceberg; GW2 is a really different game from the other MMO’s, and also expands on things that I think general RPGs are starting to adopt.  I highly recommend the game, and I think we’ll probably be seeing much more in this vein in the future.  And I look forward to it!

I’ve been working on a new game lately, with a nice pseudo-3D effect for the display. After a while, it dawned on me that what I was doing there essentially amounted to voxels. Which was strange, because while I had read about voxels before, my interest in the topic was academic at best. But now the connection was made, I decided to take a closer look, just to know what possibilities I might be overlooking.

But first, what exactly are voxels?

You know what pixels are, right? On the computer, an ordinary two-dimensional image is made of little dots arranged in a grid. Whenever you want to see what the image represents, you simply draw each dot on the screen, row after row, making sure the dots in each row line up vertically. Well, voxels are exactly the same thing, except in 3D.

Which brings up an obvious question: short of an actual volumetric display, how do you present a three-dimensional grid of dots to a viewer? Why, via 3D projection of course! And as I demonstrated in a previous article, that’s really easy to do for the basic case.

var TwoPointFive = {
    Camera: function (x, y, z, f) {
        this.x = x || 0;
        this.y = y || 0;
        this.z = z || 0;
        this.f = f || 200;
    },

    project: function (x, y, z, camera) {
        x -= camera.x;
        y -= camera.y;
        z -= camera.z;
        var scale = camera.f / z;
        var px = x * scale;
        var py = y * scale;
        return [px, py, scale];
    }
}

With that in place, all we have to do is go over each layer in turn and plot the coordinates of each voxel on screen.

for (var z = DEPTH - 1; z >=0; z++) {
    for (var x = 0; x < WIDTH; x++) {
        for (var y = 0; y < HEIGHT; y++) {
            var p = TwoPointFive.project(x, y, z, camera);
            // Determine the voxel's color somehow.
            var color = getColor(x, y, z);
            // Paint your voxel here.
        }
    }
}

Here, I make sure to start from the back and come towards the camera, a.k.a. painter’s algorithm. A more popular option nowadays is to generate a cube around each voxel and let OpenGL worry about the rendering; but then, that would take care of the 3D projection as well. As it is, I simply paint each voxel as a square, scaled according to distance from the camera (see source code).

Wait… isn’t it cheating to use a flat image in a discussion of volumetric pixels? That’s more like… a texture! No, really, it is. It’s also the same basic principle; with voxels, we simply have layer after layer of data, instead of just one. Which presents a problem.

Believe it or not, this coarse scene — full code here — contains as many voxels as the one before. (Though mostly obtained by mirroring.) The square-cube law ensures that the amount of data required increases fast with resolution. Luckily, there are ways to mitigate this problem.

This is an ordinary heightmap (see code), except rendered with voxels instead of polygons. The height of each data point is encoded in its shade of gray. It works because we’re only interested in the surface — and as a bonus, we can still use the same value to color the voxel. (Under realistic conditions, a color map would be in order.) Note how I’ve drawn the voxels taller than they are wide in order to hide the seams, and it’s still not perfect. I guess there’s a reason polygons are more popular.

What’s the point of using voxels, then? Nowadays, they are mostly used as a stylistic choice, as they give games a very distinctive appearance. They also naturally enable fully modifiable environments, something rather difficult to implement in a polygonal world. Otherwise, polygons are better studied and directly supported by the commodity GPUs built into almost any computer.

Back around 1997, however, before 3D acceleration was ubiquitous, voxels were enjoying considerable attention. Quite a few famous games used voxels for some or all of their graphics, Blade Runner being my favorite example. See, voxels are easy to understand, and require very simple calculations. But the comparative difficulty of animating voxel objects, together with the march of technology, relegated them to just another tool in the toolbox. Use wisely.

(Illustration: Voxel Fashion Party, by Raffi Asdourian; CC-BY. Tux icon courtesy of OpenClipart.org.)

Fun with voxels by Felix Pleșoianu is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.

Meet Conrad Cook. Not only he posted a minimal, “starter” Ramus document, a useful thing I failed to do myself, but followed up immediately with an original work called Unicorn Story. Which I am now hosting on the Ramus website at his request. Thank you, Conrad.

I also took the opportunity to flesh out the aforementioned website a little more, including an answer to the frequently asked question about (not using) jQuery. Hope this helps.

On the Ramus side, development turned out to be very easy indeed. The only real problem is that I keep typing href instead of rel — understandable after over a decade of Web development. It may be worth implementing URL autodetection, like in HTML TADS, but my laziness is stronger than the annoyance factor.

Anyway, you can download the game here. Enjoy!

Created in 1985 (according to IFWiki), Alan may well be the oldest interactive fiction authoring system still in active development. Despite that, it never achieved much popularity. IFDB lists 46 Alan games; Baf’s Guide, only 42 of them. To put things in perspective, that’s the number of IFComp entries on a good year. That’s too bad, because the system has unique qualities.

I downloaded the binary archive of Alan 3 beta 2 for Linux, the latest stable version as of this writing. The system falls under the open source Artistic License; beware that both the website and readme files may still refer to the old “register-ware” terms in places.

Speaking of the manual, it comes as a 227-page PDF which apparently describes the system in its entirety. That’s possible because Alan is a specialized programming language, with all the needed functionality hardcoded into the runtime, and the (otherwise ample) standard library is merely a bonus. That’s in contrast with platforms such as Inform 6 and the Z-Machine, which can and have been used for things other than interactive fiction.

While on the topic of the standard library, the Alan Beginner’s Guide recommends copying it into every project and customizing in-place. That has the undesirable side effect of forcing you to distribute the customized version with your game’s source code, should you wish to make it public; be sure to read the Artistic License if you do.

If on the other hand you go without the standard library, it turns out the game doesn’t understand any verb at all by default, except for whatever exit names you define (and “undo”, oddly enough). At the very least, you’ll want something along the lines of:

verb 'look', l does look. end verb 'look'. verb 'save' does save. end verb 'save'. verb 'restore' does restore. end verb 'restore'. verb 'quit' does quit. end verb 'quit'. verb transcript_on does transcript on. end verb transcript_on. syntax transcript_on = 'transcript' 'on'. verb transcript_off does transcript off. end verb transcript_off. syntax transcript_off = 'transcript' 'off'. 

Section 3.17 of the manual appears to suggest you can reuse language keywords as verb identifiers, but in reality you need to do it like in the code above, as per the sample game Saviour. We can expect a documentation fix soon; Thomas Nilsson was very nice and prompt in answering my e-mail.

By the way, I kind of expected to use the same identifier for an exit and the location it points at, but that was probably unreasonable. On the plus side, exit names are arbitrary. (There is no built-in concept of a compass, but you can simulate one easily enough.) That, coupled with the ease of declaring verbs per location, makes Alan a natural fit for keyword-driven games, and those just happen to be in vogue.

Overall, Alan looks like a nice combination of simplicity and advanced features. It even has rules, like the much more advanced Inform 7, and the ability to nest ordinary rooms provides an elegant solution to multi-presence objects and, yes, vehicles. On the other hand, there is no way to manipulate exits once defined, doors have to be implemented with manual checks inside said exits, and the built-in score system is quite limited; even the official documentation recommends making your own instead.

Last but not least, the verbose syntax suggests that intricate puzzles might be tedious to code, which would make the system better suited for literary pieces. (But see the above remark on clever features.) Illustrations and sounds are supported, but only in the most basic way. All in all, Alan has a very distinct flavor, and it’s worth keeping it in mind as an option.

(Alan logo used with permission.)

A look at Alan 3 by Felix Pleșoianu is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.

In game development, one of the most important learning experiences is releasing a complete, polished title, no matter how small and simple. You know what else is? Porting a game to a different platform.

Now, with most kinds of games, the challenge is adapting to the input and output capabilities of the new platform; the game logic, if well designed, can stay the same. But with a text adventure, it’s the other way around; gameplay remains essentially unchanged, but the internals can change considerably. That’s because an interactive fiction platform isn’t just a virtual machine, but also a world model, and the programming languages themselves, while of course equivalent, can have very different philosophies.

For example: by design, the original Catch That Cat can’t be made unwinnable; you’d think that arranging the same puzzles in the same layout would be enough to maintain the invariant. Nope… it broke because TADS 3 handles objects in the dark differently. Don’t skimp on beta-testing.

Another thing that can change is player expectations. In a two-word-parser title, one expects sketchiness; on a mainstream platform, you can’t get away with nearly as much. Especially in a small game, where extra responses can make half the fun. What I wrote last time about leaving out verbs? Bad idea.

Last but not least, there is the little big issue of going with the grain and making a port that fits the new platform instead of fighting it, even if that means changing certain details. Or even central elements, such as how you communicate with the human NPC in order to obtain a vital item. It would have been easy to do it exactly like in the original, but the game would have been poorer for it. After all, that particular approach addressed an engine limitation which doesn’t carry over.

On the flip side, be on the lookout for things you can easily keep the same, as well as things you can’t keep at all. In my case, ShuffledEventList messages, and explicitly listed exits. The latter are an interesting case: what is a built-in option in TADS 3 comes as an extension in Inform 7, and is outright impossible in Alan 3 (unless I missed something). As this happens to be a basic feature of my game, choosing the wrong target platform could have compromised the whole effort.

Best of all, working on this gave me improvement ideas I was able to backport into the original implementation, so I ended with two improved versions for the price of one. Now, to put all this newfound experience to good use…

What porting can teach you by Felix Pleșoianu is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.

It’s been almost a year since I last looked into IF authoring systems, and the market has shifted again. A Hugo title became the most talked about game in 2011 — one that features extensive multimedia and random combat to boot. Yay for Cryptozookeeper! There is also an ever-increasing number of (choice-based) Web games, outnumbering those written for my new favorite platform, TADS 3.

Speaking of that, soon after a new release of TADS came out with Web play support, thus bringing the old powerhouse in line with its main competitor, the news spread like fire that a new online service came out enabling people to author Inform 7 stories online. To top it all, mere days later the young Quest system announced official support for a similar feature!

All that rekindled my interest in authoring, so what started as a test drive last year turned into a serious porting effort. Whether a tiny, retro-styled text adventure is a good match for a modern authoring system and the current IF scene remains to be seen. But whatever happens, the porting process taught me invaluable lessons.

On the one hand, a more sophisticated authoring system requires some adaptations. Puzzle solutions that couldn’t be implemented with a two-word parser become the default; others must be adapted to the full containment model. Unimplemented nouns become unacceptable and so on.

But! Not everything needs to be changed. The original Catch That Cat relies entirely on nonverbal communication with the NPCs, and that still makes perfect sense for the cat. Using explicitly listed objects to decorate a room, as opposed to flowery prose, is part of the game concept, and that works even better when you can outright mark them as Decoration.

Verbs are more of an issue. Two verbs that any casual IF player will try are TALK TO and USE. Luckily, TADS 3 has the former by default, as for the latter, the default response for non-existing verbs is:

The word “use” is not necessary in this story.

which cuts down on the number of extraneous verbs I need to implement. (That, and TADS 3 has an enormous list of built-in verbs.) On the minus side, those verbs I can’t get away without involve more boilerplate than I’m used to. Oh well.

One stumbling block was turning a large, hairy block of if-else instructions into declarative code. Not only it required considerable lateral thinking — not my strong point — but it resulted in more code, not less. At least the interaction is more natural now, and hey, that’s the kind of thing that makes game development as fun for me as playing games.

Last but not least, I managed with a bit of work to install the latest FrobTads and figure out how to use it, only to realize I will still need the official Windows version to build stand-alone games, as well as for syntax highlighting, until I can find or make my own.

Looks like the adventure is just starting… again.

P.S. I found the TADS 3 library extensions in the mean time. Durr!

Adventures in Interactive Fiction by Felix Pleșoianu is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.

There’s been much talk lately about Unity 3D. A combination of rich toolset, portability, price and other factors conspire to make it increasingly popular. The recently released Indie Games Developer magazine opens with an article on it, and this sentence jumped at me:

In fact, [Unity] is so simple that it sometimes scares people off initially as they do not believe that something so easy to use can produce professional quality games and that there must be compromises to be made.

To which Nightwrath replied, “easy for whom? professionals who have used such tools for years?” And I remembered something else he told me recently (and which matches my own observations), namely that many amateur projects seem to fizzle at the stage where a character model loads and can be moved around on a simple map. You may say that’s burnout: they used up all their energy to get to this point, and they have nothing left for the game itself. And I admit that being able to focus on making the game proper is a good thing.

But you see, that’s the real difficulty.

There, I said it. Making the engine is laborious, but straightforward and exciting. You know exactly what your goal is, and all you have to do is tackle the various problems one by one. But once you get to making the actual game, suddenly we’re talking hard decisions. And if you thought programming was fiddly, wait until you get to polishing.

Tell you what. Fire up your favorite 3D modeler and model the rooms in your own apartment (just the walls and such for now). Done? Now furnish it. Grabs some premade models off the net, we’re just playing. Tired yet? Animate the doors to make them swing. (You did add doors, right?) Make the light switches flippable, too. And do you have textures on everything? Good. Now multiply that by 50 or 100 for a single building. How many of those were you planning to have in your game?

If you haven’t run away by now, maybe we can talk about collisions, interactions, AI waypoints, the AI proper, dialogues, flavor text… Or assembling all of that in a game that’s playable, winnable and fun.

You want all these operations to be as easy as possible. You want to, because you’ll be doing them again and again, way past the point where it stops being fun. That’s plenty of effort right there, never mind that effort in itself does not imply quality results. As for the need to make compromises, when did that become a problem? You can’t even do engineering, or design (which is a branch thereof), without plenty of compromising. Don’t you think Shigeru Miyamoto had to compromise with Mario? Or Gunpei Yokoi with the Game Boy? And yet they are the most popular video game character, and the best-selling gaming device ever, respectively.

Effort, quality and compromises by Felix Pleșoianu is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.

No, I won’t give you an “in the old days” speech. Things were different back then. But I’m thrilled to live in an age when so many people can make a contribution to the world’s culture, without having to ask anyone for permission. As Michael Masnick put it recently, We’re Living In the Most Creative Time In History, and that’s not a given. Be grateful for this freedom. Fight for it.

And don’t forget to check out Computoguy’s blog.

How cool is that?! by Felix Pleșoianu is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.