Swift: How to add a delay to my AI in tic tac toe game?

Question

I have just completed the AI for my tic tac toe game in Swift and while everything works fine, it seems a bit odd to the user to have the computer opponent play immediately after the user plays without "thinking". How can I add a delay to the AI's response?

My AI code:

func aiTurn() {
    if done {
        return
    }
aiDeciding = true

//Computer: Has 2 in row

    if let result = rowcheck(value:0) {
        var wherePlayResult = wherePlay(result.location, pattern:result.pattern)
        if !isOccupied(wherePlayResult) {
            setImgforCircle(wherePlayResult, player: 0)
            aiDeciding = false
            checkforWin()
            return
        }
    }

//Player: Has 2 in row

    if let result = rowcheck(value: 1) {
        var wherePlayResult = wherePlay(result.location, pattern:result.pattern)
        if !isOccupied(wherePlayResult) {
            setImgforCircle(wherePlayResult, player: 0)
            aiDeciding = false
            checkforWin()
            return
        }
    }

    func firstOpen(#isCorner:Bool)->(Int?) {
        var spots = isCorner ? [1,3,7,9] : [4,2,8,6]
        for spot in spots {
            if !isOccupied(spot) {
                return spot
            }
        }
        return nil
    }

//Computer: Center spot available?
    if !isOccupied(5) {
        setImgforCircle(5, player: 0)
        aiDeciding = false
        checkforWin()
        return
    }

//Computer: Corner available?
    if let cornerOpen = firstOpen(isCorner: true) {
        setImgforCircle(cornerOpen, player: 0)
        aiDeciding = false
        checkforWin()
        return
    }

//Computer: Side spot available?
    if let sideOpen = firstOpen(isCorner: false) {
        setImgforCircle(sideOpen, player: 0)
        aiDeciding = false
        checkforWin()
        return
    }

    ResultsLabel.hidden = false
    ResultsLabel.text = "Tied!"
    Results2.hidden = false

    aiDeciding = false
}

func wherePlay(location:String, pattern:String)->(Int) {
    var pattern1 = "011"
    var pattern2 = "101"
    var pattern3 = "110"

    switch location {
    case "top":
        if pattern == pattern1 {
                return 1
        }
        else if pattern == pattern2 {
                return 2
        }
        else {
                return 3
        }
    case "bottom":
        if pattern == pattern1 {
            return 7
        }
        else if pattern == pattern2 {
            return 8
        }
        else {
            return 9
        }
    case "middle across":
        if pattern == pattern1 {
            return 4
        }
        else if pattern == pattern2 {
            return 5
        }
        else {
            return 6
        }
    case "left down":
        if pattern == pattern1 {
            return 1
        }
        else if pattern == pattern2 {
            return 4
        }
        else {
            return 7
        }

    case "middle down":
        if pattern == pattern1 {
            return 2
        }
        else if pattern == pattern2 {
            return 5
        }
        else {
            return 8
        }
    case "right down":
        if pattern == pattern1 {
            return 3
        }
        else if pattern == pattern2 {
            return 6
        }
        else {
            return 9
        }
    case "left-right diagonal":
        if pattern == pattern1 {
            return 1
        }
        else if pattern == pattern2 {
            return 5
        }
        else {
            return 9
        }
    case "right-left diagonal":
        if pattern == pattern1 {
            return 3
        }
        else if pattern == pattern2 {
            return 5
        }
        else {
            return 7
        }

    default: return 4

    }
}

//=============================================================================================

Connor Pearson · Answer 1 · 2014-07-13T00:33:16.233

0

I think the easiest way would be to delay the call of the aiTurn() function with dispatch_after.

Assuming it is a method in your viewController, it would look something like this. Instead of calling self.aiTurn(). Use

let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(NSEC_PER_SEC * 2))
dispatch_after(dispatch_time, dispatch_get_main_queue(),{ aiTurn() })

edited Jul 13 '14 at 00:33

answered Jul 12 '14 at 20:47

Connor Pearson

63,902
28
145
142

It says that performSelector is unavailable – blue Jul 13 '14 at 00:08
So I put that into my code and there are no errors but there's still no delay. What is gcd exactly? – blue Jul 13 '14 at 00:16
He got the numbers wrong. See my answer here for the way to use dispatch_after in Swift: http://stackoverflow.com/a/24318861/341994 – matt Jul 13 '14 at 00:30
@matt is correct, the units were wrong. This will delay it by two seconds – Connor Pearson Jul 13 '14 at 00:34

score 0 · Answer 2 · answered Aug 05 '14 at 08:24

Yep - I searched around and found a solution - here is the code I used - slightly different than yours but I think you'll get it:

@IBAction func UIButtonClicked(sender:UIButton){
    userMessage.hidden = true
    if !plays[sender.tag] && !aiDeciding && !done {
        setImageForSpot(sender.tag, player:1)
    }
    checkForWin()
    func delay(delay:Double, closure:()->()) {
        dispatch_after(
            dispatch_time(
                DISPATCH_TIME_NOW,
                Int64(delay * Double(NSEC_PER_SEC))
            ),
            dispatch_get_main_queue(), closure)
    }
    delay(0.4) {
        self.aiTurn()
        // do stuff
    }

}

Swift: How to add a delay to my AI in tic tac toe game?

2 Answers2