Lazy sunday typo fixing. s/unban_player_of_ip/unban_player_or_ip/g

[dragonfireclient.git] / src / collision.cpp

diff --git a/src/collision.cpp b/src/collision.cpp
index eb948e3c36a1f9252bc0621aa4a8df8af136bb90..3058426eb380f4f11acf12606b00f44723ce7580 100644 (file)
--- a/src/collision.cpp
+++ b/src/collision.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -23,7 +23,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "nodedef.h"
 #include "gamedef.h"
 #include "log.h"
+#include "environment.h"
+#include "serverobject.h"
 #include <vector>
+#include <set>
 #include "util/timetaker.h"
 #include "main.h" // g_profiler
 #include "profiler.h"
@@ -186,11 +189,12 @@ bool wouldCollideWithCeiling(
 }
 
 
-collisionMoveResult collisionMoveSimple(Map *map, IGameDef *gamedef,
+collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
                f32 pos_max_d, const aabb3f &box_0,
                f32 stepheight, f32 dtime,
-               v3f &pos_f, v3f &speed_f, v3f &accel_f)
+               v3f &pos_f, v3f &speed_f, v3f &accel_f,ActiveObject* self)
 {
+       Map *map = &env->getMap();
        //TimeTaker tt("collisionMoveSimple");
     ScopeProfiler sp(g_profiler, "collisionMoveSimple avg", SPT_AVG);
 
@@ -205,16 +209,22 @@ collisionMoveResult collisionMoveSimple(Map *map, IGameDef *gamedef,
        }
        speed_f += accel_f * dtime;
 
-    // If there is no speed, there are no collisions
+       // If there is no speed, there are no collisions
        if(speed_f.getLength() == 0)
                return result;
 
+       // Limit speed for avoiding hangs
+       speed_f.Y=rangelim(speed_f.Y,-5000,5000);
+       speed_f.X=rangelim(speed_f.X,-5000,5000);
+       speed_f.Z=rangelim(speed_f.Z,-5000,5000);
+
        /*
                Collect node boxes in movement range
        */
        std::vector<aabb3f> cboxes;
        std::vector<bool> is_unloaded;
        std::vector<bool> is_step_up;
+       std::vector<bool> is_object;
        std::vector<int> bouncy_values;
        std::vector<v3s16> node_positions;
        {
@@ -256,6 +266,7 @@ collisionMoveResult collisionMoveSimple(Map *map, IGameDef *gamedef,
                                is_step_up.push_back(false);
                                bouncy_values.push_back(n_bouncy_value);
                                node_positions.push_back(p);
+                               is_object.push_back(false);
                        }
                }
                catch(InvalidPositionException &e)
@@ -267,14 +278,76 @@ collisionMoveResult collisionMoveSimple(Map *map, IGameDef *gamedef,
                        is_step_up.push_back(false);
                        bouncy_values.push_back(0);
                        node_positions.push_back(p);
+                       is_object.push_back(false);
                }
        }
        } // tt2
 
+       {
+               ScopeProfiler sp(g_profiler, "collisionMoveSimple objects avg", SPT_AVG);
+               //TimeTaker tt3("collisionMoveSimple collect object boxes");
+
+               /* add object boxes to cboxes */
+
+
+               std::list<ActiveObject*> objects;
+#ifndef SERVER
+               ClientEnvironment *c_env = dynamic_cast<ClientEnvironment*>(env);
+               if (c_env != 0)
+               {
+                       f32 distance = speed_f.getLength();
+                       std::vector<DistanceSortedActiveObject> clientobjects;
+                       c_env->getActiveObjects(pos_f,distance * 1.5,clientobjects);
+                       for (size_t i=0; i < clientobjects.size(); i++)
+                       {
+                               if ((self == 0) || (self != clientobjects[i].obj)) {
+                                       objects.push_back((ActiveObject*)clientobjects[i].obj);
+                               }
+                       }
+               }
+               else
+#endif
+               {
+                       ServerEnvironment *s_env = dynamic_cast<ServerEnvironment*>(env);
+                       if (s_env != 0)
+                       {
+                               f32 distance = speed_f.getLength();
+                               std::set<u16> s_objects = s_env->getObjectsInsideRadius(pos_f,distance * 1.5);
+                               for (std::set<u16>::iterator iter = s_objects.begin(); iter != s_objects.end(); iter++)
+                               {
+                                       ServerActiveObject *current = s_env->getActiveObject(*iter);
+                                       if ((self == 0) || (self != current)) {
+                                               objects.push_back((ActiveObject*)current);
+                                       }
+                               }
+                       }
+               }
+
+               for (std::list<ActiveObject*>::const_iterator iter = objects.begin();iter != objects.end(); ++iter)
+               {
+                       ActiveObject *object = *iter;
+
+                       if (object != NULL)
+                       {
+                               aabb3f object_collisionbox;
+                               if (object->getCollisionBox(&object_collisionbox))
+                               {
+                                       cboxes.push_back(object_collisionbox);
+                                       is_unloaded.push_back(false);
+                                       is_step_up.push_back(false);
+                                       bouncy_values.push_back(0);
+                                       node_positions.push_back(v3s16(0,0,0));
+                                       is_object.push_back(true);
+                               }
+                       }
+               }
+       } //tt3
+
        assert(cboxes.size() == is_unloaded.size());
        assert(cboxes.size() == is_step_up.size());
        assert(cboxes.size() == bouncy_values.size());
        assert(cboxes.size() == node_positions.size());
+       assert(cboxes.size() == is_object.size());
 
        /*
                Collision detection
@@ -386,7 +459,12 @@ collisionMoveResult collisionMoveSimple(Map *map, IGameDef *gamedef,
                                is_collision = false;
 
                        CollisionInfo info;
-                       info.type = COLLISION_NODE;
+                       if (is_object[nearest_boxindex]) {
+                               info.type = COLLISION_OBJECT;
+                       }
+                       else {
+                               info.type = COLLISION_NODE;
+                       }
                        info.node_p = node_positions[nearest_boxindex];
                        info.bouncy = bouncy;
                        info.old_speed = speed_f;