Given a vector (x,y) with magnitude m that is rotated t (theta) degrees/radians from the positive x axis, the end position of the vector is always defined by:

x = m cos t
y = m sin t

Hope that helps.

While it may go without saying be mindful of if you are rotating using degrees or radians.

Second'd, I've actually made that very mistake before and wondered why giving something a rotational speed of "5/sec" was resulting in such wild spins.
[quote name='Sean_Seanston'] EDIT: If the cos and sin of 45 are around 0.7... then wouldn't that mean that setting a point's x to m.cos.t and y to m.sin.t would just bring the point closer to the start of the vector if you rotate by 45? [/quote]
0.7 * magnitude of the vector (aka the hypotenuse of the triangle formed by the x and y components). One dimension will likely shrink while another will grow due to 0.7 being higher than the sin or cos value of the previous rotational angle. (Try out the math with a simple case: magnitude 5, original angle 0, so vector of (5, 0). Now rotate by 45 degrees. Magnitude should remain the same after you calculate the new x and y components)

The other thing to note here, I just gave you the generic formulae for x and y components of a rotated vector. You likely need to do some pre- and post- rotation translation for the math to work properly at the arbitrary x,y value of the player. If player is at (50,50) and the gun point is at (55,50) you'll need to calculate the relative position/magnitude of the gun first, then apply the math from that relative context.

your high level code would probably look like:

gunposition -= playerposition;
gun.rotate(player.rotationAngle);
gunposition += playerposition;

or some variance thereof.

Here's my code here so far:

offsetX = x;
offsetY = y;

float m = sqrt( ( x * x ) + ( y * y ) );

float mCentre = sqrt( 32.0f*32 + 32*32 );

float mPoint = m - mCentre;

offsetX = mPoint * cos( ( D3DX_PI / 180.0f ) * 45 );
offsetY = mPoint * sin( ( D3DX_PI / 180.0f ) * 45 );

xPos = offsetX + parent->getX();
yPos = offsetY + parent->getY();


m is the magnitude of the vector from 0,0 to the point.
mCentre is the magnitude from the centre of the character (or rather, the centre if the character was at 0,0) to the point.
mPoint is then (hopefully... if I did that right) the magnitude from the centre of the character to the point, since I'm rotating around the character's centre.

If I use that, the point goes from being above the character in the centre, to being somewhere near the bottom left corner, when obviously I need it to be somewhere in the top-right to reflect the character now facing that direction.

I think you're making it overly complicated with the additional magnitude calculations, (which won't do what you need anyway since a magnitude is directionless). All you should need to do is find the relative x and y of the gun. This means subtracting the player position vector from the gun vector, doing rotation, then adding back the player position vector to the newly modified gun vector.

Depending on the rest of your code, you should be able to keep the values of your gun vector separate, meaning store the gun vector as its relative values (say, 5,0 if the game starts out with the player facing right) and then do all the rotations internal to that vector. Then when you draw the player and gun, simply draw the gun at playerPosition + gunPosition.

(Keep in mind this is all very off-the-cuff, I prefer to implement a geometric vector class if the API doesn't already have one)

class Gun{
...
float xPos, yPos, magnitude;
...
void rotate(float);
...
};

Gun::Gun()
{
xPos = 5; yPos = 0;
magnitude = sqrt(xPos*xPos + yPos * yPos);
}

void Gun::rotate(float angle)
{
xPos = magnitude * cos(angle);
yPos = magnitude * sin(angle);
}

//later
//draw gun at ((player.xPos + gun.xPos),(player.yPos + gun.yPos))


tl;dr: try keeping all your vectors defined in their local context (i.e. as if they were beginning at the origin) and just add them together for position-related draw calls. Makes the rest of the math a lot simpler.