Trying to switch to more object-oriented

sdlpp/sdlpp_rectcolider.cpp

@@ -1,12 +1,30 @@
 #include "sdlpp_rectcolider.hpp"
 
 namespace SDLPP {
-RectColider::RectColider( double x, double y, double w, double h )
-        : CollisionPolygon( x, y ) {
-    w_ = w;
-    h_ = h;
+
+double RectColider::width() const {
+    return _size.getX();
 }
 
+double RectColider::height() const {
+    return _size.getY();
+}
+
+int RectColider::pixel_width() const {
+    return _size_pixel.getX();
+}
+
+int RectColider::pixel_height() const {
+    return _size_pixel.getY();
+}
+
+RectColider::RectColider( double x, double y, double w, double h )
+        : RectColider( { x, y }, { w, h } ) {}
+
+RectColider::RectColider( const Vec2D< double > &top_left,
+                          const Vec2D< double > &size )
+        : CollisionPolygon( top_left ), _size( size ) {}
+
 bool RectColider::colidesWith( const SDLPP::CollisionPolygon &other ) const {
     if ( other.isCircle() ) {
         return other.colidesWith( *this );
@@ -23,25 +41,25 @@ bool RectColider::isCircle() const {
     return false;
 }
 int RectColider::topmost() const {
-    return ( !isInfinite() || original_y != -1 ) * getY() + isInfinite() * -1;
+    return ( !isInfinite() || original.getY() != -1 ) * getY() +
+           isInfinite() * -1;
 }
 int RectColider::bottommost() const {
-    return ( !isInfinite() || h_ != -1 ) * ( getY() + pixel_h ) +
+    return ( !isInfinite() || height() != -1 ) * ( getY() + pixel_height() ) +
            isInfinite() * -1;
 }
 int RectColider::leftmost() const {
-    return ( !isInfinite() || original_x != -1 ) * getX() + isInfinite() * -1;
+    return ( !isInfinite() || original.getX() != -1 ) * getX() +
+           isInfinite() * -1;
 }
 int RectColider::rightmost() const {
-    return ( !isInfinite() || w_ != -1 ) * ( getX() + pixel_w ) +
+    return ( !isInfinite() || width() != -1 ) * ( getX() + pixel_width() ) +
            isInfinite() * -1;
 }
 
 void RectColider::updateCollision( int x, int y, int w, int h ) {
-    position_x = original_x * w + x;
-    position_y = original_y * h + y;
-    pixel_w = w_ * w;
-    pixel_h = h_ * h;
+    position = Vec2D< int >( original.getX() * w + x, original.getY() * h + y );
+    _size_pixel = Vec2D< int >( width() * w, height() * h );
 }
 
 void RectColider::render( Renderer &renderer,
@@ -71,7 +89,7 @@ void RectColider::render( Renderer &renderer ) {
 
 SDL_Rect RectColider::getRect() {
     if ( !isInfinite() )
-        return { leftmost(), topmost(), pixel_w, pixel_h };
+        return { leftmost(), topmost(), pixel_width(), pixel_height() };
 
     SDL_Rect r = { 0, 0, 0, 0 };
     if ( ( r.x = leftmost() ) == -1 )
@@ -81,11 +99,11 @@ SDL_Rect RectColider::getRect() {
     if ( rightmost() == -1 )
         r.w = std::numeric_limits< int >::max();
     else
-        r.w = pixel_w;
+        r.w = pixel_width();
     if ( bottommost() == -1 )
         r.h = std::numeric_limits< int >::max();
     else
-        r.h = pixel_h;
+        r.h = pixel_height();
     return r;
 }
 
@@ -93,4 +111,15 @@ std::shared_ptr< CollisionPolygon > RectColider::copySelf() {
     return std::make_shared< RectColider >( *this );
 }
 
+std::vector< Line< double > > RectColider::getLines() {
+    std::vector< Line< double > > ret{};
+    ret.emplace_back( original, original + Vec2D< double >( width(), 0 ) );
+    ret.emplace_back( original + Vec2D< double >( width(), 0 ),
+                      original + _size );
+    ret.emplace_back( original, original + Vec2D< double >( 0, height() ) );
+    ret.emplace_back( original + Vec2D< double >( 0, height() ),
+                      original + _size );
+    return ret;
+}
+
 } // namespace SDLPP