swift - 嵌套 "for"循环中并发 SKAction 序列的完成 block ？

Question

我正在尝试在“for”循环中运行一组 SKAction，如下面的代码所示。该序列应该像这样运行:

对于第一个 super 节点...

1. 同时在所有子子节点上运行 openingAction ；完成后...
2. 同时在所有子 Sprite 节点上运行variableDurationActions；完成后...
3. 同时对所有子子节点运行 openingAction...

对于第二个 super 节点...

同时在所有子子节点上运行 openingAction ；完成后...

每个 super 节点都会重复这个三步过程。

第一个问题是，虽然我可以编写一个闭包来等待一个操作完成后再开始另一个操作，但我不知道如何针对“for”循环中的多个并发操作执行此操作。此问题发生在步骤 1 和步骤 2 之间以及步骤 2 和步骤 3 之间。在步骤 2 和步骤 3 之间，情况更糟，因为步骤 2 中的操作的持续时间可能相差很大。

第二个问题是我不知道如何编写完成处理程序或等效的处理程序，以使 openingAction 和 openingAction 的下一次迭代同时运行，但在下一次迭代中的variableDurationActions 之前运行。

我想要用 SpriteKit 的工具做的事情是否可行？或者我应该使用调度组？我正在寻找优雅的解决方案，因为我的代码已经足够复杂了。

for superNode in scene.children {

    for subNode in superNode.children {

        // All openingActions should run first
        subNode.run(openingAction)

            for spriteNode in subNode.children {

                // These variableDurationActions should run concurrently, second
                spriteNode.run(variableDurationAction)
            }

        // All closingActions should run third AND
        // concurrently with the openingActions in the next iteration
        subNode.run(closingAction)
    }
}

Answer 1

我最终想出了一个解决方案，通过分离时间上不同的处理步骤，创建一个具有两个检查点的调度组，并让主函数(在底部，下面)通过调用自身来迭代 super 节点。

对我来说似乎有点笨拙，但它看起来是这样的:

let dispatchGroup = DispatchGroup()

// Step 1
func runOpeningActions() {
    for subNode in superNode.children {
        dispatchGroup.enter()
        // All openingActions should run concurrently, first
        subNode.run(openingAction) { 
            dispatchGroup.leave() 
        }
    }
}

// Step 2
func runVariableDurationActions {
    for subNode in superNode.children {
        dispatchGroup.enter()
        for spriteNode in subNode.children {
            // These variableDurationActions should run concurrently, second
            spriteNode.run(variableDurationAction) {
                dispatchGroup.leave()
            }
        }
    }
}

// Step 3 – to run concurrently with the next Step 1
func runClosingActions() {
    for subNode in superNode.children {
        dispatchGroup.enter()
        // All closingActions should run concurrently, third AND
        // concurrently with the openingActions in the next iteration
        subNode.run(closingAction) { 
            dispatchGroup.leave() 
        }
    }
}

var nodeIndex = 0

// Main function – iterates over Steps 1, 2, and 3
func runAllActions() {
    let superNode = scene.children[nodeIndex]
    runOpeningActions()
    dispatchGroup.notify(queue: .main) {
        runVariableDurationActions()
        dispatchGroup.notify(queue: .main) {
            runClosingActions()
            nodeIndex += 1
            if nodeIndex < scene.children.count {
                runAnimation()
            } else {
                // No more superNodes to process; leave the function
            }
        }
    }
}

// Main function call
runAllActions()