Badger: Version 1.0, 2016-09-13

First release

This sample demonstrates how to build a SceneKit-based game with advanced graphics.

Author: Lax

Badger/Badger.xcodeproj/project.pbxproj

@@ -0,0 +1,36 @@
+/*
+     Copyright (C) 2016 Apple Inc. All Rights Reserved.
+     See LICENSE.txt for this sample’s licensing information
+     
+     Abstract:
+     An extension on CAAnimation used to load animations from an SCNScene.
+ */
+
+import SceneKit
+
+// MARK: Core Animation
+
+extension CAAnimation {
+    class func animation(withSceneName name: String) -> CAAnimation {
+        guard let scene = SCNScene(named: name) else {
+            fatalError("Failed to find scene with name \(name).")
+        }
+        
+        var animation: CAAnimation?
+        scene.rootNode.enumerateChildNodes { (child, stop) in
+            guard let firstKey = child.animationKeys.first else { return }
+            animation = child.animation(forKey: firstKey)
+            stop.initialize(to: true)
+        }
+        
+        guard let foundAnimation = animation else {
+            fatalError("Failed to find animation named \(name).")
+        }
+        
+        foundAnimation.fadeInDuration = 0.3
+        foundAnimation.fadeOutDuration = 0.3
+        foundAnimation.repeatCount = 1
+        
+        return foundAnimation
+    }
+}

Badger/Common/CAAnimation+SceneName.swift

@@ -0,0 +1,106 @@
+/*
+     Copyright (C) 2016 Apple Inc. All Rights Reserved.
+     See LICENSE.txt for this sample’s licensing information
+     
+     Abstract:
+     An SCNView used to relay keyboard controls on OSX, and present
+                 setup the 2D overlay.
+ */
+
+import GameKit
+
+class View: SCNView {
+
+    // MARK: Mouse and Keyboard Events
+    
+    #if os(OSX)
+    var eventsDelegate: KeyboardEventsDelegate?
+    
+    override func keyDown(with event: NSEvent) {
+        guard let eventsDelegate = eventsDelegate, eventsDelegate.keyDown(in: self, with: event) else {
+            super.keyDown(with: event)
+            return
+        }
+    }
+    
+    override func keyUp(with event: NSEvent) {
+        guard let eventsDelegate = eventsDelegate, eventsDelegate.keyUp(in: self, with: event) else {
+            super.keyUp(with: event)
+            return
+        }
+    }
+    #endif
+    
+    // Resizing
+    
+    #if os(iOS) || os(tvOS)
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        update2DOverlays()
+    }
+    #elseif os(OSX)
+    override func setFrameSize(_ newSize: NSSize) {
+        super.setFrameSize(newSize)
+        update2DOverlays()
+    }
+    #endif
+
+    // MARK: Overlays
+    
+    private let _overlayNode = SKNode()
+    private let _scaleNode = SKNode()
+    private let _collectedItemsCountLabel = SKLabelNode(fontNamed: "Superclarendon")
+    
+    private func update2DOverlays() {
+        _overlayNode.position = CGPoint(x: 0.0, y: bounds.size.height)
+    }
+    
+    func setup2DOverlay() {
+        let w = bounds.size.width
+        let h = bounds.size.height
+        
+        // Setup the game overlays using SpriteKit.
+        let skScene = SKScene(size: CGSize(width: w, height: h))
+        skScene.scaleMode = .resizeFill
+        
+        skScene.addChild(_scaleNode)
+        _scaleNode.addChild(_overlayNode)
+        _overlayNode.position = CGPoint(x: 0.0, y: h)
+        
+        #if os(OSX)
+        _scaleNode.xScale = layer!.contentsScale
+        _scaleNode.yScale = layer!.contentsScale
+        #endif
+
+        // The Bob icon.
+        let bobSprite = SKSpriteNode(imageNamed: "BobHUD.png")
+        bobSprite.position = CGPoint(x: 70, y:-50)
+        bobSprite.xScale = 0.5
+        bobSprite.yScale = 0.5
+        _overlayNode.addChild(bobSprite)
+        
+        _collectedItemsCountLabel.text = "x0"
+        _collectedItemsCountLabel.horizontalAlignmentMode = .left
+        _collectedItemsCountLabel.position = CGPoint(x: 135, y:-63)
+        _overlayNode.addChild(_collectedItemsCountLabel)
+        
+        // Assign the SpriteKit overlay to the SceneKit view.
+        self.overlaySKScene = skScene
+        skScene.isUserInteractionEnabled = false
+    }
+    
+    var collectedItemsCount = 0 {
+        didSet {
+            _collectedItemsCountLabel.text = "x\(collectedItemsCount)"
+        }
+    }
+    
+    func didCollectItem() {
+        collectedItemsCount = collectedItemsCount + 1
+    }
+    
+    func didCollectBigItem() {
+        collectedItemsCount = collectedItemsCount + 10
+    }
+    
+}

Badger/Common/View.swift

@@ -0,0 +1,127 @@
+/*
+    Copyright (C) 2016 Apple Inc. All Rights Reserved.
+    See LICENSE.txt for this sample’s licensing information
+    
+    Abstract:
+    Handles keyboard (macOS), touch (iOS) and controller (iOS, tvOS) input for controlling the game.
+*/
+
+import GameKit
+
+#if os(OSX)
+protocol KeyboardEventsDelegate {
+    func keyDown(in view: NSView, with event: NSEvent) -> Bool
+    func keyUp(in view: NSView, with event: NSEvent) -> Bool
+}
+    
+private enum KeyboardDirection: UInt16 {
+    case left   = 123
+    case right  = 124
+    case down   = 125
+    case up     = 126
+}
+    
+extension ViewController: KeyboardEventsDelegate {}
+#endif
+
+extension ViewController {
+    
+    // MARK: Game Controller Events
+
+    func setupGameControllers() {
+        #if os(OSX)
+        sceneView.eventsDelegate = self
+        #endif
+        
+        #if os(iOS) || os(tvOS)
+        // Gesture recognizers
+        let directions: [UISwipeGestureRecognizerDirection] = [.right, .left, .up, .down]
+        for direction in directions {
+            let gesture = UISwipeGestureRecognizer(target: self, action: #selector(didSwipe))
+            gesture.direction = direction
+            sceneView.addGestureRecognizer(gesture)
+        }
+        #endif
+    }
+    
+    @objc func handleControllerDidConnectNotification(_ notification: NSNotification) {
+        let gameController = notification.object as! GCController
+        registerCharacterMovementEvents(gameController)
+    }
+
+    private func registerCharacterMovementEvents(_ gameController: GCController) {
+        // An analog movement handler for D-pads and thumbsticks.
+        let movementHandler: GCControllerDirectionPadValueChangedHandler = { [unowned self] dpad, _, _ in
+            self.controllerDPad = dpad
+        }
+        
+        #if os(tvOS)
+            
+        // Apple TV remote
+        if let microGamepad = gameController.microGamepad {
+            // Allow the gamepad to handle transposing D-pad values when rotating the controller.
+            microGamepad.allowsRotation = true
+            microGamepad.dpad.valueChangedHandler = movementHandler
+        }
+            
+        #endif
+        
+        // Gamepad D-pad
+        if let gamepad = gameController.gamepad {
+            gamepad.dpad.valueChangedHandler = movementHandler
+        }
+        
+        // Extended gamepad left thumbstick
+        if let extendedGamepad = gameController.extendedGamepad {
+            extendedGamepad.leftThumbstick.valueChangedHandler = movementHandler
+        }
+    }
+    
+    // MARK: Touch Events
+    
+    #if os(iOS) || os(tvOS)
+    func didSwipe(sender: UISwipeGestureRecognizer) {
+        if startGameIfNeeded() {
+            return
+        }
+    
+        switch sender.direction {
+            case UISwipeGestureRecognizerDirection.up: jump()
+            case UISwipeGestureRecognizerDirection.down: squat()
+            case UISwipeGestureRecognizerDirection.left: leanLeft()
+            case UISwipeGestureRecognizerDirection.right: leanRight()
+            default: break
+        }
+    }
+    #endif
+    
+    // MARK: Keyboard Events
+    
+    #if os(OSX)
+    func keyDown(in view: NSView, with event: NSEvent) -> Bool {
+        if event.isARepeat {
+            return true
+        }
+        
+        if startGameIfNeeded() {
+            return true
+        }
+
+        if let direction = KeyboardDirection(rawValue: event.keyCode) {
+            switch direction {
+                case .up: jump()
+                case .down: squat()
+                case .left: leanLeft()
+                case .right: leanRight()
+            }
+            return true
+        }
+        return false
+    }
+    
+    func keyUp(in view: NSView, with event: NSEvent) -> Bool {
+        let direction = KeyboardDirection(rawValue: event.keyCode)
+        return direction != nil ? true : false
+    }
+    #endif
+}