ios Swift - 使用同步动画对分离的 Sprite 进行分组

Question

我正在尝试制作一个同步动画(一个大视频由分离的和较小的拼图拼图部分上的帧分解)。这个游戏是一个视频拼图。这是我通过示例分三部分使用的代码:

func Anim_Puzzle13 (Node13 : SKPuzzle) {

    let puzzle13 = SKAction.animateWithTextures(sheet_puzzle13.Puzzle13_(), timePerFrame: 0.066)
    NPuzzle13 = Node13
    NPuzzle13.runAction(SKAction.repeatActionForever(puzzle13))
    NPuzzle13.position = CGPoint(x: 500, y: 400)
    NPuzzle13.zPosition = 1

}

func Anim_Puzzle19 (Node19 : SKPuzzle) {


    let puzzle19 = SKAction.animateWithTextures(sheet_puzzle19.Puzzle19_(), timePerFrame: 0.066)
    NPuzzle19 = Node19
    NPuzzle19.runAction(SKAction.repeatActionForever(puzzle19))
    NPuzzle19.position = CGPoint(x: 600, y: 500)
    NPuzzle19.zPosition = 1

}

func Anim_Puzzle30 (Node30 : SKPuzzle) {


    let puzzle30 = SKAction.animateWithTextures(sheet_puzzle30.Puzzle30_(), timePerFrame: 0.066)
    NPuzzle30 = Node30
    NPuzzle30.runAction(SKAction.repeatActionForever(puzzle30))
    NPuzzle30.position = CGPoint(x: 700, y: 600)
    NPuzzle30.zPosition = 1

}

效果很好，但动画之间不同步，视频不完整。我搜索了很长时间来寻找使动画同步的解决方案；我看到两种可能性:第一种是创建一个独特的 SKNode() ，其中包含所有拼图部分，但我希望能够独立移动每个拼图部分，但没有成功获得同步动画这种方法。

另一种方法似乎是创建一个包含所有动画的组，但这不起作用，并且会导致应用程序停止。

这是我使用的所有代码:

import SpriteKit
import UIKit
import AVFoundation
import AVKit
import CoreFoundation

private let kpuzzleNodeName = "puzzle"
private let kdancing = "dancing"


class SKPuzzle: SKSpriteNode {
var name2:String = "";
}

class GameScene: SKScene {



var background = SKVideoNode(videoFileNamed: "Video_Socle.mov")
var selectedNode = SKPuzzle()
var player:AVPlayer?
var videoNode:SKVideoNode?

var NPuzzle13 = SKPuzzle()
var NPuzzle19 = SKPuzzle()
var NPuzzle30 = SKPuzzle()
var NPuzzle11 = SKPuzzle()
var NPuzzle29 = SKPuzzle()
var NPuzzle35 = SKPuzzle()
var puzzle13 = SKAction()
var puzzle19 = SKAction()
var puzzle30 = SKAction()
var puzzle11 = SKAction()
var puzzle29 = SKAction()
var puzzle35 = SKAction()

let sheet_puzzle13 = Puzzle13()
let sheet_puzzle19 = Puzzle19()
let sheet_puzzle30 = Puzzle30()
let sheet_puzzle11 = Puzzle11()
let sheet_puzzle29 = Puzzle29()
let sheet_puzzle35 = Puzzle35()



override init(size: CGSize) {
    super.init(size: size)



    // 1
    self.background.name = kdancing
    self.background.anchorPoint = CGPointZero
    background.zPosition = 0
    self.addChild(background)


    // 2
    let sheet = Statiques()

    let sprite_dancing1 = SKSpriteNode(texture: sheet.Dancing1())
    let sprite_dancing2 = SKSpriteNode(texture: sheet.Dancing2())
    sprite_dancing1.name = kdancing
    sprite_dancing2.name = kdancing


    sprite_dancing1.position = CGPoint(x: 837, y: 752)
    sprite_dancing1.zPosition = 2
    sprite_dancing2.position = CGPoint(x: 1241, y: 752)
    sprite_dancing2.zPosition = 2

    background.addChild(sprite_dancing1)

    background.addChild(sprite_dancing2)



    let imageNames = [sheet.Puzzle13() , sheet.Puzzle19(), sheet.Puzzle30(), sheet.Puzzle11(), sheet.Puzzle29(), sheet.Puzzle35() ]

    for i in 0..<imageNames.count {
        let imageName = imageNames[i]

        let sprite = SKPuzzle(texture: imageName)

        sprite.name = kpuzzleNodeName
        sprite.name2 = "\(i)"

        let offsetFraction = (CGFloat(i) + 1.0)/(CGFloat(imageNames.count) + 1.0)

        sprite.position = CGPoint(x: size.width * offsetFraction, y: size.height / 2)
        sprite.zPosition = 3

        background.addChild(sprite)

    }



}

required init?(coder aDecoder: NSCoder) {
    fatalError("init(coder:) has not been implemented")
}

override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
    for touch: AnyObject in touches {
        let positionInScene = touch.locationInNode(self)
        selectNodeForTouch(positionInScene)
    }
}

override func didMoveToView(view: SKView) {

    let urlStr = NSBundle.mainBundle().pathForResource("Video_Socle", ofType: "mov")
    let url = NSURL(fileURLWithPath: urlStr!)

    player = AVPlayer(URL: url)
    NSNotificationCenter.defaultCenter().addObserverForName(AVPlayerItemDidPlayToEndTimeNotification, object: player!.currentItem, queue: nil)
    { notification in
        let t1 = CMTimeMake(5, 100);
        self.player!.seekToTime(t1)
        self.player!.play()
    }


    videoNode = SKVideoNode(AVPlayer: player!)
    videoNode!.position = CGPointMake(frame.size.width/2, frame.size.height/2)
    videoNode!.size = CGSize(width: 2048, height: 1536)
    videoNode!.zPosition = 0


    background.addChild(videoNode!)
    videoNode!.play()


    let gestureRecognizer = UIPanGestureRecognizer(target: self, action: #selector(GameScene.handlePanFrom(_:)))
    self.view!.addGestureRecognizer(gestureRecognizer)
}


func handlePanFrom(recognizer : UIPanGestureRecognizer) {
    if recognizer.state == .Began {
        var touchLocation = recognizer.locationInView(recognizer.view)
        touchLocation = self.convertPointFromView(touchLocation)

        self.selectNodeForTouch(touchLocation)
    } else if recognizer.state == .Changed {
        var translation = recognizer.translationInView(recognizer.view!)
        translation = CGPoint(x: translation.x, y: -translation.y)

        self.panForTranslation(translation)

        recognizer.setTranslation(CGPointZero, inView: recognizer.view)
    } else if recognizer.state == .Ended {

    }
}

func degToRad(degree: Double) -> CGFloat {
    return CGFloat(degree / 180.0 * M_PI)
}

func selectNodeForTouch(touchLocation : CGPoint) {
    // 1
    let touchedNode = self.nodeAtPoint(touchLocation)

    if touchedNode is SKPuzzle {
        // 2
        if !selectedNode.isEqual(touchedNode) {
            selectedNode.runAction(SKAction.rotateToAngle(0.0, duration: 0.1))

            selectedNode = touchedNode as! SKPuzzle

            // 3
            if touchedNode.name! == kpuzzleNodeName {
                let sequence = SKAction.sequence([SKAction.rotateByAngle(degToRad(-4.0), duration: 0.1),
                    SKAction.rotateByAngle(0.0, duration: 0.1),
                    SKAction.rotateByAngle(degToRad(4.0), duration: 0.1)])
                selectedNode.runAction(SKAction.repeatActionForever(sequence))
            }
        }
    }
}



func panForTranslation(translation : CGPoint) {
    let position = selectedNode.position

    if selectedNode.name! == kpuzzleNodeName {
        selectedNode.position = CGPoint(x: position.x + translation.x * 2, y: position.y + translation.y * 2)

        print (selectedNode.name)
        print (selectedNode.name2)
        if selectedNode.name2 == "0" {

            Anim_Puzzle13(selectedNode)
        }

        print (selectedNode.name2)
        if selectedNode.name2 == "1" {
            Anim_Puzzle19(selectedNode)
        }

        print (selectedNode.name2)
        if selectedNode.name2 == "2" {
            Anim_Puzzle30(selectedNode)
        }

        print (selectedNode.name2)
        if selectedNode.name2 == "3" {
            Anim_Puzzle11(selectedNode)
        }

        print (selectedNode.name2)
        if selectedNode.name2 == "4" {
            Anim_Puzzle29(selectedNode)
        }

        print (selectedNode.name2)
        if selectedNode.name2 == "5" {
            Anim_Puzzle35(selectedNode)
        }

    }

}


func Anim_Puzzle13 (Node13 : SKPuzzle) {

    let puzzle13 = SKAction.animateWithTextures(sheet_puzzle13.Puzzle13_(), timePerFrame: 0.066)
    NPuzzle13 = Node13
    NPuzzle13.runAction(SKAction.repeatActionForever(puzzle13))
    NPuzzle13.position = CGPoint(x: 500, y: 400)
    NPuzzle13.zPosition = 1

}

func Anim_Puzzle19 (Node19 : SKPuzzle) {


    let puzzle19 = SKAction.animateWithTextures(sheet_puzzle19.Puzzle19_(), timePerFrame: 0.066)
    NPuzzle19 = Node19
    NPuzzle19.runAction(SKAction.repeatActionForever(puzzle19))
    NPuzzle19.position = CGPoint(x: 600, y: 500)
    NPuzzle19.zPosition = 1

}

func Anim_Puzzle30 (Node30 : SKPuzzle) {


    let puzzle30 = SKAction.animateWithTextures(sheet_puzzle30.Puzzle30_(), timePerFrame: 0.066)
    NPuzzle30 = Node30
    NPuzzle30.runAction(SKAction.repeatActionForever(puzzle30))
    NPuzzle30.position = CGPoint(x: 700, y: 600)
    NPuzzle30.zPosition = 1

}

func Anim_Puzzle11 (Node11 : SKPuzzle) {


    let puzzle11 = SKAction.animateWithTextures(sheet_puzzle11.Puzzle11_(), timePerFrame: 0.066)
    NPuzzle11 = Node11
    NPuzzle11.runAction(SKAction.repeatActionForever(puzzle11))
    NPuzzle11.position = CGPoint(x: 800, y: 700)
    NPuzzle11.zPosition = 1

}

func Anim_Puzzle29 (Node29 : SKPuzzle) {


    let puzzle29 = SKAction.animateWithTextures(sheet_puzzle29.Puzzle29_(), timePerFrame: 0.066)
    NPuzzle29 = Node29
    NPuzzle29.runAction(SKAction.repeatActionForever(puzzle29))
    NPuzzle29.position = CGPoint(x: 900, y: 800)
    NPuzzle29.zPosition = 1

}

func Anim_Puzzle35 (Node35 : SKPuzzle) {


    let puzzle35 = SKAction.animateWithTextures(sheet_puzzle35.Puzzle35_(), timePerFrame: 0.066)
    NPuzzle35 = Node35
    NPuzzle35.runAction(SKAction.repeatActionForever(puzzle35))
    NPuzzle35.position = CGPoint(x: 1000, y: 900)
    NPuzzle35.zPosition = 1

}

我不确定是否可以像这样同步动画:在几个单独的部分使用 SKAction()，因为必须能够单独选择它们。

更新:我尝试按照 Action 组的方式进行操作，但我在每个 Sprite 上播放相同的动画，而不是为每个 Sprite 同步不同的动画(同步了 6 个不同的动画:6 个不同的 Sprite ):

    let sheet13 = Puzzle13()
    let sheet19 = Puzzle19()
    let sheet30 = Puzzle30()
    let sheet11 = Puzzle11()
    let sheet29 = Puzzle29()
    let sheet35 = Puzzle35()

    let imageAnims = [sheet13.Puzzle13_0000() , sheet19.Puzzle19_0000(), sheet30.Puzzle30_0000(), sheet11.Puzzle11_0000(), sheet29.Puzzle29_0000(), sheet35.Puzzle35_0000() ]

    let puzzle13 = SKAction.animateWithTextures(sheet13.Puzzle13_(), timePerFrame: 0.066)
    let puzzle19 = SKAction.animateWithTextures(sheet19.Puzzle19_(), timePerFrame: 0.066)
    let puzzle30 = SKAction.animateWithTextures(sheet30.Puzzle30_(), timePerFrame: 0.066)
    let puzzle11 = SKAction.animateWithTextures(sheet11.Puzzle11_(), timePerFrame: 0.066)
    let puzzle29 = SKAction.animateWithTextures(sheet29.Puzzle29_(), timePerFrame: 0.066)
    let puzzle35 = SKAction.animateWithTextures(sheet35.Puzzle35_(), timePerFrame: 0.066)

    let group = SKAction.group([puzzle13,puzzle19,puzzle30,puzzle11,puzzle29,puzzle35])

    for i in 0..<imageAnims.count {
        let imageAnim = imageAnims[i]

        let spriteAnim = SKPuzzle(texture: imageAnim)

        spriteAnim.name = kanimNodeName
        spriteAnim.name2 = "\(i)"

        let offsetFraction = (CGFloat(i) + 1.0)/(CGFloat(imageAnims.count) + 1.0)

        spriteAnim.position = CGPoint(x: ((size.width)*2) * offsetFraction, y: size.height * 1.5)
        spriteAnim.zPosition = 3

        spriteAnim.runAction(SKAction.repeatActionForever(group))


        background.addChild(spriteAnim)

    }

Answer 1

首先，我想列出两种不同的方法来创建您的 SKAction:

从使用 SKAction.group 的并行操作开始:

let sprite = SKSpriteNode(imageNamed:"Spaceship")
let scale = SKAction.scaleTo(0.1, duration: 0.5)
let fade = SKAction.fadeOutWithDuration(0.5)
let group = SKAction.group([scale, fade])
sprite.runAction(group)

另一个有用的方法是 completion ，所以你可以知道 SKAction 何时完成:

extension SKNode
{
    func runAction( action: SKAction!, withKey: String!, optionalCompletion: dispatch_block_t? )
    {
        if let completion = optionalCompletion
        {
            let completionAction = SKAction.runBlock( completion )
            let compositeAction = SKAction.sequence([ action, completionAction ])
            runAction( compositeAction, withKey: withKey )
        }
        else
        {
            runAction( action, withKey: withKey )
        }
    }
}

用法:

node.runAction(move,withKey:"swipeMove",optionalCompletion: {
   // here the action is finished, do whatever you want
})

之后，关于你的项目，我看到了很多node.runAction..，你也可以采用这种策略来同步你的 Action :

var myAction30 :SKAction!
var myAction31 :SKAction!

self.myAction30 = SKAction.repeatActionForever(puzzle30)
self.myAction31 = SKAction.repeatActionForever(puzzle31)
let group = SKAction.group([self.myAction30, self.myAction31])
self.runAction(group)

更新:我看过您的更新部分，当您谈到“同步”时，您可能不是指“并行运行”操作。

所以，如果你想一个接一个地运行一个 Action ，还有:

self.myAction30 = SKAction.repeatActionForever(puzzle30)
self.myAction31 = SKAction.repeatActionForever(puzzle31)
let sequence = SKAction.sequence([self.myAction30, self.myAction31])
self.runAction(sequence)