Changeset 10599 in orxonox.OLD

Timestamp:

Feb 24, 2007, 12:25:48 PM (17 years ago)

Author:

bottac

Message:

1st part of the collision bug fix.

BTW, if shouldn't have amarok (what a pity), try to
suspend/'wake up' orxonox (CTRL-Z / fg).

Location:

branches/cleanup/src

Files:

• lib/collision_reaction/cr_engine.h (modified) (1 diff)
• lib/collision_reaction/cr_physics_full_walk.cc (modified) (1 diff)
• lib/graphics/importer/bsp/bsp_manager.cc (modified) (7 diffs)
• lib/graphics/importer/bsp/bsp_manager.h (modified) (1 diff)
• world_entities/creatures/fps_player.cc (modified) (2 diffs)

branches/cleanup/src/lib/collision_reaction/cr_engine.h

@@ -62 +62 @@
       CR_COLLISION_TYPE_AXIS_Z,            //!< collision on z axis
       CR_COLLISION_TYPE_AXIS_Z_NEG,        //!< collision on negative z axis
+      CR_COLLISION_TYPE_WAY,               //!< collision on the way from last to current position
       CR_COLLISION_TYPE_OBB,               //!< object aligned bounding box collide
 

branches/cleanup/src/lib/collision_reaction/cr_physics_full_walk.cc

@@ -163 +163 @@
 
 
+ case CoRe::CREngine::CR_COLLISION_TYPE_WAY:
+          // calulate the height above ground
+          height = collPos.len() - box->halfLength[1];
+
+
+          // object is beneath the plane (ground)
+          //         if(height >= 0.0f && height <= 0.0001f) break ;// Do nothing
+          if( height < 0.0f  )
+          {
+            entity->shiftCoor(Vector(0.0f, -height + 0.5f, 0.0f));
+            entity->setOnGround(true);
+          }
+          // object is already in the wall
+          else if( ce->isInWall())
+          {
+            entity->setAbsCoor(entity->getLastAbsCoor());
+            PRINTF(0)("ground collision: reset pos\n");
+          }
+          else
+          {
+            // entity is not on ground
+            entity->setOnGround(false);
+          }
+          break;
+
+
           /* collision in the Z-AXIS */
         case CoRe::CREngine::CR_COLLISION_TYPE_AXIS_Z:

branches/cleanup/src/lib/graphics/importer/bsp/bsp_manager.cc

@@ -1102 +1102 @@
   this->outputFraction = 1.0f;
 
-
   this->checkCollisionX(worldEntity);
-  this->checkCollisionY(worldEntity);
   this->checkCollisionZ(worldEntity);
+
+  if(!(this->checkCollisionY(worldEntity)))
+  this->checkCollisionWay(worldEntity);
 
 
@@ -1288 +1289 @@
  * check the collision in the x direction (forward, backward)
  */
-void BspManager::checkCollisionX(WorldEntity* entity)
+bool BspManager::checkCollisionX(WorldEntity* entity)
 {
   // Retrieve Bounding box
@@ -1398 +1399 @@
                               SolidFlag);
   }
+
+ return (xCollisionBackward || xCollisionForward);
 }
 
@@ -1404 +1407 @@
  * check the collision in the z direction (up, down)
  */
-void BspManager::checkCollisionY(WorldEntity* entity)
+bool BspManager::checkCollisionY(WorldEntity* entity)
 {
 
@@ -1546 +1549 @@
                               collPos, SolidFlag);
   }
+
+ return (yCollisionUp || yCollisionDown);
 }
 
@@ -1554 +1559 @@
  * check the collision in the z direction (left, right)
  */
-void BspManager::checkCollisionZ(WorldEntity* entity)
+bool BspManager::checkCollisionZ(WorldEntity* entity)
 {
   // Retrieve Bounding box
@@ -1664 +1669 @@
                                collPos , SolidFlag);
   }
+
+ return (zCollisionLeft || zCollisionRight);
+
+}
+
+
+
+
+/**
+ * check wether a collision occured on the way from the last position to the current position
+ */
+bool BspManager::checkCollisionWay(WorldEntity* entity)
+{
+
+
+  
+  plane*            testPlane          = NULL;  //!< the collision test plane
+  Vector            to;
+  Vector            collPos;                    //!< the collision position
+
+  bool              yCollisionUp       = false; //!< flag true if right collision
+  bool              SolidFlag          = false; //!< flag set true if solid
+
+  Vector            from;                   //!< current position of the entity
+  Vector            dirY;                       //!< direction x
+
+  from = entity->getLastAbsCoor();
+  to    = entity->getAbsCoor();
+  collPos = from;
+  dirY =  Vector(0.0, 1.0, 0.0);
+
+
+
+
+  /*   Y Ray up */
+  // init some member variables before collision check
+  this->inputStart = from;
+  this->inputEnd   = to;
+  this->checkCollisionRayN(this->root,0.0f,1.0f, &from, &to );
+
+  if( !this->outputStartsOut )
+  {
+    this->collPlane = new plane;
+    this->collPlane->x = 0.0f;
+    this->collPlane->y = 0.0f;
+    this->collPlane->z = 0.0f;
+    yCollisionUp = true;
+  }
+  else
+  {
+    if( this->outputFraction == 1.0f)
+    {
+      if( this->outputAllSolid )
+      {
+        this->collPlane = new plane;
+        this->collPlane->x = 0.0f;
+        this->collPlane->y = 0.0f;
+        this->collPlane->z = 0.0f;
+        yCollisionUp = true;
+        SolidFlag = true;
+      }
+      else
+      {
+        yCollisionUp = false;
+        collPos = to;
+      }
+    }
+    else
+    {
+      yCollisionUp = true;
+      collPos = from + (to - from) * this->outputFraction;
+      this->out = collPos;        // why this????
+    }
+  }
+  testPlane = this->collPlane;
+
+  // collision registration
+  if( yCollisionUp)
+  {
+    CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_WAY,
+                              entity, this->parent,
+                              Vector(testPlane->x, testPlane->y, testPlane->z),
+                              collPos, SolidFlag);
+  }
+
+ return yCollisionUp;
 
 }

branches/cleanup/src/lib/graphics/importer/bsp/bsp_manager.h

@@ -88 +88 @@
   void  checkCollisionRayN(BspTreeNode * node,float startFraction, float endFraction, Vector* start, Vector* end);
 
-  void checkCollisionX(WorldEntity* entity);
-  void checkCollisionY(WorldEntity* entity);
-  void checkCollisionZ(WorldEntity* entity);
+  bool checkCollisionX(WorldEntity* entity);
+  bool checkCollisionY(WorldEntity* entity);
+  bool checkCollisionZ(WorldEntity* entity);
+  bool checkCollisionWay(WorldEntity* entity);
 
   void  checkCollisionBox(void);

branches/cleanup/src/world_entities/creatures/fps_player.cc

@@ -381 +381 @@
   if( !this->isOnGround())
   {
-    this->fallVelocity += 300.0f * time;
+    if(this->fallVelocity + 300.0F*time < 10000.0f)this->fallVelocity += 300.0f * time;
     velocity -= Vector(0.0, 1.0, 0.0) * this->fallVelocity;
 
@@ -390 +390 @@
     this->fallVelocity = 0.0f;
   }
-
-  this->shiftCoor( velocity*time );
-
-
+  if((velocity *time).len() < 10.0f) this->shiftCoor( velocity*time );
+  else{  
+         velocity.normalize();
+         velocity *= 10.0f;
+         this->shiftCoor( velocity );
+       }