Question

你好，StackOverflow！

我正在编写流行游戏Pentago的JavaScript版本作为辅助项目，然后我必须在秋季返回课程。不幸的是，对于如何从我目前在该项目中取得的进展而言，我完全不知所措。

我的方法

当我开始编写这个项目时，我认为这个游戏的最佳方法是实例化四个矩阵并将它们放在一个列表中。每个矩阵代表Pentago板的一个部分。我发现这种方法在考虑我如何迭代矩阵并确定是否放置了一排5个游戏代币时，给我带来了很多麻烦。

重新评估我的方法

然后，我决定从外部角度了解如何解决这个问题，使其更容易解决。建议我使用一个矩阵而不是四个矩阵。然而，这确实使得每个部分的旋转变得更加困难，但并非不合理。

我的问题......

总而言之，我真正需要知道的是我应该如何确定玩家是否在某个位置放置了“令牌”后赢得了比赛。

以下是我认为我知道的事情：

在玩家旋转象限后，将执行决定游戏是否结束的功能。
鉴于此，我将知道哪个玩家放置了最后一个令牌。我只需要考虑该玩家所下的代币。
我必须从矩阵中放置最后一个令牌的位置迭代矩阵，并确定令牌是否与它相邻。然后，在每个相邻的令牌上递归执行此操作，直到我找到五个相邻的令牌，对角线，垂直或水平。

以下是我为此游戏编写的代码。我真的很感激我在项目的这一部分可以得到任何帮助......它真的让我难过！谢谢！

到目前为止的代码

https://github.com/jakenewby/pentagojs/tree/master/www/app

var game = (function (players){

    var self = {};
    self.numTokensPlaced = 0;

    // instantiate the pentago board to all empty
    self.board = [];
    for(var i=0; i<6; i++)
    {
        self.board[i] = [];
        for(var j=0; j<6; j++) 
        {
          self.board[i][j] = null;
        }
    }

    // rotate one of the four sections of the board
    // given a section and a direction
    self.rotateSection = function (section, direction)
    {
      if(isGameOver())
      {

      }
      else
      {
        if(direction == 'clockwise')
        {
          /*
            var newGrid = [];
            var rowLength = Math.sqrt(section.length);
            newGrid.length = section.length

            for (var i = 0; i < section.length; i++)
            {
                //convert to x/y
                var x = i % rowLength;
                var y = Math.floor(i / rowLength);

                //find new x/y
                var newX = rowLength - y - 1;
                var newY = x;

                //convert back to index
                var newPosition = newY * rowLength + newX;
                newGrid[newPosition] = section[i];
            }

            for (var i = 0; i < newGrid.length; i++)
            {
                console.log(newGrid[i])
            }
            */
        }
        else
        {
          // rotate counter clockwise
        }
        switchTurns();
      }
    }

    // place a token at a place on the board given
    // the player placing the token, the section, and the
    // location coordinates in that section that the token
    // is being placed.
    self.placeToken = function(playerid, location)
    {
        if (self.board[location[0]][location[1]] != null)
        {
            return location.toString() + ' is already taken';
        }
        else
        {
            self.board[location[0]][location[1]] = playerid;
            self.numTokensPlaced = self.numTokensPlaced + 1;
            if(isGameOver())
            {
                alert('game is over!');
            }
        }
    }

    // looks at the current player, and sets the current
    // player variable to the other player to switch turns.
    function switchTurns()
    {
      if (players.current == players[0])
      {
        players.current = players[1];
      }
      else
      {
        players.current = players[0];
      }
      console.log(players.current);
    }

    // look through the board to see if there are any
    // five tokens in a row belonging to one player.
    // returns bool
    function isGameOver(consecutiveTokens)
    {
      // game cannot be over if the number
      // of tokens placed is less than 10
        if(self.numTokensPlaced() >= 10)
        {
            if(consecutiveTokens < 5)
            {
                for(i=0; i < 3; i++)
                {
                    if(self.board[i] != null)
                    {
                        for(j=0; j < 3; j++)
                        {
                            if(self.board[i][j] != null)
                            { 
                                if(self.board[i][j] == players.current)
                                {

                                }
                            }
                        }
                    }
                }
            }
            else
            {
                return true;   
            }
        }      
        else
        {
            return false;
        }
    }

    return self;
}());

游戏规则。

将大理石放在象限中。将大理石放入其中一个象限后，将其中一个象限向任一方向旋转90度。在水平，垂直或对角线对齐五个大理石后，你就赢了！

enter image description here

Answer 1

给定一块固定的板，我会通过创建一个可能的轴数组来解决它：

var axes = [];

// rows
for (var i = 0; i < 6; ++i) {
    axes.push(self.board[i]);
}
// columns
for (var j = 0; j < 6; ++j) {
    var column = [];
    for (var i = 0; i < 6; ++i) {
        column.push(self.board[i][j]);
    }
}
// diagonals
axes.push([self.board[0][1], self.board[1][2], ...])
// two more

使用该数组，您只需遍历所有轴并找到特定玩家的连续填充。

基于矩阵的游戏设计

1 个答案: