optimize and reformat

Author: iplanetcn

Sources/CherrystudiosGameKit/Array+Extensions.swift

@@ -0,0 +1,22 @@
+//
+//  Array+Extensions.swift
+//  CherrystudiosGameKit
+//
+import CoreGraphics
+
+extension Array where Element == CGVector {
+    /// Calculate the average of the giving vectors
+    func average() -> CGVector {
+        guard !isEmpty else {
+            return .zero
+        }
+
+        let count = CGFloat(self.count)
+
+        let sum = reduce(CGVector.zero) { result, vector in
+            CGVector(dx: result.dx + vector.dx, dy: result.dy + vector.dy)
+        }
+
+        return CGVector(dx: sum.dx / count, dy: sum.dy / count)
+    }
+}

Sources/CherrystudiosGameKit/CGFloat+Extensions.swift

@@ -5,16 +5,17 @@ let π = CGFloat(Double.pi)
 
 public extension CGFloat {
     // MARK: - Normal Methods
+
     /// 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
@@ -26,41 +27,45 @@ public extension CGFloat {
     func sign() -> CGFloat {
         return (self >= 0.0) ? 1.0 : -1.0
     }
-    
+
     // MARK: - Mutating Methods
+
     /// Ensures that the float value stays between the given values, inclusive.
-    mutating func clamp(_ v1: CGFloat, _ v2: CGFloat) -> CGFloat {
+    @discardableResult
+    mutating func clamp(_ v1: CGFloat, _ v2: CGFloat) -> Self {
         self = clamped(v1, v2)
         return self
     }
-    
+
     // MARK: - Static Methods
+
     /// 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)
+        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
     }
 }
 
 // MARK: - Associated Functions
+
 /// 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 >= π) {
+    if angle >= π {
         angle = angle - twoπ
     }
-    if (angle <= -π) {
+    if angle <= -π {
         angle = angle + twoπ
     }
     return angle

Sources/CherrystudiosGameKit/CGPoint+Extensions.swift

@@ -3,13 +3,15 @@ import SpriteKit
 
 public extension CGPoint {
     // MARK: - Computed Property
+
     /// Returns the angle in radians of the vector described by the CGPoint.
     /// The range of the angle is -π to π; an angle of 0 points to the right.
     var angle: CGFloat {
         return atan2(y, x)
     }
 
     // MARK: - Initializers
+
     /// Creates a new CGPoint given a CGVector.
     init(vector: CGVector) {
         self.init(x: vector.dx, y: vector.dy)
@@ -22,20 +24,24 @@ public extension CGPoint {
     }
 
     // MARK: - Mutating Methods
+
     /// Normalizes the vector described by the CGPoint to length 1.0.
-    mutating func normalize() -> CGPoint {
+    @discardableResult
+    mutating func normalize() -> Self {
         self = normalized()
         return self
     }
 
     /// Adds (dx, dy) to the point.
-    mutating func offset(dx: CGFloat, dy: CGFloat) -> CGPoint {
+    @discardableResult
+    mutating func offset(dx: CGFloat, dy: CGFloat) -> Self {
         x += dx
         y += dy
         return self
     }
 
     // MARK: - Normal Methods
+
     /// Returns the length (magnitude) of the vector described by the CGPoint.
     func length() -> CGFloat {
         return sqrt(x * x + y * y)
@@ -57,10 +63,10 @@ public extension CGPoint {
     func distanceTo(_ point: CGPoint) -> CGFloat {
         return (self - point).length()
     }
-
 }
 
 // MARK: - Associated Functions
+
 /// Adds two CGPoint values and returns the result as a new CGPoint.
 public func + (left: CGPoint, right: CGPoint) -> CGPoint {
     return CGPoint(x: left.x + right.x, y: left.y + right.y)

Sources/CherrystudiosGameKit/CGVector+Extensions.swift

@@ -3,12 +3,14 @@ import SpriteKit
 
 public extension CGVector {
     // MARK: - Computed Property
+
     /// 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)
     }
-    
+
     // MARK: - Initializers
+
     /// Creates a new CGVector given a CGPoint.
     init(point: CGPoint) {
         self.init(dx: point.x, dy: point.y)
@@ -20,57 +22,68 @@ public extension CGVector {
     }
 
     // MARK: - Mutating Methods
+
     // Adds (dx, dy) to the vector.
-    mutating func offset(dx: CGFloat, dy: CGFloat) -> CGVector {
+    @discardableResult
+    mutating func offset(dx: CGFloat, dy: CGFloat) -> Self {
         self.dx += dx
         self.dy += dy
         return self
     }
 
     /// Normalizes the vector described by the CGVector to length 1.0.
-    mutating func normalize() -> CGVector {
+    @discardableResult
+    mutating func normalize() -> Self {
         self = normalized()
         return self
     }
 
-    mutating func setMag(_ mag: CGFloat) {
-        let normalizedVector = normalized()
-        self = CGVector(dx: normalizedVector.dx * mag, dy: normalizedVector.dy * mag)
+    /// Set Vector's Magnititude
+    @discardableResult
+    mutating func setMag(_ mag: CGFloat) -> Self {
+        let normal = normalized()
+        self = CGVector(dx: normal.dx * mag, dy: normal.dy * mag)
+        return self
     }
-    
-    mutating func div(_ mag: CGFloat) {
-        if mag == 0 {
-            return
+
+    /// Calculate average vector into N
+    @discardableResult
+    mutating func div(_ n: CGFloat) -> Self {
+        if n == 0 {
+            return self
         }
-        
-        self = CGVector(dx: self.dx/mag, dy: dy/mag)
-    }
-    
-    mutating func limit(_ mag: CGFloat) {
-        let currentMag = sqrt(dx * dx + dy * dy)
-        if currentMag > mag {
-            let ratio = mag / currentMag
+        self = CGVector(dx: dx / n, dy: dy / n)
+        return self
+    }
+
+    /// Limit the vector's length
+    @discardableResult
+    mutating func limit(_ length: CGFloat) -> Self {
+        let len = self.length()
+        if len > length {
+            let ratio = length / len
             self = CGVector(dx: dx * ratio, dy: dy * ratio)
         }
+
+        return self
     }
 
-    mutating func add(_ vector: CGVector) {
+    /// Add a vector to self
+    @discardableResult
+    mutating func add(_ vector: CGVector) -> Self {
         self = CGVector(dx: dx + vector.dx, dy: dy + vector.dy)
+        return self
     }
-    
-    mutating func sub(_ vector: CGVector) {
+
+    /// Subtraction a vector from self
+    @discardableResult
+    mutating func sub(_ vector: CGVector) -> Self {
         self = CGVector(dx: dx - vector.dx, dy: dy - vector.dy)
-    }
-    
-    static func add(_ a:CGVector, _ b: CGVector) -> CGVector {
-        return CGVector(dx: a.dx + b.dx, dy: a.dy + b.dy)
-    }
-    
-    static func sub(_ a:CGVector, _ b: CGVector) -> CGVector {
-        return CGVector(dx: a.dx - b.dx, dy: a.dy - b.dy)
+        return self
     }
 
     // MARK: - Normal Methods
+
     /// Returns a copy of the vector.
     func copy() -> CGVector {
         return CGVector(dx: dx, dy: dy)
@@ -97,10 +110,21 @@ public extension CGVector {
         return (self - vector).length()
     }
 
-    // MARK: - Static Methods
+    // MARK: - Static Methods, those methods can be replaced with opertator functions
+
+    /// Calculates the Sum of two vectors
+    static func add(_ a: CGVector, _ b: CGVector) -> CGVector {
+        return CGVector(dx: a.dx + b.dx, dy: a.dy + b.dy)
+    }
+
+    /// Calculate the Subtraction of two vectors
+    static func sub(_ a: CGVector, _ b: CGVector) -> CGVector {
+        return CGVector(dx: a.dx - b.dx, dy: a.dy - b.dy)
+    }
 }
 
 // MARK: - Associated Functions
+
 /// 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)

Sources/CherrystudiosGameKit/Int+Extensions.swift

@@ -2,60 +2,66 @@ import CoreGraphics
 
 public extension Int {
     // MARK: - Normal Methods
+
     /// 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)
+        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)
+        return (self < range.lowerBound) ? range.lowerBound : ((self > range.upperBound) ? range.upperBound : self)
     }
-    
+
     // MARK: - Mutating Methods
+
     /// Ensures that the integer value stays with the specified range.
-    mutating func clamp(_ range: Range<Int>) -> Int {
+    @discardableResult
+    mutating func clamp(_ range: Range<Int>) -> Self {
         self = clamped(range)
         return self
     }
-    
-    mutating func clamp(_ range: ClosedRange<Int>) -> Int {
+
+    @discardableResult
+    mutating func clamp(_ range: ClosedRange<Int>) -> Self {
         self = clamped(range)
         return self
     }
-    
+
     /// Ensures that the integer value stays between the given values, inclusive.
-    mutating func clamp(_ v1: Int, _ v2: Int) -> Int {
+    @discardableResult
+    mutating func clamp(_ v1: Int, _ v2: Int) -> Self {
         self = clamped(v1, v2)
         return self
     }
 
     // MARK: - Normal Methods
+
     /// 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)
     }
 
-    // MARK: - Static Methods    
+    // MARK: - Static Methods
+
     /// 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
     }
-
-}
+}