Bejeweled benzeri bir oyunun arkasındaki mantık

Yaptığım bir prototipte bejeweled'e benzer bir mini oyun var. 2d dizisi ( int[,]) olan bir ızgara kullanarak , kullanıcının ne zaman bir eşleşme oluşturduğunu nasıl bilebilirim? Sadece yatay ve dikey olarak ilgilenirim.

Başımın üstünden her yöne bakacağımı düşünüyordum. Gibi bir şey:

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)
    //...

Daha iyi bir yol olmalı gibi görünüyor. Var mı?

Aynı eksendeki (x veya y) her bir öğeyi döndürün, önceki öğeyle aynı ise, eşleşir. Sonraki öğe farklı olduğunda, eşleşmelerin 3 veya daha büyük olup olmadığını kontrol edin, eşleşen öğeleri kaldıran bir işlevi çağırın ve devam edin.

AS3 kodu:

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

Bu sadece x ekseni içindir, y için grid [col] [i] grid [i] [row] vb. Olur. Eminim bunu anlayabilirsiniz :)

Sadece Match-3 benzeri bir oyun oluşturma deneyimimizle tartacağımı düşündüm.

Scrabble ve Bejeweled'i ezmek gibi, Match-3 tabanlı bir kelime oyunu için bir prototip geliştirdik. Boş alanları doldurmak için yeni taşlar / karolar sağlayan motorun, bir oyuncunun kelimeleri oluşturmak için harfleri dizmesi için gerçek fırsatlar yaratmak amacıyla oldukça içgözlü olması gerektiğini (hibrid sezgisel tarama ve MonteCarlo örnekleme yapıyoruz) çok erken fark ettik. Maç-3 tamircisi. Bu açıklamadan çok daha ayrıntılı ama kısa tutuyorum çünkü bir makale yazmak zorundayız.

OP'ye cevap vermek için - şu anda, herhangi bir girdide kaç eşleşme olduğunu "gladoscc" kod pasajına çok benzer bir yöntemle puanlamak için kalıp kontrolleri yapıyoruz. Sağlam bir şekilde çalışmasına rağmen, ağaç araması oynatımı sırasında yinelemeli olarak çalıştırmanın hesaplama maliyeti önemli bir yük haline gelir, bu nedenle mantığın bu kısmını ve bit-board metodolojisi ile veri sunumunu yeniden yazma sürecindeyiz ( satranç, dama, Othello gibi oyunlarda yaygın olarak uygulanır.) Testlerde, ActionScript'te 20 kattan daha hızlı çalışabileceğini gösterdik ve bu yüzden bizim için bir slam-dunk - ve yanıt verme, ses, animasyon vb. için gerekli döngüleri serbest bırakır.

Özyineleme, yo. Sınırlarınızı bilmediğiniz zaman içindir.

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

Taşkın dolgu algoritmasını kullanabilirsiniz . Bu tür bir sorun için gerçekten kullanışlı.