Radians are used in math because
They measure arc-length on the circle, i.e. an arc of angle theta on a circle of radius r is just r * theta (as opposed to pi/180 * r * theta).
When trig functions are defined in terms of radians, they obey simpler relationships between each other, such as cosine being the derivative of sine, or sin(x) ~= x for small x. If ...
I'm a bit skeptical of using atan here, because the tangent ratio shoots off to infinity at certain angles, and may lead to numerical errors (even outside of the undefined/divide by zero case for shooting straight up/down).
Using the formulae worked out in this answer, we can parametrize this in terms of the (initially unknown) time to impact, T, using the ...
Others have pointed out how you can use the sign of the dot product to broadly determine the angle between two arbitrary vectors (positive: < 90, zero: = 90, negative: > 90), but there's another useful geometric interpretation if at least one of the vectors is of length 1.
If you have one unit vector \$\hat U\$ and one arbitrary vector \$V\$, you can ...
There's a great writeup on this process by Mike Day:
It is also now implemented in glm, as of version 0.9.7.0, 02/08/2015. Check out the implementation.
To understand the math, you should look at the values that are in your rotation matrix. In addition, you have to know ...
Calculate a vector from B to A, normalize it (divide by the vector's length), then multiply by the circle size:
vx = A.x - B.x
vy = A.y - B.y
length = sqrt(vx*vx + vy*vy)
C.x = vx / length * size + A.x
C.y = vy / length * size + A.y
For the angle you can use the atan2 function, if your language has it.
The Red is:
atan2(vectorA.y - vectorB.y, vectorA.x - vectorB.x)
The Green is:
atan2(vectorB.y - vectorA.y, vectorB.x - vectorA.x)
The Blue which I think is what you are looking for:
atan2(vectorA.y, vectorA.x) - atan2(vectorB.y, vectorB.x)
You can use abs() if you want the absolute value like I think you do.
Sometimes you will get a value that is ...
Nathan's answer is very concrete. I'd like to supply a more general view:
The most complex mathematical concept that is natively implemented in most processing units are floating point numbers as models for the field of real numbers ℝ. Visual geometriy is based on the three dimensional real vector space ℝ³. Coordinates are real numbers. Geometric quantities ...
The sign of the dot-product of C with AB will be positive when the vector component of CD parallel to vector AB is in the direction AB, and negative when it is in the direction BA.
The sign of the (z-component of the) cross-product of vector CD with vector AB will indicate which side of AB the agent is approaching from.
Depending on your sign conventions, ...
When people refer to an isometric perspective in the context of pixel art or video games, they are usually talking about a dimetric projection where the z-axis is vertical and the x and y axis go diagonal with a vertical:horizontal ratio of 1:2. The reason is that this is much easier to pixel than a "true" isometric projection:
Alternatively there are also ...
Let s1 and s2 the segments, so you can calculate the angle of each using atan2(s.p1.y-s.p2.y,s.p1.x-s.p2.x) where p1 and p2 are the two points defining s;
double theta1 = Math.atan2(s1.p1.y-s1.p2.y,s1.p1.x-s1.p2.x);
double theta2 = Math.atan2(s2.p1.y-s2.p2.y,s2.p1.x-s2.p2.x);
Taking the absolute value of the difference, you get the angle between the ...
As I found out later here isometric in video games in game development it is better to have tiles with a 1/2 height/width ratio, which displays better and is nice for calculations. As I measured, having those ratios also means having a 127 degrees angle.
Later, I found this answer on gamedev : What is the view perspective angle of most 2.5D isometric games ...
If the resulting scalar is 0; then it means the 2 vectors are perpendicular to each other (angle difference 90 degrees) . If the resulting scalar > 0; then the angle difference between them is less than 90 degrees. If the resulting scale is < 0; then the 2 vectors are facing opposite directions ( or angle difference > 90 degrees).
This can be useful in ...
I think you could switch your cos with sin and vise versa if you're really against adding 90 in your function, but I think adding 90 is a perfectly viable solution. Once a function works, you shouldn't have to care what's inside of it.
You get the path the same way you'd move the object when you shoot it. Just have a tight loop that simulates the movement of the object and keep track of the position every so often. Now you have a list of positions, if you draw a dot at each position, you have a dotted line the represents the path of the object if it were to be shot from that angle.
Thanks to DMGregory, I now have a C# extension script which can be used for this. Most recent version can be found on GitHub.
public static class Rigidbody2DExtensions
/// Applies the force to the Rigidbody2D such that it will land, if unobstructed, at the target position. The arch [0, 1] determines the ...
My recommendation is to compute a restorative torque to apply to the object. This is physically more accurate than setting the velocity directly, and the simulation will be better behaved.
This solution should also work for any launch angle. Below is a gif of this method at work stabilizing arrows launched from a car.
Did you try even a cursory search for this? It's pretty standard vector math:
v1 = normalize(end1X - startX, end1Y - startY);
v2 = normalize(end2X - startX, end2Y - startY);
angle = acos(dot(v1, v2)) * 180.0/pi;
This will always give a value from 0 to 180, giving you the smallest positive angle clockwise or counter-clockwise.
In 2D, you can fix a ...
It looks like your code to mirror the bullet's angle just flips the sign of the angle. This works great for reflecting an angle about the x-axis. 45 degrees becomes -45 degrees, etc.
Now imagine reflecting off a wall that itself has an angle of 90 degrees. In this case, 85 degrees is reflected to 95 degrees; 45 degrees becomes 135 degrees, etc. Basically ...
Instead of an approach that relies heavily on trig (ie. your Atan2) as a means to solve the problem, 3d lends itself to a more linear algebra approach.
float v1ComponentAlongD = Vector3.Dot(v1, d); // look ma, no angles
Check out the last two paragraphs in Shawns blog here: http://blogs.msdn.com/b/shawnhar/archive/2010/02/12/doing-math-in-2d-vs-3d.aspx
A possible solution is to use the Dot Product. Of course, you need two vectors and not two angles, but I guess you're using them (otherwise I wouldn't explain how you're having 3D angles).
Quoting Van Verth & Bishop from the book Essential Mathematics for Games & Interactive Applications, page 30-31:
A more common use of the dot product is to test ...
The white vector is the correct vector with the code you have. If you're only ever adding integers to your position, the movement is going to be at increments of 45 degrees. That's restricted to orthogonal and diagonal movement only. If you want free movement you should be normalizing the movement vector.
Check to see if the libraries you're using have a ...
If I understand what you're asking, the vector CD is just a vector, not a ray, so only the direction matters, not location. However, AB is a line segment, not just a vector, so its location matters.
Your tests have one 'if' test to make two cases, but I think you actually have four cases. Let's look at the diagram in AB's reference frame:
If you can ...
the dot product is equal to v1.length() * v2.length() * dot(v1.normalized(), v2.normalized())
the most you can get out of that is whether the angle is acute or not or pass to other algorithms where you can delay the normalization. But you can get the normalized from the non-normalized by dividing with sqrt(v1.lengthSquared() * v2.lengthSquared()) (saves a ...
Byte56's answer is very good, especially for the example image given where simulating the movement of each "ball" in the line will work well. I'll give you an alternative idea however which might work better, or might be easier to implement if you are trying to work with a dashed line (with or without animation), something like -- -- -- --
Calculate the ...
You're not taking into account the inverted Y axis in comparison to the normal X axis in most (maybe all?) programming languages. The top left corner of the screen is (0, 0), and is positive in the right and down directions.
So if the bottom middle of your screen is, for example, (300, 400), and you click at (0, 400), then your triangle will be a first ...
You wil want to subtract the touch with the ref point:
//180 is inversed? 180 is when touch is on the right side...
let dy = (touch.y - refPoint.y) //opposite
let dx = (touch.x - refPoint.x) //adjacent
This results in the (dx, dy) vector being from the refPoint to the touch point (as you would expect).
if (Math.abs( angle) > mindelta )
I think it depends on floating point math errors, I suggest to define a min angle (mindelta in my code example) inside wich, the turret doesn't move
This might not be your only issue but I noticed you're using sin and cos with degrees. You must first convert your angles to radians for those functions to work properly (read "Parameters" here):
#define PI 3.14159265
std::pair<int,int> endpoint(double angle, int x1 , int y1, int length)
double x2 = x1 + (length * cos(angle * PI / ...