DemoBots/Nodes/ThumbStickNode.swift

/*
    Copyright (C) 2016 Apple Inc. All Rights Reserved.
    See LICENSE.txt for this sample’s licensing information
    
    Abstract:
    An iOS-specific `SKSpriteNode` subclass used to provide the on-screen thumbsticks that enable player control.
*/
 
import SpriteKit
 
/// Relay control events though `ThumbStickNodeDelegate`.
protocol ThumbStickNodeDelegate: class {
    /// Called when `touchPad` is moved. Values are normalized between [-1.0, 1.0].
    func thumbStickNode(thumbStickNode: ThumbStickNode, didUpdateXValue xValue: Float, yValue: Float)
    
    /// Called to indicate when the `touchPad` is initially pressed, and when it is released.
    func thumbStickNode(thumbStickNode: ThumbStickNode, isPressed: Bool)
}
 
/// Touch representation of a classic analog stick.
class ThumbStickNode: SKSpriteNode {
    // MARK: Properties 
    
    /// The actual thumb pad that moves with touch.
    var touchPad: SKSpriteNode
    
    weak var delegate: ThumbStickNodeDelegate?
    
    /// The center point of this `ThumbStickNode`.
    let center: CGPoint
    
    /// The distance that `touchPad` can move from the `touchPadAnchorPoint`.
    let trackingDistance: CGFloat
    
    /// Styling settings for the thumbstick's nodes.
    let normalAlpha: CGFloat = 0.3
    let selectedAlpha: CGFloat = 0.5
    
    override var alpha: CGFloat {
        didSet {
            touchPad.alpha = alpha
        }
    }
    
    // MARK: Initialization
    
    init(size: CGSize) {
        trackingDistance = size.width / 2
        
        let touchPadLength = size.width / 2.2
        center = CGPoint(x: size.width / 2 - touchPadLength, y: size.height / 2 - touchPadLength)
        
        let touchPadSize = CGSize(width: touchPadLength, height: touchPadLength)
        let touchPadTexture = SKTexture(imageNamed: "ControlPad")
        
        // `touchPad` is the inner touch pad that follows the user's thumb.
        touchPad = SKSpriteNode(texture: touchPadTexture, color: UIColor.clear, size: touchPadSize)
        
        super.init(texture: touchPadTexture, color: UIColor.clear, size: size)
 
        alpha = normalAlpha
        
        addChild(touchPad)
    }
 
    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
 
    // MARK: UIResponder
    
    override var canBecomeFirstResponder: Bool {
        return true
    }
    
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        super.touchesBegan(touches, with: event)
        // Highlight that the control is being used by adjusting the alpha.
        alpha = selectedAlpha
        
        // Inform the delegate that the control is being pressed.
        delegate?.thumbStickNode(thumbStickNode: self, isPressed: true)
    }
    
    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
        super.touchesMoved(touches, with: event)
        
        // For each touch, calculate the movement of the touchPad.
        for touch in touches {
            let touchLocation = touch.location(in: self)
            
            var dx = touchLocation.x - center.x
            var dy = touchLocation.y - center.y
            
            // Calculate the distance from the `touchPadAnchorPoint` to the current location.
            let distance = hypot(dx, dy)
            
            /*
                If the distance is greater than our allowed `trackingDistance`,
                create a unit vector and multiply by max displacement
                (`trackingDistance`).
            */
            if distance > trackingDistance {
                dx = (dx / distance) * trackingDistance
                dy = (dy / distance) * trackingDistance
            }
            
            // Position the touchPad to match the touch's movement.
            touchPad.position = CGPoint(x: center.x + dx, y: center.y + dy)
            
            // Normalize the displacements between [-1.0, 1.0].
            let normalizedDx = Float(dx / trackingDistance)
            let normalizedDy = Float(dy / trackingDistance)
            delegate?.thumbStickNode(thumbStickNode: self, didUpdateXValue: normalizedDx, yValue: normalizedDy)
        }
    }
    
    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
        super.touchesEnded(touches, with: event)
        
        // If the touches set is empty, return immediately.
        guard !touches.isEmpty else { return }
        
        resetTouchPad()
   }
    
    override func touchesCancelled(_ touches: Set<UITouch>?, with event: UIEvent?) {
        super.touchesCancelled(touches!, with: event)
        resetTouchPad()
    }
    
    /// When touches end, reset the `touchPad` to the center of the control.
    func resetTouchPad() {
        alpha = normalAlpha
        
        let restoreToCenter = SKAction.move(to: CGPoint.zero, duration: 0.2)
        touchPad.run(restoreToCenter)
        
        delegate?.thumbStickNode(thumbStickNode: self, isPressed: false)
        delegate?.thumbStickNode(thumbStickNode: self, didUpdateXValue: 0, yValue: 0)
    }
}