+// $Id$
+//
+// SuperTux
+// Copyright (C) 2004 Tobias Glaesser <tobi.web@gmx.de>
//
-// C Implementation: collision
-//
-// Description:
-//
-//
-// Author: Tobias Glaesser <tobi.web@gmx.de>, (C) 2004
-//
-// Copyright: See COPYING file that comes with this distribution
-//
+// 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.
+//
+// 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 <cmath>
#include "defines.h"
#include "collision.h"
#include "bitmask.h"
#include "scene.h"
+#include "sector.h"
+#include "tilemap.h"
+#include "tile.h"
-bool rectcollision(base_type* one, base_type* two)
+struct TileInfo
{
- 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);
+ Tile *tile;
+ int x, y;
+} tileinfo;
+
+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);
}
-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 base_type& base)
{
- int v = (int)pbase->height / 16;
- int h = (int)pbase->width / 16;
+ const TileMap& tilemap = *Sector::current()->solids;
- 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;
+ // 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 i = 1; i < h; ++i)
- {
- if(issolid(pbase->x + i*16,pbase->y + 1))
- return true;
- }
+ tileinfo.tile = NULL;
- for(int i = 1; i < h; ++i)
- {
- if( issolid(pbase->x + i*16,pbase->y + pbase->height - 1))
+ for(int x = starttilex; x*32 < max_x; ++x) {
+ for(int y = starttiley; y*32 < max_y; ++y) {
+ Tile* tile = tilemap.get_tile(x, y);
+ if(tile && tile->attributes & Tile::SOLID)
+ {
+ tileinfo.tile = tile;
+ tileinfo.x = x*32;
+ tileinfo.y = y*32;
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;
+ return false;
+}
+
+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) {
+ 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(Tile* tile)
+{
+ if(tile && (tile->attributes & Tile::GOAL))
+ return tile;
+ return 0;
+}
+
+Tile* collision_goal(const base_type& base)
+{
+ return (Tile*) collision_func(base, test_goal_tile_function);
+}
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;
steps--;
}
- if(collision_object_map(old))
+ if(collision_object_map(*old))
{
+ if(tileinfo.tile->slope_angle != 0)
+ { // in case this is a slope, set the right Y position
+ // left-right slope:
+ if(tileinfo.tile->slope_angle > 0 && tileinfo.tile->slope_angle < M_PI/2)
+ current->y = tileinfo.y - current->height +
+ (tileinfo.x - current->x)*tan(M_PI/2 - tileinfo.tile->slope_angle)
+ - 1;
+ // right-left slope:
+ if(tileinfo.tile->slope_angle > M_PI/2 && tileinfo.tile->slope_angle < M_PI)
+ current->y = tileinfo.y - current->height +
+ (current->x - tileinfo.x)*tan(M_PI - tileinfo.tile->slope_angle)
+ - 1;
+ }
+ else
+ {
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:
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;
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;
}
break;
}
+ }
}
+ 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;
}
-void collision_handler()
+Tile* gettile(float x, float y)
{
- // 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
- }
- }
- }
+ const TileMap& tilemap = *Sector::current()->solids;
+ return tilemap.get_tile_at(Vector(x, y));
+}
- /* 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;
+bool issolid(float x, float y)
+{
+ Tile* tile = gettile(x,y);
+ return tile && (tile->attributes & Tile::SOLID);
+}
- 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);
- }
- }
- }
+bool isbrick(float x, float y)
+{
+ Tile* tile = gettile(x,y);
+ return tile && (tile->attributes & Tile::BRICK);
+}
- 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);
- }
- }
- }
+bool isice(float x, float y)
+{
+ Tile* tile = gettile(x,y);
+ return tile && (tile->attributes & Tile::ICE);
+}
- // 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);
- }
- }
+bool isspike(float x, float y)
+{
+ Tile* tile = gettile(x,y);
+ return tile && (tile->attributes & Tile::SPIKE);
+}
+
+bool isfullbox(float x, float y)
+{
+ Tile* tile = gettile(x,y);
+ return tile && (tile->attributes & Tile::FULLBOX);
+}
+bool iscoin(float x, float y)
+{
+ Tile* tile = gettile(x,y);
+ return tile && (tile->attributes & Tile::COIN);
}
+/* EOF */
+
projects / supertux.git / blobdiff