SpriteKit：多SKNode执行多SKAction序列的代码优化问询

Hey there! Great question—dealing with multi-node SKAction sequences can quickly turn into nested callback hell if you don’t structure things right, so let’s fix that while clarifying exactly how SKAction.sequence(_:) works.

First: Understanding SKAction.sequence(_:) Behavior #

Let’s start with the basics to make sure we’re on the same page:

• A sequence executes one action at a time, in the order you pass them. The next action doesn’t start until the previous one finishes completely.
• Critically, sequences are tied to a single SKNode. When you call node.run(SKAction.sequence(...)), that sequence only affects that specific node—other nodes won’t inherit or wait for it unless you explicitly code that logic.
• Completion closures on a sequence run only after the entire sequence finishes (not after individual actions in the sequence).

Refactoring for Clean, Maintainable Multi-Node Logic #

The key to avoiding boilerplate is to extract reusable action logic and encapsulate the flow of executing sequences across nodes. Here are two practical approaches depending on your needs:

1. Reusable Action Helpers + Batch/Sequential Execution #

First, extract common action sequences into reusable functions so you don’t repeat code for each node:

// Example: Reusable sequence for moving and fading out
func moveAndFade(dx: CGFloat, moveDuration: TimeInterval) -> SKAction {
    return SKAction.sequence([
        SKAction.moveBy(x: dx, y: 0, duration: moveDuration),
        SKAction.fadeOut(withDuration: 0.5)
    ])
}

// Another example: Custom sequence for scaling and rotating
func scaleAndRotate(scaleFactor: CGFloat, rotateAngle: CGFloat) -> SKAction {
    return SKAction.sequence([
        SKAction.scale(to: scaleFactor, duration: 0.7),
        SKAction.rotate(byAngle: rotateAngle, duration: 1.0)
    ])
}

Option A: Parallel Execution (All Nodes Run Sequences At Once)

If you want all nodes to execute their sequences simultaneously, use a DispatchGroup to track when all are done:

let nodesToAnimate = [node1, node2, node3, node4]
let animationGroup = DispatchGroup()

nodesToAnimate.forEach { node in
    animationGroup.enter()
    
    // Assign a sequence to the node (customize logic per node as needed)
    let action: SKAction
    if node == node1 {
        action = moveAndFade(dx: 100, moveDuration: 1.0)
    } else if node == node2 {
        action = scaleAndRotate(scaleFactor: 2.0, rotateAngle: .pi)
    } else {
        action = moveAndFade(dx: -100, moveDuration: 1.0)
    }
    
    node.run(action) {
        animationGroup.leave()
    }
}

// Trigger code once all animations finish
animationGroup.notify(queue: .main) {
    print("All nodes completed their animations!")
}

Option B: Sequential Execution (One Node Finishes Before Next Starts)

If you need nodes to animate one after another, use a recursive helper function to avoid nested callbacks:

func runSequentialAnimations(on nodes: [(SKNode, SKAction)], currentIndex: Int = 0) {
    guard currentIndex < nodes.count else {
        print("All sequential animations done!")
        return
    }
    
    let (node, action) = nodes[currentIndex]
    node.run(action) {
        // Recurse to the next node after this one finishes
        runSequentialAnimations(on: nodes, currentIndex: currentIndex + 1)
    }
}

// Usage: Define your node-action pairs in an array
let sequentialAnimations = [
    (node1, moveAndFade(dx: 100, moveDuration: 1.0)),
    (node2, scaleAndRotate(scaleFactor: 2.0, rotateAngle: .pi)),
    (node3, moveAndFade(dx: -100, moveDuration: 1.0)),
    (node4, SKAction.sequence([SKAction.fadeIn(withDuration: 0.5), SKAction.moveTo(y: 50, duration: 0.8)]))
]

runSequentialAnimations(on: sequentialAnimations)

2. Bonus: Create an Animation Coordinator Class #

For even better maintainability (especially if you have complex animation logic), wrap everything in a coordinator class:

class SpriteAnimationCoordinator {
    static func runParallelAnimations(on nodeActionPairs: [(SKNode, SKAction)], completion: @escaping () -> Void) {
        let group = DispatchGroup()
        nodeActionPairs.forEach { node, action in
            group.enter()
            node.run(action) { group.leave() }
        }
        group.notify(queue: .main, execute: completion)
    }
    
    static func runSequentialAnimations(on nodeActionPairs: [(SKNode, SKAction)], completion: @escaping () -> Void) {
        guard !nodeActionPairs.isEmpty else {
            completion()
            return
        }
        
        let (firstNode, firstAction) = nodeActionPairs[0]
        let remainingPairs = Array(nodeActionPairs.dropFirst())
        
        firstNode.run(firstAction) {
            runSequentialAnimations(on: remainingPairs, completion: completion)
        }
    }
    
    // Add more helper methods for common sequences here!
    static func basicMoveFade(dx: CGFloat) -> SKAction {
        return SKAction.sequence([
            SKAction.moveBy(x: dx, y: 0, duration: 1.0),
            SKAction.fadeOut(withDuration: 0.5)
        ])
    }
}

// Usage in your scene:
let animations = [
    (node1, SpriteAnimationCoordinator.basicMoveFade(dx: 100)),
    (node2, SpriteAnimationCoordinator.basicMoveFade(dx: -100)),
    (node3, SKAction.scale(to: 0.5, duration: 0.8))
]

SpriteAnimationCoordinator.runSequentialAnimations(on: animations) {
    print("All coordinated animations finished!")
}

Why This Works #

• No Boilerplate: Adding a new node only requires adding one line to your array of node-action pairs—no more nested run() calls.
• Clear Business Logic: Your scene code focuses on what animations to run, not how to manage the sequence flow.
• Flexibility: You can easily swap out actions per node or change between parallel/sequential execution without rewriting core logic.

内容的提问来源于stack exchange，提问作者michael-martinez