Removed some superfluous Vector() calls, source object is already a Vector

[supertux.git] / src / supertux / collision.cpp

diff --git a/src/supertux/collision.cpp b/src/supertux/collision.cpp
index 716808d..4e1c601 100644 (file)
--- a/src/supertux/collision.cpp
+++ b/src/supertux/collision.cpp
@@ -19,10 +19,11 @@
 #include <algorithm>
 
 #include "math/aatriangle.hpp"
+#include "math/rectf.hpp"
 
 namespace collision {
 
-bool intersects(const Rect& r1, const Rect& r2)
+bool intersects(const Rectf& r1, const Rectf& r2)
 {
   if(r1.p2.x < r2.p1.x || r1.p1.x > r2.p2.x)
     return false;
@@ -46,36 +47,36 @@ inline void makePlane(const Vector& p1, const Vector& p2, Vector& n, float& c)
 
 }
 
-bool rectangle_aatriangle(Constraints* constraints, const Rect& rect,
+bool rectangle_aatriangle(Constraints* constraints, const Rectf& rect,
                           const AATriangle& triangle, const Vector& addl_ground_movement)
 {
-  if(!intersects(rect, (const Rect&) triangle))
+  if(!intersects(rect, (const Rectf&) triangle))
     return false;
 
   Vector normal;
-  float c;
+  float c = 0.0;
   Vector p1;
-  Rect area;
+  Rectf area;
   switch(triangle.dir & AATriangle::DEFORM_MASK) {
     case 0:
-      area.p1 = triangle.p1;
-      area.p2 = triangle.p2;
+      area.p1 = triangle.bbox.p1;
+      area.p2 = triangle.bbox.p2;
       break;
-    case AATriangle::DEFORM1:
-      area.p1 = Vector(triangle.p1.x, triangle.p1.y + triangle.get_height()/2);
-      area.p2 = triangle.p2;
+    case AATriangle::DEFORM_BOTTOM:
+      area.p1 = Vector(triangle.bbox.p1.x, triangle.bbox.p1.y + triangle.bbox.get_height()/2);
+      area.p2 = triangle.bbox.p2;
       break;
-    case AATriangle::DEFORM2:
-      area.p1 = triangle.p1;
-      area.p2 = Vector(triangle.p2.x, triangle.p1.y + triangle.get_height()/2);
+    case AATriangle::DEFORM_TOP:
+      area.p1 = triangle.bbox.p1;
+      area.p2 = Vector(triangle.bbox.p2.x, triangle.bbox.p1.y + triangle.bbox.get_height()/2);
       break;
-    case AATriangle::DEFORM3:
-      area.p1 = triangle.p1;
-      area.p2 = Vector(triangle.p1.x + triangle.get_width()/2, triangle.p2.y);
+    case AATriangle::DEFORM_LEFT:
+      area.p1 = triangle.bbox.p1;
+      area.p2 = Vector(triangle.bbox.p1.x + triangle.bbox.get_width()/2, triangle.bbox.p2.y);
       break;
-    case AATriangle::DEFORM4:
-      area.p1 = Vector(triangle.p1.x + triangle.get_width()/2, triangle.p1.y);
-      area.p2 = triangle.p2;
+    case AATriangle::DEFORM_RIGHT:
+      area.p1 = Vector(triangle.bbox.p1.x + triangle.bbox.get_width()/2, triangle.bbox.p1.y);
+      area.p2 = triangle.bbox.p2;
       break;
     default:
       assert(false);
@@ -120,21 +121,21 @@ bool rectangle_aatriangle(Constraints* constraints, const Rect& rect,
   if(p1.x < area.p1.x - RDELTA || p1.x > area.p2.x + RDELTA
      || p1.y < area.p1.y - RDELTA || p1.y > area.p2.y + RDELTA) {
     set_rectangle_rectangle_constraints(constraints, rect, area);
-    constraints->hit.left = false;
-    constraints->hit.right = false;
   } else {
     if(outvec.x < 0) {
-      constraints->right = rect.get_right() + outvec.x;
+      constraints->constrain_right(rect.get_right() + outvec.x, addl_ground_movement.x);
+      constraints->hit.right = true;
     } else {
-      constraints->left = rect.get_left() + outvec.x;
+      constraints->constrain_left(rect.get_left() + outvec.x, addl_ground_movement.x);
+      constraints->hit.left = true;
     }
 
     if(outvec.y < 0) {
-      constraints->bottom = rect.get_bottom() + outvec.y;
+      constraints->constrain_bottom(rect.get_bottom() + outvec.y, addl_ground_movement.y);
       constraints->hit.bottom = true;
       constraints->ground_movement += addl_ground_movement;
     } else {
-      constraints->top = rect.get_top() + outvec.y;
+      constraints->constrain_top(rect.get_top() + outvec.y, addl_ground_movement.y);
       constraints->hit.top = true;
     }
     constraints->hit.slope_normal = normal;
@@ -144,7 +145,7 @@ bool rectangle_aatriangle(Constraints* constraints, const Rect& rect,
 }
 
 void set_rectangle_rectangle_constraints(Constraints* constraints,
-                                         const Rect& r1, const Rect& r2, const Vector& addl_ground_movement)
+                                         const Rectf& r1, const Rectf& r2, const Vector& addl_ground_movement)
 {
   float itop = r1.get_bottom() - r2.get_top();
   float ibottom = r2.get_bottom() - r1.get_top();
@@ -155,19 +156,19 @@ void set_rectangle_rectangle_constraints(Constraints* constraints,
   float horiz_penetration = std::min(ileft, iright);
   if(vert_penetration < horiz_penetration) {
     if(itop < ibottom) {
-      constraints->bottom = std::min(constraints->bottom, r2.get_top());
+      constraints->constrain_bottom(r2.get_top(), addl_ground_movement.y);
       constraints->hit.bottom = true;
       constraints->ground_movement += addl_ground_movement;
     } else {
-      constraints->top = std::max(constraints->top, r2.get_bottom());
+      constraints->constrain_top(r2.get_bottom(), addl_ground_movement.y);
       constraints->hit.top = true;
     }
   } else {
     if(ileft < iright) {
-      constraints->right = std::min(constraints->right, r2.get_left());
+      constraints->constrain_right(r2.get_left(), addl_ground_movement.x);
       constraints->hit.right = true;
     } else {
-      constraints->left = std::max(constraints->left, r2.get_right());
+      constraints->constrain_left(r2.get_right(), addl_ground_movement.x);
       constraints->hit.left = true;
     }
   }