Changeset 7163 for code/trunk/src/orxonox

code/trunk

Property svn:mergeinfo changed

/code/branches/ai (added)	merged: 6592,6601,6640,6683,6695-6696,6782,6795,6832-6833,6847,6850,6854,6888,6891,6918-6919,6958,6978,6986,6991,6997,7029,7033
/code/branches/chat (added)	merged: 6527,6565,6577,6596-6597,6605,6633-6637,6644,6649,6652,6682,6688,6690,6693,6698-6699,6776-6777,6788,6791,6793,6797
/code/branches/chat2 (added)	merged: 6836-6837,6846,6870,6876,6879,6885,6890,6910
/code/branches/dynamicmatch (added)	merged: 6584,6586,6603,6686,6692,6697,6812,6848,6921,6954-6955,6959,6987
/code/branches/fps (added)	merged: 6591,6639,6819-6826,6866-6867,6872,6882-6883,6908,7052-7053,7055,7057,7059,7070
/code/branches/hudelements (added)	merged: 6599-6600,6602,6606,6614-6615,6631,6715-6717,6727,6796,6849,6865,6868,6873-6875,6880,6886,6897-6899,6907,6913-6914,6917,6922-6924,6941
/code/branches/lod (added)	merged: 6691,6724,6786-6787,6794,6828-6829,6838-6839,6843,6852,6877,6881,6909,6911
/code/branches/network2 (added)	merged: 6448-6450,6455-6458,6462,6464-6465
/code/branches/ppspickups3 (added)	merged: 6869,6884,6887,6892-6896,6980,6985
/code/branches/ppspickups4 (added)	merged: 7067-7068
/code/branches/presentation3 (added)	merged: 6920,6926-6928,6932-6935,6937-6940,6942,6944-6947,6951,6953,6957,6960-6961,6964-6965,6971,6977,6981-6982,6984,6990,6994,6996,6998-7000,7003-7010,7012-7025,7027-7028,7030-7032,7034-7051,7054,7056,7058,7060-7066,7069,7072-7073,7075-7099,7101-7113,7118-7123,7125-7143,7147-7162
/code/branches/rocket (added)	merged: 6778-6781,6783-6785,6803,6809-6811,6813-6818,6827,6834,6863,6878,6900,6902-6905,6943,6948-6950
/code/branches/rocket2 (added)	merged: 6956,6966,6969-6970
/code/branches/skybox2 (added)	merged: 6559,6616,6619,6673,6771-6772,6804,6806,6858,6861,6936,6972-6974,6988-6989

code/trunk/src/orxonox/CMakeLists.txt

-                      r6711
+                      r7163
   PlayerManager.cc
   Radar.cc
+  ChatHistory.cc
+  ChatInputHandler.cc
+#  Test.cc
 COMPILATION_BEGIN SceneCompilation.cc
   CameraManager.cc
 …
   FIND_HEADER_FILES
   TOLUA_FILES
+    ChatInputHandler.h
     LevelManager.h
     MoodManager.h
     controllers/HumanController.h
+    interfaces/PickupCarrier.h
+    interfaces/Pickupable.h
+    infos/PlayerInfo.h
     sound/SoundManager.h
-  DEFINE_SYMBOL
-    "ORXONOX_SHARED_BUILD"
   PCH_FILE
     OrxonoxPrecompiledHeaders.h
 …
     ${VORBIS_LIBRARY}
     ${OGG_LIBRARY}
     tinyxml++_orxonox
     tolua++_orxonox
+    tinyxml_orxonox
+    tolua_orxonox
     bullet_orxonox
     util

code/trunk/src/orxonox/Level.cc

-                      r6746
+                      r7163
         RegisterObject(Level);
         this->registerVariables();
         this->xmlfilename_ = this->getFilename();
 …
         XMLPortParam(Level, "gametype", setGametypeString, getGametypeString, xmlelement, mode).defaultValues("Gametype");
+        XMLPortObject(Level, MeshLodInformation, "lodinformation", addLodInfo, getLodInfo, xmlelement, mode);
         XMLPortObjectExtended(Level, BaseObject, "", addObject, getObject, xmlelement, mode, true, false);
+    }
+}
     void Level::registerVariables()
+    {
+        registerVariable(this->xmlfilename_, VariableDirection::ToClient, new NetworkCallback<Level>(this, &Level::networkcallback_applyXMLFile));
+        registerVariable(this->name_,        VariableDirection::ToClient, new NetworkCallback<Level>(this, &Level::changedName));
+        registerVariable(this->description_, VariableDirection::ToClient);
+        registerVariable(this->xmlfilename_,            VariableDirection::ToClient, new NetworkCallback<Level>(this, &Level::networkcallback_applyXMLFile));
+        registerVariable(this->name_,                   VariableDirection::ToClient, new NetworkCallback<Level>(this, &Level::changedName));
+        registerVariable(this->description_,            VariableDirection::ToClient);
+        registerVariable(this->networkTemplateNames_,   VariableDirection::ToClient, new NetworkCallback<Level>(this, &Level::networkCallbackTemplatesChanged));
+    }
 …
         Loader::open(this->xmlfile_);
+    }
+    void Level::networkCallbackTemplatesChanged()
+    {
+        for( std::set<std::string>::iterator it = this->networkTemplateNames_.begin(); it!=this->networkTemplateNames_.end(); ++it )
+        {
+            assert(Template::getTemplate(*it));
+            Template::getTemplate(*it)->applyOn(this);
+        }
+    }
 …
         this->objects_.push_back(object);
         object->setGametype(this->getGametype());
+        object->setLevel(this);
+    }
 …
             ++i;
+        }
+        return 0;
+    }
+    void Level::addLodInfo(MeshLodInformation* lodInformation)
+    {
+        std::string meshName = lodInformation->getMeshName();
+//         this->lodInformation_.insert(std::make_pair(meshName,lodInformation));
+        if( this->lodInformation_.find(meshName) != this->lodInformation_.end())
+          CCOUT(4) << "replacing lod information for " << meshName << endl;
+        this->lodInformation_[meshName] = lodInformation;
+    }
+    MeshLodInformation* Level::getLodInfo(std::string meshName) const
+    {
+        if(this->lodInformation_.find(meshName)!=this->lodInformation_.end())
+            return this->lodInformation_.find(meshName)->second;
         return 0;
+    }

code/trunk/src/orxonox/Level.h

-                      r5929
+                      r7163
 #include <list>
 #include <string>
+#include <map>
 #include "core/BaseObject.h"
 #include "network/synchronisable/Synchronisable.h"
+#include "graphics/MeshLodInformation.h"
 namespace orxonox
 …
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             inline void setDescription(const std::string& description)
 …
             void playerLeft(PlayerInfo* player);
+            MeshLodInformation* getLodInfo(std::string meshName) const;
         private:
+            void registerVariables();
             void addObject(BaseObject* object);
             BaseObject* getObject(unsigned int index) const;
+            void addLodInfo(MeshLodInformation* object);
+            void networkCallbackTemplatesChanged();
+//            const MeshLodInformation* getLodInfo(std::string meshName) const;
+//            MeshLodInformation* getLodInfo(unsigned int index) const;
             void setGametypeString(const std::string& gametype);
 …
             void networkcallback_applyXMLFile();
+            std::string            description_;
+            std::string            gametype_;
+            std::string            xmlfilename_;
+            XMLFile*               xmlfile_;
+            std::list<BaseObject*> objects_;
+            std::string                    description_;
+            std::string                    gametype_;
+            std::string                    xmlfilename_;
+            XMLFile*                       xmlfile_;
+            std::list<BaseObject*>         objects_;
+            std::map<std::string,MeshLodInformation*>  lodInformation_;
     };
+}

code/trunk/src/orxonox/LevelManager.cc

-                      r6501
+                      r7163
     void LevelManager::requestActivity(Level* level)
+    {
+        assert( std::find(this->levels_s.begin(), this->levels_s.end(), level)==this->levels_s.end() );
+        if( std::find(this->levels_s.begin(), this->levels_s.end(), level)!=this->levels_s.end() )
+            return; // level is already in list
         this->levels_s.push_back(level);
         if (this->levels_s.size() == 1)

code/trunk/src/orxonox/Main.cc

-                      r6105
+                      r7163
 #include "core/LuaState.h"
 #include "ToluaBindOrxonox.h"
+#include "ToluaBindNetwork.h"
 #include "Main.h"
 …
 DeclareToluaInterface(Orxonox);
+DeclareToluaInterface(Network);
 namespace orxonox

code/trunk/src/orxonox/MoodManager.cc

-                      r6417
+                      r7163
 #include "core/CoreIncludes.h"
 #include "core/ScopedSingletonManager.h"
+#include "core/Resource.h"
 namespace orxonox
 …
     ManageScopedSingleton(MoodManager, ScopeID::Root, false);
+    // Note: I'm (Kevin Young) not entirely sure whether that's good code style:
+    const std::string MoodManager::defaultMood_ = "default";
     MoodManager::MoodManager()
+    {
         RegisterRootObject(MoodManager);
         this->setConfigValues();
+        // Need to use a variable to store old data because ResetConfigValues() doesn't seem to work.
+        oldMood_ = MoodManager::defaultMood_;
+        // Checking for the existence of the folder for the default mood
+        const std::string& path = "ambient/" + MoodManager::defaultMood_ + "/.";
+        if (!Resource::exists(path))
+        {
+            // TODO: Non-fatal error handling (non-critical resource missing)
+            COUT(2) << "Mood Warning: Folder for default mood (" << MoodManager::defaultMood_ << ") does not exist!" << std::endl;
+        }
+    }
     void MoodManager::setConfigValues()
+    {
         SetConfigValue(mood_, "default")
+        SetConfigValue(mood_, MoodManager::defaultMood_)
             .description("Sets the mood for the current level.")
             .callback(this, &MoodManager::checkMoodValidity);
+    }
+    /** Sets the mood
+    @note
+        TODO: Inform dependent classes of mood change
+    */
+    /** Set a new mood
+     */
     void MoodManager::setMood(const std::string& mood)
+    {
+        oldMood_ = mood_;
         ModifyConfigValue(mood_, set, mood);
+    }
 …
     void MoodManager::checkMoodValidity()
+    {
+        // TODO: Insert new moods here & make this generic
+        if (mood_ != "default" && mood_ != "dnb")
+        //  Generic mood validation
+        const std::string& path = "ambient/" + mood_ + "/.";
+        if (!Resource::exists(path))
+        {
+            ResetConfigValue(mood_);
+            COUT(3) << "Mood " << mood_ << " does not exist. Will not change." << std::endl;
+            this->setMood(oldMood_);
+        }
         else

code/trunk/src/orxonox/MoodManager.h

-                      r6417
+                      r7163
 namespace orxonox
+{
+    /*
+    @brief
+        The MoodListener class is aware of a change in themes and directs that info to dependent classes.
+    */
     class _OrxonoxExport MoodListener : virtual public OrxonoxClass
+    {
 …
     };
+    /*
+    @brief
+        The MoodManager class serves to allow for different musical themes in the game.
+    */
     class _OrxonoxExport MoodManager : public Singleton<MoodManager>, public OrxonoxClass
+    {
 …
             // config values
             std::string mood_;
+            std::string oldMood_;
+            static const std::string defaultMood_;
             static MoodManager* singletonPtr_s;

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r6524
+                      r7163
     class ArtificialController;
     class Controller;
+    class DroneController;
     class HumanController;
     class ScriptController;
 …
     class Asteroids;
     class Deathmatch;
+    class Dynamicmatch;
     class Gametype;
     class TeamBaseMatch;
 …
     class OrxonoxOverlay;
     class OverlayGroup;
     // pickup
     class PickupIdentifier;
 …
     class CameraPosition;
     class ControllableEntity;
+    class Drone;
     class EffectContainer;
     class ExplosionChunk;

code/trunk/src/orxonox/Radar.cc

-                      r6417
+                      r7163
+    }
+    void Radar::addRadarObject(RadarViewable* rv)
+    {
+        assert( this->radarObjects_.find(rv) == this->radarObjects_.end() );
+        this->radarObjects_.insert(rv);
+        // iterate through all radarlisteners and notify them
+        for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
+            (*itListener)->addObject(rv);
+        }
+    }
+    void Radar::removeRadarObject(RadarViewable* rv)
+    {
+        assert( this->radarObjects_.find(rv) != this->radarObjects_.end() );
+        this->radarObjects_.erase(rv);
+        // iterate through all radarlisteners and notify them
+        for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
+            (*itListener)->removeObject(rv);
+        }
+    }
     const RadarViewable* Radar::getFocus()
+    {
 …
+        {
             (*itListener)->radarTick(dt);
-            for (ObjectList<RadarViewable>::iterator itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
+            {
-                if ((*itElement)->getRadarVisibility())
-                    if ((*itListener)->getRadarSensitivity() > (*itElement)->getRadarObjectCamouflage())
-                        (*itListener)->displayObject(*itElement, *itElement == this->focus_);
+            }
+        }
+    }
 …
+        }
+    }
+    void Radar::radarObjectChanged(RadarViewable* rv)
+    {
+        for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
+          (*itListener)->objectChanged(rv);
+        }
+    }
+}

code/trunk/src/orxonox/Radar.h

-                      r6417
+                      r7163
 #include <map>
+#include <set>
 #include <string>
 …
     class _OrxonoxExport Radar : public Tickable
+    {
+        friend class RadarViewable;
     public:
         Radar();
 …
         void listObjects() const;
+        const std::set<RadarViewable*>& getRadarObjects() const
+            { return this->radarObjects_; }
         void releaseFocus();
 …
         void updateFocus();
+        void addRadarObject(RadarViewable* rv);
+        void removeRadarObject(RadarViewable* rv);
+        void radarObjectChanged(RadarViewable* rv);
         ObjectListIterator<RadarViewable> itFocus_;
         RadarViewable* focus_;
         std::map<std::string, RadarViewable::Shape> objectTypes_;
+        std::set<RadarViewable*> radarObjects_;
         int objectTypeCounter_;
     };

code/trunk/src/orxonox/Scene.cc

-                      r6417
+                      r7163
 #include "Radar.h"
 #include "worldentities/WorldEntity.h"
+#include "Level.h"
 namespace orxonox
 …
         registerVariable(this->bHasPhysics_,        VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::networkcallback_hasPhysics));
         registerVariable(this->bShadows_,           VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applyShadows));
+        registerVariable(this->getLevel(),          VariableDirection::ToClient, new NetworkCallback<Scene>(this, &Scene::changedLevel));
+    }

code/trunk/src/orxonox/Test.cc

-                      r6417
+                      r7163
     void Test::registerVariables()
+    {
+        registerVariable ( u1, VariableDirection::ToClient, new NetworkCallback<Test> ( this, &Test::checkU1 ));
+        registerVariable ( u2, VariableDirection::ToServer, new NetworkCallback<Test> ( this, &Test::checkU2 ));
+        registerVariable ( u3, Bidirectionality::ServerMaster, new NetworkCallback<Test> ( this, &Test::checkU3 ), true );
+        registerVariable ( u4, Bidirectionality::ClientMaster, new NetworkCallback<Test> ( this, &Test::checkU4 ), true );
+        registerVariable ( this->mySet_, VariableDirection::ToClient );
+//         registerVariable ( u1, VariableDirection::ToClient, new NetworkCallback<Test> ( this, &Test::checkU1 ));
+//         registerVariable ( u2, VariableDirection::ToServer, new NetworkCallback<Test> ( this, &Test::checkU2 ));
+//         registerVariable ( u3, Bidirectionality::ServerMaster, new NetworkCallback<Test> ( this, &Test::checkU3 ), true );
+//         registerVariable ( u4, Bidirectionality::ClientMaster, new NetworkCallback<Test> ( this, &Test::checkU4 ), true );
         registerVariable ( s1, VariableDirection::ToClient, new NetworkCallback<Test> ( this, &Test::checkS1 ));
         registerVariable ( s2, VariableDirection::ToServer, new NetworkCallback<Test> ( this, &Test::checkS2 ));
         registerVariable ( s3, Bidirectionality::ServerMaster, new NetworkCallback<Test> ( this, &Test::checkS3 ), true );
         registerVariable ( s4, Bidirectionality::ClientMaster, new NetworkCallback<Test> ( this, &Test::checkS4 ), true );
+//         registerVariable ( s1, VariableDirection::ToClient, new NetworkCallback<Test> ( this, &Test::checkS1 ));
+//         registerVariable ( s2, VariableDirection::ToServer, new NetworkCallback<Test> ( this, &Test::checkS2 ));
+//         registerVariable ( s3, Bidirectionality::ServerMaster, new NetworkCallback<Test> ( this, &Test::checkS3 ), true );
+//         registerVariable ( s4, Bidirectionality::ClientMaster, new NetworkCallback<Test> ( this, &Test::checkS4 ), true );
         registerVariable ( pointer_, VariableDirection::ToClient, new NetworkCallback<Test> ( this, &Test::printPointer ) );
+//         registerVariable ( pointer_, VariableDirection::ToClient, new NetworkCallback<Test> ( this, &Test::printPointer ) );
+    }

code/trunk/src/orxonox/Test.h

-                      r6417
+                      r7163
 #include "tools/interfaces/Tickable.h"
+#include <set>
 typedef int TYPE;
 …
       void setConfigValues();
-      void registerVariables();
       static void call(unsigned int clientID);
 …
       void printPointer();
       static void printV1(){ instance_->checkU1(); }
       static void printV2(){ instance_->checkU2(); }
+      static void printV1(){ instance_->blub(); }
+      static void printV2(){ instance_->blub2(); }
       static void printV3(){ instance_->checkU3(); }
       static void printV4(){ instance_->checkU4(); }
 …
     private:
+      void registerVariables();
       UTYPE u1;
       UTYPE u2;
 …
       Test* pointer_;
+      std::set<uint32_t> mySet_;
       static Test* instance_;
+      void blub()
+      { mySet_.insert(2); }
+      void blub2()
+      { for( std::set<uint32_t>::iterator it=mySet_.begin(); it!=mySet_.end(); ++it ) COUT(0) << *it << endl; }
   };
+}

code/trunk/src/orxonox/collisionshapes/CollisionShape.h

-                      r5781
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             inline void setPosition(const Vector3& position)
 …
         private:
+            void registerVariables();
             Vector3                 position_;
             Quaternion              orientation_;

code/trunk/src/orxonox/controllers/AIController.cc

-                      r5929
+                      r7163
  *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
+ *      Dominik Solenicki
+ *
  */
 …
 #include "core/Executor.h"
 #include "worldentities/ControllableEntity.h"
+#include "worldentities/pawns/Pawn.h"
 namespace orxonox
 …
         float maxrand = 100.0f / ACTION_INTERVAL;
+        // search enemy
+        random = rnd(maxrand);
+        if (random < 15 && (!this->target_))
+            this->searchNewTarget();
+        // forget enemy
+        random = rnd(maxrand);
+        if (random < 5 && (this->target_))
+            this->forgetTarget();
+        // next enemy
+        random = rnd(maxrand);
+        if (random < 10 && (this->target_))
+            this->searchNewTarget();
+        // fly somewhere
+        random = rnd(maxrand);
+        if (random < 50 && (!this->bHasTargetPosition_ && !this->target_))
+            this->searchRandomTargetPosition();
+        // stop flying
+        random = rnd(maxrand);
+        if (random < 10 && (this->bHasTargetPosition_ && !this->target_))
+            this->bHasTargetPosition_ = false;
+        // fly somewhere else
+        random = rnd(maxrand);
+        if (random < 30 && (this->bHasTargetPosition_ && !this->target_))
+            this->searchRandomTargetPosition();
+        // shoot
+        random = rnd(maxrand);
+        if (random < 75 && (this->target_ && !this->bShooting_))
+            this->bShooting_ = true;
+        // stop shooting
+        random = rnd(maxrand);
+        if (random < 25 && (this->bShooting_))
+            this->bShooting_ = false;
+        if (this->state_ == FREE)
+        {
+            if (this->formationFlight_)
+            {
+                // return to Master after being forced free
+                if (this->freedomCount_ == 1)
+                {
+                this->state_ = SLAVE;
+                this->freedomCount_ = 0;
+                }
+                random = rnd(maxrand);
+                if (random < 90 && (((!this->target_) || (random < 50 && this->target_)) && !this->forcedFree()))
+                    this->searchNewMaster();
+            }
+            // search enemy
+            random = rnd(maxrand);
+            if (random < 15 && (!this->target_))
+                this->searchNewTarget();
+            // forget enemy
+            random = rnd(maxrand);
+            if (random < 5 && (this->target_))
+                this->forgetTarget();
+            // next enemy
+            random = rnd(maxrand);
+            if (random < 10 && (this->target_))
+                this->searchNewTarget();
+            // fly somewhere
+            random = rnd(maxrand);
+            if (random < 50 && (!this->bHasTargetPosition_ && !this->target_))
+                this->searchRandomTargetPosition();
+            // stop flying
+            random = rnd(maxrand);
+            if (random < 10 && (this->bHasTargetPosition_ && !this->target_))
+                this->bHasTargetPosition_ = false;
+            // fly somewhere else
+            random = rnd(maxrand);
+            if (random < 30 && (this->bHasTargetPosition_ && !this->target_))
+                this->searchRandomTargetPosition();
+            // shoot
+            random = rnd(maxrand);
+            if (!(this->passive_) && random < 75 && (this->target_ && !this->bShooting_))
+                this->bShooting_ = true;
+            // stop shooting
+            random = rnd(maxrand);
+            if (random < 25 && (this->bShooting_))
+                this->bShooting_ = false;
+        }
+        if (this->state_ == SLAVE)
+        {
+        }
+        if (this->state_ == MASTER)
+        {
+            this->commandSlaves();
+            if  (this->specificMasterAction_ != NONE)
+                    this->specificMasterActionHold();
+            else {
+                 // make 180 degree turn - a specific Master Action
+                random = rnd(1000.0f);
+                if (random < 5)
+                   this->turn180Init();
+                // spin around - a specific Master Action
+                random = rnd(1000.0f);
+                if (random < 5)
+                   this->spinInit();
+                // follow a randomly chosen human - a specific Master Action
+                random = rnd(1000.0f);
+                if (random < 1)
+                   this->followRandomHumanInit();
+                 // lose master status (only if less than 4 slaves in formation)
+                random = rnd(maxrand);
+                if(random < 15/(this->slaves_.size()+1) && this->slaves_.size() < 4 )
+                   this->loseMasterState();
+                // look out for outher masters if formation is small
+                random = rnd(maxrand);
+                if(this->slaves_.size() < 3 && random < 20)
+                    this->searchNewMaster();
+                // search enemy
+                random = rnd(maxrand);
+                if (random < 15 && (!this->target_))
+                    this->searchNewTarget();
+                // forget enemy
+                random = rnd(maxrand);
+                if (random < 5 && (this->target_))
+                    this->forgetTarget();
+                // next enemy
+                random = rnd(maxrand);
+                if (random < 10 && (this->target_))
+                    this->searchNewTarget();
+                // fly somewhere
+                random = rnd(maxrand);
+                if (random < 50 && (!this->bHasTargetPosition_ && !this->target_))
+                    this->searchRandomTargetPosition();
+                // fly somewhere else
+                random = rnd(maxrand);
+                if (random < 30 && (this->bHasTargetPosition_ && !this->target_))
+                    this->searchRandomTargetPosition();
+                // shoot
+                random = rnd(maxrand);
+                if (!(this->passive_) && random < 9 && (this->target_ && !this->bShooting_))
+                {
+                this->bShooting_ = true;
+                this->forceFreeSlaves();
+                }
+                // stop shooting
+                random = rnd(maxrand);
+                if (random < 25 && (this->bShooting_))
+                    this->bShooting_ = false;
+            }
+        }
+    }
 …
             return;
+        if (this->target_)
+            this->aimAtTarget();
+        if (this->bHasTargetPosition_)
+            this->moveToTargetPosition();
+        if (this->getControllableEntity() && this->bShooting_ && this->isCloseAtTarget(1000) && this->isLookingAtTarget(Ogre::Math::PI / 20.0f))
+            this->getControllableEntity()->fire(0);
+        if (this->state_ == MASTER)
+        {
+            if (this->specificMasterAction_ ==  NONE)
+            {
+                if (this->target_)
+                {
+                                if (!this->target_->getRadarVisibility()) /* So AI won't shoot invisible Spaceships */
+                        this->forgetTarget();
+                else this->aimAtTarget();
+            }
+                if (this->bHasTargetPosition_)
+                    this->moveToTargetPosition();
+                if (this->getControllableEntity() && this->bShooting_ && this->isCloseAtTarget(1000) && this->isLookingAtTarget(Ogre::Math::PI / 20.0f))
+                    this->getControllableEntity()->fire(0);
+            }
+            if (this->specificMasterAction_  == TURN180)
+                    this->turn180();
+            if (this->specificMasterAction_ == SPIN)
+                    this->spin();
+            if (this->specificMasterAction_ == FOLLOW)
+                    this->follow();
+        }
+        if (this->state_ == SLAVE)
+        {
+            if (this->bHasTargetPosition_)
+                this->moveToTargetPosition();
+        }
+         if (this->state_ == FREE)
+        {
+            if (this->target_)
+            {
+                                if (!this->target_->getRadarVisibility()) /* So AI won't shoot invisible Spaceships */
+                        this->forgetTarget();
+                else this->aimAtTarget();
+            }
+            if (this->bHasTargetPosition_)
+                this->moveToTargetPosition();
+            if (this->getControllableEntity() && this->bShooting_ && this->isCloseAtTarget(1000) && this->isLookingAtTarget(Ogre::Math::PI / 20.0f))
+                this->getControllableEntity()->fire(0);
+        }
         SUPER(AIController, tick, dt);

code/trunk/src/orxonox/controllers/ArtificialController.cc

-                      r6502
+                      r7163
  *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
+ *      Dominik Solenicki
+ *
  */
 …
 #include "ArtificialController.h"
+#include <vector>
+#include <climits>
+#include "util/Math.h"
+#include "core/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
 #include "worldentities/ControllableEntity.h"
 #include "worldentities/pawns/Pawn.h"
 #include "worldentities/pawns/TeamBaseMatchBase.h"
 #include "gametypes/TeamDeathmatch.h"
+#include "gametypes/Dynamicmatch.h"
 #include "controllers/WaypointPatrolController.h"
+#include "controllers/NewHumanController.h"
+#include "controllers/DroneController.h"
 namespace orxonox
+{
+    SetConsoleCommand(ArtificialController, formationflight, true);
+    SetConsoleCommand(ArtificialController, masteraction, true);
+    SetConsoleCommand(ArtificialController, followme, true);
+    SetConsoleCommand(ArtificialController, passivebehaviour, true);
+    SetConsoleCommand(ArtificialController, formationsize, true);
+    static const unsigned int STANDARD_MAX_FORMATION_SIZE = 7;
+    static const int RADIUS_TO_SEARCH_FOR_MASTERS = 5000;
+    static const int FORMATION_LENGTH =  130;
+    static const int FORMATION_WIDTH =  110;
+    static const int FREEDOM_COUNT = 4; //seconds the slaves in a formation will be set free when master attacks an enemy
+    static const float SPEED_MASTER = 0.6f;
+    static const float ROTATEFACTOR_MASTER = 0.2f;
+    static const float SPEED_FREE = 0.8f;
+    static const float ROTATEFACTOR_FREE = 0.8f;
     ArtificialController::ArtificialController(BaseObject* creator) : Controller(creator)
+    {
 …
         this->target_ = 0;
+        this->formationFlight_ = true;
+        this->passive_ = false;
+        this->maxFormationSize_ = STANDARD_MAX_FORMATION_SIZE;
+        this->myMaster_ = 0;
+        this->freedomCount_ = 0;
+        this->team_ = -1;
+        this->state_ = FREE;
+        this->specificMasterAction_ = NONE;
+        this->specificMasterActionHoldCount_  = 0;
         this->bShooting_ = false;
         this->bHasTargetPosition_ = false;
+        this->speedCounter_ = 0.2f;
         this->targetPosition_ = Vector3::ZERO;
 …
     ArtificialController::~ArtificialController()
+    {
+        if (this->isInitialized())
+        {
+            this->removeFromFormation();
+            for (ObjectList<ArtificialController>::iterator it = ObjectList<ArtificialController>::begin(); it; ++it)
+            {
+                if (*it != this)
+                {
+                    if (it->myMaster_ == this)
+                    {
+                        COUT(1) << "error: " << this << " is still master in " << (*it) << std::endl;
+                        it->myMaster_ = 0;
+                    }
+                    while (true)
+                    {
+                        std::vector<ArtificialController*>::iterator it2 = std::find(it->slaves_.begin(), it->slaves_.end(), this);
+                        if (it2 != it->slaves_.end())
+                        {
+                            COUT(1) << "error: " << this << " is still slave in " << (*it) << std::endl;
+                            it->slaves_.erase(it2);
+                        }
+                        else
+                            break;
+                    }
+                }
+            }
+        }
+    }
+    void ArtificialController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(ArtificialController, XMLPort, xmlelement, mode);
+        XMLPortParam(ArtificialController, "team", setTeam, getTeam, xmlelement, mode).defaultValues(-1);
+        XMLPortParam(ArtificialController, "formationFlight", setFormationFlight, getFormationFlight, xmlelement, mode).defaultValues(false);
+        XMLPortParam(ArtificialController, "formationSize", setFormationSize, getFormationSize, xmlelement, mode).defaultValues(STANDARD_MAX_FORMATION_SIZE);
+        XMLPortParam(ArtificialController, "passive", setPassive, getPassive, xmlelement, mode).defaultValues(false);
+    }
+// Documentation only here to get a faster overview for creating a useful documentation...
+    /**
+        @brief Activates / deactivates formationflight behaviour
+        @param form activate formflight if form is true
+    */
+    void ArtificialController::formationflight(const bool form)
+    {
+        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
+            Controller* controller = 0;
+            if (it->getController())
+                controller = it->getController();
+            else if (it->getXMLController())
+                controller = it->getXMLController();
+            if (!controller)
+                continue;
+            ArtificialController *aiController = orxonox_cast<ArtificialController*>(controller);
+            if (aiController)
+            {
+                aiController->formationFlight_ = form;
+                if (!form)
+                {
+                    aiController->removeFromFormation();
+                }
+            }
+        }
+    }
+    /**
+        @brief Get all masters to do a "specific master action"
+        @param action which action to perform (integer, so it can be called with a console command (tmp solution))
+    */
+    void ArtificialController::masteraction(const int action)
+    {
+        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
+            Controller* controller = 0;
+            if (it->getController())
+                controller = it->getController();
+            else if (it->getXMLController())
+                controller = it->getXMLController();
+            if (!controller)
+                continue;
+            ArtificialController *aiController = orxonox_cast<ArtificialController*>(controller);
+            if(aiController && aiController->state_ == MASTER)
+            {
+                if (action == 1)
+                    aiController->spinInit();
+                if (action == 2)
+                    aiController->turn180Init();
+            }
+        }
+    }
+    /**
+        @brief A human player gets followed by its nearest master. Initiated by console command, so far intended for demonstration puproses (possible future pickup).
+    */
+    void ArtificialController::followme()
+    {
+        Pawn *humanPawn = NULL;
+        NewHumanController *currentHumanController = NULL;
+        std::vector<ArtificialController*> allMasters;
+        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
+            Controller* controller = 0;
+            if (it->getController())
+                controller = it->getController();
+            else if (it->getXMLController())
+                controller = it->getXMLController();
+            if (!controller)
+                continue;
+            currentHumanController = orxonox_cast<NewHumanController*>(controller);
+            if(currentHumanController) humanPawn = *it;
+            ArtificialController *aiController = orxonox_cast<ArtificialController*>(controller);
+            if(aiController && aiController->state_ == MASTER)
+                allMasters.push_back(aiController);
+        }
+        if((humanPawn != NULL) && (allMasters.size() != 0))
+        {
+                float posHuman = humanPawn->getPosition().length();
+                float distance = 0.0f;
+                float minDistance = FLT_MAX;
+                int index = 0;
+                int i = 0;
+                for(std::vector<ArtificialController*>::iterator it = allMasters.begin(); it != allMasters.end(); it++, i++)
+                    {
+                        if (!ArtificialController::sameTeam((*it)->getControllableEntity(), humanPawn, (*it)->getGametype())) continue;
+                        distance = posHuman - (*it)->getControllableEntity()->getPosition().length();
+                        if(distance < minDistance) index = i;
+                    }
+                allMasters[index]->followInit(humanPawn);
+            }
+    }
+    /**
+        @brief Sets shooting behaviour of pawns.
+        @param passive if true, bots won't shoot.
+    */
+    void ArtificialController::passivebehaviour(const bool passive)
+    {
+        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
+            Controller* controller = 0;
+            if (it->getController())
+                controller = it->getController();
+            else if (it->getXMLController())
+                controller = it->getXMLController();
+            if (!controller)
+                continue;
+            ArtificialController *aiController = orxonox_cast<ArtificialController*>(controller);
+            if(aiController)
+            {
+                aiController->passive_ = passive;
+            }
+        }
+    }
+    /**
+        @brief Sets maximal formation size
+        @param size maximal formation size.
+    */
+    void ArtificialController::formationsize(const int size)
+    {
+        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
+            Controller* controller = 0;
+            if (it->getController())
+                controller = it->getController();
+            else if (it->getXMLController())
+                controller = it->getXMLController();
+            if (!controller)
+                continue;
+            ArtificialController *aiController = orxonox_cast<ArtificialController*>(controller);
+            if(aiController)
+            {
+                aiController->maxFormationSize_ = size;
+            }
+        }
+    }
+    /**
+        @brief Gets called when ControllableEntity is being changed. Resets the bot when it dies.
+    */
+    void ArtificialController::changedControllableEntity()
+    {
+        if (!this->getControllableEntity())
+            this->removeFromFormation();
+    }
+    void ArtificialController::removeFromFormation()
+    {
+        if (this->state_ == SLAVE || this->myMaster_) // slaves can also be temporary free, so check if myMaster_ is set
+            this->unregisterSlave();
+        else if (this->state_ == MASTER)
+            this->setNewMasterWithinFormation();
+    }
 …
             return;
+        // Slave uses special movement if its master is in FOLLOW mode
+        if(this->state_ == SLAVE && this->myMaster_ && this->myMaster_->specificMasterAction_ == FOLLOW)
+        {
+//             this->followForSlaves(target);
+//             return;
+        }
         Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
         float distance = (target - this->getControllableEntity()->getPosition()).length();
+        if (this->target_ || distance > 10)
+        {
+            // Multiply with 0.8 to make them a bit slower
+            this->getControllableEntity()->rotateYaw(-0.8f * sgn(coord.x) * coord.x*coord.x);
+            this->getControllableEntity()->rotatePitch(0.8f * sgn(coord.y) * coord.y*coord.y);
+        }
+        if (this->target_ && distance < 200 && this->getControllableEntity()->getVelocity().squaredLength() > this->target_->getVelocity().squaredLength())
+            this->getControllableEntity()->moveFrontBack(-0.5f); // They don't brake with full power to give the player a chance
+        if(this->state_ == FREE)
+        {
+            if (this->target_ || distance > 10)
+            {
+                // Multiply with ROTATEFACTOR_FREE to make them a bit slower
+                this->getControllableEntity()->rotateYaw(-1.0f * ROTATEFACTOR_FREE * sgn(coord.x) * coord.x*coord.x);
+                this->getControllableEntity()->rotatePitch(ROTATEFACTOR_FREE * sgn(coord.y) * coord.y*coord.y);
+            }
+            if (this->target_ && distance < 200 && this->getControllableEntity()->getVelocity().squaredLength() > this->target_->getVelocity().squaredLength())
+            {
+              this->getControllableEntity()->moveFrontBack(-0.05f); // They don't brake with full power to give the player a chance
+            } else this->getControllableEntity()->moveFrontBack(SPEED_FREE);
+        }
+        if(this->state_ == MASTER)
+        {
+            if (this->target_ || distance > 10)
+            {
+                this->getControllableEntity()->rotateYaw(-1.0f * ROTATEFACTOR_MASTER * sgn(coord.x) * coord.x*coord.x);
+                this->getControllableEntity()->rotatePitch(ROTATEFACTOR_MASTER * sgn(coord.y) * coord.y*coord.y);
+            }
+            if (this->target_ && distance < 200 && this->getControllableEntity()->getVelocity().squaredLength() > this->target_->getVelocity().squaredLength())
+            {
+                this->getControllableEntity()->moveFrontBack(-0.05f);
+            } else this->getControllableEntity()->moveFrontBack(SPEED_MASTER);
+        }
+        if(this->state_ == SLAVE)
+        {
+           this->getControllableEntity()->rotateYaw(-2.0f * ROTATEFACTOR_MASTER * sgn(coord.x) * coord.x*coord.x);
+           this->getControllableEntity()->rotatePitch(2.0f * ROTATEFACTOR_MASTER * sgn(coord.y) * coord.y*coord.y);
+            if (distance < 300)
+            {
+                if (distance < 40)
+                {
+                    this->getControllableEntity()->moveFrontBack(0.8f*SPEED_MASTER);
+                } else this->getControllableEntity()->moveFrontBack(1.2f*SPEED_MASTER);
+            } else {
+                this->getControllableEntity()->moveFrontBack(1.2f*SPEED_MASTER + distance/300.0f);
+            }
+        }
+    }
+    void ArtificialController::moveToTargetPosition()
+    {
+        this->moveToPosition(this->targetPosition_);
+    }
+    /**
+        @brief Unregisters a slave from its master. Initiated by a slave.
+    */
+    void ArtificialController::unregisterSlave()
+    {
+        if (this->myMaster_)
+        {
+            std::vector<ArtificialController*>::iterator it = std::find(this->myMaster_->slaves_.begin(), this->myMaster_->slaves_.end(), this);
+            if (it != this->myMaster_->slaves_.end())
+                this->myMaster_->slaves_.erase(it);
+        }
+        this->myMaster_ = 0;
+        this->state_ = FREE;
+    }
+    void ArtificialController::searchNewMaster()
+    {
+        if (!this->getControllableEntity())
+            return;
+        this->targetPosition_ = this->getControllableEntity()->getPosition();
+        this->forgetTarget();
+        int teamSize = 0;
+        //go through all pawns
+        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
+            //same team?
+            if (!ArtificialController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(*it), this->getGametype()))
+                continue;
+            //has it an ArtificialController?
+            Controller* controller = 0;
+            if (it->getController())
+                controller = it->getController();
+            else if (it->getXMLController())
+                controller = it->getXMLController();
+            if (!controller)
+                continue;
+            //is pawn oneself?
+            if (orxonox_cast<ControllableEntity*>(*it) == this->getControllableEntity())
+                continue;
+            teamSize++;
+            ArtificialController *newMaster = orxonox_cast<ArtificialController*>(controller);
+            //is it a master?
+            if (!newMaster || newMaster->state_ != MASTER)
+                continue;
+            float distance = (it->getPosition() - this->getControllableEntity()->getPosition()).length();
+            // is pawn in range?
+            if (distance < RADIUS_TO_SEARCH_FOR_MASTERS)
+            {
+                if(newMaster->slaves_.size() > this->maxFormationSize_) continue;
+                for(std::vector<ArtificialController*>::iterator itSlave = this->slaves_.begin(); itSlave != this->slaves_.end(); itSlave++)
+                {
+                    (*itSlave)->myMaster_ = newMaster;
+                    newMaster->slaves_.push_back(*itSlave);
+                }
+                this->slaves_.clear();
+                this->state_ = SLAVE;
+                this->myMaster_ = newMaster;
+                newMaster->slaves_.push_back(this);
+                break;
+            }
+        }
+        if (this->state_ != SLAVE  && teamSize != 0)
+        {
+            this->state_ = MASTER;
+            this->myMaster_ = 0;
+        }
+    }
+    /**
+        @brief Commands the slaves of a master into a formation. Sufficiently fast not to be called within tick. Initiated by a master.
+    */
+    void ArtificialController::commandSlaves()
+    {
+        if(this->state_ != MASTER) return;
+        Quaternion orient = this->getControllableEntity()->getOrientation();
+        Vector3 dest = this->getControllableEntity()->getPosition();
+        // 1 slave: follow
+        if (this->slaves_.size() == 1)
+        {
+            dest += 4*orient*WorldEntity::BACK;
+            this->slaves_.front()->setTargetPosition(dest);
+        }
         else
+            this->getControllableEntity()->moveFrontBack(0.8f);
+    }
+    void ArtificialController::moveToTargetPosition()
+    {
+        this->moveToPosition(this->targetPosition_);
+    }
+        {
+            dest += 1.0f*orient*WorldEntity::BACK;
+            Vector3 pos = Vector3::ZERO;
+            int i = 1;
+            for(std::vector<ArtificialController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
+            {
+                pos = Vector3::ZERO;
+                if (i <= 1) pos += dest  + FORMATION_WIDTH*(orient*WorldEntity::LEFT);
+                if (i == 2) pos += dest  + FORMATION_WIDTH*(orient*WorldEntity::RIGHT);
+                if (i == 3) pos += dest  + FORMATION_WIDTH*(orient*WorldEntity::UP);
+                if (i >= 4)
+                {
+                    pos += dest  + FORMATION_WIDTH*(orient*WorldEntity::DOWN);
+                    i = 1;
+                    dest += FORMATION_LENGTH*(orient*WorldEntity::BACK);
+                    (*it)->setTargetPosition(pos);
+                    continue;
+                }
+                i++;
+                (*it)->setTargetPosition(pos);
+            }
+        }
+    }
+    /**
+        @brief Sets a new master within the formation. Called by a master.
+    */
+    void ArtificialController::setNewMasterWithinFormation()
+    {
+        if(this->state_ != MASTER) return;
+        if (!this->slaves_.empty())
+        {
+            ArtificialController *newMaster = this->slaves_.back();
+            this->slaves_.pop_back();
+            newMaster->state_ = MASTER;
+            newMaster->slaves_ = this->slaves_;
+            newMaster->myMaster_ = 0;
+            for(std::vector<ArtificialController*>::iterator it = newMaster->slaves_.begin(); it != newMaster->slaves_.end(); it++)
+            {
+                (*it)->myMaster_ = newMaster;
+            }
+        }
+        this->slaves_.clear();
+        this->specificMasterAction_ = NONE;
+        this->state_ = FREE;
+    }
+    /**
+        @brief Frees all slaves form a master. Initiated by a master.
+    */
+    void ArtificialController::freeSlaves()
+    {
+        if(this->state_ != MASTER) return;
+        for(std::vector<ArtificialController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
+        {
+            (*it)->state_ = FREE;
+            (*it)->myMaster_ = 0;
+        }
+        this->slaves_.clear();
+    }
+    /**
+        @brief Master sets its slaves free for @var FREEDOM_COUNT seconds.
+    */
+    void ArtificialController::forceFreeSlaves()
+    {
+        if(this->state_ != MASTER) return;
+        for(std::vector<ArtificialController*>::iterator it = slaves_.begin(); it != slaves_.end(); it++)
+        {
+            (*it)->state_ = FREE;
+            (*it)->forceFreedom();
+            (*it)->targetPosition_ = this->targetPosition_;
+            (*it)->bShooting_ = true;
+//             (*it)->getControllableEntity()->fire(0);// fire once for fun
+        }
+    }
+    void ArtificialController::loseMasterState()
+    {
+        this->freeSlaves();
+        this->state_ = FREE;
+    }
+    void ArtificialController::forceFreedom()
+    {
+        this->freedomCount_ = FREEDOM_COUNT;
+    }
+    /**
+        @brief Checks wether caller has been forced free, decrements time to stay forced free.
+        @return true if forced free.
+    */
+    bool ArtificialController::forcedFree()
+    {
+        if(this->freedomCount_ > 0)
+        {
+            this->freedomCount_--;
+            return true;
+        } else return false;
+    }
+    /**
+        @brief Used to continue a "specific master action" for a certain time and resuming normal behaviour after.
+    */
+    void ArtificialController::specificMasterActionHold()
+    {
+        if(this->state_ != MASTER) return;
+        if (specificMasterActionHoldCount_ == 0)
+         {
+            this->specificMasterAction_ = NONE;
+            this->searchNewTarget();
+         }
+        else specificMasterActionHoldCount_--;
+    }
+    /**
+        @brief Master initializes a 180 degree turn. Leads to a "specific master action".
+    */
+    void ArtificialController::turn180Init()
+    {
+        if(this->state_ != MASTER) return;
+        Quaternion orient = this->getControllableEntity()->getOrientation();
+        this->setTargetPosition(this->getControllableEntity()->getPosition() + 1000.0f*orient*WorldEntity::BACK);
+        this->specificMasterActionHoldCount_ = 4;
+        this->specificMasterAction_ = TURN180;
+    }
+    /**
+        @brief Execute the 180 degree turn. Called within tick.
+    */
+    void ArtificialController::turn180()
+    {
+            Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, this->targetPosition_);
+            this->getControllableEntity()->rotateYaw(-2.0f * sgn(coord.x) * coord.x*coord.x);
+            this->getControllableEntity()->rotatePitch(2.0f * sgn(coord.y) * coord.y*coord.y);
+            this->getControllableEntity()->moveFrontBack(SPEED_MASTER);
+    }
+    /**
+        @brief Master initializes a spin around its looking direction axis. Leads to a "specific master action".
+    */
+    void ArtificialController::spinInit()
+    {
+        if(this->state_ != MASTER) return;
+        this->specificMasterAction_ = SPIN;
+        this->specificMasterActionHoldCount_ = 10;
+    }
+    /**
+        @brief Execute the spin. Called within tick.
+    */
+    void ArtificialController::spin()
+    {
+            this->moveToTargetPosition();
+            this->getControllableEntity()->rotateRoll(0.8f);
+    }
+    /**
+        @brief Master begins to follow a pawn. Is a "specific master action".
+        @param pawn pawn to follow.
+        @param alaways follows pawn forever if true (false if omitted).
+        @param secondsToFollow seconds to follow the pawn if always is false. Will follow pawn 100 seconds if omitted (set in header).
+    */
+    void ArtificialController::followInit(Pawn* pawn, const bool always, const int secondsToFollow)
+    {
+        if (pawn == NULL || this->state_ != MASTER)
+            return;
+        this->specificMasterAction_  =  FOLLOW;
+        this->setTarget(pawn);
+        if (!always)
+            this->specificMasterActionHoldCount_ = secondsToFollow;
+        else
+            this->specificMasterActionHoldCount_ = INT_MAX; //for now...
+    }
+    /**
+        @brief Master begins to follow a randomly chosen human player of the same team. Is a "specific master action".
+    */
+    void ArtificialController::followRandomHumanInit()
+    {
+        Pawn *humanPawn = NULL;
+        NewHumanController *currentHumanController = NULL;
+        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
+        {
+            if (!it->getController())
+                continue;
+            currentHumanController = orxonox_cast<NewHumanController*>(it->getController());
+            if(currentHumanController)
+            {
+                if (!ArtificialController::sameTeam(this->getControllableEntity(), *it, this->getGametype())) continue;
+                humanPawn = *it;
+                break;
+            }
+        }
+        if((humanPawn != NULL))
+                this->followInit(humanPawn);
+    }
+    /**
+        @brief Master follows target with adjusted speed. Called within tick.
+    */
+    void ArtificialController::follow()
+    {
+        if (this->target_)
+            this->moveToPosition(this->target_->getPosition());
+        else
+            this->specificMasterActionHoldCount_ = 0;
+/*
+        if (!this->getControllableEntity())
+            return;
+        float distance = (this->target_->getPosition() - this->getControllableEntity()->getPosition()).length();
+        Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, this->target_->getPosition());
+        this->getControllableEntity()->rotateYaw(-0.8f * sgn(coord.x) * coord.x*coord.x);
+        this->getControllableEntity()->rotatePitch(0.8f * sgn(coord.y) * coord.y*coord.y);
+        float speedDiv = this->getControllableEntity()->getVelocity().squaredLength() - this->target_->getVelocity().squaredLength();
+COUT(0) << "~follow distance: " << distance << "SpeedCounter: " << this->speedCounter_ << "~speedDiv: " << speedDiv << std::endl;
+        if (distance < 800)
+        {
+            if (distance < 200)
+            {
+                this->speedCounter_ -= 0.5f;
+                if(this->speedCounter_ < 0) this->speedCounter_ = 0.0f;
+                this->getControllableEntity()->moveFrontBack(speedCounter_);
+            } else {
+                if(speedDiv < 0)
+                    this->speedCounter_ +=  0.01f;
+                else
+                    this->speedCounter_ -= 0.05f;
+                this->getControllableEntity()->moveFrontBack(speedCounter_);
+            }
+        } else {
+            this->speedCounter_ += 0.05f;
+            this->getControllableEntity()->moveFrontBack(speedCounter_ + distance/300.0f);
+        }
+//         if (this->getControllableEntity()->getVelocity().squaredLength() > 50.0f) this->speedCounter_ = 0;
+*/
+    }
+    /**
+        @brief Slave moving behaviour when master is following a pawn, gets redirected from moveToPosition(const Vector3& target)). Called within tick.
+    */
+    void ArtificialController::followForSlaves(const Vector3& target)
+    {
+/*
+        if (!this->getControllableEntity() && !this->myMaster_ && this->myMaster_->state_ != FOLLOW && !this->myMaster_->target_)
+            return;
+        float distance = (target - this->getControllableEntity()->getPosition()).length();
+        Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
+        this->getControllableEntity()->rotateYaw(-0.8f * sgn(coord.x) * coord.x*coord.x);
+        this->getControllableEntity()->rotatePitch(0.8f * sgn(coord.y) * coord.y*coord.y);
+        float speedDiv = this->getControllableEntity()->getVelocity().squaredLength() - this->myMaster_->target_->getVelocity().squaredLength();
+         if (distance < 800)
+        {
+            if (distance < 200)
+            {
+                this->speedCounter_ -= 5.0f;
+                if(this->speedCounter_ < 0) this->speedCounter_ = 0.0f;
+                this->getControllableEntity()->moveFrontBack(speedCounter_);
+            } else {
+                if(speedDiv < 0)
+                    this->speedCounter_ +=  0.01f;
+                else
+                    this->speedCounter_ -= 0.05f;
+                this->getControllableEntity()->moveFrontBack(speedCounter_);
+            }
+        } else {
+            this->speedCounter_ += 0.05f;
+            this->getControllableEntity()->moveFrontBack(speedCounter_ + distance/300.0f);
+        }
+//         if (this->getControllableEntity()->getVelocity().squaredLength() > 50.0f) this->speedCounter_ = 0;
+*/
+    }
     void ArtificialController::setTargetPosition(const Vector3& target)
 …
+        {
             if (ArtificialController::sameTeam(this->getControllableEntity(), static_cast<ControllableEntity*>(*it), this->getGametype()))
+                continue;
+            /* So AI won't choose invisible Spaceships as target */
+            if (!it->getRadarVisibility())
                 continue;
 …
         this->bHasTargetPosition_ = (this->targetPosition_ != Vector3::ZERO);
         Pawn* pawn = dynamic_cast<Pawn*>(this->getControllableEntity());
+        Pawn* pawn = orxonox_cast<Pawn*>(this->getControllableEntity());
         if (pawn)
             pawn->setAimPosition(this->targetPosition_);
 …
         int team2 = -1;
+        if (entity1->getXMLController())
+        {
+            WaypointPatrolController* wpc = orxonox_cast<WaypointPatrolController*>(entity1->getXMLController());
+            if (wpc)
+                team1 = wpc->getTeam();
+        }
+        if (entity2->getXMLController())
+        {
+            WaypointPatrolController* wpc = orxonox_cast<WaypointPatrolController*>(entity2->getXMLController());
+            if (wpc)
+                team2 = wpc->getTeam();
+        Controller* controller = 0;
+        if (entity1->getController())
+            controller = entity1->getController();
+        else
+            controller = entity1->getXMLController();
+        if (controller)
+        {
+            ArtificialController* ac = orxonox_cast<ArtificialController*>(controller);
+            if (ac)
+                team1 = ac->getTeam();
+        }
+        if (entity2->getController())
+            controller = entity2->getController();
+        else
+            controller = entity2->getXMLController();
+        if (controller)
+        {
+            ArtificialController* ac = orxonox_cast<ArtificialController*>(controller);
+            if (ac)
+                team2 = ac->getTeam();
+        }
 …
+        }
+        DroneController* droneController = 0;
+        droneController = orxonox_cast<DroneController*>(entity1->getController());
+        if (droneController && static_cast<ControllableEntity*>(droneController->getOwner()) == entity2)
+            return true;
+        droneController = orxonox_cast<DroneController*>(entity2->getController());
+        if (droneController && static_cast<ControllableEntity*>(droneController->getOwner()) == entity1)
+            return true;
+        DroneController* droneController1 = orxonox_cast<DroneController*>(entity1->getController());
+        DroneController* droneController2 = orxonox_cast<DroneController*>(entity2->getController());
+        if (droneController1 && droneController2 && droneController1->getOwner() == droneController2->getOwner())
+            return true;
+        Dynamicmatch* dynamic = orxonox_cast<Dynamicmatch*>(gametype);
+        if (dynamic)
+        {
+            if (dynamic->notEnoughPigs||dynamic->notEnoughKillers||dynamic->notEnoughChasers) {return false;}
+            if (entity1->getPlayer())
+                team1 = dynamic->getParty(entity1->getPlayer());
+            if (entity2->getPlayer())
+                team2 = dynamic->getParty(entity2->getPlayer());
+            if (team1 ==-1 ||team2 ==-1 ) {return false;}
+            else if (team1 == dynamic->chaser && team2 != dynamic->chaser) {return false;}
+            else if (team1 == dynamic->piggy && team2 == dynamic->chaser) {return false;}
+            else if (team1 == dynamic->killer && team2 == dynamic->chaser) {return false;}
+            else return true;
+        }
         return (team1 == team2 && team1 != -1);
+    }

code/trunk/src/orxonox/controllers/ArtificialController.h

-                      r6417
+                      r7163
  *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
+ *      Dominik Solenicki
+ *
  */
 …
 #include "OrxonoxPrereqs.h"
+#include <vector>
 #include "util/Math.h"
 #include "Controller.h"
+#include "controllers/NewHumanController.h"
 namespace orxonox
 …
             virtual ~ArtificialController();
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             void abandonTarget(Pawn* target);
+            inline void setTeam(int team)
+                { this->team_ = team; }
+            inline int getTeam() const
+                { return this->team_; }
+            inline void setFormationFlight(bool formation)
+                { this->formationFlight_ = formation; }
+            inline bool getFormationFlight() const
+                { return this->formationFlight_; }
+            inline void setFormationSize(int size)
+                { this->maxFormationSize_ = size; }
+            inline int getFormationSize() const
+                { return this->maxFormationSize_; }
+            inline void setPassive(bool passive)
+                { this->passive_ = passive; }
+            inline bool getPassive() const
+                { return this->passive_; }
+            virtual void changedControllableEntity();
+            static void formationflight(const bool form);
+            static void masteraction(const int action);
+            static void followme();
+            static void passivebehaviour(const bool passive);
+            static void formationsize(const int size);
         protected:
+            void targetDied();
+            int team_;
+            bool formationFlight_;
+            bool passive_;
+            unsigned int maxFormationSize_;
+            int freedomCount_;
+            enum State {SLAVE, MASTER, FREE};
+            State state_;
+            std::vector<ArtificialController*> slaves_;
+            ArtificialController *myMaster_;
+            enum SpecificMasterAction {NONE, HOLD, SPIN, TURN180, FOLLOW};
+            SpecificMasterAction specificMasterAction_;
+            int specificMasterActionHoldCount_;
+            float speedCounter_; //for speed adjustment when following
             void moveToPosition(const Vector3& target);
             void moveToTargetPosition();
+            void removeFromFormation();
+            void unregisterSlave();
+            void searchNewMaster();
+            void commandSlaves();
+            void setNewMasterWithinFormation();
+            void freeSlaves();
+            void forceFreeSlaves();
+            void loseMasterState();
+            void forceFreedom();
+            bool forcedFree();
+            void specificMasterActionHold();
+            void turn180Init();
+            void turn180();
+            void spinInit();
+            void spin();
+            void followInit(Pawn* pawn, const bool always = false, const int secondsToFollow = 100);
+            void followRandomHumanInit();
+            void follow();
+            void followForSlaves(const Vector3& target);
             void setTargetPosition(const Vector3& target);
 …
             bool isCloseAtTarget(float distance) const;
             bool isLookingAtTarget(float angle) const;
+            void targetDied();
             static bool sameTeam(ControllableEntity* entity1, ControllableEntity* entity2, Gametype* gametype); // hack

code/trunk/src/orxonox/controllers/CMakeLists.txt

r6417	r7163
8	8	WaypointController.cc
9	9	WaypointPatrolController.cc
	10	DroneController.cc
10	11	)

code/trunk/src/orxonox/controllers/HumanController.cc

-                      r6417
+                      r7163
 #include "gametypes/Gametype.h"
 #include "infos/PlayerInfo.h"
-#include "overlays/Map.h"
 #include "Radar.h"
 #include "Scene.h"
 …
     void HumanController::yaw(const Vector2& value)
+    {
-        //Hack to enable mouselook in map
-        if ( Map::getSingletonPtr() && Map::getSingletonPtr()->getVisibility() && HumanController::localController_s->controllableEntity_->isInMouseLook() )
+        {
-            Map::getSingletonPtr()->rotateYaw(value);
-            return;
+        }
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
             HumanController::localController_s->controllableEntity_->rotateYaw(value);
 …
     void HumanController::pitch(const Vector2& value)
+    {
-        //Hack to enable mouselook in map
-        if ( Map::getSingletonPtr() && Map::getSingletonPtr()->getVisibility() && HumanController::localController_s->controllableEntity_->isInMouseLook() )
+        {
-            Map::getSingletonPtr()->rotatePitch(value);
-            return;
+        }
         if (HumanController::localController_s && HumanController::localController_s->controllableEntity_)
             HumanController::localController_s->controllableEntity_->rotatePitch(value);

code/trunk/src/orxonox/controllers/NewHumanController.cc

-                      r6598
+                      r7163
                     if (this->getControllableEntity() && (this->getControllableEntity()->isExactlyA(ClassByString("SpaceShip")) || this->getControllableEntity()->isExactlyA(ClassByString("Rocket"))))
                         this->showOverlays();
+                    else if (this->getControllableEntity() &&  this->getControllableEntity()->isExactlyA(ClassByString("FpsPlayer")))
+                    {
+                        this->showOverlays();
+                        this->hideArrows();
+                    }
                     this->crossHairOverlay_->setPosition(Vector2(static_cast<float>(this->currentYaw_)/2*-1+.5f-overlaySize_/2, static_cast<float>(this->currentPitch_)/2*-1+.5f-overlaySize_/2));
 …
         Ogre::RaySceneQueryResult& result = rsq->execute();
         Pawn* pawn = orxonox_cast<Pawn*>(this->getControllableEntity());
+        WorldEntity* myWe = static_cast<WorldEntity*>(this->getControllableEntity());
         Ogre::RaySceneQueryResult::iterator itr;
         for (itr = result.begin(); itr != result.end(); ++itr)
+        {
+            if (itr->movable->isInScene() && itr->movable->getMovableType() == "Entity" && itr->distance > 500)
+//             CCOUT(0) << "testing object as target" << endl;
+            if (itr->movable->isInScene() && itr->movable->getMovableType() == "Entity" /*&& itr->distance > 500*/)
+            {
                 // Try to cast the user pointer
+                WorldEntity* wePtr = dynamic_cast<WorldEntity*>(Ogre::any_cast<OrxonoxClass*>(itr->movable->getUserAny()));
+                WorldEntity* wePtr;
+                try
+                {
+                    wePtr = dynamic_cast<WorldEntity*>(Ogre::any_cast<OrxonoxClass*>(itr->movable->getUserAny()));
+                }
+                catch (...)
+                {
+                    continue;
+                }
+                // make sure we don't shoot ourselves
+                if( wePtr==myWe )
+                    continue;
                 if (wePtr)
+                {
 …
                     while (parent)
+                    {
                         if (this->targetMask_.isExcluded(parent->getIdentifier()))
+                        if (this->targetMask_.isExcluded(parent->getIdentifier()) || parent==myWe)
+                        {
                             parent = parent->getParent();
 …
             HumanController::yaw(value);
+        this->currentYaw_ = value.x;
+        if (this->getControllableEntity() && !this->getControllableEntity()->isExactlyA(ClassByString("FpsPlayer")))
+            this->currentYaw_ = value.x;
+    }
 …
             HumanController::pitch(value);
+        this->currentPitch_ = value.x;
+        if (this->getControllableEntity() && !this->getControllableEntity()->isExactlyA(ClassByString("FpsPlayer")))
+            this->currentPitch_ = value.x;
+    }
 …
+        }
+    }
+}

code/trunk/src/orxonox/controllers/NewHumanController.h

r6417	r7163
67	67	virtual void doResumeControl();
68	68
	69
69	70	protected:
70	71	void updateTarget();

code/trunk/src/orxonox/controllers/WaypointPatrolController.cc

-                      r6502
+                      r7163
         RegisterObject(WaypointPatrolController);
         this->team_ = 0;
+        //this->team_ = 0;
         this->alertnessradius_ = 500;
 …
         XMLPortParam(WaypointPatrolController, "alertnessradius", setAlertnessRadius, getAlertnessRadius, xmlelement, mode).defaultValues(500.0f);
         XMLPortParam(WaypointPatrolController, "team", setTeam, getTeam, xmlelement, mode).defaultValues(0);
+//        XMLPortParam(WaypointPatrolController, "team", setTeam, getTeam, xmlelement, mode).defaultValues(0);
+    }

code/trunk/src/orxonox/controllers/WaypointPatrolController.h

-                      r5929
+                      r7163
             virtual void tick(float dt);
             inline void setTeam(int team)
+           /* inline void setTeam(int team)
                 { this->team_ = team; }
             inline int getTeam() const
                 { return this->team_; }
+                { return this->team_; } */
             inline void setAlertnessRadius(float radius)
 …
             void searchEnemy();
             int team_;
+            //int team_;
             float alertnessradius_;
             Timer patrolTimer_;

code/trunk/src/orxonox/gamestates/GSClient.cc

r6426	r7163
40	40	DeclareGameState(GSClient, "client", false, false);
41	41
42		SetCommandLineArgument(~~ip, "127.0.0.1").information("Sever IP as string in the form #.#.#.#~~");
	42	SetCommandLineArgument(dest, "127.0.0.1").information("Server hostname/IP (IP in the form of #.#.#.#)");
43	43
44	44	GSClient::GSClient(const GameStateInfo& info)
45	45	: GameState(info)
46		~~, client_(0)~~
47	46	{
48	47	}
…	…
56	55	GameMode::setIsClient(true);
57	56
58		this->client_ = new Client(CommandLineParser::getValue("ip").getString(), CommandLineParser::getValue("port"));
	57	// this->client_ = new Client();
	58	// this->client_->setDestination(CommandLineParser::getValue("dest").getString(), CommandLineParser::getValue("port") );
59	59
60		if(~~!client_->establishConnection()~~)
	60	if( !Client::getInstance()->establishConnection() )
61	61	{
62		~~delete this->client_;~~
63	62	ThrowException(InitialisationFailed, "Could not establish connection with server.");
64	63	}
65	64
66		~~client_~~->update(Game::getInstance().getGameClock());
	65	Client::getInstance()->update(Game::getInstance().getGameClock());
67	66	}
68	67
69	68	void GSClient::deactivate()
70	69	{
71		~~client_~~->closeConnection();
	70	Client::getInstance()->closeConnection();
72	71
73	72	// destroy client
74		delete this->client_;
	73	// delete this->client_;
75	74
76	75	GameMode::setIsClient(false);
…	…
79	78	void GSClient::update(const Clock& time)
80	79	{
81		~~client_~~->update(time);
	80	Client::getInstance()->update(time);
82	81	}
83	82	}

code/trunk/src/orxonox/gamestates/GSClient.h

-                      r5929
+                      r7163
         void deactivate();
         void update(const Clock& time);
-    private:
-        Client* client_;
     };
+}

code/trunk/src/orxonox/gamestates/GSGraphics.cc

-                      r6417
+                      r7163
 #include "core/Game.h"
 #include "core/GUIManager.h"
-// HACK:
-#include "overlays/Map.h"
 namespace orxonox
 …
     void GSGraphics::deactivate()
+    {
+        // HACK: (destroys a resource smart pointer)
+        Map::hackDestroyMap();
+    }

code/trunk/src/orxonox/gametypes/CMakeLists.txt

r5781	r7163
6	6	UnderAttack.cc
7	7	Asteroids.cc
	8	Dynamicmatch.cc
8	9	)

code/trunk/src/orxonox/gametypes/Gametype.cc

-                      r6417
+                      r7163
         if (this->spawnpoints_.size() > 0)
+        {
+            SpawnPoint* fallbackSpawnPoint = NULL;
             unsigned int randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(this->spawnpoints_.size())));
             unsigned int index = 0;
+            std::set<SpawnPoint*> activeSpawnPoints = this->spawnpoints_;
             for (std::set<SpawnPoint*>::const_iterator it = this->spawnpoints_.begin(); it != this->spawnpoints_.end(); ++it)
+            {
+                if (index == randomspawn)
+                    fallbackSpawnPoint = (*it);
+                if (!(*it)->isActive())
+                    activeSpawnPoints.erase(*it);
+                ++index;
+            }
+            randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(this->spawnpoints_.size())));
+            index = 0;
+            for (std::set<SpawnPoint*>::const_iterator it = activeSpawnPoints.begin(); it != activeSpawnPoints.end(); ++it)
+            {
                 if (index == randomspawn)
 …
                 ++index;
+            }
+            return fallbackSpawnPoint;
+        }
         return 0;

code/trunk/src/orxonox/gametypes/TeamDeathmatch.cc

-                      r6417
+                      r7163
+        }
+        SpawnPoint* fallbackSpawnPoint = NULL;
         if (teamSpawnPoints.size() > 0)
+        {
             unsigned int randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
             unsigned int index = 0;
+            // Get random fallback spawnpoint in case there is no active SpawnPoint.
+            for (std::set<SpawnPoint*>::const_iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); ++it)
+            {
+                if (index == randomspawn)
+                {
+                    fallbackSpawnPoint = (*it);
+                    break;
+                }
+                ++index;
+            }
+            // Remove all inactive SpawnPoints from the list.
+            for (std::set<SpawnPoint*>::const_iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); )
+            {
+                if(!(*it)->isActive())
+                {
+                    teamSpawnPoints.erase(it++);
+                    continue;
+                }
+                ++it;
+            }
+            randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(teamSpawnPoints.size())));
+            index = 0;
             for (std::set<SpawnPoint*>::const_iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); ++it)
+            {
 …
                 ++index;
+            }
+            return fallbackSpawnPoint;
+        }

code/trunk/src/orxonox/graphics/Backlight.h

-                      r5781
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             virtual void tick(float dt);
 …
         private:
+            void registerVariables();
             virtual void startturnonoff();
             virtual void stopturnonoff();

code/trunk/src/orxonox/graphics/Billboard.h

-                      r5781
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             virtual void changedVisibility();
 …
         private:
+            void registerVariables();
             void changedMaterial();
 //            void changedRotation();

code/trunk/src/orxonox/graphics/BlinkingBillboard.cc

-                      r6417
+                      r7163
     void BlinkingBillboard::registerVariables()
+    {
+//        registerVariable(this->amplitude_, VariableDirection::ToClient);
+//        registerVariable(this->frequency_, VariableDirection::ToClient);
+//        registerVariable(this->phase_,     VariableDirection::ToClient);
+        unregisterVariable(this->getScale3D());
+        registerVariable(this->amplitude_,  VariableDirection::ToClient);
+        registerVariable(this->frequency_,  VariableDirection::ToClient);
+        registerVariable(this->phase_,      VariableDirection::ToClient);
+        registerVariable(this->bQuadratic_, VariableDirection::ToClient);
+    }
 …
         SUPER(BlinkingBillboard, tick, dt);
         if (GameMode::isMaster() && this->isActive())
+        if (this->isActive())
+        {
             this->time_ += dt;

code/trunk/src/orxonox/graphics/BlinkingBillboard.h

-                      r5781
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             virtual void tick(float dt);
 …
         private:
+            void registerVariables();
             float amplitude_;
             float frequency_;

code/trunk/src/orxonox/graphics/CMakeLists.txt

-                      r5929
+                      r7163
   FadingBillboard.cc
   GlobalShader.cc
+  MeshLodInformation.cc
   Model.cc
+  AnimatedModel.cc
   ParticleEmitter.cc
   ParticleSpawner.cc

code/trunk/src/orxonox/graphics/Camera.cc

r6501	r7163
111	111	SUPER(Camera, tick, dt);
112	112
113		if (this->bDrag_)
	113	if (this->bDrag_ && this->getTimeFactor() != 0)
114	114	{
115	115	// this stuff here may need some adjustments

code/trunk/src/orxonox/graphics/FadingBillboard.h

-                      r5929
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             virtual void tick(float dt);
 …
         protected:
+            void registerVariables();
             virtual void startturnonoff();
             virtual void stopturnonoff();

code/trunk/src/orxonox/graphics/GlobalShader.h

-                      r5781
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             virtual void changedVisibility();
 …
         private:
+            void registerVariables();
             void changedCompositor();

code/trunk/src/orxonox/graphics/Light.h

-                      r5781
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             virtual void changedVisibility();
 …
         private:
+            void registerVariables();
             void setTypeString(const std::string& type);
             std::string getTypeString() const;

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

-                      r5781
+                      r7163
 #include "core/XMLPort.h"
 #include "Scene.h"
+#include "graphics/MeshLodInformation.h"
+#include "Level.h"
 namespace orxonox
 …
     CreateFactory(Model);
+    Model::Model(BaseObject* creator) : StaticEntity(creator)
+    Model::Model(BaseObject* creator) :
+        StaticEntity(creator), bCastShadows_(true), lodLevel_(5), bLodEnabled_(true), numLodLevels_(10), lodReductionRate_(.15)
+    {
         RegisterObject(Model);
-        this->bCastShadows_ = true;
         this->registerVariables();
 …
         SUPER(Model, XMLPort, xmlelement, mode);
+        XMLPortParam(Model, "lodLevel", setLodLevel, getLodLevel, xmlelement, mode);
         XMLPortParam(Model, "mesh", setMeshSource, getMeshSource, xmlelement, mode);
         XMLPortParam(Model, "shadow", setCastShadows, getCastShadows, xmlelement, mode).defaultValues(true);
 …
         registerVariable(this->meshSrc_,    VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedMesh));
         registerVariable(this->bCastShadows_, VariableDirection::ToClient, new NetworkCallback<Model>(this, &Model::changedShadows));
+    }
+    float Model::getBiggestScale(Vector3 scale3d)
+    {
+        float scaleFactor = scale3d.x;
+        if(scale3d.y>scaleFactor)
+            scaleFactor = scale3d.y;
+        if(scale3d.z>scaleFactor)
+            scaleFactor = scale3d.z;
+        return scaleFactor;
+    }
 …
                 this->mesh_.getEntity()->setCastShadows(this->bCastShadows_);
                 this->mesh_.setVisible(this->isVisible());
+                //LOD
+                if( this->mesh_.getEntity()->getMesh()->getNumLodLevels()==1 )
+                {
+                    Level* level = this->getLevel();
+                    assert( level != 0 );
+                    MeshLodInformation* lodInfo = level->getLodInfo(this->meshSrc_);
+                    if( lodInfo )
+                    {
+                        setLodLevel(lodInfo->getLodLevel());
+                        this->bLodEnabled_ = lodInfo->getEnabled();
+                        this->numLodLevels_ = lodInfo->getNumLevels();
+                        this->lodReductionRate_ = lodInfo->getReductionRate();
+                    }
+                    if( this->numLodLevels_>10 )
+                    {
+                        CCOUT(2) << "More than 10 LoD levels requested. Creating only 10." << endl;
+                        this->numLodLevels_ = 10;
+                    }
+                    if( this->bLodEnabled_ )
+                    {
+                        float volume = this->mesh_.getEntity()->getBoundingBox().volume();
+    //                     float scaleFactor = 1;
+    //                     BaseObject* creatorPtr = this;
+    //
+    //                     while(creatorPtr!=NULL&&orxonox_cast<WorldEntity*>(creatorPtr))
+    //                     {
+    //                         scaleFactor *= getBiggestScale(((WorldEntity*) creatorPtr)->getScale3D());
+    //                         creatorPtr = creatorPtr->getCreator();
+    //                     }
+    //                     COUT(0) << "name: " << this->meshSrc_ << "scaleFactor: " << scaleFactor << ", volume: " << volume << endl;
+                        COUT(4) << "Setting lodLevel for " << this->meshSrc_<< " with lodLevel_: " << this->lodLevel_ <<" and volume: "<< volume << ":" << std::endl;
+#if OGRE_VERSION >= 0x010700
+                        Ogre::Mesh::LodValueList distList;
+#else
+                        Ogre::Mesh::LodDistanceList distList;
+#endif
+                        if( lodLevel_>0 )
+                        {
+    //                         float factor = scaleFactor*5/lodLevel_;
+                            float factor = pow(volume, 2.0f / 3.0f) * 15.0f / lodLevel_;
+                            COUT(4) << "LodLevel set with factor: " << factor << endl;
+                            distList.push_back(70.0f*factor);
+                            distList.push_back(140.0f*factor);
+                            distList.push_back(170.0f*factor);
+                            distList.push_back(200.0f*factor);
+                            distList.push_back(230.0f*factor);
+                            distList.push_back(250.0f*factor);
+                            distList.push_back(270.0f*factor);
+                            distList.push_back(290.0f*factor);
+                            distList.push_back(310.0f*factor);
+                            distList.push_back(330.0f*factor);
+                            while(distList.size()>this->numLodLevels_)
+                                distList.pop_back();
+                            //Generiert LOD-Levels
+                            this->mesh_.getEntity()->getMesh()->generateLodLevels(distList, Ogre::ProgressiveMesh::VRQ_PROPORTIONAL, this->lodReductionRate_);
+                        }
+                        else
+                        {
+                            std::string what;
+                            if(lodLevel_>5)
+                                what = ">5";
+                            else
+                                what = "<0";
+                            COUT(4)<<"LodLevel not set because lodLevel("<<lodLevel_<<") was "<<what<<"." << endl;
+                        }
+                    }
+                    else
+                        COUT(4) << "LodLevel for " << this->meshSrc_ << " not set because is disabled." << endl;
+                }
+            }
+        }

code/trunk/src/orxonox/graphics/Model.h

-                      r5781
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             virtual void changedVisibility();
 …
                 { return this->bCastShadows_; }
+        private:
+        protected:
+            void registerVariables();
             void changedMesh();
             void changedShadows();
+            //LoD
+            inline void setLodLevel(float lodLevel)
+                { this->lodLevel_ =  lodLevel; }
+            inline float getLodLevel() const
+                { return this->lodLevel_; }
+            float getBiggestScale(Vector3 scale3d);
             std::string meshSrc_;
             Mesh mesh_;
             bool bCastShadows_;
+            //LoD
+            float lodLevel_;
+            bool bLodEnabled_;
+            unsigned int numLodLevels_;
+            float lodReductionRate_;
     };
+}

code/trunk/src/orxonox/graphics/ParticleEmitter.h

-                      r5781
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             virtual void changedVisibility();
 …
             std::string        source_;
             LODParticle::Value   LOD_;
+        private:
+            void registerVariables();
     };
+}

code/trunk/src/orxonox/infos/GametypeInfo.cc

-                      r5781
+                      r7163
     registerMemberNetworkFunction(GametypeInfo, dispatchKillMessage);
     registerMemberNetworkFunction(GametypeInfo, dispatchDeathMessage);
+    registerMemberNetworkFunction(GametypeInfo, dispatchStaticMessage);
+    registerMemberNetworkFunction(GametypeInfo, dispatchFadingMessage);
     GametypeInfo::GametypeInfo(BaseObject* creator) : Info(creator)
 …
+    }
+    void GametypeInfo::sendStaticMessage(const std::string& message, unsigned int clientID, const ColourValue& colour)
+    {
+        if (GameMode::isMaster())
+        {
+            if (clientID == CLIENTID_SERVER)
+                this->dispatchStaticMessage(message, colour);
+            else
+                callMemberNetworkFunction(GametypeInfo, dispatchStaticMessage, this->getObjectID(), clientID, message, colour);
+        }
+    }
+    void GametypeInfo::sendFadingMessage(const std::string& message, unsigned int clientID)
+    {
+        if (GameMode::isMaster())
+        {
+            if (clientID == CLIENTID_SERVER)
+                this->dispatchFadingMessage(message);
+            else
+                callMemberNetworkFunction(GametypeInfo, dispatchFadingMessage, this->getObjectID(), clientID, message);
+        }
+    }
     void GametypeInfo::dispatchAnnounceMessage(const std::string& message)
+    {
 …
             it->deathmessage(this, message);
+    }
+     void GametypeInfo::dispatchStaticMessage(const std::string& message, const ColourValue& colour)
+    {
+        for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
+            it->staticmessage(this, message, colour);
+    }
+     void GametypeInfo::dispatchFadingMessage(const std::string& message)
+    {
+        for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
+            it->fadingmessage(this, message);
+    }
+}

code/trunk/src/orxonox/infos/GametypeInfo.h

-                      r5781
+                      r7163
             virtual ~GametypeInfo();
-            void registerVariables();
             inline bool hasStarted() const
                 { return this->bStarted_; }
 …
             void sendKillMessage(const std::string& message, unsigned int clientID);
             void sendDeathMessage(const std::string& message, unsigned int clientID);
+            void sendStaticMessage(const std::string& message, unsigned int clientID, const ColourValue& colour);
+            void sendFadingMessage(const std::string& message, unsigned int clientID);
             void dispatchAnnounceMessage(const std::string& message);
             void dispatchKillMessage(const std::string& message);
             void dispatchDeathMessage(const std::string& message);
+            void dispatchStaticMessage(const std::string& message,const ColourValue& colour);
+            void dispatchFadingMessage(const std::string& message);
         private:
+            void registerVariables();
             bool bStarted_;
             bool bEnded_;

code/trunk/src/orxonox/infos/HumanPlayer.h

-                      r5781
+                      r7163
             virtual ~HumanPlayer();
-            void registerVariables();
             void setConfigValues();
 …
             std::string gametypeHudTemplate_;
             OverlayGroup* gametypeHud_;
+        private:
+            void registerVariables();
     };
+}

code/trunk/src/orxonox/infos/PlayerInfo.cc

-                      r6417
+                      r7163
             return;
 //         assert( this->temporaryControllableEntity_==0 );
+        assert( this->oldControllableEntity_==0 );
         this->oldControllableEntity_ = this->controllableEntity_;
 …
         entity->setPlayer(this);
+        entity->setController(this->controller_);
         if (this->controller_)
 …
             return;
+        this->controllableEntity_->setController(0);
         this->controllableEntity_ = this->oldControllableEntity_;
         this->controllableEntityID_ = this->controllableEntity_->getObjectID();

code/trunk/src/orxonox/infos/PlayerInfo.h

-                      r6417
+                      r7163
 #include "core/SubclassIdentifier.h"
+namespace orxonox
+{
+    class _OrxonoxExport PlayerInfo : public Info
+    {
+namespace orxonox // tolua_export
+{ // tolua_export
+    class _OrxonoxExport PlayerInfo // tolua_export
+        : public Info
+    { // tolua_export
         public:
             PlayerInfo(BaseObject* creator);
             virtual ~PlayerInfo();
-            void registerVariables();
             virtual void changedName();
 …
         private:
+            void registerVariables();
             void networkcallback_changedcontrollableentityID();
             void networkcallback_changedgtinfoID();
 …
             const GametypeInfo* gtinfo_;
             unsigned int gtinfoID_;
     };
+}
+    }; // tolua_export
+} // tolua_export
 #endif /* _PlayerInfo_H__ */

code/trunk/src/orxonox/interfaces/GametypeMessageListener.h

r5781	r7163
44	44	virtual void killmessage(const GametypeInfo* gtinfo, const std::string& message) {}
45	45	virtual void deathmessage(const GametypeInfo* gtinfo, const std::string& message) {}
	46	virtual void staticmessage(const GametypeInfo* gtinfo, const std::string& message, const ColourValue& colour) {}
	47	virtual void fadingmessage(const GametypeInfo* gtinfo, const std::string& message) {}
46	48	};
47	49	}

code/trunk/src/orxonox/interfaces/InterfaceCompilation.cc

r6711	r7163
52	52	RegisterRootObject(GametypeMessageListener);
53	53	}
54
	54
55	55	//----------------------------
56	56	// PickupCarrier
…	…
59	59	{
60	60	RegisterRootObject(PickupCarrier);
61
62		~~this->setCarrierName("PickupCarrier");~~
63	61	}
64
	62
65	63	PickupCarrier::~PickupCarrier()
66	64	{
	65
	66	}
	67
	68	void PickupCarrier::preDestroy(void)
	69	{
67	70	std::set<Pickupable*>::iterator it = this->pickups_.begin();
	71	std::set<Pickupable*>::iterator temp;
68	72	while(it != this->pickups_.end())
69	73	{
70		(*(it++))->destroy();
	74	(*it)->carrierDestroyed();
	75	temp = it;
	76	it = this->pickups_.begin();
	77	if(it == temp) // Infinite loop avoidance, in case the pickup wasn't removed from the carrier somewhere in the carrierDestroy() procedure.
	78	{
	79	COUT(2) << "Oops. In a PickupCarrier, while cleaning up, a Pickupable (&" << (*temp) << ") didn't unregister itself as it should have." << std::endl;;
	80	it++;
	81	}
71	82	}
72	83
…	…
84	95	this->isForPlayer_ = true;
85	96	}
86
	97
87	98	//----------------------------
88	99	// RadarListener

code/trunk/src/orxonox/interfaces/NotificationListener.h

-                      r5929
+                      r7163
     class Notification;
+    /**
+    @brief
+        NotificationListener interface.
+    @author
+        Fabian 'x3n' Landau
+    */
     class _OrxonoxExport NotificationListener : virtual public OrxonoxClass
+    {

code/trunk/src/orxonox/interfaces/PickupCarrier.h

Property svn:eol-style set to native

-                      r6711
+                      r7163
 #include "core/OrxonoxClass.h"
 namespace orxonox // tolua_export
 { // tolua_export
+namespace orxonox
+{
     //! Forward-declarations.
 …
     class InvisiblePickup;
     class MetaPickup;
+    class DronePickup;
     class SpeedPickup;
 …
         Damian 'Mozork' Frick
     */
+    class _OrxonoxExport PickupCarrier  // tolua_export
+        : virtual public OrxonoxClass
+    { // tolua_export
+    class _OrxonoxExport PickupCarrier : virtual public OrxonoxClass
+    {
         //! So that the different Pickupables have full access to their PickupCarrier.
         friend class Pickupable;
         friend class PickupManager;
         //! Friends.
+        //! Friends.
         friend class Pickup;
         friend class HealthPickup;
         friend class InvisiblePickup;
         friend class MetaPickup;
+        friend class DronePickup;
         friend class SpeedPickup;
 …
             PickupCarrier(); //!< Constructor.
             virtual ~PickupCarrier(); //!< Destructor.
+            /**
+            @brief Can be called to pick up a Pickupable.
+            @param pickup A pointer to the Pickupable.
+            @return Returns true if the Pickupable was picked up, false if not.
+            */
+            bool pickup(Pickupable* pickup)
+                {
+                    bool pickedUp = this->pickups_.insert(pickup).second;
+                    if(pickedUp)
+                    {
+                        COUT(4) << "Picked up Pickupable " << pickup->getIdentifier()->getName() << "(&" << pickup << ")." << std::endl;
+                        pickup->pickedUp(this);
+                    }
+                    return pickedUp;
+                }
+            /**
+            @brief Can be called to drop a Pickupable.
+            @param pickup A pointer to the Pickupable.
+            @param drop If the Pickupable should just be removed from the PickupCarrier without further action, this can be set to false. true is default.
+            @return Returns true if the Pickupable has been dropped, false if not.
+            */
+            bool drop(Pickupable* pickup, bool drop = true)
+                {
+                    bool dropped = this->pickups_.erase(pickup) == 1;
+                    if(dropped && drop)
+                    {
+                        COUT(4) << "Dropping Pickupable " << pickup->getIdentifier()->getName() << "(&" << pickup << ")." << std::endl;
+                        pickup->dropped();
+                    }
+                    return dropped;
+                }
+            void preDestroy(void);
             /**
 …
             */
             virtual const Vector3& getCarrierPosition(void) = 0;
+            /**
+            @brief Get the name of this PickupCarrier.
+            @return Returns the name as a string.
+            */
+            const std::string& getCarrierName(void) { return this->carrierName_; } // tolua_export
+        protected:
+        protected:
             /**
             @brief Get all direct children of this PickupSpawner.
 …
             std::set<Pickupable*>& getPickups(void)
                 { return this->pickups_; }
+            /**
+            @brief Set the name of this PickupCarrier.
+                   The name needs to be set in the constructor of every class inheriting from PickupCarrier, by calling setCarrierName().
+            @param name The name to be set.
+            */
+            void setCarrierName(const std::string& name)
+                { this->carrierName_ = name; }
         private:
             std::set<Pickupable*> pickups_; //!< The list of Pickupables carried by this PickupCarrier.
+            std::string carrierName_; //!< The name of the PickupCarrier, as displayed in the PickupInventory.
             /**
+            @brief Get the number of carrier children this PickupCarrier has.
+            @return Returns the number of carrier children.
+            @brief Adds a Pickupable to the list of pickups that are carried by this PickupCarrier.
+            @param pickup A pointer to the pickup to be added.
+            @return Returns true if successfull, false if the Pickupable was already present.
             */
             unsigned int getNumCarrierChildren(void)
+            bool addPickup(Pickupable* pickup)
+                {
+                    std::vector<PickupCarrier*>* list = this->getCarrierChildren();
+                    unsigned int size = list->size();
+                    delete list;
+                    return size;
+                    COUT(4) << "Adding Pickupable (&" << pickup << ") to PickupCarrier (&" << this << ")" << std::endl;
+                    return this->pickups_.insert(pickup).second;
+                }
             /**
             @brief Get the index-th child of this PickupCarrier.
             @param index The index of the child to return.
             @return Returns the index-th child.
+            @brief Removes a Pickupable from the list of pickups that are carried by thsi PickupCarrier.
+            @param pickup A pointer to the pickup to be removed.
+            @return Returns true if successfull, false if the Pickupable was not present in the list.
             */
             PickupCarrier* getCarrierChild(unsigned int index)
+            bool removePickup(Pickupable* pickup)
+                {
+                    std::vector<PickupCarrier*>* list = this->getCarrierChildren();
+                    if(list->size() < index)
+                        return NULL;
+                    PickupCarrier* carrier = (*list)[index];
+                    delete list;
+                    return carrier;
+                    COUT(4) << "Removing Pickupable (&" << pickup << ") from PickupCarrier (&" << this << ")" << std::endl;
+                    return this->pickups_.erase(pickup) == 1;
+                }
+            /**
+            @brief Get the number of Pickupables this PickupCarrier carries.
+            @return returns the number of pickups.
+            */
+            unsigned int getNumPickups(void)
+                { return this->pickups_.size(); }
+            /**
+            @brief Get the index-th Pickupable of this PickupCarrier.
+            @param index The index of the Pickupable to return.
+            @return Returns the index-th pickup.
+            */
+            Pickupable* getPickup(unsigned int index)
+                {
+                    std::set<Pickupable*>::iterator it;
+                    for(it = this->pickups_.begin(); index != 0 && it != this->pickups_.end(); it++)
+                        index--;
+                    if(it == this->pickups_.end())
+                        return NULL;
+                    return *it;
+                }
+    }; // tolua_export
+} // tolua_export
+    };
+}
 #endif /* _PickupCarrier_H__ */

code/trunk/src/orxonox/interfaces/Pickupable.cc

Property svn:eol-style set to native

-                      r6901
+                      r7163
 #include "Pickupable.h"
+#include "core/LuaState.h"
+#include "core/GUIManager.h"
 #include "core/Identifier.h"
 #include "core/CoreIncludes.h"
+#include "util/Convert.h"
+#include "infos/PlayerInfo.h"
 #include "pickup/PickupIdentifier.h"
+#include "worldentities/pawns/Pawn.h"
 #include "PickupCarrier.h"
 namespace orxonox
+{
     /**
     @brief
 …
     */
     Pickupable::Pickupable() : pickupIdentifier_(NULL), used_(false), pickedUp_(false)
+    {
+    {
         RegisterRootObject(Pickupable);
         this->carrier_ = NULL;
         this->pickupIdentifier_ = new PickupIdentifier(this);
+    }
+    /**
+    @brief
+        Destructor.
+        this->beingDestroyed_ = false;
+        this->enabled_ = true;
+    }
+    /**
+    @brief
+        Destructor.
     */
     Pickupable::~Pickupable()
+    {
+        if(this->isUsed())
+            this->setUsed(false);
+        if(this->isPickedUp() && this->getCarrier() != NULL)
+        {
+            this->getCarrier()->drop(this, false);
+            this->setCarrier(NULL);
+        }
+        COUT(4) << "Pickupable (" << this->getIdentifier()->getName() << ") (&" << this << ") destroyed." << std::endl;
         if(this->pickupIdentifier_ != NULL)
             this->pickupIdentifier_->destroy();
+    }
+    /**
+    @brief
+        A method that is called by OrxonoxClass::destroy() before the object is actually destroyed.
+    */
+    void Pickupable::preDestroy(void)
+    {
+        this->beingDestroyed_ = true;
+        if(this->isPickedUp())
+            this->drop(false); // Drops the pickup without creating a PickupSpawner.
+    }
+    /**
+    @brief
+        Is called internally within the pickup module to destroy pickups.
+    */
+    void Pickupable::destroy(void)
+    {
+        this->destroyPickup();
+    }
+    /**
+    @brief
+        Destroys a Pickupable.
+        If the Pickupable is already in the process of being destroyed a warning is displayed and this method is skipped.
+    */
+    void Pickupable::destroyPickup(void)
+    {
+        if(!this->beingDestroyed_)
+            this->OrxonoxClass::destroy();
+        else
+            COUT(2) << this->getIdentifier()->getName() << " may be unsafe. " << std::endl;
+    }
     /**
     @brief
 …
     bool Pickupable::setUsed(bool used)
+    {
+        if(this->used_ == used)
+            return false;
+        if(this->used_ == used || !this->isPickedUp()) // If either the used status of the Pickupable doesn't change or it isn't picked up.
+            return false;
+        if((!this->isUsable() && used) || (!this->isUnusable() && !used)) // If either the Pickupable is requested to be used but it is not usable or the Pickupable is requested to be unused, while it is not unusable.
+            return false;
         COUT(4) << "Pickupable (&" << this << ") set to used " << used << "." << std::endl;
         this->used_ = used;
         this->changedUsed();
+        return true;
+    }
+        GUIManager::getInstance().getLuaState()->doString("PickupInventory.update()");
+        return true;
+    }
     /**
     @brief
 …
         if(carrier == NULL)
             return false;
         return this->isTarget(carrier->getIdentifier());
+    }
     /**
     @brief
 …
                 return true;
+        }
         return false;
+    }
     /**
     @brief
 …
         return this->addTarget(target->getIdentifier());
+    }
     /**
     @brief
 …
         if(this->isTarget(target)) //!< If the input target is already present in the list of targets.
             return false;
         COUT(4) << "Target " << target->getName() << " added to Pickupable (&" << this << ")." << std::endl;
         this->targets_.push_back(target);
         return true;
+    }
+    /**
+    @brief
+        Sets the Pickupable to picked up.
+        This method will be called by the PickupCarrier picking the Pickupable up.
+    /**
+    @brief
+        Can be called to pick up a Pickupable.
     @param carrier
+        The PickupCarrier that picked the Pickupable up.
+    @return
+        Returns false if, for some reason, the pickup could not be picked up, e.g. it was picked up already.
+    */
+    bool Pickupable::pickedUp(PickupCarrier* carrier)
+    {
+        if(this->isPickedUp()) //!< If the Pickupable is already picked up.
+            return false;
+        A pointer to the PickupCarrier that picks up the Pickupable.
+    @return
+        Returns true if the Pickupable was picked up, false if not.
+    */
+    bool Pickupable::pickup(PickupCarrier* carrier)
+    {
+        if(carrier == NULL || this->isPickedUp()) //!< If carrier is NULL or the Pickupable is already picked up.
+            return false;
+        if(!this->setCarrier(carrier))
+        {
+            COUT(3) << "A Pickupable (&" << this << ") was trying to be added to a PickupCarrier, but was already present." << std::endl;
+            return false;
+        }
+        this->setPickedUp(true);
         COUT(4) << "Pickupable (&" << this << ") got picked up by a PickupCarrier (&" << carrier << ")." << std::endl;
+        this->setCarrier(carrier);
+        this->setPickedUp(true);
+        return true;
+    }
+        return true;
+    }
+    /**
+    @brief
+        Can be called to drop a Pickupable.
+    @param createSpawner
+        If true a spawner is to be created for the dropped Pickupable. True is default.
+    @return
+        Returns true if the Pickupable has been dropped, false if not.
+    */
+    bool Pickupable::drop(bool createSpawner)
+    {
+        if(!this->isPickedUp()) // If the Pickupable is not picked up.
+            return false;
+        assert(this->getCarrier()); // The Carrier cannot be NULL at this point.
+        if(!this->getCarrier()->removePickup(this)) //TODO Shouldn't this be a little later?
+            COUT(2) << "Pickupable (&" << this << ", " << this->getIdentifier()->getName() << ") is being dropped, but it was not present in the PickupCarriers list of pickups." << std::endl;
+        COUT(4) << "Pickupable (&" << this << ") got dropped up by a PickupCarrier (&" << this->getCarrier() << ")." << std::endl;
+        this->setUsed(false);
+        this->setPickedUp(false);
+        bool created = false;
+        if(createSpawner)
+            created = this->createSpawner();
+        this->setCarrier(NULL);
+        if(!created && createSpawner) // If a PickupSpawner should have been created but wasn't.
+            this->destroy();
+        return true;
+    }
     /**
     @brief
 …
     bool Pickupable::setPickedUp(bool pickedUp)
+    {
         if(this->pickedUp_ == pickedUp)
             return false;
+        if(this->pickedUp_ == pickedUp) // If the picked up status has not changed.
+            return false;
         COUT(4) << "Pickupable (&" << this << ") set to pickedUp " << pickedUp << "." << std::endl;
         this->pickedUp_ = pickedUp;
+        if(!pickedUp) // if the Pickupable has been dropped it unregisters itself with its PickupCarrier.
+            this->getCarrier()->removePickup(this);
         this->changedPickedUp();
+        return true;
+    }
+        GUIManager::getInstance().getLuaState()->doString("PickupInventory.update()");
+        return true;
+    }
     /**
     @brief
 …
     @param carrier
         Sets the input PickupCarrier as the carrier of the pickup.
+    */
+    inline bool Pickupable::setCarrier(PickupCarrier* carrier)
+    {
+        if(this->carrier_ == carrier)
+            return false;
+    @param tell
+        If true (default) the pickup is added to the list of pickups in the PickupCarrier.
+    @return
+        Returns true if successful, false if not.
+    */
+    bool Pickupable::setCarrier(orxonox::PickupCarrier* carrier, bool tell)
+    {
+        if(this->carrier_ == carrier) // If the PickupCarrier doesn't change.
+            return false;
         COUT(4) << "Pickupable (&" << this << ") changed Carrier (& " << carrier << ")." << std::endl;
+        if(carrier != NULL && tell)
+        {
+            if(!carrier->addPickup(this))
+                return false;
+        }
         this->carrier_ = carrier;
 …
         return true;
+    }
+    /**
+    @brief
+        Sets the Pickupable to not picked up or dropped.
+        This method will be called by the PickupCarrier dropping the Pickupable.
+    @return
+        Returns false if the pickup could not be dropped.
+    */
+    bool Pickupable::dropped(void)
+    {
+        if(!this->isPickedUp()) //!< If the Pickupable is not picked up.
+            return false;
+        COUT(4) << "Pickupable (&" << this << ") got dropped up by a PickupCarrier (&" << this->getCarrier() << ")." << std::endl;
+        this->setUsed(false);
+        this->setPickedUp(false);
+        bool created = this->createSpawner();
+        this->setCarrier(NULL);
+        if(!created)
+        {
+            this->destroy();
+        }
+        return true;
+    }
+    /**
+    @brief
+        Is called by the PickupCarrier when it is being destroyed.
+    */
+    void Pickupable::carrierDestroyed(void)
+    {
+        this->destroy();
+    }
     /**
     @brief
 …
         OrxonoxClass* item = NULL;
         this->clone(item);
         Pickupable* pickup = dynamic_cast<Pickupable*>(item);
         COUT(4) << "Pickupable (&" << this << ") cloned. Clone is new Pickupable (&" << pickup << ")." << std::endl;
         return pickup;
+    }
     /**
     @brief
 …
         SUPER(Pickupable, clone, item);
+    }
+    /**
+    @brief
+        Method to transcribe a Pickupable as a Rewardable to the player.
+    @param player
+        A pointer to the PlayerInfo, do whatever you want with it.
+    @return
+        Return true if successful.
+    */
+    bool Pickupable::reward(PlayerInfo* player)
+    {
+        ControllableEntity* entity = player->getControllableEntity();
+        Pawn* pawn = static_cast<Pawn*>(entity);
+        PickupCarrier* carrier = static_cast<PickupCarrier*>(pawn);
+        return this->pickup(carrier);
+    }
+}

code/trunk/src/orxonox/interfaces/Pickupable.h

Property svn:eol-style set to native

-                      r6901
+                      r7163
 #include "core/OrxonoxClass.h"
+#include "Rewardable.h"
 namespace orxonox
+{
+namespace orxonox // tolua_export
+{ // tolua_export
     /**
     @brief
 …
         Damian 'Mozork' Frick
     */
+    class _OrxonoxExport Pickupable : virtual public OrxonoxClass
+    {
+    class _OrxonoxExport Pickupable  // tolua_export
+        : virtual public OrxonoxClass, public Rewardable
+    {  // tolua_export
         protected:
             Pickupable(); //!< Default constructor.
         public:
             virtual ~Pickupable(); //!< Default destructor.
             /**
             @brief Get whether the pickup is currently in use or not.
             @return Returns true if the pickup is currently in use.
             */
+            inline bool isUsed(void)
+                { return this->used_; }
+            inline bool isUsed(void) { return this->used_; }  // tolua_export
             /**
             @brief  Should be called when the pickup has transited from used to unused or the other way around.
 …
             */
             virtual void changedUsed(void) {}
             /**
             @brief Get the carrier of the pickup.
 …
             */
             virtual void changedCarrier(void) {}
             /**
             @brief Returns whether the Pickupable is currently picked up.
             @return Returns true if the Pickupable is currently picked up, false if not.
             */
+            inline bool isPickedUp(void)
+                { return this->pickedUp_; }
+            inline bool isPickedUp(void) { return this->pickedUp_; }  // tolua_export
             /**
             @brief  Should be called when the pickup has transited from picked up to dropped or the other way around.
 …
             */
             virtual void changedPickedUp(void) {}
+            /**
+            @brief Returns whether the Pickupable can be used.
+            @return Returns true if it can be used.
+            */
+            inline bool isUsable(void) { return this->enabled_; } // tolua_export
+            bool pickedUp(PickupCarrier* carrier); //!< Sets the Pickupable to picked up.
+            bool dropped(void); //!< Sets the Pickupable to not picked up or dropped.
+            /**
+            @brief Returns whether the Pickupable can be unused.
+            @return Returns true if it can be unused.
+            */
+            inline bool isUnusable(void) { return this->enabled_; } // tolua_export
+            /**
+            @brief Returns whether the Pickupable is enabled.
+                   Once a Pickupable is disabled it cannot be enabled again. A Pickupable that is disabled can neither be used nor unused.
+            @return Returns true if the Pickupable is enabled.
+            */
+            inline bool isEnabled(void)
+                { return this->enabled_; }
+            bool pickup(PickupCarrier* carrier); //!< Can be called to pick up a Pickupable.
+            bool drop(bool createSpawner = true); //!< Can be called to drop a Pickupable.
             virtual bool isTarget(PickupCarrier* carrier) const; //!< Get whether the given PickupCarrier is a target of this pickup.
             bool isTarget(const Identifier* identifier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this Pickupable.
             bool addTarget(PickupCarrier* target); //!< Add a PickupCarrier as target of this pickup.
             bool addTarget(Identifier* identifier); //!< Add a class, representetd by the input Identifier, as target of this pickup.
             Pickupable* clone(void); //!< Creates a duplicate of the Pickupable.
             virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             /**
             @brief Get the PickupIdentifier of this Pickupable.
 …
             virtual const PickupIdentifier* getPickupIdentifier(void)
                 { return this->pickupIdentifier_; }
             bool setUsed(bool used); //!< Sets the Pickupable to used or unused, depending on the input.
             bool setPickedUp(bool pickedUp); //!< Helper method to set the Pickupable to either picked up or not picked up.
+            bool setCarrier(PickupCarrier* carrier); //!< Sets the carrier of the pickup.
+            //TODO: private?
+            bool setCarrier(PickupCarrier* carrier, bool tell = true); //!< Sets the carrier of the pickup.
+            //TODO: private?
+            virtual void carrierDestroyed(void); //!< Is called by the PickupCarrier when it is being destroyed.
+            void destroy(void); //!< Is called internally within the pickup module to destroy pickups.
         protected:
             /**
 …
             */
             void initializeIdentifier(void) {}
+            virtual void preDestroy(void); //!< A method that is called by OrxonoxClass::destroy() before the object is actually destroyed.
+            virtual void destroyPickup(void); //!< Destroys a Pickupable.
+            /**
+            @brief Sets the Pickuapble to disabled.
+            */
+            inline void setDisabled(void)
+                { this->enabled_ = false; }
             /**
             @brief Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
 …
             */
             virtual bool createSpawner(void) = 0;
             PickupIdentifier* pickupIdentifier_; //!< The PickupIdentifier of this Pickupable.
         private:
-            bool used_; //!< Whether the pickup is currently in use or not.
-            bool pickedUp_; //!< Whether the pickup is currently picked up or not.
-            PickupCarrier* carrier_; //!< The carrier of the pickup.
-            std::list<Identifier*> targets_; //!< The possible targets of this pickup.
+    };
+            bool used_; //!< Whether the Pickupable is currently in use or not.
+            bool pickedUp_; //!< Whether the Pickupable is currently picked up or not.
+            bool enabled_; //!< Whether the Pickupable is enabled or not.
+            PickupCarrier* carrier_; //!< The PickupCarrier of the Pickupable.
+            std::list<Identifier*> targets_; //!< The possible targets of this Pickupable.
+            bool beingDestroyed_; //!< Is true if the Pickupable is in the process of being destroyed.
+        // For implementing the Rewardable interface:
+        public:
+            virtual bool reward(PlayerInfo* player); //!< Method to transcribe a Pickupable as a Rewardable to the player.
+    };  // tolua_export
     SUPER_FUNCTION(10, Pickupable, changedUsed, false);
     SUPER_FUNCTION(12, Pickupable, changedCarrier, false);
     SUPER_FUNCTION(13, Pickupable, changedPickedUp, false);
+}
+}  // tolua_export
 #endif /* _Pickupable_H__ */

code/trunk/src/orxonox/interfaces/RadarListener.h

-                      r5781
+                      r7163
         virtual ~RadarListener() { }
+        virtual void displayObject(RadarViewable* viewable, bool bIsMarked) = 0;
+        virtual void addObject(RadarViewable* viewable) = 0;
+        virtual void removeObject(RadarViewable* viewable) = 0;
+        virtual void objectChanged(RadarViewable* viewable) = 0;
         virtual float getRadarSensitivity() const = 0;
         virtual void radarTick(float dt) = 0;

code/trunk/src/orxonox/interfaces/RadarViewable.cc

-                      r6417
+                      r7163
 #include "RadarViewable.h"
-#include <OgreSceneManager.h>
-#include <OgreSceneNode.h>
-#include <OgreEntity.h>
 #include "util/StringUtils.h"
 #include "core/CoreIncludes.h"
 #include "tools/DynamicLines.h"
+#include "core/GameMode.h"
 #include "worldentities/WorldEntity.h"
 #include "Radar.h"
 #include "Scene.h"
-#include "overlays/Map.h"
 namespace orxonox
 …
         @brief Constructor.
     */
+    RadarViewable::RadarViewable()
+        : MapNode_(NULL)
+        , MapEntity_(NULL)
+        , line_(NULL)
+        , LineNode_(NULL)
+        , isHumanShip_(false)
+    RadarViewable::RadarViewable(BaseObject* creator, const WorldEntity* wePtr)
+        : isHumanShip_(false)
         , bVisibility_(true)
+        , bInitialized_(false)
+        , creator_(creator)
+        , wePtr_(wePtr)
         , radarObjectCamouflage_(0.0f)
         , radarObjectShape_(Dot)
 …
         this->uniqueId_=getUniqueNumberString();
+/*
+        if(Map::getSingletonPtr() && Map::getSingletonPtr()->getMapSceneManagerPtr())
+        if( GameMode::showsGraphics() )
+        {
+            this->addEntity();
+            this->radar_ = this->creator_->getScene()->getRadar();
+            this->radar_->addRadarObject(this);
+        }
+        */
+        this->bInitialized_ = true;
+    }
 …
     RadarViewable::~RadarViewable()
+    {
-        if (this->isHumanShip_ && MapNode_)
-            MapNode_->removeAllChildren();
+        if (MapNode_)
+            delete MapNode_;
+        if (MapEntity_)
+            delete MapEntity_;
+        if (line_)
+            delete line_;
+        if (LineNode_)
+            delete LineNode_;
+    }
+    void RadarViewable::addMapEntity()
+    { //TODO Check shape and add accordantly
+        if( this->MapNode_ && !this->MapEntity_ && Map::getSingletonPtr() && Map::getSingletonPtr()->getMapSceneManagerPtr() )
+        if( this->bInitialized_ )
+        {
+            COUT(0) << "Adding " << this->uniqueId_ << " to Map.\n";
+            this->MapEntity_ = Map::getSingletonPtr()->getMapSceneManagerPtr()->createEntity( this->uniqueId_, "drone.mesh");
+            /*this->line_ =  Map::getSingletonPtr()->getMapSceneManagerPtr()->createManualObject(this->uniqueId_ + "_l");
+            this->line_->begin("Map/line_", Ogre::RenderOperation::OT_LINE_STRIP);
+            //line_->position(0, -it->getRVWorldPosition().y, 0);
+            //this->line_->position(0, -20, 0);
+            this->line_->position(0, 0, -10); //Front Arrow
+            this->line_->position(0, 0, 0);
+            this->line_->end(); */
+            this->line_ = new Ogre::DynamicLines(Ogre::RenderOperation::OT_LINE_LIST);
+            this->line_->addPoint( Vector3(0,0,0) );
+            this->line_->addPoint( Vector3(0,0,0) );
+            this->MapNode_->attachObject( this->MapEntity_ );
+            this->LineNode_ = this->MapNode_->createChildSceneNode();
+            this->LineNode_->attachObject( this->line_ );
+        }
+        else
+        {
+            COUT(0) << "Unable to load " << this->uniqueId_ << " to Map.\n";
+            if( GameMode::showsGraphics() )
+            {
+                this->radar_->removeRadarObject(this);
+            }
+        }
+    }
+    void RadarViewable::updateMapPosition()
+    {
+        if( this->MapNode_ )
+        {
+            this->MapNode_->setPosition( this->getRVWorldPosition() );
+            this->MapNode_->translate( this->getRVOrientedVelocity(), static_cast<Ogre::Node::TransformSpace>(3) );
+            this->MapNode_->setOrientation( this->getWorldEntity()->getOrientation() );
+//Vector3 v = this->getRVWorldPosition();
+            //this->line_->setPoint(1, Vector3(0,v.y,0) );
+            this->line_->setPoint(1, Vector3( 0, static_cast<float>(static_cast<int>( -Map::getSingletonPtr()->movablePlane_->getDistance( this->getRVWorldPosition() ) ) ) ,0 ));
+            this->line_->update();
+            if( Map::getSingletonPtr()->playerShipNode_ )
+                this->LineNode_->setDirection( Map::getSingletonPtr()->playerShipNode_->getLocalAxes().GetColumn(1) ,Ogre::Node::TS_WORLD,Vector3::UNIT_Y);
+        }
+    }
+    void RadarViewable::setRadarObjectDescription(const std::string& str)
+    {
+        Radar* radar = this->getWorldEntity()->getScene()->getRadar();
+        if (radar)
+            this->radarObjectShape_ = radar->addObjectDescription(str);
+        else
+        {
+            CCOUT(2) << "Attempting to access the radar, but the radar is non existent." << std::endl;
+        }
+        this->radarObjectDescription_ = str;
+    }
+//     void RadarViewable::setRadarObjectDescription(const std::string& str)
+//     {
+//         Radar* radar = this->getWorldEntity()->getScene()->getRadar();
+//         if (radar)
+//             this->radarObjectShape_ = radar->addObjectDescription(str);
+//         else
+//         {
+//             CCOUT(2) << "Attempting to access the radar, but the radar is non existent." << std::endl;
+//         }
+//         this->radarObjectDescription_ = str;
+//     }
     const Vector3& RadarViewable::getRVWorldPosition() const
 …
+        }
+    }
+    void RadarViewable::settingsChanged()
+    {
+        if( GameMode::showsGraphics() )
+        {
+            this->radar_->radarObjectChanged(this);
+        }
+    }
+}

code/trunk/src/orxonox/interfaces/RadarViewable.h

-                      r5781
+                      r7163
 #include "util/Math.h"
-#include "util/OgreForwardRefs.h"
 #include "core/OrxonoxClass.h"
+#include "core/SmartPtr.h"
 namespace orxonox
+{
+    class BaseObject;
     /**
     @brief Interface for receiving window events.
 …
     public:
         RadarViewable();
+        RadarViewable(BaseObject* creator, const WorldEntity* wePtr);
         virtual ~RadarViewable();
         inline void setRadarObjectCamouflage(float camouflage)
+            { this->radarObjectCamouflage_ = camouflage; }
+            {
+                if( this->radarObjectCamouflage_ != camouflage )
+                {
+                    this->radarObjectCamouflage_ = camouflage;
+                    this->settingsChanged();
+                }
+            }
         inline float getRadarObjectCamouflage() const
             { return this->radarObjectCamouflage_; }
         inline void setRadarObjectColour(const ColourValue& colour)
+            { this->radarObjectColour_ = colour; }
+            {
+                if(this->radarObjectColour_ != colour)
+                {
+                    this->radarObjectColour_ = colour;
+                    this->settingsChanged();
+                }
+            }
         inline const ColourValue& getRadarObjectColour() const
             { return this->radarObjectColour_; }
         void setRadarObjectDescription(const std::string& str);
         inline const std::string& getRadarObjectDescription() const
             { return this->radarObjectDescription_; }
+//         void setRadarObjectDescription(const std::string& str);
+//         inline const std::string& getRadarObjectDescription() const
+//             { return this->radarObjectDescription_; }
         inline void setRadarVisibility(bool b)
+            { this->bVisibility_ = b; }
+            {
+                if(b!=this->bVisibility_)
+                {
+                    this->bVisibility_ = b;
+                    this->settingsChanged();
+                }
+            }
         inline bool getRadarVisibility() const
             { return this->bVisibility_; }
         virtual const WorldEntity* getWorldEntity() const = 0;
+        virtual const WorldEntity* getWorldEntity() const{ return this->wePtr_; }
         const Vector3& getRVWorldPosition() const;
 …
         inline void setRadarObjectShape(Shape shape)
+            { this->radarObjectShape_ = shape; }
+            {
+                if( this->radarObjectShape_ != shape )
+                {
+                    this->radarObjectShape_ = shape;
+                    this->settingsChanged();
+                }
+            }
         inline Shape getRadarObjectShape() const
             { return this->radarObjectShape_; }
+        void settingsChanged();
+/*
+        inline void setMapNode(Ogre::SceneNode * node)
+            { this->MapNode_ = node; }
+        inline Ogre::SceneNode * getMapNode() const
+            { return this->MapNode_; }
+        inline void setMapEntity(Ogre::Entity * ent)
+            { this->MapEntity_ = ent; }
+        inline Ogre::Entity * getMapEntity() const
+            { return this->MapEntity_; }
+*/
+        //Used for Map
+        Ogre::SceneNode * MapNode_;
+        Ogre::Entity * MapEntity_;
+        Ogre::DynamicLines* line_;
+        Ogre::SceneNode * LineNode_;
+        void addMapEntity();
+        void updateMapPosition();
         bool isHumanShip_;
         inline const std::string& getUniqueId()
 …
         void validate(const WorldEntity* object) const;
         bool bVisibility_;
+        bool bInitialized_;
         //Map
         std::string uniqueId_;
+        BaseObject* creator_;
         //Radar
+        const WorldEntity* wePtr_;
+        SmartPtr<Radar> radar_;
         float radarObjectCamouflage_;
         Shape radarObjectShape_;

code/trunk/src/orxonox/interfaces/Rewardable.h

-                      r6417
+                      r7163
         Damian 'Mozork' Frick
     */
     class _OrxonoxExport Rewardable : public OrxonoxClass
+    class _OrxonoxExport Rewardable : virtual public OrxonoxClass
+    {
         public:
 …
                 Must be implemented by every class inheriting from Rewardable.
             @param player
                 A pointer to the ControllableEntity, do whatever you want with it.
+                A pointer to the PlayerInfo, do whatever you want with it.
             @return
                 Return true if successful.

code/trunk/src/orxonox/items/Engine.cc

r6711	r7163
64	64	this->boostBlur_ = 0;
65	65
66		~~this->setCarrierName("Engine");~~
67	66	this->speedAdd_ = 0.0;
68	67	this->speedMultiply_ = 1.0;

code/trunk/src/orxonox/items/Engine.h

-                      r6711
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             void setConfigValues();
 …
         private:
+            void registerVariables();
             void networkcallback_shipID();

code/trunk/src/orxonox/items/MultiStateEngine.h

-                      r6417
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             virtual void tick(float dt);
 …
         private:
+            void registerVariables();
             int state_;
             int oldState_;

code/trunk/src/orxonox/overlays/CMakeLists.txt

-                      r6746
+                      r7163
   OverlayGroup.cc
 COMPILATION_BEGIN OverlayCompilation.cc
+#COMPILATION_BEGIN OverlayCompilation.cc
   InGameConsole.cc
+  Map.cc
+COMPILATION_END
+#COMPILATION_END
+)

code/trunk/src/orxonox/overlays/GUISheet.cc

r6746	r7163
32	32	#include "core/GUIManager.h"
33	33	#include "core/XMLPort.h"
	34	#include "core/GameMode.h"
34	35
35	36	namespace orxonox

code/trunk/src/orxonox/pickup/PickupIdentifier.cc

Property svn:eol-style set to native

r6725	r7163
39	39	namespace orxonox
40	40	{
41
	41
42	42	/**
43	43	@brief
…	…
47	47	{
48	48	RegisterRootObject(PickupIdentifier);
49
	49
50	50	if(pickup == NULL)
51	51	COUT(1) << "Error, PickupIdentifier was created without a valid Pickupable." << std::endl;
52
	52
53	53	this->pickup_ = pickup;
54	54	}
55
	55
56	56	PickupIdentifier::~PickupIdentifier()
57	57	{
58	58
59	59	}
60
	60
61	61	/**
62	62	@brief
…	…
74	74	COUT(1) << "Error in PickupIdentifier::compare: Input Identifier is NULL." << std::endl;
75	75	}
76
	76
77	77	if(identifier->pickup_ == NULL && this->pickup_ == NULL)
78	78	{
…	…
80	80	COUT(1) << "Error in PickupIdentifier::compare: Pickup stored by Identifier is NULL." << std::endl;
81	81	}
82
	82
83	83	if(identifier->pickup_ == NULL)
84	84	{
…	…
86	86	COUT(1) << "Error in PickupIdentifier::compare: Pickup stored by Identifier is NULL." << std::endl;
87	87	}
88
	88
89	89	if(this->pickup_ == NULL)
90	90	{
…	…
92	92	COUT(1) << "Error in PickupIdentifier::compare: Pickup stored by Identifier is NULL." << std::endl;
93	93	}
94
	94
95	95	//! If the classIdentifiers are not the same (meaning the PickupIdentifiers identify different classes), the obviously the two Pickupables identified by the PickupIdentifiers cannot be the same. An ordering is established through the alphabetical ordering of the respective classnames.
96	96	if(!identifier->pickup_->getIdentifier()->isExactlyA(this->pickup_->getIdentifier()))
97	97	return this->pickup_->getIdentifier()->getName().compare(identifier->pickup_->getIdentifier()->getName());
98
	98
99	99	//! If the class is the same for both PickupIdentifiers we go on to check the parameters of the class.
100	100	//! If the two have a different number of parameters then obviusly something is very wrong.
…	…
104	104	return this->parameters_.size()-identifier->parameters_.size();
105	105	}
106
107		//! We iterate through all parameters and compar their values (which are strings). The first parameter is the most significant. The ordering is once again established by the alphabetical comparison of the two value strings.
	106
	107	//! We iterate through all parameters and compare their values (which are strings). The first parameter is the most significant. The ordering is once again established by the alphabetical comparison of the two value strings.
108	108	for(std::map<std::string, std::string>::const_iterator it = this->parameters_.begin(); it != this->parameters_.end(); it++)
109	109	{
…	…
117	117	return it->second.compare(identifier->parameters_.find(it->first)->second);
118	118	}
119
	119
120	120	return 0;
121	121	}
122
	122
123	123	/**
124	124	@brief
…	…
134	134	{
135	135	COUT(4) << "PickupIdentifier " << name << ", " << value << std::endl;
136
	136
137	137	if(!(this->parameters_.find(name) == this->parameters_.end()))
138	138	{
…	…
140	140	return false;
141	141	}
142
	142
143	143	this->parameters_[name] = value;
144
	144
145	145	return true;
146	146	}
147
	147
148	148	}

code/trunk/src/orxonox/pickup/PickupIdentifier.h

Property svn:eol-style set to native

-                      r6540
+                      r7163
 #include "core/Identifier.h"
 #include "core/OrxonoxClass.h"
+#include "core/OrxonoxClass.h"
 namespace orxonox
+{
     /**
     @brief
 …
     class _OrxonoxExport PickupIdentifier : virtual public OrxonoxClass
+    {
         public:
             PickupIdentifier(Pickupable* pickup); //!< Constructor.
             ~PickupIdentifier(); //!< Destructor.
             virtual int compare(const PickupIdentifier* identifier) const; //!< Compares two PickupIdentifiers and returns 0 if a == b, <0 if a < b and >0 if a > b for a.compare(b).
             bool addParameter(std::string & name, std::string & value); //!< Add a parameter to the PickupIdentifier.
         private:
             Pickupable* pickup_; //!< The Pickupable the PickupIdentififer is for.
             std::map<std::string, std::string> parameters_; //!< The parameters identifying the type of the pickup beyond the class.
     };
     /**
     @brief
 …
             { return lhs->compare(rhs) < 0; }
     };
+}

code/trunk/src/orxonox/sound/BaseSound.cc

-                      r6502
+                      r7163
 #include <al.h>
+#include "util/Math.h"
 #include "core/CoreIncludes.h"
 #include "core/GameMode.h"
 …
         else // No source acquired so far, but might be set to playing or paused
+        {
             State state = this->state_; // save
+            State state = static_cast<State>(this->state_); // save
             if (this->isPlaying() || this->isPaused())
                 doPlay();

code/trunk/src/orxonox/sound/BaseSound.h

r6417	r7163
112	112	float volume_;
113	113	bool bLooping_;
114		~~State state_;~~
	114	uint8_t state_; // This Variable is actually of type State
115	115	float pitch_;
116	116

code/trunk/src/orxonox/sound/SoundStreamer.cc

Property svn:eol-style set to native

code/trunk/src/orxonox/sound/SoundStreamer.h

Property svn:eol-style set to native

code/trunk/src/orxonox/sound/WorldSound.cc

r6417	r7163
58	58	registerVariable(bLooping_, ObjectDirection::ToClient, new NetworkCallback<WorldSound>(this, &WorldSound::loopingChanged));
59	59	registerVariable(pitch_, ObjectDirection::ToClient, new NetworkCallback<WorldSound>(this, &WorldSound::pitchChanged));
60		registerVariable((int&)(BaseSound::state_), ObjectDirection::ToClient, new NetworkCallback<WorldSound>(this, &WorldSound::stateChanged));
	60	registerVariable((uint8_t&)(BaseSound::state_), ObjectDirection::ToClient, new NetworkCallback<WorldSound>(this, &WorldSound::stateChanged));
61	61	}
62	62

code/trunk/src/orxonox/weaponsystem/WeaponMode.cc

-                      r6417
+                      r7163
             return BLANKSTRING;
+    }
+    void WeaponMode::setDefaultSoundWithVolume(const std::string& soundPath, const float soundVolume){
+        if (this->defSndWpnFire_) {
+            this->defSndWpnFire_->setSource(soundPath);
+            this->defSndWpnFire_->setVolume(soundVolume);
+        }
+    }
+}

code/trunk/src/orxonox/weaponsystem/WeaponMode.h

r6417	r7163
55	55	void setDefaultSound(const std::string& soundPath);
56	56	const std::string& getDefaultSound();
57
	57	void setDefaultSoundWithVolume(const std::string& soundPath, const float soundVolume);
58	58
59	59	// Munition

code/trunk/src/orxonox/weaponsystem/WeaponSystem.cc

-                      r6417
+                      r7163
         Weapon* weapon = 0;
         while ((weapon = wPack->getWeapon(i++)))
+            weapon->getWeaponSlot()->removeWeapon();
+            if (weapon->getWeaponSlot())
+                weapon->getWeaponSlot()->removeWeapon();
         // Remove all added links from the WeaponSets

code/trunk/src/orxonox/worldentities/BigExplosion.cc

-                      r5929
+                      r7163
         this->debrisEntity3_ = new MovableEntity(this);
         this->debrisEntity4_ = new MovableEntity(this);
+        this->debrisEntity1_->setSyncMode(0);
+        this->debrisEntity2_->setSyncMode(0);
+        this->debrisEntity3_->setSyncMode(0);
+        this->debrisEntity4_->setSyncMode(0);
         this->debris1_ = new Model(this);
 …
         this->debris3_ = new Model(this);
         this->debris4_ = new Model(this);
+        this->debris1_->setSyncMode(0);
+        this->debris2_->setSyncMode(0);
+        this->debris3_->setSyncMode(0);
+        this->debris4_->setSyncMode(0);
         this->explosion_ = new StaticEntity(this);
+        this->explosion_->setSyncMode(0);
         this->debrisSmoke1_ = new ParticleInterface(this->getScene()->getSceneManager(), "Orxonox/smoke7", this->LOD_);
 …
         effect->setSource("Orxonox/explosion2b");
         effect->setLifetime(4.0f);
+        effect->setSyncMode(0);
         ParticleSpawner* effect2 = new ParticleSpawner(this->getCreator());
 …
         effect2->setSource("Orxonox/smoke6");
         effect2->setLifetime(4.0f);
+        effect2->setSyncMode(0);
         this->explosion_->attach(effect);
 …
             MovableEntity* partEntity1 = new MovableEntity(this);
             MovableEntity* partEntity2 = new MovableEntity(this);
+            part1->setSyncMode(0);
+            part2->setSyncMode(0);
+            partEntity1->setSyncMode(0);
+            partEntity2->setSyncMode(0);
             partEntity1->setVelocity(Vector3(rnd(-1, 1), rnd(-1, 1), rnd(-1, 1))*rnd(10,100));

code/trunk/src/orxonox/worldentities/BigExplosion.h

-                      r5929
+                      r7163
             virtual void tick(float dt);
-            void registerVariables();
             inline void setLOD(LODParticle::Value level)
 …
         private:
+            void registerVariables();
             void LODchanged();

code/trunk/src/orxonox/worldentities/CMakeLists.txt

r6417	r7163
5	5	MobileEntity.cc
6	6	ControllableEntity.cc
7
	7	Drone.cc
8	8	BigExplosion.cc
9	9	EffectContainer.cc

code/trunk/src/orxonox/worldentities/ControllableEntity.h

-                      r6417
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
-            void registerVariables();
             void setConfigValues();
 …
             inline float getMouseLookSpeed() const
                 { return this->mouseLookSpeed_; }
+            inline CameraPosition* getCurrentCameraPosition()
+                { return this->currentCameraPosition_; }
             inline Controller* getXMLController() const
 …
                 { this->hudtemplate_ = name; }
+            Ogre::SceneNode* cameraPositionRootNode_;
         private:
+            void registerVariables();
             void setXMLController(Controller* controller);
 …
             bool bMouseLook_;
             float mouseLookSpeed_;
-            Ogre::SceneNode* cameraPositionRootNode_;
             std::list<SmartPtr<CameraPosition> > cameraPositions_;
             CameraPosition* currentCameraPosition_;

code/trunk/src/orxonox/worldentities/ExplosionChunk.h

-                      r5929
+                      r7163
             virtual void tick(float dt);
-            void registerVariables();
             inline void setLOD(LODParticle::Value level)
 …
         private:
+            void registerVariables();
             void LODchanged();
             void checkStop();

code/trunk/src/orxonox/worldentities/MobileEntity.cc

r5781	r7163
46	46	this->angularAcceleration_ = Vector3::ZERO;
47	47	this->angularVelocity_ = Vector3::ZERO;
48
49		~~this->registerVariables();~~
50	48	}
51	49

code/trunk/src/orxonox/worldentities/MovableEntity.h

-                      r6417
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
-            void registerVariables();
             using WorldEntity::setPosition;
 …
         private:
+            void registerVariables();
             void clientConnected(unsigned int clientID);
             void clientDisconnected(unsigned int clientID);

code/trunk/src/orxonox/worldentities/StaticEntity.h

-                      r5781
+                      r7163
             virtual ~StaticEntity();
-            void registerVariables();
             using WorldEntity::setPosition;
             using WorldEntity::setOrientation;
 …
         private:
+            void registerVariables();
             bool isCollisionTypeLegal(CollisionType type) const;

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

r6524	r7163
81	81	this->node_->setPosition(Vector3::ZERO);
82	82	this->node_->setOrientation(Quaternion::IDENTITY);
83
	83
84	84	// Activity and visibility memory.
85	85	this->bActiveMem_ = true;
…	…
205	205	registerVariable(this->parentID_, VariableDirection::ToClient, new NetworkCallback<WorldEntity>(this, &WorldEntity::networkcallback_parentChanged));
206	206	}
207
	207
208	208	/**
209	209	@brief
…	…
213	213	{
214	214	SUPER(WorldEntity, changedActivity);
215
	215
216	216	for (std::set<WorldEntity*>::const_iterator it = this->getAttachedObjects().begin(); it != this->getAttachedObjects().end(); it++)
217	217	{
…	…
227	227	}
228	228	}
229
	229
230	230	/**
231	231	@brief
…	…
235	235	{
236	236	SUPER(WorldEntity, changedVisibility);
237
	237
238	238	for (std::set<WorldEntity*>::const_iterator it = this->getAttachedObjects().begin(); it != this->getAttachedObjects().end(); it++)
239	239	{

code/trunk/src/orxonox/worldentities/WorldEntity.h

-                      r6524
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void registerVariables();
             inline const Ogre::SceneNode* getNode() const
 …
             static const Vector3 DOWN;
             static const Vector3 UP;
             virtual void changedActivity(void);
             virtual void changedVisibility(void);
 …
         private:
+            void registerVariables();
             inline void lookAt_xmlport(const Vector3& target)
                 { this->lookAt(target); }
 …
             std::set<WorldEntity*> children_;
             bool bDeleteWithParent_;
             bool bActiveMem_;
             bool bVisibleMem_;

code/trunk/src/orxonox/worldentities/pawns/CMakeLists.txt

r5781	r7163
1	1	ADD_SOURCE_FILES(ORXONOX_SRC_FILES
	2	FpsPlayer.cc
2	3	Spectator.cc
3	4	Pawn.cc

code/trunk/src/orxonox/worldentities/pawns/Pawn.cc

-                      r6864
+                      r7163
     CreateFactory(Pawn);
+    Pawn::Pawn(BaseObject* creator) : ControllableEntity(creator)
+    Pawn::Pawn(BaseObject* creator)
+        : ControllableEntity(creator)
+        , RadarViewable(creator, static_cast<WorldEntity*>(this))
+    {
         RegisterObject(Pawn);
 …
         this->maxHealth_ = 0;
         this->initialHealth_ = 0;
+        this->shieldHealth_ = 0;
+        this->shieldAbsorption_ = 0.5;
         this->lastHitOriginator_ = 0;
 …
         else
             this->weaponSystem_ = 0;
-        this->setCarrierName("Pawn");
         this->setRadarObjectColour(ColourValue::Red);
 …
         XMLPortParam(Pawn, "maxhealth", setMaxHealth, getMaxHealth, xmlelement, mode).defaultValues(200);
         XMLPortParam(Pawn, "initialhealth", setInitialHealth, getInitialHealth, xmlelement, mode).defaultValues(100);
+        XMLPortParam(Pawn, "shieldhealth", setShieldHealth, getShieldHealth, xmlelement, mode).defaultValues(0);
+        XMLPortParam(Pawn, "shieldabsorption", setShieldAbsorption, getShieldAbsorption, xmlelement, mode).defaultValues(0);
         XMLPortParam(Pawn, "spawnparticlesource", setSpawnParticleSource, getSpawnParticleSource, xmlelement, mode);
         XMLPortParam(Pawn, "spawnparticleduration", setSpawnParticleDuration, getSpawnParticleDuration, xmlelement, mode).defaultValues(3.0f);
 …
     void Pawn::registerVariables()
+    {
+        registerVariable(this->bAlive_,        VariableDirection::ToClient);
+        registerVariable(this->health_,        VariableDirection::ToClient);
+        registerVariable(this->initialHealth_, VariableDirection::ToClient);
+        registerVariable(this->bReload_,       VariableDirection::ToServer);
+        registerVariable(this->aimPosition_,   Bidirectionality::ServerMaster, 0, true);
+        registerVariable(this->bAlive_,           VariableDirection::ToClient);
+        registerVariable(this->health_,           VariableDirection::ToClient);
+        registerVariable(this->initialHealth_,    VariableDirection::ToClient);
+        registerVariable(this->shieldHealth_,     VariableDirection::ToClient);
+        registerVariable(this->shieldAbsorption_, VariableDirection::ToClient);
+        registerVariable(this->bReload_,          VariableDirection::ToServer);
+        registerVariable(this->aimPosition_,      VariableDirection::ToServer);  // For the moment this variable gets only transfered to the server
+    }
 …
         if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
+        {
+            this->setHealth(this->health_ - damage);
+            //share the dealt damage to the shield and the Pawn.
+            float shielddamage = damage*this->shieldAbsorption_;
+            float healthdamage = damage*(1-this->shieldAbsorption_);
+            // In case the shield can not take all the shield damage.
+            if (shielddamage > this->getShieldHealth())
+            {
+                healthdamage += shielddamage-this->getShieldHealth();
+                this->setShieldHealth(0);
+            }
+            this->setHealth(this->health_ - healthdamage);
+            if (this->getShieldHealth() > 0)
+            {
+                this->setShieldHealth(this->shieldHealth_ - shielddamage);
+            }
             this->lastHitOriginator_ = originator;
 …
+    {
         if (this->weaponSystem_)
+        {
             this->weaponSystem_->addWeaponPack(wPack);
+            this->addedWeaponPack(wPack);
+        }
+    }
 …
+    {
         if (this->weaponSystem_)
+        {
             if (!this->weaponSystem_->addWeaponPack(wPack))
                 wPack->destroy();
+            else
+                this->addedWeaponPack(wPack);
+        }
+    }

code/trunk/src/orxonox/worldentities/pawns/Pawn.h

-                      r6711
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
-            void registerVariables();
             inline bool isAlive() const
 …
                 { return this->initialHealth_; }
+            inline void setShieldHealth(float shieldHealth)
+            { this->shieldHealth_ = shieldHealth; }
+            inline float getShieldHealth()
+            { return this->shieldHealth_; }
+            inline void setShieldAbsorption(float shieldAbsorption)
+            { this->shieldAbsorption_ = shieldAbsorption; }
+            inline float getShieldAbsorption()
+            { return this->shieldAbsorption_; }
             inline ControllableEntity* getLastHitOriginator() const
                 { return this->lastHitOriginator_; }
 …
             void addWeaponPackXML(WeaponPack * wPack);
             WeaponPack * getWeaponPack(unsigned int index) const;
+            virtual void addedWeaponPack(WeaponPack* wPack) {}
             inline const WorldEntity* getWorldEntity() const
 …
             Vector3 getAimPosition()
                 { return this->aimPosition_; }
             virtual const Vector3& getCarrierPosition(void)
                 { return this->getWorldPosition(); };
 …
             float maxHealth_;
             float initialHealth_;
+            float shieldHealth_;
+            float shieldAbsorption_; // Has to be between 0 and 1
             Pawn* lastHitOriginator_;
 …
         private:
+            void registerVariables();
             inline void setWeaponSystem(WeaponSystem* weaponsystem)
                 { this->weaponSystem_ = weaponsystem; }

code/trunk/src/orxonox/worldentities/pawns/SpaceShip.h

-                      r6711
+                      r7163
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
-            void registerVariables();
             void setConfigValues();
 …
         private:
+            void registerVariables();
             virtual bool isCollisionTypeLegal(WorldEntity::CollisionType type) const;
-        private:
             void loadEngineTemplate();

code/trunk/src/orxonox/worldentities/pawns/Spectator.h

-                      r6417
+                      r7163
             void setConfigValues();
-            void registerVariables();
             virtual void tick(float dt);
 …
         private:
+            void registerVariables();
             void changedGreeting();
             void changedFlareVisibility();

Context Navigation

Legend:

Download in other formats: