A fast, easy to use, free, and community supported 2D game engine
I have been trying to solve this problem for the last week, so please help.
I want to have my sprite gradually rotating towards another sprite that is moving.
So when the target sprite changes positions the rotating sprite will slowly rotate to point towards the new position of the target.
I'm not using actions, so this is all going to be done in a loop.
thx danne.
OK so this method works:
int x = target->p.x;
int y = target->p.y;
float dx = enemyShape->body->p.x - x;
float dy = enemyShape->body->p.y - y;
int angle = (atan2f(-dy, dx) * (180/3.14)) -90;
if (enemyShape->body->a > -CC_DEGREES_TO_RADIANS(angle)) {
enemyShape->body->a -= 0.05;
} else {
enemyShape->body->a += 0.05;
}The problem with this is that when the position of the angle to the target changes from 0.0 radians to 6.3 radians (or what ever equals 360 degrees) the enemy shape changes direction and spins the wrong way.
How can I solve this problem?
sorry for bumping, but I just can't figure it out. Can someone please help me?
It's probably because of the conditional
if (enemyShape->body->a > -CC_DEGREES_TO_RADIANS(angle)) {
enemyShape->body->a -= 0.05;
} else {
enemyShape->body->a += 0.05;
}So let's figure out a new replacement for that that needs to take in the fact for taking the shortest rotation.
Pretty much what you are doing is a linear interpolation from angle a to a'
a = the current angle
a' = -CC_DEGREES_TO_RADIANS(angle)
Linear Interpolation
c = a * (1 - alpha) + a' * alpha
for all alpha, 0 <= alpha <= 1So what we see is that a linear interpolation gives you a new value (in this case angle) 'c' that based on an alpha in the range [0..1] that holds:
alpha == 0 then we get a
alpha == 1 then we have a'
alpha is anywhere between 0..1 then we have a value within a..a'
In your conditional before you had 0.05 as a way to slowly reach towards a'
let's just do that the same way with linear interpolation
float lerp(float a, float b, float alpha)
{
//fill in the rest here
}
//replace your conditional with:
enemyShape->body->a = lerp(enemyShape->body->a, -CC_DEGREES_TO_RADIANS(angle), 0.05);The looming problem ahead
That removes the conditional but we have a problem with going from 2*PI radians directly to a small value. This happens when we rotate a full cycle and end up back at 0.
But first fix the conditional and see if that helps, if it does not then it's time to figure out the next step.
Critical Update
Now thinking about it the lerp doesn't help since it doesn't solve for your actual problem going from 2*PI (or the 360 deg) to 0. Argghh!
Ok that was frustrating. After a round of punching through walls, kicking windows, leaping off of rooftops into flaming hoops, (to release stress), I figured it out. ;)
What we were doing before was finding exact values of the angle to rotate to but what we should be doing is find relative angles to add to the current angle and therefore remove the issue of going from 360 to 0 in the process.
The idea is that if you are at angle 30 and you want to go to 70:
There's 2 ways about it.
You could store angle = 70 (absolute assignment)
or
alternatively, you add onto the current angle by another 40. (relative)
Both will give you an angle of 70 but working with relative solves the current problem.
So instead of:
int angle = (atan2f(-dy, dx) * (180/3.14)) -90;let's find the relative angle like so:
CGPoint dd = target - enemyShape->body(); //handwaving to get CGPoint from body (it's psuedo-code)
float newAngle = ccpAngleSigned(ccpForAngle(angle_), dd);
angle_ += newAngle - M_PI*.5f; //add the relative angle ( note: different than storing actual angle)What I've done was written angle functions in the latest cocos 99.1 to deal with angles of vectors. We find a new angle that is added onto the current angle. All variables with the '_' suffix are class variables.
Since we've add relative angles onto our angle_ we never work with absolute angle values so we don't run into that problem anymore.
But to smoothly transition we use lerp again
-(void)tick:(ccTime)dt
{
angleTo_ = lerpf(angle_, angleTo_, 0.05f);
}AngleTo is the actual angle we want to use to store to the body 'enemyShape->body->a'
Ok that's pretty much it. Wheew!
Thank you!! This might be exactly what i need!
pravin
Member
Hi ,
We are developing the game using cocos-2d 0.8v.
In our game the enemies are birds and they are moving in some directions.
We are getting the problem in rotation of Sprite smoothly.
As we are not able to rotate the Sprite (bird's head) moving in the direction.
As Lam said "before was finding exact values of the angle to rotate" how to get the angle before the rotation.
Please help.
I don't know what else I can help with.
Hmm ....
I guess I was using functions to solve the problem and didn't realize that I use those functions without explanation.
So you want to find angles with vectors?
Cocos2D includes ccpForAngle, ccpToAngle, (ccpAngle, and ccpAngleSigned in the latest trunk) to help create angles from vectors.
ccpForAngle converts an angle in radians to a unit vector of direction in a clockwise direction with respect to the x-axis.
ccpToAngle takes a vector (make sure it's a normalized vector! not a vector with magnitude, don't even think about putting in a point!) and returns the angle between the vector and the x-axis.
Those two functions allow you to convert between angles and vectors to find your rotation. It's in radians so be sure to convert to degrees.
NOTE:
ccpAngleSigned is introduced in cocos2d .99 so you probably wouldn't use it much but it allows you to find the angle between two vectors. If we choose vector 'b' to be the x-axis then it would be similar to ccpToAngle.
float ccpAngleSigned(CGPoint a, CGPoint b)
{
// we can normalize here just to make sure we have unit vectors or leave
// out the expensive calculation and notify the caller that they must normalize
CGPoint a2 = ccpNormalize(a); CGPoint b2 = ccpNormalize(b);
return atan2f(a2.x * b2.y - a2.y * b2.x, ccpDot(a2, b2));
}The naming is a bit awkward I'll have to think of a better name later.
You must log in to post.