在迅速

Question

移動吃豆子我是全新的，以迅速，我想編寫一個吃豆子。我試圖將pacman移動到滑動的方向，到目前爲止，我已經設法將它移動到屏幕的邊緣，問題是，當我嘗試將它從屏幕邊緣移動到中間位置時在刷卡的動作，它只是在屏幕的邊緣，並移動到刷卡方向，這裏是一個方向的代碼：

var x = view.center.x 
    for var i = x; i > 17; i-- 
    { 
     var origin: CGPoint = self.view.center 
     var move = CABasicAnimation(keyPath:"position.x") 
     move.speed = 0.13 
     move.fromValue = NSValue(nonretainedObject: view.center.x) 
     move.toValue = NSValue(nonretainedObject: i) 
     view.layer.addAnimation(move, forKey: "position") 
     view.center.x = i 
    } 

的事情是，我知道這是當我刷卡的問題我想要for循環的方向不會等待動畫停止，但它會在不到一秒的時間內完成循環，而且我需要在這裏或其他代碼中進行某種延遲。

Answer 1

這是一個有趣的問題，所以我決定在SpriteKit一個例子。沒有任何碰撞檢測，路徑查找甚至路徑。這僅僅是當發生滑動時如何使'吃豆人'改變方向的一個例子。

我已經包含下面的GameScene：

class GameScene: SKScene { 
    enum Direction { 
     case Left 
     case Right 
     case Up 
     case Down 
    } 
    lazy var openDirectionPaths = [Direction: UIBezierPath]() 
    lazy var closedDirectionPaths = [Direction: UIBezierPath]() 
    lazy var wasClosedPath = false 
    lazy var needsToUpdateDirection = false 
    lazy var direction = Direction.Right 
    lazy var lastChange: NSTimeInterval = NSDate().timeIntervalSince1970 

    var touchBeganPoint: CGPoint? 
    let pacmanSprite = SKShapeNode(circleOfRadius: 15) 

    override func didMoveToView(view: SKView) { 
     let radius: CGFloat = 15, diameter: CGFloat = 30, center = CGPoint(x:radius, y:radius) 
     func createPaths(startDegrees: CGFloat, endDegrees: CGFloat, inout dictionary dic: [Direction: UIBezierPath]) { 
      var path = UIBezierPath(arcCenter: center, radius: radius, startAngle: startDegrees.toRadians(), endAngle: endDegrees.toRadians(), clockwise: true) 
      path.addLineToPoint(center) 
      path.closePath() 
      dic[.Right] = path 
      for d: Direction in [.Up, .Left, .Down] { 
       path = path.pathByRotating(90) 
       dic[d] = path 
      } 
     } 
     createPaths(35, 315, dictionary: &openDirectionPaths) 
     createPaths(1, 359, dictionary: &closedDirectionPaths) 
     pacmanSprite.position = CGPointMake(CGRectGetMidX(self.frame), CGRectGetMidY(self.frame)) 
     pacmanSprite.fillColor = UIColor.yellowColor() 
     pacmanSprite.lineWidth = 2 
     if let path = openDirectionPaths[.Right] { 
      pacmanSprite.path = path.CGPath 
     } 
     pacmanSprite.strokeColor = UIColor.blackColor() 
     self.addChild(pacmanSprite) 
     updateDirection() 

     // Blocks to stop 'Pacman' changing direction outside of a defined path? 
     //375/25 = 15 width 
     //666/37 = 18 height 
    } 

    override func touchesBegan(touches: Set<NSObject>, withEvent event: UIEvent) { 
     touchBeganPoint = positionOfTouch(inTouches: touches) 
    } 

    override func touchesEnded(touches: Set<NSObject>, withEvent event: UIEvent) { 
     if let touchStartPoint = touchBeganPoint, 
      touchEndPoint = positionOfTouch(inTouches: touches) { 
       if touchStartPoint == touchEndPoint { 
        return 
       } 
       let degrees = atan2(touchStartPoint.x - touchEndPoint.x, 
        touchStartPoint.y - touchEndPoint.y).toDegrees() 
       var oldDirection = direction 
       switch Int(degrees) { 
       case -135...(-45): direction = .Right 
       case -45...45:  direction = .Down 
       case 45...135:  direction = .Left 
       default:   direction = .Up 
       } 
       if (oldDirection != direction) { 
        needsToUpdateDirection = true 
       } 
     } 
    } 

    override func touchesCancelled(touches: Set<NSObject>!, withEvent event: UIEvent!) { 
     touchBeganPoint = nil 
    } 

    override func update(currentTime: CFTimeInterval) { 
     /* Called before each frame is rendered */ 
     if let nodes = self.children as? [SKShapeNode] { 
      for node in nodes { 
       let p = node.position 
       let s = node.frame.size 
       //let s = node.size 
       if p.x - s.width > self.size.width { 
        node.position.x = -s.width 
       } 
       if p.y - s.height > self.size.height { 
        node.position.y = -s.height 
       } 
       if p.x < -s.width { 
        node.position.x = self.size.width + (s.width/2) 
       } 
       if p.y < -s.height { 
        node.position.y = self.size.height + (s.height/2) 
       } 
       if needsToUpdateDirection || NSDate().timeIntervalSince1970 - lastChange > 0.25 { 
        if let path = wasClosedPath ? openDirectionPaths[direction]?.CGPath : closedDirectionPaths[direction]?.CGPath { 
         node.path = path 
        } 
        wasClosedPath = !wasClosedPath 
        lastChange = NSDate().timeIntervalSince1970 
       } 
       updateDirection() 
      } 
     } 
    } 

    // MARK:- Helpers 

    func positionOfTouch(inTouches touches: Set<NSObject>) -> CGPoint? { 
     for touch in (touches as! Set<UITouch>) { 
      let location = touch.locationInNode(self) 
      return location 
     } 
     return nil 
    } 

    func updateDirection() { 
     if !needsToUpdateDirection { 
      return 
     } 
     pacmanSprite.removeActionForKey("Move") 
     func actionForDirection() -> SKAction { 
      let Delta: CGFloat = 25 
      switch (direction) { 
      case .Up: 
       return SKAction.moveByX(0.0, y: Delta, duration: 0.1) 
      case .Down: 
       return SKAction.moveByX(0.0, y: -Delta, duration: 0.1) 
      case .Right: 
       return SKAction.moveByX(Delta, y: 0.0, duration: 0.1) 
      default: 
       return SKAction.moveByX(-Delta, y: 0.0, duration: 0.1) 
      } 
     } 
     let action = SKAction.repeatActionForever(actionForDirection()) 
     pacmanSprite.runAction(action, withKey: "Move") 
     needsToUpdateDirection = false 
    } 
} 

存儲庫可以是found here

我已經加入了麻省理工學院的許可證，所以你可以，如果你想叉這個庫。我希望這有幫助。