依次更改SKAction.wait（forDuration：）

Question

I have this. It runs, but now I have to change the forDuration: 10 in maybe 5 . In the action sequence are 4 sprites that move their path for a given time. Once I run the sequence I can not change the forDuration: 10

Is the anybody out there, who can help me?

let s1_1 = SKAction.run{let unit = S1(); unit.gegnerSpeed = 100; unit.moveAlongPath(self.pfadGegner);self.addChild(unit)}
let s1_2 = SKAction.run{let unit = S1(); unit.gegnerSpeed = 80; unit.moveAlongPath(self.pfadGegner);self.addChild(unit)}


let action1 = SKAction.sequence([
                s1_1, SKAction.wait(forDuration: 10),
                s1_2, SKAction.wait(forDuration: 10),
                s1_1, SKAction.wait(forDuration: 10),
                s1_2, SKAction.wait(forDuration: 10)    ])
            let sequenz = SKAction.sequence([action1, SKAction.run {
                self.letzterGegnerLos = true
                }])
            run(SKAction.repeat(sequenz, count: 1))

Thanks a lot.

Answer 1

I am not sure why you are running actions on your scene to run actions, you should have your actions on specific nodes instead. But that said, once you assign a sequence, you can't change the actions inside of it as far as I am aware. This means you have to remove the sequence, and assign a new sequence with a new wait duration.

Or do you?

In a case like yours, it is possible to manipulate the speed property of either the action, or the node. To manipulate the speed of the action, you need to extract the action using node.action(forKey:"key") . The only problem with this, is that you manipulate the speed on all the actions inside the sequence.

Instead, let's change the speed of the node.

To do this, I recommend using a variable to assign the speed:

let dSpeed = 1
let action1 = SKAction.sequence([

            s1_1,
            SKAction.run{[unowned self] in self.speed = dSpeed}, 
            SKAction.wait(forDuration: 10),
            SKAction.run{[unowned self] in self.speed = 1}, 
            s1_2,
            SKAction.run{[unowned self] in self.speed = dSpeed}, 
            SKAction.wait(forDuration: 10),
            SKAction.run{[unowned self] in self.speed = 1},
            s1_1, 
            SKAction.run{[unowned self] in self.speed = dSpeed},
            SKAction.wait(forDuration: 10),
            SKAction.run{[unowned self] in self.speed = 1},
            s1_2, 
            SKAction.run{[unowned self] in self.speed = dSpeed},
            SKAction.wait(forDuration: 10),
            SKAction.run{[unowned self] in self.speed = 1}    ])
        let sequenz = SKAction.sequence([action1, SKAction.run {
            self.letzterGegnerLos = true
            }])
        run(SKAction.repeat(sequenz, count: 1))

Of course, now we have a problem with the scene running fast. This is why I am questioning why you are running things on your scene.

From the looks of your code, you need a spawning node to spawn units. Let's create that.

lazy var spawnNode = {
                         [unowned self] in
                         let node = SKNode()
                         self.addChild(node)
                         return node
                     }()

As soon as you access spawnNode , it will create it and add it to the scene for you.

Next, we set up your spawning functionality.

func spawn(_ speed:int)
{
    let unit = S1()
    unit.gegnerSpeed = speed
    unit.moveAlongPath(self.pfadGegner)
    self.addChild(unit)
}

Finally, let's set up your action

let s1_1 = SKAction.run{spawn(100)}
let s1_2 = SKAction.run{spawn(80)}
let dSpeed = 1
let action1 = SKAction.sequence([

            s1_1,
            SKAction.run{spawnNode.speed = dSpeed}, 
            SKAction.wait(forDuration: 10),
            SKAction.run{spawnNode.speed = 1}, 
            s1_2,
            SKAction.run{spawnNode.speed = dSpeed}, 
            SKAction.wait(forDuration: 10),
            SKAction.run{spawnNode.speed = 1},
            s1_1, 
            SKAction.run{spawnNode.speed = dSpeed},
            SKAction.wait(forDuration: 10),
            SKAction.run{spawnNode.speed = 1},
            s1_2, 
            SKAction.run{spawnNode.speed = dSpeed},
            SKAction.wait(forDuration: 10),
            SKAction.run{spawnNode.speed = 1}    ])
        let sequenz = SKAction.sequence([action1, SKAction.run {
            self.letzterGegnerLos = true
            }])
        run(SKAction.repeat(sequenz, count: 1))

Now, if we want the node to spawn twice as fast, we do dSpeed = 2 . If we want the node to spawn twice as slow, we do dSpeed = 0.5 . By doing this in this fashion, we are not manipulating the speed of the scene in any way.

Just a note, the reason I did the speed changes before and after a run block instead of at the beginning and end of the sequence is in case you needed to do any animations. The way the code is set up now, run blocks fire immediately, so you can get away with setting dSpeed in the beginning, and 1 at the end. But if for some reason, you place a move action right after you spawn a node, that move action will use the speed of spawn node. So if you are only going to do run blocks, then this is acceptable.

let action1 = SKAction.sequence([
        SKAction.run{spawnNode.speed = dSpeed}, 
        s1_1,     
        SKAction.wait(forDuration: 10),
        s1_2,
        SKAction.wait(forDuration: 10),
        s1_1, 
        SKAction.wait(forDuration: 10),
        s1_2, 
        SKAction.wait(forDuration: 10),
        SKAction.run{spawnNode.speed = 1}    ])
    let sequenz = SKAction.sequence([action1, SKAction.run {
        self.letzterGegnerLos = true
        }])
    run(SKAction.repeat(sequenz, count: 1))