在迅速

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

我已经加入了麻省理工学院的许可证，所以你可以，如果你想叉这个库。我希望这有帮助。