Remove print statements

Author: s7u4rt99

ps4/peggleclone/Models/Peg.swift

@@ -73,8 +73,6 @@ class Peg: PeggleObject {
 
     override func overlap(peggleObject: PeggleObject) -> Bool {
         if let peg = peggleObject as? Peg {
-            print("self.radius \(self.radius)")
-            print("peg.radius \(peg.radius)")
             return distanceSquared(peg: peg) <= (self.radius + peg.radius) * (self.radius + peg.radius)
         } else if let triangle = peggleObject as? TriangleBlock {
             return triangle.overlap(peggleObject: self)
@@ -128,7 +126,6 @@ class Peg: PeggleObject {
         && peg.center.yCoordinate <= (height - peg.radius)
     }
 
-    // TODO: refactor into own cannonball class
     override func spooked() {
         self.shadowRadius = 30.0
         self.shadow = .blue

ps4/peggleclone/Models/TriangleBlock.swift

@@ -96,9 +96,6 @@ class TriangleBlock: PeggleObject {
         if let peg = peggleObject as? Peg {
             return trianglePegOverlapCheck(peg: peg)
         } else if let triangle = peggleObject as? TriangleBlock {
-//            print("self \(self.base) \(self.height)")
-//            print("triangle \(triangle.base) \(triangle.height)")
-//            return triangleTriangleOverlapCheck(triangle: triangle)
             return trianglesIntersect(self, triangle)
         } else {
             return false

ps4/peggleclone/Music/MusicManager.swift

@@ -28,7 +28,7 @@ class MusicManager {
                 audioPlayer.prepareToPlay()
                 audioPlayer.play()
             } catch {
-                print(error)
+//                print(error)
             }
         }
     }
@@ -43,7 +43,7 @@ class MusicManager {
                 }
                 audioPlayer.play()
             } catch {
-                print(error)
+//                print(error)
             }
         }
     }

ps4/peggleclone/Persistance/StorageManager.swift

@@ -33,7 +33,6 @@ class StorageManager {
             fatalError("Unable to decode data")
         }
 
-        print(url)
         guard let persistanceLevels = try? decoder.decode([LevelPersistance].self, from: data) else {
             fatalError("Failed to decode JSON from data")
         }

ps4/peggleclone/SLGameEngine/PowerUpHandler.swift

@@ -17,14 +17,12 @@ class PowerUpHandler {
         if let spookyPeg = powerPeg as? SpookyPeg {
             if !spookyPeg.activated {
                 spookyBallsActivated += 1
-                print(spookyBallsActivated)
                 spookyPeg.setActivated()
             }
         } else if let kaboomPeg = powerPeg as? KaboomPeg {
             if !kaboomPeg.activated {
                 // find area of hit
                 for (key, value) in mappings where isWithinExplosionRadius(kaboomPeg: kaboomPeg, physicsBody: value) {
-                    // TODO: make peggleobject have a glow method?
                     if let peg = key as? Peg {
                         peg.glow()
                         value.setCollided()
@@ -72,7 +70,6 @@ class PowerUpHandler {
             cannonBallPhysicsBody
                 .setVelocity(newVelocity: cannonBallPhysicsBody.velocity.multiplyWithScalar(scalar: 0.5))
             spookyBallsActivated -= 1
-            print("used one spooky ball, \(spookyBallsActivated) left")
         }
     }
 

ps4/peggleclone/SLGameEngine/SLGameEngine.swift

@@ -11,6 +11,7 @@ import SwiftUI
 class SLGameEngine {
     private var physicsEngine = SLPhysicsWorld()
     private var mappings: [PeggleObject: SLPhysicsBody] = [:]
+    private var trianglesRemovedTemporarily: [TriangleBlock: SLPhysicsBody] = [:]
     private let msPerUpdate = TimeInterval(0.016)
     private var lag = 0.0
     private var previous: Date?
@@ -71,12 +72,10 @@ class SLGameEngine {
         mappings[bucket] = bucketPhysicsBody
         physicsObjects.append(bucketPhysicsBody)
         physicsEngine.load(physicsBodies: physicsObjects, canvasDimensions: canvasDimensions)
-        print(level.peggleObjects)
         addCannonBall()
-        guard let cannonBall = cannonBall else {
+        guard cannonBall != nil else {
             return
         }
-        print(cannonBall)
         if numOfOrangePegs == 0 {
             gameLogicDelegate.gameWin()
         }
@@ -91,11 +90,6 @@ class SLGameEngine {
         let cannonBall = Peg(color: PegState.cannonPeg, center: toPoint(point: middleOfTopScreen),
                              radius: Peg.pegMinRadiusRatio * canvasDimensions.width)
         self.cannonBall = cannonBall
-        guard let cannonBallCheck = self.cannonBall else {
-            print("failed to add")
-            return
-        }
-        print("cannon ball added \(cannonBallCheck)")
         gameDisplayDelegate.didAddCannonBall(cannonBall: cannonBall)
         self.mostRecentPosition = cannonBall.center
     }
@@ -134,20 +128,19 @@ class SLGameEngine {
         render(cannonBallCount: numberOfCannonBalls)
     }
 
-    private func handleCannonBallMovement(_ cannonBallCount: Int, _ currentCollisions: [Peg]) {
+    private func handleCannonBallMovement(_ cannonBallCount: Int, _ currentCollisions: [PeggleObject]) {
         guard let cannonBall = cannonBall,
               let cannonBallPhysicsBody = mappings[cannonBall],
               let gameDisplayDelegate = gameDisplayDelegate,
               let gameLogicDelegate = gameLogicDelegate else {
             return
         }
-
         let similarPositionLimit = 75
 
         if cannonBallCount == 0 {
             cannonBallPhysicsBody.ignore()
             mappings.removeValue(forKey: cannonBall)
-            gameDisplayDelegate.didRemove(peg: cannonBall)
+            gameDisplayDelegate.didRemove(peggleObject: cannonBall)
             if cannonBallInBucket {
                 numOfCannonBallsLeft += 1
                 gameLogicDelegate.addCannonball()
@@ -158,13 +151,17 @@ class SLGameEngine {
         } else {
             if isCannonBallSamePosition() {
                 if similarPositionCounter > similarPositionLimit {
-                    for peg in currentCollisions {
-                        guard let pegInTouch = mappings[peg] else {
+                    for peggleObject in currentCollisions {
+                        guard let peggleObjInTouch = mappings[peggleObject] else {
                             continue
                         }
-                        if pegInTouch.hasCollided {
-                            pegInTouch.ignore()
-                            gameDisplayDelegate.didRemove(peg: peg)
+                        if peggleObjInTouch.hasCollided {
+                            peggleObjInTouch.ignore()
+                            gameDisplayDelegate.didRemove(peggleObject: peggleObject)
+                            if let triangle = peggleObject as? TriangleBlock {
+                                // handle them -> put in an array or whatever
+                                trianglesRemovedTemporarily[triangle] = peggleObjInTouch
+                            }
                         }
                     }
                 } else {
@@ -206,12 +203,9 @@ class SLGameEngine {
         moveCannonBall(cannonBall, cannonBallPhysicsBody, gameDisplayDelegate)
 
         let collisions = cannonBallPhysicsBody.collisionsWith
-        let currentCollisions = handleCollisions(collisions,
-                                                 gameDisplayDelegate,
-                                                 gameLogicDelegate,
-                                                 cannonBallCount,
-                                                 cannonBall)
+        let currentCollisions = handleCollisions(collisions, cannonBallCount)
 
+        checkCollidedTriangles()
         handleCannonBallMovement(cannonBallCount, currentCollisions)
 
         if numOfCannonBallsLeft == 0 && cannonBallCount == 0 {
@@ -224,17 +218,38 @@ class SLGameEngine {
         }
     }
 
+    private func checkCollidedTriangles() {
+        for (key, value) in trianglesRemovedTemporarily {
+            if !touchingCannonBall(value) {
+                gameDisplayDelegate?.didAdd(peggleObject: key)
+                mappings[key] = value
+                value.unignore()
+                trianglesRemovedTemporarily.removeValue(forKey: key)
+            }
+        }
+    }
+
+    private func touchingCannonBall(_ physicsBody: SLPhysicsBody) -> Bool {
+        guard let cannonBall = cannonBall, let cannonBallMapping = mappings[cannonBall] else {
+            return false
+        }
+        return cannonBallMapping.intersectWith(physicsBody: physicsBody)
+    }
+
     private func moveBucket(
         _ bucket: Bucket, _ bucketPhysicsBody: SLPhysicsBody, _ gameDisplayDelegate: GameDisplayDelegate) {
         bucket.center = bucketPhysicsBody.position
         gameDisplayDelegate.didMove(peggleObject: bucket, newLocation: bucketPhysicsBody.position)
     }
 
-    private func handleCollisions(
-        _ collisions: [SLPhysicsBody], _ gameDisplayDelegate: GameDisplayDelegate,
-        _ gameLogicDelegate: GameLogicDelegate,
-        _ cannonBallCount: Int, _ cannonBall: Peg) -> [Peg] {
-        var currentCollisions: [Peg] = []
+    private func handleCollisions(_ collisions: [SLPhysicsBody], _ cannonBallCount: Int) -> [PeggleObject] {
+        guard let gameLogicDelegate = gameLogicDelegate,
+              let gameDisplayDelegate = gameDisplayDelegate,
+              let cannonBall = cannonBall else {
+            return []
+        }
+
+        var currentCollisions: [PeggleObject] = []
 
         for (key, value) in mappings where value.hasCollided {
             if let peg = key as? Peg {
@@ -246,8 +261,8 @@ class SLGameEngine {
                     powerUpHandler.handlePowerUp(powerPeg: peg, mappings: mappings,
                                                  cannonBall: cannonBall, gameDisplayDelegate: gameDisplayDelegate)
                 }
-                if cannonBallCount == 0 {
-                    gameDisplayDelegate.didRemove(peg: peg)
+                if cannonBallCount == 0 && peg != cannonBall {
+                    gameDisplayDelegate.didRemove(peggleObject: peg)
                     mappings.removeValue(forKey: peg)
                     if peg.color != cannonBall.color {
                         gameLogicDelegate.didAddPoints(peg.points)
@@ -261,6 +276,10 @@ class SLGameEngine {
                         }
                     }
                 }
+            } else if let triangle = key as? TriangleBlock {
+                if contains(arr: collisions, physicsBody: value) {
+                    currentCollisions.append(triangle)
+                }
             }
         }
 
@@ -320,20 +339,15 @@ class SLGameEngine {
     }
 
     func fireCannonBall(directionOf: Point) -> Bool {
-        print("fire cannon ball")
         guard let cannonBall = cannonBall else {
-            print("no cannon ball")
             return false
         }
 
         if mappings[cannonBall] != nil {
-            print("no cannon ball mapping")
             return false
         }
 
-        print("fired cannon ball")
         self.numOfCannonBallsLeft -= 1
-        print(numOfCannonBallsLeft)
         var modifiedDirection = directionOf
         if directionOf.yCoordinate < cannonBall.center.yCoordinate {
             modifiedDirection = Point(xCoordinate: directionOf.xCoordinate,

ps4/peggleclone/SLPhysicsEngine/SLPhysicsBody.swift

@@ -45,4 +45,6 @@ protocol SLPhysicsBody {
     func clearCollisionsWith()
 
     func addForceToVelocity(force: Vector)
+
+    func unignore()
 }

ps4/peggleclone/SLPhysicsEngine/SLPhysicsBucket.swift

@@ -113,4 +113,8 @@ class SLPhysicsBucket: SLPhysicsBody {
     func addForceToVelocity(force: Vector) {
         // do nothing
     }
+
+    func unignore() {
+        self.canIgnore = false
+    }
 }

ps4/peggleclone/SLPhysicsEngine/SLPhysicsCircle.swift

@@ -125,4 +125,8 @@ class SLPhysicsCircle: SLPhysicsBody {
     func containsPoint(_ point: Point) -> Bool {
         point.distanceFrom(point: position) <= radius
     }
+
+    func unignore() {
+        self.canIgnore = false
+    }
 }

ps4/peggleclone/SLPhysicsEngine/SLPhysicsCollision.swift

@@ -39,63 +39,24 @@ class SLPhysicsCollision {
     }
 
     private func resolveTriangleCircleCollision(triangle: SLPhysicsTriangle, circle: SLPhysicsCircle) {
-//        let collisionVector = Vector(xDirection: circle.position.xCoordinate
-//                                     - triangle.position.xCoordinate,
-//                                     yDirection: circle.position.yCoordinate
-//                                     - triangle.position.yCoordinate)
-//        let distance = 2 * max(triangle.width / 2, circle.radius)
-//        let collisionNormalVector = Vector(xDirection: collisionVector.xDirection / (distance),
-//                                           yDirection: collisionVector.yDirection / (distance))
-//        let relativeVelocity = triangle.velocity.subtract(vector: circle.velocity)
-//        let tempSpeed = (relativeVelocity.xDirection * collisionVector.xDirection +
-//                         relativeVelocity.yDirection * collisionVector.yDirection)
-//        let speedAfterScale = Double(tempSpeed) * speedScale
-//        let speedAfterRestitution = speedAfterScale * restitution
-//        if speedAfterRestitution >= 0 {
-//            triangle.forces.append(collisionNormalVector
-//                                        .multiplyWithScalar(scalar: -1 * speedAfterRestitution))
-//            circle.forces.append(collisionNormalVector
-//                                        .multiplyWithScalar(scalar: speedAfterRestitution))
-//        }
         var restitution = 0.85
         if circleIntersectTriangleVertices(triangle: triangle, circle: circle) {
             restitution = 0.95
             circle.setVelocity(newVelocity: circle.velocity.negate().multiplyWithScalar(scalar: restitution))
         } else if circleIntersectEdge(circle: circle, vertexOne: triangle.vertexOne, vertexTwo: triangle.vertexTwo) {
             // rebound counter clockwise
-//            let line = Vector(xDirection: triangle.vertexTwo.xCoordinate - triangle.vertexOne.xCoordinate,
-//                              yDirection: triangle.vertexTwo.yCoordinate - triangle.vertexOne.yCoordinate)
-//            let normal = Vector(xDirection: -line.yDirection, yDirection: line.xDirection)
-//            let normalUnitVector = normal.multiplyWithScalar(scalar: 1/normal.magnitude)
             let resultant = Vector(xDirection: -circle.velocity.yDirection,
                                    yDirection: circle.velocity.xDirection)
-//            let resultant = circle.velocity
-//                .subtract(vector: normalUnitVector
-//                            .multiplyWithScalar(scalar: 2 * circle.velocity.dotProductWith(vector: normalUnitVector)))
             circle.setVelocity(newVelocity: resultant.multiplyWithScalar(scalar: restitution))
         } else if circleIntersectEdge(circle: circle, vertexOne: triangle.vertexTwo, vertexTwo: triangle.vertexThree) {
             // rebound clockwise
-//            let line = Vector(xDirection: triangle.vertexThree.xCoordinate - triangle.vertexTwo.xCoordinate,
-//                              yDirection: triangle.vertexThree.yCoordinate - triangle.vertexTwo.yCoordinate)
-//            let normal = Vector(xDirection: line.yDirection, yDirection: -line.xDirection)
-//            let normalUnitVector = normal.multiplyWithScalar(scalar: 1/normal.magnitude)
             let resultant = Vector(xDirection: circle.velocity.yDirection,
                                    yDirection: -circle.velocity.xDirection)
-//            let resultant = circle.velocity
-//                .subtract(vector: normalUnitVector
-//                            .multiplyWithScalar(scalar: 2 * circle.velocity.dotProductWith(vector: normalUnitVector)))
             circle.setVelocity(newVelocity: resultant.multiplyWithScalar(scalar: restitution))
         } else if circleIntersectEdge(circle: circle, vertexOne: triangle.vertexThree, vertexTwo: triangle.vertexOne) {
             // rebound clockwise
-//            let line = Vector(xDirection: triangle.vertexOne.xCoordinate - triangle.vertexThree.xCoordinate,
-//                              yDirection: triangle.vertexOne.yCoordinate - triangle.vertexThree.yCoordinate)
-//            let normal = Vector(xDirection: line.yDirection, yDirection: -line.xDirection)
-//            let normalUnitVector = normal.multiplyWithScalar(scalar: 1/normal.magnitude)
             let resultant = Vector(xDirection: circle.velocity.yDirection,
                                    yDirection: -circle.velocity.xDirection)
-//            let resultant = circle.velocity
-//                .subtract(vector: normalUnitVector
-//                            .multiplyWithScalar(scalar: 2 * circle.velocity.dotProductWith(vector: normalUnitVector)))
             circle.setVelocity(newVelocity: resultant.multiplyWithScalar(scalar: restitution))
         }
     }