So erstellen Sie eine vertikale Scroll-Menü im spritekit?

Die zweite Antwort, wie versprochen, habe ich gerade herausgefunden, das Problem.

Empfehle ich immer die neueste version von diesem code aus meinem gitHub-Projekt sofern ich änderungen vorgenommen, da diese Antwort, der link dazu ist auf der Unterseite.

Schritt 1: Erstellen Sie ein neues swift-Datei und fügen Sie diesen code

import SpriteKit

///Scroll direction
enum ScrollDirection {
    case vertical //cases start with small letters as I am following Swift 3 guildlines.
    case horizontal
}

class CustomScrollView: UIScrollView {

//MARK: - Static Properties

///Touches allowed
static var disabledTouches = false

///Scroll view
private static var scrollView: UIScrollView!

//MARK: - Properties

///Current scene
private let currentScene: SKScene

///Moveable node
private let moveableNode: SKNode

///Scroll direction
private let scrollDirection: ScrollDirection

///Touched nodes
private var nodesTouched = [AnyObject]()

//MARK: - Init
init(frame: CGRect, scene: SKScene, moveableNode: SKNode) {
    self.currentScene = scene
    self.moveableNode = moveableNode
    self.scrollDirection = scrollDirection
    super.init(frame: frame)

    CustomScrollView.scrollView = self
    self.frame = frame
    delegate = self
    indicatorStyle = .White
    scrollEnabled = true
    userInteractionEnabled = true
    //canCancelContentTouches = false
    //self.minimumZoomScale = 1
    //self.maximumZoomScale = 3

    if scrollDirection == .horizontal {
        let flip = CGAffineTransformMakeScale(-1,-1)
        transform = flip
    }
}

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

//MARK: - Touches
extension CustomScrollView {

///Began
override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {

    for touch in touches {
        let location = touch.locationInNode(currentScene)

        guard !CustomScrollView.disabledTouches else { return }

        ///Call touches began in current scene
        currentScene.touchesBegan(touches, withEvent: event)

        ///Call touches began in all touched nodes in the current scene
        nodesTouched = currentScene.nodesAtPoint(location)
        for node in nodesTouched {
            node.touchesBegan(touches, withEvent: event)
        }
    }
}

///Moved
override func touchesMoved(touches: Set<UITouch>, withEvent event: UIEvent?) {

    for touch in touches {
        let location = touch.locationInNode(currentScene)

        guard !CustomScrollView.disabledTouches else { return }

        ///Call touches moved in current scene
        currentScene.touchesMoved(touches, withEvent: event)

        ///Call touches moved in all touched nodes in the current scene
        nodesTouched = currentScene.nodesAtPoint(location)
        for node in nodesTouched {
            node.touchesMoved(touches, withEvent: event)
        }
    }
}

///Ended
override func touchesEnded(touches: Set<UITouch>, withEvent event: UIEvent?) {

    for touch in touches {
        let location = touch.locationInNode(currentScene)

        guard !CustomScrollView.disabledTouches else { return }

        ///Call touches ended in current scene
        currentScene.touchesEnded(touches, withEvent: event)

        ///Call touches ended in all touched nodes in the current scene
        nodesTouched = currentScene.nodesAtPoint(location)
        for node in nodesTouched {
            node.touchesEnded(touches, withEvent: event)
        }
    }
}

///Cancelled
override func touchesCancelled(touches: Set<UITouch>?, withEvent event: UIEvent?) {

    for touch in touches! {
        let location = touch.locationInNode(currentScene)

        guard !CustomScrollView.disabledTouches else { return }

        ///Call touches cancelled in current scene
        currentScene.touchesCancelled(touches, withEvent: event)

        ///Call touches cancelled in all touched nodes in the current scene
        nodesTouched = currentScene.nodesAtPoint(location)
        for node in nodesTouched {
            node.touchesCancelled(touches, withEvent: event)
        }
     }
   }
}

//MARK: - Touch Controls
extension CustomScrollView {

     ///Disable
    class func disable() {
        CustomScrollView.scrollView?.userInteractionEnabled = false
        CustomScrollView.disabledTouches = true
    }

    ///Enable
    class func enable() {
        CustomScrollView.scrollView?.userInteractionEnabled = true
        CustomScrollView.disabledTouches = false
    }
}

//MARK: - Delegates
extension CustomScrollView: UIScrollViewDelegate {

    func scrollViewDidScroll(scrollView: UIScrollView) {

        if scrollDirection == .horizontal {
            moveableNode.position.x = scrollView.contentOffset.x
        } else {
            moveableNode.position.y = scrollView.contentOffset.y
        }
    }
}

Diese eine Unterklasse von UIScrollView und stellt die grundlegenden Eigenschaften von es. Es als hat seinen eigenen berührt-Methode, die sich an der einschlägigen Szene.

Schritt 2: In Ihrem jeweiligen Szene, die Sie es verwenden möchten, erstellen Sie eine scroll-view und bewegliche Knoten-Eigenschaft wie so

weak var scrollView: CustomScrollView!
let moveableNode = SKNode()

und fügen Sie Sie der Szene in didMoveToView

scrollView = CustomScrollView(frame: CGRect(x: 0, y: 0, width: self.frame.size.width, height: self.frame.size.height), scene: self, moveableNode: moveableNode, scrollDirection: .vertical)
scrollView.contentSize = CGSizeMake(self.frame.size.width, self.frame.size.height * 2)
view?.addSubview(scrollView) 


addChild(moveableNode)

Was Sie hier in der Zeile 1 ist Sie init der scroll-view-helper mit Ihnen Szene Abmessungen. Sie auch entlang der Szene für die Referenz-und die moveableNode, die Sie erstellt in Schritt 2.
Zeile 2 legen Sie die Größe des Inhalts der scrollView, in diesem Fall die doppelt so lang ist als die Bildschirmhöhe.

Schritt 3: - Fügen Sie Beschriftungen oder Knoten usw. und positionieren Sie diese.

label1.position.y = CGRectGetMidY(self.frame) - self.frame.size.height
moveableNode.addChild(label1)

in diesem Beispiel die Beschriftung auf der 2. Seite in der scrollView. Dies ist, wo Sie haben zu spielen, um Sie mit Etiketten und-Positionierung.

Ich empfehlen, dass, wenn Sie haben eine Menge Seiten in der scroll-Ansicht und eine Menge von Etiketten zu tun, die folgenden. Erstellen Sie eine SKSpriteNode für jede Seite in der scroll-Ansicht und jeder von Ihnen die Größe des Bildschirms. Rufen Sie wie page1Node, page2Node etc. Sie, als Sie alle Etiketten, die Sie wollen, zum Beispiel auf der zweiten Seite zu page2Node. Der Vorteil hier ist, dass Sie im Grunde positionieren können alle Ihre Sachen, wie gewohnt page2Node und als nur die position page2Node in der scrollView.

Sind Sie auch Glück, denn mit der scrollView vertikal (was u gesagt, Sie möchten), die Sie nicht brauchen, um jedes kippen und rückwärts Positionierung.

Machte ich einige Klasse func also, wenn Sie brauchen, um zu deaktivieren Sie Ihre scrollView incase Sie ein weiteres overlay-Menü ontop der scrollView.

CustomScrollView.enable()
CustomScrollView.disable()

Und schließlich vergessen Sie nicht, entfernen Sie die scroll-Blick von der Szene vor dem übergang zu einer neuen. Einer der Schmerzen beim Umgang mit UIKit in spritekit.

scrollView?.removeFromSuperView()

Für horizontales scrollen, ändern Sie einfach die scroll-Richtung auf die init-Methode auf .horizontale (Schritt 2).

Und jetzt der größte Schmerz ist, dass alles Umgekehrt bei der Positionierung Zeug. So ist die scroll-view geht von rechts nach Links. So müssen Sie die scrollView "contentOffset" - Methode, um es neu zu positionieren und im Grunde legen Sie alle Ihre Etiketten in umgekehrter Reihenfolge von rechts nach Links. Mit SkNodes wieder macht dies viel einfacher, wenn Sie verstehen, was passiert.

Hoffe, das hilft und sorry für die massive post, aber wie ich sagte, es ist ein bisschen wie ein Schmerz im spritekit. Lassen Sie mich wissen, wie es geht und wenn ich nichts übersehen habe.

Projekt ist auf gitHub

https://github.com/crashoverride777/SwiftySKScrollView

Hier ist der code, den wir verwendet, um zu simulieren UIScrollView Verhalten für SpriteKit Menüs.

Grundsätzlich müssen Sie eine dummy - UIView entspricht die Höhe der SKScene dann füttern UIScrollView scrollen und Tippen Sie auf Ereignisse, um die SKScene für die Verarbeitung.

Es ist frustrierend Apple nicht bieten diese nativ, aber hoffentlich sonst niemand hat Zeit zu verschwenden, den Wiederaufbau der Funktionalität!

class ScrollViewController: UIViewController, UIScrollViewDelegate {
    //IB Outlets
    @IBOutlet weak var scrollView: UIScrollView!

    //General Vars
    var scene = ScrollScene()

    //=======================================================================================================
    //MARK: Public Functions
    //=======================================================================================================
    override func viewDidLoad() {
        //Call super
        super.viewDidLoad()

        //Create scene
        scene = ScrollScene()

        //Allow other overlays to get presented
        definesPresentationContext = true

        //Create content view for scrolling since SKViews vanish with height > ~2048
        let contentHeight = scene.getScrollHeight()
        let contentFrame = CGRect(x: 0, y: 0, width: UIScreen.main.bounds.size.width, height: contentHeight)
        let contentView = UIView(frame: contentFrame)
        contentView.backgroundColor = UIColor.clear

        //Create SKView with same frame as <scrollView>, must manually compute because <scrollView> frame not ready at this point
        let scrollViewPosY = CGFloat(0)
        let scrollViewHeight = UIScreen.main.bounds.size.height - scrollViewPosY
        let scrollViewFrame = CGRect(x: 0, y: scrollViewPosY, width: UIScreen.main.bounds.size.width, height: scrollViewHeight)
        let skView = SKView(frame: scrollViewFrame)
        view.insertSubview(skView, at: 0)

        //Configure <scrollView>
        scrollView.addSubview(contentView)
        scrollView.delegate = self
        scrollView.contentSize = contentFrame.size

        //Present scene
        skView.presentScene(scene)

        //Handle taps on <scrollView>
        let tapGesture = UITapGestureRecognizer(target: self, action: #selector(scrollViewDidTap))
        scrollView.addGestureRecognizer(tapGesture)
    }

    //=======================================================================================================
    //MARK: UIScrollViewDelegate Functions
    //=======================================================================================================
    func scrollViewDidScroll(_ scrollView: UIScrollView) {
        scene.scrollBy(contentOffset: scrollView.contentOffset.y)
    }


    //=======================================================================================================
    //MARK: Gesture Functions
    //=======================================================================================================
    @objc func scrollViewDidTap(_ sender: UITapGestureRecognizer) {
        let scrollViewPoint = sender.location(in: sender.view!)
        scene.viewDidTapPoint(viewPoint: scrollViewPoint, contentOffset: scrollView.contentOffset.y)
    }
}



class ScrollScene : SKScene {
    //Layer Vars
    let scrollLayer = SKNode()

    //General Vars
    var originalPosY = CGFloat(0)


    //================================================================================================
    //MARK: Initializers
    //================================================================================================
    override init() {
        super.init()
    }


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


    //================================================================================================
    //MARK: Public Functions
    //================================================================================================
    func scrollBy(contentOffset: CGFloat) {
        scrollLayer.position.y = originalPosY + contentOffset
    }


    func viewDidTapPoint(viewPoint: CGPoint, contentOffset: CGFloat) {
        let nodes = getNodesTouchedFromView(point: viewPoint, contentOffset: contentOffset)
    }


    func getScrollHeight() -> CGFloat {
        return scrollLayer.calculateAccumulatedFrame().height
    }


    fileprivate func getNodesTouchedFromView(point: CGPoint, contentOffset: CGFloat) -> [SKNode] {
        var scenePoint = convertPoint(fromView: point)
        scenePoint.y += contentOffset
        return scrollLayer.nodes(at: scenePoint)
    }
}