Has anyone experienced zRotation greater than 2 Pi? - sprite-kit

Question

I'm getting values for zRotation less/greater than -/+pi with Swift3 (e.g. 7.41137313842773, in radians at about 0,5Pi). It happens when rotating a node using the approach described below.
Code is
override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
for touch in touches {
newLocation = touch.location(in: self)
turnAngle = atan2(newLocation.y - lastLocation.y - mySprite.position.y, newLocation.x - lastLocation.x - mySprite.position.x)
mySprite.run(SKAction.rotate(byAngle: turnAngle, duration: 0.1))
lastLocation = newLocation
print("mySprite zRotation: \(mySprite.zRotation)")
}
}
I also notice a jittery jump in the sprite at the point when the sprite is rotated to pi/2 (absolute). If this is normal behaviour, is there a way to recalculate zRotation between -/+Pi or 0-2Pi?

Answer 1

I believe in your code there are two point to analyze:
SKAction and zRotation.
The first (SKAction) should be considered in general (not about this issue). If you want to launch an SKAction like 'rotate' inside a cycle, because it have a duration you should check if this action is finished before to launch another. An example:
extension SKNode
{
func actionForKeyIsRunning(key: String) -> Bool {
return self.action(forKey: key) != nil ? true : false
}
}
if !self.mySprite.actionForKeyIsRunning(key: "rotation") {
self.mySprite.run(SKAction.rotate(byAngle: turnAngle, duration: 0.1),withKey:"rotation")
}
Speaking about zRotation and your issue the reason you have a wrong zRotation value is because you are using an action. zRotation is a node property: properties of nodes undergoing animation are not updated at each step in the simulation. You can set zRotation to rotate your node:
self.mySprite.zRotation = turnAngle
or create a physics body and set the angular velocity.
For more details about SKAction and node properties look the official Apple doc where there is this note:
When You Shouldn’t Use Actions
Although actions are efficient, there is a cost to creating and
executing them. If you are making changes to a node’s properties in
every frame of animation and those changes need to be recomputed in
each frame, you are better off making the changes to the node directly
and not using actions to do so. For more information on where you
might do this in your game, see Advanced Scene Processing.

Answer 2

As #PietroPepe has pointed out, you are stacking actions one on top of the other. Let's break down your code:
override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
for touch in touches {
This tells us that your touch calls will be done multiple times throughout the life cycle of your touch. Even with a quick touch down and up action, it is very possible to go through at least 2 calls on this method.
newLocation = touch.location(in: self)
turnAngle = atan2(newLocation.y - lastLocation.y - mySprite.position.y, newLocation.x - lastLocation.x - mySprite.position.x)
The point of this code is to have the sprite move at the change of the touch from last position to current position
mySprite.run(SKAction.rotate(byAngle: turnAngle, duration: 0.1))
lastLocation = newLocation
print("mySprite zRotation: \(mySprite.zRotation)")
}
}
Finally this point of the code says do it in 1/10th of a second.
Now let's run through a scenario. We touch the screen, move it, and let go.
The amount of time it took to perform it was 4 frames, this means 1 touchBegan, 2 touchMoved, and 1 touchEnded.
in our toucheMoved events, we calculate a change of 60degrees, each time.
Now a frame is 1/60th of a second keep in mind.
Our rotation event will take 1/10th of a second to go from 0 to 60, so 6/60th seconds, 6 frames.
This means every frame we are moving 10 degrees.
Now we come to the second frame of the rotateBy.
The same logic as the first frame above will apply, so we will now have another series of rotations that will be moving by 10 degrees.
This mean we now have 2 events rotating our sprite at 6 degrees each.
So the timeline is as followed:
Frames: 0 1 2 3 4 5 6 7
+10 +10 +10 +10 +10 +10
+10 +10 +10 +10 +10 +10
Notice the inconsistent behaviors between the end and the beginning of your rotation? This is why things look all screwy.
Now, I am not sure of the desired effect you are looking for, but if I were to be doing this, I would be setting zRotation instead of using actions.
If you are looking for a delayed effect, then use the withKey parameter on the run function so that you only have 1 action running, and use SKAction.rotateTo to have the sprite always rotating to the last possible touch location. This of course means you need to keep track of when touch first began, not when last touched.
This also gets a little tricky depending on desired effect, because you may need to keep track of the time that has elapsed between the number of touchesMoved events called and apply the time difference to your duration, so basically duration:.01 - timeSinceTouchBegan,