ตรรกะที่อยู่เบื้องหลังเกมที่คล้ายประดับด้วยเพชรพลอย

ในต้นแบบที่ฉันทำมี minigame คล้ายกับ bejeweled การใช้กริดที่เป็นอาร์เรย์ 2 มิติ ( 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) เพื่อสร้างโอกาสที่แท้จริงสำหรับผู้เล่น ช่าง Match-3 มันเป็นวิธีที่ซับซ้อนกว่าคำอธิบาย แต่ฉันพูดสั้น ๆ เพราะเราต้องเขียนบทความ

เพื่อตอบคำถาม OP - เรากำลังทำการตรวจสอบรูปแบบเพื่อให้คะแนนว่ามีการแข่งขันกี่ครั้งในรอบใด ๆ ณ เวลาปัจจุบันผ่านวิธีการที่คล้ายกับโค้ด "gladoscc" มาก ในขณะที่มันทำงานได้อย่างมีประสิทธิภาพต้นทุนการคำนวณสำหรับการทำงานที่เกิดขึ้นซ้ำ ๆ ในช่วงการค้นหาต้นไม้กลายเป็นภาระที่สำคัญดังนั้นเราจึงอยู่ในกระบวนการของการเขียนส่วนนี้ของตรรกะและการแสดงข้อมูลด้วยวิธีการแบบ มีการใช้งานทั่วไปในเกมอื่น ๆ เช่นเกมหมากรุกตัวตรวจสอบ Othello และอื่น ๆ ) ในการทดสอบเราได้แสดงให้เห็นว่ามันสามารถทำงานได้เร็วกว่า ActionScript ถึง 20 เท่าและสำหรับพวกเราที่ต้องทำมันก็คือ slam-dunk - และปลดปล่อยวงจรที่จำเป็นสำหรับการตอบสนองเสียงภาพเคลื่อนไหว ฯลฯ

การเรียกซ้ำ, yo สำหรับเมื่อคุณไม่ทราบขอบเขตของคุณ

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

คุณสามารถใช้อัลกอริทึมเติมน้ำท่วม มันมีประโยชน์มากสำหรับปัญหาประเภทนี้