For a while now I've been trying to hack Photonstorm's Power Tools 'Spring' plugin for Flixel. I've dabbled in a few formulas but I've not gotten what I've sort of wanted until now.
I've managed to hack this into the plugin:
http://illogictree.com/blog/2010/01/1345/
Which makes the example look like this now:
Which is good. It behaves pretty much the way I'd like it to feel. Except for a problem. I'd like for the ball on the string to be directly below the mouse. Any idea on how to do that?
And before you ask, code:
//The plugin hack
package org.flixel.plugin.photonstorm.BaseTypes
{
import org.flixel.*;
import org.flixel.plugin.photonstorm.FlxExtendedSprite;
public class MouseSpring
{
public var sprite:FlxExtendedSprite;
/**
* The tension of the spring, smaller numbers create springs closer to the mouse pointer
* #default 0.1
*/
public var tension:Number = 0.1;
/**
* The friction applied to the spring as it moves
* #default 0.95
*/
public var friction:Number = 0.95;
/**
* The gravity controls how far "down" the spring hangs (use a negative value for it to hang up!)
* #default 0
*/
public var gravity:Number = 0;
private var retainVelocity:Boolean = false;
private var vx:Number = 0;
private var vy:Number = 0;
private var dx:Number = 0;
private var dy:Number = 0;
private var ax:Number = 0;
private var ay:Number = 0;
/**
* Adds a spring between the mouse and a Sprite.
*
* #param sprite The FlxExtendedSprite to which this spring is attached
* #param retainVelocity true to retain the velocity of the spring when the mouse is released, or false to clear it
* #param tension The tension of the spring, smaller numbers create springs closer to the mouse pointer
* #param friction The friction applied to the spring as it moves
* #param gravity The gravity controls how far "down" the spring hangs (use a negative value for it to hang up!)
*/
public function MouseSpring(sprite:FlxExtendedSprite, retainVelocity:Boolean = false, tension:Number = 0.1, friction:Number = 0.95, gravity:Number = 0)
{
this.sprite = sprite;
this.retainVelocity = retainVelocity;
this.tension = tension; //bounciness
this.friction = friction; //how tight
this.gravity = gravity; //mass
}
/**
* Updates the spring physics and repositions the sprite
*/
public function update():void
{
dx = FlxG.mouse.x - sprite.springX;
dy = FlxG.mouse.y - sprite.springY;
ax = dx * tension;
ay = dy * tension;
//ax = Math.cos(dx * tension);
//ay = Math.sin(dy * tension);
vx += ax;
vy += ay;
//vy += gravity;
//vx *= friction;
//vy *= friction;
//This is where I've hacked it in:
vx = ax + ( 1.0 / gravity ) * (-friction * ax - tension * ( FlxG.mouse.x - dx ) + sprite.springX * gravity ) * FlxG.elapsed;
vy= ay + ( 1.0 / gravity ) * ( -friction * ay - tension * ( FlxG.mouse.y - dy ) + sprite.springY * gravity ) * FlxG.elapsed;
sprite.x += vx;
sprite.y += vy;
}
/**
* Resets the internal spring physics
*/
public function reset():void
{
vx = 0;
vy = 0;
dx = 0;
dy = 0;
ax = 0;
ay = 0;
}
}
}
Applying the object to the state:
ball1 = new FlxExtendedSprite(160, 120, AssetsRegistry.redPNG);
//Argument 1:onPressed: true if the spring should only be active when the mouse is pressed down on this sprite
//Argument 2:retainVelocity: true to retain the velocity of the spring when the mouse is released, or false to clear it
//Argument 3:tension: The tension of the spring, smaller numbers create springs closer to the mouse pointer
//Argument 4:friction: The friction applied to the spring as it moves
//Argument 5:gravity: The gravity controls how far "down" the spring hangs (use a negative value for it to hang up!)
ball1.enableMouseSpring(false, false, 0.1, 0.95, -5);
ball1.springOffsetX = 0;
ball1.springOffsetY = 0;
Also, any help for loosening up the spring to make it more rope or string like would help too!
Thanks in advance!
If you want it to be directly under the mouse, remove all x calculations and replace it with the mouseX param from the stage. The spring will now only move in the y dimension.
To adjust the springiness, play with the values for these:
this.tension = tension; //bounciness
this.friction = friction; //how tight
this.gravity = gravity; //mass
Some combination will get you what you're looking for.
Related
I have a monster that produces crystals. I want each crystal to orbit the monster, but when there is more than one crystal, I want them to orbit at an equal distance from each other. I've been trying to get this to work using two blocks of code I already have, but each one does something different and i need one block of code that does it all.
This block simply allows an object to orbit another:
orbitRadius = 110;
angle += orbitSpeed;
rad = (angle * (Math.PI / 180));
orbitX = monster.x + orbitRadius * Math.cos(rad);
orbitY = monster.y + orbitRadius * Math.sin(rad);
Here's a video of what it looks like:
https://www.youtube.com/watch?v=ACclpQBsjPo
This block of code arranges crystals around the monster based on the amount of crystals there are:
radius = 110;
angle = ((Math.PI * 2) / targetArray.length) * targetArray.indexOf(this);
orbitX = monster.x - (radius * Math.cos(angle));
orbitY = monster.y - (radius * Math.sin(angle));
And here's this video: https://www.youtube.com/watch?v=TY0mBHc2A8U
I do not know how to both space the crystals equally and make them circle around the monster at the same time. What needs to be done in order to achieve this?
1) Hierarchical way: put crystals into the same container so they spread equally (like you are doing on the second video) then rotate the container.
2) Math way.
Implementation:
public class Orbiter extends Sprite
{
// Pixels.
public var radius:Number = 100;
// Degrees per second.
public var speed:Number = 360;
public var items:Array;
public var lastTime:int;
public function start()
{
stop();
rotation = 0;
items = new Array;
lastTime = getTimer();
addEventListener(Event.ENTER_FRAME, onFrame);
}
public function stop():void
{
items = null;
removeEventListener(Event.ENTER_FRAME, onFrame);
}
public function onFrame(e:Event = null):void
{
var aTime:int = getTimer();
rotation += speed * (aTime - lastTime) / 1000;
lastTime = aTime;
for (var i:int = 0; i < items.length; i++)
{
// Get the object.
var anItem:DisplayObject = items[i];
// Get the object's designated position.
var aPos:Point = getPosition(i);
// Follow the position smoothly.
anItem.x += (aPos.x - anItem.x) / 10;
anItem.y += (aPos.y - anItem.y) / 10;
}
}
private function getPosition(index:int):Point
{
// Calculate the angle with regard to the present items amount.
var anAngle:Number = (rotation - 360 / items.length) * Math.PI / 180;
var result:Point = new Point;
// Figure the position with regard to (x,y) offset.
result.x = x + radius * Math.cos(anAngle);
result.y = y + radius * Math.sin(anAngle);
return result;
}
}
Usage:
var O:Orbiter = new Orbiter;
// Define the offset.
O.x = monster.x;
O.y = monster.y;
// Set radius and rotation speed.
O.radius = 110;
O.speed = 270;
// Enable the rotation processing.
O.start();
// Append items to orbit.
O.items.push(Crystal1);
O.items.push(Crystal2);
O.items.push(Crystal3);
You can change radius and speed any time, as well as add/remove items, thanks to motion smoothing that all will look equally fine.
i am try trying to make space shooter game in which ship is able to rotate and shoot in all directions, now, i do know basics of trigonometry, but i stuck at this point and my brain seems to be frozen so i seek your help.
I have Ship.as and Turret.as , every ship contains some number of turrets, and this is loop that is responsible to create bullet for each turret on players input and its located in Ship.as.
for (var i:int = 0; i < turrets.length; i++)
{
var _pcos:Number = Math.cos(angle / 180 * Math.PI);
var _psin:Number = Math.sin(angle / 180 * Math.PI);
var bulletX:Number = center.x + turrets[i].distance * _pcos;
var bulletY:Number = center.y + turrets[i].distance * _psin;
var bullet:BulletBase = new bulletClass(bulletX, bulletY, angle);
layerBullets.add(bullet);
bullets.push(bullet);
}
variable center is point positioned in exact center of ships sprite, angle is ships rotation towards mouse, turret.distance is distance from center to turret
This is whats happening in Turret.as
public class Turret extends Point
{
private var ship:Ship;
public var distance:Number;
public var angle:Number;
/**
*
* #param x position with angle 0
* #param y position with angle 0
* #param distance distance from center of ship to turret
*/
public function Turret(x:Number = 0, y:Number = 0, ship:Ship = null)
{
super(x, y);
this.ship = ship;
this.x = x;
this.y = y;
var dx:Number = ship.center.x - x;
var dy:Number = ship.center.y - y;
angle = Math.atan2(dy, dx);
distance = Math.sqrt(dx * dx + dy * dy);
}
Now, what is happening with this code is that bullets seems like they are fired from same direction, only one bullet is behind.
I am not math expert and if anyone knows the answer i would really appreciate it.
var _pcos:Number = Math.cos((turret.angle + angle) / 180 * Math.PI);
var _psin:Number = Math.sin((turret.angle + angle) / 180 * Math.PI);
angle is angle of ship
Me and my friend are trying to make an rpg-style game where you see your character from above but we've run into some trouble with object collision. Might be worth mentioning we're doing this in an object oriented AS3 project in flash CS6.
I'm sorry if this has been asked a million times but we've been looking for solutions all day and what we've found so far has either been stuff that's a bit too advanced for us like box2d/nape or just plain collision detection which we know already.
The problem we have is that we want a convenient way to detect collision and prevent the main character from overlapping with objects in the scene, without having it freeze up or get stuck. So far we've scrapped all attempts at solving the issue but here's the rest of the code in case that helps you understand where we're at(sorry if it's difficult to read). Any kind of suggestions or referral to relevant tutorials is appreciated.
The main class
package {
import flash.display.Stage;
import flash.display.MovieClip;
import flash.events.Event;
public class Engine extends MovieClip
{
private var hero:Hero;
private var box1:Box1;
public function Engine()
{
box1 = new Box1();
stage.addChild(box1);
box1.x = stage.stageWidth / 4;
box1.y = stage.stageHeight / 2;
hero = new Hero(stage, box1);
stage.addChild(hero);
hero.x = stage.stageWidth / 2;
hero.y = stage.stageHeight / 2;
}
}
}
The character class
package
{
import flash.display.MovieClip;
import flash.events.Event;
import flash.display.Stage;
public class Hero extends MovieClip
{
private var box1:Box1;
private var stageRef:Stage;
private var vy:Number = 0;
private var vx:Number = 0;
private var limit:Number = 30;
private var rad:Number;
private var bounce:Number = 0.125;
private var _max:Number = 8;
public function Hero(stageRef:Stage, box1:Box1)
{
//box variable was used in previous experiments with hit tests
this.box1 = box1;
this.stageRef = stageRef;
Input.initialize(stageRef);
stageRef.addEventListener(Event.ENTER_FRAME, moveHero);
}
private function moveHero(e:Event):void
{
if (Input.kd("W","UP"))
{
vy = vy < 1 - _max ? _max * -1:vy - 1;
}
if (Input.kd("S","DOWN"))
{
vy = vy > _max - 1 ? _max:vy + 1;
}
else if (!Input.kd("W", "UP", "S", "DOWN"))
{
if (vy > 1)
{
vy = vy < 1 ? 0:vy - 1;
}
else
{
vy = vy > -1 ? 0:vy + 1;
}
}
if (Input.kd("A","LEFT"))
{
vx = vx < 1 - _max ? _max * -1:vx - 1;
}
if (Input.kd("D","RIGHT"))
{
vx = vx > _max - 1 ? _max:vx + 1;
}
else if (!Input.kd("A", "LEFT", "D", "RIGHT"))
{
if (vx > 1)
{
vx = vx < 1 ? 0:vx - 1;
}
else
{
vx = vx > -1 ? 0:vx + 1;
}
}
if (x < limit)
{
x = limit;
vx *= - bounce;
}
if (x > stage.stageWidth - limit)
{
x = stage.stageWidth - limit;
vx *= - bounce;
}
if (y < limit)
{
y = limit;
vy *= - bounce;
}
if (y > stage.stageHeight - limit)
{
y = stage.stageHeight - limit;
vy *= - bounce;
}
x += vx;
y += vy;
rad = (Math.atan2(stage.mouseY - y,stage.mouseX - x)) * 180 / Math.PI;
this.rotation = rad;
}
}
}
A simple way to do collision detection is:
1) Attempt to move the object X to its new position
2) For each other object in the game Y, compute if Y and X overlap (will use different algorithms for rectangle in circle, rectangle in rectangle, circle in circle, etc)
3) If they do overlap, go back to step 1 but attempt to move it half as far. ALTERNATIVELY: If the object you collided with was round, alter the angle of movement to go tangential to it while making it smaller according to how much you rotated it by (the cosine of the angle change, so 0x for 90 degree changes, (sqrt2/2)x for 45 degree changes and 1x for 0 degree changes, makes sense in my head.)
4) If your move was successful, keep it. If the movement length is growing incredibly small and is still being rejected, assume you are at rest and give up.
More complex algorithms would eject you away from the center of what you collided with, so you'll curve around curved objects by walking into them and so on, but then you have to be careful that the ejection doesn't collide you with a third object Z, and it can get tricky. (Have you considered using a physics library? They're coded for a good reason - physics is hard to get right.)
...well, to an incomplete circle.
I have a draggable slider that looks like this:
The blue bar has the instance name track and the pink dot has the instance name puck.
I need the puck to be constrained within the blue area at all times, and this is where my maths failings work against me! So far I have the puck moving along the x axis only like this:
private function init():void
{
zeroPoint = track.x + (track.width/2);
puck.x = zeroPoint-(puck.width/2);
puck.buttonMode = true;
puck.addEventListener(MouseEvent.MOUSE_DOWN,onMouseDown);
}
private function onMouseDown(evt:MouseEvent):void
{
this.stage.addEventListener(MouseEvent.MOUSE_MOVE,onMouseMove);
this.stage.addEventListener(MouseEvent.MOUSE_UP,onMouseUp);
}
private function onMouseUp(evt:MouseEvent):void
{
this.stage.removeEventListener(MouseEvent.MOUSE_MOVE,onMouseMove);
}
private function onMouseMove(evt:MouseEvent):void
{
puck.x = mouseX-(puck.width/2);
//need to plot puck.y using trig magic...
}
My thinking is currently that I can use the radius of the incomplete circle (50) and the mouseX relative to the top of the arc to calculate a triangle, and from there I can calculate the required y position. Problem is, I'm reading various trigonometry sites and still have no idea where to begin. Could someone explain what I need to do as if speaking to a child please?
Edit: The fact that the circle is broken shouldn't be an issue, I can cap the movement to a certain number of degrees in each direction easily, it's getting the degrees in the first place that I can't get my head around!
Edit2: I'm trying to follow Bosworth99's answer, and this is the function I've come up with for calculating a radian to put into his function:
private function getRadian():Number
{
var a:Number = mouseX - zeroPoint;
var b:Number = 50;
var c:Number = Math.sqrt((a^2)+(b^2));
return c;
}
As I see it, the problem you solve is finding the closest point on a circle. Google have a lot of suggestions on this subject.
You can optimise it by first detecting an angle between mouse position and circle center. Use Math.atan2() for that. If the angle is in a gap range, just choose the closest endpoint: left or right.
EDIT1 Here is a complete example of this strategy.
Hope that helps.
import flash.geom.Point;
import flash.events.Event;
import flash.display.Sprite;
var center:Point = new Point(200, 200);
var radius:uint = 100;
var degreesToRad:Number = Math.PI/180;
// gap angles. degrees are used here just for the sake of simplicity.
// what we use here are stage angles, not the trigonometric ones.
var gapFrom:Number = 45; // degrees
var gapTo:Number = 135; // degrees
// calculate endpoints only once
var endPointFrom:Point = new Point();
endPointFrom.x = center.x+Math.cos(gapFrom*degreesToRad)*radius;
endPointFrom.y = center.y+Math.sin(gapFrom*degreesToRad)*radius;
var endPointTo:Point = new Point();
endPointTo.x = center.x+Math.cos(gapTo*degreesToRad)*radius;
endPointTo.y = center.y+Math.sin(gapTo*degreesToRad)*radius;
// just some drawing
graphics.beginFill(0);
graphics.drawCircle(center.x, center.y, radius);
graphics.moveTo(center.x, center.y);
graphics.lineTo(endPointFrom.x, endPointFrom.y);
graphics.lineTo(endPointTo.x, endPointTo.y);
graphics.lineTo(center.x, center.y);
graphics.endFill();
// something to mark the closest point
var marker:Sprite = new Sprite();
marker.graphics.lineStyle(20, 0xFF0000);
marker.graphics.lineTo(0, 1);
addChild(marker);
var onEnterFrame:Function = function (event:Event) : void
{
// circle intersection goes here
var mx:int = stage.mouseX;
var my:int = stage.mouseY;
var angle:Number = Math.atan2(center.y-my, center.x-mx);
// NOTE: in flash rotation is increasing clockwise,
// while in trigonometry angles increase counter clockwise
// so we handle this difference
angle += Math.PI;
// calculate the stage angle in degrees
var clientAngle:Number = angle/Math.PI*180
// check if we are in a gap
if (clientAngle >= gapFrom && clientAngle <= gapTo) {
// we are in a gap, no sines or cosines needed
if (clientAngle-gapFrom < (gapTo-gapFrom)/2) {
marker.x = endPointFrom.x;
marker.y = endPointFrom.y;
} else {
marker.x = endPointTo.x;
marker.y = endPointTo.y;
}
// we are done here
return;
}
// we are not in a gp, calculate closest position on a circle
marker.x = center.x + Math.cos(angle)*radius;
marker.y = center.y + Math.sin(angle)*radius;
}
addEventListener(Event.ENTER_FRAME, onEnterFrame);
EDIT2 Some links
Here are some common problems explained and solved in a brilliantly clear and concise manner: http://paulbourke.net/geometry/ This resource helped me a lot days ago.
Intersection of a line and a circle is a bit of an overkill here, but here it is: http://paulbourke.net/geometry/sphereline/
Rather than trying to move the point along the partial path of the circle, why not fake it and use a knob/dial? Skin it to look like the dot is moving along the path.
Then just set the rotation of the knob to:
var deg:Number = Math.atan2(stage.mouseY - knob.y,stage.mouseX - knob.x) / (Math.PI/180);
// code to put upper/lower bounds on degrees
knob.rotation = deg;
You can test this by throwing it in an enter frame event, but you'll obviously want to put some logic in to control how the knob starts moving and when it should stop.
100% working code.
enter code here
const length:int = 100;
var dragging:Boolean = false;
var tx:int;
var ty:int;
var p1:Sprite = new Sprite();
var p2:Sprite = new Sprite();
p1.graphics.beginFill(0);
p1.graphics.drawCircle(0, 0, 10);
p1.graphics.endFill();
p2.graphics.copyFrom(p1.graphics);
p1.x = stage.stageWidth / 2;
p1.y = stage.stageHeight / 2;
p2.x = p1.x + length;
p2.y = p1.y;
addChild(p1);
addChild(p2);
p2.addEventListener(MouseEvent.MOUSE_DOWN, mouseDown);
stage.addEventListener(MouseEvent.MOUSE_UP, mouseUp);
stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMove);
function mouseDown(event:MouseEvent):void
{
dragging = true;
}
function mouseUp(event:MouseEvent):void
{
dragging = false;
}
function mouseMove(event:MouseEvent):void
{
if (dragging)
{
tx = event.stageX - p1.x;
ty = event.stageY - p1.y;
if (tx * tx + ty * ty > length * length)
{
p2.x = p1.x + tx / Math.sqrt(tx * tx + ty * ty) * length;
p2.y = p1.y + ty / Math.sqrt(tx * tx + ty * ty) * length;
}
else
{
p2.x = event.stageX;
p2.y = event.stageY;
}
}
}
Something like this ought to work out:
private function projectLocation(center:point, radius:uint, radian:Number):Point
{
var result:Point = new Point();
//obtain X
result.x = center.x + radius * Math.cos(radian));
//obtain Y
result.y = center.y + radius * Math.sin(radian));
return result;
}
Obviously, modify as needed, but you just need to send in a center point, radius and then a radian (you can obtain with angle * (Math.PI / 180)). You could easily hard code in the first two params if they don't change. What does change is the radian, and that is what you will need to change over time, as your mouse is dragging (defined by the mouseX distance to the center point - positive or negative).
Hopefully that helps get you started -
update
This was how I was working this out - tho its a tad buggy, in that the puck resets to 0 degrees when the sequence starts. That being said, I just saw that - #Nox got this right. I'll post what I was arriving at using my projectLocation function anyways ;)
package com.b99.testBed.knob
{
import com.b99.testBed.Main;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.MouseEvent;
import flash.geom.Point;
/**
* ...
* #author bosworth99
*/
public class Knob extends Sprite
{
private var _puck :Sprite;
private var _track :Sprite;
private const DIAMETER :uint = 100;
private const RADIUS :uint = DIAMETER / 2;
public function Knob()
{
super();
init();
}
private function init():void
{
assembleDisplayObjects();
addEventHandlers();
}
private function assembleDisplayObjects():void
{
_track = new Sprite();
with (_track)
{
graphics.beginFill(0xffffff, 1);
graphics.lineStyle(1, 0x000000);
graphics.drawEllipse(-RADIUS, -RADIUS, DIAMETER, DIAMETER);
graphics.endFill();
}
this.addChild(_track);
_track.x = Main.stage.stageWidth / 2;
_track.y = Main.stage.stageHeight / 2;
_puck = new Sprite();
with (_puck)
{
graphics.beginFill(0x2DFE07, 1);
graphics.drawEllipse(-8, -8, 16, 16);
graphics.endFill();
x = _track.x;
y = _track.y - _track.width / 2;
buttonMode = true;
}
this.addChild(_puck);
}
private function addEventHandlers():void
{
Main.stage.addEventListener(MouseEvent.MOUSE_DOWN, activate);
Main.stage.addEventListener(MouseEvent.MOUSE_UP, deactivate);
}
private function deactivate(e:MouseEvent):void
{
Main.stage.removeEventListener(MouseEvent.MOUSE_MOVE, update);
}
private var _origin:uint;
private function activate(e:MouseEvent):void
{
Main.stage.addEventListener(MouseEvent.MOUSE_MOVE, update);
_origin = mouseX;
}
private function update(e:MouseEvent):void
{
var distance:Number;
(mouseX < _origin)? distance = -(_origin - mouseX) : distance = mouseX - _origin;
if(distance > 40){distance = 40};
if(distance < -220){distance = -220};
var angle:Number = distance; //modify?
var radian:Number = angle * (Math.PI / 180);
var center:Point = new Point(_track.x, _track.y);
var loc:Point = projectLocation(center, RADIUS, radian);
_puck.x = loc.x;
_puck.y = loc.y;
}
private function projectLocation(center:Point, radius:uint, radian:Number):Point
{
var result:Point = new Point();
//obtain X
result.x = center.x + radius * Math.cos(radian);
//obtain Y
result.y = center.y + radius * Math.sin(radian);
return result;
}
}
}
Main difference is that I'm obtaining the angle via horizontal (x) movement, and not checking against the cursors angle. Thos, trapping the values manually feels kinda hacky compared to #Nox very good soution. Would of cleaned up had I kept going;)
Nice question - Cheers
Sprite.rotation+=10;
Sprite.rotation*=0.97;
because in as3 the system goes from 180 to -180 I don't know how to apply a drag to a constantly rotating object if it moves either direction. Do I have to convert to radians somehow and then do something? I am pretty bad with math.
I'm not sure "drag" makes sense with the code you've posted. What you've shown would slowly wind the object back to 0 rotation.
If you want a drag/acceleration effect, create a separate variable with your acceleration factor, which you apply every frame. Then, you can apply a factor to that variable to slow rotation down/speed it up.
Something like:
private var _rotationAcceleration:Number = 0;
private var _dragFactor:Number = 0.97;
private var _clip:Sprite;
private function startSpin():void {
_rotationAcceleration = 10.0;
}
private function enterFrameListener(event:Event):void {
_clip.rotation += _rotationAcceleration;
_rotationAcceleration *= _dragFactor;
}
I think you're looking for this:
private function updateRotation():void
{
var _dx:Number = _player.x - stage.mouseX; // rotate _player mc to mouse
var _dx:Number = _player.y - stage.mouseY; // rotate _player mc to mouse
// which way to rotate
var rotateTo:Number = getDegrees(getRadians(_dx, _dy));
// keep rotation positive, between 0 and 360 degrees
if (rotateTo > _player.rotation + 180) rotateTo -= 360;
if (rotateTo < _player.rotation - 180) rotateTo += 360;
// ease rotation
var _trueRotation:Number = (rotateTo - _player.rotation) / 5; // rotation speed 5
// update rotation
_player.rotation += _trueRotation;
}
public function getRadians(delta_x:Number, delta_y:Number):Number
{
var r:Number = Math.atan2(delta_y, delta_x);
if (delta_y < 0)
{
r += (2 * Math.PI);
}
return r;
}
public function getDegrees(radians:Number):Number
{
return Math.floor(radians/(Math.PI/180));
}
It actually does goes from 180 to -180 (contrary to what Reuben says), but higher/lower values get automatically corrected to that range (i.e. 181 is converted to -179)... one way to work with this is to use an auxiliary variable for your math (animation or whatever) and then assign it to the rotation, say:
myVar+=10;
myVar*=.97;
clip.rotation=myVar;