add more extensions and tools

Author: iplanetcn

Sources/CherrystudiosGameKit/CGFloat+Extensions.swift

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2013-2014 Razeware LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+import CoreGraphics
+
+/** The value of π as a CGFloat */
+let π = CGFloat(Double.pi)
+
+public extension CGFloat {
+    /**
+     * Converts an angle in degrees to radians.
+     */
+    func degreesToRadians() -> CGFloat {
+        return π * self / 180.0
+    }
+    
+    /**
+     * Converts an angle in radians to degrees.
+     */
+    func radiansToDegrees() -> CGFloat {
+        return self * 180.0 / π
+    }
+    
+    /**
+     * Ensures that the float value stays between the given values, inclusive.
+     */
+    func clamped(_ v1: CGFloat, _ v2: CGFloat) -> CGFloat {
+        let min = v1 < v2 ? v1 : v2
+        let max = v1 > v2 ? v1 : v2
+        return self < min ? min : (self > max ? max : self)
+    }
+    
+    /**
+     * Ensures that the float value stays between the given values, inclusive.
+     */
+    mutating func clamp(_ v1: CGFloat, _ v2: CGFloat) -> CGFloat {
+        self = clamped(v1, v2)
+        return self
+    }
+    
+    /**
+     * Returns 1.0 if a floating point value is positive; -1.0 if it is negative.
+     */
+    func sign() -> CGFloat {
+        return (self >= 0.0) ? 1.0 : -1.0
+    }
+    
+    /**
+     * Returns a random floating point number between 0.0 and 1.0, inclusive.
+     */
+    static func random() -> CGFloat {
+        return CGFloat.random(in: 0.0...1.0)
+    }
+    
+    /**
+     * Returns a random floating point number in the range min...max, inclusive.
+     */
+    static func random(min: CGFloat, max: CGFloat) -> CGFloat {
+        assert(min < max)
+        return CGFloat.random() * (max - min) + min
+    }
+    
+    /**
+     * Randomly returns either 1.0 or -1.0.
+     */
+    static func randomSign() -> CGFloat {
+        return (arc4random_uniform(2) == 0) ? 1.0 : -1.0
+    }
+}
+
+/**
+ * Returns the shortest angle between two angles. The result is always between
+ * -π and π.
+ */
+public func shortestAngleBetween(_ angle1: CGFloat, angle2: CGFloat) -> CGFloat {
+    let twoπ = π * 2.0
+    var angle = (angle2 - angle1).truncatingRemainder(dividingBy: twoπ)
+    if (angle >= π) {
+        angle = angle - twoπ
+    }
+    if (angle <= -π) {
+        angle = angle + twoπ
+    }
+    return angle
+}

Sources/CherrystudiosGameKit/CGVector+Extensions.swift

@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2013-2014 Razeware LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+import CoreGraphics
+import SpriteKit
+
+public extension CGVector {
+    /**
+     * Creates a new CGVector given a CGPoint.
+     */
+    init(point: CGPoint) {
+        self.init(dx: point.x, dy: point.y)
+    }
+    
+    /**
+     * Given an angle in radians, creates a vector of length 1.0 and returns the
+     * result as a new CGVector. An angle of 0 is assumed to point to the right.
+     */
+    init(angle: CGFloat) {
+        self.init(dx: cos(angle), dy: sin(angle))
+    }
+    
+    /**
+     * Adds (dx, dy) to the vector.
+     */
+    mutating func offset(dx: CGFloat, dy: CGFloat) -> CGVector {
+        self.dx += dx
+        self.dy += dy
+        return self
+    }
+    
+    /**
+     * Returns the length (magnitude) of the vector described by the CGVector.
+     */
+    func length() -> CGFloat {
+        return sqrt(dx*dx + dy*dy)
+    }
+    
+    /**
+     * Returns the squared length of the vector described by the CGVector.
+     */
+    func lengthSquared() -> CGFloat {
+        return dx*dx + dy*dy
+    }
+    
+    /**
+     * Normalizes the vector described by the CGVector to length 1.0 and returns
+     * the result as a new CGVector.
+     public  */
+    func normalized() -> CGVector {
+        let len = length()
+        return len>0 ? self / len : CGVector.zero
+    }
+    
+    /**
+     * Normalizes the vector described by the CGVector to length 1.0.
+     */
+    mutating func normalize() -> CGVector {
+        self = normalized()
+        return self
+    }
+    
+    /**
+     * Calculates the distance between two CGVectors. Pythagoras!
+     */
+    func distanceTo(_ vector: CGVector) -> CGFloat {
+        return (self - vector).length()
+    }
+    
+    /**
+     * Returns the angle in radians of the vector described by the CGVector.
+     * The range of the angle is -π to π; an angle of 0 points to the right.
+     */
+    var angle: CGFloat {
+        return atan2(dy, dx)
+    }
+}
+
+/**
+ * Adds two CGVector values and returns the result as a new CGVector.
+ */
+public func + (left: CGVector, right: CGVector) -> CGVector {
+    return CGVector(dx: left.dx + right.dx, dy: left.dy + right.dy)
+}
+
+/**
+ * Increments a CGVector with the value of another.
+ */
+public func += (left: inout CGVector, right: CGVector) {
+    left = left + right
+}
+
+/**
+ * Subtracts two CGVector values and returns the result as a new CGVector.
+ */
+public func - (left: CGVector, right: CGVector) -> CGVector {
+    return CGVector(dx: left.dx - right.dx, dy: left.dy - right.dy)
+}
+
+/**
+ * Decrements a CGVector with the value of another.
+ */
+public func -= (left: inout CGVector, right: CGVector) {
+    left = left - right
+}
+
+/**
+ * Multiplies two CGVector values and returns the result as a new CGVector.
+ */
+public func * (left: CGVector, right: CGVector) -> CGVector {
+    return CGVector(dx: left.dx * right.dx, dy: left.dy * right.dy)
+}
+
+/**
+ * Multiplies a CGVector with another.
+ */
+public func *= (left: inout CGVector, right: CGVector) {
+    left = left * right
+}
+
+/**
+ * Multiplies the x and y fields of a CGVector with the same scalar value and
+ * returns the result as a new CGVector.
+ */
+public func * (vector: CGVector, scalar: CGFloat) -> CGVector {
+    return CGVector(dx: vector.dx * scalar, dy: vector.dy * scalar)
+}
+
+/**
+ * Multiplies the x and y fields of a CGVector with the same scalar value.
+ */
+public func *= (vector: inout CGVector, scalar: CGFloat) {
+    vector = vector * scalar
+}
+
+/**
+ * Divides two CGVector values and returns the result as a new CGVector.
+ */
+public func / (left: CGVector, right: CGVector) -> CGVector {
+    return CGVector(dx: left.dx / right.dx, dy: left.dy / right.dy)
+}
+
+/**
+ * Divides a CGVector by another.
+ */
+public func /= (left: inout CGVector, right: CGVector) {
+    left = left / right
+}
+
+/**
+ * Divides the dx and dy fields of a CGVector by the same scalar value and
+ * returns the result as a new CGVector.
+ */
+public func / (vector: CGVector, scalar: CGFloat) -> CGVector {
+    return CGVector(dx: vector.dx / scalar, dy: vector.dy / scalar)
+}
+
+/**
+ * Divides the dx and dy fields of a CGVector by the same scalar value.
+ */
+public func /= (vector: inout CGVector, scalar: CGFloat) {
+    vector = vector / scalar
+}
+
+/**
+ * Performs a linear interpolation between two CGVector values.
+ */
+public func lerp(start: CGVector, end: CGVector, t: CGFloat) -> CGVector {
+    return start + (end - start) * t
+}

Sources/CherrystudiosGameKit/Int+Extensions.swift

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2013-2014 Razeware LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+import CoreGraphics
+
+public extension Int {
+    /**
+     * Ensures that the integer value stays with the specified range.
+     */
+    func clamped(_ range: Range<Int>) -> Int {
+        return (self < range.lowerBound) ? range.lowerBound : ((self >= range.upperBound) ? range.upperBound - 1: self)
+    }
+    
+    func clamped(_ range: ClosedRange<Int>) -> Int {
+        return (self < range.lowerBound) ? range.lowerBound : ((self > range.upperBound) ? range.upperBound: self)
+    }
+    
+    /**
+     * Ensures that the integer value stays with the specified range.
+     */
+    mutating func clamp(_ range: Range<Int>) -> Int {
+        self = clamped(range)
+        return self
+    }
+    
+    mutating func clamp(_ range: ClosedRange<Int>) -> Int {
+        self = clamped(range)
+        return self
+    }
+    
+    /**
+     * Ensures that the integer value stays between the given values, inclusive.
+     */
+    func clamped(_ v1: Int, _ v2: Int) -> Int {
+        let min = v1 < v2 ? v1 : v2
+        let max = v1 > v2 ? v1 : v2
+        return self < min ? min : (self > max ? max : self)
+    }
+    
+    /**
+     * Ensures that the integer value stays between the given values, inclusive.
+     */
+    mutating func clamp(_ v1: Int, _ v2: Int) -> Int {
+        self = clamped(v1, v2)
+        return self
+    }
+    
+    /**
+     * Returns a random integer in the specified range.
+     */
+    static func random(_ range: Range<Int>) -> Int {
+        return Int(arc4random_uniform(UInt32(range.upperBound - range.lowerBound - 1))) + range.lowerBound
+    }
+    
+    static func random(_ range: ClosedRange<Int>) -> Int {
+        return Int(arc4random_uniform(UInt32(range.upperBound - range.lowerBound))) + range.lowerBound
+    }
+    
+    /**
+     * Returns a random integer between 0 and n-1.
+     */
+    static func random(_ n: Int) -> Int {
+        return Int(arc4random_uniform(UInt32(n)))
+    }
+    
+    /**
+     * Returns a random integer in the range min...max, inclusive.
+     */
+    static func random(min: Int, max: Int) -> Int {
+        assert(min < max)
+        return Int(arc4random_uniform(UInt32(max - min + 1))) + min
+    }
+}