概述

SpriteKit制作瓦片地图游戏，深入了解2D游戏制作过程

详细

说实话这个2D游戏实战的入门看的我脑浆子都沸腾了, 好多新的概念涌入, 没做过游戏开发的我表示真的难以接受, 吸收效率与之前相比也下降好多, 不过越往后学, 就能够加深对之前知识的掌握, 这可能也是看书的好处吧, 今天我也把对瓦片地图的一些学习经验记录下来供大家探讨.

说实话, 我很推荐Ray家的资源, 由浅入深手把手的教学, 内容前后呼应, 看几本书就能涵盖国内4个月培训班的课程体系. 遵循本系列一贯的风格, 我们还是从基础的API开始看起, 对API掌握熟练的话, 多敲两个Demo就能够基本的上手任何项目了.

一、瓦片地图技术要点

1、SKTileMapNode

  1. @available(iOS 10.0, *)
  2. open class SKTileMapNode : SKNode, NSCopying, NSCoding
  3.      public init(tileSet: SKTileSet, columns: Int, rows: Int, tileSize: CGSize)
  4.      open var numberOfColumns: Int
  5.      open var numberOfRows: Int
  6.      open var tileSize: CGSize
  7.      open var mapSize: CGSize { get }
  8.      open var tileSet: SKTileSet
  9.      open var colorBlendFactor: CGFloat
  10.      open func tileDefinition(atColumn column: Int, row: Int) -> SKTileDefinition?
  11.      open func tileGroup(atColumn column: Int, row: Int) -> SKTileGroup?
  12.      open func setTileGroup(_ tileGroup: SKTileGroup?, forColumn column: Int, row: Int)
  13.      open func tileColumnIndex(fromPosition position: CGPoint) -> Int
  14.      open func tileRowIndex(fromPosition position: CGPoint) -> Int
  15.      open func centerOfTile(atColumn column: Int, row: Int) -> CGPoint

  • init(tileSet: SKTileSet, columns: Int, rows: Int, tileSize: CGSize) 瓦片地图节点的初始化方法

  • numberOfColumns 瓦片地图的列数

  • numberOfRows 瓦片地图的行数

  • tileSize 瓦片地图中每个瓦片的尺寸

  • mapSize 瓦片地图的尺寸

  • tileSet 瓦片地图的瓦片集

  • colorBlendFactor 瓦片的渲染着色

  • tileDefinition(atColumn column: Int, row: Int) -> SKTileDefinition? 根据列数和行数返回瓦片定义

  • tileGroup(atColumn column: Int, row: Int) -> SKTileGroup? 根据列数和行数返回瓦片组

  • setTileGroup(_ tileGroup: SKTileGroup?, forColumn column: Int, row: Int) 根据列数和行数设置瓦片组

  • tileColumnIndex(fromPosition position: CGPoint) -> Int 根据瓦片位置返回瓦片在瓦片地图中列数下标

  • tileRowIndex(fromPosition position: CGPoint) -> Int 根据瓦片位置返回瓦片在瓦片地图中行数下标

2、SKTileSet

  1. @available(iOS 10.0, *)
  2. open class SKTileSet : NSObject, NSCopying, NSCoding
  3.      public init(tileGroups: [SKTileGroup])
  4.      open var tileGroups: [SKTileGroup]
  5.      open var name: String?
  6.      open var defaultTileGroup: SKTileGroup?
  7.      open var defaultTileSize: CGSize
  8.      open var type: SKTileSetType
  9.  
  10. @available(iOS 10.0, *)
  11. public enum SKTileSetType : UInt {
  12.     case grid
  13.     case isometric
  14.     case hexagonalFlat
  15.     case hexagonalPointy
  16. }

  • init(tileGroups: [SKTileGroup]) 根据瓦片组初始化瓦片集

  • tileGroups 瓦片组

  • name 瓦片集的标识

  • defaultTileGroup 瓦片集默认瓦片组

  • defaultTileSize 瓦片集默认瓦片尺寸

  • type 瓦片集类型 - 网格, 等值, 六边形

3、SKTileGroup

  1. @available(iOS 10.0, *)
  2. open class SKTileGroup : NSObject, NSCopying, NSCoding
  3.      open class func empty() -> Self
  4.      public init(tileDefinition: SKTileDefinition)
  5.      public init(rules: [SKTileGroupRule])
  6.      open var name: String?

  • empty() 返回一个空的瓦片组

  • init(tileDefinition: SKTileDefinition) 根据瓦片定义初始化瓦片组

  • init(rules: [SKTileGroupRule]) 根据瓦片组规则初始化瓦片组

  • name 瓦片组的标识

4、SKTileGroupRule

  1. @available(iOS 10.0, *)
  2. open class SKTileGroupRule : NSObject, NSCopying, NSCoding
  3.      public init(adjacency: SKTileAdjacencyMask, tileDefinitions: [SKTileDefinition])
  4.      open var adjacency: SKTileAdjacencyMask
  5.      open var tileDefinitions: [SKTileDefinition]
  6.      open var name: String?

  • init(adjacency: SKTileAdjacencyMask, tileDefinitions: [SKTileDefinition]) 根据瓦片链接和瓦片定义初始化瓦片组规则

  • adjacency 瓦片链接

  • tileDefinitions 瓦片规则

  • name 瓦片组规则标识

5、SKTileDefinition

  1. @available(iOS 10.0, *)
  2. open class SKTileDefinition : NSObject, NSCopying, NSCoding
  3.      public init(texture: SKTexture)
  4.      public init(textures: [SKTexture], normalTextures: [SKTexture], size: CGSize, timePerFrame: CGFloat)
  5.      open var userData: NSMutableDictionary?
  6.      open var name: String?
  7.      open var size: CGSize
  8.      open var timePerFrame: CGFloat
  9.      open var rotation: SKTileDefinitionRotation
  10.      open var flipVertically: Bool
  11.      open var flipHorizontally: Bool

  • init(texture: SKTexture) 根据纹理初始化瓦片定义

  • init(textures: [SKTexture], normalTextures: [SKTexture], size: CGSize, timePerFrame: CGFloat) 根据纹理集合, 尺寸, 和帧率初始化瓦片定义

  • userData 瓦片定义的用户数据

  • name 瓦片定义的标识

  • timePerFrame 瓦片定义的帧率

  • rotation 瓦片定义的旋转规则

  • flipVertically 是否垂直翻转

  • flipHorizontally 是否水平翻转

二、程序实现

API, 了解一些基本的就够了, 如果要深究可以打开头文件逐个尝试, 我们现在就来实现一个小游戏, 这个游戏中包含了3个场景, 控制人物在规定时间内消灭所有的害虫, 我们着手进行游戏的开发吧!

1、step1 设置游戏场景的属性

  1. class GameScene: SKScene {
  2.   var background: SKTileMapNode! //背景瓦片地图节点
  3.   var obstaclesTileMap: SKTileMapNode? //障碍物瓦片地图节点
  4.   var bugsprayTileMap: SKTileMapNode? //杀虫喷剂瓦片地图节点
  5.  
  6.   var bugsNode = SKNode() //害虫的节点
  7.  
  8.   var player = Player() //玩家的节点
  9.   var hud = HUD() //文字说明
  10.  
  11.   var firebugCount: Int = 0 //高级害虫的节点数
  12.  
  13.   var timeLimit: Int = 10 //时间限制
  14.   var elapsedTime: Int = 0 //经过时间
  15.   var startTime: Int? //开始时间
  16.  
  17.   var currentLevel: Int = 1 //当前关卡等级
  18.  
  19.   var gameState: GameState = .initial { //游戏状态默认为初始状态
  20.     didSet {
  21.       hud.updateGameState(from: oldValue, to: gameState) //更新游戏状态
  22.     }
  23.   }
  24.   ...
  25. }

2、step2 加载游戏场景的初始化设置

  1. required init?(coder aDecoder: NSCoder) {
  2.     super.init(coder: aDecoder)
  3.     background =
  4.       childNode(withName: "background") as! SKTileMapNode //通过节点名读取背景瓦片地图节点
  5.     obstaclesTileMap = childNode(withName: "obstacles")
  6.       as? SKTileMapNode //通过节点名读取障碍物瓦片地图节点
  7.  
  8.     if let timeLimit =
  9.       userData?.object(forKey: "timeLimit") as? Int {
  10.       self.timeLimit = timeLimit //通过节点的用户数据设置每个场景的时间限制
  11.     }
  12.     // 1
  13.     let savedGameState = aDecoder.decodeInteger(forKey: "Scene.gameState") //解档保存游戏状态
  14.     if let gameState = GameState(rawValue: savedGameState), gameState == .pause { //当解档保存游戏状态为暂停时
  15.       self.gameState = gameState //赋值游戏状态
  16.       firebugCount = aDecoder.decodeInteger(
  17.         forKey: "Scene.firebugCount") //解档高级害虫数
  18.       elapsedTime = aDecoder.decodeInteger(
  19.         forKey: "Scene.elapsedTime") //解档经过时间
  20.       currentLevel = aDecoder.decodeInteger(
  21.         forKey: "Scene.currentLevel") //解档当前关卡等级
  22.       // 2
  23.       player = childNode(withName: "Player") as! Player //根据节点名读取玩家节点
  24.       hud = camera!.childNode(withName: "HUD") as! HUD //根据节点名读取文字说明
  25.       bugsNode = childNode(withName: "Bugs")! //根据节点名读取害虫节点
  26.       bugsprayTileMap = childNode(withName: "Bugspray")
  27.         as? SKTileMapNode //通过节点名读取杀虫喷雾瓦片地图节点
  28.     }
  29.  
  30.     addObservers() //添加观察者
  31.   }
  32.  
  33.   deinit {
  34.     NotificationCenter.default.removeObserver(self) //移除观察者
  35.   }

3、step3 当场景移动到屏幕时的设置

  1. override func didMove(to view: SKView) {
  2.     if gameState == .initial { //当游戏状态为初始状态时
  3.       addChild(player) //添加玩家到场景
  4.       setupWorldPhysics() //添加物理世界
  5.       createBugs() //添加害虫
  6.       setupObstaclePhysics() //添加障碍物
  7.       if firebugCount > 0 { //如果有高级害虫
  8.         createBugspray(quantity: firebugCount + 10) //添加杀虫喷雾
  9.       }
  10.       setupHUD() //添加文字说明
  11.       gameState = .start //设置游戏状态为开始状态
  12.     }
  13.     setupCamera() //添加摄像头
  14.   }

4、step4 物理世界的设置

  1. func setupWorldPhysics() {
  2.     background.physicsBody =
  3.       SKPhysicsBody(edgeLoopFrom: background.frame) //设置边缘物理体
  4.     background.physicsBody?.categoryBitMask = PhysicsCategory.Edge //设置物理体标识为边缘
  5.  
  6.     physicsWorld.contactDelegate = self //物理世界代理
  7.  
  8.   }

5、step5 创建害虫的设置

  1. func createBugs() {
  2.     guard let bugsMap = childNode(withName: "bugs")
  3.       as? SKTileMapNode else { return } //校验害虫瓦片地图节点
  4.     // 1
  5.     for row in 0..<bugsMap.numberOfRows { //逐行遍历害虫瓦片地图
  6.       for column in 0..<bugsMap.numberOfColumns { //逐列遍历害虫瓦片地图
  7.         // 2
  8.         guard let tile = tile(in: bugsMap,
  9.                               at: (column, row))
  10.           else { continue } //校验瓦片地图中的每个瓦片
  11.         // 3
  12.         let bug: Bug
  13.         if tile.userData?.object(forKey: "firebug") != nil { //从用户数据中判断是否为高级害虫
  14.           bug = Firebug() //将害虫设置为高级害虫
  15.           firebugCount += 1 //高级害虫书自增
  16.         } else {
  17.           bug = Bug() //将害虫设置为普通害虫
  18.         }
  19.         bug.position = bugsMap.centerOfTile(atColumn: column,
  20.                                             row: row) //从害虫瓦片地图中读取位置并赋值
  21.         bugsNode.addChild(bug) //添加节点
  22.         bug.moveBug() //移动害虫
  23.       }
  24.     }
  25.     // 4
  26.     bugsNode.name = "Bugs" //设置害虫节点标识
  27.     addChild(bugsNode) //添加父节点到场景
  28.     // 5
  29.     bugsMap.removeFromParent() //删除害虫瓦片地图地图节点
  30.   }

6、step6 添加障碍物的设置

  1. func setupObstaclePhysics() {
  2.     guard let obstaclesTileMap = obstaclesTileMap else { return } //校验障碍物瓦片地图节点
  3.     // 1
  4.     for row in 0..<obstaclesTileMap.numberOfRows {
  5.       for column in 0..<obstaclesTileMap.numberOfColumns {
  6.         // 2
  7.         guard let tile = tile(in: obstaclesTileMap,
  8.                               at: (column, row))
  9.           else { continue }
  10.         guard tile.userData?.object(forKey: "obstacle") != nil
  11.           else { continue }
  12.         // 3
  13.         let node = SKNode() //创建节点
  14.         node.physicsBody = SKPhysicsBody(rectangleOf: tile.size) 根据瓦片尺寸创建物理体
  15.         node.physicsBody?.isDynamic = false //不进入物理世界
  16.         node.physicsBody?.friction = 0 //摩擦系数为0
  17.         node.physicsBody?.categoryBitMask =
  18.           PhysicsCategory.Breakable //设置物理体标识
  19.  
  20.         node.position = obstaclesTileMap.centerOfTile(
  21.           atColumn: column, row: row)
  22.         obstaclesTileMap.addChild(node)
  23.       }
  24.     }
  25.   }

7、step7 添加杀虫喷雾的设置

  1. func createBugspray(quantity: Int) {
  2.     // 1
  3.     let tile = SKTileDefinition(texture:
  4.       SKTexture(pixelImageNamed: "bugspray")) //创建瓦片定义
  5.     // 2
  6.     let tilerule = SKTileGroupRule(adjacency:
  7.       SKTileAdjacencyMask.adjacencyAll, tileDefinitions: [tile]) //创建瓦片组规则
  8.     // 3
  9.     let tilegroup = SKTileGroup(rules: [tilerule]) //创建瓦片组
  10.     // 4
  11.     let tileSet = SKTileSet(tileGroups: [tilegroup]) //创建瓦片集
  12.  
  13.     // 5
  14.     let columns = background.numberOfColumns //读取背景瓦片地图节点的列数
  15.     let rows = background.numberOfRows //读取背景瓦片地图节点的行数
  16.     bugsprayTileMap = SKTileMapNode(tileSet: tileSet,
  17.                                     columns: columns,
  18.                                     rows: rows,
  19.                                     tileSize: tile.size) //创建新的瓦片地图节点
  20.     // 6
  21.     for _ in 1...quantity {
  22.       let column = Int.random(min: 0, max: columns-1) //随机列数
  23.       let row = Int.random(min: 0, max: rows-1) //随机行数
  24.       bugsprayTileMap?.setTileGroup(tilegroup,
  25.                                     forColumn: column, row: row) //在新额的瓦片地图节点上随机生成瓦片组
  26.     }
  27.     // 7
  28.     bugsprayTileMap?.name = "Bugspray" //设置瓦片地图节点的标识
  29.     addChild(bugsprayTileMap!) //将瓦片地图添加到场景
  30.  
  31.   }

8、step8 添加摄像头设置

  1. func setupCamera() {
  2.     guard let camera = camera, let view = view else { return }
  3.  
  4.     let zeroDistance = SKRange(constantValue: 0)
  5.     let playerConstraint = SKConstraint.distance(zeroDistance,
  6.                                                  to: player) //对玩家进行约束
  7.     // 1
  8.     let xInset = min(view.bounds.width/2 * camera.xScale,
  9.                      background.frame.width/2)
  10.     let yInset = min(view.bounds.height/2 * camera.yScale,
  11.                      background.frame.height/2)
  12.  
  13.     // 2
  14.     let constraintRect = background.frame.insetBy(dx: xInset,
  15.                                                   dy: yInset)
  16.     // 3
  17.     let xRange = SKRange(lowerLimit: constraintRect.minX,
  18.                          upperLimit: constraintRect.maxX)
  19.     let yRange = SKRange(lowerLimit: constraintRect.minY,
  20.                          upperLimit: constraintRect.maxY)
  21.  
  22.     let edgeConstraint = SKConstraint.positionX(xRange, y: yRange)
  23.     edgeConstraint.referenceNode = background
  24.     // 4
  25.     camera.constraints = [playerConstraint, edgeConstraint]
  26.   }

9、step9 获取瓦片的一些帮助方法

  1. func tile(in tileMap: SKTileMapNode,
  2.             at coordinates: TileCoordinates)
  3.     -> SKTileDefinition? {
  4.       return tileMap.tileDefinition(atColumn: coordinates.column,
  5.                                     row: coordinates.row)
  6.   }
  7.  
  8.   func tileCoordinates(in tileMap: SKTileMapNode,
  9.                        at position: CGPoint) -> TileCoordinates {
  10.     let column = tileMap.tileColumnIndex(fromPosition: position)
  11.     let row = tileMap.tileRowIndex(fromPosition: position)
  12.     return (column, row)
  13.   }
  14.  
  15.   func tileGroupForName(tileSet: SKTileSet, name: String)
  16.     -> SKTileGroup? {
  17.       let tileGroup = tileSet.tileGroups
  18.         .filter { $0.name == name }.first
  19.       return tileGroup
  20.   }

10、step10 点击场景的设置

  1. override func touchesBegan(_ touches: Set<UITouch>,
  2.                              with event: UIEvent?) {
  3.     guard let touch = touches.first else { return }
  4.     switch gameState {
  5.     // 1
  6.     case .start: //开始状态
  7.       gameState = .play //切换成游戏状态
  8.       isPaused = false //开始
  9.       startTime = nil
  10.       elapsedTime = 0
  11.     // 2
  12.     case .play: //游戏状态
  13.       player.move(target: touch.location(in: self)) //移动玩家
  14.     case .win: //获胜状态
  15.       transitionToScene(level: currentLevel + 1) //切换场景
  16.     case .lose: //落败状态
  17.       transitionToScene(level: 1) //切换场景
  18.     case .reload: //唤醒状态
  19.       // 1
  20.       if let touchedNode =
  21.         atPoint(touch.location(in: self)) as? SKLabelNode {
  22.         // 2
  23.         if touchedNode.name == HUDMessages.yes { //如果点击的节点是YES
  24.           isPaused = false
  25.           startTime = nil
  26.           gameState = .play
  27.           // 3
  28.         } else if touchedNode.name == HUDMessages.no { //如果点击的节点是NO
  29.           transitionToScene(level: 1)
  30.         }
  31.       }
  32.     default:
  33.       break
  34.     }
  35.   }

11、step11 切换场景的设置

  1. func transitionToScene(level: Int) {
  2.     // 1
  3.     guard let newScene = SKScene(fileNamed: "Level\(level)")
  4.       as? GameScene else {
  5.         fatalError("Level: \(level) not found")
  6.     }
  7.     // 2
  8.     newScene.currentLevel = level
  9.     view!.presentScene(newScene,
  10.                        transition: SKTransition.flipVertical(withDuration: 0.5))
  11.   }

12、step12 刷帧

  1. override func update(_ currentTime: TimeInterval) {
  2.     if gameState != .play  {
  3.       isPaused = true //如果不是游戏状态就暂停刷帧
  4.       return
  5.     }
  6.  
  7.     if !player.hasBugspray {
  8.       updateBugspray() //如果玩家没有杀虫喷雾, 就进行更新
  9.     }
  10.     advanceBreakableTile(locatedAt: player.position) //更新障碍物的物理体状态
  11.     updateHUD(currentTime: currentTime) //更新文字说明
  12.     checkEndGame() //检查是否达到胜负条件
  13.   }

13、step13 更新杀虫喷雾

  1. func updateBugspray() {
  2.     guard let bugsprayTileMap = bugsprayTileMap else { return }
  3.     let (column, row) = tileCoordinates(in: bugsprayTileMap,
  4.                                         at: player.position)
  5.     if tile(in: bugsprayTileMap, at: (column, row)) != nil {
  6.       bugsprayTileMap.setTileGroup(nil, forColumn: column,
  7.                                    row: row)
  8.       player.hasBugspray = true
  9.     }
  10.   }

14、step14 更新障碍物的物理体状态

  1. func advanceBreakableTile(locatedAt nodePosition: CGPoint) {
  2.     guard let obstaclesTileMap = obstaclesTileMap else { return }
  3.     // 1
  4.     let (column, row) = tileCoordinates(in: obstaclesTileMap,
  5.                                         at: nodePosition)
  6.     // 2
  7.     let obstacle = tile(in: obstaclesTileMap,
  8.                         at: (column, row))
  9.     //3
  10.     guard let nextTileGroupName =
  11.       obstacle?.userData?.object(forKey: "breakable") as? String
  12.       else { return }
  13.     // 4
  14.     if let nextTileGroup =
  15.       tileGroupForName(tileSet: obstaclesTileMap.tileSet,
  16.                        name: nextTileGroupName) {
  17.       obstaclesTileMap.setTileGroup(nextTileGroup,
  18.                                     forColumn: column, row: row) //设置新的瓦片组到瓦片地图中
  19.     }
  20.   }

15、step15 更新文字说明

  1. func updateHUD(currentTime: TimeInterval) {
  2.     // 1
  3.     if let startTime = startTime {
  4.       // 2
  5.       elapsedTime = Int(currentTime) - startTime
  6.     } else {
  7.       // 3
  8.       startTime = Int(currentTime) - elapsedTime
  9.     }
  10.     // 4
  11.     hud.updateTimer(time: timeLimit - elapsedTime) //对文字说明进行更新
  12.   }

16、step16 检查是否达到胜负条件

  1. func checkEndGame() {
  2.     if bugsNode.children.count == 0 { //是否消灭全部害虫
  3.       player.physicsBody?.linearDamping = 1
  4.       gameState = .win
  5.     } else if timeLimit - elapsedTime <= 0 { //是否时间用完
  6.       player.physicsBody?.linearDamping = 1
  7.       gameState = .lose
  8.     }
  9.   }

17、step17 物理世界代理的设置

  1. extension GameScene : SKPhysicsContactDelegate {
  2.   func remove(bug: Bug) { //消灭害虫
  3.     bug.removeFromParent()
  4.     background.addChild(bug)
  5.     bug.die()
  6.     hud.updateBugCount(with: bugsNode.children.count)
  7.   }
  8.  
  9.   func didBegin(_ contact: SKPhysicsContact) {
  10.     let other = contact.bodyA.categoryBitMask
  11.       == PhysicsCategory.Player ?
  12.         contact.bodyB : contact.bodyA
  13.  
  14.     switch other.categoryBitMask {
  15.     case PhysicsCategory.Bug:
  16.       if let bug = other.node as? Bug {
  17.         remove(bug: bug) //当玩家接触到普通害虫, 消灭普通害虫
  18.       }
  19.     case PhysicsCategory.Firebug:
  20.       if player.hasBugspray {
  21.         if let firebug = other.node as? Firebug {
  22.           remove(bug: firebug)
  23.           player.hasBugspray = false //当玩家手持杀虫喷雾接触高级害虫才能消灭高级害虫
  24.         }
  25.       }
  26.     case PhysicsCategory.Breakable:
  27.       if let obstacleNode = other.node {
  28.         // 1
  29.         advanceBreakableTile(locatedAt: obstacleNode.position) //更新障碍物
  30.         // 2
  31.         obstacleNode.removeFromParent() //删除原障碍物
  32.       }
  33.  
  34.     default:
  35.       break
  36.     }
  37.     if let physicsBody = player.physicsBody {
  38.       if physicsBody.velocity.length() > 0 {
  39.         player.checkDirection() //进行玩家方向的设置
  40.       }
  41.     }
  42.   }
  43. }

18、step18 观察者的设置

  1. extension GameScene {
  2.   func applicationDidBecomeActive() {
  3.     print("* applicationDidBecomeActive")
  4.     if gameState == .pause {
  5.       gameState = .reload //重新进入, 进行游戏重载
  6.     }
  7.   }
  8.  
  9.   func applicationWillResignActive() {
  10.     print("* applicationWillResignActive")
  11.     isPaused = true
  12.     if gameState != .lose {
  13.       gameState = .pause  //暂停游戏进程
  14.     }
  15.   }
  16.  
  17.   func applicationDidEnterBackground() {
  18.     print("* applicationDidEnterBackground")
  19.     if gameState != .lose {
  20.       saveGame() //进入后台保存游戏进度
  21.     }
  22.   }
  23.  
  24.   func addObservers() {
  25.     NotificationCenter.default.addObserver(self,
  26.                                            selector: #selector(applicationDidBecomeActive),
  27.                                            name: .UIApplicationDidBecomeActive, object: nil)
  28.     NotificationCenter.default.addObserver(self,
  29.                                            selector: #selector(applicationWillResignActive),
  30.                                            name: .UIApplicationWillResignActive, object: nil)
  31.     NotificationCenter.default.addObserver(self,
  32.                                            selector: #selector(applicationDidEnterBackground),
  33.                                            name: .UIApplicationDidEnterBackground, object: nil)
  34.   }
  35.  
  36. }

19、step19 游戏的存储设置

  1. extension GameScene {
  2.   func saveGame() {
  3.     // 1
  4.     let fileManager = FileManager.default
  5.     guard let directory =
  6.       fileManager.urls(for: .libraryDirectory,
  7.                        in: .userDomainMask).first
  8.       else { return }
  9.     // 2
  10.     let saveURL = directory.appendingPathComponent("SavedGames")
  11.     // 3
  12.     do {
  13.       try fileManager.createDirectory(atPath: saveURL.path,
  14.                                       withIntermediateDirectories: true,
  15.                                       attributes: nil)
  16.     } catch let error as NSError {
  17.       fatalError(
  18.         "Failed to create directory: \(error.debugDescription)")
  19.     }
  20.     // 4
  21.     let fileURL = saveURL.appendingPathComponent("saved-game")
  22.     print("* Saving: \(fileURL.path)")
  23.     // 5
  24.     NSKeyedArchiver.archiveRootObject(self, toFile: fileURL.path) //文件处理器新建路径并归档
  25.   }
  26.  
  27.   override func encode(with aCoder: NSCoder) { /对关键属性的归档
  28.     aCoder.encode(firebugCount,
  29.                   forKey: "Scene.firebugCount")
  30.     aCoder.encode(elapsedTime,
  31.                   forKey: "Scene.elapsedTime")
  32.     aCoder.encode(gameState.rawValue,
  33.                   forKey: "Scene.gameState")
  34.     aCoder.encode(currentLevel,
  35.                   forKey: "Scene.currentLevel")
  36.     super.encode(with: aCoder)
  37.   }
  38.  
  39.   class func loadGame() -> SKScene? { //重新加载存储游戏进程
  40.     print("* loading game")
  41.     var scene: SKScene?
  42.     // 1
  43.     let fileManager = FileManager.default
  44.     guard let directory =
  45.       fileManager.urls(for: .libraryDirectory,
  46.                        in: .userDomainMask).first
  47.       else { return nil }
  48.     // 2
  49.     let url = directory.appendingPathComponent(
  50.       "SavedGames/saved-game")
  51.     // 3
  52.     if FileManager.default.fileExists(atPath: url.path) {
  53.       scene = NSKeyedUnarchiver.unarchiveObject(  //根据路径进行解档游戏进程
  54.         withFile: url.path) as? GameScene
  55.       _ = try? fileManager.removeItem(at: url)
  56.     }
  57.     return scene
  58.   }
  59.  
  60. }

三、运行效果与文件截图

1、运行效果

2、文件截图

PestControl文件里的截图：

PestControl.xcodeproj文件里的截图：

四、其他补充

Notice: 忽略了一些节点的设置, 但不影响瓦片地图的理解.

注：本文著作权归作者，由demo大师发表，拒绝转载，转载需要作者授权

[SpriteKit] 制作瓦片地图小游戏的更多相关文章

  1. 用C#制作推箱子小游戏

    思路分析: 一.制作一个地图 二.地图中放置墙.箱子.人.目标等 三.让小人动起来完成推箱子动作 游戏制作: 1.按照上述地图制作一个地图  (12行×13列) 地图可以看做是行和列组成的,即可以看做 ...

  2. 制作动画或小游戏——CreateJS事件（二）

    在Canvas中如果要添加事件,就需要计算坐标来模拟各种事件,而EaselJS中已经封装好了多个事件,只需调用即可. 一.事件 1)点击 事件是绑定在Shape类中的,click事件与DOM中的意思是 ...

  3. 制作一个 JavaScript 小游戏

    简评: 作者学习了编程两个月,边学边做了一个 JavaScript 小游戏,在文中总结了自己在这个过程中的一些体会,希望能给其他初学者一些帮助. 对于很多想学编程但一直没下定决心的同学来说,最大的问题 ...

  4. 制作动画或小游戏——CreateJS基础类（一）

    前面曾经记录过Canvas的基础知识<让自己也能使用Canvas>,在实际使用中,用封装好的库效率会高点. 使用成熟的库还能对基础知识有更深入的理解,CreateJS是基于HTML5开发的 ...

  5. IOS学习之路五（SpriteKit 开发飞机大战小游戏一）

    参考SpriteKit 创建游戏的教程今天自己动手做了一下,现在记录一下自己怎么做的,今天之做了第一步,一共有三个部分. 第一步,项目搭建. 项目所用图片资源:点击打开链接 1.在Xcode打开之后, ...

  6. Python制作塔防小游戏

    开发工具 Python版本:3.6.4 相关模块: pygame模块: 以及一些Python自带的模块.

  7. 原生JS制作贪吃蛇小游戏

    感情都在代码里,来,干了!... <!doctype html> <html> <head> <meta http-equiv="Content-T ...

  8. 用cocos2d 2.1制作一个过河小游戏(4): 游戏主逻辑BaseLayer设计

    前段时间一直在忙.没有时间更新博客.今天还是抽点时间把最后一小部分游戏的实现放上来吧. BaseLayer.h: #import <GameKit/GameKit.h> #import & ...

  9. 利用python 5分钟制作一款小游戏

    1.安装pygame 在命令行cmd中输入:pip install pygame ( 注:如果安装不成功,需要输入:python -m pip install --user --upgrade pip ...

随机推荐

  1. Unity中一键创建常用文件夹

    Unity中一键创建常用文件夹 说明 项目测试版本Unity5.3. 这个一个小工具:功能非常简单,就是一键给新建工程添加所有文件夹.到此结束. 但是具体咋操作呢? 与把大象装进冰箱一样,三步,下载代 ...

  2. 4. python 修改字符串实例总结

    4. python 修改字符串实例总结 我们知道python里面字符串是不可原处直接修改的,为了是原来的字符串修改过来,我们有一下方法: 1.分片和合并 >>> a='abcde'  ...

  3. SWT 全接触

    http://www.ibm.com/developerworks/cn/opensource/os-swt/index.html 1．SWT简介 SWT-"Standard Widget ...

  4. 【centOS7】centOS7上普通用户切换root用户，相互切换

    当前普通用户登录,想要切换为root用户,需要输入命令 su 需要输入root密码.输入时候屏幕不会显示,直接输入完了,回车即可 回车后,即切换到root用户下 想要从root用户切换到普通用户,只需 ...

  5. C# 输入法 z

    C# 输入法 虽说输入法不是什么新事物,各种语言版本都有,不过在C#不常见:这就会给人一种误会:C#不能做!其实C#能不能做呢,答案是肯定的——三种方式都行:IMM.TSF以及外挂式.IMM这种就是调 ...

  6. AFNetworking 2.0使用(持续更新)

    本人视频教程系列 导入AFNetworking 2.0 文件夹,引入头文件AFNetworking.h --------------- *使用NSURLSessionDownloadTask来下载一张 ...

  7. Mantis的config_inc.php的各配置项的作用及其修改

    Mantis的设置是这样保存的:在 config_defaults_inc.php中保存Mantis的默认设置,用户自己的设置信息保存在config_inc.php中.如果某个选项在config_in ...

  8. 将MyEclipse项目导入到Eclipse中

    1.请首先确保你的eclipse是javaee版本的,或者已经安装wtp插件 2.然后修改eclipse工程下的.project文件: 3.在<natures></natures&g ...

  9. Coursera课程《大家的Python》中一些资料

    Printed copies of Python for Informatics are available for $10 or less from Amazon and $2 or less on ...

  10. 第十二章 ThreadPoolExecutor使用 + 工作机理 + 生命周期

    1.最基础的线程池ThreadPoolExecutor 使用方式: /** * ThreadPoolExecutor测试类 * 注意: * 1.ThreadPoolExecutor是一个线程池 * 2 ...