Changeset 8190 in orxonox.OLD for trunk/src/world_entities

Timestamp:

Jun 7, 2006, 3:00:01 PM (19 years ago)

Author:

patrick

Message:

trunk: merged the cr branche to trunk

Location:

trunk/src/world_entities

Files:

• projectiles/projectile.cc (modified) (1 diff)
• world_entity.cc (modified) (8 diffs)
• world_entity.h (modified) (7 diffs)

trunk/src/world_entities/projectiles/projectile.cc

@@ -38 +38 @@
   this->target = NULL;
   this->removeNode();
+
+  /* character attributes */
+  this->setHealth(1.0f);
+  this->setDamage(100.0f); // default damage of a projectile set to 100.0 damage points
 
   this->explosionBuffer = NULL;

trunk/src/world_entities/world_entity.cc

@@ -32 +32 @@
 #include "camera.h"
 
-#include "cr_engine.h"
 #include "collision_handle.h"
+#include "collision_event.h"
+
+#include <stdarg.h>
 
 
@@ -59 +61 @@
   this->healthMax = 1.0f;
   this->health = 1.0f;
+  this->damage = 0.0f; // no damage dealt by a default entity
   this->scaling = 1.0f;
 
@@ -68 +71 @@
   this->objectListIterator = NULL;
 
+  // reset all collision handles to NULL == unsubscribed state
+  for(int i = 0; i < CREngine::CR_NUMBER; ++i)
+    this->collisionHandles[i] = NULL;
+  this->bReactive = false;
+
+  // registering default reactions:
+  this->subscribeReaction(CREngine::CR_OBJECT_DAMAGE, CL_WORLD_ENTITY);
+  this->subscribeReaction(CREngine::CR_PHYSICS_GROUND, CL_TERRAIN);
+
   this->toList(OM_NULL);
 
@@ -91 +103 @@
   if (this->healthWidget != NULL)
     delete this->healthWidget;
+
+  this->unsubscribeReaction();
 }
 
@@ -249 +263 @@
  * subscribes this world entity to a collision reaction
  *  @param type the type of reaction to subscribe to
+ *  @param target1 a filter target (classID)
+ */
+void WorldEntity::subscribeReaction(CREngine::CRType type, long target1)
+{
+  this->subscribeReaction(type);
+
+  // add the target filter
+  this->collisionHandles[type]->addTarget(target1);
+}
+
+
+/**
+ * subscribes this world entity to a collision reaction
+ *  @param type the type of reaction to subscribe to
+ *  @param target1 a filter target (classID)
+ */
+void WorldEntity::subscribeReaction(CREngine::CRType type, long target1, long target2)
+{
+  this->subscribeReaction(type);
+
+  // add the target filter
+  this->collisionHandles[type]->addTarget(target1);
+  this->collisionHandles[type]->addTarget(target2);
+}
+
+
+/**
+ * subscribes this world entity to a collision reaction
+ *  @param type the type of reaction to subscribe to
+ *  @param target1 a filter target (classID)
+ */
+void WorldEntity::subscribeReaction(CREngine::CRType type, long target1, long target2, long target3)
+{
+  this->subscribeReaction(type);
+
+  // add the target filter
+  this->collisionHandles[type]->addTarget(target1);
+  this->collisionHandles[type]->addTarget(target2);
+  this->collisionHandles[type]->addTarget(target3);
+}
+
+
+/**
+ * subscribes this world entity to a collision reaction
+ *  @param type the type of reaction to subscribe to
+ *  @param target1 a filter target (classID)
+ */
+void WorldEntity::subscribeReaction(CREngine::CRType type, long target1, long target2, long target3, long target4)
+{
+  this->subscribeReaction(type);
+
+  // add the target filter
+  this->collisionHandles[type]->addTarget(target1);
+  this->collisionHandles[type]->addTarget(target2);
+  this->collisionHandles[type]->addTarget(target3);
+  this->collisionHandles[type]->addTarget(target4);
+}
+
+
+/**
+ * subscribes this world entity to a collision reaction
+ *  @param type the type of reaction to subscribe to
  *  @param nrOfTargets number of target filters
  *  @param ... the targets as classIDs
  */
-void WorldEntity::subscribeReaction(CREngine::CRType type, int nrOfTargets, ...)
-{}
+void WorldEntity::subscribeReaction(CREngine::CRType type)
+{
+  if( this->collisionHandles[type] != NULL)  {
+    PRINTF(2)("Registering for a CollisionReaction already subscribed to! Skipping\n");
+    return;
+  }
+
+  this->collisionHandles[type] = CREngine::getInstance()->subscribeReaction(this, type);
+
+  // now there is at least one collision reaction subscribed
+  this->bReactive = true;
+}
+
+
+/**
+ * unsubscribes a specific reaction from the worldentity
+ *  @param type the reaction to unsubscribe
+ */
+void WorldEntity::unsubscribeReaction(CREngine::CRType type)
+{
+  if( this->collisionHandles[type] == NULL)
+    return;
+
+  CREngine::getInstance()->unsubscribeReaction(this->collisionHandles[type]);
+  this->collisionHandles[type] = NULL;
+
+  // check if there is still any handler registered
+  for(int i = 0; i < CREngine::CR_NUMBER; ++i)
+  {
+    if( this->collisionHandles[i] != NULL)
+    {
+      this->bReactive = true;
+      return;
+    }
+  }
+  this->bReactive = false;
+}
+
+
+/**
+ * unsubscribes all collision reactions
+ */
+void WorldEntity::unsubscribeReaction()
+{
+  for( int i = 0; i < CREngine::CR_NUMBER; i++)
+    this->unsubscribeReaction((CREngine::CRType)i);
+
+  // there are no reactions subscribed from now on
+  this->bReactive = false;
+}
+
+
+/**
+ * registers a new collision event to this world entity
+ *  @param entityA entity of the collision
+ *  @param entityB entity of the collision
+ *  @param bvA colliding bounding volume of entityA
+ *  @param bvB colliding bounding volume of entityA
+ */
+bool WorldEntity::registerCollision(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB)
+{
+  // is there any handler listening?
+  if( !this->bReactive)
+    return false;
+
+  // get a collision event
+  CollisionEvent* c = CREngine::getInstance()->popCollisionEventObject();
+  assert(c != NULL); // if this should fail: we got not enough precached CollisionEvents: alter value in cr_defs.h
+  c->collide(entityA, entityB, bvA, bvB);
+
+  for( int i = 0; i < CREngine::CR_NUMBER; ++i)
+    if( this->collisionHandles[i] != NULL)
+      this->collisionHandles[i]->registerCollisionEvent(c);
+}
+
+
+/**
+ * registers a new collision event to this woeld entity
+ *  @param entity the entity that collides
+ *  @param plane it stands on
+ *  @param position it collides on the plane
+ */
+bool WorldEntity::registerCollision(WorldEntity* entity, Plane* plane, Vector position)
+{
+  // is there any handler listening?
+  if( !this->bReactive)
+    return false;
+
+  // get a collision event
+  CollisionEvent* c = CREngine::getInstance()->popCollisionEventObject();
+  assert(c != NULL); // if this should fail: we got not enough precached CollisionEvents: alter value in cr_defs.h
+  c->collide(entity, plane, position);
+
+  for( int i = 0; i < CREngine::CR_NUMBER; ++i)
+    if( this->collisionHandles[i] != NULL)
+      this->collisionHandles[i]->registerCollisionEvent(c);
+}
 
 
@@ -324 +495 @@
 void WorldEntity::collidesWithGround(const Vector& feet, const Vector& ray_1, const Vector& ray_2)
 {
-  
+
   // PRINTF(0)("BSP_GROUND: Player collides \n", this->getClassName() );
-  
+
   Vector v = this->getAbsDirX();
   v.x *= 10;
@@ -332 +503 @@
   v.z *= 10;
   Vector u = this->getAbsDirY();
-  
+
   if(feet.x == (u.x+this->getAbsCoor().x) &&  feet.y == u.y +this->getAbsCoor().y && feet.z == this->getAbsCoor().z)
   {
-    
+
   this->setAbsCoor(ray_2 - v);
   }
@@ -342 +513 @@
     if(ray_1.x == this->getAbsCoor().x + v.x && ray_1.y == this->getAbsCoor().y + v.y + 0.1 && ray_1.z ==this->getAbsCoor().z + v.z)
     {
-      this->setAbsCoor(feet -u );  
-    }
-      
-    this->setAbsCoor(ray_2 - v);  
-   
+      this->setAbsCoor(feet -u );
+    }
+
+    this->setAbsCoor(ray_2 - v);
+
   }
 }

trunk/src/world_entities/world_entity.h

@@ -15 +15 @@
 #include "glincl.h"
 #include <vector>
-#include <stdarg.h>
+
+#include "physics_interface.h"
 
 
@@ -24 +25 @@
 
 class BVTree;
+class BoundingVolume;
 class Model;
 class CollisionHandle;
+class Collision;
+class Plane;
 
 
@@ -72 +76 @@
 
   /* --- Collision Reaction Block --- */
-  void subscribeReaction(CREngine::CRType type, int nrOfTargets, ...);
+  void subscribeReaction(CREngine::CRType type);
+  void subscribeReaction(CREngine::CRType type, long target1);
+  void subscribeReaction(CREngine::CRType type, long target1, long target2);
+  void subscribeReaction(CREngine::CRType type, long target1, long target2, long target3);
+  void subscribeReaction(CREngine::CRType type, long target1, long target2, long target3, long target4);
+
+  void unsubscribeReaction(CREngine::CRType type);
+  void unsubscribeReaction();
+
+  bool registerCollision(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB);
+  bool registerCollision(WorldEntity* entity, Plane* plane, Vector position);
+  /** @return true if there is at least on collision reaction subscribed */
+  inline bool isReactive() const { return this->bReactive; }
+
+  CollisionHandle* getCollisionHandle(CREngine::CRType type) const { return this->collisionHandles[type]; }
 
 
@@ -98 +116 @@
 
   /* --- Character Attribute Block --- */
+  /** @returns the damage dealt by this world entity */
+  float getDamage() const { return this->damage; }
+  /** sets the damage dealt to @param damage damage per second */
+  void setDamage(float damage) { this->damage = damage; }
   /** @returns the Energy of the entity */
   float getHealth() const { return this->health; };
@@ -107 +129 @@
   OrxGui::GLGuiWidget* getHealthWidget();
   bool hasHealthWidget() const { return this->healthWidget; };
-  
+
   virtual void varChangeHandler( std::list<int> & id );
+
+
+  //FIXME: the PhysicsInterface and the whole PEngine should probably be reviewed. Here its just used to store the vars
+  /* --- Physics Interface --- */
+  inline PhysicsInterface getPhysicsInterface() const { return this->physicsInterface; }
+  inline float getMass() const { return this->physicsInterface.getMass(); }
+  inline float getTotalMass() const { return this->physicsInterface.getTotalMass(); }
+
 
   /* --- Misc Stuff Block --- */
@@ -128 +158 @@
 private:
   /// TODO maybe we will move the following three entries and the corresponding functions to Playable AND NPC
+  float                   damage;             //!< the damage dealt to other objects by colliding.
   float                   health;             //!< The Energy of this Entity, if the Entity has any energy at all.
   float                   healthMax;          //!< The Maximal energy this entity can take.
@@ -140 +171 @@
   bool                    bVisible;           //!< If it should be visible.
 
-  OM_LIST                           objectListNumber;   //!< The ObjectList from ObjectManager this Entity is in.
-  ObjectManager::EntityList::iterator objectListIterator; //!< The iterator position of this Entity in the given list of the ObjectManager.
+  OM_LIST                 objectListNumber;                //!< The ObjectList from ObjectManager this Entity is in.
+  ObjectManager::EntityList::iterator objectListIterator;  //!< The iterator position of this Entity in the given list of the ObjectManager.
 
-  
-  //network stuff
-  
-  float       scaling;                         //!< model's scaling factor
-  int         scaling_handle;                  //!< handle for syncing var
-  
-  std::string modelFileName;                  //!< model's file name
-  int         modelFileName_handle;           //!< handle for syncing var
-  CollisionHandle**       collisionHandles;
 
+
+  float                   scaling;                         //!< model's scaling factor
+  int                     scaling_handle;                  //!< handle for syncing var
+
+  std::string             modelFileName;                   //!< model's file name
+  int                     modelFileName_handle;            //!< handle for syncing var
+
+  CollisionHandle*        collisionHandles[CREngine::CR_NUMBER];  //!< the list of the collision reactions
+  bool                    bReactive;                              //!< true if there is at least one collision reaction subscibed
+
+  PhysicsInterface        physicsInterface;                //!< the physics object of the WorldEntity
 
 };