Thread: simple xy motion question...

Originally Posted by chunlee

hi there:

i am stuck on a simple math problem that i wonder if anyone can point me to the right difrection.

i what to write a algorithm that draws a object and have it move towards a known xy coordinate at contant speed. for example, if the object is at (x, y) and the target is (5, 3), how would i work out the path between them and code it?

many thanks

CHUN

Let vx = velocity in the x direction and vy = velocity in the y direction.

Then deltax = vx * deltat and deltay = vy *deltat, where deltax is the change in x coordinate during time deltat and deltay is the change in y coordinate during time deltat

Let s = the speed, then vx = s * cos(theta) and vy = s * sin(theta), where

cos(theta) = (5 - x)/sqrt((5 - x) *(5 - x) + (3 - y) * (3 - y)) and
sin(theta) = (3 - y)/sqrt((5 - x) *(5 - x) + (3 - y) *( 3 - y))

If speed and direction are constant, everything up to and including the calculations for vx and vy are done once at the beginning of the transition, then deltax and deltay are applied incrementally

Does that get you started?

Regards,

Dave

Consider something along the lines of the Bresenham line drawing algorithm. You can use this method to "chart the path" of where your object needs to go.

Quzah.

It's easier than that.

Code:

 
struct Vector2D
{
float x;
float y;
};
 
 
void GetVectorTo(Vector2D Start, Vector2D End, Vector2D &Result)
{
float vector_x=Start.x-End.x;
float vector_y=Start.y-End.y;
float totaldist=sqrt((vector_x*vector_x)+(vector_y*vector_y));
float oneOverDist=1.0f/totaldist;
Result.x=vector_x*oneOverDist;
Result.y=vector_y*oneOverDist;
}

For DirectX using the D3DX library:

Code:

 
void GetVectorTo(D3DXVECTOR2 Start,D3DXVECTOR2 End,&D3DXVECTOR2 Result)
{
D3DXVECTOR2 VectorFromStartToEnd;
D3DXVec2Subtract(&VectorFromStartToEnd,&Start,&End);
D3DXVec2Normalize(&Result,&VectorFromStartToEnd);
}

This function returns a normalized or unit vector from Start to End. All vectors will lie on a unit circle and thereby can be used to increment your object each frame.

The use for this code is:

Code:

 
class Object2D
{
Vector2D Position;
float Speed;
float Angle;
... 
...
 
};
 
 
void Object2D::ComputeVectorToTarget(Object2D Target)
{
Vector2D Result;
 
GetVectorTo(Position,Target.Position,Result);
VelocityVector=Result;
Angle=atan2(VelocityVector.x,VelocityVector.y);
 
}
 
void Object::Update(float _frameTimeDelta)
{
Position.x+=(VelocityVector.x*Speed)*_frameTimeDelta;
Position.y+=(VelocityVector.y*Speed)*_frameTimeDelta;
}

So to get the vector from Object/Point A to Object/Point B

1. Create a Vector V from Object A to Object B by subtracting them.
2. Compute length of Vector V by using distance formula.
3. Divide each element of Vector V by the distance you just computed - or in simpler terms normalize Vector V.

I use oneOverDistance because dividing by distance is the same as multiplying by its reciprocal. A floating point multiplication is much faster than a floating point divide.

The angle is computed by taking the arc tanget of y over x. The C math function atan2 will do this for you. And sorry for using a class and other C++ code on a C board but people will get over it.

cos(theta) = (5 - x)/sqrt((5 - x) *(5 - x) + (3 - y) * (3 - y)) and
sin(theta) = (3 - y)/sqrt((5 - x) *(5 - x) + (3 - y) *( 3 - y))

Essentially the same thing with (5-x) being the x component of Vector V and (3-y) being the y component of Vector V.