Latest News

Submitted for your approval is a Terrible, Old Manse. This is my first attempt at making an interactive fiction game with Inform 7. The game is an interpretation of the classic Atari 2600 game Haunted House.

As you play the game, please do send me a list of typos or weird behavior that you find. It is easy enough to bang out new releases.

Enjoy!

This Christmas, my family received a Wii game console. You can install a version of the Opera web browser on it and play games on the Internet.

Lucky for you, both my Tic-Tac-Toe game and State Secrets work on Wii through Opera. Enjoy!

As part of my technological foraging, I have been playing around with Ajax as presented through the new hotness that is jQuery. The result is a very humble, but all Ajax, tic-tac-toe game. This replaces the all flash version I had on this site for a while. Not only did I improve the AI of the computer player (thanks CS210!), but I have completely validated HTML and CSS files to boot.

Part of my inspiration comes from my current nighttime read, jQuery in Action by Bibeault and Katz. Besides gently easing the reader into jQuery concepts, the authors turned me on to the concept of unobtrusive javascript, which is the idea that HTML, CSS and javascript should be kept separate from each other, thus simplifying development considerably. One way to intrepret this concept is that HTML, CSS and Javascript all need to be keep in discrete files. That means no "onClick" attributes in the HTML, please. In structure, one can find liberation.

The architecture of my tic-tac-toe game follows a pretty standard client-server model. The server bit consists of a single PHP script that handles game session and AI. The client bit is simply an HTML file supported by CSS and Javascript. The client API is narrowly defined to prevent obvious forms of cheating and to enforce the idea that the client is a display and input mechanism that has little idea about how to play tic-tac-toe. The game logic is enforced by the PHP script. I'll discuss the design of the game engine later, but let's look at the client first.

The entire source for tic-tac-toe can be found here.

The place to begin with the tic-tac-toe client is the index.html file. This is a validating HTML 4.01 Transitional document. It has no TABLE tags at all. It depends on CSS float to make the playing board and handle the rest of the page layout. Because of some problems with Internet Explorer, there is a bit of IE-specific goo that forces a warning to appear in that browser. That will be the subject I return to last.

That HTML file is so clean, you could eat off it. Anyone who has done PHP or even a lot of javascripting will be surprised that such a simple file could be the basis of anything complex. As far as the game is concerned, the most interesting elements in the HTML file are the DIVs that have an ID attribute beginning with "s". In traditional video game parlance, these function as both buttons and sprites. I could have used HTML buttons here. Part of me still thinks that's the right way to go, but just using DIVs looks a lot more "gamey" to me. All the wiring of event handlers for these DIVs is handled in the ttt.js file, described shortly. The look and layout of the client is provided by the ttt.css file, which holds no surprises.

The client-side magic happens in the javascript. As it promises to do, the jQuery library greatly reduced the burden of locating and attaching elements, attaching click handlers and Ajax processing. Because the jQuery library is loaded before ttt.js, jQuery functionality is accessible in this file. The first four lines of code are pretty harmless:

var Game = new Object();
Game.timeout = 5000;
Game.square_clicker_enabled = false;

$(document).ready(init);

A global object called Game is created that will hold client-side game state. Scoping in javascript is a little primative, so having one global object in which to store various bits of information helps to reduce namespace clutter. The game property 'square_clicker_enabled' is set to false to prevent undesirable button clicking later on. I'll get to that. The most powerful statement here is the ready() function that calls init() (not shown yet) when the DOM is fully constructed in the browser. As any primer on jQuery will tell you, the more traditional onLoad() event for BODY elements does not run untill all the graphics are loaded on the page. The ready() function is ideal of initialization code. Speaking of which...

function init() {
   $("#newGame").click(new_game_clicker);
   var arg = new Object();
   arg.get_board = 1;
   $.ajax({url: 'move.php',
           type: 'GET',
           data: arg,
           dataType: 'json',
           timeout: Game.timeout,
           error: bomb,
           success: function(a) { paint_board(a);}
        });
}

The init() function sets up the click handler for the "New Game?" button/DIV that ensures a new session and a blank board on the server. The fancy jQuery selector simply looks for an element with the ID of newGame. An object is created to hold parameters to be passed in the following Ajax request. The call to "get_board" simply requests the board state of the current game, if applicable. If the call is successful, the paint_board() function is invoked with the structure returned from the server. Even though the server returns a JSON serialized string, jQuery deserializes this structure and passed it to the function. That's some pretty terse code for an RPC mechanism!

function new_game_clicker() {
   if (confirm("Really start a new game?")) {
     var arg = new Object();
     arg["new"] = 1;
     $.ajax({url: 'move.php',
            type: 'POST',
            data: arg,
            dataType: 'json',
            timeout: Game.timeout,
            error: bomb,
            success: function(a) { paint_board(a);}
        })

   }
}

There's little new code here at all. All veteran javascripters will have seen the confirm() dialog function. The click handler for the new game button is mostly another Ajax call. This one creates a new session and empty tic-tac-toe board on the server. Again, whenever the state of the board might have changed, paint_board() needs to be invoked.

function square_clicker(e) {
   if (Game.square_clicker_enabled) {
        Game.square_clicker_enabled = false;

        var arg = new Object;
        arg.pos = this.id.charAt(1);
        $.ajax({url: 'move.php',
           type: 'GET',
           data: arg,
           dataType: 'json',
           timeout: Game.timeout,
           error: bomb,
           success: function(a) { paint_board(a);}
        });
    } else {
        alert("Thinking!");
    }
}

The click handler of each game board square is a little trickier. At its heart, the handler is merely responsible for sending the human's move to the computer using an Ajax call. When the player moves, the computer also makes a move and the new board state is returned and passed to paint_board(). Again, there are a lot of details behind that tiny bit of code!

The Ajax call is protected by a boolean. The idea is to prevent humans from wildly click on squares before the computer returns with the new game state. The opening move for the computer can take a few seconds to calculate, even when the depth of recursion is limited! I suppose that's why algorithms with a runtime performs of O(n!) are frown upon.

As simple as this mechanism is, Internet Explorer does not seem to like it very much. When I use that browser, I get all kinds of weird board states. It is a mystery to me why this happens, but this is why I include a warning to IE users in the HTML document.

function paint_board (a) {
   if (a.board == null) {
     $("#status").text("No game in progress");
     Game.square_clicker_enabled = false;
   } else {
     for (var i=0; i < a.board.length; i++) {
        $("#s" + i).empty();
        if (a.board.charAt(i) == '0') {
            var events = $("#s"+i).data("events");
            if (events == null) {
                $("#s"+i).click(square_clicker);
            }
        } else {
            $("#s"+i).unbind('click',square_clicker);
	    var e = a.board.charAt(i).toUpperCase()	
            e = $("<span></span>").text(e).addClass("p");
            $("#s"+i).append(e);
        }
     }
     Game.square_clicker_enabled = true;
     if (a.msg == null) {
        a.msg = " ";
     }
     $("#status").text(a.msg + " ");
   }
}

Finally, the heart of the client code appears in paint_board. Given a structure from the server, it displays the game state on the board to the human. The board's state is presented as a nine character string where each position represents a place on the board. A zero is an unoccupied space, an 'x' represents the human's move and a 'y' represents the computer's. Notice that the client doesn't even know that much. It simply knows that 0 states are presented one way and non-zero another.

When the board is painted, the square_clicker_enabled flag is set to true, allowing the human to make a new move. If an open square is indicated by the board state, a click handler is installed if one does not exist. If the square is occupied, the click_handler is removed. Doing this without jQuery would have been horrible.

And there's the client! Amazingly small and even valid HTML. Will wonders never cease?

This post is already long. At some point, I'll go into the server code which has some moderated clever AI and some awful code to determine a win condition. Keep reachin' for the stars!

Because it's fun to play a character who's playing a character in a fantastical world of magic. I've got an advanced copy of the game and already have a level 9 Creepy Introvert! His Power Sulking skill is unstoppable.

Last Defense is a game that should be familiar to most of you. While playable, the game is about 80% done. It plays fine on my macbook (60 fps), but simply crawls on my windows box (14 fps). I'm not sure that the problem is. Use at your own risk.

I developed a framework around pygame to "rapidly" develop this game. While I didn't spend a lot of time fooling with pygame, I did spend a ridiculous effort on the basic game logic. It's amazing how complicated space invaders really is.

Graphics continue to elude me, so I borrow those from existing free projects. I have found a pretty decent pixel editor called Pixen for Mac OS X. Of course, that program does not magically imbue me with graphic talent.

The framework needs, er, work. It doesn't not help me manage different game "scenes," which is the metaphor I use to describe the various game screens. In the case of this game, I'd say there are perhaps 2 scenes.

Sigh. Programming is hard!

Blasterama was written by R. S. Brook as an example of python game programming for his sons.

This straight-forward arcade game reminded me a lot of the atari games I played growing up. Since I had access to the source code, I hacked in joystick support. Pygame does a great job at reducing the complexity of joysticks, so this was easy. Next I started cleaning up the code to make it easier to add the following features to the game:

• a lives system
• scoring
• background music
• a wave-level system
• ship defense shields
• scrolling starfield background
• game restart
• different sized aliens
• windows setup installer
• a backstory for the game :-D

So download the Windows package now or grab the source code. It's good for a laugh!

I feel a little dirty using this tool, since it does the heavy code lifting for you. On the other head, I get to concentrate on story and art more.

I've got a concept for an adventure game that I'm working through now. Let's see if I can make this happen.

Following on the earlier post I made about programming hex maps for games, I have taken a stab at a Java program that generates different sized maps. You can download the zip file here. If you've got a recent version of the JRE (1.5), this should work for you out of the box by double clicking on it. Otherwise, you can run it by unpacking the archive and typing "java -jar HexMap.jar".

This toy just generates hex maps according to adjustable parameters. Hit the "Repaint" button to see the glory.

In a future post, I'll be explaining the math and heuristics I used. I'll also make the source code available then. However, there are better implementations I have in mind for this. Eventually, I should be able to emit an actual game that uses this work. No time, no time. Sigh.

Hex maps. Every wargamer knows them. Expert D&D players broke out of their dual-axis world during their Isle of Dread campaign to use these six-sided monsters. Here's a close up of one:

Hex maps, it is claimed, offer a more natural choice of direction for players who want to model open air terrain than the good old graph-paper, cartesian plane, 2 perpendicular axes maps. Graph paper maps do match up well to the four cardinal points of a compass, which is nice. Even better for programmers, these kinds of maps are easily represented with 2 dimensional arrays, a data structure that even grumpy old C supports!

And it's easy to find the neighboring squares in this kind of map. Consider a coordinate system whose origin (0,0) is the upper most left corner of a grid. Going to the right adds to the x coordinate, while going left subtracts from it. Similarly, going down to the bottom of the grid adds to the y coordinate, but going up lessens the y value. If the starting square can be thought of as being at the coordinate (x,y), then neighbors can be found at predictable offsets:

• Northern neighbor: (x, y-1)
• Eastern neighbor: (x+1, y)
• Southern neighbor: (x, y+1)
• Western neighbor: (x-1, y)

It's easy to extrapolate how you could find the diagonal squares too if you wanted to, but that's not desirable for wargamers. There are at most only four equidistant neighbors for any given square on the graph paper map. Sure, you could include the four squares pointed to by the diagonals of the square, but these are more distant from the center of the square than the neighbors at the cardinal points. And that makes wargamers mad! How can you accurately plot the range of your 18th century dutch cannon using only the cardinal compass points?! Hex maps offer up to six equidistant neighbors for any given hex. And that means more accurate pathing for cannon fire. Super!

But how do you model a map in which each element has six neighbors? You could make a linked list of structures that contain pointers to each of their neighbors. But that's not a particularly natural fit and would cause a great deal of programming overhead to populate and search. Is there a way to get all the benefits of a hex map into a 2D array implementation? Yes, there is but you need to to think about a hex map in a certain way.

Look at Figure 1 again, but try to see the map as three columns of hexes stacked on top of each other. Notice that although the first column (with hexes A and D) are horizontally aligned with the last column (with hexes C and F) but the the middle column (with hexes B, E and G) is a bit offset. This is an important detail that will affect our hex map model. We can order these hexes from left to right, top to bottom if we take into account the offset columns that happen every other time. That is, all the odd number columns are offset from the even numbered ones. We can make a horizontal row by starting with a left-most hex. Then, find the "northeastern" neighbor in the odd row. To find the horizontal neighbor of that hex, look to its "southeastern" side. In Figure 1, the first horizontal row is marked out as hexes A, B and C. Continue this alternation until you hit the last column of hexes.

Once we have a predictable sorting order for our hexes, we can use a 2D array to model this map. Why bother with a 2D for a linear list? The answer is that a 2D array naturally maps to the way computer screens are represented in most drawing libraries. 2D arrays also fit easily into an SQL database system. So, even though the thing we want could be represented in a number of ways, there's a lot of convenience to be had in thinking of (x,y) coordinates. So given a hex coordinate, how can we determine its neighbors in a 2D array? The answer is: it depends!

It depends on whether the hex is in a odd numbered column or an even numbered one. Consult the two tables below. I look for neighboring hexes in a clockwise direction starting at the top of the hex (which would be the northern neighbor).

Figure 3: Calculating Neighbors for Hexes in Even Columns

Figure 4: Calculating Neighbors for Hexes in Odd Columns

And for the purposes of this discussion, column 0 counts as even. Does your brain hurt a little? Mine too. Let's make this more concrete.

Using Figure 1, let's create a 2D array that maps the hexes in the right order.

Figure 5: Mapping a Hex Map into a 2D Array

I have included the coordinates of the hex in this table for easier reference. Let's walk through our algorithm to find all the neighbors of each point.

Whew! That's quite a table of mind-numbing numbers! What this table is attempting to show is the neighboring hexes for each hex appearing in the left-hand column. Computations which result in a valid location are shown with that area's label. Computations that produce bum results are shown in italics, just to give you some idea how the edge cases work.

Now that you can easily find the neighbors of any hex, you can implement any of the class of algorithms designed to calculate shortest path, distance, etc. Of particular note, A* pathfinding and shortest distance routines should fall out nicely once you wrap the neighbor calculations into some kind of function.

Which is an exercise I leave for the reader. I realize that modeling hex maps is a solved problem, but I worked this stuff out for myself. Thinking of these sorts of things keeps me off the streets and high on life.

Peace out.

UPDATE: Other people are interested in hex maps too.

This dude reminds me of Gnat Torkington. And it's not just because he talks funny.

Dear Internet,

For no reason more than nostalgia, I'm looking to buy a copy of the TSR minigame "Revolt on Antares". If you've got a complete, usable copy of the game that you'd like to sell, please drop me an email (jjohn [at] taskboy dot com). I'm not looking for a collectable, near-mint copy.

Thanks!

UPDATE (Jan 12, 2008): After a nerd-fisted slap fight on eBay over a near-mint version of the game, in which the bidding when over $100, I decided that I'd try Alibris, which has a used copy in an unknown condition for $27. Who's laughing now, TSRwhore88?

Even when I win, I lose.

FINAL UPDATE: I received RoA today and was pleased to find all the counters still attached! Near Mint, baby!

Funny thing, Atari Space Invaders. It's mind-numbing in its simplicity and yet I love to play it for as long as I can. It's perhaps the best realized game of the original batch of Atari 2600 titles. At some point I'd like to more formally contrast Atari's invaders with the original arcade version (which the NES aped), but that's a tomorrow project (for the gameshelf?).

Anyway, in a game without much point, a favorite meta-game is to see how many times you can "roll the score". As you will remember, the score in the 2600 version of this game only goes to 9999. After that, the score is reset to 0000.

In my day, you had to make your own fun out of the video games that were available.

Anyway, tonight I managed to die just as I rolled the score. I've never ended a game with 0000 before. Where's my gold-plated gladis of victory?

A funny retrospective on the banality of video games from a wacky Brit.

For no particular reason, I'd like to record my preferred order for tackling the minibosses at the beginning of the NES game Megaman 2. Pay close attention.

1. Airman: Use your shooter
2. Metalman: Use your shooter
3. Woodman: Use metal blades
4. Bubbleman: Use metal blades
5. Crashman: Use air attack
6. Heatman: Use bubble attack
7. Flashman: Use heat attack or shooter
8. Quickman: Use crash bombs

If you follow this order, you should have all the special weapons you need when you need to get 1UPs and other goodies.

Good hunting.

I woke up early this morning and starting reading about A* pathfinding, which led me to implement a binary heap in Python.

Once again, I've been playing with python for game programming on Windows. I'm up to atari 2600-level games now. Yay!

Compiling python scripts in .EXE files is extraordinarily easy, which makes shipping a python game to a machine without python installed possible. This is a huge advantage over Perl. Even the dependent libraries used by called modules are bundled easily.

I'll start posting some of my python work as soon as I create modestly interesting game.

UPDATE: For those interested in 30 seconds of Atari-like fun, I present Stubby Falls Down (3MB Windows Installer).

From Gamasutra (registration required):

«When I first started writing commercial game code, my code was liberally littered with comments, and I couldn't imagine any drawbacks to this. As time passed, I noticed something odd: the code and the comments grew increasingly out of sync, and I found that wrong comments cost me more time than correct comments saved me. The cutting and pasting, and late night alterations that happen when the pressure's on all meant that the code changed while the comments didn't.»

I couldn't be more in sync with the sentiments of this article. Copious comments can breed laziness. Debug code! If the code is hard to understand, rewrite it!

I saw the following image while looking at google news today. Very appropriate for the subject. The U.S. needs a multi-billion dollar space-based missile defense program as much as a fish needs a bicycle. Still, I enjoy cold war imagery as much as the next person of my mature stature.

You know what would make a great video game? Forced prosyletization of non-Christians and rock stars.

Cashing in on the best selling and brain-melting Christian-fantasy porn called Left Behind (no, I'm not linking to that crap; find it yourself), some schmucks created a sort of real-time "first person saver" game in which you convert (or shoot) non-believers in an effort to feel good about your imaginary friend in the sky. It's called "Left Behind: Eternal Forces," which is appropriate since the forces of stupidity are as deathless as dread Cthulhu.

I fully enjoy the Tom Clancy angle to the game's title. There's nothing like replacing the adrenaline rush of Cold War M.A.D. with violet religious bigotry based on a unctuous interpretation of Revelations.

Sure, there are those weak, degenerate liberal Christians would have you believe that conversion to Jesus worship should be voluntary, but they're just pussies.

It seems that there will always be those theists who pine for a homogenous religious culture. I don't really understand this desire. When has a culture with a hegemonical religion been a really great place to live? We already have that situation in the U.S. and it's called Salt Lake City. If that's your idea of paradise, you can get really cheap tickets to it from Jet Blue. If you don't like deserts, I invite you scenic South Boston where you don't have to be Irish and Catholic to live there (you could also be Catholic and Irish too), but you'll sure be hated a lot less if you are.

Real, fact-based agenda people know that allowing and embracing diversity leads to a more pleasant, healthy, creative and productive society. There's just something darn helpful about someone calling you on your delusions that moves a culture forward. When everyone agrees with each other about too many things, you pretty much get the Taliban in Tragikstan.

Hey, I know! Why not make a game in which you shoot the zombies raised by Jesus after the Tribulation? Call it "Left Behind: Not on my Watch." You could get Charlton Heston to do voice-over work for it. Make it an massively multiplayer online game to boot! That would kick ass!

So you thought the Atari 2600 was dead, eh? Well, you were wrong. Here you will find a hacked version of Kaboom! called Kabul! that features, yup, Osama bin Laden. Work out your terrorist angst on the old VCS.

[Original use.perl.org post and comments.]

Volity is a p2p gaming system for computer versions of board games. This project is fairly new, but there are several games already to choose from including Barsoomite Go, which is like traditional Go, but played with Icehouse pieces. The screenshot above shows my crushing defeat of a hapless go-bot.

I no longer fear the coming of robots. Their simple alpha-omega pruning AI is no match for my madd skillz.

There are many things in life that I'd like 200 pounds of. Gold, rubies, diamonds and VT220s all top my list. What I didn't want, but did little to prevent, is arriving at 200 pounds of body mass again. This year has brought stress from a number of quarters which have all convinced me to hide in a corner and eat. Well, fie to that I say.

With the major eating holiday over and the leftovers nearly gone, I can begin to work off some of my unwanted girth. If Boston gets a relative dry winter, I will able able to walk off a good deal of weight. If the city gets snowbound for long stretches of time, I'll need a plan B, which, God help me, may involve spending money on a gym membership.

Still, I hate reading blogs about people bitching about their weight, so I'll give you a glimpse into one of my secret desires. In the late 90's, Interplay released a computer role playing game (CRPG) called Fallout, in which you, as the survivor of WWIII, had to journey out of your bomb shelter vault to fetch a much needed tech thingie for your vault's continued well being. Along the way, you get into wacky hyjinx with dogs, raiders, ghouls and super mutants. Did I mention the large irradiated bugs? There's plenty of them too. A good time is guaranteed for all.

A few years later, Interplay released a sequel sagaciously called Fallout 2. Set a couple of decades after the first game, the new adventure casts you as a descendent of the original "Vault Dweller," who became too much of a barbarian to live in the Vault he saved and so he founded a village. As an uncouth "tribal," you must find a pre-war tech thingie that will dispel a withering disease that afflicts the village. The adventure is much bigger, taking place on the shattered Pacific coast of the US. This is the game I fell in love with (although I must say, I didn't care for the ending very much). Fallout 2 captured a lot of the magic of paper and pencil RPGs that I loved as a kid. Unfortunately, Interplay went tits up a few years ago, so the Fallout line is pretty much dead. Let's not speak of Fallout: Tactics, shall we?

It turns out that I'm not the only fan of Fallout. That honor must go to a group of Russians, who spent a great deal of time reverse engineering and tampering with Fallout to make modifications. The good news is that there are a number of tools to make new adventures in worlds of Fallout and Fallout 2. The bad news is that the game engines (by Bioware) are complicated. I guess that part of the fun of hacking.

Now for my secret desire: I'd like to implement out D&D modules using the Fallout 2 engine. It's a simple thing to recast the medieval fantasy setting into the retro future world of Fallout. I'd like to start with B2 The Keep on the Borderlands, as that is both simple and very much in line with the rest of Fallout.

I'm keeping notes on my hacking quest. I'm trying to learn the scripting language, which isn't bad but has a number of unfortunated C language idioms. I think I get how simple dialogs and quests work (and how to make those appear in the PIPboy PDA). Somethings I can't do are new graphics, because I have no graphic talent. That's a blessing, though. I can focus on scripting the adventure and simple reuse what's there.

If I succeed even a little at this, I'll write up my hacking adventure. I'm certain people will continue to hack on Fallout for several years.

Somerville residence will no doubt rejoice to learn that a new episode of the Gameshelf will air Wednesday, October 26 at 10PM. The following games are reviewed: Space Station Assult, Awful Green Things from Outer Space and Star Control 2.

Most special of all, I'll be cohosting this ep and I killed in the studio. Don't believe me? Watch this opening clip.

Law and Order, we will crush you in the ratings. No hard feelings.

Update: Here's another trailer for you, this one of The Shining. It has a little different feel to it. It suggests that the Shining is less a supernatural horror film and more a feel-good chick film. So many people miss that about this movie. Enjoy.

A few weeks ago, I visited the lovely SCAT studios to help Jason McIntosh with his show The Gameshelf. In a weird twist, I was asked to be in front of the camera to play Space Station Assault, created in Cambridge, MA. It was a different way to kill a few hours on the weekend.

Yesterday, I returned to SCAT with Jason as a temporary cohost of the show. The job involved a lot of sitting and talking, which I think played to my strengths as an actor. We then filmed a two minute intro in front of a green screen, during which we were very silly.

I don't know when the show will air. This is will be episode 2. The show normally airs at 10:00PM on Wednesdays.

I want to give a very public thank you to Jason for offering me this opportunity and hope that the once the world has seen my obvious talent, the emotional scaring won't be too horrible.

If I'm needed, I shall be in my trailer...

The third and hopefully last incarnation of State Secrets is now available on taskboy.com. There will be bugs, but the game is afoot now. It really has a win condition and PvP violence, so that's delic.

State Secrets is a game I designed that was inspired by Seth Able's Funeral Quest and his excellent earlier offering Legend of the Red Dragon (L.O.R.D). In SS, you assume the role of either an FBI agent or shadowy Man In Black to ferret out a collection of Secrets from ne' do wells around town. The game ends after someone defeats the 3 Lodge sub-bosses in Pier 13.

Putting together this game was a lot more work than I ever thought and I'm certain I'm not done. I need a lot more error detection and cheat prevention, at a minium. Business applications are far easier to write.

Anyway, sign up and poke around. Let me know what you think.