ios - स्प्राइटकिट-एसकेकेमेरेनोड लंबक प्रभाव?



swift sprite-kit (2)

मैं SKCameraNode के साथ प्रयोग कर रहा हूँ, लेकिन मैं इसके साथ एक लंबन प्रभाव बनाने के बारे में कुछ भी नहीं मिल सकता है

मान लें कि मैं ऊपर कोड को जोड़ता हूं और मैं अपने baseNode behindNode नीचे एक behindNode हूं। फिर मैं अपने कैमरे को चेतन करता हूँ

let behindNode = SKNode()
addChild(behindNode)

let blueSquare = SKSpriteNode(color: SKColor.blueColor(), size: CGSize(width: 80, height: 80))
blueSquare.position = CGPoint(x: size.width/2+40, y: size.height/2+40)
behindNode.addChild(blueSquare)

let baseNode = SKNode()
addChild(baseNode)

let redSquare = SKSpriteNode(color: SKColor.redColor(), size: CGSize(width: 80, height: 80))
redSquare.position = CGPoint(x: size.width/2, y: size.height/2)
baseNode.addChild(redSquare)


let cameraNode = SKCameraNode()
camera = cameraNode
addChild(camera!)
camera!.position = redSquare.position

cameraNode.runAction(SKAction.sequence([
    SKAction.waitForDuration(1),
    SKAction.moveBy(CGVector(dx: 100, dy: 100), duration: 3),
    SKAction.moveBy(CGVector(dx: -100, dy: 100), duration: 1),
    SKAction.moveBy(CGVector(dx: 100, dy: -100), duration: 1)
]))

कैमरे के चलते लाल स्क्वायर के सापेक्ष धीमे दर पर जाने के लिए मुझे नीले वर्ग की जरूरत है .. मैं उम्मीद करता हूं कि कैमरेनोड को एक रिश्तेदार पदों के शब्दकोश या कुछ और करना है, लेकिन यह नहीं है ..

https://ffff65535.com


मैं अपने आईओएस 9 स्प्राइटकिट गेम में एक लंबन प्रभाव का उपयोग कर रहा हूं।

असल में आप अपने दृश्य update() फ़ंक्शन के कुछ लाइनों को जोड़ सकते हैं जो चौराहों को कैमरे की विपरीत दिशा में स्थानांतरित करता है, लेकिन कुछ स्केल कारक के साथ।

update(){
  let moveXFactor: CGFloat = 3
  let moveYFactor: CGFloat = 2
  camera.position = CGPoint( camera.position.x + moveXFactor, camera.position.y + moveYFactor )

  let redSquareParallaxSpeedFactor: CGFloat = -0.2
  let blueSquareParallaxSpeedFactor: CGFloat = -0.1
  redSquare.position = CGPoint( redSquare.position.x + redSquareParallaxSpeedFactor * moveXFactor, redSquare.position.y + redSquareParallaxSpeedFactor * moveYFactor )
  blueSquare.position = CGPoint( blueSquare.position.x + blueSquareParallaxSpeedFactor * moveXFactor, blueSquare.position.y + blueSquareParallaxSpeedFactor * moveYFactor )
}

यह एक सरल उदाहरण है एक वेरिएबल का उपयोग करें जो घड़ी के साथ एफपीएस ट्रैक करता है और एक निरंतर टाइल्स-सील पर आधारित ऑब्जेक्ट को स्थानांतरित करता है, जो कि डिवाइस की वर्तमान एफपीएस पर आधारित तेजी से या धीमी गति से चल रहा है।

इसलिए, अपने दृश्य की क्लास फ़ाइल में कुछ चर को परिभाषित करें।

var lastUpdate: NSTimeInterval
var deltaTime: CGFloat

फिर उन्हें अपने दृश्य के वर्ग के init() फ़ंक्शन में प्रारंभ करें।

lastUpdate = 0
deltaTime = 0.01666

और अंत में, उन्हें अपने दृश्य के update() फ़ंक्शन में हर ताज़ा करें अपडेट करें

deltaTime = CGFloat( currentTime - lastUpdate )
lastUpdate = currentTime

if deltaTime > 1.0 {
  deltaTime = 0.0166
}

तो अब जब यह घड़ी काम करती है, तो इसे लंबवत प्रभाव को स्केल करने के लिए उपयोग करें, ताकि यह चिकना हो।

update(){
  deltaTime = CGFloat( currentTime - lastUpdate )
  lastUpdate = currentTime

  if deltaTime > 1.0 {
    deltaTime = 0.0166
  }

  let someScale: CGFloat = 0.001

  var moveXFactor: CGFloat = 3 * deltaTime * someScale
  var moveYFactor: CGFloat = 2 * deltaTime * someScale
  camera.position = CGPoint( camera.position.x + moveXFactor, camera.position.y + moveYFactor )

  let redSquareParallaxSpeedFactor: CGFloat = -0.2
  let blueSquareParallaxSpeedFactor: CGFloat = -0.1
  redSquare.position = CGPoint( redSquare.position.x + redSquareParallaxSpeedFactor * moveXFactor, redSquare.position.y + redSquareParallaxSpeedFactor * moveYFactor )
  blueSquare.position = CGPoint( blueSquare.position.x + blueSquareParallaxSpeedFactor * moveXFactor, blueSquare.position.y + blueSquareParallaxSpeedFactor * moveYFactor )
}

मैंने एक ऐसा समाधान बनाया जो सेकंड या फ्रेम के साथ सौदा नहीं करता

आप SKCameraNode के उपवर्ग बना सकते हैं और स्विफ्ट कीससेट () विधि का उपयोग कर सकते हैं जिसे क्लास चर के बाद कहा जाता है। हमारे मामले में हम कैमरे के नोड की स्थिति चर के बदलावों को सुनना चाहते हैं।

class CameraNodeParallax:SKCameraNode{

override var position : CGPoint {
    didSet {  
       // Move our backgrounds
    }
}

हम आगे एक सरणी बनाना चाहते हैं जिसमें हमारे लंबन पृष्ठभूमि नोड्स होते हैं और इनमें एक है जो कैमरे की चलती गति के संबंध में संबंधित चलती गति को शामिल करता है।

var backgroundNodes:[SKNode] = []
var backgroundNodesSpeedFactor:[CGVector] = [] // in relation to camera nodes speed

func addParallaxBackgroundNode(background:SKNode, vector:CGVector) {
    backgroundNodes.append(background)
    backgroundNodesSpeedFactor.append(vector)
}

एक init () जो हमारे नए चर को भरता है वह भी उपयोगी हो सकता है

init(position:CGPoint) {
  super.init()
  self.position = position
}

अब हम अपने didSet () श्रोता को भर सकते हैं:

// Move our backgrounds
var i = 0
for node in backgroundNodes {

    let positionChangeX = position.x-oldValue.x
    let positionChangeY = position.y-oldValue.y
    let changeX = positionChangeX*backgroundNodesSpeedFactor[i].dx
    let changeY = positionChangeY*backgroundNodesSpeedFactor[i].dy
    node.position = CGPointMake(node.position.x+changeX,node.position.y+changeY)

    i += 1
}

अंतिम कोड इस तरह दिखता है:

class CameraNodeParallax:SKCameraNode{

    var backgroundNodes:[SKNode] = []
    var backgroundNodesSpeedFactor:[CGVector] = [] // in relation to camera nodes speed

    init(position:CGPoint) {
        super.init()
        self.position = position
    }

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

    override var position : CGPoint {
        didSet {

            // Move your parallax backgrounds
                var i = 0
                for node in backgroundNodes {

                    let positionChangeX = position.x-oldValue.x
                    let positionChangeY = position.y-oldValue.y
                    let changeX = positionChangeX*backgroundNodesSpeedFactor[i].dx
                    let changeY = positionChangeY*backgroundNodesSpeedFactor[i].dy
                    node.position = CGPointMake(node.position.x+changeX,node.position.y+changeY)

                    i += 1
                }
        }
    }

    func addParallaxBackgroundNode(background:SKNode, vector:CGVector) {
        backgroundNodes.append(background)
        backgroundNodesSpeedFactor.append(vector)
    }
}

मैंने एक वैकल्पिक कार्यान्वयन बनाया जो कि यहां से SKCameraNode से प्राप्त नहीं हुआ है https://github.com/gitmalong/lovelySpriteKitHelpers/blob/master/ParallaxBackgroundMover.Swift





parallax