Avast, ye spuds! Into the deep fryer with all, ya. Today, Fairway takes a look at Potato Pirates, a card game currently on Kickstarter that intends to introduce the basics of programming to its players. Find out whether this carb-loaded game is crispy or undercooked.
Potato Pirates is a three- to six-player take-that card game with a strong educational concept: learn to program or walk the plank. Individual games can be fast, like ten minutes for three players, but got longer as more players joined. I reviewed a prototype copy of the game, so some changes are likely to occur before final production.
Initial Impressions ^
- The game play is simple, but the rules were daunting if only because so much time was spent on “explaining” the cards and card combinations. I could see this being quite unnerving for the target audience of parents and teachers.
- We liked that it could support a lot of players. However, in a whole bunch of games, the only way we seemed to win is by elimination, never capturing the captains. Maybe it was just our play style, but a six-player, mostly-elimination game is going to make this hard as a teaching tool–you can’t have four students sit out.
- The game does a really nice job introducing common programming concepts: loops, conditionals, etc.
- The potatoes are adorable. Who wouldn’t like adorable potatoes?
Game play ^
In Potato Pirates, players control pirate ships and a crew of spuds in an attempt to become the best potato lord by either capturing the seven potato kings or eliminating all the other players. The game essentially consists of a deck of programming cards, a series of pirate ship cards, and potato tokens. At the start of the game, players are given two pirate ship cards and starting crew of potato tokens. The programming cards are shuffled and a starting hand is dealt to each player. The remainder of programming cards are set face down in a draw pile.
The pirate ships are double sided cards. On one side is the “anchored” side. The other side is the “battle” side reflecting a ship out to sea. While anchored, a player can “program” their ships and then set them out to sea for battle. To start, both ships are anchored and players assign some number of their potato crew tokens to each ship.
The programming cards are a series of cards that reflect common programming concepts: conditionals, loops, actions, interrupts and bugs. Players will use these cards to “program” their ships when anchored and “execute” the program during the battle phase.
The game is played over a series of turns. Beginning with the first player and continuing clockwise, each player takes a turn. On your turn you will first draw two programming cards from the deck and add them to your hand. Now, you can do any number of things on your turn. You can expend four crew to buy a new ship and anchor it in port, play cards from your hand onto any ship in port, or send any programmed ship into battle.
To program a ship, players can use up to three programming cards from their hand to their ship. On the bottom an “action” card that causes something to happen to your opponents ships such as frying or mashing opposing crew members. These cards are teal. Above that, up to two additional “control” cards are played. Control cards are orange and have common programming constructs like “while” and “for” loops and “if then” conditionals. When players send their ships to attack, these programming cards are evaluated top to bottom. For instance, in the example to the right, the player would “three times” mash two of their opponents potatoes. If, as is the case here, the other player doesn’t have enough potato crew members, the opponent’s ship is sunk.
There are a few other types of cards that represent “bugs” and “interrupts.” Bugs are “pirate king” cards. When a player draws one of the blue pirate king cards, it’s immediately played. The player who’s the last to react (salute the player) must discard crew members. In the second case, interrupt cards (pink) are the “special” cards. They can be played at any time and the action is immediately resolved. The actions can be things like stealing cards, hijacking ships (with their cards), or blocking an action taken against you.
After players take their turns, play passes to the next player until either someone has all the pirate kings or all but one player is eliminated.
On the green ^
Art. Potatoes are cute. And while the art is simple–generally just a small potato drawings against a solid color–“simple” is probably better than complex for the game. You can tell from things like the ship cards, that the designers could have been much more intricate art. Especially since the focus is on the “concepts” imparted on the cards, we thought this was a good art and design choice.
Play/learning time. Most games go pretty quickly. We tried a few games at the higher player counts and the play times seem to grow exponentially since there are more targets, longer gaps between turns, and more players doing more programming activities. There’s definitely a sweet spot around four players.
Two putts ^
Since this is a preview, I think that it’s possible for the game to improve before it gets to production. I’m calling out these two particular… quirks… that are definitely holding this game back.
Programming concepts. The game touts its ability to get people thinking like programmers. It’s plastered all over the Kickstarter in the form of infographics. I think there’s a safe bet that folks who weren’t previously exposed to “while” and “for” loops will come away with an understanding of them. In sort of the Robot Turtles vein, this amount of conceptual learning is pretty low, though. It’s probably less than what’s in a standard game of Robot Turtles.
The fact that the rule book would even take on the task of enumerating the possible combinations is somewhat telling. The limited outcomes and no room for user-created programming mistakes essentially limit the learning here. Indeed, by this measure, games like Manhattan Project: Chain Reaction and Windup Wars offer more “programming” and learning potential. And one of the valuable learning opportunities in games like Robot Turtles is not in the successful stringing together of cards, but when something doesn’t go right. This is all but taken away from players in Potato Pirates, other than in the form of the “special” cards which are played, at random, by other players. The only “wrongness” possible is if your planning doesn’t go right (a ship loses crew or it’s reassigned or a ship doesn’t exist) at the time you try to execute your program, not that the program itself is wrong.
Related, the game often felt more like a “reading” or “math” exercise than a programming one. There’s a good reason for this. The cards literally say what you’re supposed to do and when you can do it. The inputs and outputs are all spelled out in the cards. Likewise, the programming concepts themselves are just printed on the card. In some other places, the designers doubled down on writing things out where it’s clear the designers had a hard time conveying information. For example, concepts like “Attack Every Ship” are just added to the card. The same card also says “attack ships with fewer than 6 potatoes” and “attack ships with 6 or more potatoes” in order to explain the full consequence of the “If” statement. In other places, where it would seem your variables would matter, like “While > 4,” it’s actually your opponent’s variables.
One other consequence of making this a “reading game” is that you actually lose some of the target audience here: kids. Again, Robot Turtles avoided this issue by making the concepts less literal and allowing players to chain commands and to use the “function frog” to repeat commands.
Where it comes up short ^
Before you scream, “It’s a game about programming, potatoes and pirates, Fairway,” I know. That was exactly what I was thinking. So, even if the above faults are fixed, what’s not to like?
Depth. There is just no depth to this game. At least out of the box, the potential combination of cards is really limited with some very specific powerful combinations. The types of things you can do with the cards out of the box, don’t really invite lots of learning and exploration and, when integrated with game play, it’s just playing the best of the cards you draw. Perhaps its on the designers’ mind, but having things to scale/scaffold the difficulty would be welcome. While the designers mention this in their press materials, the current revealed stretch goals on the campaign don’t include them. You can compare this to something like Robot Turtles where the game includes level and difficulty scaling as it introduces new concepts. Nothing like that out of the box here.
Take That and Player Elimination. For whatever reason, “educational” and “kids” games tend to gravitate heavily toward take that. This game goes a step further and tacks on player elimination. I get the idea that pirates are frying and smashing crew members and attacking opponents. It certainly adds to the theme. But as a consequence, it also implements player elimination which can take players out of the game very early, especially with higher player counts. These hardly seem to form a great foundation of a game that’s intended to be used as a teaching tool. If the first player can be eliminated in the second or third round of the game, how much learning was really done? The fact that players can “go out” that quickly also suggests there’s other issues.
Non-“programming” cards. A good chunk of the cards are dedicated to the pink interrupt cards (hijack, loot, switch, etc.) and pirate king cards. Our experience was that these all seem weirdly out of place. While these ideas aren’t foreign to programming, they break the in-game programming mentality–they’re just cards you can play whenever and get some reward. Would anyone playing the loot card immediately associate any programming content value to it? These cards seem specifically designed to add more take-that and seem to detract from the learning objective.
Same thing for the potato king cards which are meant to be “bugs”. But why am I saluting bugs? And why am I trying to capture all the bugs? Feels like a missed opportunity. Wouldn’t it make more sense for the “bugs” to be potato-issues that cause problems to your programs (like redirecting action cards) and the goal is to get rid of them?
Two players? The game is pitched as three- to six-players. By itself, this would be alright. However, in a game where you can eliminate down to two players, limiting the game to three players just doesn’t work. The game still has to be playable at those lower numbers to account for when players are eliminated. As it is now, a few cards in the game don’t seem to take two-player situations into account. And there’s at least one card in the game, the potato king, that makes little sense with just two players since it always punishes the other player. The whole “pirate king” card is also thematically weird for reasons I set out above–namely, why are we rewarding players for bugs? There’s clearly an issue here, but one that’s not well-resolved in the current design.
In the hole ^
Potato Pirates is a cute game of programmed potato pirate ships trying to fry their opponents. The game knows its a programming, educational game and doesn’t shy away from that. The game definitely takes some missteps and misses a few opportunities. Perhaps those will be fixed before production. With that caveat, I have no doubt that it will impart some knowledge and experience of programming in players unfamiliar with loops and conditionals. And certainly some teachers and parents will find it a useful tool to introduce some those fundamental constructs of any programming language. And if that’s what you’re looking for, you should definitely check it out. Plus, it has cute potatoes.
Potato Pirates is in the hole for One Over Par. ^
Fairway was provided a copy of Potato Pirates in order to write this preview. He was not otherwise compensated for this post.
[amazon_link asins=’B00HN2BXUY,B00LE06W7A,B01M7YIVA9,B01DCGR2GS’ template=’TIGR-ProductCarousel’ store=’theigreport-20′ marketplace=’US’ link_id=”]