Changeset 9995

Timestamp:

Mar 9, 2014, 9:01:44 PM (11 years ago)

Author:

noep

Message:

Modified collision-detecting-process, such that collisions can be traced back to single child-CollisionShapes of Compound-CollisionShapes

Location:

code/branches/modularships

Files:

• data/levels/emptyLevel.oxw (modified) (1 diff)
• src/modules/weapons/projectiles/BasicProjectile.cc (modified) (1 diff)
• src/modules/weapons/projectiles/BasicProjectile.h (modified) (1 diff)
• src/modules/weapons/projectiles/Projectile.cc (modified) (1 diff)
• src/modules/weapons/projectiles/Projectile.h (modified) (1 diff)
• src/modules/weapons/projectiles/Rocket.cc (modified) (1 diff)
• src/modules/weapons/projectiles/Rocket.h (modified) (1 diff)
• src/modules/weapons/projectiles/SimpleRocket.cc (modified) (1 diff)
• src/modules/weapons/projectiles/SimpleRocket.h (modified) (1 diff)
• src/orxonox/Scene.cc (modified) (2 diffs)
• src/orxonox/Scene.h (modified) (1 diff)
• src/orxonox/worldentities/MovableEntity.cc (modified) (1 diff)
• src/orxonox/worldentities/MovableEntity.h (modified) (1 diff)
• src/orxonox/worldentities/WorldEntity.h (modified) (1 diff)
• src/orxonox/worldentities/pawns/Pawn.cc (modified) (3 diffs)
• src/orxonox/worldentities/pawns/Pawn.h (modified) (2 diffs)

code/branches/modularships/data/levels/emptyLevel.oxw

@@ -32 +32 @@
     <SpawnPoint team=0 position="-200,0,0" lookat="0,0,0" spawnclass=SpaceShip pawndesign=spaceshipescort />
     
+    <MovableEntity position="0,0,0" collisionType=dynamic scale=1 linearDamping=0.8 angularDamping=0  collisiondamage=0.005 enablecollisiondamage=true>
+    <attached> 
+        <Model position="0,0,0" mesh="cube.mesh" scale3D="40,40,40" /> 
+        <StaticEntity position="0,90,0" direction="0,0,0" collisionType=static mass=100 friction=0.01 >
+            <attached> 
+                <Model position="0,0,0" mesh="cube.mesh" scale3D="30,30,30" /> 
+            </attached> 
+            <collisionShapes> 
+                <BoxCollisionShape position="0,0,0" halfExtents="30,30,30" /> 
+            </collisionShapes> 
+        </StaticEntity>
+    </attached> 
+    <collisionShapes> 
+        <BoxCollisionShape position="0,0,0" halfExtents="40,40,40" /> 
+    </collisionShapes> 
+    </MovableEntity>
+    
+    <Pawn health=30 position="0,-50,0" direction="0,-1,0" collisionType=dynamic mass=1000 name=box radarname = "Box 4" >
+        <attached>
+            <Model position="0,0,0" mesh="crate.mesh" scale3D="3,3,3" />
+        </attached>
+        <collisionShapes>
+            <BoxCollisionShape position="0,0,0" halfExtents="15,15,15" />
+        </collisionShapes>
+    </Pawn>
+    
   </Scene>
 </Level>

code/branches/modularships/src/modules/weapons/projectiles/BasicProjectile.cc

@@ -141 +141 @@
     }
 
+    bool BasicProjectile::customProcessCollision(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape* cs)
+        {
+            if (!this->bDestroy_ && GameMode::isMaster())
+            {
+                if (otherObject == this->getShooter()) // Prevents you from shooting yourself
+                    return false;
+
+                this->bDestroy_ = true; // If something is hit, the object is destroyed and can't hit something else.
+                                        // The projectile is destroyed by its tick()-function (in the following tick).
+
+                Pawn* victim = orxonox_cast<Pawn*>(otherObject); // If otherObject isn't a Pawn, then victim is NULL
+
+                WorldEntity* entity = orxonox_cast<WorldEntity*>(this);
+                assert(entity); // The projectile must not be a WorldEntity.
+
+                // If visual effects after destruction cause problems, put this block below the effects code block
+                if (victim)
+                {
+                    victim->customHit(this->getShooter(), contactPoint, cs, this->getDamage(), this->getHealthDamage(), this->getShieldDamage());
+                    victim->startReloadCountdown();
+                }
+
+                // Visual effects for being hit, depending on whether the shield is hit or not
+                if (this->getShooter()) // If the owner does not exist (anymore?), no effects are displayed.
+                {
+                    // Damping and explosion effect is only played if the victim is no Pawn (see cast above)
+                    // or if the victim is a Pawn, has no shield left, is still alive and any damage goes to the health
+                    if (!victim || (victim && !victim->hasShield() && victim->getHealth() > 0.0f && (this->getDamage() > 0.0f || this->getHealthDamage() > 0.0f)))
+                    {
+                        {
+                            ParticleSpawner* effect = new ParticleSpawner(this->getShooter()->getContext());
+                            effect->setPosition(entity->getPosition());
+                            effect->setOrientation(entity->getOrientation());
+                            effect->setDestroyAfterLife(true);
+                            effect->setSource("Orxonox/explosion3");
+                            effect->setLifetime(2.0f);
+                        }
+                        // Second effect with same condition
+                        {
+                            ParticleSpawner* effect = new ParticleSpawner(this->getShooter()->getContext());
+                            effect->setPosition(entity->getPosition());
+                            effect->setOrientation(entity->getOrientation());
+                            effect->setDestroyAfterLife(true);
+                            effect->setSource("Orxonox/smoke4");
+                            effect->setLifetime(3.0f);
+                        }
+                    }
+
+                    // victim->isAlive() is not false until the next tick, so getHealth() > 0 is used instead
+                    if (victim && victim->hasShield() && (this->getDamage() > 0.0f || this->getShieldDamage() > 0.0f) && victim->getHealth() > 0.0f)
+                    {
+                        ParticleSpawner* effect = new ParticleSpawner(this->getShooter()->getContext());
+                        effect->setDestroyAfterLife(true);
+                        effect->setSource("Orxonox/Shield");
+                        effect->setLifetime(0.5f);
+                        victim->attach(effect);
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+
     /**
     @brief

code/branches/modularships/src/modules/weapons/projectiles/BasicProjectile.h

@@ -120 +120 @@
         protected:
             bool processCollision(WorldEntity* otherObject, btManifoldPoint& contactPoint);
+            bool customProcessCollision(WorldEntity* otherObject, btManifoldPoint& contactPoint, const btCollisionShape* cs);
             void destroyCheck(void);
 

code/branches/modularships/src/modules/weapons/projectiles/Projectile.cc

@@ -93 +93 @@
     }
 
+    bool Projectile::customCollidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint)
+    {
+        return this->customProcessCollision(otherObject, contactPoint, cs);
+    }
+
 }

code/branches/modularships/src/modules/weapons/projectiles/Projectile.h

@@ -65 +65 @@
             virtual void tick(float dt);
             virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
+            virtual bool customCollidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
 
         private:

code/branches/modularships/src/modules/weapons/projectiles/Rocket.cc

@@ -196 +196 @@
     }
 
+    bool Rocket::customCollidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint)
+    {
+        return this->customProcessCollision(otherObject, contactPoint, cs);
+    }
+
     /**
     @brief

code/branches/modularships/src/modules/weapons/projectiles/Rocket.h

@@ -65 +65 @@
 
             virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
+            virtual bool customCollidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
             virtual void destroyObject(void);
             void destructionEffect();

code/branches/modularships/src/modules/weapons/projectiles/SimpleRocket.cc

@@ -177 +177 @@
     }
 
+    bool SimpleRocket::customCollidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint)
+    {
+        return this->customProcessCollision(otherObject, contactPoint, cs);
+    }
+
     /**
     @brief

code/branches/modularships/src/modules/weapons/projectiles/SimpleRocket.h

@@ -65 +65 @@
 
             virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
+            virtual bool customCollidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
 
             void disableFire(); //!< Method to disable the fire and stop all acceleration

code/branches/modularships/src/orxonox/Scene.cc

@@ -201 +201 @@
             // Note: This is a global variable which we assign a static function.
             // TODO: Check whether this (or anything about Bullet) works with multiple physics engine instances.
-            gContactAddedCallback = &Scene::collisionCallback;
+            gContactAddedCallback = &Scene::customCollisionCallback;
         }
         else if (!wantPhysics && hasPhysics())
@@ -358 +358 @@
         return modified;
     }
+
+    /* ADDED static*/ bool Scene::customCollisionCallback(btManifoldPoint& cp, const btCollisionObject* colObj0, int partId0,
+                                             int index0, const btCollisionObject* colObj1, int partId1, int index1)
+    {
+        // get the WorldEntity pointers
+        SmartPtr<WorldEntity> object0 = static_cast<WorldEntity*>(colObj0->getUserPointer());
+        SmartPtr<WorldEntity> object1 = static_cast<WorldEntity*>(colObj1->getUserPointer());
+
+        // get the CollisionShape pointers
+        const btCollisionShape* cs0 = colObj0->getCollisionShape();
+        const btCollisionShape* cs1 = colObj1->getCollisionShape();
+
+        // false means that bullet will assume we didn't modify the contact
+        bool modified = false;
+        if (object0->isCollisionCallbackActive())
+            modified |= object0->customCollidesAgainst(object1, cs0, cp);
+        if (object1->isCollisionCallbackActive())
+            modified |= object1->customCollidesAgainst(object0, cs1, cp);
+
+        return modified;
+    }
 }

code/branches/modularships/src/orxonox/Scene.h

@@ -143 +143 @@
                                           int index0, const btCollisionObject* colObj1, int partId1, int index1);
 
+            static bool customCollisionCallback(btManifoldPoint& cp, const btCollisionObject* colObj0, int partId0,
+                                                      int index0, const btCollisionObject* colObj1, int partId1, int index1);
+
             // Bullet objects
             btDiscreteDynamicsWorld*             physicalWorld_;

code/branches/modularships/src/orxonox/worldentities/MovableEntity.cc

@@ -87 +87 @@
     }
 
+    bool MovableEntity::customCollidesAgainst(WorldEntity* otherObject, const btCollisionShape* ownCollisionShape, btManifoldPoint& contactPoint)
+    {
+        if (GameMode::isMaster() && enableCollisionDamage_)
+        {
+            Pawn* victim = orxonox_cast<Pawn*>(otherObject);
+            if (victim)
+            {
+                float damage = this->collisionDamage_ * (victim->getVelocity() - this->getVelocity()).length();
+                victim->customHit(0, contactPoint, ownCollisionShape, damage);
+            }
+        }
+
+        return false;
+    }
+
 
     void MovableEntity::registerVariables()

code/branches/modularships/src/orxonox/worldentities/MovableEntity.h

@@ -48 +48 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
+            virtual bool customCollidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
 
             using WorldEntity::setPosition;

code/branches/modularships/src/orxonox/worldentities/WorldEntity.h

@@ -375 +375 @@
             */
             virtual inline bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
+                { return false; } /* With false, Bullet assumes no modification to the collision objects. */
+
+            virtual inline bool customCollidesAgainst(WorldEntity* otherObject, const btCollisionShape* ownCollisionShape, btManifoldPoint& contactPoint)
                 { return false; } /* With false, Bullet assumes no modification to the collision objects. */
 

code/branches/modularships/src/orxonox/worldentities/pawns/Pawn.cc

@@ -274 +274 @@
     }
 
+    void Pawn::customDamage(float damage, float healthdamage, float shielddamage, Pawn* originator, const btCollisionShape* cs)
+    {
+        // Applies multiplier given by the DamageBoost Pickup.
+        if (originator)
+            damage *= originator->getDamageMultiplier();
+
+        orxout() << "damage(): Custom collision detected on CS: " << cs << endl;
+
+        if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
+        {
+            if (shielddamage >= this->getShieldHealth())
+            {
+                this->setShieldHealth(0);
+                this->setHealth(this->health_ - (healthdamage + damage));
+            }
+            else
+            {
+                this->setShieldHealth(this->shieldHealth_ - shielddamage);
+
+                // remove remaining shieldAbsorpton-Part of damage from shield
+                shielddamage = damage * this->shieldAbsorption_;
+                shielddamage = std::min(this->getShieldHealth(),shielddamage);
+                this->setShieldHealth(this->shieldHealth_ - shielddamage);
+
+                // set remaining damage to health
+                this->setHealth(this->health_ - (damage - shielddamage) - healthdamage);
+            }
+
+            this->lastHitOriginator_ = originator;
+        }
+    }
+
 // TODO: Still valid?
 /* HIT-Funktionen
@@ -288 +320 @@
     }
 
+    void Pawn::customHit(Pawn* originator, const Vector3& force, const btCollisionShape* cs, float damage, float healthdamage, float shielddamage)
+    {
+        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
+        {
+            this->customDamage(damage, healthdamage, shielddamage, originator, cs);
+            this->setVelocity(this->getVelocity() + force);
+        }
+    }
 
     void Pawn::hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage, float shielddamage)
@@ -294 +334 @@
         {
             this->damage(damage, healthdamage, shielddamage, originator);
+
+            if ( this->getController() )
+                this->getController()->hit(originator, contactpoint, damage); // changed to damage, why shielddamage?
+        }
+    }
+
+    void Pawn::customHit(Pawn* originator, btManifoldPoint& contactpoint, const btCollisionShape* cs, float damage, float healthdamage, float shielddamage)
+    {
+        if (this->getGametype() && this->getGametype()->allowPawnHit(this, originator) && (!this->getController() || !this->getController()->getGodMode()) )
+        {
+            this->customDamage(damage, healthdamage, shielddamage, originator, cs);
 
             if ( this->getController() )

code/branches/modularships/src/orxonox/worldentities/pawns/Pawn.h

@@ -127 +127 @@
             //virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage);
             virtual void hit(Pawn* originator, const Vector3& force, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
+            virtual void customHit(Pawn* originator, const Vector3& force, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
             virtual void hit(Pawn* originator, btManifoldPoint& contactpoint, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
+            virtual void customHit(Pawn* originator, btManifoldPoint& contactpoint, const btCollisionShape* cs, float damage, float healthdamage = 0.0f, float shielddamage = 0.0f);
 
             virtual void kill();
@@ -197 +199 @@
             //virtual void damage(float damage, Pawn* originator = 0);
             virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL);
+            virtual void customDamage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL, const btCollisionShape* cs = NULL);
 
             bool bAlive_;