|Name||One Zero One (2013)|
|Accessibility Report||Meeple Like Us|
|Complexity||Medium Light [1.84]|
|BGG Rank||4119 [6.54]|
|Designer(s)||David Harding (II)|
A game with a strong programming theme was always something at which I would leap. I’m a computing academic with a strong background in coding. My PhD may be in accessibility, but it was in the building of a kind of virtual machine which could provide cross-platform adaptive accessibility support. In other word, It was as programmy as hell. My undergraduate degree is in software engineering. I’m the owner and main developer of a text-based apocalyptic MMO (or what used to be known as a MUD). I’ve been teaching programming for around fifteen years. One Zero One sounded right up my alleyway and I thought it could maybe even fill a gap I’ve felt existed for years. I didn’t mean that to sound as dirty as it did. For clarity’s sake, my alleyway has no gap that I currently feel is in need of filling. What I thought was that One Zero One could maybe be a teaching tool that meaningfully built logical literacy in a fun and engaging way.
So, first things first – it’s not a game that’s actually about programming. It adopts some of the linguistic conventions of programming, and even the retro aesthetics of early BASIC interpreters. It’s really more of an area control game. What programming that exists is only expressed in the jargon of play. Each player gets a deck of sixteen identical cards, of a composition made up of several special instruction sets. These are shuffled, and then a ‘program’ is constructed from the control and program number cards.
Each of the cards has a 0 or a 1 on it, and each player adopts one of these numbers. Each player takes turns laying down one of their cards and executing the instructions, if any, that are printed on the front. You’ll normally be playing with the following starter deck:
Cards may be rotated, but must always be played in portrait orientation. As you can see, you have two of each instruction – one that works on a column, and one that works on a row. You also have six basic number cards, which have no special effects at all.
Once you’ve mastered the starting deck cards, you can look to replace some of your instruction set with other, more advanced commands:
When the game begins, players flip a card to see who goes first. In our example, we’re going to start off with player 0. Michael, for that is his name, draws three cards from his deck into his hand. The composition of the hand he has is secret, but the top-most card of his stack is visible to both players – the game refers to this as playing ‘open source’. Yeah, that kind of thing is the sum total of the real programming you’ll find in the game – little verbal nods to coding concepts. Can you nod verbally? I guess it doesn’t matter. We’re in flavour country now.
Play progresses in three phases. You input a card from your hand into the program. You execute the card if it has special instructions. You then load cards from your deck into your hand until you have three.
Input is a little more complicated than just placing a card wherever you like it though. You can only play to a line if every line above it has a minimum of three cards in place. That’s not true for the 10 and 20 lines, but it will hugely restrict your ability to influence later parts of the program That’s important, because the number that’s given to the line is how much it’s worth in scoring.
Scoring, you say? Ah yes – the purpose of the game is to gain control of lines through amassed cards of your player digit. Control is awarded, at least temporarily, when a line has at least three cards in it and when there is a majority presence of a particular number. Control of lines will shift back and forth as the game is played. The prize is greatest for the 40 and 50 lines because they are the most lucrative.
There’s no limit to how many cards play be played in a row, except for the 50 line. As soon as the third card is played into the 50 line, the game is over and must be scored. The game also ends if a player cannot execute their load phase. Games, in other words, are very short – only ten or so minutes.
So, Michael looks at the game state and decides he’s going to go big or go home. He plays his ‘if… then… card into the 20 line:
That’s the load operation. The execute operation then makes us look at the card adjacent to the instruction, and execute it. The 1 to the left of it becomes a 0. If it had been placed with the instruction on the right, nothing would have happened.
Michael then loads his hand, and gets a blank 0 to play. Then Pauline (for that is player two) gets a chance to go. But look at her hand:
It is at least three turns before she’s going to get to do anything interesting, which hugely constrains her ability to influence the program. All she can do is place digits where she thinks they’ll do the most good. As you can imagine, this is bags of not fun.
She loads her hand, and… bugger. It’s another blank 1! Michael plays his blank 0 to the 20 line, taking control.0 Having placed that 0, line 30 becomes available to play (editor’s note – actually, rereading the rules it doesn’t. The line 10/20 exemptions are only for playing to the line, they’re not exception from the ‘all lines must have three cards’ restriction. BUT LET’S PRETEND). So she plays a blank 1 to line 30 in the hope of claiming the initiative. Her cards though do nothing special, and it’s going to be hard to do make anything good happen.
At least her next card to load will be a special operation – a print. When she plays that, she’ll get to instantly play a second card from her hand. If it had any special powers, she’d get to trigger that too. Print cards permit for some limited opportunities to chain instructions.
Michael plays an ‘enter’ card, moving the zero above it onto the row below. He gives up control of the 20 line in exchange for a better chance of control of the 30. Pauline plays a 1 to the 10 line, claiming it.
And so on and so on until the game state starts to reach the third card of the 50 line:
At the end, we tot up control of lines and the player with the largest sum of line numbers in their control is the winner.
Oh god I wanted to like this game. But there’s just not enough of it. The good news is, there’s a base here that I think could be meaningfully iterated into something very special. The bad news is it’s going to depend on the will to fundamentally alter the flow and mechanics of the game and I don’t think that will is there.
The key criticism I have of One Zero One is that fundamentally it is not at all interesting to play. You don’t have enough instructions, and the instructions don’t interact in ways that offer opportunities for cleverness. There are a few ways to chain effects together, but not a lot and they very much rely on hugely situational conjunctions of events. At best, you’ll manage to pull off a print that plays a card with another effect, or a paste that retriggers an especially useful card. The card-play is mechanically fine, but the expressiveness of the instruction sets hugely lets it down. It doesn’t have meaningful strategic depth because you’re too much at the mercy of the draw and the limited options you have available.
The winning conditions are entirely broken. There’s just too much emphasis on the numeric value of lines, and not enough weight given to how challenging they are to claim. Most of the difficult contention over rows comes from the 10s and the 20s. The 50 is comparatively easy to lock down, especially if you have a print card available. The lines you have to actually fight over are worth less than the one you can pick up largely through the luck of good timing. All that matters is building up the program so that you can lock down the 40 and the 50. Scoring in a game is the key element that shapes and defines the variety of meaningful play experiences permitted. There isn’t much variety in here. Play it a couple of times with different instruction sets, and you’ll never need to play it again.
Coupled to all of this is a missed opportunity. There is no coherent follow-through in the link between theme and mechanics. One Zero One is a game that should be so wedded to the programming theme that reskinning it would be virtually impossible. It’s not though, because fundamentally it’s not a game of logic. It’s a game of area control. It could just as easily be orcs versus elves or axis versus allies. The theme is pasted on, which is a shame because the opportunity is here for a truly wonderful game.
Where is the actual logical manipulation? Real programs don’t get built around conditionals alone. You can’t do anything interesting if all you have is an if statement. Where things get very interesting is when you can combine them with loops. Why are there no loops in the game? Why not allow us to place a loop around a card that causes its instructions to repeat every turn, instead of just when it’s played? Or better yet, allow us to choose whether to loop over a number of iterations or to loop indefinitely. Give us a currency of ‘CPU cycles’ we can spend on elaborate logical engines of game-state manipulation.
Instantly this would become a game of intense depth, where players build their own self-contained constructs which could run independently while you tried to dismantle those of your opponent. Imagine if I stick my looping ‘print’ card so that it is spitting out ones in a row, only to have them encounter your looping ‘if’ that flips the value. Hilarity! What if I then put an enter card in between so that my ones get redirected into the row below. Awesomeness!
Why not let us build packages of cards with some kind of data structure system, and let us play them as individual units? Let me defer my play until I have something nice cooked up, and then play it as one card that gets executed in stack order. AND THEN LET ME LOOP IT, OH MY GOD. Just imagine how much creative anarchy you could enable with those kind of systems. That’s the kind of thing that turns simple mechanics into breathtakingly deep systems in which you could drown.
None of this would really work with the game as it stands though because the instruction sets are not very interesting.
So One Zero One needs something else. I know exactly what it needs, too. It needs Paperback’s deck-building system. Begin the game with a starter deck, but let us progressively buy more interesting instructions. Let us discard those tedious blank 1s and 0s, and stack the deck with command sets that will work for our current situation. Make maximising the benefit of our playing a balancing act between long term planning and short-term opportunism.
All of this can bolt on to the game with expansion packs, and I would happily buy each and every one of them to get the game that One Zero One could be.
Now, some of these criticisms can be dismissed easily enough. One Zero One is after all an abstract game, and we understand the conventions of abstraction – theme is not important. To add in the programming systems I’d like to see would also hugely impact on its learnability. It’s very easy to pick up at the moment, and you can fit it into even small gaps of time.
The game I’d like to see would be neither of those things but it would also be a game that I think the market is crying out for. This could be a game that I could put out in front of my first year programming students so that they intuitively grok the code they’ll end up writing. As it stands, it’s not even a game that could be used for meaningfully illuminating the concept of binary numerical systems. All you’re getting is a workaday card game. Sure, you can play it in ten minutes, but those ten minutes won’t be an awful lot of fun.
One Zero One is definitely in the vicinity of greatness, but not as it stands and maybe never. There was a kickstarter for an expansion pack that unfortunately looked like it would just double-down on the game’s systemic flaws without making it the phenomenal experience I believe it could be. I might very well be forced to make the game that I want myself, because I don’t like living in a world where something that awesome and pedagogically valuable is not available.