Egressors - those who escape

Charlene and I have really gotten into escape rooms lately.  I mean, really gotten into them.  We did our first room in September of 2016, and since then we've been playing as many as we can.  So far we've done about 26 rooms in 5 states and 3 countries.  If you haven't tried them yet, I just can't recommend them enough.

We started a spreadsheet to track which rooms we've visited, and it wasn't long before I thought there ought to be a website for that.  I've seen at least one (escapetalk.nl), but it's mostly in Dutch and doesn't cover our area.  After a while I decided this was something I could do.  So after a few months of on-and-off coding while the kids were asleep, I'm finally ready to launch:

EGRESSORS.COM

Egressors Logo

Egressors is a directory of escape rooms in the New England area, and a place where you can sign in and track your own escapes.  We're starting simple and planning to build up features over time.  For instance, right now you can track your escapes but you can't see anyone else's.

Fancy graphics.

One of the first updates I plan for the site will be to see how many users have logged plays at each room, and see the escape rates.  I'm holding back on reviews and comments and other judgement-y features at first, because I don't want the site to impact any of the venues in a negative way.

Another early update I hope to include will be a tailored news system - so that users can sign up to hear about new rooms and events, but specifically ones in their area or for rooms they are "watching".  Some rooms have their own mailing lists, but you have to sign up to those one at a time.  There are mailing lists out there for general escape room info, but they don't have any way to filter to local information.

The other escape-room-related project we're working on is a "passport" for rooms in the North Shore area.  There's a great concentration of rooms along I-95 north of Boston, and if other "egressors" are like me, then once you're hooked you want to escape them all.  This passport provides a physical way to track where you've gone, and a goal greater than just one room.

Not valid for travel to foreign countries.

Plus, and of course, there's a puzzle on it.  To solve the puzzle you need to visit enough of the rooms (not necessarily all of them).  Each room will write something different that will get you one step closer to the solution.  Nine venues in the North Shore area have signed up to distribute the passport, all fine places to get out of:

• 8D Room Escape and Board Games
• Amaze Escape
• Breakout
• Escape This Live
• Escapology
• Key Quest at Laser Quest
• North Shore Escape
• Time Warp
• Wicked Escapes

At some point I might add a feature to egressors.com where you can enter the solution to the passport and thus get some internet points.  If the passport goes well I could see expanding it to other areas.

So if you're in New England and like escape rooms, check out the site and consider signing up for an account.  And if you're near the North Shore then keep an eye out for the passport.

QblePon is the best game

The best game.

I want to fix a problem with the internet.  First of all, I think we can all agree that QblePon is the best game.

But the thing is, I searched for a list of QblePon characters on the internet and as far as I can tell there isn't one.  This is ridiculous, people.  There's a list of animals with fraudulent diplomas, for Pete's sake.  Where is someone to go when they can't remember which QblePon character has the floppy disk in its head?  (It's Stanchmode)

So I'm here to help.  Please enjoy below a list of all the known QblePon characters.  There are probably more, but these are the ones that Hector mentioned when he described the epic game that he and This Kid played, which come to think of it may be the only game of QblePon ever played.

Before we begin, a little bit about the game itself.  It's a card game.  We know that two players can play it, and they sort of mostly take turns.  The characters seem to have a single stat: Something the range of one to five.  Also, in this episode of the TV show, it is revealed that Twirbirdler can do an attack called "Gashing Slice".  It is not known how the attack works in the game.

Well that's enough details, let's see some characters.  You know you want to look at them.  Here they are in alphabetical order:

Beestburdin

Stat: 5

"My main man and yours."

Hard to stop thinking about.

Feedems

Stat: 3

"All day long."

Combo: Good with Feedems (Jersey) and Feedems (Raw).

Feedems (Jersey)

Stat: 3

See also: Feedems.

Feedems (Raw)

Stat: 3

See also: Feedems.

Jamtape

Stat: 3

"Not actually a QblePon character."

Actually, a QblePon character.

Pantso

Stat: 5

Combo: Can be played with Skweezout.

Puckershine

Stat: 1

Robustolé

Stat: 1

"Some fourth level beeswax."

Not the best card to start with.

Seemingly Sam

Stat: 2

Skweezout

Stat: 2

Combo: Can be played with Pantso.

Stanchmode

Stat: 5

Tallsocket

Stat: 4

Twirbirdler

Stat: 3

Attack: "Gashing Slice"

Zappadasher

Stat: 1

May not have been played in Hector's game.

Zock Click

Stat: 3

There, problem solved.

Mancala AI

My kids were into mancala for a little while this year, and so I made a version of it that you (mainly my kids) can play in a web browser.  A secondary reason to do it was to explore more about the game and its strategies.

Looks like south has a pretty good lead here...

Here's some of what I learned from this paper: Design of Artificial Intelligence for Mancala Games:

There are around 650 billion board positions (depending on which rule set you use, here I'm focusing on "Kalah").  In the year 2000, someone at Caltech found the winning strategy for it - that is, they solved it so we can now know what the best move is in each position.  The player that goes first has a slight advantage in random play.  

For a simple human-player strategy, we could learn from the "Advanced Heuristic Minimax", which uses the following principles, weighing the earlier ones more strongly than the later ones:

• Maximize the amount of counters in your own store.
• Keep the opponents score to a minimum.
• Prefer to move the counters from your right-most pit.
• Have as many moves as possible from which to choose.
• Hoard as many counters as possible in the left-most pit.
• Keep as many counters on your own side as possible.

Below is a link to the online version I made, which has four computer opponent choices: Random Rachel just picks each move randomly.  Greedy Greg moves to take as many pieces as he can, choosing randomly when he can't capture.  Minnie Max uses a minimax strategy, looking ahead about 8 moves.  And then there's Foolish Frank, who also uses minimax, but makes the worst move he can find.

Mancalamity

(github repo)

An unfinished Pikmin-like game prototype

Here's a project that I haven't managed to finish.  It's a 2D imitation of Pikmin, which I think is a fascinating take on the real-time strategy genre.  I was working furiously on it in March, and then I ran out of steam and moved on to something else.  I was a little too ambitious here for a short-term project, but it was some good exercise for certain tools.  I used the Phaser framework for the rendering and tile/map management, and Tiled to make the maps.

To try it out, just click anywhere to get past the menu and then:

• W A S D to move your character
• left-click to throw a minion
• right-click (and hold) to call minions in a certain area
• space to disband (and sort) your army

Throw minion onto a pellet to pick it up and carry it back to their home.  They'll carry it to whichever color makes up the majority of the carrying crew.  That will then spawn more minions.

Pikmin-like game prototype

BlockFractal: generator of blocky fractal-like shapes

The frabjous isle of North Osia

BlockFractal is an algorithm that generates blocky fractal-like shapes.  The idea is to make something that would be suitable for a continent, island, or lake, in a procedurally generated 2d tile-based game.  The demo page shows the generated shape with a Google-Maps-like interface, where you can zoom and pan around.

First it generates a random place name, like New Gharnia, Superior Iukauton, or Twuq'eros.  That name is used as a random seed to generate a random fractal.  You can enter your own place name, and you can control two properties of the fractal generation.

One is "iterations".  This sets how many times the BlockFractal algorithm is run on the initial seed shape.  The initial shape is a simple square, but each iteration adds finer and finer random detail to it.  Drag the iterations slider around to see how the shape was built.

The other is "variation".  This basically affects the craziness of the shape.  Low variation produces a simpler but blockier shape.  High variation produces a shape with many more twists and turns.  Somewhere in the middle seems to be pretty good for continent-looking shapes.

Seed square

Iteration in progress

New shape after first iteration

There's a thorough description of the algorithm at the Algorithm Overview page on the github site, but basically it goes like this:  Take the initial seed shape (a 2x2 square in the first of the three example images above), double it, and then for each unit edge make a random decision to leave it be or to move it "inward" or "outward".  That produces a new shape which is more complicated, and around twice as big, as the last one.

The frumious land of Yixonia

Repeat this algorithm as many times as you like, though it does take twice as much memory with each iteration, so to avoid memory issues I stopped the demo at 9 iterations.

There are a few edge cases to consider, for instance I don't want the path to intersect itself.  If you're curious the Algorithm Overview page has more details.

The resulting shapes make me think of Koch snowflakes and quadric fractals.  Also, check out Brainfilling Curves, for some similar and amazing shapes.

As you play with the demo, imagine if this were the high-level map of a top-down RPG or roguelike game.  I like the idea of scattering some different biomes and rivers around, randomly placing some cities and towns, and maybe using some Delaunay triangulation to connect them with roads.

BlockFractal (demo)

(github repo)

WarpField: portal-casting field-of-view algorithm

Here's WarpField, a "portal-casting" field-of-view algorithm.  This goes beyond the usual field-of-view mechanism by adding support for portals.  A portal basically connects an edge between tiles in one map with an edge in a (possibly different) map.  WarpField computes the field of view through the portal, and also returns what the player can see at each location.  This could be useful for:

Going up (or down) stairs.

• Continuous overworld movement from zone to zone
• Over/under pathways, such as bridges and tunnels
• Smooth transitions of elevation changes, like stairs
• Crazy magical effects, like portals to alternate dimensions.

In a previous post, I discussed WallyFOV, my implementation of a 2d grid-based field-of-view algorithm using shadow-casting.  For games that don't need portals, that algorithm is a better choice, since it's simpler and faster.  Unlike many field-of-view implementations, WallyFOV supports walls, which is a prerequisite for adding portal support.

"Portal-casting" is basically an extension of shadow-casting.  Shadow-casting tracks contiguous ranges of angles of rays that are visible from the player.  When a wall is encountered, we simply cut that range of angles out (causing a shadow).  For portals, instead of cutting that range out, we split it off into a new, separate range.  For each range we track which map the range "sees", and the relative tile offset into that map.

Entering a tunnel.

For each location that isn't completely in a shadow, we now have to decide which map we're seeing at that location, and which tile in that map goes there.  This can be tricky, because we might see the location more than one way at a time.  Maybe some rays reach the location after passing through a warp to map A, while others reach it after a warp to map B, and some reach it without passing through any warps at all.  In a 2D tile-based game we don't really want to show slices of a tile, we want to just pick one to show.  To resolve this ambiguity, WarpField has an order of preference: rays closest to the center are preferred, followed by rays that go through fewer warps, and finally ties are broken by the map with the lowest "id".

There are a lot of edge cases to consider, and most of them are touched upon in the algorithm overview.  I did a lot of testing and benchmarking, and I'm pretty sure it works according to spec, but there are some asymmetries that I'd like to remove (due to the order in which locations are visited).  I think I can clean that up by switching to fractional math instead of floating-point math.  Nevertheless, it's fairly robust, you can throw crazy cases at it like warps into the same map (such that the player can see themself through it), and rays that pass through many warps at once.

I think this could add a lot of potential to roguelike games.

WarpField (demo)

(github repo)

WallyFOV: Shadow-casting field-of-view implementation with walls

I've been working on a field-of-view algorithm for 2d tile-based games (e.g. roguelikes).  There's a particular killer feature I mean to include in the algorithm, which I won't reveal in this post, but I decided to go ahead and release the slightly simpler version because I think it might be useful on its own.

It's called WallyFOV.  It's basically an implementation of recursive shadowcasting in TypeScript, but with support for walls.

Go ahead and check out the demo.  (and thanks to EasyStar.js for the pathfinding algorithm used in that demo, and from which I kindof copied the demo page style)

Recursive shadowcasting works by scanning outwards from the player looking for obstructions.  When something is found, a shadow (represented by two angles) is added to a shadow list.  Overlapping shadows are merged to keep the algorithm running quickly.

In this particular variant, a tile is considered visible if there exists any line from the center of the player's tile to any point within the target tile.  There are some complications around dealing with diagonally-adjacent bodies, which you can read about in the algorithm overview, but overall it's a pretty simple algorithm to understand.  It's a bit tricky to implement and optimize, however.

I spent a little extra time optimizing it to run in V8 (at least the version of V8 in node.js 7.9).  Along the way I learned how to use node's --trace-deopt, and discovered some very unexpected optimization tips, mainly having to do with newer ECMAScript features.

For instance, this version of V8 doesn't optimize "compound let/const assignment".  Meaning if you declare a variable with let or const, and then use something like X += Y, your function will be deoptimized.  Simply using X = X + Y instead avoids that trap.  The general lesson here is that JavaScript is apparently changing too rapidly to rely on the engine optimizing things according to your intuition.  This is probably true with any language, to a certain extent.  But, come on, X = X + Y?

WallyFOV (demo)

(github repo)

Mr. Floppypants

Here's Mr. Floppypants.  A simple ragdoll-physics game.  Maybe it's about a very lazy person who needs to be forced to go explore and have fun.

It's based loosely on a "Chrome experiment" called Boingy, which the kids really got a kick out of.  I think they mostly liked dropping stuff on the poor protagonist, or forcing it to fall down stairs, or getting it twisted up into painful-looking poses.  After I played a bunch of MANYGOLF and through that learned about the p2.js javascript physics engine, I thought I'd make a more complicated version of my own.

It seems to work in Chome, Firefox, and Edge.  It does not work in IE.

Basically you click and drag to toss the guy around.  For more advanced play, if you click on his hand and drag it to something then he'll "grab" the thing.  You can use this to carry an item with you to some other part of the world, and to operate the car.

This game isn't nearly finished yet.  I was hoping to make the world a lot larger, and to add other characters to meet and also toss around.  If you get any ideas for things I could add to the game, let me know in the comments below.

Mr. Floppypants

It's EELectric! (Junior)

My kids really wanted to play It's EELectric!, but it's way too hard for them.  So I made a new version with simpler rules and easier levels.  You know, for kids.  Or adults who couldn't stand the punishment of the previous version.

It's EElectric! (Junior)

It's EELectric!

Do you like eel-based puzzle games?  Ready for some mind-bending diagonal-moving action?  No?  Nevertheless, let me introduce you to It's EELectric!, an original puzzle game I've been working on.

In this game you star as an apex predator, the deadly Electrophorus electricus, better known as the electric eel. This is not a realistic eel simulation. In fact, I looked it up: electric eels don't look like this thing at all.

Plus, I don't think there starfish in the same... you know what, just swim with it.  Your job is to eat all the fish on the level, but before you chow down on the unsuspecting prey you have to kill it with your electric shock attack.  And you're hungry and getting hungrier, so you'll have to be careful not to waste any moves.  Otherwise you'll perish and have to press R to go back in time to try again.  I already mentioned it's not realistic.  SHOCKING.

Enjoy 37 fiendfishly difficult pools of funderwater puzzling!  Sound sea-ffects?  It's um, reel.. something.  Hmm.

Anyway here it is:

It's EELectric!

Hexfold

Here is HEXFOLD, a web-based puzzle game inspired by the puzzle toy Cool Circuits.  For some background, see my post analyzing Cool Circuits, and the one describing how to extend Cool Circuits to a hexagonal board.

Level 7: "Lucid Sitar"

TL;DR: The object of the game is to place the pieces on the board to create a loop, using every piece and obeying certain constraints that are different for each level.  I made 36 levels (the 37th and final one is randomly generated) which more or less increase in difficulty from hand-holding tutorial to absurdly hard.

I should warn you, this isn't an easy, kid game like Robot Quest or a simple, casual game like Logoplex.  Oh, sure, it starts out easy enough.  But that doesn't last.

If you give it a try, please provide feedback in the comments below.

Before you ask: the level names are just arbitrary adjective-noun combinations.  I generated a bunch using The Sillifier, and picked out the ones that amused me.

HEXFOLD (Web)

It's also available as a Chome App:

HEXFOLD (Chrome Store)

Cool Circuits: Hexagons

If you haven't read my previous post about Cool Circuits, better go read that first.

What if Cool Circuits was made with a hexagonal grid instead of a square one?  More precisely, what if the turns in each piece were 60 degrees instead of 90?

We'll use the same pattern for generating the pieces: Each piece is a path composed of five turns either clockwise or counterclockwise, and each piece is uniquely described by a sequence of four bits, where each bit indicates whether the next turn is in a different direction than the previous turn.  Here's what the pieces would look like:

"JUVENILSQ"

Compared to the 90-degree pieces, these new ones are a little more stretched out.  If you've been paying attention you'll notice there's a new one.  The last piece in that image corresponds to the bit sequence 0001, which wasn't possible in the original Cool Circuits because it would have intersected itself.  I'm going to call it "Q".

Can we make a circuits with all of these pieces?  Nope.  In 90-degree-land, each piece contributed a single 90-degree turn (either way) to the overall path, and since there were an even number of pieces that meant we could end up with the complete 360-degree turn necessary for a circuit.  But with these new pieces, 6 of them contribute a 60-degree turn, and 3 of them contribute a 180-degree turn.  That means if we use all the pieces we'll always end up 180 degrees off. Here's a tabular summary:

Letter	Description	Flipped	Contribution
J	0011	1100	180
U	1001	(same)	±60
V	1011	1101	±60
E	0110	(same)	180
N	0101	1010	±60
I	1111	(same)	±60
L	0111	1110	±60
S	0010	0100	±60
Q	0001	1000	180

So we'll have to drop at least one piece.  For now, just to be true to the original puzzle, we're going to have to let Q go.  Sorry Q.  Maybe we'll find a job for you later.

Behold!  Hexagons!

Because the turns are 60 degrees, the pegs on the board will be arranged in a hexagonal grid.  Clearly, the overall shape of the board should also be a hexagon, but what size?  Five seems like a nice diameter - it would have almost the same number of points as the original puzzle.  I modified my solver from the original puzzle for these new parameters, kicked it off, and sat back to watch the solutions roll in.  Sadly, there are none.

Cool Circuits has a neat property that every solution leaves behind 6 untouched pegs.  In "Cool Circuits, Jr" they add 6 rings that you can use to wrap those pegs.  Once you've done that, there is no position left untouched.  This hexagonal version doesn't have that feature.  For each turn you make, you make it impossible for the path to later hit the point you didn't turn towards.  Near the edges, that can cascade and make other points untouchable as well.  I suspect this is a clue to why there aren't any solutions in the 5-board.

Before we give up on this board though, what if we had even fewer pieces?  I tried dropping J and E (leaving us with only pieces that contribute 60 degree turns), and I found that there are solutions to that variant.  Exactly four of them (ignoring solutions that are equivalent via rotation and reflection).  Here they are:

Four unique solutions for the 5-board, using the UVNILS pieces.

Note how the V and N pieces can be swapped (and flipped and rotated) to convert one solution into another.  That's also true in some of the solutions to Cool Circuits, though in both cases it depends on how tightly-packed the circuit is.

To me, this doesn't seem like enough solutions for an interesting puzzle game.  Sure, with rotation and reflection we could make more circuits, but they would all end up feeling the same.

Time to raise the diameter to 7.  You can probably guess going into this one that there will be too much space on the board.  Going back to 8 pieces, I let the solver run overnight, and it says there are 1503 circuits.

Alternative boards.

So with lots of space (A) we have lots of solutions.  I also considered removing the six outer-most pegs (B: 474 solutions) and removing four pegs from each of three edges, forming a somewhat triangular board (C: 130 solutions), but the bigger hexagonal board seems more thematic to me.  The large number of solutions does mean that we'll need to have plenty of constraints in each puzzle to make it uniquely solvable.

Overall, while not as elegant, I think this configuration works pretty well as a variant of Cool Circuits.  I'm working on a web-based playable version called HEXFOLD, which I'll post here once I've finished the levels and had some people play-test it.

HEXFOLD Solver

Cool Circuits

I came across a particular kind of puzzle, the design of which is really fascinating to me.

I wanted to get my son some electronics toys for his last birthday.  I had one of those 100-in-1 electronics kits when I was a kid but he's still a bit young for the complex wiring, or at least that's what I thought.  I ended up picking Snap Circuits, which he loves.  I had to pick one more thing because you never know with kids, it's safer to get a couple of smaller things than one big one, so I tossed in Cool Circuits, because it had a similar name, and I think Amazon suggested it or something.  He also loved that one.  It's not really about electronics, it's just a puzzle game, but I've come to realize it's a very cleverly-made one.

A cool circuit in progress.

Here's how it works: the board has 25 pegs, arranged in a kind of diagonal grid.  There are 8 serpentine pieces which can fit in between the pegs, and each has a unique shape.  For each puzzle you are given some constraints (e.g. part of the circuit must travel along this path) and you must put the pieces on the board in a way that meets the constraints.  The one universal constraint is that the pieces must form a single loop.  In the toy, that triggers some mechanism which lights up the board and plays some music, but I've found that feature to be pretty finicky.

It's pretty tough to make a circuit from scratch, so the constraints tend to help more than hurt, and the more of them there are the easier the puzzle.

At first I thought the shapes of the pieces were arbitrary, but there's a mathematical beauty and completeness to them that took some pondering to discover.

As a font, it would not be easy to read.

Each piece is made of a sequence of five quarter-circles.  The manual describes them as "J", "U", "V", "E", "N", "I", "L", and "S".  So if you're looking at a given piece, starting from one end, you might describe it by listing the chirality of each segment.  For instance the "V" piece would be: turn right, left, left, right, left.  Or maybe clockwise, counter-clockwise, etc..  But that's a terrible description because the same piece would be described differently if you started from the other end, or flipped it over.

Math!

We can normalize the description for flipping by listing not the turns themselves, but the changes.  So if it starts out in one direction, we just say whether the next turn is the same as the previous one or different.  The "V" piece would then be different-same-different-different.  Now imagine same as 0 and different as 1 (e.g. 1011).  Each piece is described by four bits.  But some pieces have a different description if we start from the other end.  To correct for that, for each piece we'll pick the description that has the smallest number when treated as binary.

Here are the eight pieces:

Letter	Description	Flipped
J	0011	1100
U	1001	(same)
V	1011	1101
E	0110	(same)
N	0101	1010
I	1111	(same)
L	0111	1110
S	0010	0100

In this scheme, you can't have three zeros in a row, because that would make the piece intersect itself.  So 0000, 0000, and 1000 are out.  That means every workable bit sequence is represented.  These aren't arbitrary shapes at all, it's all possible unique shapes of length 5!  At length 4, there are 6 possible pieces.  At length 6, there would be 15.

All possible locations for the first piece.
Testing just the blue ones is enough.

So how many circuits are there? Let's start with an upper bound. For now let's say the first piece we put down can go in any point, in any direction, flipped or not. There are 224 possible first points (red and blue arrows in the diagram to the right).  However, some of those are equivalent to one another, because we could just rotate or "flip" the board itself.  So we'll cut that down to 28 (blue arrows only).

Suppose each piece can fit two ways at one of the blue arrows.  Actually, some pieces fit fewer ways than that, and sometimes they won't fit at all, but let's not work out those details yet.  After that first piece, we choose a next piece and fit it on in one of four ways.  This overestimated upper bound says there are fewer than 28×8!×2×4⁷ paths (36,993,761,280). That's pretty high.  Luckily, many of the paths terminate quickly, either running off the board or crossing and earlier section of the path, so we're not going to need to search them all just to find the complete circuits.

I wrote a program to brute force all the paths.  It found 17,473 paths, starting from those blue-arrow positions, that used all 8 pieces without self-intersection or running off the board.  Of those, 1,520 ended up where they started, forming (possibly cool) circuits.

We're overcounting with that number though, because for any given unique solution, we're seeing it 16 different ways (counting reflection and cycling through the 8 pieces as starting pieces).  Now I very well may have made a mistake (or several) here, but I think the final answer, the number of unique solutions to this puzzle, the number of Cool Circuits, is 95 (no, see UPDATE below).

Cool Circuits at ScienceWiz

Solver Source Code

UPDATE 4/27: I found a mistake.  I didn't account for some solutions that fit so tightly that they leave four empty pegs all along one side of the board.  Those solutions are double counted in my initial number because they can be translated into another solution.  I was accounting for rotation and reflection, but not translation.  There are apparently 11 solutions like that, so my final answer (today) is 84.

Logoplex

There are many logo quizzes on the internet.  Many.  Yeah, just tons.  Here's another one.

An uninformative screenshot.

It's called logoplex.  This one focuses on big vector graphics, animations, and clean design.  I limited myself to the logos I could get in SVG form, and which if I removed the identifying text from them I was left with a (mostly) recognizable shape.  I collected 100 logos in total, but logoplex only chooses 10 of them at a time to throw at you.

Gathering the logos was quite a grind.  Logopedia was useful, they have just about everything there - plus for any given logo you can see how it has changed over the years.  Wikipedia was also great (as usual) for things like lists of companies and fast food chains and whatnot, and if there's an SVG version of a logo out there Wikimedia Commons probably has it.

However, some of them seem to have been badly converted from Illustrator, with lots of unnecessary elements.  I wanted to make sure each logo stayed less than 10 kB.  In some cases I had to allow more than that, but in others I simply had to let the logo go.  For example, I dropped the Discovery Channel logo because the globe image makes that one pretty big.  Some of them I just edited down to size.

The program lets you get a little sloppy with your answers.  In addition to allowing variations in some answers, it also allows minor misspellings using Levenshtein distance.

Give it a try, and let me know what you think:

logoplex

The Robot Quest Soundtrack

I've uploaded the music from Robot Quest to SoundCloud, so if you're not inclined to install any Chrome apps, but still interested in my rudimentary MIDI handiwork, you can have a listen or a download with only a few clicks.

There are three tracks from the game:

• Processing: The clock cycle of a simple-minded, trudging, oblivious robot.  Another part came in and seemed to me to be another robot - a companion - which decided for some reason to walk alongside the first.  This was my first and I think it's a little overcooked.

• Robot Party: A more boisterous call-and-response-style piece, with more improvisation than you could reasonably expect from a room full of soulless machines.

• Clockwork: I wanted something with guitars (well, "guitars").  I have partial lyrics for this one but I won't tell.  To sum it up: an undying machine, in love with a person, is confused and disappointed by mortality.  You probably wouldn't pick that up just from listening to it.

Plus a bonus track:

• Plugged In:  Just piano and drums this time, with some fancy-fingers action.  I haven't found any robot symbolism in this one.  This isn't in the game because I haven't finished the fourth level.

Robot Quest Soundtrack