I'm trying to make a game and I need the player(rectangle) to always be looking at the mouse, I have found some pages on this but I can't seem to understand the math.
Main:
g2d.rotate(calculateRotation, x,y);
g2d.fill(player);
g2d.rotate(-calculateRotation, x,y);
Mouse Listener:
int mx = e.getX();
int mY = e.getY();
float rotation = Math.atan((mouseX-playerX)/(mouseY-playerY)); //<--- I don't know
would it be something like this?
You should use linear algebra- instead of using sines and cosines, you use vectors.
If you have P1=(x1,y1) (where the player is) and P2=(x2,y2) (where the mouse pointer is), then you have the vector V=(x2-x1,y2-y1)=(v1,v2), which has length v=|V|=sqrt(v1^2+v2^2). Then you have the versor (which is a vector of length=1) M=(v1/v,v2/v)=(m1,m2).
Then instead of computing an angle, you can rotate points by mapping (x,y)->(x* m1-y* m2, x* m2+y*m1).
See also https://en.wikipedia.org/wiki/Rotation_matrix#In_two_dimensions
(and remember to take care in the case V=0)
Note: using atan is OK, but you will need to check the signs of x and y.. If they are both negative you'll find the wrong angle; and if one is positive and the other is negative, you still don't know if your arrow points NW or SE.
Related
When two of my objects collide, I want one of them to push the other.
while (checkCollision(this, cl)){
//cl is referring to the other entity, non-cl things my entity
double an = Assist.angle(new Vector3f(cl.z, 0, cl.x),
new Vector3f(z, 0, x));
double moveZ = Math.cos(Math.toRadians(an));
double moveX = Math.sin(Math.toRadians(an));
cl.z += moveZ;
cl.x += moveX;
}
The checkCollision() method works perfectly fine, detecting if my two objects (in this case 3D ships) have collided.
I am then getting the angle between the other object and my current one, and then using that angle, I am pushing away the other object. However - It isn't working.
The other object always seems to be pushed torwards the +x direction, and the Z doesn't seem to have any strict pattern, but isn't working correctly either.
Here is my method to calculate the angle (Assist.angle()):
public static double angle(Vector3f vec1, Vector3f vec2){
double so = Math.toDegrees(Math.atan2(((vec1.z) - vec2.z), ((vec1.x) - vec2.x)));
return Math.abs(so);
}
There must obviously be something blatantly wrong here - But I'm not seeing it, and I've been working for hours to try and get this code to work.
Math.atan2() takes vector cords not angles, radian or otherwise. What it returns is in radians.
For historical reasons to stupid to go into Math.atan2() expects y before x.
http://docs.oracle.com/javase/7/docs/api/java/lang/Math.html#atan2(double,%20double)
Also I don't think that Math.abs(so) at the end is helping anything.
Take a look at this:
From your comments it sounds like you think you need Ab. You don't. If you just want to bounce off (which is a grand simplification) you need Ta and it's compliment.
Does anybody know how to find out if a set of coordinates are within a triangle for which you have the coordinates for. i know how to work out length of sides, area and perimeter, but i have no idea where to begin working out the whereabouts within the triangle of other points.
Any advice would be appreciated
You can create a Polygon object.
Polygon triangle = new Polygon();
Add the vertexes of your triangle with the addPoint(int x, int y) method.
And then, you just need to check if the set of coordinates is inside your triangle using contains(double x, double y) method.
Use the contains method of the Polygon class as documented here.
For a solution without using the Polygon-class:
Assume that you have giving three points A,B,C the vertices of your polygon. Let P be the point you want to check. First calculate the vectors representing the edges of your triangle. Let us call them AB, BC, CA. Also calculate the three vectors PA, PB, PC.
Now calculate the cross product between the first two of the vectors from above.
The cross product of the first pair gives you the sin(alpha), where alpha is the angle between AB and PA, multiplied with a vector pendenpicular to AB and PA. Ignore this vector because we are interested in the angle and take a look at the sine (in the case of 2D vectors you can imagine it as the vector standing perpendicular to your screen).
The sine can take values between (let's say for the ease) betwenn 0 and 2*Pi. It's 0 exactly at 0 and Pi. For every value in between the sine is positive and for every value between Pi and 2*Pi it's negative.
So let's say your Point p is on the left hand side of AB, so the sine would be positive.
By taking the cross product of each pair from above, you could easily guess that the point P is on the left hand side of each edge from the triangle. This just means that it has to be inside the triangle.
Of course this method can even be used from calculating whether a point P is in a polygon. Be aware of the fact, that this method only works if the sides of the polygon are directed.
I'm creating a very very simple game for fun. Realizing I needed the trajectory of an object given an angle and a velocity, it seemed logical to use this parametric equation:
x = (v*cos(ø))t and y = (v*sin(ø)t - 16t^2
I know that this equation works for a trajectory, but it isn't working with most ø values I use.
Do java angles work any differently from normal angle calculation?
My goal is for the object to start from bottom left of the window and follow an arc that is determined by the speed and angle given. However it tends to go strange directions.
The value of ø should be horizontal at 0 degrees and vertical at 90, and in the equation it refers to the angle at which the arc begins.
This is my first ever question post on this site, so if I'm missing anything in that regard please let me know.
Here is the calculating part of my code
not shown is the void time() that counts for each 5ms
also I should mention that the parX and parY are used to refer to the x and y coordinates in an unrounded form, as graphics coordinates require integer values.
Any help is much appreciated, and thank you in advance!
public void parametric()
{
parX = (float) ((speed*cos(-ø))*time);
gravity = (time*time)*(16);
parY = (float) ((float) ((speed*sin(-ø))*time)+gravity)+500;
xCoord = round(parX);
yCoord = round(parY);
}
Do java angles work any differently from normal angle calculation?
You only need to read the docs
public static double cos(double a)
Parameters:
a - an angle, in radians.
I guess you are using degrees instead of radians?
what I want to do is the following: I have an object (blue point) and I want to point it to other object no matter where it is located around it (green point). So I need to know the angle between these two objects to do what I want right?
http://s13.postimage.org/6jeuphcdj/android_angle.jpg
The problem is, I don't know what to do to achieve this. I've already used atan, math.tan and so many other functions but without any good results.
Could you help me? Thanks in advance.
Calculate a dot product of object vectors. Use Math.acos on the value you get. That will give you an angle in radians.
So, say your blue dot is at vec1 = (50, 100) and green one at vec2 = (100, 400).
A tuple (x, y) as a two dimensional vector describes object's position and distance from (0, 0) on your screen. To find the angle between these two vectors, you do a standard, binary dot product operation on them. This will get you a scalar (a value, cos(Theta)), but you want the inverse of it (acos) which is the angle you're looking for.
You can get a better understanding on the matter here
Suppose the coordinates of the blue and green points are (xblue, yblue) and (xgreen, ygreen) respectively.
The angle at which the blue point sees the green point is:
double angleRadians = Math.atan2(ygreen-yblue, xgreen-xblue);
If you want the angle in degrees:
double angleDegrees = Math.toDegrees(angleRadians);
I am trying to find a method which will rotate an object to make it face a specified point, however the numbers I am getting don't make much sense and I don't think I understand what the math methods are returning.
Here is my code:
public void rotate(double x, double y) {
rotateRight(Math.toDegrees(Math.atan2((x - getX()), (y - getY()))));
}
x and y are the specified point and getX() and getY() are the objects current point, so I am trying to find the number of degrees that object has to turn right to be facing the specified point.
Can anyone recommend a reliable way to do this?
You need a matrix transformation to do it properly.
Your naming is a bit confusing, so I'm making some assumptions here. Your "object" is located at the origin (0,0) and getX() and getY() return the point that the object is currently facing, and you want the object to face a new point.
From here it's simple trig and arithmetic. First thing is to figure out your current angle:
current_angle=atan(getX()/getY())
Your new angle will be
new_angle=atan(newX/newY)
and the angle you need to rotate through is naturally,
rotation_angle=new_angle - current_angle
It depends on what units you are using. Personally, in radians, i have this function in my snippets.
public static double getAngleBetween(double x1, double y1, double x2, double y2)
{
return(Math.atan2(y1-y2, x1-x2));
}
Which results in the angle (in radians) between any two abstract points.
The angle returned by Math.atan2() is absolute. In order to turn it into a relative rotation you first need to know what the current angle is, then you need to subtract the two.