Changeset 8490 in orxonox.OLD for trunk/src/lib/collision_reaction

Timestamp:

Jun 15, 2006, 9:34:48 PM (19 years ago)

Author:

patrick

Message:

merged the bsp branche back to trunk

Location:

trunk/src/lib/collision_reaction

Files:

• Makefile.am (modified) (2 diffs)
• collision.h (modified) (2 diffs)
• collision_event.h (modified) (3 diffs)
• collision_handle.cc (modified) (6 diffs)
• collision_handle.h (modified) (1 diff)
• collision_reaction.h (modified) (2 diffs)
• cr_engine.cc (modified) (2 diffs)
• cr_object_damage.cc (modified) (3 diffs)
• cr_physics_ground_walk.cc (copied) (copied from branches/bsp_model/src/lib/collision_reaction/cr_physics_ground_walk.cc) (1 diff)
• cr_physics_ground_walk.h (copied) (copied from branches/bsp_model/src/lib/collision_reaction/cr_physics_ground_walk.h)

trunk/src/lib/collision_reaction/Makefile.am

@@ -9 +9 @@
                      collision_handle.cc \
                      collision_reaction.cc \
-                     cr_object_damage.cc
+                     cr_object_damage.cc \
+                     cr_physics_ground_walk.cc
 
 
@@ -19 +20 @@
                      cr_defs.h \
                      collision_reaction.h \
-                     cr_object_damage.h
+                     cr_object_damage.h \
+                     cr_physics_ground_walk.h
 

trunk/src/lib/collision_reaction/collision.h

@@ -27 +27 @@
 
     /** collides two WorldEntities @param entityA world entity A, @param entityB world entity B, @param bvA volume A @param bvB volumeB */
-    inline void collide(WorldEntity* entityA, WorldEntity* entityB) { this->entityA = entityA; this->entityB = entityB; }
+    inline void collide(WorldEntity* entityA, WorldEntity* entityB) { this->entityA = entityA; this->entityB = entityB; this->bDispatched = false; }
 
 
@@ -42 +42 @@
     /** sets the flag if it reacts @param flag true if it should react on entityB*/
     inline void setEntityBCollide(bool flag) { this->entityACollide = flag; }
+
 
     /** @returns true if this Collision has already been dispatched */

trunk/src/lib/collision_reaction/collision_event.h

@@ -25 +25 @@
   { this->entityA = entityA; this->entityB = entityB; this->bvA = bvA; this->bvB = bvB; }
   /** collides two WorldEntities @param entity world entity , @param ground ground plane, @param position position on the ground */
-  inline void collide(WorldEntity* entity, Plane* ground, Vector position)
-  { this->entityA = entity; this->ground = ground; this->position = position; }
+  inline void collide(WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position)
+  { this->entityA = entity; this->entityB = groundEntity, this->groundNormal = normal; this->position = position; }
 
 
@@ -38 +38 @@
   inline BoundingVolume* getBVB() const { return this->bvB; }
 
+  /** @return ground plane if collided with bsp model */
+  inline Vector getGroundNormal() { return this->groundNormal; }
 
-  inline void operator()(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB) { this->collide(entityA, entityB, bvA, bvB); }
-  inline void operator()(WorldEntity* entity, Plane* ground, Vector position) { this->collide(entity, ground, position); }
-
+  /** @return position of the position, only accurate if this is a collision with the ground!!! */
+  inline Vector getCollisionPosition() { return this->position; }
 
  private:
@@ -50 +51 @@
   BoundingVolume*   bvB;                           //!< reference to the bounding volume B
 
-  Plane*            ground;                        //!< the ground plane with which it collides (only for bsp-model collisions
+  Vector            groundNormal;                  //!< the ground plane with which it collides (only for bsp-model collisions
   Vector            position;                      //!< position of the collision on the ground plane
 };

trunk/src/lib/collision_reaction/collision_handle.cc

@@ -24 +24 @@
 
 #include "cr_object_damage.h"
+#include "cr_physics_ground_walk.h"
 
 #include "debug.h"
@@ -42 +43 @@
 
   this->bCollided = false;
-  this->bDispatched = false;
-
-  if( this->type == CREngine::CR_PHYSICS_STEP_BACK)
-    this->bContinuousPoll = false;
-  else
-    this->bContinuousPoll = true;
-
-  if( this->type == CREngine::CR_OBJECT_DAMAGE)
-    this->bStopOnFirstCollision = true;
-  else
-   this->bStopOnFirstCollision = false;
+  this->bDispatched = true;
+
+  this->collisionReaction = NULL;
+  this->bContinuousPoll = false;
+  this->bStopOnFirstCollision = false;
+
 
   switch( type)
   {
+    case CREngine::CR_PHYSICS_STEP_BACK:
+//       this->collisionReaction = new CRPhysicsGroundWalk();
+      this->bContinuousPoll = true;
+      break;
+    case CREngine::CR_PHYSICS_GROUND_WALK:
+      this->collisionReaction = new CRPhysicsGroundWalk();
+      this->bContinuousPoll = true;
+      break;
     case CREngine::CR_OBJECT_DAMAGE:
       this->collisionReaction = new CRObjectDamage();
+      this->bStopOnFirstCollision = true;
       break;
     default:
@@ -71 +76 @@
 {
   // delete what has to be deleted here
+  if( this->collisionReaction != NULL)
+    delete this->collisionReaction;
 }
 
@@ -169 +176 @@
 
  c->registerCollisionEvent(collisionEvent);
+ PRINTF(0)("Registering Collision Event: %s, %s\n", collisionEvent->getEntityA()->getClassName(), collisionEvent->getEntityB()->getClassName());
 }
 
@@ -186 +194 @@
 void CollisionHandle::handleCollisions()
 {
+  // if continuous poll poll the reaction
+  if( this->bContinuousPoll && !this->bCollided)
+  {
+    this->collisionReaction->update(this->owner);
+    return;
+  }
+
   // collision reaction calculations (for every collision there will be a reaction)
   vector<Collision*>::iterator it = this->collisionList.begin();
@@ -214 +229 @@
   {
     if( collisionEvent->getEntityA() == this->owner) {
-      if( collisionEvent->getEntityA()->isA((ClassID)(*it)))
+      if( collisionEvent->getEntityB()->isA((ClassID)(*it))) {
+        PRINTF(0)("I am: %s colliding with: %s is a %i filter ok\n", owner->getClassName(),
+                  collisionEvent->getEntityB()->getClassName(), *it);
         return true; }
+    }
     else {
-      if( collisionEvent->getEntityB()->isA((ClassID)(*it)))
-        return true; }
+      if( collisionEvent->getEntityA()->isA((ClassID)(*it))) {
+        PRINTF(0)("I am: %s colliding with: %s is a %i filter ok\n", owner->getClassName(),
+                  collisionEvent->getEntityA()->getClassName(), *it);
+      return true; }
+    }
   }
 

trunk/src/lib/collision_reaction/collision_handle.h

@@ -41 +41 @@
     /** @returns true if this handle should be pulled also if there are no collisions */
     inline bool isContinuousPoll() const { return this->bContinuousPoll; }
+    /** @returns the type */
+    inline CREngine::CRType getType() const { return this->type; }
 
     void handleCollisions();

trunk/src/lib/collision_reaction/collision_reaction.h

@@ -12 +12 @@
 
 class Collision;
+class WorldEntity;
+
 
 //! A class representing a simple collision
@@ -23 +25 @@
     virtual void reactToCollision(Collision* collision) = 0;
 
+    virtual void update(WorldEntity* owner) {}
+
+    /** use this to do some collision offline calculations, only called for bContinuousPoll == true */
     inline bool isContinuousPoll() const { return this->bContinuousPoll; }
 

trunk/src/lib/collision_reaction/cr_engine.cc

@@ -126 +126 @@
 {
   std::vector<CollisionHandle*>::iterator it;
-  for( it = this->collisionHandles.begin(); it != this->collisionHandles.end(); it++)
-  {
-    if( *it == collisionHandle)
-    {
+  for( it = this->collisionHandles.begin(); it != this->collisionHandles.end(); it++)  {
+    if( *it == collisionHandle) {
       this->collisionHandles.erase(it);
       delete collisionHandle;
@@ -147 +145 @@
   for( it = this->collisionHandles.begin(); it != this->collisionHandles.end(); it++)
   {
-    if( (*it)->isCollided() || (*it)->isContinuousPoll())  //does it have any collisions to report at all
+    if( !(*it)->isDispatched() || (*it)->isContinuousPoll())  //does it have any collisions to report at all
     {
       (*it)->handleCollisions();

trunk/src/lib/collision_reaction/cr_object_damage.cc

@@ -54 +54 @@
 void CRObjectDamage::reactToCollision(Collision* collision)
 {
-  float damage;
+  float damage = 0.0f;
 
-  PRINTF(0)("Dealing damage - Handling collision: %s vs %s\n",
+  PRINTF(4)("Dealing damage - Handling collision: %s vs %s\n",
             collision->getEntityA()->getClassName(),
             collision->getEntityB()->getClassName());
@@ -65 +65 @@
     collision->getEntityA()->decreaseHealth(damage);
   }
-  PRINTF(0)("Dealing damage - %f damage to %s \n", damage, collision->getEntityA()->getClassName());
+  PRINTF(4)("Dealing damage - %f damage to %s \n", damage, collision->getEntityA()->getClassName());
 
   if( collision->isEntityBCollide()) {
@@ -71 +71 @@
     collision->getEntityB()->decreaseHealth(damage);
   }
-  PRINTF(0)("Dealing damage - %f damage to %s \n", damage, collision->getEntityB()->getClassName());
+  PRINTF(4)("Dealing damage - %f damage to %s \n", damage, collision->getEntityB()->getClassName());
 
   collision->flushCollisionEvents();

trunk/src/lib/collision_reaction/cr_physics_ground_walk.cc

@@ -23 +23 @@
 #include "world_entity.h"
 #include "cr_physics_ground_walk.h"
+
+#include "debug.h"
 
 #include <vector>