C++ Magnitude (Normalise) doesn't seem to be correct

Question

I'm doing a little 2D tank turret game where you rotate a tank in the middle of a screen, click your left button and then a little projectile moves to that location.

I'm currently at the point where I have a current location and a desired location, what I need to do now is to get the magnitude of those two points, which should either return 1 or 0.

This is my C++ VectorClass magnitude function:

float vector2D::magnitude(vector2D vec2)//<! Vector magnitude
{
    float result;
    result = (sqrt(x*vec2.x)+(y*vec2.y));
    return result;
}

This is the code where I normalise my desired and current location:

currentPos.x = laserTexture.getSize().x/2.0f;
currentPos.y = laserTexture.getSize().y/2.0f;
desiredPos.x = sf::Mouse::getPosition().x;
desiredPos.y = sf::Mouse::getPosition().y;
normalisedLocation = magnitude(desiredPos - currentPos);

The current position is tied to the middle of my laserTexture, which is a fixed rotating point in the middle of the screen.

My desired location is a mouse click which returns the position in X and Y (This works).

Maths isn't my strong point, so when it comes to programming this sort of stuff I struggle more then other people do, so it takes me a lot longer / i'll just come up with some not very elegant solution.

My end goal is to get the normalised location, and then when the left mouse button is clicked the tank turret will fire, and the projectile will get to move to the desired location.

So to clarify:

• Is my magnitude function correct?
• Am I normalising my desired and current positions correctly?

Thanks

Answer 1

ad 1.) "Is my magnitude function correct?"

No, you have little error in your maginutude() method. Yours:

result = (sqrt(x*vec2.x)+(y*vec2.y));

is

result = sqrt(x*vec2.x)+(y*vec2.y);

is

result = sqrt(x*vec2.x) + (y*vec2.y);

but you probably wanted to write this:

result = sqrt((x*vec2.x)+(y*vec2.y));

EDIT:

I originally wrote that sqrt(x*vec2.x+y*vec2.y) is correct, but it's not, correctly it's this:

result = sqrt(vec2.x*vec2.x + vec2.y*vec2.y);

and that's because OP wanted to calculate magnitude of only vec2, there is no need to use this.x and this.y. For this reason I would further suggest to change your method to static:

static float vector2D::magnitude(vector2D vec2)//<! Vector magnitude
{
    return sqrt((vec2.x*vec2.x)+(vec2.y*vec2.y));
}

or use only instance values:

float vector2D::magnitude()//<! Vector magnitude
{
    return sqrt((x*x)+(y*y));
}

in this, second case, you would need to use the magnitude() method like this:

(desiredPos - currentPos).magnitude();

Further notes:

• Result of this method is magnitude and not normalization (of anything), but can be used to normalize given vector.
• This result is equal to distance between desiredPos and currentPos.
• If you divide (desiredPos - currentPos) by the magnitude value, you'll get normalized vector which is direction from currentPos to desiredPos.
• It's obvious, but if desiredPos and currentPos are equal, magnitude is zero and you cannot normalize the vector.
• For reasons above, I would rename the normalisedLocation variable. It distance, as stated above.

---

Ad 2.) "Am I normalising my desired and current positions correctly?"

I'm not sure how to understand this question, because you don't normalize anything in the example code. Anyway, look at this:

// This is from your code:
currentPos.x = laserTexture.getSize().x/2.0f;
currentPos.y = laserTexture.getSize().y/2.0f;
desiredPos.x = sf::Mouse::getPosition().x;
desiredPos.y = sf::Mouse::getPosition().y;

// Store direction to desired position. Currently length of this vector is
// distance between the two points.
vector2D dirToDesiredPos = (desiredPos - currentPos);

// Calculate distance between the two points.
float dirToDesiredPosDist = magnitude(desiredPos - currentPos);

// Detect whether the distance is zero. Problem is, you cannot compare float
// with zero (computer is not accurate enough) so we compare it with a delta
// value. It should be some small number, for example 0.01f.
// (Note that in this case we don't need to compare it with negative value -
// which would be -0.01f, because distance is always positive or zero.)
if(dirToDesiredPosDist < FLOAT_DELTA)
{
    // User clicked on the tank, we cannot shoot!!!
}
else
{
    // Following two lines do actuall normalization - direction of this vector
    // is unchanged, but it's length is currently 1.
    dirToDesiredPos.x /= dirToDesiredPosDist;
    dirToDesiredPos.y /= dirToDesiredPosDist;

    // Now dirToDesiredPos can be used to calculate to move your bullet to the
    // desired location.
}

---

However there is still a catch. It's following lines:

currentPos.x = laserTexture.getSize().x/2.0f;
currentPos.y = laserTexture.getSize().y/2.0f;

With this, you calculate center of laser texture, however this position is correct only if laser is rendered at [0, 0] position. Otherwise you need to update it like this:

currentPos.x = laserTexture.getSize().x/2.0f + laserPos.x;
currentPos.y = laserTexture.getSize().y/2.0f + laserPos.y;

where laserPos is position where your laser is currently located.

Answer 2

The magnitude of your vector, i.e. its length, would be

float vector2D::magnitude() const
{
    return sqrt(x*x + y*y);
}

(It's the hypotenuse of the right triangle with sides x and y.)

To normalise a vector, i.e. to get a vector with the same direction but length 1, you divide its coordinates with its magnitude:

vector2D vector2D::normalise() const 
{
    float length = magnitude();
    // Do something suitable to handle the case where the length is close to 0 here...
    return vector2D(x / length, y / length);
}

and your last line would be

normalisedDirection = (desiredPos - currentPos).normalise();

or, more verbose

vector2D direction = desiredPos - currentPos;
normalisedDirection = location.normalise();

(I renamed a variable to clarify that we're computing a direction, not a location.)

Alternatively, you could use free functions:

float magnitude(vector2D v)
{
    return sqrt(v.x * v.x + v.y * v.y);
}

vector2D normalise(vector2D v)
{
   float length = magnitude(v);
   v.x /= length;
   v.y /= length;
   return v;
}

// ...

normalisedDirection = normalise(desiredPos - currentPos);

Side note:
You have a typo in your function that makes it extra incorrect:

(sqrt(x*vec2.x)+(y*vec2.y));

looks a lot like

sqrt((x*vec2.x)+(y*vec2.y));

because of the two brackets at the end, but it's actually

sqrt(x * vec2.x) + y * vec2.y;

To avoid these kinds of problems, first: don't be afraid of the space bar, and second: don't use excessive brackets.

Answer 3

The norm of a vector is the square root of the sum of the squares of its coordinates. Your method should be:

float vector2D::magnitude(vector2D vec2)
{
    return sqrt(vec2.x * vec2.x + vec2.y * vec2.y);
}

Answer 4

why would you need magnitude? you need direction which is an angle (either degree or radians). since you already have the base position of the tank, and the desired location where you clicked your mouse, from that you would need to calculate at what angle those to points are. with a little pythagoras and trignometry you can figure out the angle, rotate your tank to that angle, launch your projectile in the same heading.