计算机AI上交UIViewController

Question

In a swift game using UIKit I am writing, a human player will interact with UIKit UIButtons, GUI elements to take actions.

In the game, the player will play against AI players.

But here's the thing; the human player presses buttons and interacts and the AI player does not.

Given a simple UIViewController;

class SampleViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
    }

    @IBAction func buyBtnPressed(_ sender: UIButton) {
       print ("pressed")
    }
}

So what I'm trying to ascertain is, how does the AI player itself take actions and handling turns within the context of the current view controller?

I believe the best way to do this is that there should be a loop that will wait until all players have completed their respective turns.

But where does this loop go? In the view did load?

If so, won't it eat up memory, or potentially lead (if not careful) to an endless loop?

I'm finding it hard to ascertain how an AI player can take actions within the given context of a UIViewController considering GUI elements are for human interaction.

I don't mean the AI should be animating pressing buttons or interacting with the screen, I mean; I have a UIViewController, it has a view did load; what is the strategy of implementing AI turns and whether or not this should be be achieved in a "game loop" in the View did load or can this be achieved in another way?

My question is; given the context of a UIViewController; how can I code the handling of an AI player taking turns and can this be achieved with a loop or another strategy?

Many thanks

edit: Code is now added

I have written out a turn base manager using Swift playgrounds, and 2 examples one using a UIViewController and another is a loop.

code now follows;

import Foundation
import GameplayKit

class Player {
    var name: String
    public private(set) var isAI: Bool = false
    public private(set) var turnOrder: Int = 0

    init(name: String, isAI: Bool?) {
        self.name = name
        if let hasAI = isAI {
            self.isAI = hasAI
        }
    }

    func setTurnOrderIndex(number: Int) {
        self.turnOrder = number
    }
}

let p1 = Player.init(name: "Bob", isAI: false)
let p2 = Player.init(name: "Alex", isAI: true)

protocol TurnOrderManagerDelegate: NSObjectProtocol {
    func turnOrderWasSet()
}

protocol TurnDelegate: class {
    func turnIsCompleted()
}

class Turn: NSObject {
    weak var player: Player?
    weak var delegate: TurnDelegate?

    public private(set) var completed: Bool = false {
        didSet {
            delegate?.turnIsCompleted()
        }
    }

    init(player:Player, delegate: TurnDelegate) {
        self.player = player
        self.delegate = delegate
    }

    func setAsComplete() {
        self.completed = true
    }
}

class TurnOrderManager: NSObject, TurnOrderManagerDelegate, TurnDelegate {
    static var instance = TurnOrderManager()

    public private(set) var turnOrderIndex: Int = 0
    public private(set) var turnOrder: [Turn] = [Turn]() {
        didSet {
            self.turnOrderWasSet()
        }
    }

    var playerOnTurn: Player? {
        let turnObj = self.turnOrder[turnOrderIndex]
        return (turnObj.player)
    }

    var allTurnsCompleted: Bool {
        let filtered = turnOrder.filter { (turnObj:Turn) -> Bool in
            return (turnObj.completed)
        }.count
        return (filtered == turnOrder.count)
    }

    func setTurnOrder(players:[Player]) {
        if (self.turnOrder.count == 0) {
            for playerObj in players {
                let turnObj = Turn.init(player: playerObj, delegate: self)
                self.turnOrder.append(turnObj)
            }
        }
    }

    func turnOrderWasSet() {
        for (index, turnObj) in self.turnOrder.enumerated() {
            turnObj.player?.setTurnOrderIndex(number: index)
        }
    }

    func next() {
        if (turnOrderIndex < (self.turnOrder.count - 1)) {
            turnOrderIndex += 1
        }
        else {
            turnOrderIndex = 0
        }
    }

    internal func turnIsCompleted() {
        print (" - turnIsCompleted")
        TurnOrderManager.instance.next()
    }

}

class GameModel {
    var turnOrderManager: TurnOrderManager

    init() {
        self.turnOrderManager = TurnOrderManager.instance
        self.turnOrderManager.setTurnOrder(players:[p1,p2])
    }

    // other game model stuff [...]
}

class Phase1State : GKState {

    var gameModel: GameModel!

    init(gameModel:GameModel) {
        super.init()
        self.gameModel = gameModel
    }

    override func isValidNextState(_ stateClass: AnyClass) -> Bool
    {
        return false
    }

    override func didEnter(from previousState: GKState?) {
    }

    override func willExit(to nextState: GKState) {
    }

    // MARK: - Action

    func buy() {
        let index = self.gameModel.turnOrderManager.turnOrderIndex
        let turn = self.gameModel.turnOrderManager.turnOrder[index]
        turn.setAsComplete()
    }
}

class SomeViewController: UIViewController
{
    var gameModel: GameModel?
    weak var gamePhase: Phase1State?
    var isPhaseComplete: Bool {
        return self.gameModel?.turnOrderManager.allTurnsCompleted ?? false
    }

    override func viewDidLoad() {
        super.viewDidLoad()

        self.gameModel = GameModel.init()
        self.gamePhase = Phase1State.init(gameModel: self.gameModel!)
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }

    func buyButtonPressed() {
        self.gamePhase?.buy()
        self.finishTurn()
    }

    func finishTurn() {
        guard let turnIndex = self.gameModel?.turnOrderManager.turnOrderIndex else {
            return
        }
        guard let turn = self.gameModel?.turnOrderManager.turnOrder[turnIndex] else {
            return
        }
        turn.setAsComplete()

        if (self.isPhaseComplete)
        {
            print ("All turns are completed")
        }
        else {
            //self.gameModel?.turnOrderManager.next()
            self.gamePhase?.buy()

            guard let playerOnTurn = self.gameModel?.turnOrderManager.playerOnTurn else {
                print ("No player is on turn")
                return
            }

            print ("\(playerOnTurn.name) is on turn")

            if (playerOnTurn.isAI)
            {
                self.gamePhase?.buy()
                self.finishTurn()
            }
        }
    }
}


// EXAMPLE 1 -- first attempt ...

let vc = SomeViewController()
vc.viewDidLoad()
vc.buyButtonPressed()

// EXAMPLE 2 -- another attempt ....


let gameModel: GameModel = GameModel.init()
let gamePhase = Phase1State.init(gameModel: gameModel)

// player then takes an action

while (gameModel.turnOrderManager.allTurnsCompleted == false)
{
    let turnIndex = gameModel.turnOrderManager.turnOrderIndex
    let turnObj = gameModel.turnOrderManager.turnOrder[turnIndex]
    guard let playerOnTurn = turnObj.player else {
        break
    }

    print ("Player \(playerOnTurn.name) is on turn")

    gamePhase.buy()
}

print ("All turns are completed, advance to next phase")

The issue is;

On the finishTurn, it only seems to work if it relies on the first player in the index is a human player. If its not, I have no idea how to make it fire the buy action.

On the second example, I use a loop; but I'm concerned using a loop could end up just looping forever.

My query is therefore clarifyed, how can I ensure my view controller will fire actions for AI players when they don't press buttons and loop through each player and execute their respective turn.

Many thanks

Further edit:

I do not know if I should have the while (gameModel.turnOrderManager.allTurnsCompleted == false) loop inside my viewDidLoad() to act like a game loop.

Answer 1

Look, I'm not sure on what kind of game you're making, buy you should probably learn SpriteKit , specially SKActions . With that, you can easily control the flow of events from your game.

With that said, how is your AI implementation? Based on your code, I would begin with something like this:

class AI {

    enum Decision {
        case doSomething
        case doAnotherThing
        case dontDoAnything
    }

    public func decide() -> Decision {
        // Decide which action the AI will take...
        return .doSomething // This return is just a example!
    }

    public func act(on : Decision) {
        // Do whatever the AI needs based on a decision...
    }

}

Then, in your ViewController:

class SampleViewController: UIViewController {

    var ai = AI()

    override func viewDidLoad() {
        super.viewDidLoad()
    }

    @IBAction func buyBtnPressed(_ sender: UIButton) {
        print ("pressed")
        ai.act(on: ai.decide())
    }

}

I hope that helps!

Answer 2

There is no need to specifically use Sprite Kit for this. SpriteKit would be more to do with how the UI is made rather than how the logic of the game works.

However, I would recommend looking at GameplayKit. It's a framework that contains lots of built in game logic tools. Specifically you want something like the GKDecisionTree . There are a few WWDC videos about it too. GameplayKit can be used with SpriteKit, UIKit, SSceneKit or any other game engine that you decide to use (or not).

Also, the question you're asking is a very general question about game development. Having the computer "decide" to do something is quite a complex subject.

I'd also suggest having a quick watch of this video from AI & Games and other videos from that channel.

It'll give you an idea of how to approach your problem.

Session 609 and 608 from WWDC 2015 and 2016 are prob good :D

Regarding updating the AI.

Your AI should be event driven. You have the concept of "turns" and "players". There is a point in the game at which it becomes a "player's" "turn". (Even at the very beginning of the game it is either Player 1 or Player 2's turn.

At this time there are two possibilities. Either the player is an AI, or the player is a person.

As soon as this happens there should be some sort of trigger (like a function call or something) that tells the player its turn has started.

If that player is the AI then you need to start some sort of calculation (maybe with a built in delay to make it realistic) so that it decides what to do.