0

I have already asked a question about the subject in here:
https://stackoverflow.com/questions/19916951/generating-a-tree-form-array-for-ataxx-game-in-java

But let me go step by step:

What is the best way (or the best data structure) to represent a state of the Ataxx game (with 7x7 grid board)?

* The state is represented by a node of the game tree but what's in the node? A value? A string? Another data structure?

Community
  • 1
  • 1
zallexy
  • 131
  • 1
  • 2
  • 7

2 Answers2

2

The entire board can be represented by a 2D array of some integral type (i.e. byte[][]), or perhaps an enum[][]. Then 0 can, for example, represent an empty cell, 1 can represent a cell with player 1's piece and 2 can represent a cell with player 2's piece.

A node in the game tree would typically be the entire board (so the byte[][] or enum[][]).

If you're looking for a more compact representation of a board, you can also represent a board using base-3 or base-4 (2 bits, easier to work with) notation, but that's a bit complex (you can probably stick to the 2D array until you start having memory / running time issues - as long as you abstract it into a class, the conversion should be fairly simple, and easy to test).

Bernhard Barker
  • 54,589
  • 14
  • 104
  • 138
  • I've already created the array with value= 0 if empty cell, +1 if player1, -1 if player2. My problem is not with that. I am building the game tree so I need to represent each node with a game state. The array alone is not, in my point of view, sufficient as a node. In the node I should also have the information of which player has what cells. That's why I thought of a hashmap to hold all the occupied cells to the value representing the player( 1 or -1). Please tell me what do you think and thanks for your answer – zallexy Nov 13 '13 at 20:58
  • You said that the node would be the entire board, I agree, but the board should have cells occupied by player1, cells occupied by player2 and the empty cells too. So every node should hold these information which are different from a node to another. So how would you represent all these information in the tree? – zallexy Nov 13 '13 at 21:04
  • @zallexy You can either perform increment changes (make-unmake) or deep copy the state (copy-make) when making moves. The former is faster, while the latter is usually cleaner. You can decide which is suitable depending on how light your node state is. If you do opt for the array approach make-unmake would probably be worth it, but if you use bitboards, it's only two integers, so it wouldn't matter. You can of course use a combination of data structure, depending on what information you need (bitboard for fast general operations, array to quickly determine the piece on a particular square). – Zong Nov 13 '13 at 21:24
  • @zallexy Yes, as Zong said, each node will have a copy of the board (the incremental changes will only work if you're doing a DFS-based approach) - whenever a player makes a move, copy the board to create the new node. – Bernhard Barker Nov 13 '13 at 21:29
  • It's tagged minimax, so I'm guessing that is fine. Keeping track of incremental changes can be a real pain though. I'm trying to debug a problem in my chess engine that takes an hour of search to reproduce right now... – Zong Nov 13 '13 at 21:32
  • @Zong Zheng Li I am not savy to understand all that. I will try to work out one of these slutions and will get back to u if I have questions – zallexy Nov 13 '13 at 22:16
2

I would employ a very effective representation taken from chess and checkers: bitboards. The concept is to represent pieces with bits, and so the set of pieces of a player can be represented with a field of bits. We need at least 49 bits, so a 64-bit integer would work nicely.

This is an extremely memory and computational efficient representation, and it is also more expressive than other representations. You can easily work with both single pieces as well entire sets at once with bitwise operations. With array based representations such as the byte[][] suggested, you have to loop way too much for operations that can be represented by a single operator with bitboards (&, |, ^, <<, >>>, etc).

The set bits give the player's pieces. For example, this might be bitboard for one player. You will need another bitboard for the other player. 

0000000000000000000000000000000010000000001000000

In decimal, this would be long bitboard = 65600;. If we insert some new lines, it looks like this: 

0000000
0000000
0000000
0000000
0000100
0000000
1000000

To work with this efficiently, we can precompute some tables. Thus for the piece in the center on the 32nd bit/square, we might have a surrounding table that when used as surrounding[square] gives:

0000000
0000000
0000000
0001110
0001010
0001110
0000000

We can then find the intersection of this with the opponent's bitboard with the bitwise & operator, or takes its union with |, or difference with ^, etc. You can shift the entire the bitboards one row up with << 7, or do any number of complex operations easily. It's has lot of expressive power, and most of these operations only take a single clock cycle, so it is also incredibly efficient.

Zong
  • 6,160
  • 5
  • 32
  • 46
  • This should be a powerfull solution, I am considering it and I am looking to figure out how to use the bitboard. I might have some other questions, thanks for the answer – zallexy Nov 13 '13 at 21:01
  • @zallexy No problem, remember that upvoting/accepting is the best way to say thanks on this site. – Zong Nov 13 '13 at 21:05