+// $Id$
//
-// C Implementation: collision
+// SuperTux
+// Copyright (C) 2006 Matthias Braun <matze@braunis.de>
//
-// Description:
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
//
-// Author: Tobias Glaesser <tobi.web@gmx.de>, (C) 2004
-//
-// Copyright: See COPYING file that comes with this distribution
-//
-//
-
-#include "defines.h"
-#include "collision.h"
-#include "bitmask.h"
-#include "scene.h"
-
-bool rectcollision(base_type* one, base_type* two)
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+// 02111-1307, USA.
+#include <config.h>
+
+#include "collision.hpp"
+
+#include <algorithm>
+#include <iostream>
+#include <stdio.h>
+#include <float.h>
+#include <math.h>
+#include "math/vector.hpp"
+#include "math/aatriangle.hpp"
+#include "math/rect.hpp"
+#include "collision_hit.hpp"
+#include "log.hpp"
+
+namespace collision
{
- return (one->x >= two->x - one->width + 1 &&
- one->x <= two->x + two->width - 1 &&
- one->y >= two->y - one->height + 1 &&
- one->y <= two->y + two->height - 1);
-}
-bool rectcollision_offset(base_type* one, base_type* two, float off_x, float off_y)
+bool intersects(const Rect& r1, const Rect& r2)
{
- return (one->x >= two->x - one->width +off_x + 1 &&
- one->x <= two->x + two->width + off_x - 1 &&
- one->y >= two->y - one->height + off_y + 1 &&
- one->y <= two->y + two->height + off_y - 1);
-}
-
-bool collision_object_map(base_type* pbase)
-{
- int v = (int)pbase->height / 16;
- int h = (int)pbase->width / 16;
-
- if(issolid(pbase->x + 1, pbase->y + 1) ||
- issolid(pbase->x + pbase->width -1, pbase->y + 1) ||
- issolid(pbase->x +1, pbase->y + pbase->height -1) ||
- issolid(pbase->x + pbase->width -1, pbase->y + pbase->height - 1))
- return true;
+ if(r1.p2.x < r2.p1.x || r1.p1.x > r2.p2.x)
+ return false;
+ if(r1.p2.y < r2.p1.y || r1.p1.y > r2.p2.y)
+ return false;
- for(int i = 1; i < h; ++i)
- {
- if(issolid(pbase->x + i*16,pbase->y + 1))
- return true;
- }
+ return true;
+}
- for(int i = 1; i < h; ++i)
- {
- if( issolid(pbase->x + i*16,pbase->y + pbase->height - 1))
- return true;
- }
+//---------------------------------------------------------------------------
- for(int i = 1; i < v; ++i)
- {
- if( issolid(pbase->x + 1, pbase->y + i*16))
- return true;
- }
- for(int i = 1; i < v; ++i)
- {
- if( issolid(pbase->x + pbase->width - 1, pbase->y + i*16))
- return true;
- }
+namespace {
+ inline void makePlane(const Vector& p1, const Vector& p2, Vector& n, float& c)
+ {
+ n = Vector(p2.y-p1.y, p1.x-p2.x);
+ c = -(p2 * n);
+ float nval = n.norm();
+ n /= nval;
+ c /= nval;
+ }
- return false;
+ static const float DELTA = .0001f;
}
-
-void collision_swept_object_map(base_type* old, base_type* current)
+bool rectangle_aatriangle(Constraints* constraints, const Rect& rect,
+ const AATriangle& triangle, const Vector& addl_ground_movement)
{
- int steps; /* Used to speed up the collision tests, by stepping every 16pixels in the path. */
- int h;
- float lpath; /* Holds the longest path, which is either in X or Y direction. */
- float xd,yd; /* Hold the smallest steps in X and Y directions. */
- float temp, xt, yt; /* Temporary variable. */
-
- lpath = 0;
- xd = 0;
- yd = 0;
-
- if(old->x == current->x && old->y == current->y)
- {
- return;
+ if(!intersects(rect, (const Rect&) triangle))
+ return false;
+
+ Vector normal;
+ float c;
+ Vector p1;
+ Rect area;
+ switch(triangle.dir & AATriangle::DEFORM_MASK) {
+ case 0:
+ area.p1 = triangle.p1;
+ area.p2 = triangle.p2;
+ break;
+ case AATriangle::DEFORM1:
+ area.p1 = Vector(triangle.p1.x, triangle.p1.y + triangle.get_height()/2);
+ area.p2 = triangle.p2;
+ break;
+ case AATriangle::DEFORM2:
+ area.p1 = triangle.p1;
+ area.p2 = Vector(triangle.p2.x, triangle.p1.y + triangle.get_height()/2);
+ break;
+ case AATriangle::DEFORM3:
+ area.p1 = triangle.p1;
+ area.p2 = Vector(triangle.p1.x + triangle.get_width()/2, triangle.p2.y);
+ break;
+ case AATriangle::DEFORM4:
+ area.p1 = Vector(triangle.p1.x + triangle.get_width()/2, triangle.p1.y);
+ area.p2 = triangle.p2;
+ break;
+ default:
+ assert(false);
+ }
+
+ switch(triangle.dir & AATriangle::DIRECTION_MASK) {
+ case AATriangle::SOUTHWEST:
+ p1 = Vector(rect.p1.x, rect.p2.y);
+ makePlane(area.p1, area.p2, normal, c);
+ break;
+ case AATriangle::NORTHEAST:
+ p1 = Vector(rect.p2.x, rect.p1.y);
+ makePlane(area.p2, area.p1, normal, c);
+ break;
+ case AATriangle::SOUTHEAST:
+ p1 = rect.p2;
+ makePlane(Vector(area.p1.x, area.p2.y),
+ Vector(area.p2.x, area.p1.y), normal, c);
+ break;
+ case AATriangle::NORTHWEST:
+ p1 = rect.p1;
+ makePlane(Vector(area.p2.x, area.p1.y),
+ Vector(area.p1.x, area.p2.y), normal, c);
+ break;
+ default:
+ assert(false);
+ }
+
+ float n_p1 = -(normal * p1);
+ float depth = n_p1 - c;
+ if(depth < 0)
+ return false;
+
+#if 0
+ std::cout << "R: " << rect << " Tri: " << triangle << "\n";
+ std::cout << "Norm: " << normal << " Depth: " << depth << "\n";
+#endif
+
+ Vector outvec = normal * (depth + 0.2f);
+
+ const float RDELTA = 3;
+ 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;
+ } else {
+ constraints->left = rect.get_left() + outvec.x;
}
- else if(old->x == current->x && old->y != current->y)
- {
- lpath = current->y - old->y;
- if(lpath < 0)
- {
- yd = -1;
- lpath = -lpath;
- }
- else
- {
- yd = 1;
- }
- h = 1;
- xd = 0;
- }
- else if(old->x != current->x && old->y == current->y)
- {
- lpath = current->x - old->x;
- if(lpath < 0)
- {
- xd = -1;
- lpath = -lpath;
- }
- else
- {
- xd = 1;
- }
- h = 2;
- yd = 0;
- }
- else
- {
- lpath = current->x - old->x;
- if(lpath < 0)
- lpath = -lpath;
- if(current->y - old->y > lpath || old->y - current->y > lpath)
- lpath = current->y - old->y;
- if(lpath < 0)
- lpath = -lpath;
- h = 3;
- xd = (current->x - old->x) / lpath;
- yd = (current->y - old->y) / lpath;
- }
-
- steps = (int)(lpath / (float)16);
-
- old->x += xd;
- old->y += yd;
-
- for(float i = 0; i <= lpath; old->x += xd, old->y += yd, ++i)
- {
- if(steps > 0)
- {
- old->y += yd*16.;
- old->x += xd*16.;
- steps--;
- }
-
- if(collision_object_map(old))
- {
- switch(h)
- {
- case 1:
- current->y = old->y - yd;
- while(collision_object_map(current))
- current->y -= yd;
- break;
- case 2:
- current->x = old->x - xd;
- while(collision_object_map(current))
- current->x -= xd;
- break;
- case 3:
- xt = current->x;
- yt = current->y;
- current->x = old->x - xd;
- current->y = old->y - yd;
- while(collision_object_map(current))
- {
- current->x -= xd;
- current->y -= yd;
- }
-
- temp = current->x;
- current->x = xt;
- if(!collision_object_map(current))
- break;
- current->x = temp;
- temp = current->y;
- current->y = yt;
-
- if(!collision_object_map(current))
- {
- break;
- }
- else
- {
- current->y = temp;
- while(!collision_object_map(current))
- current->y += yd;
- current->y -= yd;
- break;
- }
-
- break;
- default:
- break;
- }
- break;
- }
+ if(outvec.y < 0) {
+ constraints->bottom = rect.get_bottom() + outvec.y;
+ constraints->hit.bottom = true;
+ constraints->ground_movement += addl_ground_movement;
+ } else {
+ constraints->top = rect.get_top() + outvec.y;
+ constraints->hit.top = true;
}
+ constraints->hit.slope_normal = normal;
+ }
- *old = *current;
+ return true;
}
-void collision_handler()
+void set_rectangle_rectangle_constraints(Constraints* constraints,
+ const Rect& r1, const Rect& r2, const Vector& addl_ground_movement)
{
- // CO_BULLET & CO_BADGUY check
- for(unsigned int i = 0; i < world.bullets.size(); ++i)
- {
- for(unsigned int j = 0; j < world.bad_guys.size(); ++j)
- {
- if(world.bad_guys[j].dying != DYING_NOT)
- continue;
- if(rectcollision(&world.bullets[i].base, &world.bad_guys[j].base))
- {
- // We have detected a collision and now call the
- // collision functions of the collided objects.
- // collide with bad_guy first, since bullet_collision will
- // delete the bullet
- world.bad_guys[j].collision(0, CO_BULLET);
- bullet_collision(&world.bullets[i], CO_BADGUY);
- break; // bullet is invalid now, so break
- }
- }
+ float itop = r1.get_bottom() - r2.get_top();
+ float ibottom = r2.get_bottom() - r1.get_top();
+ float ileft = r1.get_right() - r2.get_left();
+ float iright = r2.get_right() - r1.get_left();
+
+ float vert_penetration = std::min(itop, ibottom);
+ 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->hit.bottom = true;
+ constraints->ground_movement += addl_ground_movement;
+ } else {
+ constraints->top = std::max(constraints->top, r2.get_bottom());
+ constraints->hit.top = true;
}
-
- /* CO_BADGUY & CO_BADGUY check */
- for(unsigned int i = 0; i < world.bad_guys.size(); ++i)
- {
- if(world.bad_guys[i].dying != DYING_NOT)
- continue;
-
- for(unsigned int j = i+1; j < world.bad_guys.size(); ++j)
- {
- if(j == i || world.bad_guys[j].dying != DYING_NOT)
- continue;
-
- if(rectcollision(&world.bad_guys[i].base, &world.bad_guys[j].base))
- {
- // We have detected a collision and now call the
- // collision functions of the collided objects.
- world.bad_guys[j].collision(&world.bad_guys[i], CO_BADGUY);
- world.bad_guys[i].collision(&world.bad_guys[j], CO_BADGUY);
- }
- }
+ } else {
+ if(ileft < iright) {
+ constraints->right = std::min(constraints->right, r2.get_left());
+ constraints->hit.right = true;
+ } else {
+ constraints->left = std::max(constraints->left, r2.get_right());
+ constraints->hit.left = true;
}
-
- if(tux.dying != DYING_NOT) return;
-
- // CO_BADGUY & CO_PLAYER check
- for(unsigned int i = 0; i < world.bad_guys.size(); ++i)
- {
- if(world.bad_guys[i].dying != DYING_NOT)
- continue;
-
- if(rectcollision_offset(&world.bad_guys[i].base,&tux.base,0,0))
- {
- // We have detected a collision and now call the collision
- // functions of the collided objects.
- if (tux.previous_base.y < tux.base.y &&
- tux.previous_base.y + tux.previous_base.height
- < world.bad_guys[i].base.y + world.bad_guys[i].base.height/2)
- {
- world.bad_guys[i].collision(&tux, CO_PLAYER, COLLISION_SQUISH);
- }
- else
- {
- tux.collision(&world.bad_guys[i], CO_BADGUY);
- }
- }
- }
-
- // CO_UPGRADE & CO_PLAYER check
- for(unsigned int i = 0; i < world.upgrades.size(); ++i)
- {
- if(rectcollision(&world.upgrades[i].base, &tux.base))
- {
- // We have detected a collision and now call the collision
- // functions of the collided objects.
- upgrade_collision(&world.upgrades[i], &tux, CO_PLAYER);
- }
- }
-
+ }
}
-
+}