X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=src%2Fsupertux%2Fsector.cpp;h=0add01f0029f1843fe7a884a782f0fd761f53180;hb=08bddcf4d4fbe2edf9a0078dc6f3c3275ef05302;hp=d337fc8e72788943c6a78006d92f611f21d0b4b1;hpb=4cfce5fd814629d7782c894235b56a2e760c8d8c;p=supertux.git

diff --git a/src/supertux/sector.cpp b/src/supertux/sector.cpp
index d337fc8e7..0add01f00 100644
--- a/src/supertux/sector.cpp
+++ b/src/supertux/sector.cpp
@@ -45,7 +45,7 @@
 #include "object/snow_particle_system.hpp"
 #include "object/text_object.hpp"
 #include "object/tilemap.hpp"
-#include "physfs/ifile_stream.hpp"
+#include "physfs/ifile_streambuf.hpp"
 #include "scripting/squirrel_util.hpp"
 #include "supertux/collision.hpp"
 #include "supertux/constants.hpp"
@@ -409,19 +409,26 @@ Sector::fix_old_tiles()
       for(size_t y=0; y < solids->get_height(); ++y) {
         uint32_t    id   = solids->get_tile_id(x, y);
         const Tile *tile = solids->get_tile(x, y);
-        Vector pos(solids->get_x_offset() + x*32, solids->get_y_offset() + y*32);
+        Vector pos = solids->get_tile_position(x, y);
 
         if(id == 112) {
           add_object(new InvisibleBlock(pos));
           solids->change(x, y, 0);
         } else if(tile->getAttributes() & Tile::COIN) {
-          add_object(new Coin(pos));
+          add_object(new Coin(pos, solids));
           solids->change(x, y, 0);
         } else if(tile->getAttributes() & Tile::FULLBOX) {
           add_object(new BonusBlock(pos, tile->getData()));
           solids->change(x, y, 0);
         } else if(tile->getAttributes() & Tile::BRICK) {
-          add_object(new Brick(pos, tile->getData()));
+          if( ( id == 78 ) || ( id == 105 ) ){
+            add_object( new Brick(pos, tile->getData(), "images/objects/bonus_block/brickIce.sprite") );
+          } else if( ( id == 77 ) || ( id == 104 ) ){
+            add_object( new Brick(pos, tile->getData(), "images/objects/bonus_block/brick.sprite") );
+          } else {
+            log_warning << "attribute 'brick #t' is not supported for tile-id " << id << std::endl;
+            add_object( new Brick(pos, tile->getData(), "images/objects/bonus_block/brick.sprite") );
+          }
           solids->change(x, y, 0);
         } else if(tile->getAttributes() & Tile::GOAL) {
           std::string sequence = tile->getData() == 0 ? "endsequence" : "stoptux";
@@ -439,8 +446,8 @@ Sector::fix_old_tiles()
     for(size_t x=0; x < tm->get_width(); ++x) {
       for(size_t y=0; y < tm->get_height(); ++y) {
         uint32_t id = tm->get_tile_id(x, y);
-        Vector pos(tm->get_x_offset() + x*32, tm->get_y_offset() + y*32);
-        Vector center(pos.x + 16, pos.y + 16);
+        Vector pos = tm->get_tile_position(x, y);
+        Vector center = pos + Vector(16, 16);
 
         // torch
         if (id == 1517) {
@@ -509,15 +516,11 @@ Sector::add_object(GameObject* object)
 #ifndef NDEBUG
   for(GameObjects::iterator i = gameobjects.begin(); i != gameobjects.end();
       ++i) {
-    if(*i == object) {
-      assert("object already added to sector" == 0);
-    }
+    assert(*i != object);
   }
   for(GameObjects::iterator i = gameobjects_new.begin();
       i != gameobjects_new.end(); ++i) {
-    if(*i == object) {
-      assert("object already added to sector" == 0);
-    }
+    assert(*i != object);
   }
 #endif
 
@@ -574,22 +577,37 @@ Sector::activate(const Vector& player_pos)
   }
   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);
+    }
   }
 
+  //FIXME: This is a really dirty workaround for this strange camera jump
+  player->move(player->get_pos()+Vector(-32, 0));
   camera->reset(player->get_pos());
+  camera->update(1);
+  player->move(player->get_pos()+(Vector(32, 0)));
+  camera->update(1);
+  
   update_game_objects();
 
   //Run default.nut just before init script
@@ -597,7 +615,8 @@ Sector::activate(const Vector& player_pos)
   std::string basedir = FileSystem::dirname(get_level()->filename);
   if(PHYSFS_exists((basedir + "/info").c_str())) {
     try {
-      IFileStream in(basedir + "/default.nut");
+      IFileStreambuf ins(basedir + "/default.nut");
+      std::istream in(&ins);
       run_script(in, "default.nut");
     } catch(std::exception& ) {
       // doesn't exist or erroneous; do nothing
@@ -647,7 +666,7 @@ Sector::get_active_region()
 void
 Sector::update(float elapsed_time)
 {
-  player->check_bounds(camera);
+  player->check_bounds();
 
   /* update objects */
   for(GameObjects::iterator i = gameobjects.begin();
@@ -862,13 +881,13 @@ Sector::draw(DrawingContext& context)
   }
 
   if(show_collrects) {
-    Color col(0.2f, 0.2f, 0.2f, 0.7f);
+    Color color(1.0f, 0.0f, 0.0f, 0.75f);
     for(MovingObjects::iterator i = moving_objects.begin();
         i != moving_objects.end(); ++i) {
       MovingObject* object = *i;
       const Rectf& rect = object->get_bbox();
 
-      context.draw_filled_rect(rect, col, LAYER_FOREGROUND1 + 10);
+      context.draw_filled_rect(rect, color, LAYER_FOREGROUND1 + 10);
     }
   }
 
@@ -881,10 +900,10 @@ Sector::draw(DrawingContext& context)
 
 /** r1 is supposed to be moving, r2 a solid object */
 void check_collisions(collision::Constraints* constraints,
-                      const Vector& movement, const Rectf& r1, const Rectf& r2,
-                      GameObject* object = NULL, MovingObject* other = NULL, const Vector& addl_ground_movement = Vector(0,0))
+                      const Vector& obj_movement, const Rectf& obj_rect, const Rectf& other_rect,
+                      GameObject* object = NULL, MovingObject* other = NULL, const Vector& other_movement = Vector(0,0))
 {
-  if(!collision::intersects(r1, r2))
+  if(!collision::intersects(obj_rect, other_rect))
     return;
 
   MovingObject *moving_object = dynamic_cast<MovingObject*> (object);
@@ -895,31 +914,31 @@ void check_collisions(collision::Constraints* constraints,
     return;
 
   // calculate intersection
-  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 itop    = obj_rect.get_bottom() - other_rect.get_top();
+  float ibottom = other_rect.get_bottom() - obj_rect.get_top();
+  float ileft   = obj_rect.get_right() - other_rect.get_left();
+  float iright  = other_rect.get_right() - obj_rect.get_left();
 
-  if(fabsf(movement.y) > fabsf(movement.x)) {
+  if(fabsf(obj_movement.y) > fabsf(obj_movement.x)) {
     if(ileft < SHIFT_DELTA) {
-      constraints->right = std::min(constraints->right, r2.get_left());
+      constraints->constrain_right(other_rect.get_left(), other_movement.x);
       return;
     } else if(iright < SHIFT_DELTA) {
-      constraints->left = std::max(constraints->left, r2.get_right());
+      constraints->constrain_left(other_rect.get_right(), other_movement.x);
       return;
     }
   } else {
     // shiftout bottom/top
     if(itop < SHIFT_DELTA) {
-      constraints->bottom = std::min(constraints->bottom, r2.get_top());
+      constraints->constrain_bottom(other_rect.get_top(), other_movement.y);
       return;
     } else if(ibottom < SHIFT_DELTA) {
-      constraints->top = std::max(constraints->top, r2.get_bottom());
+      constraints->constrain_top(other_rect.get_bottom(), other_movement.y);
       return;
     }
   }
 
-  constraints->ground_movement += addl_ground_movement;
+  constraints->ground_movement += other_movement;
   if(other != NULL) {
     HitResponse response = other->collision(*object, dummy);
     if(response == ABORT_MOVE)
@@ -935,18 +954,18 @@ void check_collisions(collision::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(other_rect.get_top(), other_movement.y);
       constraints->hit.bottom = true;
     } else {
-      constraints->top = std::max(constraints->top, r2.get_bottom());
+      constraints->constrain_top(other_rect.get_bottom(), other_movement.y);
       constraints->hit.top = true;
     }
   } else {
     if(ileft < iright) {
-      constraints->right = std::min(constraints->right, r2.get_left());
+      constraints->constrain_right(other_rect.get_left(), other_movement.x);
       constraints->hit.right = true;
     } else {
-      constraints->left = std::max(constraints->left, r2.get_right());
+      constraints->constrain_left(other_rect.get_right(), other_movement.x);
       constraints->hit.left = true;
     }
   }
@@ -954,7 +973,8 @@ void check_collisions(collision::Constraints* constraints,
 
 void
 Sector::collision_tilemap(collision::Constraints* constraints,
-                          const Vector& movement, const Rectf& dest) const
+                          const Vector& movement, const Rectf& dest,
+                          MovingObject& object) const
 {
   // calculate rectangle where the object will move
   float x1 = dest.get_left();
@@ -966,36 +986,42 @@ Sector::collision_tilemap(collision::Constraints* constraints,
     TileMap* solids = *i;
 
     // test with all tiles in this rectangle
-    int starttilex = int(x1 - solids->get_x_offset()) / 32;
-    int starttiley = int(y1 - solids->get_y_offset()) / 32;
-    int max_x = int(x2 - solids->get_x_offset());
-    int max_y = int(y2+1 - solids->get_y_offset());
+    Rect test_tiles = solids->get_tiles_overlapping(Rectf(x1, y1, x2, y2));
 
-    for(int x = starttilex; x*32 < max_x; ++x) {
-      for(int y = starttiley; y*32 < max_y; ++y) {
+    for(int x = test_tiles.left; x < test_tiles.right; ++x) {
+      for(int y = test_tiles.top; y < test_tiles.bottom; ++y) {
         const Tile* tile = solids->get_tile(x, y);
         if(!tile)
           continue;
         // skip non-solid tiles
-        if((tile->getAttributes() & Tile::SOLID) == 0)
+        if(!tile->is_solid ())
           continue;
-        // only handle unisolid when the player is falling down and when he was
-        // above the tile before
-        if(tile->getAttributes() & Tile::UNISOLID) {
-          if(movement.y <= 0 || dest.get_bottom() - movement.y - SHIFT_DELTA > y*32)
+        Rectf tile_bbox = solids->get_tile_bbox(x, y);
+
+        /* If the tile is a unisolid tile, the "is_solid()" function above
+         * didn't do a thorough check. Calculate the position and (relative)
+         * movement of the object and determine whether or not the tile is
+         * solid with regard to those parameters. */
+        if(tile->is_unisolid ()) {
+          Vector relative_movement = movement
+            - solids->get_movement(/* actual = */ true);
+
+          if (!tile->is_solid (tile_bbox, object.get_bbox(), relative_movement))
             continue;
-        }
+        } /* if (tile->is_unisolid ()) */
 
-        if(tile->getAttributes() & Tile::SLOPE) { // slope tile
+        if(tile->is_slope ()) { // slope tile
           AATriangle triangle;
-          Vector p1(x*32 + solids->get_x_offset(), y*32 + solids->get_y_offset());
-          Vector p2((x+1)*32 + solids->get_x_offset(), (y+1)*32 + solids->get_y_offset());
-          triangle = AATriangle(p1, p2, tile->getData());
+          int slope_data = tile->getData();
+          if (solids->get_drawing_effect() == VERTICAL_FLIP)
+            slope_data = AATriangle::vertical_flip(slope_data);
+          triangle = AATriangle(tile_bbox, slope_data);
 
-          collision::rectangle_aatriangle(constraints, dest, triangle, solids->get_movement());
+          collision::rectangle_aatriangle(constraints, dest, triangle,
+              solids->get_movement(/* actual = */ false));
         } else { // normal rectangular tile
-          Rectf rect(x*32 + solids->get_x_offset(), y*32 + solids->get_y_offset(), (x+1)*32 + solids->get_x_offset(), (y+1)*32 + solids->get_y_offset());
-          check_collisions(constraints, movement, dest, rect, NULL, NULL, solids->get_movement());
+          check_collisions(constraints, movement, dest, tile_bbox, NULL, NULL,
+              solids->get_movement(/* actual = */ false));
         }
       }
     }
@@ -1015,21 +1041,19 @@ Sector::collision_tile_attributes(const Rectf& dest) const
     TileMap* solids = *i;
 
     // test with all tiles in this rectangle
-    int starttilex = int(x1 - solids->get_x_offset()) / 32;
-    int starttiley = int(y1 - solids->get_y_offset()) / 32;
-    int max_x = int(x2 - solids->get_x_offset());
-    int max_y = int(y2+1 - solids->get_y_offset());
-    int max_y_ice = int(max_y + SHIFT_DELTA);
+    Rect test_tiles = solids->get_tiles_overlapping(Rectf(x1, y1, x2, y2));
+    // For ice (only), add a little fudge to recognize tiles Tux is standing on.
+    Rect test_tiles_ice = solids->get_tiles_overlapping(Rectf(x1, y1, x2, y2 + SHIFT_DELTA));
 
-    for(int x = starttilex; x*32 < max_x; ++x) {
+    for(int x = test_tiles.left; x < test_tiles.right; ++x) {
       int y;
-      for(y = starttiley; y*32 < max_y; ++y) {
+      for(y = test_tiles.top; y < test_tiles.bottom; ++y) {
         const Tile* tile = solids->get_tile(x, y);
         if(!tile)
           continue;
         result |= tile->getAttributes();
       }
-      for(; y*32 < max_y_ice; ++y) {
+      for(; y < test_tiles_ice.bottom; ++y) {
         const Tile* tile = solids->get_tile(x, y);
         if(!tile)
           continue;
@@ -1114,9 +1138,9 @@ Sector::collision_object(MovingObject* object1, MovingObject* object2) const
 void
 Sector::collision_static(collision::Constraints* constraints,
                          const Vector& movement, const Rectf& dest,
-                         GameObject& object)
+                         MovingObject& object)
 {
-  collision_tilemap(constraints, movement, dest);
+  collision_tilemap(constraints, movement, dest, object);
 
   // collision with other (static) objects
   for(MovingObjects::iterator i = moving_objects.begin();
@@ -1143,8 +1167,6 @@ Sector::collision_static_constrains(MovingObject& object)
   Constraints constraints;
   Vector movement = object.get_movement();
   Rectf& dest = object.dest;
-  float owidth = object.get_bbox().get_width();
-  float oheight = object.get_bbox().get_height();
 
   for(int i = 0; i < 2; ++i) {
     collision_static(&constraints, Vector(0, movement.y), dest, object);
@@ -1152,18 +1174,18 @@ Sector::collision_static_constrains(MovingObject& object)
       break;
 
     // apply calculated horizontal constraints
-    if(constraints.bottom < infinity) {
-      float height = constraints.bottom - constraints.top;
-      if(height < oheight) {
+    if(constraints.get_position_bottom() < infinity) {
+      float height = constraints.get_height ();
+      if(height < object.get_bbox().get_height()) {
         // we're crushed, but ignore this for now, we'll get this again
         // later if we're really crushed or things will solve itself when
         // looking at the vertical constraints
       }
-      dest.p2.y = constraints.bottom - DELTA;
-      dest.p1.y = dest.p2.y - oheight;
-    } else if(constraints.top > -infinity) {
-      dest.p1.y = constraints.top + DELTA;
-      dest.p2.y = dest.p1.y + oheight;
+      dest.p2.y = constraints.get_position_bottom() - DELTA;
+      dest.p1.y = dest.p2.y - object.get_bbox().get_height();
+    } else if(constraints.get_position_top() > -infinity) {
+      dest.p1.y = constraints.get_position_top() + DELTA;
+      dest.p2.y = dest.p1.y + object.get_bbox().get_height();
     }
   }
   if(constraints.has_constraints()) {
@@ -1184,12 +1206,12 @@ Sector::collision_static_constrains(MovingObject& object)
       break;
 
     // apply calculated vertical constraints
-    if(constraints.right < infinity) {
-      float width = constraints.right - constraints.left;
-      if(width + SHIFT_DELTA < owidth) {
+    float width = constraints.get_width ();
+    if(width < infinity) {
+      if(width + SHIFT_DELTA < object.get_bbox().get_width()) {
 #if 0
         printf("Object %p crushed horizontally... L:%f R:%f\n", &object,
-               constraints.left, constraints.right);
+               constraints.get_position_left(), constraints.get_position_right());
 #endif
         CollisionHit h;
         h.left = true;
@@ -1197,12 +1219,16 @@ Sector::collision_static_constrains(MovingObject& object)
         h.crush = true;
         object.collision_solid(h);
       } else {
-        dest.p2.x = constraints.right - DELTA;
-        dest.p1.x = dest.p2.x - owidth;
+        float xmid = constraints.get_x_midpoint ();
+        dest.p1.x = xmid - object.get_bbox().get_width()/2;
+        dest.p2.x = xmid + object.get_bbox().get_width()/2;
       }
-    } else if(constraints.left > -infinity) {
-      dest.p1.x = constraints.left + DELTA;
-      dest.p2.x = dest.p1.x + owidth;
+    } else if(constraints.get_position_right() < infinity) {
+      dest.p2.x = constraints.get_position_right() - DELTA;
+      dest.p1.x = dest.p2.x - object.get_bbox().get_width();
+    } else if(constraints.get_position_left() > -infinity) {
+      dest.p1.x = constraints.get_position_left() + DELTA;
+      dest.p2.x = dest.p1.x + object.get_bbox().get_width();
     }
   }
 
@@ -1216,9 +1242,9 @@ Sector::collision_static_constrains(MovingObject& object)
   // an extra pass to make sure we're not crushed horizontally
   constraints = Constraints();
   collision_static(&constraints, movement, dest, object);
-  if(constraints.bottom < infinity) {
-    float height = constraints.bottom - constraints.top;
-    if(height + SHIFT_DELTA < oheight) {
+  if(constraints.get_position_bottom() < infinity) {
+    float height = constraints.get_height ();
+    if(height + SHIFT_DELTA < object.get_bbox().get_height()) {
 #if 0
       printf("Object %p crushed vertically...\n", &object);
 #endif
@@ -1358,24 +1384,26 @@ Sector::is_free_of_tiles(const Rectf& rect, const bool ignoreUnisolid) const
     TileMap* solids = *i;
 
     // test with all tiles in this rectangle
-    int starttilex = int(rect.p1.x - solids->get_x_offset()) / 32;
-    int starttiley = int(rect.p1.y - solids->get_y_offset()) / 32;
-    int max_x = int(rect.p2.x - solids->get_x_offset());
-    int max_y = int(rect.p2.y - solids->get_y_offset());
+    Rect test_tiles = solids->get_tiles_overlapping(rect);
 
-    for(int x = starttilex; x*32 <= max_x; ++x) {
-      for(int y = starttiley; y*32 <= max_y; ++y) {
+    for(int x = test_tiles.left; x < test_tiles.right; ++x) {
+      for(int y = test_tiles.top; y < test_tiles.bottom; ++y) {
         const Tile* tile = solids->get_tile(x, y);
         if(!tile) continue;
-        if(tile->getAttributes() & Tile::SLOPE) {
+        if(!(tile->getAttributes() & Tile::SOLID))
+          continue;
+        if(tile->is_unisolid () && ignoreUnisolid)
+          continue;
+        if(tile->is_slope ()) {
           AATriangle triangle;
-          Vector p1(x*32 + solids->get_x_offset(), y*32 + solids->get_y_offset());
-          Vector p2((x+1)*32 + solids->get_x_offset(), (y+1)*32 + solids->get_y_offset());
-          triangle = AATriangle(p1, p2, tile->getData());
+          Rectf tbbox = solids->get_tile_bbox(x, y);
+          triangle = AATriangle(tbbox, tile->getData());
           Constraints constraints;
-          if(collision::rectangle_aatriangle(&constraints, rect, triangle) && (!ignoreUnisolid || !(tile->getAttributes() & Tile::UNISOLID))) return false;
+          if(!collision::rectangle_aatriangle(&constraints, rect, triangle))
+            continue;
         }
-        if((tile->getAttributes() & Tile::SOLID) && (!ignoreUnisolid || !(tile->getAttributes() & Tile::UNISOLID))) return false;
+        // We have a solid tile that overlaps the given rectangle.
+        return false;
       }
     }
   }
@@ -1460,7 +1488,7 @@ Sector::play_music(MusicType type)
       sound_manager->play_music(music);
       break;
     case HERRING_MUSIC:
-      sound_manager->play_music("music/invincible.music");
+      sound_manager->play_music("music/invincible.ogg");
       break;
     case HERRING_WARNING_MUSIC:
       sound_manager->stop_music(TUX_INVINCIBLE_TIME_WARNING);
@@ -1496,10 +1524,11 @@ Sector::inside(const Rectf& rect) const
 {
   for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin(); i != solid_tilemaps.end(); i++) {
     TileMap* solids = *i;
-    bool horizontally = ((rect.p2.x >= 0 + solids->get_x_offset()) && (rect.p1.x <= solids->get_width() * 32 + solids->get_x_offset()));
-    bool vertically = (rect.p1.y <= solids->get_height() * 32 + solids->get_y_offset());
 
-    if (horizontally && vertically)
+    Rectf bbox = solids->get_bbox();
+    bbox.p1.y = -INFINITY; // pretend the tilemap extends infinitely far upwards
+
+    if (bbox.contains(rect))
       return true;
   }
   return false;
@@ -1512,9 +1541,7 @@ Sector::get_width() const
   for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin();
       i != solid_tilemaps.end(); i++) {
     TileMap* solids = *i;
-    if ((solids->get_width() * 32 + solids->get_x_offset()) > width) {
-      width = solids->get_width() * 32 + solids->get_x_offset();
-    }
+    width = std::max(width, solids->get_bbox().get_right());
   }
 
   return width;
@@ -1527,9 +1554,7 @@ Sector::get_height() const
   for(std::list<TileMap*>::const_iterator i = solid_tilemaps.begin();
       i != solid_tilemaps.end(); i++) {
     TileMap* solids = *i;
-    if ((solids->get_height() * 32 + solids->get_y_offset()) > height) {
-      height = solids->get_height() * 32 + solids->get_y_offset();
-    }
+    height = std::max(height, solids->get_bbox().get_bottom());
   }
 
   return height;
@@ -1583,4 +1608,52 @@ Sector::get_gravity() const
   return gravity;
 }
 
+Player*
+Sector::get_nearest_player (const Vector& pos)
+{
+  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 != players.end();
+      ++playerIter)
+  {
+    Player *this_player = *playerIter;
+    if (this_player->is_dying() || this_player->is_dead())
+      continue;
+
+    float this_dist = this_player->get_bbox ().distance(pos);
+
+    if (this_dist < nearest_dist) {
+      nearest_player = this_player;
+      nearest_dist = this_dist;
+    }
+  }
+
+  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 */