迷幻游戏背后的逻辑

在我正在做的原型中，有一个类似于宝石迷阵的迷你游戏。使用二维数组（int[,]）的网格，如何知道用户何时形成比赛？我只关心水平和垂直方向。

我想着从头顶上往各个方向看。就像是：

int item = grid[x,y];
if(grid[x-1,y]==item)
{
    int step=x;
    int matches =2;
    while(grid[step-1,y]==item)
    {
        step++;
        matches++
    }
    if(matches>2)
        //remove all matching items
}
else if(grid[x+1,y]==item
    //....
else if(grid[x,y-1==item)
    //...
else if(grid[x,y+1]==item)
    //...

似乎应该有更好的方法。在那儿？

循环遍历同一轴（x或y）中的每个项目，如果它们与上一个项目相同，则它们增量匹配。当下一项变得不同时，检查匹配项是否大于或等于3，调用一个删除匹配项的函数，然后继续。

AS3代码：

var grid:Array = [[2,3,2,2,2,4],
                  [ .. ]]; //multidimensional array
var matches:uint;
var gemType:uint;
for(col = 0; col < grid.length; col++){
    matches = 0;        
    gemType = 0; //Reserve 0 for the empty state. If we make it a normal gem type, then only 2 are needed to match for the start.
    for(i = 0; i < grid[0].length; i++){
        if(grid[col][i] == gemType){
            matches++;
        }
        if(grid[col][i] != gemType || i == grid[0].length - 1){ //subtract 1 because arrays start at 0
            if(matches >= 3){
                removeMatches(blah);
            }
            gemType = grid[col][i];
            matches = 1;
        }
    }
}

这仅适用于x轴，对于y，grid [col] [i]会变成grid [i] [row]等。我敢肯定，您可以弄清楚这一点:)

只是以为我会结合我们在开发类似Match-3的游戏中的经验。

我们为基于Match-3的文字游戏构建了原型，有点像将拼字游戏和Bejeweled混在一起。我们很早就意识到，提供新的宝石/瓷砖填充空白空间的引擎必须具有高度的内省性（我们运行混合启发法和MonteCarlo采样），以便为玩家创造实际的机会，使他们通过三消技工。它比描述要复杂得多，但是我要保持简短，因为我们必须写一篇论文。

为了回答OP问题，我们正在通过非常类似于“ gladoscc”代码段的方法，对模式进行检查，以对当前任何给定电网上的匹配项进行评分。尽管它运行稳定，但在树状搜索播放期间递归运行的计算成本成为一个沉重的负担，因此我们正在使用位板方法重写这部分逻辑和数据表示（通常在象棋，跳棋，奥赛罗等其他网格游戏中实现。）在测试中，我们证明了它在ActionScript中的运行速度可以提高20倍以上，因此对我们来说，这是灌篮-并释放了响应，声音，动画等基本循环。

递归，哟。当您不知道自己的界限时。

   public int getHMatchSize(int row, int column)
    {
        int returnMe = getMatchValue(row, 0, column, 1);

        if (returnMe < 3)
        {
            return 0;
        }
        else return returnMe;
    }


    public int getVMatchSize(int row, int column)
    {
        int returnMe = getMatchValue(row, 1, column, 0);

        if (returnMe < 3)
        {
            return 0;
        }
        else return returnMe;
    }

    /// <summary>
    /// I return the match size.
    /// </summary>
    /// <param name="row"></param>
    /// <param name="rowDelta">1 means look vertically.  Dont set both deltas to 1.</param>
    /// <param name="column"></param>
    /// <param name="columnDelta">1 means look horizontally.  Dont set both deltas to 1.</param>
    /// <returns>The number of contiguous matching things</returns>
    public int getMatchValue(int row, int rowDelta, int column, int columnDelta)
    {
        int[] start = getEndItem(row, -1 * rowDelta, column, -1 * columnDelta);
        int[] end = getEndItem(row, rowDelta, column, columnDelta);

        int returnMe = 0;
        returnMe += end[0] - start[0];
        returnMe += end[1] - start[1];
        return returnMe;
    }

    /// <summary>
    /// I will return the end of a sequence of matching items.
    /// </summary>
    /// <param name="row">start here</param>
    /// <param name="column">start here</param>
    private int[] getEndItem(int row, int rowDelta, int column, int columnDelta)
    {
        Gem matchGem = new Gem(-1);
        int[] returnMe = new int[2];

        if (boardSpace[row + rowDelta][column + columnDelta] == boardSpace[row][column])
        {
            return getEndItem(row + rowDelta, rowDelta, column + columnDelta, columnDelta);
        }
        else
        {
            returnMe[0] = row;
            returnMe[1] = column;
            return returnMe;
        }
    }

您可以使用洪水填充算法。这种类型的问题确实有用。