X-Git-Url: https://git.verplant.org/?a=blobdiff_plain;f=src%2Fcollision.cpp;h=237590f0200c6a4e982000b40a253f9628dc9b6b;hb=875ef8eb7e93726bc67dfa7f05da946250e588d4;hp=15a8b8b7fb41b84b4f148cfc6d4a3f35b09a0962;hpb=84160722392a024dda42bd86ca9bd85b68c49457;p=supertux.git

diff --git a/src/collision.cpp b/src/collision.cpp
index 15a8b8b7f..237590f02 100644
--- a/src/collision.cpp
+++ b/src/collision.cpp
@@ -18,67 +18,102 @@
 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 //  02111-1307, USA.
 
+#include <config.h>
+
+#include <cmath>
 #include "defines.h"
 #include "collision.h"
-#include "bitmask.h"
 #include "scene.h"
-#include "world.h"
-#include "level.h"
+#include "sector.h"
+#include "tilemap.h"
 #include "tile.h"
 
-bool rectcollision(base_type* one, base_type* two)
+#if 0
+bool rectcollision(const base_type& one, const base_type& two)
 {
-  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);
+  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 rectcollision_offset(const base_type& one, const base_type& two, float off_x, float off_y)
 {
-  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);
+  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)
+bool collision_object_map(const Rectangle& rect)
 {
-  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;
+  base_type base;
+  base.x = rect.p1.x;
+  base.y = rect.p1.y;
+  base.width = rect.get_width();    
+  base.height = rect.get_height();
+  return collision_object_map(base);
+}
 
-  for(int i = 1; i < h; ++i)
-    {
-      if(issolid(pbase->x + i*16,pbase->y + 1))
+bool collision_object_map(const base_type& base)
+{
+  const TileMap& tilemap = *Sector::current()->solids;
+
+  // we make the collision rectangle 1 pixel smaller
+  int starttilex = int(base.x+1) / 32;
+  int starttiley = int(base.y+1) / 32;
+  int max_x = int(base.x + base.width);
+  int max_y = int(base.y + base.height);
+
+  for(int x = starttilex; x*32 < max_x; ++x) {
+    for(int y = starttiley; y*32 < max_y; ++y) {
+      const Tile* tile = tilemap.get_tile(x, y);
+      if(tile && tile->attributes & Tile::SOLID)
         return true;
     }
+  }
 
-  for(int i = 1; i < h; ++i)
-    {
-      if(  issolid(pbase->x + i*16,pbase->y + pbase->height - 1))
-        return true;
-    }
+  return false;
+}
 
-  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;
+void* collision_func(const base_type& base, tiletestfunction function)
+{
+  const TileMap& tilemap = *Sector::current()->solids;
+  
+  int starttilex = int(base.x) / 32;
+  int starttiley = int(base.y) / 32;
+  int max_x = int(base.x + base.width);
+  int max_y = int(base.y + base.height);
+
+  for(int x = starttilex; x*32 < max_x; ++x) {
+    for(int y = starttiley; y*32 < max_y; ++y) {
+      const Tile* tile = tilemap.get_tile(x, y);
+      void* result = function(tile);
+      if(result != 0)
+        return result;
     }
+  }
 
-  return false;
+  return 0;
 }
 
+static void* test_goal_tile_function(const Tile* tile)
+{
+  if(tile && (tile->attributes & Tile::GOAL))
+    return const_cast<void*> ((const void*) tile); // evil cast...
+  return 0;
+}
+
+const Tile* collision_goal(const Rectangle& rect)
+{
+  // too lazy to rewrite for now, so we transform to base_type...
+  base_type base;
+  base.x = rect.p1.x;
+  base.y = rect.p1.y;
+  base.width = rect.get_width();
+  base.height = rect.get_height();
+  return (const Tile*) collision_func(base, test_goal_tile_function);
+}
 
 void collision_swept_object_map(base_type* old, base_type* current)
 {
@@ -143,6 +178,8 @@ void collision_swept_object_map(base_type* old, base_type* current)
 
   steps = (int)(lpath / (float)16);
 
+  float orig_x = old->x;
+  float orig_y = old->y;
   old->x += xd;
   old->y += yd;
 
@@ -155,18 +192,18 @@ void collision_swept_object_map(base_type* old, base_type* current)
           steps--;
         }
 
-      if(collision_object_map(old))
+      if(collision_object_map(*old))
         {
           switch(h)
             {
             case 1:
               current->y = old->y - yd;
-              while(collision_object_map(current))
+              while(collision_object_map(*current))
                 current->y -= yd;
               break;
             case 2:
               current->x = old->x - xd;
-              while(collision_object_map(current))
+              while(collision_object_map(*current))
                 current->x -= xd;
               break;
             case 3:
@@ -174,7 +211,7 @@ void collision_swept_object_map(base_type* old, base_type* current)
               yt = current->y;
               current->x = old->x - xd;
               current->y = old->y - yd;
-              while(collision_object_map(current))
+              while(collision_object_map(*current))
                 {
                   current->x -= xd;
                   current->y -= yd;
@@ -182,20 +219,20 @@ void collision_swept_object_map(base_type* old, base_type* current)
 
               temp = current->x;
               current->x = xt;
-              if(!collision_object_map(current))
+              if(!collision_object_map(*current))
                 break;
               current->x = temp;
               temp = current->y;
               current->y = yt;
 
-              if(!collision_object_map(current))
+              if(!collision_object_map(*current))
                 {
                   break;
                 }
               else
                 {
                   current->y = temp;
-                  while(!collision_object_map(current))
+                  while(!collision_object_map(*current))
                     current->y += yd;
 		  current->y -= yd;
                   break;
@@ -209,45 +246,55 @@ void collision_swept_object_map(base_type* old, base_type* current)
         }
     }
 
+  if((xd > 0 && current->x < orig_x) || (xd < 0 && current->x > orig_x))
+    current->x = orig_x;
+  if((yd > 0 && current->y < orig_y) || (yd < 0 && current->y > orig_y))
+    current->y = orig_y;
+
   *old = *current;
 }
 
-
-Tile* gettile(float x, float y)
+const Tile* gettile(float x, float y)
 {
-  return TileManager::instance()->get(World::current()->get_level()->gettileid(x, y));
+  const TileMap& tilemap = *Sector::current()->solids;
+  return tilemap.get_tile_at(Vector(x, y));
 }
 
 bool issolid(float x, float y)
 {
-  Tile* tile = gettile(x,y);
-  return tile && tile->solid;
+  const Tile* tile = gettile(x,y);
+  return tile && (tile->attributes & Tile::SOLID);
 }
 
 bool isbrick(float x, float y)
 {
-  Tile* tile = gettile(x,y);
-  return tile && tile->brick;
+  const Tile* tile = gettile(x,y);
+  return tile && (tile->attributes & Tile::BRICK);
 }
 
 bool isice(float x, float y)
 {
-  Tile* tile = gettile(x,y);
-  return tile && tile->ice;
+  const Tile* tile = gettile(x,y);
+  return tile && (tile->attributes & Tile::ICE);
 }
 
-bool isfullbox(float x, float y)
+bool isspike(float x, float y)
 {
-  Tile* tile = gettile(x,y);
-  return tile && tile->fullbox;
+  const Tile* tile = gettile(x,y);
+  return tile && (tile->attributes & Tile::SPIKE);
 }
 
-bool isdistro(float x, float y)
+bool isfullbox(float x, float y)
 {
-  Tile* tile = gettile(x,y);
-  return tile && tile->distro;
+  const Tile* tile = gettile(x,y);
+  return tile && (tile->attributes & Tile::FULLBOX);
 }
 
-/* EOF */
+bool iscoin(float x, float y)
+{
+  const Tile* tile = gettile(x,y);
+  return tile && (tile->attributes & Tile::COIN);
+}
 
+#endif