Added operator overloading and new methods to Vector2D class

src/level.cpp

@@ -34,6 +34,7 @@ extern bool textforetile;
 
 
 extern uint16_t tilecolor;
+extern uint16_t backcolor;
 
 extern std::vector<Border*> MyLevelBorders;
 
@@ -136,11 +137,6 @@ void Level::Render( void )
     #endif
 }
 
-void Level::RenderSelected( uint8_t i, uint8_t j )
-{
-
-}
-
 
 void Level::Update( float dt )
 {
@@ -191,37 +187,26 @@ int Level::GetTileForeground( uint16_t x, uint16_t y )
 // if there is an intersection, return true and store the result into Point R
 bool CollisionSegSeg( Vector2D A, Vector2D B, Vector2D N, Vector2D C, Vector2D D, Vector2D *R )
 {
-    Vector2D I, J;
+    Vector2D I = B - A;
+    Vector2D J = D - C;
 
-    I.x = B.x - A.x;
-    I.y = B.y - A.y;
-    
-    //if (I.x==0 && I.y==0) return false;
-
-    J.x = D.x - C.x;
-    J.y = D.y - C.y;
-
-    //if (J.x==0 && J.y==0) return false;
-
-    libnum::num32 det;
-    det = I.x*J.y-I.y*J.x;
+    libnum::num32 det = I.Det(J);
 
     if (det==0) return false;       // the segments are parallel
 
-    libnum::num32 m;
-    m = (I.x*A.y - I.x*C.y - I.y*A.x + I.y*C.x) / det;
+    libnum::num32 m = (I.Det(A) - I.Det(C) ) / det;
     
-    libnum::num32 k;
-    k = (J.x*A.y - J.x*C.y - J.y*A.x + J.y*C.x) / det;
+    libnum::num32 k = (J.Det(A) - J.Det(C) ) / det;
 
     if ((m>=libnum::num32(0) && m<=libnum::num32(1) && k>=libnum::num32(0) && k<=libnum::num32(1)))
     {
-        if ( (J.x*N.x + J.y*N.y) >= libnum::num32(0))
+        if ( J.Dot(N) >= libnum::num32(0))
             return false;
         else
         {
-            (*R).x = C.x + k*J.x;
-            (*R).y = C.y + k*J.y;
+            //(*R).x = C.x + k*J.x;
+            //(*R).y = C.y + k*J.y;
+            *R = C + k*J;
             return true;
         }
     } 

src/level.h

@@ -34,7 +34,6 @@ class Level
 
         void Update( float dt );
         void Render( void );
-        void RenderSelected( uint8_t i, uint8_t j );
 
 		void ChangeMap( int level );
 		void UpdateDataMap( void );

src/vector2D.cpp

@@ -45,6 +45,12 @@ Vector2D::Vector2D( libnum::num32 x, libnum::num32 y )
     this->y = y;
 }
 
+Vector2D::Vector2D( const Vector2D &v )
+{
+    this->x = v.x;
+    this->y = v.y;
+}
+
 Vector2D::~Vector2D()
 {
 
@@ -103,6 +109,11 @@ libnum::num32 Vector2D::Dot( Vector2D v )
     return ( this->x * v.x + this->y * v.y );
 }
 
+libnum::num32 Vector2D::Det( Vector2D v )
+{
+    return ( this->x * v.y - this->y * v.x );
+}
+
 Vector2D Vector2D::Perp( void )
 {
     Vector2D temp( -this->y, this->x );

src/vector2D.h

@@ -15,6 +15,7 @@ class Vector2D
         Vector2D();
         Vector2D( float x, float y );
         Vector2D( libnum::num32 x, libnum::num32 y );
+        Vector2D( const Vector2D &v );
         ~Vector2D();
 
         Vector2D Clone( void );
@@ -29,56 +30,89 @@ class Vector2D
         void Scale( libnum::num32 scale );
 
         libnum::num32 Dot( Vector2D v );
+        libnum::num32 Det( Vector2D v );
         Vector2D Perp( void );
 
+        libnum::num32 operator[](uint8_t pos)
+        {
+            return pos == 0 ? x : y;
+        } 
 
+        Vector2D &operator=(const Vector2D &v )
+        {
+            this->x = v.x;
+            this->y = v.y;
+            return *this;
+        }
 
-        inline constexpr Vector2D &operator+=( Vector2D const &other )
+        Vector2D operator+(const Vector2D &v ) const
+        {
+            return Vector2D(x + v.x, y + v.y);
+        }
+
+        Vector2D operator-(const Vector2D &v ) const
+        {
+            return Vector2D(x - v.x, y - v.y);
+        }
+
+        Vector2D &operator+=( Vector2D const &other ) 
         {
             this->x += other.x;
             this->y += other.y;
             return *this;
         }
 
-        inline constexpr Vector2D &operator-=( Vector2D const &other )
+		Vector2D operator-() const
+		{
+			return (Vector2D(-x, -y));
+		}
+
+		Vector2D operator+() const
+		{
+			return *this;
+		}
+
+        Vector2D &operator-=( Vector2D const &other )
         {
             this->x -= other.x;
             this->y -= other.y;
             return *this;
         }
 
-        inline constexpr Vector2D &operator*=( float scale )
+        Vector2D &operator*=( libnum::num32 scale )
         {
-            this->x *= libnum::num32(scale);
-            this->y *= libnum::num32(scale);
+            this->x *= scale;
+            this->y *= scale;
             return *this;
         }
 
-        inline constexpr Vector2D &operator/=( float scale )
+        Vector2D &operator/=( libnum::num32 scale )
         {
-            this->x /= libnum::num32(scale);
-            this->y /= libnum::num32(scale);
+            this->x /= scale;
+            this->y /= scale;
             return *this;
         }
 
-        inline friend Vector2D operator*(float scale, Vector2D const &v) {
+        friend Vector2D operator*(libnum::num32 scale, Vector2D const &v)
+        {
             Vector2D r;
-            r.x = v.x * libnum::num32( scale );
-            r.y = v.y * libnum::num32( scale );
+            r.x = v.x * scale;
+            r.y = v.y * scale;
             return r;
         }
 
-        inline friend Vector2D operator*(Vector2D const &v, float scale) {
+        friend Vector2D operator*(Vector2D const &v, libnum::num32 scale)
+        {
             Vector2D r;
-            r.x = v.x * libnum::num32( scale );
-            r.y = v.y * libnum::num32( scale );
+            r.x = v.x * scale;
+            r.y = v.y * scale;
             return r;
         }
 
-        inline friend Vector2D operator/(Vector2D const &v, float scale) {
+        friend Vector2D operator/(Vector2D const &v, libnum::num32 scale) {
             Vector2D r;
-            r.x = v.x / libnum::num32( scale );
-            r.y = v.y / libnum::num32( scale );
+            r.x = v.x / scale;
+            r.y = v.y / scale;
             return r;
         }