p2Point.h

#ifndef __P2POINT_H__
#define __P2POINT_H__

#include "Globals.h"
#include <math.h>

template<class TYPE>
class p2Point
{
public:

	TYPE x, y;

	p2Point()
	{}

	p2Point(const p2Point& v)
	{
		this->x = v.x;
		this->y = v.y;
	}

	p2Point(const TYPE& x, const TYPE& y)
	{
		this->x = x;
		this->y = y;
	}

	p2Point& create(const TYPE& x, const TYPE& y)
	{
		this->x = x;
		this->y = y;

		return(*this);
	}

	// Math ------------------------------------------------
	p2Point operator -(const p2Point &v) const
	{
		p2Point r;

		r.x = x - v.x;
		r.y = y - v.y;

		return(r);
	}

	p2Point operator + (const p2Point &v) const
	{
		p2Point r;

		r.x = x + v.x;
		r.y = y + v.y;

		return(r);
	}

	p2Point operator / (const TYPE k) const
	{
		p2Point r;

		r.x = x / k;
		r.y = y / k;

		return (r);
	}

	p2Point operator * (const TYPE k) const
	{
		p2Point r;

		r.x = x * k;
		r.y = y * k;

		return (r);
	}

	TYPE operator * (const p2Point &v) const
	{
		return (x*v.x + y*v.y);
	}

	const p2Point& operator -=(const p2Point &v)
	{
		x -= v.x;
		y -= v.y;

		return(*this);
	}

	const p2Point& operator +=(const p2Point &v)
	{
		x += v.x;
		y += v.y;

		return(*this);
	}

	bool operator ==(const p2Point& v) const
	{
		return (x == v.x && y == v.y);
	}

	bool operator !=(const p2Point& v) const
	{
		return (x != v.x || y != v.y);
	}

	// Utils ------------------------------------------------
	bool IsZero() const
	{
		return (x == 0 && y == 0);
	}

	p2Point& SetToZero()
	{
		x = y = 0;
		return(*this);
	}

	p2Point& Negate()
	{
		x = -x;
		y = -y;

		return(*this);
	}

	TYPE Length() const
	{
		return (TYPE)sqrtf(float(x*x) + float(y*y));
	}

	double Angle(const p2Point& v) const
	{
		float rads = acos(float(*this * v) / float(Length()*v.Length()));
		return rads * 180 / 3.141593;
	}

	void Normalize()
	{
		x = x / Length();
		y = y / Length();
	}

	// Distances ---------------------------------------------
	TYPE DistanceTo(const p2Point& v) const
	{
		TYPE fx = x - v.x;
		TYPE fy = y - v.y;

		return (TYPE)sqrtf(float(fx*fx) + float(fy*fy));
	}

	TYPE DistanceNoSqrt(const p2Point& v) const
	{
		TYPE fx = x - v.x;
		TYPE fy = y - v.y;

		return (fx*fx) + (fy*fy);
	}

	TYPE DistanceManhattan(const p2Point& v) const
	{
		return abs(v.x - x) + abs(v.y - y);
	}
};

typedef p2Point<int> iPoint;
typedef p2Point<float> fPoint;


#endif // __P2POINT_H__