id: tak title: Tak date_created: 2021-05-01 date_last_updated: 2021-05-01 description: My effort at making a functioning python program to play Tak. ---

## Tak

One of my favourite fantasy book series is the Kingkiller Chronicles by Patrick Rothfuss. In the second book The Wise Man’s Fear there is a board game that they play that sounded fascinating. I have always like abstract strategy games and this was his worlds “Chess”; the game that had been around forever, simple rules but deep strategy etc.

I was so excited when I found out that it was being made into a full game by Cheapass Games. The rules are available for free on their website. I bought myself a copy and it is a lot of fun. They did an amazing job getting the feel of the game right and it is now for sale on WorldBuilders Market. Proceeds from WorldBuilders go to charity so if you try out the game and enjoy it please consider buying a copy.

As a project I made a digital copy of the game. Source code here. It is written in python 3 and the only extra library it needs to run is pygame. If you want to run the tests you will need pytest as well.

Here is the program interface.

Tak Program

The game was a very interesting challenge to implement for a few reasons.

The board size is flexible. It ranges from 3×3 to 8×8 (skipping 7×7 but I am not quite sure why). The rules for victory are the same regardless of board size but the number of pieces each player has access to changes. The board had to be housed in a flexible object that would also dictate the number of pieces.

While there are only two types of pieces (regular and capstones), the standard pieces can be played in 2 different orientations. Flat placement is the default. It contributes to win conditions and can make stacks. Placing a normal piece as a wall blocks other pieces but does not contribute to your win condition and can only be at the top of a stack. The capstone has the best characteristics of both and can squish walls to flat if it lands on them alone.

Tak pieces (left to right: flat, wall, capstone)

Rather than make an object for each piece I built the piece specific rules into the move action. The move is the same at its core for each piece and the only difference is the interaction when one piece lands on top of another. Storing the pieces as integers in a 2d array makes this far simpler. As the interactions depend on both pieces, using an integer makes that comparison very easy.

The game has an interesting 3 dimensional component. The pieces can be stacked on top of one another and a stack can move as far as the stack is high (in a straight line controlled by the player whose piece is at the top) dropping one piece at a minimum on each square along the way. This means that each square in the 2d array needs to contain a stack where new pieces are added to the top. When pieces are lifted off a stack your hand acts like a second stack. Pieces are popped off the top of the square and added to the stack in your hand. Then they are dropped from the “bottom” of this inverted stack as you move.

The comparison needs to be done from the “bottom” of the inverted stack in your hand to the top of the stack that the piece will land on.

That is the main challenge of the game play. The victory conditions were also challenging. The game has 3 different ways that it can end and 2 possible ways to calculate who won.

The game ends when one player builds a connected line of pieces from one of the sides of the board to the opposite side. The line does not need to be straight but squares do not connect on the diagonal. The victor in this case is the player who has the “road”. If a move creates a road for both players the active player wins.

Victory!

The game also ends if either player runs out of pieces or there are no more open spaces on the board. In that case the winner is the player with the control of the most squares of the board.

Both of these need to be checked after each turn and when a winner is found the points are calculated based on the size of the board and the number of pieces left.

Compared to Chess or Go, Tak is a little bit more complicated. This is not through having a significantly large number of rules but the systems intertwine more and are more flexible. This does not mean that it is a better game just different, but it has a similar feeling of depth and timelessness.

The board being stored as an array of integers means that it takes very little memory. That made it simple to store past boards in a stack and implement an undo function. Both to take back moves and even go back to a previous game from the same session.

I am pleased with how the game turned out. I am working on other things at the moment but in the future I would like to do two more things with this game. I want to implement it online so that I can play with friends over the internet. I would also like to try and develop an A.I. agent to play the game. I had this in mind when I was writing it so made sure that the GUI was disconnected from the actual mechanics behind the game. This will hopefully make it easier to connect to an agent for training.