как ждать рекурсии до завершения выполнения функции

Question

У меня есть одна функция Recursion, которая выполняет действия, и в своем последнем цикле она проверяет условие, и если условие истинно, она вызывает другую аналогичную функцию, которая также выполняет действия. Но пока вторая функция выполняет действия через рекурсию, первая функция начинает выполняться. Итак, теперь два действия выполняются одновременно. Я прочитал о GCD и попробовал его, но не получил ожидаемых результатов. (На самом деле я все еще не понимаю, как правильно его использовать)

Первый основной Func movePiece ()

Вот мой код, все в одном классе:

func movePiece() {
    // some Func Calls here.
    if ( self.movesRemaining > 0) {
        DispatchQueue.global(qos: .userInteractive).async {
            self.moveFinished = false

            let currentSpace:Int = self.returnPlayerSpace(player: self.whosTurn)
            let spaceNumber:Int = currentSpace
            var nextSpace:Int = spaceNumber + 1

            let moveAction:SKAction = SKAction.move(to: (self.childNode(withName: String(nextSpace))?.position)!, duration: 0.4)
            moveAction.timingMode = .easeOut

            let wait:SKAction = SKAction.wait(forDuration: 0.2)

            let runAction:SKAction = SKAction.run({
                if (self.movesRemaining == 1) {
                    self.KillHim(player:self.whosTurn, nextspace:nextSpace)
                  DispatchQueue.main.async {
                    self.moveBackPiece()
                  }
                }

                self.setThePlayerSpace(space: nextSpace, player:self.whosTurn)

                if (self.movesRemaining == 1) {
                    self.Adjust(node: self.childNode(withName: String(nextSpace))!)
                }

                self.movesRemaining = self.movesRemaining - 1
                self.movePiece()
            })

            if self.whosTurn == .Player1 {
                self.touchedNode.run(SKAction.sequence([moveAction, wait, runAction]))
            } else {
                self.playerPiece.run(SKAction.sequence( [moveAction, wait, runAction]))
            }
        }
    }
}

Вот второй func moveBackPiece ():

func moveBackPiece() {
    if ((killedPiece == self.Player1Piece1 || killedPiece == self.Player1Piece2 || killedPiece == self.Player1Piece3 || killedPiece == self.Player1Piece4) && self.movesRemainingBack != 1) || ((killedPiece == self.Player2Piece1 || killedPiece == self.Player2Piece2 || killedPiece == self.Player2Piece3 || killedPiece == self.Player2Piece4) && self.movesRemainingBack != 5) || ((killedPiece == self.Player3Piece1 || killedPiece == self.Player3Piece2 || killedPiece == self.Player3Piece3 || killedPiece == self.Player3Piece4) && self.movesRemainingBack != 9) || ((killedPiece == self.Player4Piece1 || killedPiece == self.Player4Piece2 || killedPiece == self.Player4Piece3 || killedPiece == self.Player4Piece4) && self.movesRemainingBack != 13) {
        self.movesRemainingBack -= 1

        let moveAction:SKAction = SKAction.move(to: (self.childNode(withName: String(self.movesRemainingBack))?.position)!, duration: 0.4)
        moveAction.timingMode = .easeOut

        let runAction:SKAction = SKAction.run({
            if ((self.killedPiece == self.Player1Piece1 || self.killedPiece == self.Player1Piece2 || self.killedPiece == self.Player1Piece3 || self.killedPiece == self.Player1Piece4) && self.movesRemainingBack == 1) || ((self.killedPiece == self.Player2Piece1 || self.killedPiece == self.Player2Piece2 || self.killedPiece == self.Player2Piece3 || self.killedPiece == self.Player2Piece4) && self.movesRemainingBack == 5) || ((self.killedPiece == self.Player3Piece1 || self.killedPiece == self.Player3Piece2 || self.killedPiece == self.Player3Piece3 || self.killedPiece == self.Player3Piece4) && self.movesRemainingBack == 9) || ((self.killedPiece == self.Player4Piece1 || self.killedPiece == self.Player4Piece2 || self.killedPiece == self.Player4Piece3 || self.killedPiece == self.Player4Piece4) && self.movesRemainingBack == 13) {
                self.setThePlayerSpaceBack(space: self.movesRemainingBack, Killed: self.killedPiece)
            }

            self.movesRemaining = self.movesRemaining - 1
            self.moveBackPiece()
        })

        self.killedPiece.run(SKAction.sequence([moveAction, runAction]))
    }
}

как я могу решить это с помощью GCD или что-то еще? Спасибо за ваше время.

Answer 1

Вы должны использовать очереди групп GCD.Он также будет работать с асинхронными операциями.Это как Go In -> Go Out, Go In -> Go Out, в конце он уведомит вас, вот пример

    let queue = DispatchQueue(label: "com.your.text", attributes: .concurrent)
let group = DispatchGroup()

group.enter()
queue.async {
    print("1st Operation")
    Thread.sleep(forTimeInterval: 10)
    print("1st Operatio finished")
    group.leave()
}

group.enter()
queue.async {
    print("2nd Operation")
    Thread.sleep(forTimeInterval: 10)
    print("2nd Operation finished")
    group.leave()
}

group.notify(queue: .main) {
        print("Finished")
    }

Это быстро написано здесь, поэтому может возникнуть синтаксическая ошибка.Я надеюсь, что это поможет вам в вашей проблеме.