how to wait Recursion until the function finish executing - swift

Question

I have one Recursion func that executes the actions and on it's last cycle it checks for a condition, and if the condition is true it calls another similar function that Also runs actions. But while second func is executing actions through recursion the first func starts executing. So have two actions now running simultaneously. I Read about GCD and tried it but didn't get results as expected.(Actually I still don't understand how to use it properly)
First main Func movePiece()
Here's my code it's all in the same class :
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]))
}
}
}
}
Here is second 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]))
}
}
how can I solve it with GCD Or something else?
Thanks for your Time.

Answer 1

You have to use GCD group queues. It will work with async operations also. It's like Go In -> Go Out, Go In ->Go Out, At the end it will notify you , Here is the example
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")
}
It's quickly written here, so might be syntax error will come. I hope it helps you out on your issue.