Kollision zwischen Sprites erkennen

Question

Ich habe ein Problem in meinem Code.

Ich erstelle ein Spiel und ich brauche ein Sprite, das mehrere Male gleichzeitig erscheinen kann. Dazu habe ich eine Klasse erstellt, damit ich addChild (Hindernis) mehrmals machen kann und es einen SKSpriteNode spawnt genau ähnlich zu einem anderen.

Mein Problem ist, dass ich die Kollision zwischen meinem Spieler und dem Hindernis überprüfen möchte, aber weil es vom selben SKSpriteNode ist, kann der Computer nicht wissen, über welches Hindernis ich spreche.

Hier ist, wie ich die Spieler erstellt und das Hindernis:

import SpriteKit 

class Obstacle: SKSpriteNode { 

    init() { 
     let obstacleTexture = SKTexture(imageNamed: "obstacle") 
     super.init(texture: obstacleTexture, color: UIColor.clearColor(), size: CGSize(width: 80, height: 80)) 
    } 

    required init(coder aDecoder: NSCoder) { 
     fatalError("init(coder:) has not been implemented") 
    } 

} 

class GameScene: SKScene { 

    var player:SKSpriteNode! 

    override func didMoveToView(view: SKView) { 

     //player setup 
     let playerTexture = SKTexture(imageNamed: "player") 
     player = SKSpriteNode(texture: playerTexture) 
     player.position = CGPointMake(self.frame.size.width * 0.5, self.frame.size.height * 0.2) 

    } 

    //how I spawn an obstacle 
    func spawnObstacle() { 

     let obstacle = Obstacle() 

     //obstacle position setup 
     obstacle.position.x = CGFloat(arc4random()) % self.frame.size.width 
     obstacle.position.y = self.frame.size.height + 200 

     //random spin action setup 
     var rotateObstacle = SKAction.rotateByAngle(CGFloat(M_PI), duration: Double((drand48() + 1) * 0.75)) 

     if random() % 2 == 0 { 
      rotateObstacle = SKAction.rotateByAngle(CGFloat(M_PI), duration: Double((drand48() + 1) * 0.75)) 
     }else{ 
      rotateObstacle = SKAction.rotateByAngle(-CGFloat(M_PI), duration: Double((drand48() + 1) * 0.75)) 
     } 

     let rotateObstacleForever = SKAction.repeatActionForever(rotateObstacle) 

     //random move action setup 
     let moveObstacle = SKAction.moveTo(CGPointMake(CGFloat(arc4random()) % self.frame.size.width, -200), duration: Double((drand48() + 1) * 1.5)) 

     //running the actions 
     obstacle.runAction(rotateObstacleForever) 
     obstacle.runAction(moveObstacle) 

     addChild(obstacle) 

    } 

} 

} 

Wie zu erkennen, wenn der Spieler mit einem Hindernis kollidieren?

Answer 1

Um Kollisionen zu erkennen, könnten Sie die SpriteKit-Physik verwenden.

Hier haben Sie drei Elemente beteiligt hypothetische Kollisionen:

• Die Grenzen (oder das Feld, in dem Sie Ihre Spieler leben und wo Sie Ihre Hindernisse)
• Der Spieler
• die Hindernisse

Tipps

Setzen Sie diesen Parameter auf Ihre Debug-Phasen Physik sehen Grenzen Objekte:

skView.showsPhysics = true 

Ein Beispiel-Code (Warnung: - Dieser Code würde nur einen Punkt zu beginnen, Ihre Physik zu realisieren, kann ich nicht kennen den Rest Ihres Projekts so Ihre Aufgabe sein wird, zu korrigieren, wie Sie glauben, dass es für Ihre Objekte besser):

enum CollisionTypes: UInt32 { 
    case Field = 1 
    case Player = 2 
    case Obstacle = 4 
} 

class GameScene: SKScene, SKPhysicsContactDelegate { 
    override func didMoveToView(view: SKView) { 
     self.physicsWorld.gravity = CGVectorMake(0, 0) // set your gravity value 
     self.physicsWorld.contactDelegate = self 
     let fieldBody = SKPhysicsBody.init(edgeLoopFromRect: self.frame) 
     self.physicsBody = fieldBody 
     self.physicsBody!.affectedByGravity = false 
     self.physicsBody!.usesPreciseCollisionDetection = true 
     self.physicsBody!.dynamic = true 
     self.physicsBody!.mass = 0.8 
     self.physicsBody!.friction = 0 
     self.physicsBody!.linearDamping = 0 
     self.physicsBody!.angularDamping = 0 
     self.physicsBody!.restitution = 0 
     self.physicsBody!.categoryBitMask = CollisionTypes.Field.rawValue 
     self.physicsBody!.contactTestBitMask = CollisionTypes.Player.rawValue 

     // Prepare the player 
     player.physicsBody = SKPhysicsBody(circleOfRadius: player.frame.width/2) 
     player.physicsBody!.affectedByGravity = false 
     player.physicsBody!.restitution = 0.0 
     player.physicsBody!.linearDamping = 0 
     player.physicsBody!.friction = 0.3 
     player.physicsBody!.dynamic = true 
     player.physicsBody!.mass = 0.2 
     player.physicsBody!.allowsRotation = false 
     player.physicsBody!.categoryBitMask = CollisionTypes.Player.rawValue 
     player.physicsBody!.contactTestBitMask = CollisionTypes.Field.rawValue | CollisionTypes.Obstacles.rawValue 
     player.physicsBody!.collisionBitMask = CollisionTypes.Field.rawValue | CollisionTypes.Obstacles.rawValue 

     //Prepare the obstacles (you must do it in your obstacle class) 
     obstacle.physicsBody = SKPhysicsBody(circleOfRadius: obstacle.frame.width/2) 
     obstacle.physicsBody!.affectedByGravity = false 
     obstacle.physicsBody!.restitution = 0.0 
     obstacle.physicsBody!.linearDamping = 0 
     obstacle.physicsBody!.friction = 0.3 
     obstacle.physicsBody!.dynamic = true 
     obstacle.physicsBody!.mass = 0.8 
     obstacle.physicsBody!.allowsRotation = true 
     obstacle.physicsBody!.categoryBitMask = CollisionTypes.Obstacle.rawValue 
     obstacle.physicsBody!.contactTestBitMask = CollisionTypes.Player.rawValue 
     obstacle.physicsBody!.collisionBitMask = CollisionTypes.Player.rawValue 
    } 
    func didBeginContact(contact: SKPhysicsContact) { 
     if (contact.bodyA.categoryBitMask == CollisionTypes.Player.rawValue && 
     contact.bodyB.categoryBitMask == CollisionTypes.Obstacle.rawValue) { 
     print("contact between Player and Obstacle") 
     } 
     if (contact.bodyA.categoryBitMask == CollisionTypes.Player.rawValue && 
     contact.bodyB.categoryBitMask == CollisionTypes.Field.rawValue) { 
     print("contact between Player and Field") 
     } 
    } 
}