Monthly Archives: October 2013

Rock and Dirt Games 1

Here’s a game fresh off the press for those who like 2-player abstract strategy games, especially ones played with a simple board and one type of piece.

Two players take turns placing or moving tokens in squares of an 8×8 board. No square may ever have more than 3 tokens, and tokens may only move up/down and left/right by one square. Each turn a player may add one token to any square the board or move any number of tokens from one square to an adjacent square (as long as at the end of that player’s turn there are <=3 tokens in each square).

Player 1 tries to make the sequence 1-2-3 in adjacent squares, player 2 tries to make 1-3-2. This includes diagonals, though pieces may not move diagonally. The first player to make their sequence wins.

Variations: changing sequences and square limits are an easy way to up complexity. Changing the dimensions of the grid (or using a different network, e.g. a hexagonal tiling) is another parameter which could be changed. For a 3-player variant, use 123, 132, and 213 as the goals. Additionally you could use multiple types of pieces (different colors say) and then make more complicated sequences.

Note: to prevent indefinite repeats, a player cannot make a move which would cause the other player to encounter an identical board state to what they just played on (e.g. if the other player moves a piece you cannot move it back).

If you solve this game I’ll give you a prize. If you then turn it into a variant which you can’t solve, I’ll bake you a cake.

Block Party Arcade

Since day 2 or 3 after Block Party’s inception we’ve had the idea to make digital versions of the game. Of course, that will include the classic versions that you can play with the wooden blocks, but it also allows for many other types of gameplay not suited for a physical game. So we got on to thinking, what new games does a digital environment allow with mechanics as with Block Party symbols?

First let’s look at a few ideas which we can borrow generously from. Right now on the short list we have bubble shooterlogic mazes, and the family of {bejewleddots, and other such games}.

With bubble shooter (you can play a round if you don’t know what it plays like) it seems like it would be easy enough to swap out the simple ‘colors’ for block party symbols where groups are destroyed when they share one value. Because of the hexagonal adjacency, each symbol you add has the potential to form different groups along different attributes (it could have a triangle group on one side and a blue group on another), allowing for much more strategic placement. In a harder variant, we could be eliminating runs of sub-parties, or requiring a full party (either along a single direction, in a group, or something else–though this is likely too difficult to play).

Each 3 in a row in the path must be a sub-party

For logic mazes, I first want to share that block party minis are great for prototyping new games (including digital ones). For an example of a logic maze using block party minis, see the image to the right. The puzzle is to traverse from the bottom left to top right by going along a path where each 3 in a row is a valid sub-party. Conveniently this type of puzzle extends to 3D surfaces, or generally any adjacency matrix (network) where nodes are symbols and edges are potential travel paths.

2-attribute jumping mazejump in rows/cols where each move shares 2 attributes
Another variant is instead of walking one block at a time, you must jump within rows and columns so that for any jump you make the symbol you jump two shares two values with the symbol you came from. For an example, try going from the bottom right to the top left of the puzzle on the right.

These maze puzzles at least in my experience have the potential to get quite hard, and I’m pretty sure there’s room for several insights for the solver in a stepped difficulty sequence. Another convenient aspect is that they can be designed purely programmatically, with metrics on the average branching factor used as proxy for human difficulty. Also, they can all start out arbitrarily easy by decreasing the number of attributes or values. Generally, the set can be extended to k attributes each with n values and the exact same mechanics persist (though (3,4) has the nice property of length 3 sub-parties as well as other considerations for human play). One final note I’ll add is that in the world of mazes, mechanics are pretty endless. You can make the maze change over time according to arbitrary rules, you can make it have multiple sides with holes which you switch between, you can have multiple agents which have to accomplish things together (e.g. imagine having 3 players where they all have to move simultaneously and make a sub-party and eventually end up on goal squares). So that’s pretty promising as far as an infinite supply of replayability, though deciding which mechanics result in the most additional insights and sorting by that is the challenge.

And finally a shout out to all those Bejewlers, Candy Crushers, Dots players, and others trapped in tight dopamine loops. Instead of ranting I’ll just ask, what if they were using block party symbols and had more dimensions?

Block Party Glyph Designs

If you’ve seen Block Party, you’ve also encountered at least one set of BP glyphs.
V1 glyphs in black
V1 glyphs

A glyph (or symbol) in Block Party for all those interested is composed of three independent attributes which each take on one of 4 possible values. in the original design this manifested as shape, fill, and color taking on values in {circle, triangle, square, pentagon}, {empty, striped, crosshatched, solid}, and {red, blue, green, black} respectively.

After playing with those glyphs for a bit we started to realize that there were probably better ways to design them so that each feature was easier to see. We swapped put the pentagon for a hexagon, which we then swapped out for a star.
V2 glyphs
V2 Originals

We also changed striped and crosshatched to shape-in-shape and tessellated to realize that those fills (while more aesthetically pleasing) were harder for people to learn on. One other experiment we tried was changing the fill to an inside color, which was far more difficult even for more practiced players.

From these experiments we’ve noticed a few factors which are important to measure for new glyph designs: learnability, differentiability, and perceptual ease. Learnability is a measure of how long it takes someone new to find their first party, a distribution with a mean which we’d like to minimize.
Double color symbols
V2.C: color-in-color

For differentiability, consider the experiment where a subject is shown two glyphs and must press one of two buttons, same or different. We want to minimize the maximum time this takes. For perceptual ease, we’d like to make each attribute so as to minimize T, where T is the maximum result if someone were just looking for parties of one variety (e.g. just same color, just same shape, just same fill, etc.) for each variety. (For reference, I currently find a same-color party in less than 20 seconds on average, and same-fill party in about 30 seconds on V2.) For a examples of glyphs which make this kind of separation difficult, check out the 16 ‘black’ V2 and V2.C symbols. (To obtain the different colors in V2.C, the outlines of the symbols are changed to be one of the 4 inside colors.)

We’re still working on our designs and will post future ones as we come up with them. In the meantime, if you have ideas and suggestions feel free to comment below or email them to g at, we’d be delighted to hear your thoughts.

Where the party at?

I just started writing some code to check statistical properties of Block Party (results will be published soon) and have been thinking about party search quite a bit recently. (For those interested, the code so far can be accessed at the block party github repository.)

Party search is an interesting problem in a few respects, but I want to start with an idea I’m calling a search strategy’s halting distribution. This is a probability distribution over time which shows how frequently an algorithm halts (finds a party) at what times. So, for example, if I always look for all-different parties (call this strategy A) I might expect my halting distribution to be fairly concentrated around a moderate amount of time (since there will almost always be an all-different party, this single routine is very likely to halt). However, looking for all-differents can take longer than, say, looking only at same color. Let strategy B be to first look for a party of the same color, and then failing that find one which is all-different. B will have two density spikes, one early on (since looking at same colors is somewhat easy), and then another which occurs at the time strategy A’s peak occurs plus the amount of time it takes for the same-color algorithm to return null. If A and B both find all-differents in the same amount of time with low enough variance, and if there is no same-color party at least half the time, we should expect A to outperform B.

Now that we have a bit of an understanding about how search algorithms can have different halting distributions, lets consider a mathematical curiosity referred to as nontransitive dice. Suppose (you don’t have to believe that it exists, just pretend!) that there are halting distributions which are proportional to a set of nontransitive dice (they will likely have much more continuous distributions). We now have nontransitive search algorithms, which when run against one another give rise to a rock-paper-scissors cycle. This results in a fascinating metagame in competitive block party wherein players keep track of other players’ party types and adjust their search algorithms to be expected to outperform the others. I would even venture to conjecture that despite non-equal hardware (some people’s brains run some routines faster, call it G or whatever) a (not too much) disadvantaged player could still outperform a better player by playing the metagame properly.

Some future work I’d be excited to explore in this area would be coding algorithms which exhibit different halting profiles given times on subroutines. If this were combined with some scientific research (e.g. if we knew the range of time it can take people to asses which color is most prevalent on a board and other such subroutines, memory constraints, etc.) then we could theoretically model different people playing block party and devise algorithms which optimize given their particular subroutine time distributions. In the shorter term (not requiring human research) it would be fascinating to put together a comprehensive enough library of subroutines with which many party search algorithms can be created and have a competition where, under different parameters of how long subroutines take to operate, algorithms compete head to head. This gets extra interesting when you consider that in a head-to-head match, algorithms are able to see what types of parties the opponent is taking, thereby giving some clues as to what the opposing algorithm’s subprocesses are (and thus clues to the halting profile). This creates a metametagame where programming teams are coding algorithms which have different metagame profiles showing how they evolve and deliberately adding noise to the signal of which strategies they’re using.

Interested in creating the subroutine library or competing in the coding tournament? Want to share your thoughts about party search or other relevant literature? Comment below or email g at!

[Three Pixel Heart is hiring. If you’re a energetic, multifaceted funlover who likes what we do, give us a shout!]