Getting an angle in degrees from north

Question

This may have been asked already, but I was unable to find it, because I don't really know what I'm looking for. I drew a picture:

I need theta. I've seen various solutions using Vector.Dot, and Math.Atan2, but they don't seem to work...

BTW, I need the output in degrees. On previous tries, I ran my results through MathHelper.ToDegrees(), but got values over 360, which shouldn't be possible.

This is my current code:

    Vector2 mouse = new Vector2(Mouse.GetState().X, Mouse.GetState().Y);
    Vector2 delta = mouse - Position;
    angle = Math.Atan2(delta.X, -delta.Y);
    angle = MathHelper.ToDegrees((float)angle);

EDIT: A little more info. I'm making a 2D game, and need the angle to 'rotate' one of my sprites (simply changing which sprite I'm displaying). The code for how I'm doing this is below.

public static Direction GetDirection(double radians)
        {
            if (radians > GetRadians(Direction.Up).Lower && radians < GetRadians(Direction.Up).Upper)
            {
                return Direction.Up;
            }
            else if (radians > GetRadians(Direction.UpRight).Lower && radians < GetRadians(Direction.UpRight).Upper)
            {
                return Direction.UpRight;
            }
            else if (radians > GetRadians(Direction.Right).Lower && radians < GetRadians(Direction.Right).Upper)
            {
                return Direction.Right;
            }
            else if (radians > GetRadians(Direction.DownRight).Lower && radians < GetRadians(Direction.DownRight).Upper)
            {
                return Direction.DownRight;
            }
            else if (radians > GetRadians(Direction.Down).Lower && radians < GetRadians(Direction.Down).Upper)
            {
                return Direction.Down;
            }
            else if (radians > GetRadians(Direction.DownLeft).Lower && radians < GetRadians(Direction.DownLeft).Upper)
            {
                return Direction.DownLeft;
            }
            else if (radians > GetRadians(Direction.Left).Lower && radians < GetRadians(Direction.Left).Upper)
            {
                return Direction.Left;
            }
            else
            {
                return Direction.UpLeft;
            }
        }
public static Radians GetRadians(Direction direction)
        {
            Radians r = new Radians(0,0);
            switch (direction)
            {
                case Direction.Up:
                    r = new Radians(15 * increment, increment);
                    break;

                case Direction.UpRight:
                    r = new Radians(1 * increment, 3 * increment);
                    break;

                case Direction.Right:
                    r = new Radians(3 * increment, 5 * increment);
                    break;

                case Direction.DownRight:
                    r = new Radians(5 * increment, 7 * increment);
                    break;

                case Direction.Down:
                    r = new Radians(7 * increment, 9 * increment);
                    break;

                case Direction.DownLeft:
                    r = new Radians(9 * increment, 11 * increment);
                    break;

                case Direction.Left:
                    r = new Radians(11 * increment, 13 * increment);
                    break;

                case Direction.UpLeft:
                    r = new Radians(13 * increment, 15 * increment);
                    break;
            }

            return r;
        }

Answer 1

Two parts: 1. coordinate systems for angles can be...finicky. 2. You don't really need degrees for anything, with the possible exception of outputting their value to the user interface.

Coordinate system angles

So you want an angle from "North", and judging from your example math, that means the -Y direction (in sprite coordinates with the origin in the upper left). Also judging from your example, you want it to grow clockwise. That's fine, although it varies from math convention slightly, which starts the unit circle pointing right and grows counter-clockwise. So instead of using a function that expects normal coordinate systems (and reversing the arguments you pass into it), use plain Math.Atan() instead.

There are surely elegant ways to deal with angles in any convention and coordinate system. But I have yet to find one. There always seem to be troubles when angles switch from one sign of angle to another. In order to avoid headaches with different cut-offs between the various ranges of output of trigonometric functions, I suggest you build a logic switch per quadrant. Quadrants can be from North to East, East to South, South to West, and West back to North. Like so:

// assert (delta != Vector2.Zero)
double angle = 0;
if (delta.X >= 0) {
  if (delta.Y > 0) {
    //quadrant 1
    angle = (0 * PI) + Math.Atan(delta.X / delta.Y);
  } else if (delta.Y < 0) {
    //quadrant 2, arctan will yield negative values, so work back from "South"
    angle = (1 * PI) + Math.Atan(delta.X / delta.Y);
  } else {
    // maybe Math.Atan2 handles the case of y=0.  But why leave that to chance?
    // due East
    angle = (1/2 * PI);
  }
} else { // (delta.X < 0)
  if (delta.Y < 0) {
    //quadrant 3, both coordinates negative, arctan will yield positive values
    angle = (1 * PI) + Math.Atan(delta.X / delta.Y);
  } else if (delta.Y > 0) {
    //quadrant 4, arctan gives negative values, angle increases toward 2PI
    angle = (2 * PI) + Math.Atan(delta.X / delta.Y);
  } else {
    // due West
    angle = (3/2 * PI);
  }
}

Using radians like the universe intended

Ok, now you have a useful angle that is guaranteed to range from 0 to 2PI. It is in natural units, so you can apply all kinds of extra math on it quickly and efficiently using normal trigonometry functions. You get this advantage because you didn't stop to prematurely convert your angle into arbitrary, weird, and non-useful units called degrees. But if you really, really must display that unit to the user as degrees, then you can call MathHelper.ToDegrees(angle) at the very end.

Answer 2

I understand your problem to be this:

You want to know from your Actor where the mouse is so that you can point in roughly that direction. In particular, you are limited to 8 facings.

You can get most of where you want to go with determining the angle from point a to point b using Math.atan2, and then by changing to range from [0..2*PI) to [0..8).

double theOctant=Math.Round(Math.Atan2(y2-y1,x2-x1)*4/Math.PI);

This will give you one of 8 values: -3,-2,-1,0,1,2,3,4, which will map to one of your eight directins.

0 is in the positive x direction, and increases going clockwise.

However, if you simply rotate your original x,y coordinate to the left by 90 degrees, like so:

double theOctant = Math.Round(Math.Atan2(-dx,dy) * 4 / Math.PI);

You wind up with a value of -4 for north, -3 for northeast, and so on, and simply adding 4 will give you 0..7, which is likely all you wanted in the first place:

double theOctant = Math.Round(Math.Atan2(-dx,dy) * 4 / Math.PI) + 4;

From here, you could cast to your enum if the values match up, and you are done.