ios - 如何检查我的游戏的数组数组

Question

我正在制作一款棋盘游戏，其中每个点都是一个按钮。除了我想检测胜利之外，一切都按预期进行。我的板高 5 格，宽 4 格。所以20个按钮。它们的标题如下:

0   1   2   3

4   5   6   7

8   9   10  11

12  13  14  15

16  17  18  19

我创建了一个包含所有可能获胜的数组。按钮上有棋子的图像，您必须连续获得三个棋子。这是我的胜利数组

                            // horizontal wins
var winList: [[Int]] = [    [0,1,2],    [1,2,3],
                            [4,5,6],    [5,6,7],
                            [8,9,10],   [9,10,11],
                            [12,13,14], [13,14,15],
                            [16,17,18], [17,18,19],

                            // vertical wins
                            [0,4,8],    [4,8,12],   [8,12,16],
                            [1,5,9],    [5,9,13],   [9,13,17],
                            [2,6,10],   [6,10,14],  [10,14,18],
                            [3,7,11],   [7,11,15],  [11,15,19],

                            // right diagonal wins
                            [2,5,8],    [3,6,9],    [6,9,12],
                            [7,10,13],  [10,13,16], [11,14,17],

                            // left diagonal wins
                            [1,6,11],   [0,5,10],   [5,10,15],
                            [4,9,14],   [9,14,19],  [8,13,18]]

我有一个名为 checkForWin 的空函数。我怎样才能检查是否有任何标题按钮与 winList 中的模式之一匹配。为了获胜，他们的按钮上都应该有相同的图像。

我之前也做过类似的合法举动。我有一个数组数组。这是我之前的功能:

func checkIfValidMove(moveFromButton: UIButton, moveToButton: UIButton) -> Bool {
        var moveFromButtonTitle = moveFromButton.currentTitle
        var moveToButtonTitle = moveToButton.currentTitle
        var moveFromButtonTitleInt = moveFromButtonTitle?.toInt()
        var moveToButtonTitleInt = moveToButtonTitle?.toInt()
        if moveToButton.imageView!.image != UIImage(named:"NoPiece.png") {
            return false
        } else {
            if contains(moveList[moveFromButtonTitleInt!], moveToButtonTitleInt!) {
                return true
            } else {
                return false
            }
        }
    }

这是我的合法行动变量:

var moveList: [[Int]] = [   [1,4],      [0,2,5],        [1,3,6],        [2,7],
                            [0,5,8],    [1,4,6,9],      [2,5,7,10],     [3,6,11],
                            [4,9,12],   [5,8,10,13],    [6,9,11,14],    [7,10,15],
                            [8,13,16],  [9,12,14,17],   [10,13,15,18],  [11,14,19],
                            [12,17],    [13,16,18],     [14,17,19],     [15,18]]

感谢任何帮助!感谢您的宝贵时间!

Answer 1

Huang Chen 的评论让我想到了更聪明的方法，而不仅仅是定义巨大的数组。你的解决方案的问题很明显——如果你想增加游戏板的尺寸或只是改变尺寸，你将不得不重建你的定义文件。此外，当增加“按钮”的数量时，可能的组合数量将呈指数增长。当然，这意味着您将不得不为小型电路板进行大量的迭代，更不用说像 10x10 这样的电路板了。

模式

但是以这种不同的方式思考，如果您可以在定义中找到模式怎么办？然后，它会让事情变得容易得多。当您看到您的定义时，是否有一些相似之处？是的，有!

• 一切似乎都按升序排列，这是好的开始
• 一切都增加相同的数量!
• 对于水平获胜，所有内容都必须在同一行并且数字之间必须相差 1
• 对于垂直获胜，所有内容都必须在同一列上，并且数字之间必须相差 4
• 对于对角线，它们必须是相差 3 或 5 的序列，并且它还必须具有行的序列，因此每个数字都从下一行开始，并且仅从下一行开始

所以当你看到这对每个模式都适用但对所有其他模式都不成立时，你可以清楚地看到一切都只是简单的加法序列，我们可以制作算法来检查所有模式而不是使用你的定义？为此，我们需要一些方法:

检查数字是否按顺序:

func isSequence3(selection : [Int], allowedDifference : Int) -> Bool {

    // Check if difference between [10] is the same as [21], which makes sequence. Also, check for value of that difference
    let difference10 = selection[1] - selection[0]
    let difference21 = selection[2] - selection[1]
    return difference10 == difference21 && difference10 == allowedDifference
}

检查数字是否在不同的行上，是否连续:

func isRowSequence(selection : [Int], rowSize : Int) -> Bool {

    var currentRow = (selection[0] / rowSize) - 1
    for number in selection {
        // Check if row is increasing by one in each step, if yes, remember last row
        if number / rowSize - currentRow == 1 {
            currentRow++
        } else {
            return false
        }
    }

    // It is row Sequence
    return true
}

检查数字是否在同一行和同一列:

func isOnSameRow(selection : [Int], rowSize : Int) -> Bool {

    return selection.first! / rowSize == selection.last! / rowSize
}


func isOnSameColumn(selection : [Int], columnSize : Int) -> Bool {

    let column = selection.first! % columnSize
    for number in selection {
        if number % columnSize != column {
            return false
        }
    }

    return true
}

现在我们已经有了所需的所有方法，我们只需要验证方法来将所有这些规则放在一起:

func isValidPattern(selection : [Int]) -> Bool {

    // Sort user selection first, ascending
    var ascSelection = selection.sorted(ascending)

    // Validate for horizontal wins
    let isValidForHorizontalWins = self.isSequence3(ascSelection, allowedDifference: 1)
                                && self.isOnSameRow(ascSelection, rowSize: ROW_SIZE)

    // Validate for vertical wins
    let isValidForVerticalWins = self.isSequence3(ascSelection, allowedDifference: 4)
                             && self.isOnSameColumn(ascSelection, columnSize: COLUMN_SIZE)

    // Validate for diagonals
    let isValidForDiagonals =  self.isSequence3(ascSelection, allowedDifference: 3)
                            || self.isSequence3(ascSelection, allowedDifference: 5)
                            && self.isRowSequence(ascSelection, rowSize: ROW_SIZE)

    // Is at least one rule valid?
    return isValidForHorizontalWins || isValidForVerticalWins || isValidForDiagonals
}

就是这样(或者至少我认为应该是这样，考虑到现在已经很晚了，我明天会回顾一下以确保:) 不管怎样，here is complete gist与所有代码在一起。通过调整验证方法中的数字，您可以使其适用于您想要的任何尺寸。还有一些优化需要完成，但那是为你准备的。

最后的一些提示:

• 始终寻找动态的解决方案。最后，它会为您节省大量时间(试图弄清楚所有组合.. 不好玩)
• 正如您可能注意到的那样，我正在使用整数。 UIButton 有 .tag 变量，您可以在其中分配数字。这样，您就可以轻松地通过标签而不是图像来识别按钮，在您的情况下，这会使整个解决方案变得更加容易。