Best way to represent Quarto Board Game Pieces - c++

Question

I'm creating Quarto, the board game. It's essentially advanced connect 4.
Each piece has four distinguishing features (WHITE VS BLACK | TALL VS SHORT | SQUARE VS CIRCLE | SOLID VS HOLLOW). If you get four of any of those features in a row, you win.
At the moment, I am current trying to write a function to check for a win. However, it is on track to be O(n^4), and I think I can improve this depending on how I structure my code.
Currently, I have this:
enum Piece
{
WTSS, WTSH, WTHS, WTHH,
WSSS, WSSH, WSHS, WSHH,
BTSS, BTSH, BTHS, BTHH,
BSSS, BSSH, BSHS, BSHH,
EMPTY
};
static const char * PieceStrings[] = {
"WTSS ", "WTSH ", "WTHS ", "WTHH ",
"WSSS ", "WSSH ", "WSHS ", "WSHH ",
"BTSS ", "BTSH ", "BTHS ", "BTHH ",
"BSSS ", "BSSH ", "BSHS ", "BSHH ",
"____ ",
};
But I don't think this is very efficient. I have thought about making them their own class, but it then makes it hard to initialize and work with all of these pieces.
This is how I am starting to go about checking for a win:
// go through all N+2 possible connections
// check if any have shared feature
bool Board::isWin() {
int i, j, k;
for (i = 0, k = BOARDSIZE-1; i < BOARDSIZE; i++, k--) {
for (j = 0; j < BOARDSIZE; j++) {
//Horizontal case
// board[i][j];
//Vertical case
// board[j][i];
}
// Diagonal cases
// board[i][i];
// board[k][i];
}
return false;
}
// Checks if pieces have a similar component
bool Board::checkPieces(list<string> & piecesInARow) {
int i, j;
list<string>::iterator it = piecesInARow.begin();
for (i = 0; i < BOARDSIZE; i++) {
for (j = 0; j < BOARDSIZE; j++) {
// check if pieces all have shared char at index
}
}
}
How can I improve this and make it easier for myself?

Answer 1

Each property has 2 possibilities, so you could store them in a bit-field as 0 or 1. For example:
unsigned char type = (color << 0) | (size << 1) | (shape << 2) | (thickness << 3)
where each value is a 0 or 1. Let's say:
enum Color { BLACK = 0, WHITE = 1 };
enum Size { SHORT = 0, TALL = 1 };
enum Shape { CIRCLE = 0, SQUARE = 1 };
enum Thickness { HOLLOW = 0, SOLID = 1 };
then you could compare them by checking XNOR (bit equality) to compare 2 at a time in one operation, where each comparison will return a bit-field of which types compared equally.
(piece1 XNOR piece2) AND (piece2 XNOR piece3) AND (piece3 XNOR piece4) != 0
Like this
class Piece {
public:
Piece(Color color, Size size, Shape shape, Thickness thickness) {
type = (color) | (size << 1) | (shape << 2) | (thickness << 3);
}
Color color() const {
return static_cast<Color>((type >> 0) & 1);
}
Size size() const {
return static_cast<Size>((type >> 1) & 1);
}
Shape shape() const {
return static_cast<Shape>((type >> 2) & 1);
}
Thickness thickness() const {
return static_cast<Thickness>((type >> 3) & 1);
}
static bool compare(Piece p0, Piece p1, Piece p2, Piece p3) {
unsigned char c[3];
c[0] = ~( p0.type ^ p1.type ); // XNOR
c[1] = ~( p1.type ^ p2.type ); // XNOR
c[2] = ~( p2.type ^ p3.type ); // XNOR
return (c[0] & c[1] & c[2] & 0b1111) != 0;
}
protected:
unsigned char type;
};
I tested it with this code:
int main() {
Piece p0(WHITE, SHORT, CIRCLE, HOLLOW);
Piece p1(WHITE, SHORT, CIRCLE, HOLLOW);
Piece p2(BLACK, SHORT, CIRCLE, HOLLOW);
Piece p3(BLACK, TALL, CIRCLE, SOLID);
const char* str = Piece::compare(p0, p1, p2, p3) ? "success" : "fail";
std::cout << str << '\n';
return 0;
}
I decided to manage it with a class, however, each piece is a 4-bit value, so it can be managed in an integral type just as easily.
Another consequence of doing it this way is that pieces can be randomized by picking a value between 0b0000 and 0b1111, which is [0,15] inclusive.