Changeset 1552 for code/trunk/src/orxonox/objects

Timestamp:

Jun 6, 2008, 5:31:58 PM (16 years ago)

Author:

landauf

Message:

several improvements:

• AI works properly now - add enemies with 'createEnemy x' where x is the number of enemies to add, default is 1. You can remove AI ships with 'killEnemies'.
• Added new explosion (with smoke)
• Added new projectile (with trail)
• Added new thruster emitter
• AI ships are destroyable - they start with 100 hp, each hit makes 15 hp damage, this value is configurable in the config-file: [Projectile] damage_
• Added AI ship spawn and explosion effects

Location:

code/trunk/src/orxonox/objects

Files:

• BillboardProjectile.cc (added)
• BillboardProjectile.h (added)
• Explosion.cc (deleted)
• Explosion.h (deleted)
• Model.cc (modified) (2 diffs)
• ParticleProjectile.cc (added)
• ParticleProjectile.h (added)
• ParticleSpawner.cc (added)
• ParticleSpawner.h (added)
• Projectile.cc (modified) (5 diffs)
• Projectile.h (modified) (3 diffs)
• RotatingProjectile.cc (modified) (1 diff)
• RotatingProjectile.h (modified) (2 diffs)
• SpaceShip.cc (modified) (10 diffs)
• SpaceShip.h (modified) (5 diffs)
• SpaceShipAI.cc (modified) (15 diffs)
• SpaceShipAI.h (modified) (2 diffs)
• WorldEntity.cc (modified) (3 diffs)

code/trunk/src/orxonox/objects/Model.cc

@@ -45 +45 @@
     CreateFactory(Model);
 
-    Model::Model()
+    Model::Model() : meshSrc_("")
     {
         RegisterObject(Model);
@@ -53 +53 @@
     Model::~Model()
     {
+        if ((this->meshSrc_ != "") && (this->meshSrc_.size() > 0))
+            this->detachObject(this->mesh_.getEntity());
     }
 

code/trunk/src/orxonox/objects/Projectile.cc

@@ -35 +35 @@
 #include "core/Executor.h"
 #include "core/ConfigValueIncludes.h"
+#include "particle/ParticleInterface.h"
 
-#include "SpaceShip.h"
-#include "Explosion.h"
+#include "SpaceShipAI.h"
+#include "ParticleSpawner.h"
 #include "Model.h"
 
 namespace orxonox
 {
-    CreateFactory(Projectile);
+    float Projectile::speed_ = 2000;
 
-    float Projectile::speed_ = 0;
-
-    Projectile::Projectile(SpaceShip* owner) :
-      owner_(owner)
+    Projectile::Projectile(SpaceShip* owner) : owner_(owner)
     {
         RegisterObject(Projectile);
 
         this->setConfigValues();
-
-        this->billboard_.setBillboardSet("Examples/Flare", ColourValue(1.0, 1.0, 0.5), 1);
-        this->attachObject(this->billboard_.getBillboardSet());
-        this->scale(0.5);
+        this->explosionTemplateName_ = "Orxonox/explosion1";
+        this->smokeTemplateName_ = "Orxonox/smoke3";
 
         if (this->owner_)
@@ -63 +59 @@
             this->setPosition(this->owner_->getPosition());
             this->translate(Vector3(55, 0, 0), Ogre::Node::TS_LOCAL);
-            this->setVelocity(Vector3(1, 0, 0) * this->speed_);
+            this->setVelocity(this->owner_->getInitialDir() * this->speed_);
         }
 
         this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Projectile::destroyObject)));
-//        COUT(3) << this->classID << std::endl;
     }
 
@@ -76 +71 @@
     void Projectile::setConfigValues()
     {
-        SetConfigValue(lifetime_, 10.0).description("The time in seconds a projectile stays alive");
+        SetConfigValue(damage_, 15.0).description("The damage caused by the projectile");
+        SetConfigValue(lifetime_, 5.0).description("The time in seconds a projectile stays alive");
         SetConfigValue(speed_, 2000.0).description("The speed of a projectile in units per second");
 
-        this->setVelocity(Vector3(1, 0, 0) * this->speed_);
+        this->setVelocity(this->owner_->getInitialDir() * this->speed_);
     }
 
@@ -95 +91 @@
                 if (this->getPosition().squaredDistance(it->getPosition()) <= (radius*radius))
                 {
-                    Explosion *exp = new Explosion(this);
-                    exp->create();
+                    // hit
+                    if (it->isA(Class(SpaceShipAI)))
+                        ((SpaceShipAI*)(*it))->damage(this->damage_);
+                    ParticleSpawner* explosion = new ParticleSpawner(this->explosionTemplateName_, 2.0);
+                    explosion->setPosition(this->getPosition());
+                    explosion->create();
+                    ParticleSpawner* smoke = new ParticleSpawner(this->smokeTemplateName_, 6.0, 0.0);
+                    smoke->setPosition(this->getPosition());
+                    smoke->getParticleInterface()->setSpeedFactor(3.0);
+                    smoke->create();
                     delete this;
                     return;
@@ -108 +112 @@
         delete this;
     }
-
-    void Projectile::setColour(const ColourValue& colour)
-    {
-        this->billboard_.getBillboardSet()->getBillboard(0)->setColour(colour);
-    }
 }

code/trunk/src/orxonox/objects/Projectile.h

@@ -33 +33 @@
 
 #include "WorldEntity.h"
-#include "../tools/BillboardSet.h"
-#include "../tools/Timer.h"
-#include "util/Math.h"
+#include "tools/Timer.h"
 
 namespace orxonox
@@ -42 +40 @@
     {
         public:
-            Projectile(SpaceShip* owner = 0);
             virtual ~Projectile();
             void setConfigValues();
             void destroyObject();
             virtual void tick(float dt);
-            virtual bool create(){return WorldEntity::create();}
-            void setColour(const ColourValue& colour);
 
             static float getSpeed()
@@ -54 +49 @@
 
         protected:
+            Projectile(SpaceShip* owner = 0);
             SpaceShip* owner_;
 
         private:
-            BillboardSet billboard_;
+            std::string explosionTemplateName_;
+            std::string smokeTemplateName_;
             static float speed_;
             float lifetime_;
+            float damage_;
             Timer<Projectile> destroyTimer_;
     };

code/trunk/src/orxonox/objects/RotatingProjectile.cc

@@ -37 +37 @@
     CreateFactory(RotatingProjectile);
 
-    RotatingProjectile::RotatingProjectile(SpaceShip* owner) : Projectile(owner)
+    RotatingProjectile::RotatingProjectile(SpaceShip* owner) : BillboardProjectile(owner)
     {
         RegisterObject(RotatingProjectile);

code/trunk/src/orxonox/objects/RotatingProjectile.h

@@ -2 +2 @@
 #define _RotatingProjectile_H__
 
-#include "../OrxonoxPrereqs.h"
+#include "OrxonoxPrereqs.h"
 #include "util/Math.h"
-#include "Projectile.h"
+#include "BillboardProjectile.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport RotatingProjectile : public Projectile/*, public network::Synchronisable*/
+    class _OrxonoxExport RotatingProjectile : public BillboardProjectile
     {
         public:
@@ -15 +15 @@
             void setConfigValues();
             virtual void tick(float dt);
-            virtual bool create(){return Projectile::create();}
 
         private:

code/trunk/src/orxonox/objects/SpaceShip.cc

@@ -44 +44 @@
 #include "core/input/InputManager.h"
 #include "particle/ParticleInterface.h"
-#include "Projectile.h"
 #include "RotatingProjectile.h"
+#include "ParticleProjectile.h"
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
@@ -69 +69 @@
     SpaceShip* SpaceShip::instance_s;
 
-    
+
     SpaceShip *SpaceShip::getLocalShip(){
       Iterator<SpaceShip> it;
@@ -88 +88 @@
       cam_(0),
       camName_("CamNode"),
-      tt_(0),
+      tt1_(0),
+      tt2_(0),
       redNode_(0),
       greenNode_(0),
@@ -111 +112 @@
       mouseX_(0.0f),
       mouseY_(0.0f),
-      emitterRate_(0.0f),
       myShip_(false),
       teamNr_(0),
@@ -138 +138 @@
     SpaceShip::~SpaceShip()
     {
-        if (this->tt_)
-            delete this->tt_;
+        if (this->tt1_)
+            delete this->tt1_;
+        if (this->tt2_)
+            delete this->tt2_;
         if(setMouseEventCallback_)
           InputManager::removeMouseHandler("SpaceShip");
@@ -180 +182 @@
     {
         // START CREATING THRUSTER
-        this->tt_ = new ParticleInterface(GraphicsEngine::getSingleton().getSceneManager(),"twinthruster" + this->getName(),"Orxonox/engineglow");
-        this->tt_->getParticleSystem()->setParameter("local_space","true");
-        this->tt_->newEmitter();
-/*
-        this->tt_->setDirection(Vector3(0,0,1));
-        this->tt_->setPositionOfEmitter(0, Vector3(20,-1,-15));
-        this->tt_->setPositionOfEmitter(1, Vector3(-20,-1,-15));
-*/
-        this->tt_->setDirection(Vector3(-1,0,0));
-        this->tt_->setPositionOfEmitter(0, Vector3(-15,20,-1));
-        this->tt_->setPositionOfEmitter(1, Vector3(-15,-20,-1));
-        this->tt_->setVelocity(50);
-
-        emitterRate_ = tt_->getRate();
-
-        Ogre::SceneNode* node2 = this->getNode()->createChildSceneNode(this->getName() + "particle2");
-        node2->setInheritScale(false);
-        tt_->addToSceneNode(node2);
+        this->tt1_ = new ParticleInterface("Orxonox/thruster1");
+        this->tt1_->createNewEmitter();
+        this->tt1_->getAllEmitters()->setDirection(-this->getInitialDir());
+        this->tt1_->getEmitter(0)->setPosition(Vector3(-15, 20, -1));
+        this->tt1_->getEmitter(1)->setPosition(Vector3(-15, -20, -1));
+        this->tt1_->setSpeedFactor(3.0);
+
+        Ogre::SceneNode* node2a = this->getNode()->createChildSceneNode(this->getName() + "particle2a");
+        node2a->setInheritScale(false);
+        node2a->setScale(1, 1, 1);
+        tt1_->addToSceneNode(node2a);
+
+        this->tt2_ = new ParticleInterface("Orxonox/thruster2");
+        this->tt2_->createNewEmitter();
+        this->tt2_->getAllEmitters()->setDirection(Vector3(-1, 0, 0));
+        this->tt2_->getEmitter(0)->setPosition(Vector3(-30, 40, -2));
+        this->tt2_->getEmitter(1)->setPosition(Vector3(-30, -40, -2));
+
+        Ogre::SceneNode* node2b = this->getNode()->createChildSceneNode(this->getName() + "particle2b");
+        node2b->setInheritScale(false);
+        node2b->setScale(0.5, 0.5, 0.5);
+        tt2_->addToSceneNode(node2b);
         // END CREATING THRUSTER
 
@@ -266 +272 @@
       this->camNode_ = this->getNode()->createChildSceneNode(camName_);
       COUT(4) << "position: (this)" << this->getNode()->getPosition() << std::endl;
-      this->camNode_->setPosition(Vector3(-50,0,10));
+      this->camNode_->setPosition(Vector3(-25,0,5));
 //      Quaternion q1 = Quaternion(Radian(Degree(90)),Vector3(0,-1,0));
 //      Quaternion q2 = Quaternion(Radian(Degree(90)),Vector3(0,0,-1));
@@ -339 +345 @@
     }
 
-    Vector3 SpaceShip::getDir() {
-        return currentDir_;
-    }
-
-    Vector3 SpaceShip::getOrth(){
-        return currentOrth_;
-    }
-
-    float SpaceShip::getMaxSpeed() { return maxSpeed_; }
-
     void SpaceShip::tick(float dt)
     {
@@ -374 +370 @@
         {
 
-            Projectile *p;
-            if (this->isExactlyA(Class(SpaceShip)))
-                p = new RotatingProjectile(this);
-            else
-                p = new Projectile(this);
-            p->setColour(this->getProjectileColour());
-            p->create();
-            if(p->classID==0)
+            BillboardProjectile* projectile = new ParticleProjectile(this);
+            projectile->setColour(this->getProjectileColour());
+            projectile->create();
+            if (projectile->classID == 0)
+            {
               COUT(3) << "generated projectile with classid 0" <<  std::endl; // TODO: remove this output
-
-            p->setBacksync(true);
+            }
+
+            projectile->setBacksync(true);
             this->timeToReload_ = this->reloadTime_;
         }
@@ -464 +458 @@
 
         if (this->acceleration_.x > 0)
-            this->tt_->setRate(emitterRate_);
+        {
+            this->tt1_->setEnabled(true);
+            this->tt2_->setEnabled(true);
+        }
         else
-            this->tt_->setRate(0);
+        {
+            this->tt1_->setEnabled(false);
+            this->tt2_->setEnabled(false);
+        }
 
         if( myShip_ )

code/trunk/src/orxonox/objects/SpaceShip.h

@@ -43 +43 @@
     {
         public:
-          
-
             static SpaceShip *getLocalShip();
 
@@ -66 +64 @@
             void getFocus();
 
+            inline float getMaxSpeed() const
+                { return this->maxSpeed_; }
+            inline float getMaxSideAndBackSpeed() const
+                { return this->maxSideAndBackSpeed_; }
+            inline float getMaxRotation() const
+                { return this->maxRotation_; }
+            inline float getTransAcc() const
+                { return this->translationAcceleration_; }
+            inline float getRotAcc() const
+                { return this->rotationAcceleration_; }
+            inline float getTransDamp() const
+                { return this->translationDamping_; }
+            inline float getRotDamp() const
+                { return this->rotationDamping_; }
+
             static std::string whereAmI();
             static void setMaxSpeedTest(float value)
@@ -83 +96 @@
             void doFire();
 
-            float getMaxSpeed();
-            Vector3 getDir();
-            Vector3 getOrth();
+            inline const Vector3& getDir() const
+                { return this->currentDir_; }
+            inline const Vector3& getInitialDir() const
+                { return this->initialDir_; }
+            inline const Vector3& getOrth() const
+                { return this->currentOrth_; }
+            inline const Vector3& getInitialOrth() const
+                { return this->initialOrth_; }
+
             Camera* getCamera();
 
             int getTeamNr() const
                 { return this->teamNr_; }
-            int getHealth() const
+            float getHealth() const
                 { return this->health_; }
 
@@ -118 +137 @@
             std::string camName_;
 
-
-            ParticleInterface* tt_;
+            ParticleInterface* tt1_;
+            ParticleInterface* tt2_;
 
             BillboardSet redBillboard_;
@@ -153 +172 @@
             float mouseY_;
 
-            float emitterRate_;
-
         protected:
             bool myShip_;
 
             int teamNr_;
-            int health_;
+            float health_;
 
             static SpaceShip* instance_s;

code/trunk/src/orxonox/objects/SpaceShipAI.cc

@@ -32 +32 @@
 #include <OgreMath.h>
 #include "Projectile.h"
+#include "ParticleSpawner.h"
 #include "core/CoreIncludes.h"
 #include "core/Iterator.h"
@@ -37 +38 @@
 #include "core/ConsoleCommand.h"
 #include "core/XMLPort.h"
+#include "particle/ParticleInterface.h"
 
 #define ACTION_INTERVAL 1.0f
@@ -51 +53 @@
         RegisterObject(SpaceShipAI);
 
-        this->alive_ = true;
-        this->setPosition(Vector3(rnd(-1000, 1000), rnd(-1000, 1000), rnd(-1000, 0000)));
         this->target_ = 0;
         this->bShooting_ = 0;
@@ -70 +70 @@
     }
 
+    SpaceShipAI::~SpaceShipAI()
+    {
+        for (Iterator<SpaceShipAI> it = ObjectList<SpaceShipAI>::begin(); it; ++it)
+            it->shipDied(this);
+    }
+
     void SpaceShipAI::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
         SpaceShip::XMLPort(xmlelement, mode);
-        myShip_=true;
-
+
+        this->myShip_=true;
         this->actionTimer_.setTimer(ACTION_INTERVAL, true, this, createExecutor(createFunctor(&SpaceShipAI::action)));
     }
@@ -85 +91 @@
             newenemy->setMesh("assff.mesh");
 //            newenemy->setPosition(0, 0, 0);
+            newenemy->setPosition(Vector3(rnd(-3000, 3000), rnd(-3000, 3000), rnd(-3000, 3000)));
             newenemy->setScale(10);
             newenemy->setMaxSpeed(500);
@@ -95 +102 @@
             Element xmlelement;
             newenemy->XMLPort(xmlelement, XMLPort::LoadObject);
+
+            ParticleSpawner* spawneffect = new ParticleSpawner("Orxonox/fairytwirl", 2.0, 0.0, newenemy->getOrth());
+            spawneffect->setPosition(newenemy->getPosition() - newenemy->getOrth() * 50);
+            spawneffect->create();
         }
     }
@@ -103 +114 @@
         for (Iterator<SpaceShipAI> it = ObjectList<SpaceShipAI>::begin(); it; )
         {
-            delete *(it++);
-            ++i;
+            (it++)->kill();
             if (num && i >= num)
                 break;
@@ -122 +132 @@
         // search enemy
         random = rnd(maxrand);
-//std::cout << "search enemy: " << random << std::endl;
         if (random < 20 && (!this->target_))
-        {
             this->searchNewTarget();
-        }
 
         // forget enemy
         random = rnd(maxrand);
-//std::cout << "forget enemy: " << random << std::endl;
         if (random < 5 && (this->target_))
-        {
             this->forgetTarget();
-        }
 
         // next enemy
         random = rnd(maxrand);
-//std::cout << "next enemy: " << random << std::endl;
         if (random < 10 && (this->target_))
-        {
             this->searchNewTarget();
-        }
 
         // fly somewhere
         random = rnd(maxrand);
-//std::cout << "fly somewhere: " << random << std::endl;
         if (random < 40 && (!this->bHasTargetPosition_ && !this->target_))
-        {
             this->searchNewTargetPosition();
-        }
 
         // stop flying
         random = rnd(maxrand);
-//std::cout << "stop flying: " << random << std::endl;
         if (random < 10 && (this->bHasTargetPosition_ && !this->target_))
-        {
             this->bHasTargetPosition_ = false;
-        }
 
         // fly somewhere else
         random = rnd(maxrand);
-//std::cout << "fly somewhere else: " << random << std::endl;
         if (random < 30 && (this->bHasTargetPosition_ && !this->target_))
-        {
             this->searchNewTargetPosition();
-        }
 
         // shoot
         random = rnd(maxrand);
-//std::cout << "shoot: " << random << std::endl;
         if (random < 75 && (this->target_ && !this->bShooting_))
-        {
             this->bShooting_ = true;
-        }
 
         // stop shooting
         random = rnd(maxrand);
-//std::cout << "stop shooting: " << random << std::endl;
         if (random < 25 && (this->bShooting_))
-        {
             this->bShooting_ = false;
-        }
+    }
+
+    void SpaceShipAI::damage(float damage)
+    {
+        this->health_ -= damage;
+        if (this->health_ <= 0)
+        {
+            this->kill();
+            SpaceShipAI::createEnemy(1);
+        }
+    }
+
+    void SpaceShipAI::kill()
+    {
+        ParticleSpawner* explosion = new ParticleSpawner("Orxonox/BigExplosion1part1", 3.0);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part2", 3.0);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+
+        Vector3 ringdirection = Vector3(rnd(), rnd(), rnd());
+        ringdirection.normalise();
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part3", 3.0, 0.5, ringdirection);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+
+        delete this;
     }
 
@@ -193 +214 @@
             this->moveToTargetPosition(dt);
 
-        if (this->bShooting_ && this->isCloseAtTarget(2000) && this->isLookingAtTarget(Ogre::Math::PI / 10.0f))
+        if (this->bShooting_ && this->isCloseAtTarget(2500) && this->isLookingAtTarget(Ogre::Math::PI / 10))
             this->doFire();
 
@@ -201 +222 @@
     void SpaceShipAI::moveToTargetPosition(float dt)
     {
-        static Radian RadianZERO(0);
-
-//        float dotprod = (this->getOrientation() * Ogre::Vector3::UNIT_X).dotProduct(this->targetPosition_ - this->getPosition());
-        Quaternion rotation = (this->getOrientation() * Ogre::Vector3::UNIT_X).getRotationTo(this->targetPosition_ - this->getPosition());
-/*
-std::cout << "scalprod: " << dotprod << std::endl;
-std::cout << "dist: " << this->targetPosition_ - this->getPosition() << std::endl;
-std::cout << "yaw: " << rotation.getYaw().valueRadians() << std::endl;
-std::cout << "pitch: " << rotation.getPitch().valueRadians() << std::endl;
-std::cout << "roll: " << rotation.getRoll().valueRadians() << std::endl;
-*/
-        this->setMoveYaw(-rotation.getRoll().valueRadians());
-        this->setMovePitch(rotation.getYaw().valueRadians());
-
-        if ((this->targetPosition_ - this->getPosition()).length() > 100)
-        {
+        Vector3 proj = Ogre::Plane(this->getDir(), this->getPosition()).projectVector(this->targetPosition_ - this->getPosition());
+        float angle = acos((this->getOrth().dotProduct(proj)) / (this->getOrth().length()*proj.length()));
+
+        if ((this->getDir().crossProduct(this->getOrth())).dotProduct(this->targetPosition_ - this->getPosition()) > 0)
+            this->setMoveYaw(sgn(sin(angle)));
+        else
+            this->setMoveYaw(-sgn(sin(angle)));
+        this->setMovePitch(sgn(cos(angle)));
+
+        if ((this->targetPosition_ - this->getPosition()).length() > 300)
             this->setMoveLongitudinal(1);
-        }
-
+
+        if (this->isCloseAtTarget(300) && this->target_)
+        {
+            if (this->getVelocity().length() > this->target_->getVelocity().length())
+                this->setMoveLongitudinal(-1);
+        }
     }
 
@@ -241 +260 @@
                 Vector3 distanceNew = it->getPosition() - this->getPosition();
                 if (!this->target_ || it->getPosition().squaredDistance(this->getPosition()) * (1.5f + acos((this->getOrientation() * Ogre::Vector3::UNIT_X).dotProduct(distanceNew) / speed / distanceNew.length()) / (2 * Ogre::Math::PI))
-                        < this->targetPosition_.squaredDistance(this->getPosition()) * (1.5f + acos((this->getOrientation() * Ogre::Vector3::UNIT_X).dotProduct(distanceCurrent) / speed / distanceCurrent.length()) / (2 * Ogre::Math::PI)))
+                        < this->targetPosition_.squaredDistance(this->getPosition()) * (1.5f + acos((this->getOrientation() * Ogre::Vector3::UNIT_X).dotProduct(distanceCurrent) / speed / distanceCurrent.length()) / (2 * Ogre::Math::PI)) + rnd(-250, 250))
                 {
                     this->target_ = (*it);
@@ -248 +267 @@
             }
         }
-   }
+    }
 
     void SpaceShipAI::forgetTarget()
@@ -260 +279 @@
         if (!this->target_)
             return;
-/*
+
         Vector3 enemymovement = this->target_->getVelocity();
         Vector3 distance_normalised = this->target_->getPosition() - this->getPosition();
@@ -267 +286 @@
         float scalarprod = enemymovement.dotProduct(distance_normalised);
         float aimoffset = scalarprod*scalarprod + Projectile::getSpeed() * Projectile::getSpeed() - this->target_->getVelocity().squaredLength();
+
         if (aimoffset < 0)
         {
@@ -273 +293 @@
         }
         aimoffset = -scalarprod + sqrt(aimoffset);
-        this->targetPosition_ = enemymovement + distance_normalised * aimoffset;
+        this->targetPosition_ = this->getPosition() + enemymovement + distance_normalised * aimoffset;
         this->bHasTargetPosition_ = true;
-
-        std::cout << "targetpos: " << this->targetPosition_ << std::endl;
-*/
-        this->targetPosition_ = this->target_->getPosition();
-        this->bHasTargetPosition_ = true;
     }
 
     bool SpaceShipAI::isCloseAtTarget(float distance)
     {
-        return (this->getPosition().squaredDistance(this->targetPosition_) < distance*distance);
+        if (!this->target_)
+            return (this->getPosition().squaredDistance(this->targetPosition_) < distance*distance);
+        else
+            return (this->getPosition().squaredDistance(this->target_->getPosition()) < distance*distance);
     }
 
     bool SpaceShipAI::isLookingAtTarget(float angle)
     {
-        return (this->getOrientation() * Ogre::Vector3::UNIT_X).directionEquals(this->targetPosition_ - this->getPosition(), Radian(angle));
+        Vector3 dist = this->targetPosition_ - this->getPosition();
+        return (acos((this->getDir().dotProduct(dist)) / (dist.length() * this->getDir().length())) < angle);
+    }
+
+    void SpaceShipAI::shipDied(SpaceShipAI* ship)
+    {
+        this->forgetTarget();
+        this->searchNewTargetPosition();
     }
 }

code/trunk/src/orxonox/objects/SpaceShipAI.h

@@ -44 +44 @@
         public:
             SpaceShipAI();
+            virtual ~SpaceShipAI();
+
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             static void createEnemy(int num);
             static void killEnemies(int num);
+            void shipDied(SpaceShipAI* ship);
+            void damage(float damage);
+            void kill();
 
         private:
@@ -64 +69 @@
             Timer<SpaceShipAI> actionTimer_;
 
-            bool alive_;
             bool bHasTargetPosition_;
             Vector3 targetPosition_;

code/trunk/src/orxonox/objects/WorldEntity.cc

@@ -66 +66 @@
         }
     }
-    
+
 
     WorldEntity::~WorldEntity()
     {
-      // just to make sure we clean out all scene nodes
-      if(this->getNode())
-        this->getNode()->removeAndDestroyAllChildren();
+        // just to make sure we clean out all scene nodes
+        if(this->getNode())
+        {
+            this->getNode()->removeAndDestroyAllChildren();
+            GraphicsEngine::getSingleton().getSceneManager()->destroySceneNode(this->getName());
+        }
     }
 
@@ -95 +98 @@
         create();
     }
-    
+
 
     void WorldEntity::setYawPitchRoll(const Degree& yaw, const Degree& pitch, const Degree& roll)
@@ -122 +125 @@
 
         XMLPortObject(WorldEntity, WorldEntity, "attached", attachWorldEntity, getAttachedWorldEntity, xmlelement, mode, false, true);
-        
+
         WorldEntity::create();
     }