Question

我想为我的SpriteKit游戏构建一个库存。为此，当我按下暂停按钮时，我想转到另一个代表我的库存的SKScene文件。我的问题是，当我从InventoryScene转换回我的GameScene时，GameScene会加载全新的。这是我的GameScene类的转换代码：

func loadInventory(){
    if !transitionInProgress{
        transitionInProgress = true
        if let scene = InventoryScene(fileNamed: "Inventory"){
            Globals.InventoryGlobals.levelBeforeSwitch = currentLevel
            scene.scaleMode = .aspectFill
            let transition = SKTransition.push(with: .down, duration: 0.5)
            self.view?.presentScene(scene, transition: transition)
        }
    }
}

使用此代码，我将转到我的InventoryScene。

现在在我的InventoryScene中，我想回到我的GameScene：

func loadLevel(level: String){
    if !transitionInProgress{
        transitionInProgress = true
        if let scene = GameScene(fileNamed: level){
            scene.currentLevel = level
            scene.scaleMode = .aspectFill
            let transition = SKTransition.doorsOpenHorizontal(withDuration: 1)
            self.view?.presentScene(scene, transition: transition)
        }
    }
}

转换正在进行但我的问题是GameScene加载全新，这显然是因为我实例化了一个新的GameScene。因此，当玩家处于关卡中间然后进入库存并返回GameScene时，玩家将返回关卡的开头。如果我从库存回到现场，我想成为之前的GameScene（玩家位置，敌人健康等）

有谁知道我该怎么做？

Answer 1

保留场景非常简单，您需要做的就是使用强大的参考保留场景

在ViewController中，它就像存储变量一样简单

class ViewController : UIViewController
{
    var gameScene = GameScene(fileNamed:"GameScene")
}

现在只要你的视图控制器还活着，你的场景就会活着。

要访问它，您只需要找到一种方法告诉您的视图控制器所在的MenuScene，然后显示该场景。

class ViewController : UIViewController
{
    var gameScene = GameScene(fileNamed:"GameScene")
    lazy var skView : SKView = self.view as! SKView
    func gotoMenu()
    {
         let menu = MenuScene(fileNamed"MenuScene")
         menu.viewController = self
         skView.presentScene(menu)
    }
}

class MenuScene : SKScene
{
   var viewController : ViewController!
   func returnToGame()
   {
       view.presentScene(viewcontroller.gameScene)
   }
}

但是，如果您不想一直使用自定义SKScene类，使用视图控制器，或者更愿意依赖组件，那么为什么没有一种方便的方法可以返回场景。

好吧，我的朋友，有，userData发挥作用的地方

class GameScene : SKScene
{
    func gotoMenu()
    {
         let menu = MenuScene(fileNamed:"MenuScene")
         menu.userData = menu.userData ?? ["":Any]()
         menu.userData["backToScene"] = self
         view.presentScene(menu)
    }
}

class MenuScene : SKScene
{
   func returnToGame()
   {
       guard let userData = userData, let scene = userData["backToScene"] as? SKScene
       view.presentScene(scene)
   }
}

由于我们将其保留在用户数据中，因此我们现在可以在任何可以访问菜单场景的地方展示旧场景。

userData在转移广告资源方面也很出色，当然我会创建一个类来管理广告资源，只需通过userData

传递参考资料

现在，要创建一个覆盖当前场景的菜单，就像在场景中应用新节点一样简单。

您甚至可以使用单独的SKS文件来布局菜单，并覆盖它：

class GameScene : SKScene
{
    let menu = MenuScene(fileNamed:"MenuScene")

    func overlayMenu()
    {
         scene.addChild(menu)  //You probably want to add an SKCameraNode, and add it to the camera instead
    }
    override func update(currentTime: CFTimeInterval) 
    {
        if menu.parent != nil
        {
            menu.update(currentTime:currentTime) //do this only when you need to have a constant update call,  be sure to include additional functionality like `didFinishUpdate` in the approprate functions when needed
        }
    }


}

当然现在是开发所谓worldNode的好时机，也可称为gameNode

本节点的基本内容是保存所有游戏元素的节点。这允许您添加可以暂停游戏的叠加节点。

您的场景层次结构如下：

SKScene
--worldNode
----所有属于游戏的节点
--menuNode
----属于菜单的所有节点

现在，在任何时候，菜单都可以将worldNode的isPaused状态设置为true，允许游戏暂停并仍然让您能够与menuNode进行交互

Answer 2

我一直在我的Spritekit游戏中停留窗口，并且它不必像你想象的那样复杂。以下是如何在不离开场景的情况下在Spritekit中完成所有操作。

创建一个新类，它是InventoryDialog的SKSpriteNode的子类。

import SpriteKit

protocol InventoryDialogDelegate: class {
    func close()
}

class InventoryDialog: SKSpriteNode {

    private var closeButton: SKSpriteNode!
    weak var delegate: InventoryDialogDelegate?

    init(size: CGSize) {
        super.init(texture: nil, color: .clear, size: size)

        name = "inventoryDialog"

        //do some background design work here   
        let background = SKSpriteNode(color: .white, size: self.size)
        background.zPosition = 1
        addChild(background) 

        closeButton = SKSpriteNode(texture: SKTexture(imageNamed: "closeButton"))
        closeButton.position = CGPoint(x: self.size.width / 2 - closeButton.size.width / 2, y: self.size.height / 2 - closeButton.size.height / 2)
        closeButton.zPosition = 2
        addChild(closeButton)
    }

    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        let touch = touches.first
        let touchLocation = touch!.location(in: self)
        if closeButton.contains(touchLocation) {
            close()
        }
    }

    func close() {
        self.delegate?.close()
    }
}

在GameScene文件中

class GameScene: SKScene {

    var inventoryDialog: InventoryDialog!
    var openButton: SKSpriteNode!

    override func didMove(to view: SKView) {
        openButton = SKSpriteNode(texture: SKTexture(imageNamed: "openButton"))
        openButton.position = CGPoint(x: self.size.width / 2 - closeButton.size.width / 2, y: self.size.height / 2 - closeButton.size.height / 2)
        openButton.zPosition = 2
        addChild(openButton) 
    }

    func displayInventoryDialog() {
        backgroundBlocker = SKSpriteNode(imageNamed: "background3")
        backgroundBlocker.size = self.size
        backgroundBlocker.zPosition = 4999
        addChild(backgroundBlocker)

        inventoryDialog = InventoryDialog(size: CGSize(width: 500, height: 800))
        inventoryDialog.delegate = self
        inventoryDialog.zPosition = 5000
        addChild(inventoryDialog)
    }

    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        //pause any action that you don't want running while the dialog is open
        gameLayer.isPaused = true

        let touch = touches.first
        let touchLocation = touch!.location(in: self)
        if openButton.contains(touchLocation) {
            displayInventoryDialog()
        }
    }
}

//MARK: - InventoryDialogDelegate Methods

extension GameScene: InventoryDialogDelegate {

    func close() {
        //at this point you could update any GUI nesc. based on what happened in your dialog
        backgroundBlocker.removeFromParent()
        inventoryDialog?.removeFromParent()
        gameLayer.isPaused = false
    }
}

Answer 3

这正是你想要的。

class GameScene: SKScene {
class InventoryManager: UIView {
    override init(frame: CGRect) {
        super.init(frame: CGRect(x: 0, y: 0, width: 300, height: 200))

        //here is where you set up anything you want to display inside the view
        self.backgroundColor = UIColor.green

        let Button = UIButton()
        Button.frame = CGRect(x: 0, y: 0, width: 40, height: 20)
        Button.backgroundColor = UIColor.red

        let TouchView = UIView()
        TouchView.frame = self.frame

        Button.center.x = TouchView.center.x
        Button.center.y = TouchView.center.y

        TouchView.backgroundColor = UIColor.brown

        self.addSubview(TouchView)
        //make sure you add any objects that you want to the TouchView and not to the self
        TouchView.addSubview(Button)

    }

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

var Node = SKSpriteNode()

override func didMove(to view: SKView) {
    //this keeps the view centered in the screen
    InventoryView.center.x = (self.view?.center.x)!
    InventoryView.center.y = (self.view?.center.y)!



    Node = SKSpriteNode(color: UIColor.blue, size: CGSize(width: 40, height: 40))
    Node.position = CGPoint(x: self.frame.size.width / 3, y: self.frame.size.height / 3)

    self.addChild(Node)
}

override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    for touch in touches {
        let location = touch.location(in: self)

        if !(self.view?.frame.contains(location))! {
            InventoryView.removeFromSuperview()
        }
        if Node.contains(location) && InventoryView.isDescendant(of: self.view!) {
            self.view?.addSubview(InventoryView)
        }

    }
}

    override func update(_ currentTime: TimeInterval) {
        // Called before each frame is rendered
    }
}

单击蓝色按钮会再次将其添加到场景中，然后单击其他任何位置将其从场景中删除

通过转换保存GameScene的状态

3 个答案: