How to shoot a moving sprite in Swift?

Question

I am trying to get my stationary monster to shoot at my moving player. Both the player position and the monster position are obtaining the right values and this code is written in a function that is called every second. Right now the projectile shows up but doesn't move away from the monster. Is there something else I should be using besides .applyAngularImpulse?

    let deltaX = player.position.x - monster.position.x
    let deltaY = player.position.y - monster.position.y
    let angle = atan2(deltaY, deltaX)

    monProjectile.physicsBody?.applyAngularImpulse(angle)

Answer 1

UPDATE

Having looked at the code you provided, I suspect two things are at fault:

1) You are specifying a "projectile" image that I can't see in your project.

2) You are trying to apply angular impulse (i.e. spin) rather than a regular impulse (i.e., direction plus speed).

To fix the first problem add an image for your projectile. To fix the second, consider using applyImpulse() with a CGVector.

Original answer

Off the top of my head, there are a few things that might cause this:

1) How much of an impulse are you applying? Print out the value and see what kind of number you're working with.

2) Does your projectile overlap the monster when it's created? If so, it might be colliding and getting stuck.

3) Is it possible the projectile is colliding with some other node entirely, e.g. a background picture?

You should consider setting showsPhysics to be true for your SKView so you can see what's happening more clearly.

Answer 2

func makeShoot() {
    let Shoot:ShootClass = ShootClass.init()
    Shoot.physicsBody = SKPhysicsBody(texture: Shoot.texture!,
                                     size: Shoot.texture!.size())
    Shoot.position = (self.Shoot?.position)!
    Shoot.currentPosition = (self.Shoot?.position)!
    Shoot.physicsBody?.isDynamic = true
    Shoot.physicsBody?.allowsRotation = false
    Shoot.physicsBody?.affectedByGravity = false
    Shoot.physicsBody?.friction = 0
    Shoot.physicsBody?.restitution = 1
    Shoot.physicsBody?.mass = 1
    Shoot.physicsBody?.linearDamping = 0.0
    Shoot.physicsBody?.angularDamping = 0.0
    Shoot.physicsBody?.categoryBitMask = ShootCategory
    Shoot.physicsBody?.collisionBitMask = BorderCategory
    Shoot.physicsBody?.contactTestBitMask = BorderCategory

    PlayingView.addChild(Shoot);

    Shoot.physicsBody?.applyImpulse(CGVector(dx: 100, dy: 100))

    self.moveNodeToLocation(Shoot: Shoot)
}



override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    let curTouch = touches.first!
    let curPoint = curTouch.location(in: self)
    if ((curPoint.x > 103.5 && curPoint.y > 50.0) || (curPoint.x < 840.0 && curPoint.y > 50.0)) {
        StartingPoint = touches.first?.location(in: self)
        direction?.isHidden = false
        direction?.setScale(0.50)
        FirstTouchLocater = SKSpriteNode(imageNamed: "ic_Shootz");
        FirstTouchLocater.position = curPoint
        FirstTouchLocater.alpha = 0.5
        self.addChild(FirstTouchLocater);

    }
    else{
        self.direction?.isHidden = true
    }
}

override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {

    let point:CGPoint = (touches.first?.location(in: self))!

    if point.y < 40 {
        return
    }

    if !(isTouch!) {
        isTouch = true
    }


    let dy:CGFloat = StartingPoint!.y - point.y

    let size:CGFloat = dy*10/self.frame.height

    if size < 2 && size > 0.50 {
        direction?.setScale(size)
    }
     print("size ======> \(size)")




    let curTouch = touches.first!
    let curPoint = curTouch.location(in: self)

    if (curPoint.x <= ((StartingPoint?.x)! + 20.0)) &&  ((curPoint.x + 20.0) >= (StartingPoint?.x)!) && (curPoint.y <= ((StartingPoint?.y)! + 20.0)) &&  ((curPoint.y + 20.0) >= (StartingPoint?.y)!){
        self.direction?.isHidden = true
        FirstTouchLocater?.isHidden = true
    }
    else if ((curPoint.x > 103.5 && curPoint.y > 50.0) || (curPoint.x < 840.0 && curPoint.y > 50.0)) {
        let deltaX = (self.direction?.position.x)! - curPoint.x
        let deltaY = (self.direction?.position.y)! - curPoint.y
        let angle = atan2(deltaY, deltaX)

        let DegreesToRadians = CGFloat.pi / 180

        self.direction?.zRotation = angle + 90 * DegreesToRadians
        self.direction?.isHidden = false
        FirstTouchLocater?.isHidden = false
    }
    else{
        self.direction?.isHidden = true
        FirstTouchLocater?.isHidden = true
    }
}

override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
    if direction?.isHidden == false {
        FirstTouchLocater.removeFromParent()
        direction?.isHidden = true
        direction?.setScale(0.1)
        if timeThrow == nil && isTouch!
        {
            isTouch = false
            counterY = 0;

            let touch = touches.first
            let touchLocation = touch?.location(in: self)
            lastTouch = touchLocation
            lastTouch1 = touchLocation

            ShootThrow = 2

            timeThrow = Timer.scheduledTimer(timeInterval: 0.1, target: self, selector: #selector(self.loadScreen), userInfo: nil, repeats: true)
        }
    }
}

func moveNodeToLocation(Shoot:SKSpriteNode) {
    let dx = (lastTouch?.x)! - Shoot.position.x
    let dy = (lastTouch?.y)! - Shoot.position.y

    let speed1:CGFloat = 424
    let hypo = hypot(dx, dy)

    let newX = (speed1 * dx) / hypo
    let newY = (speed1 * dy) / hypo
    Shoot.physicsBody?.velocity = CGVector(dx:newX, dy: newY)

}

}