C# Set Rotation of Object to Face Coordinates

Question

I'm making a game in a custom engine using C#. (Not Unity)

I've got a large grid and the x/y coordinates of two objects. The Player object and the Destination object. Along with the player's current rotation in degrees (0-360).

I've become too reliant on existing game engines and cannot work out how to find the rotation I need to put the player at to face the target.

playerRotation;//0 to 360 degrees.
playerX double = 47.43;
playerY double = 43.36;
targetX double = 52.15;
targetY double = 38.67;

My method at the moment is to try and get the distance between the objects by:

float distanceX = Math.Abs(playerX - destinationX);
float distanceY = Math.Abs(playerY - destinationY);

Which seems to work fine. Then I need to rotate the player to face the destination and have them move towards it until distanceX/Y are <= 0.

Edit: I've been messing with Atan2 to try and get the answer.

Vector2 playerCoords = new Vector2(playerX, playerY);
Vector2 targetCoords = new Vector2(targetX, targetY);

double theta = Math.Atan2((targetCoords.yValue - playerCoords.yValue), (targetCoords.xValue - playerCoords.xValue));

theta = theta * (180 / Math.PI);//Convert theta to degrees.

double sigma = playerRotation;//Direction in degrees the player is currently facing.

double omega = sigma - theta;

OutputLog("omega: " + omega);

My output log should be showing me the degrees my player needs to be facing to be facing the target. But it's giving me the wrong results.

Player: (4782, 4172) and Target: (4749, 4157)

Angle should be about 286~.

But Theta = -155 and omega = 229.

Answer 1

Vector math can be very helpful, and it's not that complicated.

First vectors would be your player position and destination's:

Vector2 playerPos = new Vector2(playerX, playerY);
Vector2 destinationPos = new Vector2(destinationX, destinationY);

Now you can just subtract both vectors, to get a vector which points from one position to the other.

Vector2 delta = destination - playerPos; // Note, it might be the other way around: playerPos - destination

That delta vector has a length, and that is the distance between both points. There is usually a Length and a LengthSquared property available on the Vector class. Be aware however that calculating the length is quite CPU intensive because it uses a square root. If you want to compare that distance to a fixed distance like 200, just use the length squared and compare it to (200 * 200) which is way faster.

You can also use that delta, to let a bullet fly from one position to the other. You just need to normalize delta, there's a method for it, and you have it scaled down to length one. You can now use that delta, multiplied with a speed on each physics cycle to change the bullets position.

Now to get the angle, you can just use: double angle = Math.Atan2 (delta.Y, delta.X); // Note that y and x are reversed here, and it should be like that.

Note that this angle is in radians, not degrees. A circle in radians starts at -PI and ends at PI. A full circle therefore is 2 * PI. To convert radians to degrees, you can see this question

Edit

I always assume that 12 o'clock is 0 degrees, 3 o'clock is 90, 6 o'clock is 180 and 9 o'clock is 270.

But actually in the cartesian coordinate system things are a bit different. I also made this false assumption in the code below.

But it turned out that I was wrong. See this picture

Now if you look at my sourcecode, all my variables are named incorrectly. If you look at their values however you can see that they match up with the picutre. Therefore the Atan2 correction is as it's supposed to be. // Using Vector2 from System.Numerics;

internal static double RadianToDegree(double rad)
{
    double thetaDegree = rad * (180.0 / Math.PI);

    // Convert negative angles into positive ones
    // https://stackoverflow.com/a/25725005/7671671
    double thetaDegree2 = (thetaDegree + 360) % 360;

    return thetaDegree2;
}

internal void Run()
{
    // Player: (4782, 4172) and Target: (4749, 4157)

    Vector2 player = new Vector2(4782, 4172);
    Vector2 target = new Vector2(4749, 4157);

    Vector2 delta = target - player;

    double theta = Math.Atan2(delta.Y, delta.X);
    double thetaDegree = RadianToDegree(theta);

    // Given cartesian coordinate system
    // positive y is up, negative is down
    // positive x is right, negative is left

    // Falsely assuming up is 0
    // Falsely assuming right is 90
    // Falsely assuming down is 180
    // Falsely assuming left is 270
    Vector2 v0 = new Vector2(0, 1);
    Vector2 v45 = new Vector2(0.5f, 0.5f);
    Vector2 v90 = new Vector2(0.5f, 0);
    Vector2 v180 = new Vector2(0, -1);
    Vector2 v270 = new Vector2(-1, 0);

    double theta0 = Math.Atan2(v0.Y, v0.X);
    double theta45 = Math.Atan2(v45.Y, v45.X);
    double theta90 = Math.Atan2(v90.Y, v90.X);
    double theta180 = Math.Atan2(v180.Y, v180.X);
    double theta270 = Math.Atan2(v270.Y, v270.X);

    double result0 = RadianToDegree(theta0);
    double result45 = RadianToDegree(theta45);
    double resultv90 = RadianToDegree(theta90);
    double resultv180 = RadianToDegree(theta180);
    double resultv270 = RadianToDegree(theta270);

    // result 0 --> 90
    // result 45 --> 45
    // result 90 --> 0
    // result 180 --> 270
    // result 270 --> 180
}