#include "trigger/sequence_trigger.hpp"
#include "util/file_system.hpp"
-#define DEFORM_BOTTOM AATriangle::DEFORM1
-#define DEFORM_TOP AATriangle::DEFORM2
-#define DEFORM_LEFT AATriangle::DEFORM3
-#define DEFORM_RIGHT AATriangle::DEFORM4
-
Sector* Sector::_current = 0;
bool Sector::show_collrects = false;
}
try_expose_me();
- // spawn smalltux below spawnpoint
- if (!player->is_big()) {
- player->move(player_pos + Vector(0,32));
- } else {
- player->move(player_pos);
- }
- // spawning tux in the ground would kill him
- if(!is_free_of_tiles(player->get_bbox())) {
- log_warning << "Tried spawning Tux in solid matter. Compensating." << std::endl;
- Vector npos = player->get_bbox().p1;
- npos.y-=32;
- player->move(npos);
+ // two-player hack: move other players to main player's position
+ // Maybe specify 2 spawnpoints in the level?
+ for(GameObjects::iterator i = gameobjects.begin();
+ i != gameobjects.end(); ++i) {
+ Player* p = dynamic_cast<Player*>(*i);
+ if (!p) continue;
+
+ // spawn smalltux below spawnpoint
+ if (!p->is_big()) {
+ p->move(player_pos + Vector(0,32));
+ } else {
+ p->move(player_pos);
+ }
+
+ // spawning tux in the ground would kill him
+ if(!is_free_of_tiles(p->get_bbox())) {
+ log_warning << "Tried spawning Tux in solid matter. Compensating." << std::endl;
+ Vector npos = p->get_bbox().p1;
+ npos.y-=32;
+ p->move(npos);
+ }
}
camera->reset(player->get_pos());
#define MV_SOLID 1
/* If the tile is not a slope, this is very easy. */
- if ((tile->getAttributes() & Tile::SLOPE) == 0)
+ if (!tile->is_slope ())
{
- if (movement.y >= 0) /* moving down */
+ int dir = tile->getData () & ((int) Tile::UNI_DIR_MASK);
+
+ log_debug << "Tile data is " << tile->getData () << ", dir = " << dir << std::endl;
+
+ if (dir != Tile::UNI_DIR_NORTH)
+ log_debug << "Found non-north facing unisolid tile." << std::endl;
+
+ if (((dir == Tile::UNI_DIR_NORTH) && (movement.y >= 0)) /* moving down */
+ || ((dir == Tile::UNI_DIR_SOUTH) && (movement.y < 0)) /* moving up */
+ || ((dir == Tile::UNI_DIR_WEST) && (movement.x >= 0)) /* moving right */
+ || ((dir == Tile::UNI_DIR_EAST) && (movement.x < 0))) /* moving left */
return MV_SOLID;
- else /* moving up */
+ else
return MV_NON_SOLID;
}
/* determine tangent of the slope */
slope_tan = 1.0;
- if (((slope_info & AATriangle::DEFORM_MASK) == DEFORM_BOTTOM)
- || ((slope_info & AATriangle::DEFORM_MASK) == DEFORM_TOP))
+ if (((slope_info & AATriangle::DEFORM_MASK) == AATriangle::DEFORM_BOTTOM)
+ || ((slope_info & AATriangle::DEFORM_MASK) == AATriangle::DEFORM_TOP))
slope_tan = 0.5; /* ~= 26.6 deg */
- else if (((slope_info & AATriangle::DEFORM_MASK) == DEFORM_LEFT)
- || ((slope_info & AATriangle::DEFORM_MASK) == DEFORM_RIGHT))
+ else if (((slope_info & AATriangle::DEFORM_MASK) == AATriangle::DEFORM_LEFT)
+ || ((slope_info & AATriangle::DEFORM_MASK) == AATriangle::DEFORM_RIGHT))
slope_tan = 2.0; /* ~= 63.4 deg */
/* up and right */
#define POS_SOLID 1
/* If this is not a slope, this is - again - easy */
- if ((tile->getAttributes() & Tile::SLOPE) == 0)
+ if (!tile->is_slope ())
{
- if ((obj_bbox.get_bottom () - SHIFT_DELTA) <= tile_bbox.get_top ())
+ int dir = tile->getData () & Tile::UNI_DIR_MASK;
+
+ if ((dir == Tile::UNI_DIR_NORTH)
+ && ((obj_bbox.get_bottom () - SHIFT_DELTA) <= tile_bbox.get_top ()))
return POS_SOLID;
- else
- return POS_NON_SOLID;
+ else if ((dir == Tile::UNI_DIR_SOUTH)
+ && ((obj_bbox.get_top () + SHIFT_DELTA) >= tile_bbox.get_bottom ()))
+ return POS_SOLID;
+ else if ((dir == Tile::UNI_DIR_WEST)
+ && ((obj_bbox.get_right () - SHIFT_DELTA) <= tile_bbox.get_left ()))
+ return POS_SOLID;
+ else if ((dir == Tile::UNI_DIR_EAST)
+ && ((obj_bbox.get_left () + SHIFT_DELTA) >= tile_bbox.get_right ()))
+ return POS_SOLID;
+
+ return POS_NON_SOLID;
}
/* There are 20 different cases. For each case, calculate a line that
& (AATriangle::DIRECTION_MASK | AATriangle::DEFORM_MASK))
{
case AATriangle::SOUTHWEST:
- case AATriangle::SOUTHWEST | DEFORM_TOP:
- case AATriangle::SOUTHWEST | DEFORM_LEFT:
+ case AATriangle::SOUTHWEST | AATriangle::DEFORM_TOP:
+ case AATriangle::SOUTHWEST | AATriangle::DEFORM_LEFT:
case AATriangle::NORTHEAST:
- case AATriangle::NORTHEAST | DEFORM_TOP:
- case AATriangle::NORTHEAST | DEFORM_LEFT:
+ case AATriangle::NORTHEAST | AATriangle::DEFORM_TOP:
+ case AATriangle::NORTHEAST | AATriangle::DEFORM_LEFT:
tile_x = tile_bbox.get_left ();
tile_y = tile_bbox.get_top ();
gradient = 1.0;
break;
case AATriangle::SOUTHEAST:
- case AATriangle::SOUTHEAST | DEFORM_TOP:
- case AATriangle::SOUTHEAST | DEFORM_RIGHT:
+ case AATriangle::SOUTHEAST | AATriangle::DEFORM_TOP:
+ case AATriangle::SOUTHEAST | AATriangle::DEFORM_RIGHT:
case AATriangle::NORTHWEST:
- case AATriangle::NORTHWEST | DEFORM_TOP:
- case AATriangle::NORTHWEST | DEFORM_RIGHT:
+ case AATriangle::NORTHWEST | AATriangle::DEFORM_TOP:
+ case AATriangle::NORTHWEST | AATriangle::DEFORM_RIGHT:
tile_x = tile_bbox.get_right ();
tile_y = tile_bbox.get_top ();
gradient = -1.0;
break;
- case AATriangle::SOUTHEAST | DEFORM_BOTTOM:
- case AATriangle::SOUTHEAST | DEFORM_LEFT:
- case AATriangle::NORTHWEST | DEFORM_BOTTOM:
- case AATriangle::NORTHWEST | DEFORM_LEFT:
+ case AATriangle::SOUTHEAST | AATriangle::DEFORM_BOTTOM:
+ case AATriangle::SOUTHEAST | AATriangle::DEFORM_LEFT:
+ case AATriangle::NORTHWEST | AATriangle::DEFORM_BOTTOM:
+ case AATriangle::NORTHWEST | AATriangle::DEFORM_LEFT:
tile_x = tile_bbox.get_left ();
tile_y = tile_bbox.get_bottom ();
gradient = -1.0;
break;
- case AATriangle::SOUTHWEST | DEFORM_BOTTOM:
- case AATriangle::SOUTHWEST | DEFORM_RIGHT:
- case AATriangle::NORTHEAST | DEFORM_BOTTOM:
- case AATriangle::NORTHEAST | DEFORM_RIGHT:
+ case AATriangle::SOUTHWEST | AATriangle::DEFORM_BOTTOM:
+ case AATriangle::SOUTHWEST | AATriangle::DEFORM_RIGHT:
+ case AATriangle::NORTHEAST | AATriangle::DEFORM_BOTTOM:
+ case AATriangle::NORTHEAST | AATriangle::DEFORM_RIGHT:
tile_x = tile_bbox.get_right ();
tile_y = tile_bbox.get_bottom ();
gradient = 1.0;
delta_y *= .70710678118654752440; /* 1/sqrt(2) */
break;
- case DEFORM_BOTTOM:
- case DEFORM_TOP:
+ case AATriangle::DEFORM_BOTTOM:
+ case AATriangle::DEFORM_TOP:
delta_x *= .44721359549995793928; /* 1/sqrt(5) */
delta_y *= .89442719099991587856; /* 2/sqrt(5) */
gradient *= 0.5;
break;
- case DEFORM_LEFT:
- case DEFORM_RIGHT:
+ case AATriangle::DEFORM_LEFT:
+ case AATriangle::DEFORM_RIGHT:
delta_x *= .89442719099991587856; /* 2/sqrt(5) */
delta_y *= .44721359549995793928; /* 1/sqrt(5) */
gradient *= 2.0;
// only handle unisolid when the player is falling down and when he was
// above the tile before
- if(tile->getAttributes() & Tile::UNISOLID) {
+ if(tile->is_unisolid ()) {
int status;
Vector relative_movement = movement
- solids->get_movement(/* actual = */ true);
continue;
}
- if(tile->getAttributes() & Tile::SLOPE) { // slope tile
+ if(tile->is_slope ()) { // slope tile
AATriangle triangle;
int slope_data = tile->getData();
if (solids->get_drawing_effect() == VERTICAL_FLIP)
if(!tile) continue;
if(!(tile->getAttributes() & Tile::SOLID))
continue;
- if((tile->getAttributes() & Tile::UNISOLID) && ignoreUnisolid)
+ if(tile->is_unisolid () && ignoreUnisolid)
continue;
- if(tile->getAttributes() & Tile::SLOPE) {
+ if(tile->is_slope ()) {
AATriangle triangle;
Rectf tbbox = solids->get_tile_bbox(x, y);
triangle = AATriangle(tbbox, tile->getData());
return gravity;
}
-Player *
+Player*
Sector::get_nearest_player (const Vector& pos)
{
- Player *nearest_player;
- float nearest_dist;
-
- nearest_player = NULL;
+ Player *nearest_player = NULL;
+ float nearest_dist = std::numeric_limits<float>::max();
std::vector<Player*> players = Sector::current()->get_players();
for (std::vector<Player*>::iterator playerIter = players.begin();
++playerIter)
{
Player *this_player = *playerIter;
- float x_dist;
- float y_dist;
- float this_dist;
-
if (this_player->is_dying() || this_player->is_dead())
continue;
- x_dist = fabs ((this_player->get_pos ().x) - pos.x);
- y_dist = fabs ((this_player->get_pos ().y) - pos.y);
- this_dist = sqrtf (x_dist*x_dist + y_dist*y_dist);
+ float this_dist = this_player->get_bbox ().distance(pos);
- if ((nearest_player == NULL) || (nearest_dist > this_dist)) {
+ if (this_dist < nearest_dist) {
nearest_player = this_player;
nearest_dist = this_dist;
}
}
- return (nearest_player);
+ return nearest_player;
} /* Player *get_nearest_player */
+std::vector<MovingObject*>
+Sector::get_nearby_objects (const Vector& center, float max_distance)
+{
+ std::vector<MovingObject*> ret;
+ std::vector<Player*> players = Sector::current()->get_players();
+
+ for (size_t i = 0; i < players.size (); i++) {
+ float distance = players[i]->get_bbox ().distance (center);
+ if (distance <= max_distance)
+ ret.push_back (players[i]);
+ }
+
+ for (size_t i = 0; i < moving_objects.size (); i++) {
+ float distance = moving_objects[i]->get_bbox ().distance (center);
+ if (distance <= max_distance)
+ ret.push_back (moving_objects[i]);
+ }
+
+ return (ret);
+}
+
/* vim: set sw=2 sts=2 et : */
/* EOF */
projects / supertux.git / blobdiff