宝石をちりばめたようなゲームの背後にあるロジック

私がやっているプロトタイプには、宝石をちりばめたようなミニゲームがあります。2D配列のグリッド（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）内の各アイテムをループします。それらが前のアイテムと同じである場合、それらは一致をインクリメントします。次のアイテムが異なる場合、matchesが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]などになります。

マッチ3のようなゲームを作成した経験に私は圧倒されると思っただけです。

マッチ3ベースのワードゲームのプロトタイプを作成しました。これは、スクラブルとビジュエルドをマッシュアップするようなものです。空のスペースを埋めるために新しい宝石/タイルを供給するエンジンは、プレイヤーが文字列を作成して単語を形成する実際の機会を作成するために、非常に内省的である必要があることを非常に早い段階で認識しました（ハイブリッドヒューリスティックとモンテカルロサンプリングを実行します）マッチ3メカニック。説明よりもずっと複雑ですが、論文を書かなければならないので簡潔にしています。

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

フラッドフィルアルゴリズムを使用できます。このタイプの問題には本当に役立ちます。