代表四合棋盘游戏棋子的最佳方法

Question

我正在创建棋盘游戏Quarto。本质上是高级连接4。

每片都有四个显着特征（白色VS黑色|高VS短|方形VS圆形|实心VS空心）。如果您连续获得其中任何一项功能，您将获胜。

目前，我目前正在尝试编写一个函数来检查获胜情况。但是，它有望达到O（n ^ 4），我认为我可以根据我的代码结构来对此进行改进。

当前，我有这个：

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 ",
  "____ ",
};

但是我认为这不是非常有效。我曾考虑过让它们成为自己的类，但是这使得初始化和使用所有这些组件变得困难。

这就是我开始检查胜利的方式：

// 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
    }
  }
}

我该如何改善它并使它对我自己更容易？

Answer 1

每个属性都有2种可能性，因此您可以将它们存储在0或1的位域中。例如：

unsigned char type = (color << 0) | (size << 1) | (shape << 2) | (thickness << 3)

其中每个值是0或1。假设：

enum Color { BLACK = 0, WHITE = 1 };
enum Size { SHORT = 0, TALL = 1 };
enum Shape { CIRCLE = 0, SQUARE = 1 };
enum Thickness { HOLLOW = 0, SOLID = 1 };

然后，您可以通过在一个操作中一次检查XNOR以一次比较2来比较它们，其中每个比较将返回相等比较的类型的位字段。

[（piece1 XNOR piece2）AND（piece2 XNOR piece3）AND（piece3 XNOR piece4）！= 0

喜欢这个

class Piece {
public:
    Piece(Color color, Size size, Shape shape, Thickness thickness) {
        type = (color) | (size << 1) | (shape << 2) | (thickness << 3);
    }

    Color color() {
        return static_cast<Color>((type >> 0) & 1);
    }

    Size size() {
        return static_cast<Size>((type >> 1) & 1);
    }

    Shape shape() {
        return static_cast<Shape>((type >> 2) & 1);
    }

    Thickness thickness() {
        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;
};

我使用此代码对其进行了测试：

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;
}

我决定用一个类来管理它，但是，每个块都是一个4位值，因此可以很容易地以整数类型对其进行管理。