I have a shooter app that is crashing when the bullet hits two overlapping nodes. I've tried everything, I tried checking if the bodies were nil but it wouldnt allow me, I'm not sure how to make this work anymore. here's the code:
func didBeginContact(contact: SKPhysicsContact) {
var firstBody:SKPhysicsBody
var secondBody:SKPhysicsBody
if (contact.bodyA.categoryBitMask < contact.bodyB.categoryBitMask) {
firstBody = contact.bodyA
secondBody = contact.bodyB
}
else {
firstBody = contact.bodyB
secondBody = contact.bodyA
}
if ((firstBody.categoryBitMask & photonCategory) != 0 && (secondBody.categoryBitMask & alientCategory) != 0){
aliensCollideWithBullets(firstBody.node as! SKSpriteNode, alien: secondBody.node as! SKSpriteNode)
// firstBody.node?.removeFromParent()
// secondBody.node?.removeFromParent()
}
}
func aliensCollideWithBullets(torpedo:SKSpriteNode, alien:SKSpriteNode) {
print("hit")
torpedo.removeFromParent()
alien.removeFromParent()
aliensDestroyed++
trumpsDestroyedLabel.text = "\(aliensDestroyed) Trumps"
if (aliensDestroyed > 10) {
}
}
the line crashing is:
if ((firstBody.categoryBitMask & photonCategory) != 0 && (secondBody.categoryBitMask & alientCategory) != 0){
aliensCollideWithBullets(firstBody.node as! SKSpriteNode, alien: secondBody.node as! SKSpriteNode)
// firstBody.node?.removeFromParent()
// secondBody.node?.removeFromParent()
}
Any help is appreciated.
Check bodyA and bodyB for nil. I had the same issue and solved it with this line of code:
if contact.bodyA.node != nil && contact.bodyB.node != nil
Related
Not sure which part is the problem. I'm doing a spriteKit shooter game and the collision isn't working. The spaceships are not being destroyed.
It must have to do with the collision somewhere...
The projectiles are just moving the enemy over slightly but not destroying them.
struct physicsCategory {
static let player : UInt32 = 1
static let enemy : UInt32 = 2
static let projectile : UInt32 = 3
}
func didBeginContact(contact: SKPhysicsContact) {
let firstBody : SKPhysicsBody = contact.bodyA
let secondBody : SKPhysicsBody = contact.bodyB
if ((firstBody.categoryBitMask == physicsCategory.projectile) && (secondBody.categoryBitMask == physicsCategory.enemy) || (firstBody.categoryBitMask == physicsCategory.enemy) && (secondBody.categoryBitMask == physicsCategory.projectile)) {
projectileCollision(enemyTemp: firstBody.node as! SKSpriteNode, projectileTemp: secondBody.node as! SKSpriteNode)
}
if ((firstBody.categoryBitMask == physicsCategory.enemy) && (secondBody.categoryBitMask == physicsCategory.player) || (firstBody.categoryBitMask == physicsCategory.player) && (secondBody.categoryBitMask == physicsCategory.enemy)) {
enemyPlayerCollision(enemyTemp: firstBody.node as! SKSpriteNode, playerTemp: secondBody.node as! SKSpriteNode)
}
}
///////////
func projectileCollision(enemyTemp: SKSpriteNode, projectileTemp: SKSpriteNode){
enemy.removeFromParent()
projectile.removeFromParent()
score = score + 1
updateScore()
}
////////////
func enemyPlayerCollision(enemyTemp: SKSpriteNode, playerTemp: SKSpriteNode) {
mainLabel.fontSize = 50
mainLabel.alpha = 1.0
mainLabel.text = "Game Over"
player.removeFromParent()
isAlive = false
waitThenMoveToTiltleScreen()
}
Your first issue is static let projectile : UInt32 = 3
If you want to declare a unique bitMasks, it needs to be in a power of 2 (2^0,2^1,2^2,..etc)
What 3 really means, is your projectile is both a player and an enemy ( 1 = 2^0, 2 = 2^1)
Your second issue is your logic
let f = firstBody.categoryBitMask
let s = secondbody.categoryBitmask
let p = physicsCategory.projectile
let x = physicsCategory.player
let e = physicsCategory.enemy
This is your projectile if statements:
if ((f == p) && (s == e) || (f == e) && (s == p)) {
projectileCollision(enemyTemp: firstBody.node as! SKSpriteNode, projectileTemp: secondBody.node as! SKSpriteNode)
}
In your if statement, you are saying either first or second could be the enemy, but in your projectile collision method, you are claiming that first body is always the enemy, and second body is always the projectile.
You need to handle the condition where your first body is projectile, and your second body is enemy, because chances are, your projectile will move into enemy, so it would be the first body.
thanks ( sorry I'm fairly new to spriteKit) I'm nearly there I think as I've written this code below and it worked better.
just with one small problem! some of the projectiles just go through the enemys.and only some destroy.
func didBegin(_ contact: SKPhysicsContact) {
let firstBody : SKPhysicsBody = contact.bodyA
let secondBody : SKPhysicsBody = contact.bodyB
if ((firstBody.categoryBitMask == physicsCategory.enemy) && (secondBody.categoryBitMask == physicsCategory.projectile) || (firstBody.categoryBitMask == physicsCategory.projectile) && (secondBody.categoryBitMask == physicsCategory.enemy)) {
projectileCollision(enemy: firstBody.node as! SKSpriteNode, projectile: secondBody.node as! SKSpriteNode)
}
else if ((firstBody.categoryBitMask == physicsCategory.enemy) && (secondBody.categoryBitMask == physicsCategory.player) || (firstBody.categoryBitMask == physicsCategory.player) && (secondBody.categoryBitMask == physicsCategory.enemy)) {
enemyPlayerCollision(enemy: firstBody.node as! SKSpriteNode, person: secondBody.node as! SKSpriteNode)
}
}
///////////
func projectileCollision(enemy: SKSpriteNode, projectile: SKSpriteNode){
enemy.removeFromParent()
projectile.removeFromParent()
score = score + 1
updateScore()
}
////////////
func enemyPlayerCollision(enemy: SKSpriteNode, person: SKSpriteNode) {
mainLabel.fontSize = 50
mainLabel.alpha = 1.0
mainLabel.text = "Game Over"
person.removeFromParent()
enemy.removeFromParent()
isAlive = false
waitThenMoveToTiltleScreen()
}
I have two different types of collisions I want to detect in SpriteKit:
When ballOne hits goalOne and when ballTwo hits goalTwo:
So far I've added my different physics categories:
struct physicsCategory {
static let ballOne :UInt32 = 0x1 << 0
static let goalOne :UInt32 = 0x1 << 1
static let ballTwo :UInt32 = 0x1 << 2
static let goalTwo :UInt32 = 0x1 << 3
}
And here's the relevant parts of my class:
class gameScene: SKScene, SKPhysicsContactDelegate {
var borderBody:SKPhysicsBody!
var myscore:Int = 0
var opponentScore:Int = 10
override func sceneDidLoad() {
super.sceneDidLoad()
physicsWorld.contactDelegate = self
}
func didBegin(_ contact: SKPhysicsContact) {
let firstBody = contact.bodyA.node as! SKSpriteNode
let secondBody = contact.bodyB.node as! SKSpriteNode
if ((firstBody.name == "ballOne") && (secondBody.name == "goalOne")) {
collisionGoalOne(BallOne: firstBody, GoalOne: secondBody)
}
else {
}
}
func collisionGoalOne(BallOne: SKSpriteNode, GoalOne: SKSpriteNode) {
addScore()
}
override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
let touch = touches.first
let touchLocation = touch!.location(in: self)
let ballOne = childNode(withName: "ballOne") as! SKSpriteNode
ballOne.physicsBody?.categoryBitMask = physicsCategory.ballOne
ballOne.physicsBody?.collisionBitMask = physicsCategory.goalOne
ballOne.physicsBody?.contactTestBitMask = physicsCategory.goalOne
ballOne.physicsBody?.isDynamic = true
let goalOne = childNode(withName: "goalOne") as! SKSpriteNode
goalOne.physicsBody?.categoryBitMask = physicsCategory.goalOne
goalOne.physicsBody?.collisionBitMask = physicsCategory.ballOne
goalOne.physicsBody?.contactTestBitMask = physicsCategory.ballOne
goalOne.physicsBody?.isDynamic = false
}
}
Right now the app crashes when the ball collides with the wall on
let firstBody = contact.bodyA.node as! SKSpriteNode
with "Could not cast value of type 'appName.gameScene' (0x105320) to 'SKSpriteNode' (0x1877b5c)."
Would love to understand why this crash is happening and if this is even a good approach to collision handling. Thank you.
FirstBody might not be able to be cast to SKSpriteNode, so only create that variable after you check which nodes collide.
Note that ballOne could be either bodyA or bodyB so change your code to check for both possibilities.
I changed your code a bit. Hope this helps
if ((contact.bodyA.node?.name == "ballOne") && (contact.bodyB.node?.name == "goalOne")) {
let firstBody = contact.bodyA.node as! SKSpriteNode
let secondBody = contact.bodyB.node as! SKSpriteNode
collisionGoalOne(BallOne: firstBody, GoalOne: secondBody)
} else if ((contact.bodyA.node?.name == "goalOne") && (contact.bodyB.node?.name == "ballOne")) {
let firstBody = contact.bodyA.node as! SKSpriteNode
let secondBody = contact.bodyB.node as! SKSpriteNode
collisionGoalOne(BallOne: secondBody, GoalOne: firstBody)
}
I think there are a couple of changes you might want to make.
When your ball node contacts the wall, I believe your didBegin(_ contact: SKPhysicsContact) method is invoked with one body as the ball (SKNode) and the other body as the scene border (SKScene).
Forcing a cast of SKScene to SKSpriteNode with let firstBody = contact.bodyA.node as! SKSpriteNode crashes, as RT5754 points out.
To fix this you might consider the following:
Add a physics category for the wall/border. Something like:
static let sceneBorder :UInt32 = 0x1 << 4
Update the border and the ball nodes to have collision physics:
ballNode.physicsBody?.collisionBitMask = physicsCategory.sceneBorder
borderNode.physicsBody?.collisionBitMask = physicsCategory.ballOne + physicsCategory.ballTwo
When handling other contact logic, my pattern for
didBegin(_ contact: SKPhysicsContact)
is like this:
func didBegin(_ contact: SKPhysicsContact) {
var firstBody: SKPhysicsBody = contact.bodyA
var secondBody: SKPhysicsBody = contact.bodyB
//in did begin contact, order the bodies by physics category
if firstBody.categoryBitMask > secondBody.categoryBitMask {
let temp = secondBody
secondBody = firstBody
firstBody = temp
}
//logic to handle contact is based on physicsCategory
if secondBody.categoryBitMask == physicsCategory.whatever {
methodToHandleWhatever(thingOne: firstBody, thingTwo: secondBody)
}
I want to add a bunch of different rocks and other dangerous objects that the player can collide with and die. How would I do this effectively? Now if I would copy paste these functions, it would surely work. But it seems like a huge amount of unnecessary code.
Sidenote: I'm very new to xcode, swift 2 & Sprite-kit.
func didBeginContact(contact: SKPhysicsContact) {
let firstBody : SKPhysicsBody = contact.bodyA
let secondBody : SKPhysicsBody = contact.bodyB
if ((firstBody.categoryBitMask == PhysicsCategory.Rock) && (secondBody.categoryBitMask == PhysicsCategory.Bullet) || (firstBody.categoryBitMask == PhysicsCategory.Bullet) && (secondBody.categoryBitMask == PhysicsCategory.Rock)) {
CollisionWithBullet(firstBody.node as! SKSpriteNode, Bullet: secondBody.node as! SKSpriteNode)
}
if ((firstBody.categoryBitMask == PhysicsCategory.Rock) && (secondBody.categoryBitMask == PhysicsCategory.Player) || (firstBody.categoryBitMask == PhysicsCategory.Player) && (secondBody.categoryBitMask == PhysicsCategory.Rock)) {
CollisionWithPlayer(firstBody.node as! SKSpriteNode, Player: secondBody.node as! SKSpriteNode)
}
}
func CollisionWithPlayer(Rock: SKSpriteNode, Player: SKSpriteNode){
let ScoreDefault = NSUserDefaults.standardUserDefaults()
ScoreDefault.setValue(Score, forKey: "Score")
ScoreDefault.synchronize()
let HighscoreDefault = NSUserDefaults.standardUserDefaults()
if (HighscoreDefault.valueForKey("Highscore") != nil){
Highscore = HighscoreDefault.valueForKey("Highscore") as! NSInteger
} else {
Highscore = 0
}
if (Score > Highscore){
let HighscoreDefault = NSUserDefaults.standardUserDefaults()
HighscoreDefault.setValue(Score, forKey: "Highscore")
}
self.view?.presentScene(EndScene())
ScoreLabel.removeFromSuperview()
}
So what you're likely looking for here is the bitwise OR operator and the bitwise AND operator.
With SpriteKit, physicsBodies can have multiple categories assigned to them. For instance, if we have the following categories set up:
enum CollisionCategories : UInt32 {
case Player = 1
case Enemy = 2
case Rock = 4
case Bullet = 8
}
we can set up the player category and contact bitmasks as follows:
let player = SKSpriteNode(color: UIColor.blackColor(), size: CGSize(width: 50, height: 50))
player.physicsBody = SKPhysicsBody(rectangleOfSize: player.size)
player.physicsBody?.categoryBitMask = CollisionCategories.Player.rawValue
player.physicsBody?.contactTestBitMask = CollisionCategories.Enemy.rawValue
and two enemy category and contact bitmasks as follows:
let rockEnemy = SKSpriteNode(color: UIColor.greenColor(), size: CGSize(width: 25, height: 25))
rockEnemy.physicsBody = SKPhysicsBody(rectangleOfSize: rockEnemy.size)
rockEnemy.physicsBody?.categoryBitMask = CollisionCategories.Enemy.rawValue | CollisionCategories.Rock.rawValue
rockEnemy.physicsBody?.contactTestBitMask = CollisionCategories.Player.rawValue
let bulletEnemy = SKSpriteNode(color: UIColor.redColor(), size: CGSize(width: 25, height: 25))
bulletEnemy.physicsBody = SKPhysicsBody(rectangleOfSize: bulletEnemy.size)
bulletEnemy.physicsBody?.categoryBitMask = CollisionCategories.Enemy.rawValue | CollisionCategories.Bullet.rawValue
bulletEnemy.physicsBody?.contactTestBitMask = CollisionCategories.Player.rawValue
Notice that on setting the category bitmasks, I am using the bitwise OR operator ('|'). This is a nice way of setting the bitmasks to two different categories at the same time. This way, a sprite can be both a rock and an enemy or a bullet and an enemy, etc.
See the image below for an idea of what is happening bitwise under the hood.
In our contact detection function, we can use the bitwise AND operator ('&') to see if our contact possesses a certain category.
func didBeginContact(contact: SKPhysicsContact) {
let firstBody : SKPhysicsBody = contact.bodyA
let secondBody : SKPhysicsBody = contact.bodyB
if (firstBody.categoryBitMask & CollisionCategories.Player.rawValue == CollisionCategories.Player.rawValue &&
secondBody.categoryBitMask & CollisionCategories.Enemy.rawValue == CollisionCategories.Enemy.rawValue) {
print("The collision was between the Player and an Enemy")
}
else if (firstBody.categoryBitMask & CollisionCategories.Enemy.rawValue == CollisionCategories.Enemy.rawValue &&
secondBody.categoryBitMask & CollisionCategories.Player.rawValue == CollisionCategories.Player.rawValue) {
print("The collision was between the Player and an Enemy")
}
}
This way, you can have enemies with multiple categories, but you can always do one check to see if a node is in fact an enemy, regardless of what other categories they might possess.
I have two types of collision. First one is the spaceShip and asteroid (this is already handled) but I can't handle second type of collisions, where my spaceShipLazer hits enemySpaceShips. In second case I have drugging/multiple collisions or sometimes perfect collision.
My enemySpaceShip is an EnemySpaceShip class which is a subclass of SKSpriteNode.
So the question is about second collision. Is has multiple collisions that is not expected. How I can fix it?
func didBeginContact(contact: SKPhysicsContact) {
if contact.bodyA.categoryBitMask == CollisionCategories.PlayerSpaceShip && contact.bodyB.categoryBitMask == CollisionCategories.Asteroid || contact.bodyB.categoryBitMask == CollisionCategories.PlayerSpaceShip && contact.bodyA.categoryBitMask == CollisionCategories.Asteroid {
if !gameOver && !playerWasHit {
playerWasHit = true
self.pauseTheGame()
//spaceShip vs asteroid animation
let fadeOutAction = SKAction.fadeOutWithDuration(0.1)
fadeOutAction.timingMode = SKActionTimingMode.EaseOut
let fadeInAction = SKAction.fadeInWithDuration(0.1)
fadeInAction.timingMode = SKActionTimingMode.EaseOut
let blinkAction = SKAction.sequence([fadeOutAction, fadeInAction])
let blinkRepeatAction = SKAction.repeatAction(blinkAction, count: 3)
let delayAction = SKAction.waitForDuration(0.2)
let gameOverAction = SKAction.runBlock({ () -> Void in
self.gameSettings.lives--
self.gameDelegate?.gameDelegateDidUpdateLives()
if self.gameSettings.lives > 0 {
self.respawn()
} else {
self.gameSettings.recordScores(self.gameSettings.currentScore)
self.gameDelegate?.gameDelegateGameOver(self.gameSettings.currentScore)
self.gameOver = true
self.pauseTheGame()
}
})
let gameOverSequence = SKAction.sequence([blinkRepeatAction, delayAction, gameOverAction])
spaceShipLayer.runAction(gameOverSequence)
}
if soundOn {
let hitSoundAction = SKAction.playSoundFileNamed("hitSound.wav", waitForCompletion: true)
runAction(hitSoundAction)
}
//second case playerLazer vs enemySpaceShip
} else if contact.bodyA.categoryBitMask == CollisionCategories.PlayerLaser && contact.bodyB.categoryBitMask == CollisionCategories.EnemySpaceShip || contact.bodyB.categoryBitMask == CollisionCategories.PlayerLaser && contact.bodyA.categoryBitMask == CollisionCategories.EnemySpaceShip {
contact.bodyA.node?.removeFromParent()
contact.bodyB.node?.removeFromParent()
}
}
I found decision that makes everything perfect:
just second part should be like this:
if
contact.bodyA.categoryBitMask == CollisionCategories.PlayerLaser &&
contact.bodyB.categoryBitMask == CollisionCategories.EnemySpaceShip ||
contact.bodyA.categoryBitMask == CollisionCategories.EnemySpaceShip &&
contact.bodyB.categoryBitMask == CollisionCategories.PlayerLaser
{
contact.bodyA.node?.physicsBody?.categoryBitMask = CollisionCategories.None
contact.bodyB.node?.physicsBody?.categoryBitMask = CollisionCategories.None
contact.bodyA.node?.removeFromParent()
contact.bodyB.node?.removeFromParent()
self.addPoints(5)
}
}
So I've made .None categoryBitMask and applied it after collision detection so now points and spriteNode behavior is correct!
I'm making a game in XCode using SpriteKit. The game has a player and different types of projectiles that he has to avoid. When the player collides with the projectiles, the score changes and the projectile disappears. However, when two projectiles collide, they kind of bounce away.
I want to make that every time two projectiles collide, they act like nothing happened and they keep going in their original path. What should I do?
*Note: This is not the whole code, it's just what matters.
import SpriteKit
struct Physics {
static let player : UInt32 = 1
static let missileOne : UInt32 = 2
static let missileTwo : UInt32 = 3
}
class GameScene: SKScene, SKPhysicsContactDelegate {
var player = SKSpriteNode(imageNamed: "p1.png")
override func didMoveToView(view: SKView) {
physicsWorld.contactDelegate = self
player.position = CGPointMake(self.size.width/2, self.size.height/5)
player.physicsBody = SKPhysicsBody(rectangleOfSize: player.size)
player.physicsBody?.affectedByGravity = false
player.physicsBody?.dynamic = false
player.physicsBody?.categoryBitMask = Physics.player
player.physicsBody?.collisionBitMask = Physics.missileOne
player.physicsBody?.collisionBitMask = Physics.missileTwo
var missileOneTimer = NSTimer.scheduledTimerWithTimeInterval(1, target: self, selector: Selector("SpawnMissileOne"), userInfo: nil, repeats: true)
var missileTwoTimer = NSTimer.scheduledTimerWithTimeInterval(1.2, target: self, selector: Selector("SpawnMissileTwo"), userInfo: nil, repeats: true)
self.addChild(player)
}
//When contact happens
func didBeginContact(contact: SKPhysicsContact) {
var firstBody : SKPhysicsBody = contact.bodyA
var secondBody : SKPhysicsBody = contact.bodyB
if ((firstBody.categoryBitMask == Physics.player) && (secondBody.categoryBitMask == Physics.missileOne)) {
CollisionWithMissileOne(firstBody.node as SKSpriteNode, missileOne: secondBody.node as SKSpriteNode)
} else if ((firstBody.categoryBitMask == Physics.player) && (secondBody.categoryBitMask == Physics.missileTwo)){
CollisionWithMissileTwo(firstBody.node as SKSpriteNode, missileTwo: secondBody.node as SKSpriteNode)
} else if ((firstBody.categoryBitMask == Physics.missileOne)&&(secondBody.categoryBitMask == Physics.missileTwo)) {
CollisionBetweenMissiles(firstBody.node as SKSpriteNode, missileTwo: secondBody.node as SKSpriteNode)
}
}
//For Player and MissileOne
func CollisionWithMissileOne(player: SKSpriteNode, missileOne: SKSpriteNode) {
missileOne.removeFromParent()
}
//For Player and MissileTwo
func CollisionWithMissileOne(player: SKSpriteNode, missileTwo: SKSpriteNode) {
missileTwo.removeFromParent()
}
//For MissileOne and MissileTwo
func CollisionBetweenMissiles(missileOne: SKSpriteNode, missileTwo: SKSpriteNode) {
???WHAT SHOULD I CODE HERE???
}
}
The confusion is that the collisionBitMask is used to define which physicsBodies that interacts in the physicsModel. What you really want is contactTestBitmask.
Also your Physics doesn't return proper values to use for a Bit Mask. As pure Ints they should be 1,2,4,8 etc.
Here is your code changed to something that (hopefully) works, I've commented changes wherever I've made them.
struct Physics {
static let player : UInt32 = 1
static let missileOne : UInt32 = 2
static let missileTwo : UInt32 = 4 // to work properly as bit masks
}
This change is necessary if you want to check for contact with more than one type of physicsBody.categoryBitMask. Check out the player.physicsBody?.contactTestBitMask = ... in didMoveToView:
override func didMoveToView(view: SKView) {
physicsWorld.contactDelegate = self
// All your existing player-stuff is fine until...
// contactTest, not collision but contact, also: use bitwise OR
player.physicsBody?.contactTestBitMask = Physics.missileOne | Physics.missileTwo
self.addChild(player)
// It is not recommended to use NSTimer for SpriteKit, use SKActions instead
let missileOneWait = SKAction.waitForDuration(1)
let callSpawnOneAction = SKAction.runBlock({ self.spawnMissileOne() })
let missileOneRepeat = SKAction.repeatActionForever(SKAction.sequence([missileOneWait, callSpawnOneAction]))
runAction(missileOneRepeat)
let missileTwoWait = SKAction.waitForDuration(1.2)
let callSpawnTwoAction = SKAction.runBlock({ self.spawnMissileTwo() })
let missileTwoRepeat = SKAction.repeatActionForever(SKAction.sequence([missileTwoWait, callSpawnTwoAction]))
runAction(missileTwoRepeat)
}
Pretty much rewritten didBeginContact to something I believe reads and scales a lot better:
func didBeginContact(contact: SKPhysicsContact) {
var firstBody = contact.bodyA
var secondBody = contact.bodyB
// Rewritten with dynamic variables
var playerNode : SKSpriteNode? {
if firstBody.categoryBitMask == Physics.player {
return firstBody.node as? SKSpriteNode
} else if secondBody.categoryBitMask == Physics.player {
return secondBody.node as? SKSpriteNode
}
return nil
}
// If you want to handle contact between missiles you need to split this
// into two different variables
var missileNode : SKSpriteNode? {
let bitmask1 = firstBody.categoryBitMask
let bitmask2 = secondBody.categoryBitMask
if bitmask1 == Physics.missileOne || bitmask1 == Physics.missileTwo {
return firstBody.node as? SKSpriteNode
} else if bitmask2 == Physics.missileOne || bitmask2 == Physics.missileTwo {
return secondBody.node as? SKSpriteNode
}
return nil
}
if playerNode != nil {
collisionBetweenPlayer(playerNode, missile: missileNode)
}
}
Then you'll only need one function for contact between missile and player:
func collisionBetweenPlayer(player: SKSpriteNode?, missile: SKSpriteNode?) {
missile?.removeFromParent()
}