$NEWTON64 :: {blog|games}
 
Super Mario Solar System

I was bored and I decided to do something.

The Solar System is pretty big—like, pretty very big. The enormity of the cosmic scale is often lost on folks, and so scientists have come up with various models to demonstrate just how mind-numbingly vast this place can be.

Now, I’m not a scientist, though I do play one in the videogames. Ergo, I decided to make a scale model of the Solar System using the original Super Mario Bros. (NES). Using level maps so thoughtfully provided by our benefactors Ian Albert—and a little bit of ImageMagick—I stitched together a single-row map of the entirety of the (non-bonus) worlds of SMB.

That map is available here.

(NOTE: The map doesn’t seem to render in-browser, but I know that if you File->Save As…, Windows Super-Clippy Image Preview Madoodle/something does open it correctly).

Next, knowing that this image was 107008 pixels wide, and choosing Neptune as my endpoint (F*ck Pluto. I liked it before it was a dwarf planet. (Though it is still quite cool.)), I determined (assuming Neptune’s average orbital distance from the Sun is 4.5 billion kilometres) that each pixel in this SMB map is equivalent to 42052.93km. I then compiled this table, using average orbital distances provided by Wikipedia.

The distances, in pixels, in this table show where each planet/region is to be found, assuming of course that the Sun is found at PIXEL ZERO. It then becomes trivial to draw in each planet.

That map can be found here.

I’ll let you kids do the downloading-and-at-looking, but a few salient points:

  • Mercury and Venus are both close in, in Level 1-1.
  • The Earth is placed at the second ? block in Level 1-2.
  • Mars is also in Level 1-2.
  • Holy crap that’s a lot of empty space.

Nerds. They’re not just the waste byproduct of candy production and unicorn tears anymore.

The More You Know

Harry’s 1st Walkthrough

What the hell?

I created Harry’s 21st Birthday seven years ago, entirely on a whim. The game is not very logical—nor is it very enjoyable—so I can understand if you never played it to completion.

This morning however, in a burst of vanity, I decided to search around for “harry’s 21st birthday,” and there—nestled cozily below Prince Harry’s royal celebration, and above the Harry Potter fanfic (!!!)—I found the first (extremely beautiful and entirely thorough) walkthrough for any of my games.

A game that is all of seven minutes long, and all of three minutes good.

I haven’t felt this touched since INAPPROPRIATE JOKE.

Honestly, I am confused and gladdened and flattered that someone would go through the time to do this—and just in time for Christ’s Mass (in kg), my heart is growing three sizes too large.

Now you really have no excuse!

Learn the hottest pro-tips!

Throw Harry a wicked-sweet party!

When you get to Hell, try the birthday cake!
(It’s BYOBeelzebub.)

Skrud or Pizza?

PREMISE 1
My friend Skrud is awesome.

Now, a few weekends ago, I had a group of friends over to play video games, board games, and have some beers. The crew had mostly gathered except for my aforementioned friend Skrud, and it was at that point that I decided to order some pizza. Some time later, the doorbell rang, to which one of my friends reacted:

“Is that Skrud or pizza?”

Several guffaws and handshakes later, we agreed that this question would be probably the best thing to happen to games since “Tic-Tac-Punch in the nuts” was rewritten in its more contemporary incarnation.

Time passed.

Then last week, it occurred to me that Manmas was just around the corner (I’m non-orthodox and celebrating tonight). Knowing that Skrud would be in attendance and proceeding from Premise 1, I decided to make the game in the space of a week. Yet another opportunity to play around with Unity (huzzah for iTweens and Coroutines).

Once again, this is a complete bloody mess—the idea being to gather up to four willing/drunk competitors to survive an assault on the senses and morals, and identify whether a rapidly-progressing series of images is either Skrud or Pizza. If this doesn’t sound like a grand ol’ time to you, clearly you’ve never taken part in a clinical study for compensation of up to $27.

As per my methods:

The Good
  • Hahahahahahaha
The Bad
  • Not enough user testing from the start.
  • It was done in a week, but even then I think I took too long.
The Ugly
  • My code. It’s a ball of delicious spaghetti. Learning new possibilities in Unity as I went along meant I often ripped apart or hacked open segments of code to fit the new bit. More design from the start == good idea.
  • The game itself. I often aimed for higher production values, but time constraints made me abandon some ideas (e.g., a doorbell ringing and a door that opens every time one is presented with an image). In this case though, I think “thrown together with disdain and held together with duct tape and disdain” is an appropriate stylistic choice.

Maybe it’s a party game. Maybe it’s terrible (definitely).

Whatever it is, it’s either Skrud or Pizza.

Puzzle Shots

My good friend Erin Robinson recently released her biggest game to date, Puzzle Bots. If you haven’t played it yet, now’s your chance. Trust me, it’s a keeper. Go ahead, I can wait.

Puzzle Bots banner

No, seriously, buy it.

Given that I’d also recently started following The Drunken Moogle, it seemed only logical to somehow combine the two. It is therefore with a great deal of pride—and a moderate amount of less-shame—that I give you…

PUZZLE SHOTS

Puzzle Shots

It is now officially on like Donkey Kong as well as the other, lesser Kongs.

I tried to ensure that all the ingredients would be readily available, or at least easy enough to find in stores. So, without further ado, let’s meet the team (from left to right).

HERO

Hero

  • 1 part orange juice
  • 1 part vodka
  • Dash of blue curaçao

Directions: Mix OJ and vodka separately. Pour blue curaçao into bottom of glass, then gently layer OJ mix on top.
Tasting notes: Refreshing and citrus-y. Quite the go-getter.

ULTRABOT

Ultrabot

  • 1 part crème de menthe
  • 1 part Jägermeister

Directions: Slowly layer Jägermeister over the crème de menthe.
Tasting notes: The Jägermeister provides an initial, punishing Eastern bloc-style punch, while the crème de menthe reveals the sweet underbelly.

KELVIN

Kelvin

  • Literally a few drops of crème de menthe
  • Sambuca

Directions: Pour a few drops of crème de menthe into a glass, then top up with sambuca.
Tasting notes: As this is mostly made of sambuca, clearly it is meant to be set aflame.

IBI

Ibi

  • 1 part gin
  • 1 part grape juice
  • 1 blueberry

Directions: Mix the gin and grape juice in a glass. Add the blueberry.
Tasting notes: Ever the shy one, Ibi tends to curl up into a ball on land.

BOMCHELLE

Bomchelle

  • Rosé wine
  • Dash of tabasco sauce

Directions: Pour a shot full of rosé wine. Then add generous dashes of tabasco.
Tasting notes: Starts off sweet enough, but carries a surprisingly potent sting.


And there you have it! Remember people, always drink responsibly. And if that’s not an option, blame the new guy.

Spare Parts — Walking a procedural path

As one may be aware, my graduate studies at McGill were focused on procedural content generation (PCG) for videogames—the end result was a rather primitive-looking pipeline for generating terrain, road networks, and buildings. While I enjoyed the work, it was something of a let-down for me because the bar had already been set extraordinarily high, most notably by ETH Zürich graduates Parish and Müller in their “Procedural Modeling of Cities.” Follow that link, read their paper, explore the site, and be bloody impressed.

P&M’s fantastic-looking algorithm is based on a heavily-modified implementation of L-systems, named for Hungarian Aristid Lindenmeyer, who developed them to model branching systems seen in plant development; later it was applied to blood vessel networks, fractal imagery, and a few other applications. P&M made their version context-aware and applied a two-step process of 1) proposing “global goals” (e.g., roads follow a circular or other global pattern) and 2) adapting proposed roads to local constraints (e.g., roads don’t go into the water, and can intersect with previously-built roads). 1

Being the consummate slacker that I am, I took one look at the algorithm in P&M’s paper and dismissed it as too complicated to implement for the purposes of my thesis—I had other, more different fish to fry, after all. And so I turned my back on L-systems, which felt like something of an intellectual cop-out.

A year later though, we come to Spare Parts, as previously advertised.

In a nutshell, Spare Parts will be “a procedurally-generated grave-robbing prototype.” Thus far, I’ve stuck to simple methods to generate the graveyard borders and the terrain contained within: three intersected rectangles define the extent of the level, which is then filled in with a variety of tiles distributed according to a single-iteration Perlin noise function. If it sounds overly simplified, well, it is. But I have to say, I think the results aren’t bad, if you’ll forgive my (lack of) artistic skills:

noroads1

noroads2

noroads3

Note the small white gateway, which marks where the player starts each map.

If nothing else, I like to think they look like plausible levels, if not necessarily photorealistic. Either way though, it’s still missing the finishing intermediate touch which inspired this whole darn post: randomly-generated roads. Because graveyards just aren’t the same without an interminable winding path2. I decided that this was probably as good a time as any to return to L-systems, and perhaps redeem myself for having abandoned them so hastily.

Looking online for an appropriate starting point in Lua (scripting, you’ll recall, being one of my motivators for this prototype), and still fully expecting it to be a long and complicated process, I happened to come across this forum post. Read it at your leisure, but I’ll go ahead and spoil the punchline: L-systems are bollocks. Well, not in every situation, but certainly in the case of road network generation.

P&M’s L-system algorithm, like any L-system, relies on “production rules,” which, on parsing a string of symbols, essentially just says “when you see substring X, turn it into Y,” with probabilities and/or conditions sometimes associated with a given rule. The magic of L-systems then comes from defining “branch” symbols, and balancing a certain regularity of pattern with some element of chance; plants, for example, are often mathematically precise, and yet still subject to environmental vagaries3. But looking at P&M’s rule set shows that about half of their rules ignore the “global goals/local constraints” pattern and are used instead for simple housekeeping: prepare a symbol (road) for deletion, delete roads in the next turn, propagate time-delay information, and so on. This, argues the author of that forum post, is useless and complicated work, and I’m inclined to agree. The author then proceeds to systematically deconstruct the L-system algorithm given by P&M, approaching the underlying, functional core of the procedure; that is, to maintain a list of “proposed” roads, and then evaluate them in some order, see if they are acceptable (with or without some minor modifications), and then store each accepted road while “proposing” a handful more branching from it. The post gives the following (slightly modified) pseudo-code:

initialize priority queue Q with a single entry: r(0, r0, q0)
initialize segment list S to empty

until Q is empty
  pop smallest r(ti, ri, qi) from Q (i.e., smallest ‘t’)
  accepted = localConstraints(&r)
  if (accepted) {
    add segment(ri) to S
    foreach r(tj, rj, qj) produced by globalGoals(ri, qi)
      add r(ti + 1 + tj, rj, qj) to Q
  }

Here, r(ti, ri, qi) represents any proposed road: ti is the time-step delay before this road is evaluated, ri is the actual representation of the road (e.g., a vector), and qi contains meta-information relevant to to our globalGoals function (e.g., for circular roads it might describe the polar angle, or it might declare the segment to be a highway as opposed to a country road, &c). The localConstraints() function evaluates a given road (passed by reference, so that the road can be modified—snapped to local intersections, for instance), and then determines if the road is acceptable or not. If it is, the road segment is added to segment list S, and the globalGoals() function uses that road to suggest new branching roads, which are then added back to priority queue Q with an incremented delay.

This is beautiful. It is the absolute height of simplicity. No housekeeping, no complicated symbols, just a priority queue and a simple loop. Developers can just focus on tailoring their globalGoals() and localConstraints() functions to the application at hand, and not worry about implementing a convoluted evaluation framework.

Needless to say, I immediately emailed the author of this forum post and offered him a beer; second, I got to work implementing his algorithm (the framework, at least) in my PCG library, and the global/local functions in Lua. For the purposes of Spare Parts, my needs are simple: roads can only be horizontal or vertical, and there are no necessary global patterns to speak of (if you’ve ever walked around certain parts of Père Lachaise Cemetery, you’ll know what I’m talking about). I impose the following constraints on the paths: that they form proper intersections; that, if two paths are parallel, they must be separated by a given minimum distance; and finally, that a certain minimum fraction of the terrain tiles must be “near enough” to a path.

These are extraordinarily simple rules. But will they produce anything remotely interesting? Have a gander:

roads1

roads2

roads3

Rocks and trees added as decorative obstacles. Eye-bleeding yellow used for contrast.

And of course, you can apply the same algorithm to the same tracts of land and still get different results…

roads4

roads5

roads6

It’s all still fairly primitive, but I was primarily concerned with making “roughly believable” paths through these graveyards, and I’m happy with the results, even if they’re not necessarily quite sophisticated, and lifelike. They should at least be fun to play.


1 If I’m not mistaken, the rad dudes at Introversion are using a similar system for Subversion.

2 This is something of a pun, of course, since the makers of The Graveyard also made The Path.

3 As a side-note: Przemyslaw Prusinkiewicz3a, who worked with Lindenmeyer, runs the Algorithmic Botany project at the University of Calgary, where you’ll find an impressive collection of virtual plants generated by L-systems.

3a Rudzicz. Prusinkiewicz. They’re cops. Polish cops.