Changeset 9348 for code/trunk/src

code/trunk

Property svn:ignore

old	new
	1	.project
1	2	build
2	3	codeblocks
	4	dependencies
3	5	vs
4		~~dependencies~~

Property svn:mergeinfo changed

/code/branches/newlevel2012 (added)	merged: 9033,9066,9094-9098,9103-9104,9106,9108-9113,9116-9117,9122-9124,9129,9132-9146,9148-9149,9154,9160-9161,9167-9168,9172-9173,9175,9180-9181,9188,9190,9193-9194,9196,9199,9204,9207,9211,9213,9236
/code/branches/pCuts (added)	merged: 9023-9024,9027,9081-9092
/code/branches/pickup2012 (added)	merged: 9029,9099,9118-9119,9155,9184
/code/branches/presentation2012 (added)	merged: 9189,9195,9202-9203,9208,9216,9229,9241,9243-9248,9250,9268
/code/branches/presentation2012merge (added)	merged: 9266,9269-9282,9286-9287,9290-9306,9312-9314,9316,9318-9334,9336-9347
/code/branches/shipSelection (added)	merged: 9038-9039,9045-9046,9057,9074,9101,9127-9128,9157,9185,9201
/code/branches/sound2012 (added)	merged: 9205,9214
/code/branches/surfaceRace (added)	merged: 9028,9035-9037,9041,9056,9059,9061,9070-9071,9107,9120-9121,9130,9150,9162,9169,9171,9174,9187

code/trunk/src/BuildUnitsConfigGCC.cmake

Property svn:eol-style set to native

code/trunk/src/BuildUnitsConfigMSVC.cmake

Property svn:eol-style set to native

code/trunk/src/external/enet/VERSION

Property svn:eol-style set to native

code/trunk/src/external/tolua/README_ORXONOX

Property svn:eol-style set to native

code/trunk/src/libraries/core/Super.h

-                      r8866
+                      r9348
         SUPER_NOARGS(classname, functionname)
-    #define SUPER_clone(classname, functionname, ...) \
-        SUPER_ARGS(classname, functionname, __VA_ARGS__)
     #define SUPER_changedCarrier(classname, functionname, ...) \
         SUPER_NOARGS(classname, functionname)
 …
                     inline void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) ) \
                     { \
                         (dynamic_cast<T*>(object))->T:: functionname
+                        (orxonox_cast<T*>(object))->T:: functionname
         /*
 …
                 inline void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) )
+                {
                     (dynamic_cast<T*>(object))->T:: functionname ( Call the function with it's arguments );
+                    (orxonox_cast<T*>(object))->T:: functionname ( Call the function with it's arguments );
+                }
 …
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(11, clone, true, OrxonoxClass*& item)
+            (item)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(12, changedCarrier, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(13, changedPickedUp, false)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(11, changedCarrier, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(12, changedPickedUp, false)
             ()
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
 …
     SUPER_INTRUSIVE_DECLARATION(changedGametype);
     SUPER_INTRUSIVE_DECLARATION(changedUsed);
-    SUPER_INTRUSIVE_DECLARATION(clone);
     SUPER_INTRUSIVE_DECLARATION(changedCarrier);
     SUPER_INTRUSIVE_DECLARATION(changedPickedUp);

code/trunk/src/libraries/core/Template.cc

-                      r8858
+                      r9348
         orxout(verbose, context::templates) << object->getLoaderIndentation() << " aplying Template \"" << this->getName() << "\"..." << endl;
+        // check if the template is applied on an object of the right type
+        Identifier* identifier = Identifier::getIdentifierByString(this->getXMLElement().Value());
+        if (!object->getIdentifier()->isA(identifier))
+            orxout(internal_warning, context::templates) << "Template was defined for " << identifier->getName() << " but the object is of type " << object->getIdentifier()->getName() << endl;
         Element temp = &const_cast<TiXmlElement&>(this->getXMLElement());

code/trunk/src/libraries/core/XMLPort.h

r8858	r9348
197	197	ClassIdentifier<classname>::getIdentifier()->addXMLPortParamContainer(paramname, containername); \
198	198	} \
199		containername->port(~~dynamic~~_cast<BaseObject*>(this), object, xmlelement, mode)
	199	containername->port(orxonox_cast<BaseObject*>(this), object, xmlelement, mode)
200	200
201	201	// --------------------

code/trunk/src/libraries/core/command/ConsoleCommand.cc

-                      r8858
+                      r9348
         @param bPrintError If true, an error is printed if the command doesn't exist
     */
     /* static */ const ConsoleCommand* ConsoleCommand::getCommand(const std::string& group, const std::string& name, bool bPrintError)
+    /* static */ ConsoleCommand* ConsoleCommand::getCommand(const std::string& group, const std::string& name, bool bPrintError)
+    {
         // find the group
 …
         @param bPrintError If true, an error is printed if the command doesn't exist
     */
     /* static */ const ConsoleCommand* ConsoleCommand::getCommandLC(const std::string& group, const std::string& name, bool bPrintError)
+    /* static */ ConsoleCommand* ConsoleCommand::getCommandLC(const std::string& group, const std::string& name, bool bPrintError)
+    {
         std::string groupLC = getLowercase(group);

code/trunk/src/libraries/core/command/ConsoleCommand.h

-                      r8858
+                      r9348
                 public:
                     /// Constructor: Creates a manipulator for a given ConsoleCommand.
                     ConsoleCommandManipulator(const ConsoleCommand* command) : command_(const_cast<ConsoleCommand*>(command)) {}
+                    ConsoleCommandManipulator(ConsoleCommand* command) : command_(command) {}
                     /// Changes the current function of the command. @param function The new function-pointer @param bForce If true, the new function-pointer is always assigned, even if the headers don't match
 …
             /// Returns a manipulator for this command.
             inline ConsoleCommandManipulator getManipulator() const
+            inline ConsoleCommandManipulator getManipulator()
                 { return this; }
 …
             /// Returns a command (shortcut) with given name. @param name The name of the command shortcut @param bPrintError If true, an error is printed if the command doesn't exist
             static inline const ConsoleCommand* getCommand(const std::string& name, bool bPrintError = false)
+            static inline ConsoleCommand* getCommand(const std::string& name, bool bPrintError = false)
                 { return ConsoleCommand::getCommand("", name, bPrintError); }
             /// Returns a command (shortcut) with given name in lowercase. @param name The lowercase name of the command shortcut @param bPrintError If true, an error is printed if the command doesn't exist
             static inline const ConsoleCommand* getCommandLC(const std::string& name, bool bPrintError = false)
+            static inline ConsoleCommand* getCommandLC(const std::string& name, bool bPrintError = false)
                 { return ConsoleCommand::getCommandLC("", name, bPrintError); }
             static const ConsoleCommand* getCommand(const std::string& group, const std::string& name, bool bPrintError = false);
             static const ConsoleCommand* getCommandLC(const std::string& group, const std::string& name, bool bPrintError = false);
+            static ConsoleCommand* getCommand(const std::string& group, const std::string& name, bool bPrintError = false);
+            static ConsoleCommand* getCommandLC(const std::string& group, const std::string& name, bool bPrintError = false);
             static void destroyAll();

code/trunk/src/libraries/util/output/ConsoleWriter.cc

Property svn:eol-style set to native

code/trunk/src/modules/CMakeLists.txt

r8706	r9348
38	38	ADD_SUBDIRECTORY(weapons)
39	39	ADD_SUBDIRECTORY(docking)
	40	ADD_SUBDIRECTORY(towerdefense)

code/trunk/src/modules/docking/DockingController.cc

-                      r8858
+                      r9348
         float distance = (this->dock_->getWorldPosition() - entity->getPosition()).length();
         Vector2 coord = get2DViewdirection(     // I don't understand this too
+        Vector2 coord = get2DViewcoordinates(     // I don't understand this too
             entity->getPosition(),
             entity->getOrientation() * WorldEntity::FRONT,
 …
         if (distance > 10)
+        {
             entity->rotateYaw(-1.0f * 0.8f * sgn(coord.x) * coord.x*coord.x);
             entity->rotatePitch(0.8f * sgn(coord.y) * coord.y*coord.y);
+            entity->rotateYaw(-1.0f * 0.8f * clamp(coord.x * 10, -1.0f, 1.0f));
+            entity->rotatePitch(0.8f * clamp(coord.y * 10, -1.0f, 1.0f));
+        }

code/trunk/src/modules/gametypes/OldRaceCheckPoint.cc

Property svn:eol-style set to native

r9016	r9348
112	112	const std::string& message = "You have " + multi_cast<std::string>(this->bTimeLimit_)
113	113	+ " seconds to reach the check point " + multi_cast<std::string>(this->bCheckpointIndex_+1);
114		~~const_cast<GametypeInfo*>(gametype->getGametypeInfo()~~)->sendAnnounceMessage(message);
	114	gametype->getGametypeInfo()->sendAnnounceMessage(message);
115	115	ChatManager::message(message);
116	116	}

code/trunk/src/modules/gametypes/OldRaceCheckPoint.h

Property svn:eol-style set to native

code/trunk/src/modules/gametypes/OldSpaceRace.cc

Property svn:eol-style set to native

-                      r9016
+                      r9348
                         + "You didn't reach the check point " + multi_cast<std::string>(this->checkpointsReached_+1)
                         + " before the time limit. You lose!";
             const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+            this->getGametypeInfo()->sendAnnounceMessage(message);
             ChatManager::message(message);
+        }
 …
             const std::string& message = "You win!! You have reached the last check point after "+ multi_cast<std::string>(s)
                         + "." + multi_cast<std::string>(ms) + " seconds.";
             const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+            this->getGametypeInfo()->sendAnnounceMessage(message);
             ChatManager::message(message);
 /*
 …
         std::string message("The match has started! Reach the check points as quickly as possible!");
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+        this->getGametypeInfo()->sendAnnounceMessage(message);
         ChatManager::message(message);
+    }
 …
                         + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms)
                         + " seconds.";
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+        this->getGametypeInfo()->sendAnnounceMessage(message);
         ChatManager::message(message);
+    }

code/trunk/src/modules/gametypes/OldSpaceRace.h

Property svn:eol-style set to native

r9016	r9348
59	59
60	60	virtual void newCheckpointReached();
	61	virtual void addBots(unsigned int amount){} //<! overwrite function in order to bypass the addbots command.
	62	//<! This is only a temporary solution. Better: create racingBots.
61	63
62	64	inline void setCheckpointsReached(int n)

code/trunk/src/modules/gametypes/RaceCheckPoint.cc

r9263	r9348
97	97	std::string message = "You have " + multi_cast<std::string>(this->timeLimit_)
98	98	+ " seconds to reach the check point " + multi_cast<std::string>(this->checkpointIndex_ + 1);
99		~~const_cast<GametypeInfo*>(this->getGametype()->getGametypeInfo()~~)->sendAnnounceMessage(message);
	99	this->getGametype()->getGametypeInfo()->sendAnnounceMessage(message);
100	100	ChatManager::message(message);
101	101	}

code/trunk/src/modules/gametypes/SpaceRace.cc

-                      r9263
+                      r9348
  *     Mauro Salomon
  *   Co-authors:
  *      ...
+ *      Celine Egger
+ *
  */
 …
         this->cantMove_ = false;
         this->bTimeIsUp_ = false;
+        this->numberOfBots_ = 0; // quick fix: don't allow default-bots to enter the race
+                                 // remove this line, if a raceBot has been created.
+    }
 …
+        }
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+        this->getGametypeInfo()->sendAnnounceMessage(message);
         ChatManager::message(message);
+    }
 …
             std::string message = "The match has started! Reach the check points as quickly as possible!";
             const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+            this->getGametypeInfo()->sendAnnounceMessage(message);
             ChatManager::message(message);
+        }
 …
         const std::string& message = "Checkpoint " + multi_cast<std::string>(checkpoint->getCheckpointIndex() + 1)
             + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms) + " seconds.";
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+        this->getGametypeInfo()->sendAnnounceMessage(message);
         ChatManager::message(message);
+    }

code/trunk/src/modules/gametypes/SpaceRaceManager.cc

Property svn:eol-style set to native

r9263	r9348
149	149	}
150	150	else
151		{
	151	{
152	152	// adjust the radarvisibility
153	153	gametype->newCheckpointReached(newCheckpoint, player);

code/trunk/src/modules/gametypes/SpaceRaceManager.h

Property svn:eol-style set to native

code/trunk/src/modules/objects/triggers/CheckPoint.cc

r7601	r9348
109	109	if (bIsDestination_)
110	110	{
111		~~const_cast<GametypeInfo*>(gametype->getGametypeInfo()~~)->sendAnnounceMessage("Congratulations - you have won the match!");
	111	gametype->getGametypeInfo()->sendAnnounceMessage("Congratulations - you have won the match!");
112	112	gametype->end();
113	113	}
…	…
115	115	if (!bIsFirst_ && !bIsDestination_)
116	116	{
117		~~const_cast<GametypeInfo*>(gametype->getGametypeInfo()~~)->sendAnnounceMessage("Checkpoint reached");
	117	gametype->getGametypeInfo()->sendAnnounceMessage("Checkpoint reached");
118	118	}
119	119	}

code/trunk/src/modules/overlays/OverlaysPrereqs.h

r8706	r9348
95	95	class PauseNotice;
96	96	class TeamBaseMatchScore;
97		~~class UnderAttackHealthBar;~~
98	97
99	98	// stats

code/trunk/src/modules/overlays/hud/CMakeLists.txt

r9016	r9348
12	12	KillMessage.cc
13	13	DeathMessage.cc
14		~~UnderAttackHealthBar.cc~~
15	14	TeamBaseMatchScore.cc
16	15	GametypeStaticMessage.cc

code/trunk/src/modules/overlays/hud/HUDBoostBar.cc

Property svn:eol-style set to native

code/trunk/src/modules/overlays/hud/HUDBoostBar.h

Property svn:eol-style set to native

code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.cc

Property svn:eol-style set to native

code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.h

Property svn:eol-style set to native

code/trunk/src/modules/overlays/hud/HUDNavigation.cc

-                      r9257
+                      r9348
 namespace orxonox
+{
+bool compareDistance ( std::pair<RadarViewable*, unsigned int > a, std::pair<RadarViewable*, unsigned int > b )
+{
+    return a.second<b.second;
+}
+void HUDNavigation::setConfigValues()
+{
+  SetConfigValue(markerLimit_, 3);
+  SetConfigValue(showDistance, false);
+}
+CreateFactory ( HUDNavigation );
+HUDNavigation::HUDNavigation ( BaseObject* creator )
+        : OrxonoxOverlay ( creator )
+{
+    RegisterObject ( HUDNavigation );
+    this->setConfigValues();
+    // Set default values
+    this->setFont ( "Monofur" );
+    this->setTextSize ( 0.05f );
+    this->setNavMarkerSize ( 0.05f );
+    this->setDetectionLimit( 10000.0f );
+}
+HUDNavigation::~HUDNavigation()
+{
+    if ( this->isInitialized() )
+    {
+        for ( ObjectMap::iterator it = activeObjectList_.begin(); it != activeObjectList_.end(); )
+            removeObject ( ( it++ )->first );
+    }
+    sortedObjectList_.clear();
+}
+void HUDNavigation::XMLPort ( Element& xmlelement, XMLPort::Mode mode )
+{
+    SUPER ( HUDNavigation, XMLPort, xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "font",          setFont,          getFont,          xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "textSize",      setTextSize,      getTextSize,      xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "navMarkerSize", setNavMarkerSize, getNavMarkerSize, xmlelement, mode );
+    XMLPortParam ( HUDNavigation, "detectionLimit", setDetectionLimit, getDetectionLimit, xmlelement, mode );
+}
+void HUDNavigation::setFont ( const std::string& font )
+{
+    const Ogre::ResourcePtr& fontPtr = Ogre::FontManager::getSingleton().getByName ( font );
+    if ( fontPtr.isNull() )
+    {
+        orxout(internal_warning) << "HUDNavigation: Font '" << font << "' not found" << endl;
+        return;
+    }
+    fontName_ = font;
+    for ( ObjectMap::iterator it = activeObjectList_.begin(); it != activeObjectList_.end(); ++it )
+    {
+        if ( it->second.text_ != NULL )
+            it->second.text_->setFontName ( fontName_ );
+    }
+}
+const std::string& HUDNavigation::getFont() const
+{
+    return fontName_;
+}
+void HUDNavigation::setTextSize ( float size )
+{
+    if ( size <= 0.0f )
+    {
+        orxout(internal_warning) << "HUDNavigation: Negative font size not allowed" << endl;
+        return;
+    }
+    textSize_ = size;
+    for ( ObjectMap::iterator it = activeObjectList_.begin(); it!=activeObjectList_.end(); ++it )
+    {
+        if ( it->second.text_ )
+            it->second.text_->setCharHeight ( size );
+    }
+}
+float HUDNavigation::getTextSize() const
+{
+    return textSize_;
+}
+float HUDNavigation::getArrowSizeX(int dist)
+{
+    if (dist < 600)
+        dist = 600;
+    return this->getActualSize().x * 900 * navMarkerSize_ / dist;
+}
+float HUDNavigation::getArrowSizeY(int dist)
+{
+    if (dist < 600)
+        dist = 600;
+    return this->getActualSize().y * 900 * navMarkerSize_ / dist;
+}
+void HUDNavigation::tick ( float dt )
+{
+    SUPER ( HUDNavigation, tick, dt );
+    Camera* cam = CameraManager::getInstance().getActiveCamera();
+    if ( cam == NULL )
+        return;
+    const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
+    for ( sortedList::iterator listIt = sortedObjectList_.begin(); listIt != sortedObjectList_.end(); ++listIt )
+    {
+        listIt->second = ( int ) ( ( listIt->first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition() ).length() + 0.5f );
+    }
+    sortedObjectList_.sort ( compareDistance );
+    unsigned int markerCount_ = 0;
+    bool closeEnough_ = false; //only display objects that are close enough to be relevant for the player
+//         for (ObjectMap::iterator it = activeObjectList_.begin(); it != activeObjectList_.end(); ++it)
+    for ( sortedList::iterator listIt = sortedObjectList_.begin(); listIt != sortedObjectList_.end(); ++markerCount_, ++listIt )
+    {
+        ObjectMap::iterator it = activeObjectList_.find ( listIt->first );
+        closeEnough_ = listIt->second < detectionLimit_ ;
+        // display radarviewables on HUD if the marker limit and max-distance is not exceeded
+        if ( markerCount_ < markerLimit_ && (closeEnough_ ||  detectionLimit_ < 0) )
+        {
+            // Get Distance to HumanController and save it in the TextAreaOverlayElement.
+            int dist = listIt->second;
+            float textLength = 0.0f;
+            //display distance next to cursor
+            if (showDistance){
+            it->second.text_->setCaption ( multi_cast<std::string> ( dist ) );
+            textLength = multi_cast<std::string> ( dist ).size() * it->second.text_->getCharHeight() * 0.3f;
+            }
+            //display name next to cursor
+            else{
+            it->second.text_->setCaption(it->first->getRadarName());
+            textLength = it->first->getRadarName().size() * it->second.text_->getCharHeight() * 0.3f;
+            }
+            // Transform to screen coordinates
+            Vector3 pos = camTransform * it->first->getRVWorldPosition();
+            bool outOfView = true;
+            if ( pos.z > 1.0 )
+    bool compareDistance(std::pair<RadarViewable*, unsigned int> a, std::pair<RadarViewable*, unsigned int> b)
+    {
+        return a.second < b.second;
+    }
+    CreateFactory ( HUDNavigation );
+    HUDNavigation::HUDNavigation(BaseObject* creator) : OrxonoxOverlay(creator)
+    {
+        RegisterObject(HUDNavigation);
+        this->setConfigValues();
+        // Set default values
+        this->setFont("Monofur");
+        this->setTextSize(0.05f);
+        this->setNavMarkerSize(0.05f);
+        this->setDetectionLimit(10000.0f);
+    }
+    HUDNavigation::~HUDNavigation()
+    {
+        if (this->isInitialized())
+        {
+            for (std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.begin(); it != this->activeObjectList_.end();)
+                removeObject((it++)->first);
+        }
+        this->sortedObjectList_.clear();
+    }
+    void HUDNavigation::setConfigValues()
+    {
+        SetConfigValue(markerLimit_, 3);
+        SetConfigValue(showDistance_, false);
+    }
+    void HUDNavigation::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(HUDNavigation, XMLPort, xmlelement, mode);
+        XMLPortParam(HUDNavigation, "font",           setFont,           getFont,           xmlelement, mode);
+        XMLPortParam(HUDNavigation, "textSize",       setTextSize,       getTextSize,       xmlelement, mode);
+        XMLPortParam(HUDNavigation, "navMarkerSize",  setNavMarkerSize,  getNavMarkerSize,  xmlelement, mode);
+        XMLPortParam(HUDNavigation, "detectionLimit", setDetectionLimit, getDetectionLimit, xmlelement, mode);
+    }
+    void HUDNavigation::setFont(const std::string& font)
+    {
+        const Ogre::ResourcePtr& fontPtr = Ogre::FontManager::getSingleton().getByName(font);
+        if (fontPtr.isNull())
+        {
+            orxout(internal_warning) << "HUDNavigation: Font '" << font << "' not found" << endl;
+            return;
+        }
+        this->fontName_ = font;
+        for (std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.begin(); it != this->activeObjectList_.end(); ++it)
+        {
+            if (it->second.text_ != NULL)
+                it->second.text_->setFontName(this->fontName_);
+        }
+    }
+    const std::string& HUDNavigation::getFont() const
+    {
+        return this->fontName_;
+    }
+    void HUDNavigation::setTextSize(float size)
+    {
+        if (size <= 0.0f)
+        {
+            orxout(internal_warning) << "HUDNavigation: Negative font size not allowed" << endl;
+            return;
+        }
+        this->textSize_ = size;
+        for (std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.begin(); it!=this->activeObjectList_.end(); ++it)
+        {
+            if (it->second.text_)
+                it->second.text_->setCharHeight(size);
+        }
+    }
+    float HUDNavigation::getTextSize() const
+    {
+        return this->textSize_;
+    }
+    float HUDNavigation::getArrowSizeX(int dist) const
+    {
+        if (dist < 600)
+            dist = 600;
+        return this->getActualSize().x * 900 * this->navMarkerSize_ / dist;
+    }
+    float HUDNavigation::getArrowSizeY(int dist) const
+    {
+        if (dist < 600)
+            dist = 600;
+        return this->getActualSize().y * 900 * this->navMarkerSize_ / dist;
+    }
+    void HUDNavigation::tick(float dt)
+    {
+        SUPER(HUDNavigation, tick, dt);
+        Camera* cam = CameraManager::getInstance().getActiveCamera();
+        if (cam == NULL)
+            return;
+        const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
+        for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
+            listIt->second = (int)((listIt->first->getRVWorldPosition() - HumanController::getLocalControllerSingleton()->getControllableEntity()->getWorldPosition()).length() + 0.5f);
+        this->sortedObjectList_.sort(compareDistance);
+        unsigned int markerCount = 0;
+        bool closeEnough = false; // only display objects that are close enough to be relevant for the player
+        for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++markerCount, ++listIt)
+        {
+            std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.find(listIt->first);
+            closeEnough = listIt->second < this->detectionLimit_;
+            // display radarviewables on HUD if the marker limit and max-distance is not exceeded
+            if (markerCount < this->markerLimit_ && (closeEnough ||  this->detectionLimit_ < 0))
+            {
+                // z > 1.0 means that the object is behind the camera
+                outOfView = true;
+                // we have to switch all coordinates (if you don't know why,
+                // try linear algebra lectures, because I can't explain..)
+                pos.x = -pos.x;
+                pos.y = -pos.y;
+            }
+            else
+                outOfView = pos.x < -1.0 || pos.x > 1.0 || pos.y < -1.0 || pos.y > 1.0;
+            if ( outOfView )
+            {
+                // Object is not in view
+                // Change material only if outOfView changed
+                if ( !it->second.wasOutOfView_ )
+                // Get Distance to HumanController and save it in the TextAreaOverlayElement.
+                int dist = listIt->second;
+                float textLength = 0.0f;
+                if (this->showDistance_)
+                {
+                    it->second.panel_->setMaterialName( TextureGenerator::getMaterialName( "arrows.png", it->first->getRadarObjectColour()) );
+                    it->second.wasOutOfView_ = true;
+                    //display distance next to cursor
+                    it->second.text_->setCaption(multi_cast<std::string>(dist));
+                    textLength = multi_cast<std::string>(dist).size() * it->second.text_->getCharHeight() * 0.3f;
+                }
+                //float xDistScale = this->getActualSize().x * 1000.0f * navMarkerSize_ / dist;
+                //float yDistScale = this->getActualSize().y * 1000.0f * navMarkerSize_ / dist;
+                // Adjust Arrowsize according to distance
+                it->second.panel_->setDimensions(getArrowSizeX(dist),getArrowSizeY(dist));
+                // Switch between top, bottom, left and right position of the arrow at the screen border
+                if ( pos.x < pos.y )
+                else
+                {
+                    if ( pos.y > -pos.x )
+                    //display name next to cursor
+                    it->second.text_->setCaption(it->first->getRadarName());
+                    textLength = it->first->getRadarName().size() * it->second.text_->getCharHeight() * 0.3f;
+                }
+                // Transform to screen coordinates
+                Vector3 pos = camTransform * it->first->getRVWorldPosition();
+                bool outOfView = true;
+                if (pos.z > 1.0)
+                {
+                    // z > 1.0 means that the object is behind the camera
+                    outOfView = true;
+                    // we have to switch all coordinates (if you don't know why,
+                    // try linear algebra lectures, because I can't explain..)
+                    pos.x = -pos.x;
+                    pos.y = -pos.y;
+                }
+                else
+                    outOfView = pos.x < -1.0 || pos.x > 1.0 || pos.y < -1.0 || pos.y > 1.0;
+                if (outOfView)
+                {
+                    // Object is not in view
+                    // Change material only if outOfView changed
+                    if (!it->second.wasOutOfView_)
+                    {
+                        // Top
+                        float position = pos.x / pos.y + 1.0f;
+                        it->second.panel_->setPosition ( ( position - it->second.panel_->getWidth() ) * 0.5f, 0.0f );
+                        it->second.panel_->setUV ( 0.5f, 0.0f, 1.0f, 0.5f );
+                        it->second.text_->setLeft ( ( position - textLength ) * 0.5f );
+                        it->second.text_->setTop ( it->second.panel_->getHeight() );
+                        it->second.panel_->setMaterialName(TextureGenerator::getMaterialName("arrows.png", it->first->getRadarObjectColour()));
+                        it->second.wasOutOfView_ = true;
+                    }
+                    //float xDistScale = this->getActualSize().x * 1000.0f * this->navMarkerSize_ / dist;
+                    //float yDistScale = this->getActualSize().y * 1000.0f * this->navMarkerSize_ / dist;
+                    // Adjust Arrowsize according to distance
+                    it->second.panel_->setDimensions(getArrowSizeX(dist), getArrowSizeY(dist));
+                    // Switch between top, bottom, left and right position of the arrow at the screen border
+                    if (pos.x < pos.y)
+                    {
+                        if (pos.y > -pos.x)
+                        {
+                            // Top
+                            float position = pos.x / pos.y + 1.0f;
+                            it->second.panel_->setPosition((position - it->second.panel_->getWidth()) * 0.5f, 0.0f);
+                            it->second.panel_->setUV(0.5f, 0.0f, 1.0f, 0.5f);
+                            it->second.text_->setLeft((position - textLength) * 0.5f);
+                            it->second.text_->setTop(it->second.panel_->getHeight());
+                        }
+                        else
+                        {
+                            // Left
+                            float position = pos.y / pos.x + 1.0f;
+                            it->second.panel_->setPosition(0.0f, (position - it->second.panel_->getWidth()) * 0.5f);
+                            it->second.panel_->setUV(0.0f, 0.0f, 0.5f, 0.5f);
+                            it->second.text_->setLeft(it->second.panel_->getWidth() + 0.01f);
+                            it->second.text_->setTop((position - it->second.text_->getCharHeight()) * 0.5f);
+                        }
+                    }
                     else
+                    {
+                        // Left
+                        float position = pos.y / pos.x + 1.0f;
+                        it->second.panel_->setPosition ( 0.0f, ( position - it->second.panel_->getWidth() ) * 0.5f );
+                        it->second.panel_->setUV ( 0.0f, 0.0f, 0.5f, 0.5f );
+                        it->second.text_->setLeft ( it->second.panel_->getWidth() + 0.01f );
+                        it->second.text_->setTop ( ( position - it->second.text_->getCharHeight() ) * 0.5f );
+                        if (pos.y < -pos.x)
+                        {
+                            // Bottom
+                            float position = -pos.x / pos.y + 1.0f;
+                            it->second.panel_->setPosition((position - it->second.panel_->getWidth()) * 0.5f, 1.0f - it->second.panel_->getHeight());
+                            it->second.panel_->setUV(0.0f, 0.5f, 0.5f, 1.0f );
+                            it->second.text_->setLeft((position - textLength) * 0.5f);
+                            it->second.text_->setTop(1.0f - it->second.panel_->getHeight() - it->second.text_->getCharHeight());
+                        }
+                        else
+                        {
+                            // Right
+                            float position = -pos.y / pos.x + 1.0f;
+                            it->second.panel_->setPosition(1.0f - it->second.panel_->getWidth(), (position - it->second.panel_->getHeight()) * 0.5f);
+                            it->second.panel_->setUV(0.5f, 0.5f, 1.0f, 1.0f);
+                            it->second.text_->setLeft(1.0f - it->second.panel_->getWidth() - textLength - 0.01f);
+                            it->second.text_->setTop((position - it->second.text_->getCharHeight()) * 0.5f);
+                        }
+                    }
+                }
                 else
+                {
+                    if ( pos.y < -pos.x )
+                    // Object is in view
+                    // Change material only if outOfView changed
+                    if (it->second.wasOutOfView_)
+                    {
+                        // Bottom
+                        float position = -pos.x / pos.y + 1.0f;
+                        it->second.panel_->setPosition ( ( position - it->second.panel_->getWidth() ) * 0.5f, 1.0f - it->second.panel_->getHeight() );
+                        it->second.panel_->setUV ( 0.0f, 0.5f, 0.5f, 1.0f );
+                        it->second.text_->setLeft ( ( position - textLength ) * 0.5f );
+                        it->second.text_->setTop ( 1.0f - it->second.panel_->getHeight() - it->second.text_->getCharHeight() );
+                        //it->second.panel_->setMaterialName("Orxonox/NavTDC");
+                        it->second.panel_->setMaterialName(TextureGenerator::getMaterialName("tdc.png", it->first->getRadarObjectColour()));
+                        it->second.panel_->setDimensions(this->navMarkerSize_ * this->getActualSize().x, this->navMarkerSize_ * this->getActualSize().y);
+                        it->second.wasOutOfView_ = false;
+                    }
+                    else
+                    {
                         // Right
                         float position = -pos.y / pos.x + 1.0f;
                         it->second.panel_->setPosition ( 1.0f - it->second.panel_->getWidth(), ( position - it->second.panel_->getHeight() ) * 0.5f );
+                        it->second.panel_->setUV ( 0.5f, 0.5f, 1.0f, 1.0f );
                         it->second.text_->setLeft ( 1.0f - it->second.panel_->getWidth() - textLength - 0.01f );
                         it->second.text_->setTop ( ( position - it->second.text_->getCharHeight() ) * 0.5f );
+                    }
+                    // Position marker
+                    it->second.panel_->setUV(0.0f, 0.0f, 1.0f, 1.0f);
+                    it->second.panel_->setLeft((pos.x + 1.0f - it->second.panel_->getWidth()) * 0.5f);
+                    it->second.panel_->setTop((-pos.y + 1.0f - it->second.panel_->getHeight()) * 0.5f);
+                    // Position text
+                    it->second.text_->setLeft((pos.x + 1.0f + it->second.panel_->getWidth()) * 0.5f);
+                    it->second.text_->setTop((-pos.y + 1.0f + it->second.panel_->getHeight()) * 0.5f);
+                }
+                // Make sure the overlays are shown
+                it->second.panel_->show();
+                it->second.text_->show();
+            }
             else
+            else // do not display on HUD
+            {
+                // Object is in view
+                // Change material only if outOfView changed
+                if ( it->second.wasOutOfView_ )
+                {
+                  //it->second.panel_->setMaterialName ( "Orxonox/NavTDC" );
+                    it->second.panel_->setMaterialName( TextureGenerator::getMaterialName( "tdc.png", it->first->getRadarObjectColour()) );
+                    it->second.panel_->setDimensions ( navMarkerSize_ * this->getActualSize().x, navMarkerSize_ * this->getActualSize().y );
+                    it->second.wasOutOfView_ = false;
+                }
+                // Position marker
+                it->second.panel_->setUV ( 0.0f, 0.0f, 1.0f, 1.0f );
+                it->second.panel_->setLeft ( ( pos.x + 1.0f - it->second.panel_->getWidth() ) * 0.5f );
+                it->second.panel_->setTop ( ( -pos.y + 1.0f - it->second.panel_->getHeight() ) * 0.5f );
+                // Position text
+                it->second.text_->setLeft ( ( pos.x + 1.0f + it->second.panel_->getWidth() ) * 0.5f );
+                it->second.text_->setTop ( ( -pos.y + 1.0f + it->second.panel_->getHeight() ) * 0.5f );
+                it->second.panel_->hide();
+                it->second.text_->hide();
+            }
+            // Make sure the overlays are shown
+            it->second.panel_->show();
+            it->second.text_->show();
+        }
+        else // do not display on HUD
+        {
+            it->second.panel_->hide();
+            it->second.text_->hide();
+        }
+        }
+    }
+    /** Overridden method of OrxonoxOverlay.
+    @details
+        Usually the entire overlay scales with scale().
+        Here we obviously have to adjust this.
+    */
+    void HUDNavigation::sizeChanged()
+    {
+        // Use size to compensate for aspect ratio if enabled.
+        float xScale = this->getActualSize().x;
+        float yScale = this->getActualSize().y;
+        for (std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.begin(); it != this->activeObjectList_.end(); ++it)
+        {
+            if (it->second.panel_ != NULL)
+                it->second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
+            if (it->second.text_ != NULL)
+                it->second.text_->setCharHeight(it->second.text_->getCharHeight() * yScale);
+        }
+    }
+    void HUDNavigation::addObject(RadarViewable* object)
+    {
+        if (showObject(object) == false)
+            return;
+        if (this->activeObjectList_.size() >= this->markerLimit_)
+            if (object == NULL)
+                return;
+        // Object hasn't been added yet (we know that)
+        assert(this->activeObjectList_.find(object) == this->activeObjectList_.end());
+        // Scales used for dimensions and text size
+        float xScale = this->getActualSize().x;
+        float yScale = this->getActualSize().y;
+        // Create everything needed to display the object on the radar and add it to the map
+        // Create arrow/marker
+        Ogre::PanelOverlayElement* panel = static_cast<Ogre::PanelOverlayElement*>( Ogre::OverlayManager::getSingleton()
+                                           .createOverlayElement("Panel", "HUDNavigation_navMarker_" + getUniqueNumberString()));
+        //panel->setMaterialName("Orxonox/NavTDC");
+        panel->setMaterialName(TextureGenerator::getMaterialName("tdc.png", object->getRadarObjectColour()));
+        panel->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
+        //panel->setColour(object->getRadarObjectColour());
+        Ogre::TextAreaOverlayElement* text = static_cast<Ogre::TextAreaOverlayElement*>( Ogre::OverlayManager::getSingleton()
+                                             .createOverlayElement("TextArea", "HUDNavigation_navText_" + getUniqueNumberString()));
+        text->setFontName(this->fontName_);
+        text->setCharHeight(text->getCharHeight() * yScale);
+        text->setColour(object->getRadarObjectColour());
+        panel->hide();
+        text->hide();
+        ObjectInfo tempStruct = {panel, text, false /*, TODO: initialize wasOutOfView_ */};
+        this->activeObjectList_[object] = tempStruct;
+        this->background_->addChild(panel);
+        this->background_->addChild(text);
+        this->sortedObjectList_.push_front(std::make_pair(object, (unsigned int)0));
+    }
+    void HUDNavigation::removeObject(RadarViewable* viewable)
+    {
+        std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.find(viewable);
+        if (this->activeObjectList_.find(viewable) != this->activeObjectList_.end())
+        {
+            // Detach overlays
+            this->background_->removeChild(it->second.panel_->getName());
+            this->background_->removeChild(it->second.text_->getName());
+            // Properly destroy the overlay elements (do not use delete!)
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(it->second.panel_);
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(it->second.text_);
+            // Remove from the list
+            this->activeObjectList_.erase(viewable);
+        }
+        for (std::list<std::pair<RadarViewable*, unsigned int> >::iterator listIt = this->sortedObjectList_.begin(); listIt != this->sortedObjectList_.end(); ++listIt)
+        {
+            if ((listIt->first) == viewable)
+            {
+                this->sortedObjectList_.erase(listIt);
+                break;
+            }
+        }
+    }
+    void HUDNavigation::objectChanged(RadarViewable* viewable)
+    {
+        // TODO: niceification neccessary ;)
+        removeObject(viewable);
+        addObject(viewable);
+    }
+    bool HUDNavigation::showObject(RadarViewable* rv)
+    {
+        if (rv == orxonox_cast<RadarViewable*>(this->getOwner()))
+            return false;
+        assert(rv->getWorldEntity());
+        if (rv->getWorldEntity()->isVisible() == false || rv->getRadarVisibility() == false)
+            return false;
+        return true;
+    }
+    void HUDNavigation::changedOwner()
+    {
+        const std::set<RadarViewable*>& respawnObjects = this->getOwner()->getScene()->getRadar()->getRadarObjects();
+        for (std::set<RadarViewable*>::const_iterator it = respawnObjects.begin(); it != respawnObjects.end(); ++it)
+        {
+            if (!(*it)->isHumanShip_)
+                this->addObject(*it);
+        }
+    }
+}
-/** Overridden method of OrxonoxOverlay.
-@details
-    Usually the entire overlay scales with scale().
-    Here we obviously have to adjust this.
-*/
-void HUDNavigation::sizeChanged()
+{
-    // Use size to compensate for aspect ratio if enabled.
-    float xScale = this->getActualSize().x;
-    float yScale = this->getActualSize().y;
-    for ( ObjectMap::iterator it = activeObjectList_.begin(); it!=activeObjectList_.end(); ++it )
+    {
-        if ( it->second.panel_ != NULL )
-            it->second.panel_->setDimensions ( navMarkerSize_ * xScale, navMarkerSize_ * yScale );
-        if ( it->second.text_ != NULL )
-            it->second.text_->setCharHeight ( it->second.text_->getCharHeight() * yScale );
+    }
+}
-void HUDNavigation::addObject ( RadarViewable* object )
+{
-    if( showObject(object)==false )
-        return;
-    if ( activeObjectList_.size() >= markerLimit_ )
-        if ( object == NULL )
-            return;
-    // Object hasn't been added yet (we know that)
-    assert ( this->activeObjectList_.find ( object ) == this->activeObjectList_.end() );
-    // Scales used for dimensions and text size
-    float xScale = this->getActualSize().x;
-    float yScale = this->getActualSize().y;
-    // Create everything needed to display the object on the radar and add it to the map
-    // Create arrow/marker
-    Ogre::PanelOverlayElement* panel = static_cast<Ogre::PanelOverlayElement*> ( Ogre::OverlayManager::getSingleton()
-                                       .createOverlayElement ( "Panel", "HUDNavigation_navMarker_" + getUniqueNumberString() ) );
-//     panel->setMaterialName ( "Orxonox/NavTDC" );
-    panel->setMaterialName( TextureGenerator::getMaterialName( "tdc.png", object->getRadarObjectColour()) );
-    panel->setDimensions ( navMarkerSize_ * xScale, navMarkerSize_ * yScale );
-//     panel->setColour( object->getRadarObjectColour() );
-    Ogre::TextAreaOverlayElement* text = static_cast<Ogre::TextAreaOverlayElement*> ( Ogre::OverlayManager::getSingleton()
-                                         .createOverlayElement ( "TextArea", "HUDNavigation_navText_" + getUniqueNumberString() ) );
-    text->setFontName ( this->fontName_ );
-    text->setCharHeight ( text->getCharHeight() * yScale );
-    text->setColour( object->getRadarObjectColour() );
-    panel->hide();
-    text->hide();
-    ObjectInfo tempStruct = {panel, text, false /*, TODO: initialize wasOutOfView_ */};
-    activeObjectList_[object] = tempStruct;
-    this->background_->addChild ( panel );
-    this->background_->addChild ( text );
-    sortedObjectList_.push_front ( std::make_pair ( object, ( unsigned int ) 0 ) );
+}
-void HUDNavigation::removeObject ( RadarViewable* viewable )
+{
-    ObjectMap::iterator it = activeObjectList_.find ( viewable );
-    if ( activeObjectList_.find ( viewable ) != activeObjectList_.end() )
+    {
-        // Detach overlays
-        this->background_->removeChild ( it->second.panel_->getName() );
-        this->background_->removeChild ( it->second.text_->getName() );
-        // Properly destroy the overlay elements (do not use delete!)
-        Ogre::OverlayManager::getSingleton().destroyOverlayElement ( it->second.panel_ );
-        Ogre::OverlayManager::getSingleton().destroyOverlayElement ( it->second.text_ );
-        // Remove from the list
-        activeObjectList_.erase ( viewable );
+    }
-    for ( sortedList::iterator listIt = sortedObjectList_.begin(); listIt != sortedObjectList_.end(); ++listIt )
+    {
-        if ( (listIt->first) == viewable )
+        {
-            sortedObjectList_.erase ( listIt );
-            break;
+        }
+    }
+}
-void HUDNavigation::objectChanged(RadarViewable* viewable)
+{
-    // TODO: niceification neccessary ;)
-    removeObject(viewable);
-    addObject(viewable);
+}
-bool HUDNavigation::showObject(RadarViewable* rv)
+{
-    if ( rv == dynamic_cast<RadarViewable*> ( this->getOwner() ) )
-        return false;
-    assert( rv->getWorldEntity() );
-    if ( rv->getWorldEntity()->isVisible()==false || rv->getRadarVisibility()==false )
-        return false;
-    return true;
+}
-void HUDNavigation::changedOwner()
+{
-    const std::set<RadarViewable*>& respawnObjects = this->getOwner()->getScene()->getRadar()->getRadarObjects();
-    for ( std::set<RadarViewable*>::const_iterator it = respawnObjects.begin(); it != respawnObjects.end(); ++it )
+    {
-        if ( ! ( *it )->isHumanShip_ )
-            this->addObject ( *it );
+    }
+}
+}

code/trunk/src/modules/overlays/hud/HUDNavigation.h

-                      r9016
+                      r9348
 #include <string>
 #include "util/OgreForwardRefs.h"
 #include "tools/interfaces/Tickable.h"
 …
 namespace orxonox
+{
 class _OverlaysExport HUDNavigation : public OrxonoxOverlay, public Tickable, public RadarListener
+{
 public:
     HUDNavigation ( BaseObject* creator );
     virtual ~HUDNavigation();
+    class _OverlaysExport HUDNavigation : public OrxonoxOverlay, public Tickable, public RadarListener
+    {
+        public:
+            HUDNavigation(BaseObject* creator);
+            virtual ~HUDNavigation();
     void setConfigValues();
+            void setConfigValues();
     virtual void XMLPort ( Element& xmlelement, XMLPort::Mode mode );
     virtual void tick ( float dt );
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void tick(float dt);
     // RadarListener interface
     virtual void addObject ( RadarViewable* object );
     virtual void removeObject ( RadarViewable* viewable );
     virtual void objectChanged ( RadarViewable* viewable );
+            // RadarListener interface
+            virtual void addObject(RadarViewable* object);
+            virtual void removeObject(RadarViewable* viewable);
+            virtual void objectChanged(RadarViewable* viewable);
     virtual void changedOwner();
     virtual void sizeChanged();
     virtual void angleChanged() { }
     virtual void positionChanged() { }
     virtual void radarTick ( float dt ) {}
+            virtual void changedOwner();
+            virtual void sizeChanged();
+            virtual void angleChanged() { }
+            virtual void positionChanged() { }
+            virtual void radarTick(float dt) {}
     inline float getRadarSensitivity() const
     { return 1.0f; }
+            inline float getRadarSensitivity() const
+                { return 1.0f; }
+    unsigned int getMarkerLimit() { return this->markerLimit_; }
+            inline unsigned int getMarkerLimit() const
+                { return this->markerLimit_; }
+private:
+    struct ObjectInfo
+    {
+        Ogre::PanelOverlayElement* panel_;
+        Ogre::TextAreaOverlayElement* text_;
+        bool outOfView_;
+        bool wasOutOfView_;
+        private:
+            struct ObjectInfo
+            {
+                Ogre::PanelOverlayElement* panel_;
+                Ogre::TextAreaOverlayElement* text_;
+                bool outOfView_;
+                bool wasOutOfView_;
+            };
+            bool showObject(RadarViewable* rv);
+            // XMLPort accessors
+            inline void setNavMarkerSize(float size)
+            {
+                navMarkerSize_ = size;
+                this->sizeChanged();
+            }
+            inline float getNavMarkerSize() const
+                { return navMarkerSize_; }
+            inline void setDetectionLimit(float limit)
+                { this->detectionLimit_ = limit; }
+            inline float getDetectionLimit() const
+                { return this->detectionLimit_; }
+            void setTextSize(float size);
+            float getTextSize() const;
+            void setFont(const std::string& font);
+            const std::string& getFont() const;
+            float getArrowSizeX(int dist) const;
+            float getArrowSizeY(int dist) const;
+            std::map<RadarViewable*, ObjectInfo> activeObjectList_;
+            std::list<std::pair<RadarViewable*, unsigned int> > sortedObjectList_;
+            float navMarkerSize_;
+            std::string fontName_;
+            float textSize_;
+            bool showDistance_;
+            unsigned int markerLimit_;
+            float detectionLimit_; //!< Objects that are more far away than detectionLimit_ are not displayed on the HUD. 10000.0f is the default value.
     };
-    bool showObject( RadarViewable* rv );
-    // XMLPort accessors
-    void setNavMarkerSize ( float size )
-        { navMarkerSize_ = size; this->sizeChanged(); }
-    float getNavMarkerSize() const
-        { return navMarkerSize_; }
-    void setDetectionLimit( float limit )
-        { this->detectionLimit_ = limit; }
-    float getDetectionLimit() const
-        { return this->detectionLimit_; }
-    void setTextSize ( float size );
-    float getTextSize() const;
-    void setFont ( const std::string& font );
-    const std::string& getFont() const;
-    typedef std::map<RadarViewable*, ObjectInfo > ObjectMap;
-    ObjectMap activeObjectList_;
-    typedef std::list < std::pair<RadarViewable*, unsigned int > > sortedList;
-    sortedList sortedObjectList_;
-    float getArrowSizeX(int dist);
-    float getArrowSizeY(int dist);
-    float navMarkerSize_;
-    std::string fontName_;
-    float textSize_;
-    bool showDistance;
-    unsigned int markerLimit_;
-    float detectionLimit_; //!< Objects that are more far away than detectionLimit_ are not displayed on the HUD. 10000.0f is the default value.
-};
+}

code/trunk/src/modules/overlays/hud/HUDRadar.cc

-                      r8891
+                      r9348
     void HUDRadar::addObject(RadarViewable* object)
+    {
         if (object == dynamic_cast<RadarViewable*>(this->owner_))
+        if (object == orxonox_cast<RadarViewable*>(this->owner_))
             return;
         if( showObject(object) == false ) //do not show objects that are "invisible" or "radar invisible"
 …
     bool HUDRadar::showObject(RadarViewable* rv)
+    {
         if ( rv == dynamic_cast<RadarViewable*> ( this->getOwner() ) )
+        if ( rv == orxonox_cast<RadarViewable*> ( this->getOwner() ) )
             return false;
         assert( rv->getWorldEntity() );

code/trunk/src/modules/pickup/CMakeLists.txt

-                      r7163
+                      r9348
 SET_SOURCE_FILES(PICKUP_SRC_FILES
   CollectiblePickup.cc
-  DroppedPickup.cc
   Pickup.cc
   PickupCollection.cc
-  PickupCollectionIdentifier.cc
   PickupManager.cc
   PickupRepresentation.cc

code/trunk/src/modules/pickup/CollectiblePickup.cc

-                      r7494
+                      r9348
         Registers the object and initializes variables.
     */
     CollectiblePickup::CollectiblePickup() : isInCollection_(false)
+    CollectiblePickup::CollectiblePickup() : collection_(NULL)
+    {
         RegisterObject(CollectiblePickup);
-        this->collection_ = NULL;
+    }
 …
     CollectiblePickup::~CollectiblePickup()
+    {
+    }
+    /**
+    @brief
+        Is called by OrxonoxClass::destroy() before the object is actually destroyed.
+    */
+    void CollectiblePickup::preDestroy(void)
+    {
+        this->Pickupable::preDestroy();
+        // The PickupCollection has to be destroyed as well.
+        if(this->isInCollection())
+            this->collection_->Pickupable::destroy();
+    }
+    /**
+    @brief
+        Destroys a Pickupable.
+    */
+    void CollectiblePickup::destroyPickup(void)
+    {
+        if(!this->isInCollection()) // If the CollectiblePickup is not in a PickupCollection the destroyPickup method of Pickupable is called.
+            this->Pickupable::destroyPickup();
+        else // Else the ColectiblePickup is dropped and disabled,
+        {
+            this->drop(false);
+            if(this->isInCollection() && this->isEnabled()) // It is only disabled if it is enabled and still ina PickupCollection after having been dropped.
+            {
+                this->setDisabled();
+                this->collection_->pickupDisabled();
+            }
+        }
+    }
+    /**
+    @brief
+        Is called by the PickupCarrier when it is being destroyed.
+    */
+    void CollectiblePickup::carrierDestroyed(void)
+    {
+        if(!this->isInCollection())
+            this->Pickupable::destroy();
+        else // If the CollectiblePickup is part of a PickupCollection it is just dropped instead of destroyed.
+            this->drop(false);
+        if (this->isInCollection())
+            this->collection_->removePickupable(this);
+    }
 …
     /**
     @brief
         Adds this CollectiblePickup to the input PickupCollection.
+        Notifies this CollectiblePickup that it was added to a PickupCollection.
     @param collection
         A pointer to the PickupCollection to which the CollectiblePickup should be added.
-    @return
-        Returns true if the CollectiblePickup was successfully added to the PickupCollection.
     */
     bool CollectiblePickup::addToCollection(PickupCollection* collection)
+    void CollectiblePickup::wasAddedToCollection(PickupCollection* collection)
+    {
-        if(this->isInCollection() || collection == NULL) //If the CollectiblePickup already is in a PickupCollection or if the input pointer is NULL.
-            return false;
-        this->isInCollection_ = true;
         this->collection_ = collection;
-        return true;
+    }
     /**
     @brief
+        Removes this CollectiblePickup from its PickupCollection.
+    @return
+        Returns true if the CollectiblePickup was succcessfully removed.
+        Notifies this CollectiblePickup that it was removed from its PickupCollection.
     */
     bool CollectiblePickup::removeFromCollection(void)
+    void CollectiblePickup::wasRemovedFromCollection(void)
+    {
-        if(!this->isInCollection()) //If the CollectiblePickup is not in a PickupCollection.
-            return false;
-        this->isInCollection_ = false;
         this->collection_ = NULL;
-        return true;
+    }
+}

code/trunk/src/modules/pickup/CollectiblePickup.h

-                      r7547
+                      r9348
     class _PickupExport CollectiblePickup : public Pickupable
+    {
+        friend class PickupCollection;
         public:
 …
             */
             bool isInCollection(void) const
+                { return this->isInCollection_; }
+            bool addToCollection(PickupCollection* collection); //!< Adds this CollectiblePickup to the input PickupCollection.
+            bool removeFromCollection(void); //!< Removes this CollectiblePickup from its PickupCollection.
+            void carrierDestroyed(void); //!< Is called by the PickupCarrier when it is being destroyed.
+        protected:
+            virtual void preDestroy(void); //!< Is called by OrxonoxClass::destroy() before the object is actually destroyed.
+            virtual void destroyPickup(void); //!< Destroys a Pickupable.
+                { return this->collection_ != NULL; }
         private:
+            bool isInCollection_; //!< True if the CollectiblePickup is in a PickupCollection.
+            void wasAddedToCollection(PickupCollection* collection);
+            void wasRemovedFromCollection(void);
             PickupCollection* collection_; //!< A pointer to the PickupCollection this CollectiblePickup is in.
     };
+}

code/trunk/src/modules/pickup/Pickup.cc

-                      r8864
+                      r9348
 #include "util/StringUtils.h"
+#include "pickup/PickupIdentifier.h"
+#include "DroppedPickup.h"
+#include "PickupSpawner.h"
 namespace orxonox
 …
     /**
     @brief
-        Initializes the PickupIdentififer of this Pickup.
-    */
-    void Pickup::initializeIdentifier(void)
+    {
-        std::string val1 = this->getActivationType();
-        std::string type1 = "activationType";
-        this->pickupIdentifier_->addParameter(type1, val1);
-        std::string val2 = this->getDurationType();
-        std::string type2 = "durationType";
-        this->pickupIdentifier_->addParameter(type2, val2);
+    }
-    /**
-    @brief
         Method for creating a Pickup object through XML.
     */
 …
         SUPER(Pickup, XMLPort, xmlelement, mode);
+        XMLPortParam(Pickup, "activationType", setActivationType, getActivationType, xmlelement, mode);
+        XMLPortParam(Pickup, "durationType", setDurationType, getDurationType, xmlelement, mode);
+        this->initializeIdentifier();
+        XMLPortParam(Pickup, "representation", setRepresentationName, getRepresentationName, xmlelement, mode);
+        XMLPortParam(Pickup, "activationType", setActivationTypeAsString, getActivationTypeAsString, xmlelement, mode);
+        XMLPortParam(Pickup, "durationType", setDurationTypeAsString, getDurationTypeAsString, xmlelement, mode);
+    }
 …
         Returns a string containing the activation type.
     */
     const std::string& Pickup::getActivationType(void) const
+    const std::string& Pickup::getActivationTypeAsString(void) const
+    {
         switch(this->activationType_)
+        switch(this->getActivationType())
+        {
             case pickupActivationType::immediate:
 …
         Returns a string containing the duration type.
     */
     const std::string& Pickup::getDurationType(void) const
+    const std::string& Pickup::getDurationTypeAsString(void) const
+    {
         switch(this->durationType_)
+        switch(this->getDurationType())
+        {
             case pickupDurationType::once:
 …
         The activation type of the Pickup as a string.
     */
     void Pickup::setActivationType(const std::string& type)
+    void Pickup::setActivationTypeAsString(const std::string& type)
+    {
         if(type == Pickup::activationTypeImmediate_s)
             this->activationType_ = pickupActivationType::immediate;
+            this->setActivationType(pickupActivationType::immediate);
         else if(type == Pickup::activationTypeOnUse_s)
             this->activationType_ = pickupActivationType::onUse;
+            this->setActivationType(pickupActivationType::onUse);
         else
             orxout(internal_error, context::pickups) << "Invalid activationType '" << type << "' in " << this->getIdentifier()->getName() << "." << endl;
 …
         The duration type of the Pickup as a string.
     */
     void Pickup::setDurationType(const std::string& type)
+    void Pickup::setDurationTypeAsString(const std::string& type)
+    {
         if(type == Pickup::durationTypeOnce_s)
             this->durationType_ = pickupDurationType::once;
+            this->setDurationType(pickupDurationType::once);
         else if(type == Pickup::durationTypeContinuous_s)
             this->durationType_ = pickupDurationType::continuous;
+            this->setDurationType(pickupDurationType::continuous);
         else
             orxout(internal_error, context::pickups) << "Invalid durationType '" << type << "' in " << this->getIdentifier()->getName() << "." << endl;
 …
     /**
     @brief
-        Creates a duplicate of the OrxonoxClass.
-    @param item
-        A reference to the pointer of the item that we're duplicating.
-    */
-    void Pickup::clone(OrxonoxClass*& item)
+    {
-        if(item == NULL)
-            item = new Pickup(this);
-        SUPER(Pickup, clone, item);
-        Pickup* pickup = dynamic_cast<Pickup*>(item);
-        pickup->setActivationTypeDirect(this->getActivationTypeDirect());
-        pickup->setDurationTypeDirect(this->getDurationTypeDirect());
-        pickup->initializeIdentifier();
+    }
-    /**
-    @brief
         Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
-        This method must be implemented by any class directly inheriting from Pickupable. It is most easily done by just creating a new DroppedPickup, e.g.:
-        DroppedPickup(BaseObject* creator, Pickupable* pickup, const Vector3& position);
     @return
         Returns true if a spawner was created, false if not.
 …
     bool Pickup::createSpawner(void)
+    {
         new DroppedPickup(this, this, this->getCarrier());
+        PickupSpawner::createDroppedPickup(this, this, this->getCarrier());
         return true;
+    }

code/trunk/src/modules/pickup/Pickup.h

-                      r8108
+                      r9348
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual const std::string& getRepresentationName() const
+                { return this->representationName_; }
             /**
             @brief Get the activation type of the Pickup.
             @return Returns the activation type of the Pickup.
             */
             inline pickupActivationType::Value getActivationTypeDirect(void) const
+            inline pickupActivationType::Value getActivationType(void) const
                 { return this->activationType_; }
             /**
 …
             @return Returns the duration type of the Pickup.
             */
             inline pickupDurationType::Value getDurationTypeDirect(void) const
+            inline pickupDurationType::Value getDurationType(void) const
                 { return this->durationType_; }
             const std::string& getActivationType(void) const; //!< Get the activation type of the Pickup.
             const std::string& getDurationType(void) const; //!< Get the duration type of the Pickup.
+            const std::string& getActivationTypeAsString(void) const; //!< Get the activation type of the Pickup.
+            const std::string& getDurationTypeAsString(void) const; //!< Get the duration type of the Pickup.
             /**
 …
             */
             inline bool isImmediate(void) const
                 { return this->getActivationTypeDirect() == pickupActivationType::immediate; }
+                { return this->getActivationType() == pickupActivationType::immediate; }
             /**
             @brief Get whether the activation type is 'onUse'.
 …
             */
             inline bool isOnUse(void) const
                 { return this->getActivationTypeDirect() == pickupActivationType::onUse; }
+                { return this->getActivationType() == pickupActivationType::onUse; }
             /**
             @brief Get whether the duration type is 'once'.
 …
             */
             inline bool isOnce(void) const
                 { return this->getDurationTypeDirect() == pickupDurationType::once; }
+                { return this->getDurationType() == pickupDurationType::once; }
             /**
             @brief Get whether the duration type is 'continuous'.
 …
             */
             inline bool isContinuous(void) const
                 { return this->getDurationTypeDirect() == pickupDurationType::continuous; }
+                { return this->getDurationType() == pickupDurationType::continuous; }
             virtual void changedPickedUp(void); //!< Should be called when the pickup has transited from picked up to dropped or the other way around.
-            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the OrxonoxClass.
         protected:
             void initializeIdentifier(void);
+            virtual bool createSpawner(void); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
+            virtual bool createSpawner(void); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
+            /**
+            @brief Sets the representation name which refers to the name of the PickupRepresentation that is used to represent this pickup.
+            */
+            inline void setRepresentationName(const std::string& name)
+                { this->representationName_ = name; }
             /**
 …
             @param type The activation type of the Pickup.
             */
             inline void setActivationTypeDirect(pickupActivationType::Value type)
+            inline void setActivationType(pickupActivationType::Value type)
                 { this->activationType_ = type; }
             /**
 …
             @param type The duration type of the Pickup.
             */
             inline void setDurationTypeDirect(pickupDurationType::Value type)
+            inline void setDurationType(pickupDurationType::Value type)
                 { this->durationType_ = type; }
             void setActivationType(const std::string& type); //!< Set the activation type of the Pickup.
             void setDurationType(const std::string& type); //!< Set the duration type of the Pickup.
+            void setActivationTypeAsString(const std::string& type); //!< Set the activation type of the Pickup.
+            void setDurationTypeAsString(const std::string& type); //!< Set the duration type of the Pickup.
         private:
             void initialize(void); //!< Initializes the member variables.
+            std::string representationName_; //!< The name of the associated PickupRepresentation.
             pickupActivationType::Value activationType_; //!< The activation type of the Pickup.
             pickupDurationType::Value durationType_; //!< The duration type of the Pickup.

code/trunk/src/modules/pickup/PickupCollection.cc

-                      r8305
+                      r9348
 #include "CollectiblePickup.h"
+#include "DroppedPickup.h"
+#include "PickupCollectionIdentifier.h"
+#include "PickupSpawner.h"
 #include "PickupCollection.h"
 …
         The creator of the object.
     */
     PickupCollection::PickupCollection(BaseObject* creator) : BaseObject(creator), pickupCollectionIdentifier_(NULL)
+    PickupCollection::PickupCollection(BaseObject* creator) : BaseObject(creator)
+    {
         RegisterObject(PickupCollection);
-        this->pickupCollectionIdentifier_ = new PickupCollectionIdentifier(this);
-        this->usedCounter_ = 0;
-        this->pickedUpCounter_ = 0;
-        this->disabledCounter_ = 0;
         this->processingUsed_ = false;
         this->processingPickedUp_ = false;
 …
         Destructor. Iterates through all Pickupables this PickupCollection consists of and destroys them if they haven't been already.
     */
     PickupCollection::~ PickupCollection()
+    PickupCollection::~PickupCollection()
+    {
         // Destroy all Pickupables constructing this PickupCollection.
         for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
             (*it)->removeFromCollection();
+        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
+        {
+            (*it)->wasRemovedFromCollection();
             (*it)->destroy();
+        }
         this->pickups_.clear();
-        if(this->pickupCollectionIdentifier_ != NULL)
-            delete this->pickupCollectionIdentifier_;
+    }
 …
         SUPER(PickupCollection, XMLPort, xmlelement, mode);
+        XMLPortParam(PickupCollection, "representation", setRepresentationName, getRepresentationName, xmlelement, mode);
         XMLPortObject(PickupCollection, CollectiblePickup, "pickupables", addPickupable, getPickupable, xmlelement, mode);
-        this->initializeIdentifier();
+    }
-    /**
-    @brief
-        Initializes the PickupIdentifier for this pickup.
-    */
-    void PickupCollection::initializeIdentifier(void)
+    {
-        for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
-            this->pickupCollectionIdentifier_->addPickup((*it)->getPickupIdentifier());
+        }
+    }
 …
         this->processingUsed_ = true;
         // Change used for all Pickupables this PickupCollection consists of.
         for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
             (*it)->setUsed(this->isUsed());
 …
             return;
+        size_t numPickupsEnabled = 0;
+        size_t numPickupsInUse = 0;
+        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
+        {
+            if ((*it)->isEnabled())
+                ++numPickupsEnabled;
+            if ((*it)->isUsed())
+                ++numPickupsInUse;
+        }
         // If all the pickups are not in use but the PickupCollection is.
         if(this->usedCounter_ == 0 && this->isUsed())
+        if(numPickupsInUse == 0 && this->isUsed())
             this->setUsed(false);
         // If all the enabled pickups are in use but the PickupCollection is not.
         if(this->usedCounter_ != 0 && this->usedCounter_ == this->pickups_.size()-this->disabledCounter_ && !this->isUsed())
+        if(numPickupsInUse > 0 && numPickupsInUse == numPickupsEnabled && !this->isUsed())
             this->setUsed(true);
+    }
 …
         // Change the PickupCarrier for all Pickupables this PickupCollection consists of.
         for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
+        {
             if(this->getCarrier() == NULL)
 …
         this->processingPickedUp_ = true;
         // Change the pickedUp status for all Pickupables this PickupCollection consists of.
         for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
             (*it)->setPickedUp(this->isPickedUp());
+        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); )
+            (*(it++))->setPickedUp(this->isPickedUp());
         this->processingPickedUp_ = false;
 …
             return;
+        // If at least all the enabled pickups of this PickupCollection are no longer picked up.
+        if(this->pickedUpCounter_ <= this->disabledCounter_ && this->isPickedUp())
+        // If at least all the enabled pickups of this PickupCollection are no longer picked up.
+        bool isOnePickupEnabledAndPickedUp = false;
+        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
+        {
+            if ((*it)->isEnabled() && (*it)->isPickedUp())
+            {
+                isOnePickupEnabledAndPickedUp = true;
+                break;
+            }
+        }
+        if(!isOnePickupEnabledAndPickedUp && this->isPickedUp())
             this->Pickupable::destroy();
-        // If the PickupCollection is no longer picked up.
-        if(!this->isPickedUp())
-            this->pickedUpCounter_ = 0;
+    }
-    /**
-    @brief
-        Creates a duplicate of the input Pickupable.
-        This method needs to be implemented by any Class inheriting from Pickupable.
-    @param item
-        A reference to a pointer to the OrxonoxClass that is to be duplicated.
-    */
-    void PickupCollection::clone(OrxonoxClass*& item)
+    {
-        if(item == NULL)
-            item = new PickupCollection(this);
-        SUPER(PickupCollection, clone, item);
-        PickupCollection* pickup = dynamic_cast<PickupCollection*>(item);
-        // Clone all Pickupables this PickupCollection consist of.
-        for(std::vector<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        {
-            Pickupable* newPickup = (*it)->clone();
-            CollectiblePickup* collectible = static_cast<CollectiblePickup*>(newPickup);
-            pickup->addPickupable(collectible);
+        }
-        pickup->initializeIdentifier();
+    }
 …
     bool PickupCollection::isTarget(const PickupCarrier* carrier) const
+    {
         for(std::vector<CollectiblePickup*>::const_iterator it = this->pickups_.begin(); it != this->pickups_.end(); it++)
+        for(std::list<CollectiblePickup*>::const_iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
+        {
             if(!carrier->isTarget(*it))
 …
         return true;
+    }
-    /**
-    @brief
-        Get the PickupIdentifier of this PickupCollection.
-        This is in fact the PickupCollectionIdentifier.
-    @return
-        Returns a pointer to the PickupIdentifier of this PickupCollection.
-    */
-    const PickupIdentifier* PickupCollection::getPickupIdentifier(void) const
+    {
-        return this->pickupCollectionIdentifier_;
+    }
 …
             return false;
-        pickup->addToCollection(this);
         this->pickups_.push_back(pickup);
+        pickup->wasAddedToCollection(this);
+        this->pickupsChanged();
         return true;
+    }
 …
     const Pickupable* PickupCollection::getPickupable(unsigned int index) const
+    {
+        return this->pickups_[index];
+        if(this->pickups_.size() >= index)
+            return NULL;
+        std::list<CollectiblePickup*>::const_iterator it = this->pickups_.begin();
+        std::advance(it, index);
+        return *it;
+    }
+    /**
+    @brief
+        Removes the Pickup from the Collection.
+    @param pickup
+        The Pickup to be removed.
+    @return
+        Returns true if the pickup was in the collection.
+    */
+    bool PickupCollection::removePickupable(CollectiblePickup* pickup)
+    {
+        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
+        {
+            if (*it == pickup)
+            {
+                this->pickups_.erase(it);
+                pickup->wasRemovedFromCollection();
+                this->pickupsChanged();
+                return true;
+            }
+        }
+        return false;
+    }
 …
         This is used internally by the CollectiblePickup class.
     @param changed
         The value the used status has changed to.
+        The value the used status has changed to.
     */
     void PickupCollection::pickupChangedUsed(bool changed)
+    {
-        if(changed)
-            this->usedCounter_++;
-        else
-            this->usedCounter_--;
         this->changedUsedAction();
+    }
 …
     void PickupCollection::pickupChangedPickedUp(bool changed)
+    {
-        if(changed)
-            this->pickedUpCounter_++;
-        else
-            this->pickedUpCounter_--;
         this->changedPickedUpAction();
+    }
 …
     void PickupCollection::pickupDisabled(void)
+    {
+        this->disabledCounter_++;
+    }
+    /**
+    @brief
+        Helpfer function if the number of pickups in this collection has changed.
+    */
+    void PickupCollection::pickupsChanged(void)
+    {
+        this->changedUsedAction();
+        this->changedPickedUpAction();
+    }
 …
     @brief
         Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
-        This method must be implemented by any class directly inheriting from Pickupable. It is most easily done by just creating a new DroppedPickup, e.g.:
-        DroppedPickup(BaseObject* creator, Pickupable* pickup, const Vector3& position);
     @return
         Returns true if a spawner was created, false if not.
 …
     bool PickupCollection::createSpawner(void)
+    {
         new DroppedPickup(this, this, this->getCarrier());
+        PickupSpawner::createDroppedPickup(this, this, this->getCarrier());
         return true;
+    }

code/trunk/src/modules/pickup/PickupCollection.h

-                      r8351
+                      r9348
         The PickupCollection combines different @ref orxonox::Pickupable "Pickupables" (more precisely @ref orxonox::CollectiblePickup "CollectiblePickups") to a coherent, single pickup and makes them seem (from the outside looking in) just as if they were just one @ref orxonox::Pickupable "Pickupable".
-        To differentiate between different types of @ref orxonox::PickupCollection "PickupCollections" (just as we differentiate between different types of @ref orxonox::Pickupable "Pickupables") we define a new identifyer called the @ref orxonox::PickupCollectionIdentifier "PickupCollectionIdentifier" which has pretty much the same properties as the @ref orxonox::PickupIdentifier "PickupIdentifier" but extende to @ref orxonox::PickupCollection "PickupCollections".
         A PickupCollection can be created in XML as follows:
         @code
 …
             virtual void changedPickedUp(void); //!< Is called when the pickup has transited from picked up to dropped or the other way around.
-            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input pickup.
             virtual bool isTarget(const PickupCarrier* carrier) const; //!< Get whether a given class, represented by the input Identifier, is a target of this PickupCollection.
+            virtual const PickupIdentifier* getPickupIdentifier(void) const; //!< Get the PickupIdentifier of this PickupCollection.
+            inline void setRepresentationName(const std::string& name)
+                { this->representationName_ = name; }
+            virtual const std::string& getRepresentationName() const
+                { return this->representationName_; }
             bool addPickupable(CollectiblePickup* pickup); //!< Add the input Pickupable to list of Pickupables combined by this PickupCollection.
             const Pickupable* getPickupable(unsigned int index) const; //!< Get the Pickupable at the given index.
+            bool removePickupable(CollectiblePickup* pickup); //!< Removes the input Pickupable from the list of Pickupables in this PickupCollection.
+            inline const std::list<CollectiblePickup*>& getPickups() const
+                { return this->pickups_; }
             void pickupChangedUsed(bool changed); //!< Informs the PickupCollection, that one of its pickups has changed its used status to the input value.
 …
         protected:
-            void initializeIdentifier(void); //!< Initializes the PickupIdentifier for this pickup.
             virtual bool createSpawner(void); //!< Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
-            PickupCollectionIdentifier* pickupCollectionIdentifier_; //!< The PickupCollectionIdentifier of this PickupCollection. Is used to distinguish different PickupCollections amongst themselves.
         private:
             void changedUsedAction(void); //!< Helper method.
             void changedPickedUpAction(void); //!< Helper method.
+            void pickupsChanged(void); //!< Helper method.
+            std::vector<CollectiblePickup*> pickups_; //!< The list of the pointers of all the Pickupables this PickupCollection consists of. They are weak pointers to facilitate testing, whether the pointers are still valid.
+            unsigned int usedCounter_; //!< Keeps track of the number of pickups of this PickupCollection, that are in use.
+            unsigned int pickedUpCounter_; //!< Keeps track of the number of pickups of this PickupCollection, that are picked up.
+            unsigned int disabledCounter_; //!< Keeps track of the number of pickups of this PickupCollection, that are disabled.
+            std::string representationName_; //!< The name of the associated PickupRepresentation.
+            std::list<CollectiblePickup*> pickups_; //!< The list of the pointers of all the Pickupables this PickupCollection consists of. They are weak pointers to facilitate testing, whether the pointers are still valid.
             bool processingUsed_; //!< Boolean to ensure, that the PickupCollection doesn't update its used status while its internal state is inconsistent.

code/trunk/src/modules/pickup/PickupManager.cc

-                      r8858
+                      r9348
         this->representations_.clear();
-        this->representationsNetworked_.clear();
         // Destroying all the PickupInventoryContainers that are still there.
 …
     /**
     @brief
+        Registers a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents, on the server (or in standalone mode).
+        For every type of Pickupable (uniquely identified by a PickupIdentifier) there can be one (and just one) PickupRepresentation registered.
+    @param identifier
+        The PickupIdentifier identifying the Pickupable.
+        Registers a PickupRepresentation.
+    @param name
+        The representation's name.
     @param representation
         A pointer to the PickupRepresentation.
 …
         Returns true if successful and false if not.
     */
+    bool PickupManager::registerRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation)
+    {
+        assert(identifier);
+    bool PickupManager::registerRepresentation(const std::string& name, PickupRepresentation* representation)
+    {
         assert(representation);
         // If the list is not empty and Pickupable already has a Representation registered.
         if(!this->representations_.empty() && this->representations_.find(identifier) != this->representations_.end())
+        if(!this->representations_.empty() && this->representations_.find(name) != this->representations_.end())
             return false;
         this->representations_[identifier] = representation;
+        this->representations_[name] = representation;
         orxout(verbose, context::pickups) << "PickupRepresentation &" << representation << " registered with the PickupManager." << endl;
 …
     /**
     @brief
+        Unegisters a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents, on the server (or in standalone mode).
+    @param identifier
+        The PickupIdentifier identifying the Pickupable.
+    @param representation
+        A pointer to the PickupRepresentation.
+        Unegisters a PickupRepresentation.
+    @param name
+        The representation's name.
     @return
         Returns true if successful and false if not.
     */
+    bool PickupManager::unregisterRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation)
+    {
+        assert(identifier);
+        assert(representation);
+        std::map<const PickupIdentifier*, PickupRepresentation*, PickupIdentifierCompare>::iterator it = this->representations_.find(identifier);
+    bool PickupManager::unregisterRepresentation(const std::string& name)
+    {
+        std::map<std::string, PickupRepresentation*>::iterator it = this->representations_.find(name);
         if(it == this->representations_.end()) // If the Pickupable is not registered in the first place.
             return false;
 …
         this->representations_.erase(it);
         orxout(verbose, context::pickups) << "PickupRepresentation &" << representation << " unregistered with the PickupManager." << endl;
+        orxout(verbose, context::pickups) << "PickupRepresentation &" << name << " unregistered with the PickupManager." << endl;
         return true;
+    }
 …
     /**
     @brief
+        Registers a PickupRepresentation on the host it was created.
+    @param representation
+        A pointer to the PickupRepresentation.
+    @return
+        Returns true if successful, false if not.
+    */
+    bool PickupManager::registerRepresentation(PickupRepresentation* representation)
+    {
+        assert(representation);
+        // If the list is not empty and PickupRepresentation is already registered.
+        if(!this->representationsNetworked_.empty() && this->representationsNetworked_.find(representation->getObjectID()) != this->representationsNetworked_.end())
+            return false;
+        this->representationsNetworked_[representation->getObjectID()] = representation;
+        return true;
+    }
+    /**
+    @brief
+        Unregisters a PickupRepresentation on the host it is being destroyed (which is the same host on which it was created).
+    @param representation
+        A pointer to the Pickuprepresentation.
+    @return
+        Returns true if successful, false if not.
+    */
+    bool PickupManager::unregisterRepresentation(PickupRepresentation* representation)
+    {
+        assert(representation);
+        std::map<uint32_t, PickupRepresentation*>::iterator it = this->representationsNetworked_.find(representation->getObjectID());
+        if(it == this->representationsNetworked_.end()) // If the Pickupable is not registered in the first place.
+            return false;
+        this->representationsNetworked_.erase(it);
+        return true;
+    }
+    /**
+    @brief
+        Get the PickupRepresentation representing the Pickupable with the input PickupIdentifier.
+    @param identifier
+        The PickupIdentifier.
+        Get the PickupRepresentation with the given name.
+    @param name
+        The name of the PickupRepresentation.
     @return
         Returns a pointer to the PickupRepresentation.
     */
     PickupRepresentation* PickupManager::getRepresentation(const PickupIdentifier* identifier)
+    {
         std::map<const PickupIdentifier*, PickupRepresentation*, PickupIdentifierCompare>::iterator it = this->representations_.find(identifier);
         if(it == this->representations_.end()) // If there is no PickupRepresentation associated with the input PickupIdentifier.
+    PickupRepresentation* PickupManager::getRepresentation(const std::string& name)
+    {
+        std::map<std::string, PickupRepresentation*>::iterator it = this->representations_.find(name);
+        if(it == this->representations_.end()) // If there is no PickupRepresentation associated with the input name.
+        {
             orxout(verbose, context::pickups) << "PickupManager::getRepresentation() returned default representation." << endl;
 …
+        {
             // If there is no PickupRepresentation registered the default representation is used.
             if(this->representations_.find(pickup->getPickupIdentifier()) == this->representations_.end())
                 PickupManager::pickupChangedPickedUpNetwork(index, pickup->isUsable(), this->defaultRepresentation_->getObjectID(), pickedUp);
+            if(this->representations_.find(pickup->getRepresentationName()) == this->representations_.end())
+                PickupManager::pickupChangedPickedUpNetwork(index, pickup->isUsable(), this->defaultRepresentation_->getObjectID(), pickup->getRepresentationName(), pickedUp);
             else
                 PickupManager::pickupChangedPickedUpNetwork(index, pickup->isUsable(), this->representations_[pickup->getPickupIdentifier()]->getObjectID(), pickedUp);
+                PickupManager::pickupChangedPickedUpNetwork(index, pickup->isUsable(), this->representations_[pickup->getRepresentationName()]->getObjectID(), pickup->getRepresentationName(), pickedUp);
+        }
         // If the concerned host is somewhere in the network, we call pickupChangedPickedUpNetwork() on its PickupManager.
 …
+        {
             // If there is no PickupRepresentation registered the default representation is used.
             if(this->representations_.find(pickup->getPickupIdentifier()) == this->representations_.end())
+            if(this->representations_.find(pickup->getRepresentationName()) == this->representations_.end())
+            {
                 callStaticNetworkFunction(PickupManager::pickupChangedPickedUpNetwork, clientId, index, pickup->isUsable(), this->defaultRepresentation_->getObjectID(), pickedUp);
 …
             else
+            {
                 callStaticNetworkFunction(PickupManager::pickupChangedPickedUpNetwork, clientId, index, pickup->isUsable(), this->representations_[pickup->getPickupIdentifier()]->getObjectID(), pickedUp);
+                callStaticNetworkFunction(PickupManager::pickupChangedPickedUpNetwork, clientId, index, pickup->isUsable(), this->representations_[pickup->getRepresentationName()]->getObjectID(), pickedUp);
+            }
+        }
 …
         The pickedUp status the Pickupable changed to.
     */
     /*static*/ void PickupManager::pickupChangedPickedUpNetwork(uint32_t pickup, bool usable, uint32_t representationObjectId, bool pickedUp)
+    /*static*/ void PickupManager::pickupChangedPickedUpNetwork(uint32_t pickup, bool usable, uint32_t representationObjectId, const std::string& representationName, bool pickedUp)
+    {
         PickupManager& manager = PickupManager::getInstance(); // Get the PickupManager singleton on this host.
 …
             container->unusable = false;
             container->representationObjectId = representationObjectId;
+            container->representationName = representationName;
             // Insert the container into the pickupInventoryContainers_ list.
             manager.pickupInventoryContainers_.insert(std::pair<uint32_t, PickupInventoryContainer*>(pickup, container));
 …
             manager.updateGUI(); // Tell the PickupInventory that something has changed.
+        }
+    }
-    /**
-    @brief
-        Get the PickupRepresentation of an input Pickupable.
-        This method spares us the hassle to export the PickupIdentifier class to lua.
-    @param pickup
-        The number identifying the Pickupable whose PickupRepresentation should be returned.
-    @return
-        Returns the PickupRepresentation of the input Pickupable or NULL if an error occurred.
-    */
-    orxonox::PickupRepresentation* PickupManager::getPickupRepresentation(uint32_t pickup)
+    {
-        // Clear and rebuild the representationsNetworked_ list.
-        //TODO: Better solution?
-        this->representationsNetworked_.clear();
-        for(ObjectList<PickupRepresentation>::iterator it = ObjectList<PickupRepresentation>::begin(); it != ObjectList<PickupRepresentation>::end(); ++it)
-            this->representationsNetworked_[it->getObjectID()] = *it;
-        // Get the container belonging to the input pickup, if not found return the default representation.
-        std::map<uint32_t, PickupInventoryContainer*>::iterator it = this->pickupInventoryContainers_.find(pickup);
-        if(it == this->pickupInventoryContainers_.end())
-            return this->defaultRepresentation_;
-        // Get the PickupRepresentation of the input pickup (through the objecId of the representation stored in the PickupInventoryContainer belonging to the pickup), if not found return the default representation.
-        std::map<uint32_t, PickupRepresentation*>::iterator it2 = this->representationsNetworked_.find(it->second->representationObjectId);
-        if(it2 == this->representationsNetworked_.end())
-            return this->defaultRepresentation_;
-        return it2->second;
+    }

code/trunk/src/modules/pickup/PickupManager.h

-                      r8706
+                      r9348
 #include "core/WeakPtr.h"
-#include "pickup/PickupIdentifier.h"
 #include "PickupRepresentation.h"
 …
         bool unusable; //!< Whether the @ref orxonox::Pickupable "Pickupable" is droppable.
         uint32_t representationObjectId; //!< The objectId of the @ref orxonox::PickupRepresentation "PickupRepresentation" that represents the @ref orxonox::Pickupable "Pickupable".
+        std::string representationName; //!< The name of the associated PickupRepresentation
     };
     // tolua_end
 …
         The PickupManager class manages @ref orxonox::Pickupable "Pickupables".
         It has in essence two tasks to fulfill. Firstly it must link @ref orxonox::Pickupable "Pickupables" (through their @ref orxonox::PickupIdentifier "PickupIdentifiers") to their respective @ref orxonox::PickupRepresentation "PickupRepresentations". Secondly it manages the PickupInventory. (The PickupInventory is the GUI that displays @ref orxonox::Pickupable "Pickupables" for the covenience of the user.)
+        It has in essence two tasks to fulfill. Firstly it must link @ref orxonox::Pickupable "Pickupables" (through their representation-name attribute) to the respective @ref orxonox::PickupRepresentation "PickupRepresentations". Secondly it manages the PickupInventory. (The PickupInventory is the GUI that displays @ref orxonox::Pickupable "Pickupables" for the covenience of the user.)
         @section PickupManagerTechnicalDetails Technical details
 …
         Firstly there are a number of lists (where by list I really mean any kind of ordered data structure) kept.
+        - The @ref orxonox::PickupManager::representations_ "representations_" list links @ref orxonox::PickupRepresentation "PickupRepresentations" with @ref orxonox::PickupIdentifier "PickupIdentifiers" and can be used to get the @ref orxonox::PickupRepresentation "PickupRepresentation" for a given @ref orxonox::Pickupable "Pickupable". It is only populated on the server (or in standalone mode). Each @ref orxonox::PickupRepresentation "PickupRepresentation" that is generated through XML registers itself with the PickupManager and is thereby added to the list.
+        - The @ref orxonox::PickupManager::representationsNetworked_ "representationsNetworked_" list is the networked (hence the name) equivalent to the @ref orxonox::PickupManager::representations_ "representations_" list. It links an objectId of a @ref orxonox::PickupRepresentation "PickupRepresentation" to a @ref orxonox::PickupRepresentation "PickupRepresentation". This list is maintained on all hosts, each representation registers itself (in its constructor) with the PickupManager. Since the representations are synchronised they are created on each host. The "same" instance on each host is identified by the same objectId and that is why we store the representations with the objectId as key. We can then use this list to get a @ref orxonox::PickupRepresentation "PickupRepresentation" for a specific @ref orxonox::Pickupable "Pickupable" (or more precisely a number identifiying that particular pickup, but we'll see that, when we look at the next list) on a client to be used in the PickupInventory.
+        - The @ref orxonox::PickupManager::representations_ "representations_" list links @ref orxonox::PickupRepresentation "PickupRepresentations" with its name and can be used to get the @ref orxonox::PickupRepresentation "PickupRepresentation" for a given @ref orxonox::Pickupable "Pickupable". It is only populated on the server (or in standalone mode). Each @ref orxonox::PickupRepresentation "PickupRepresentation" that is generated through XML registers itself with the PickupManager and is thereby added to the list.
         - The @ref orxonox::PickupManager::pickupInventoryContainers_ "pickupInventoryContainers_" list links a number identifying a @ref orxonox::Pickupable "Pickupable" to a data structure (the @ref orxonox::PickupInventoryContainer "PickupInventoryContainer"), which contains all necessary information about that @ref orxonox::Pickupable "Pickupable". This list is maintained on all hosts, a new container is inserted when a @ref orxonox::Pickupable "Pickupable" is picked up, but only if it has been picked up by the repsective host. This list is then used by the PickupInventory to access the required information and to get the correct @ref orxonox::PickupRepresentation "PickupRepresentation".
         - The @ref orxonox::PickupManager::pickups_ "pickups_" list links a number identifiying a @ref orxonox::Pickupable "Pickupable" to a (weak pointer to a) @ref orxonox::Pickupable "Pickupable". It is only maintained by the server (or in standalone mode), to be able to use, unuse and drop @ref orxonox::Pickupable "Pickupables" through the PickupInventory. Since @ref orxonox::Pickupable "Pickupables" only exist on the server a client that wants to change a pickups status has so send a request over the network (with the number identifying the pickup) to the server and then the server facilitates the change, using this list to map from the identifyer to the actual @ref orxonox::Pickupable "Pickupable".
 …
             static PickupManager& getInstance() { return Singleton<PickupManager>::getInstance(); } // tolua_export
             bool registerRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation); //!< Registers a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents.
             bool unregisterRepresentation(const PickupIdentifier* identifier, PickupRepresentation* representation); //!< Unegisters a PickupRepresentation together with the PickupIdentifier of the Pickupable the PickupRepresentation represents.
+            bool registerRepresentation(const std::string& name, PickupRepresentation* representation);
+            bool unregisterRepresentation(const std::string& name);
+            bool registerRepresentation(PickupRepresentation* representation); //!< Registers a PickupRepresentation on the host it was created.
+            bool unregisterRepresentation(PickupRepresentation* representation); //!< Unregisters a PickupRepresentation on the host it is being destroyed.
+            PickupRepresentation* getRepresentation(const PickupIdentifier* identifier); //!< Get the PickupRepresentation representing the Pickupable with the input PickupIdentifier.
+            PickupRepresentation* getRepresentation(const std::string& name); // tolua_export
             virtual void pickupChangedUsed(Pickupable* pickup, bool used); //!< Is called by the PickupListener to notify the PickupManager, that the input Pickupable has transited to the input used state.
             static void pickupChangedUsedNetwork(uint32_t pickup, bool inUse, bool usable, bool unusable); //!< Helper method to react to the change in the used status of a Pickupable.
             virtual void pickupChangedPickedUp(Pickupable* pickup, bool pickedUp); //!< Is called by the PickupListener to notify the PickupManager, that the input Pickupable has transited to the input pickedUp state.
             static void pickupChangedPickedUpNetwork(uint32_t pickup, bool usable, uint32_t representationObjectId, bool pickedUp); //!< Helper method to react to the change in the pickedUp status of a Pickupable.
+            static void pickupChangedPickedUpNetwork(uint32_t pickup, bool usable, uint32_t representationObjectId, const std::string& representationName, bool pickedUp); //!< Helper method to react to the change in the pickedUp status of a Pickupable.
         // Methods to be used by the PickupInventory.
         public:
             // tolua_begin
-            orxonox::PickupRepresentation* getPickupRepresentation(uint32_t pickup); //!< Get the PickupRepresentation of an input indentifier for Pickupable.
             int getNumPickups(void); //!< Get the number of pickups currently picked up by the player.
             /**
 …
             PickupRepresentation* defaultRepresentation_; //!< The default PickupRepresentation.
+            std::map<const PickupIdentifier*, PickupRepresentation*, PickupIdentifierCompare> representations_; //!< Map linking PickupIdentifiers (representing types of Pickupables) and PickupRepresentations.
+            std::map<uint32_t, PickupRepresentation*> representationsNetworked_; //!< Map linking the PickupRepresentation's objectId to the PickupRepresentation itself. It is used for networking purposes.
+            std::map<std::string, PickupRepresentation*> representations_; //!< Map linking PickupRepresentations and their names.
             std::map<uint32_t, PickupInventoryContainer*> pickupInventoryContainers_; //!< Map linking a number identifying a Pickupable to a PickupInventoryContainer, which contains all necessary information about that Pickupable.

code/trunk/src/modules/pickup/PickupPrereqs.h

-                      r8706
+                      r9348
     class CollectiblePickup;
-    class DroppedPickup;
     class Pickup;
     class PickupCollection;
-    class PickupCollectionIdentifier;
     class PickupManager;
     class PickupRepresentation;
 …
     class ShieldPickup;
     class ShrinkPickup;
+    class DamageBoostPickup;
+}

code/trunk/src/modules/pickup/PickupRepresentation.cc

-                      r8858
+                      r9348
         This is primarily for use of the PickupManager in creating a default PickupRepresentation.
     */
     PickupRepresentation::PickupRepresentation() : BaseObject(NULL), Synchronisable(NULL), spawnerRepresentation_(NULL), pickup_(NULL)
+    PickupRepresentation::PickupRepresentation() : BaseObject(NULL), Synchronisable(NULL), spawnerRepresentation_(NULL)
+    {
         RegisterObject(PickupRepresentation);
 …
         Default Constructor. Registers the object and initializes its member variables.
     */
     PickupRepresentation::PickupRepresentation(BaseObject* creator) : BaseObject(creator), Synchronisable(creator), spawnerRepresentation_(NULL), pickup_(NULL)
+    PickupRepresentation::PickupRepresentation(BaseObject* creator) : BaseObject(creator), Synchronisable(creator), spawnerRepresentation_(NULL)
+    {
         RegisterObject(PickupRepresentation);
 …
         this->initialize();
         this->registerVariables();
-        PickupManager::getInstance().registerRepresentation(this); // Registers the PickupRepresentation with the PickupManager.
+    }
 …
         if(this->isInitialized())
+        {
+            if(GameMode::isMaster() && this->pickup_ != NULL)
+            {
+                PickupManager::getInstance().unregisterRepresentation(this->pickup_->getPickupIdentifier(), this);
+            }
+            PickupManager::getInstance().unregisterRepresentation(this);
+        }
+            PickupManager::getInstance().unregisterRepresentation(this->getName());
+    }
 …
         XMLPortParam(PickupRepresentation, "spawnerTemplate", setSpawnerTemplate, getSpawnerTemplate, xmlelement, mode);
         XMLPortParam(PickupRepresentation, "inventoryRepresentation", setInventoryRepresentation, getInventoryRepresentation, xmlelement, mode);
-        XMLPortObject(PickupRepresentation, Pickupable, "pickup", setPickup, getPickup, xmlelement, mode);
         XMLPortObject(PickupRepresentation, StaticEntity, "spawner-representation", setSpawnerRepresentation, getSpawnerRepresentationIndex, xmlelement, mode);
-        if(GameMode::isMaster())
+        {
-            // Registers the PickupRepresentation with the PickupManager through the PickupIdentifier of the Pickupable it represents.
-            PickupManager::getInstance().registerRepresentation(this->pickup_->getPickupIdentifier(), this);
+        }
-        if(this->spawnerRepresentation_ != NULL)
-            this->spawnerRepresentation_->setVisible(false);
         orxout(verbose, context::pickups) << "PickupRepresentation created: name: '" << this->name_ << "', description: '" << this->description_ << "', spawnerTemplate: '" << this->spawnerTemplate_ << "'." << endl;
 …
         Returns a pointer to the StaticEntity.
     */
     StaticEntity* PickupRepresentation::getSpawnerRepresentation(PickupSpawner* spawner)
+    StaticEntity* PickupRepresentation::createSpawnerRepresentation(PickupSpawner* spawner)
+    {
         if(this->spawnerRepresentation_ == NULL)
 …
             if(this->spawnerTemplate_ == "")
+            {
                 orxout(verbose, context::pickups) << "PickupRepresentation: Spawner template is empty." << endl;
+                orxout(internal_warning, context::pickups) << "PickupRepresentation: Spawner template is empty." << endl;
                 // If neither spawnerRepresentation nor spawnerTemplate was specified
                 return this->getDefaultSpawnerRepresentation(spawner);
 …
+        }
+        StaticEntity* representation = this->spawnerRepresentation_;
+        representation->setVisible(true);
+        this->spawnerRepresentation_->setVisible(true);
+        StaticEntity* temp = this->spawnerRepresentation_;
+        this->spawnerRepresentation_ = NULL;
         this->addTemplate(this->spawnerTemplate_);
         this->spawnerRepresentation_->setVisible(false);
+        return temp;
+    }
+        return representation;
+    void PickupRepresentation::changedName()
+    {
+        // Registers the PickupRepresentation with the PickupManager.
+        PickupManager::getInstance().unregisterRepresentation(this->getOldName());
+        PickupManager::getInstance().registerRepresentation(this->getName(), this);
+    }
+    void PickupRepresentation::setSpawnerRepresentation(StaticEntity* representation)
+    {
+        this->spawnerRepresentation_ = representation;
+        if(this->spawnerRepresentation_ != NULL)
+            this->spawnerRepresentation_->setVisible(false);
+    }

code/trunk/src/modules/pickup/PickupRepresentation.h

-                      r7547
+                      r9348
 #include "interfaces/Pickupable.h"
-#include "pickup/PickupIdentifier.h"
 #include "worldentities/StaticEntity.h"
 …
     /**
     @brief
         The PickupRepresentation class represents a specific pickup type (identified by its @ref orxonox::PickupIdentifier "PickupIdentifier"). It defines the information displayed in the GUI (PickupInventory) and how @ref orxonox::PickupSpawner "PickupSpawners" that spawn the pickup type look like.
+        The PickupRepresentation class represents a specific pickup type. It defines the information displayed in the GUI (PickupInventory) and how @ref orxonox::PickupSpawner "PickupSpawners" that spawn the pickup type look like.
         They are created through XML and are registered with the @ref orxonox::PickupManager "PickupManager".
 …
             spawnerTemplate = "awesomePickupRepresentation"
             inventoryRepresentation = "AwesomePickup"
+        >
+            <pickup>
+                <SomePickup />
+            </pickup>
+        </PickupRepresentation>
+        />
         @endcode
         As you might have noticed, there is a parameter called <em>spawnerTemplate</em> and also another parameter called <em>inventoryRepresentation</em>. Let's first explain the second one, <em>inventoryRepresentation</em>.
 …
             */
             inline const std::string& getInventoryRepresentation(void) const { return this->inventoryRepresentation_; } // tolua_export
-            /**
-            @brief Get the Pickupable represented by this PickupRepresentation.
-            @param index The index.
-            @return Returns (for index = 0) a pointer to the Pickupable. For index > 0 it returns NULL.
-            */
-            inline const Pickupable* getPickup(unsigned int index) const
-                { if(index == 0) return this->pickup_; return NULL; }
+            StaticEntity* getSpawnerRepresentation(PickupSpawner* spawner); //!< Get a spawnerRepresentation for a specific PickupSpawner.
+            virtual void changedName();
+            StaticEntity* createSpawnerRepresentation(PickupSpawner* spawner); //!< Create a spawnerRepresentation for a specific PickupSpawner.
         protected:
 …
             @param representation A pointer to the StaticEntity that is the spawnerRepresentation of this PickupRepresentation.
             */
             inline void setSpawnerRepresentation(StaticEntity* representation)
+                { this->spawnerRepresentation_ = representation; }
+            void setSpawnerRepresentation(StaticEntity* representation);
             /**
             @brief Set the image representing the pickup in the PickupInventory.
 …
             inline void setInventoryRepresentation(const std::string& image)
                 { this->inventoryRepresentation_ = image; }
-            /**
-            @brief Set the Pickupable that is represented by this PickupRepresentation.
-            @param pickup A pointer to the Pickupable.
-            */
-            inline void setPickup(Pickupable* pickup)
-                { this->pickup_ = pickup; }
         private:
 …
             std::string inventoryRepresentation_; //!< The name of an image representing the pickup in the PickupInventory.
-            Pickupable* pickup_; //!< The Pickupable that is represented by this PickupRepresentation.
     }; // tolua_export

code/trunk/src/modules/pickup/PickupSpawner.cc

-                      r8891
+                      r9348
         Pointer to the object which created this item.
     */
     PickupSpawner::PickupSpawner(BaseObject* creator) : StaticEntity(creator), pickup_(NULL)
+    PickupSpawner::PickupSpawner(BaseObject* creator) : StaticEntity(creator), pickup_(NULL), representation_(NULL), pickupTemplate_(NULL)
+    {
         RegisterObject(PickupSpawner);
         this->initialize();
+    }
-    /**
-    @brief
-        Constructor, Creates a fully functional PickupSpawner.
-    @param creator
-        The creator of this PickupSpawner.
-    @param pickup
-        The Pickupable to be spawned by this PickupSpawner.
-    @param triggerDistance
-        The distance at which the PickupSpawner will trigger.
-    @param respawnTime
-        The minimum time between two spawns.
-    @param maxSpawnedItems
-        The maximum number of items spawned by this PickupSpawner.
-    */
-    PickupSpawner::PickupSpawner(BaseObject* creator, Pickupable* pickup, float triggerDistance, float respawnTime, int maxSpawnedItems) : StaticEntity(creator), pickup_(NULL)
+    {
-        RegisterObject(PickupSpawner);
-        this->initialize();
-        this->pickup_ = pickup;
-        this->triggerDistance_ = triggerDistance;
-        this->respawnTime_ = respawnTime;
-        this->setMaxSpawnedItems(maxSpawnedItems);
-        if(this->pickup_ == NULL)
+        {
-            orxout(internal_warning, context::pickups) << "A PickupSpawner was created without a valid Pickupable. This won't work." << endl;
-            this->setActive(false);
+        }
-        else
+        {
-            PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(this->pickup_->getPickupIdentifier());
-            this->attach(representation->getSpawnerRepresentation(this));
-            this->setActive(true);
+        }
+    }
 …
         this->spawnsRemaining_ = INF;
         this->selfDestruct_ = false;
+        this->setPickupable(NULL);
+    }
 …
         if(this->isInitialized() && this->selfDestruct_ && this->pickup_ != NULL)
             this->pickup_->destroy();
+    }
+    /**
+    @brief
+        Factory method, Creates a fully functional PickupSpawner.
+    @param creator
+        The creator of this PickupSpawner.
+    @param pickup
+        The Pickupable to be spawned by this PickupSpawner.
+    @param carrier
+        The PickupCarrier that carried the input pickup before it was dropped.
+    @param triggerDistance
+        The distance at which the PickupSpawner will trigger.
+    */
+    /*static*/ PickupSpawner* PickupSpawner::createDroppedPickup(BaseObject* creator, Pickupable* pickup, PickupCarrier* carrier, float triggerDistance)
+    {
+        PickupSpawner* spawner = new PickupSpawner(creator);
+        spawner->setPickupable(pickup);
+        spawner->setTriggerDistance(triggerDistance);
+        spawner->setMaxSpawnedItems(1);
+        spawner->setPosition(carrier->getCarrierPosition());
+        spawner->block(carrier);
+        return spawner;
+    }
 …
         SUPER(PickupSpawner, XMLPort, xmlelement, mode);
+        XMLPortObject(PickupSpawner, Pickupable, "pickup", setPickupable, getPickupable, xmlelement, mode);
+        XMLPortParam(PickupSpawner, "pickup", setPickupTemplateName, getPickupTemplateName, xmlelement, mode);
         XMLPortParam(PickupSpawner, "triggerDistance", setTriggerDistance, getTriggerDistance, xmlelement, mode);
         XMLPortParam(PickupSpawner, "respawnTime", setRespawnTime, getRespawnTime, xmlelement, mode);
         XMLPortParam(PickupSpawner, "maxSpawnedItems", setMaxSpawnedItems, getMaxSpawnedItems, xmlelement, mode);
-        if(this->pickup_ == NULL)
+        {
-            orxout(internal_warning, context::pickups) << "A PickupSpawner was created without a valid Pickupable. This won't work." << endl;
-            this->setActive(false);
+        }
-        else
+        {
-            PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(this->pickup_->getPickupIdentifier());
-            this->attach(representation->getSpawnerRepresentation(this));
-            this->setActive(true);
+        }
+    }
-    /**
-    @brief
-        Invoked when the activity has changed. Sets visibility of attached objects.
-    */
-    void PickupSpawner::changedActivity()
+    {
-        SUPER(PickupSpawner, changedActivity);
-        if(GameMode::isMaster())
-            this->setVisible(this->isActive());
+    }
 …
                 Vector3 distance = it->getWorldPosition() - this->getWorldPosition();
                 PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(*it);
+                PickupCarrier* carrier = static_cast<PickupCarrier*>(*it);
                 // If a PickupCarrier, that fits the target-range of the Pickupable spawned by this PickupSpawner, is in trigger-distance and the carrier is not blocked.
                 if(distance.length() < this->triggerDistance_ && carrier != NULL && this->blocked_.find(carrier) == this->blocked_.end())
 …
     /**
     @brief
+        Trigger the PickupSpawner.
+        Adds the pickup to the Pawn that triggered, sets the timer to re-activate and deactives the PickupSpawner.
+    @param carrier
+        Carrier which triggered the PickupSpawner.
+    */
+    void PickupSpawner::trigger(PickupCarrier* carrier)
+    {
+        orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") triggered and active." << endl;
+        PickupCarrier* target = carrier->getTarget(this->pickup_);
+        this->block(carrier);
+        assert(target);
+        bool pickedUp = this->pickup_->pickup(target);
+        assert(pickedUp);
+        pickedUp = false; // To avoid compiler warning.
+        this->setPickupable(NULL);
+        this->decrementSpawnsRemaining();
+    }
+    void PickupSpawner::setPickupTemplateName(const std::string& name)
+    {
+        Template* temp = Template::getTemplate(name);
+        if (temp)
+            this->setPickupTemplate(temp);
+    }
+    void PickupSpawner::setPickupTemplate(Template* temp)
+    {
+        this->pickupTemplate_ = temp;
+        this->pickupTemplateName_ = temp->getName();
+        this->setPickupable(this->createPickup());
+    }
+    /**
+    @brief
         Sets the maximum number of spawned items.
     @param items
 …
             this->spawnsRemaining_--;
+        this->setActive(false);
         if(this->spawnsRemaining_ != 0 && this->respawnTime_ > 0)
+        {
             this->startRespawnTimer();
-            this->setActive(false);
             this->fireEvent();
+        }
 …
+        {
             orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") empty, selfdestruct initialized." << endl;
-            this->setActive(false);
             this->destroy();
+        }
 …
+    {
         this->respawnTimer_.setTimer(this->respawnTime_, false, createExecutor(createFunctor(&PickupSpawner::respawnTimerCallback, this)));
+    }
+    /**
+    @brief
+        Invoked by the timer, re-activates the PickupSpawner.
+    */
+    void PickupSpawner::respawnTimerCallback()
+    {
+        orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") reactivated." << endl;
+        this->setPickupable(this->createPickup());
+    }
+    /**
+    @brief
+        Creates a new Pickupable.
+    @return
+        The Pickupable created.
+    */
+    Pickupable* PickupSpawner::createPickup(void)
+    {
+        if(this->spawnsRemaining_ == 0)
+        {
+            orxout(internal_error, context::pickups) << "Massive Error: PickupSpawner still alive until having spawned last item." << endl;
+            return NULL;
+        }
+        if (this->pickupTemplate_ != NULL)
+        {
+            Identifier* identifier = this->pickupTemplate_->getBaseclassIdentifier();
+            if (identifier != NULL)
+            {
+                Pickupable* pickup = orxonox_cast<Pickupable*>(identifier->fabricate(this));
+                orxonox_cast<BaseObject*>(pickup)->addTemplate(this->pickupTemplate_);
+                return pickup;
+            }
+            else
+                orxout(internal_error, context::pickups) << "No base class defined in pickup-template " << this->pickupTemplateName_ << endl;
+        }
+        return NULL;
+    }
 …
     void PickupSpawner::setPickupable(Pickupable* pickup)
+    {
+        if(this->pickup_ != NULL)
+        {
+            orxout(internal_error, context::pickups) << "In PickupSpawner (&" << this << "): setPickupable called, with this->pickup_ already set." << endl;
+            return;
+        }
+        if(pickup == NULL)
+        {
+            orxout(internal_error, context::pickups) << "In PickupSpawner (&" << this << "): Argument of setPickupable is NULL." << endl;
+            return;
+        if (this->representation_ != NULL)
+        {
+            this->representation_->destroy();
+            this->representation_ = NULL;
+        }
+        if (pickup != NULL)
+        {
+            if (this->pickup_ != NULL)
+                this->pickup_->destroy();
+            PickupRepresentation* representation = PickupManager::getInstance().getRepresentation(pickup->getRepresentationName());
+            this->representation_ = representation->createSpawnerRepresentation(this);
+            this->attach(this->representation_);
+            this->setActive(true);
+        }
+        else
+        {
+            this->setActive(false);
+        }
         this->pickup_ = pickup;
+    }
-    /**
-    @brief
-        Get the Pickupable that is spawned by this PickupSpawner.
-    @return
-        Returns the Pickupable that is spawned by this PickupSpawner.
-    */
-    const Pickupable* PickupSpawner::getPickupable(void) const
+    {
-        return this->pickup_;
+    }
-    /**
-    @brief
-        Trigger the PickupSpawner.
-        Adds the pickup to the Pawn that triggered, sets the timer to re-activate and deactives the PickupSpawner.
-    @param pawn
-        Pawn which triggered the PickupSpawner.
-    */
-    void PickupSpawner::trigger(Pawn* pawn)
+    {
-        if(this->isActive()) // Checks whether PickupSpawner is active.
+        {
-            orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") triggered and active." << endl;
-            PickupCarrier* carrier = dynamic_cast<PickupCarrier*>(pawn);
-            assert(carrier);
-            // If the Pawn isn't a target of the Pickupable.
-            if(!carrier->isTarget(this->pickup_))
+            {
-                orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") triggered but Pawn wasn't a target of the Pickupable." << endl;
-                return;
+            }
-            PickupCarrier* target = carrier->getTarget(this->pickup_);
-            Pickupable* pickup = this->getPickup();
-            this->block(carrier);
-            assert(pickup);
-            assert(target);
-            bool pickedUp = pickup->pickup(target);
-            assert(pickedUp);
-            pickedUp = false; // To avoid compiler warning.
-            this->decrementSpawnsRemaining();
+        }
+    }
-    /**
-    @brief
-        Creates a new Pickupable.
-    @return
-        The Pickupable created.
-    */
-    Pickupable* PickupSpawner::getPickup(void)
+    {
-        if(this->spawnsRemaining_ == 0)
+        {
-            orxout(internal_error, context::pickups) << "Massive Error: PickupSpawner still alive until having spawned last item." << endl;
-            return NULL;
+        }
-        Pickupable* pickup = this->pickup_->clone();
-        return pickup;
+    }
-    /**
-    @brief
-        Invoked by the timer, re-activates the PickupSpawner.
-    */
-    void PickupSpawner::respawnTimerCallback()
+    {
-        orxout(verbose, context::pickups) << "PickupSpawner (&" << this << ") reactivated." << endl;
-        this->setActive(true);
+    }
+}

code/trunk/src/modules/pickup/PickupSpawner.h

-                      r7549
+                      r9348
         public:
             PickupSpawner(BaseObject* creator); //!< Default Constructor.
-            PickupSpawner(BaseObject* creator, Pickupable* pickup, float triggerDistance, float respawnTime, int maxSpawnedItems); //!< Constructor.
             virtual ~PickupSpawner(); //!< Destructor.
+            static PickupSpawner* createDroppedPickup(BaseObject* creator, Pickupable* pickup, PickupCarrier* carrier, float triggerDistance = 10.0);
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);  //!< Method for creating a PickupSpawner through XML.
-            virtual void changedActivity(); //!< Invoked when activity has changed (set visibilty).
             virtual void tick(float dt); //!< Tick, checks if any Pawn is close enough to trigger.
 …
             inline int getMaxSpawnedItems(void) const
                 { return this->maxSpawnedItems_; }
+            /**
+            @brief Returns the name of the template which is used to create a pickup for this spawner.
+            */
+            inline const std::string& getPickupTemplateName() const
+                { return this->pickupTemplateName_; }
+            /**
+            @brief Returns the template which is used to create a pickup for this spawner.
+            */
+            inline Template* getPickupTemplate() const
+                {return this->pickupTemplate_; }
+        protected:
+        private:
+            void initialize(void);
+            void trigger(PickupCarrier* carrier); //!< Method called when a carrier is close enough.
+            void respawnTimerCallback(); //!< Method called when the timer runs out.
             void decrementSpawnsRemaining(void); //!< Decrements the number of remaining spawns.
             void startRespawnTimer(void); //!< Invoked by the timer, re-activates the PickupSpawner.
 …
             inline void setRespawnTime(float time)
                 { this->respawnTime_ = time; }
             void setMaxSpawnedItems(int items); //!< Sets the maximum number of spawned items.
+            virtual Pickupable* getPickup(void); //!< Creates a new Pickupable.
+            void setPickupTemplateName(const std::string& name);
+            void setPickupTemplate(Template* temp);
+            Pickupable* createPickup(void); //!< Creates a new Pickupable.
             void setPickupable(Pickupable* pickup); //!< Sets a Pickupable for the PickupSpawner to spawn.
-            const Pickupable* getPickupable(void) const; //!< Get the Pickupable that is spawned by this PickupSpawner.
             Pickupable* pickup_; //!< The pickup to be spawned.
+        private:
+            void initialize(void);
+            void trigger(Pawn* pawn); //!< Method called when a Pawn is close enough.
+            void respawnTimerCallback(); //!< Method called when the timer runs out.
+            StaticEntity* representation_; //!< The active representation of the spawner.
+            std::string pickupTemplateName_; //!< The name of the pickup template.
+            Template* pickupTemplate_; //!< The template to be used to create a pickupable.
             int maxSpawnedItems_; //!< Maximum number of items spawned by this PickupSpawner.

code/trunk/src/modules/pickup/items/CMakeLists.txt

r8706	r9348
7	7	ShieldPickup.cc
8	8	ShrinkPickup.cc
	9	DamageBoostPickup.cc
9	10	)

code/trunk/src/modules/pickup/items/DronePickup.cc

-                      r8858
+                      r9348
 #include "controllers/DroneController.h"
-#include "pickup/PickupIdentifier.h"
 #include "worldentities/Drone.h"
 #include "worldentities/pawns/Pawn.h"
 …
+    {
         this->addTarget(ClassIdentifier<Pawn>::getIdentifier());
         this->setDurationTypeDirect(pickupDurationType::once);
+        this->setDurationType(pickupDurationType::once);
         this->droneTemplate_ = "";
+    }
-    /**
-    @brief
-        Initializes the PickupIdentifier of this pickup.
-    */
-    void DronePickup::initializeIdentifier(void)
+    {
-        std::string val = this->getDroneTemplate();
-        std::string type = "droneTemplate";
-        this->pickupIdentifier_->addParameter(type, val);
+    }
 …
         SUPER(DronePickup, XMLPort, xmlelement, mode);
         XMLPortParam(DronePickup, "droneTemplate", setDroneTemplate, getDroneTemplate, xmlelement, mode);
-        this->initializeIdentifier();
+    }
 …
         The name of the Template to e set.
     */
     void DronePickup::setDroneTemplate(std::string templatename){
+    void DronePickup::setDroneTemplate(const std::string& templatename){
         droneTemplate_ = templatename;
+    }
 …
                 Controller* controller = drone->getController();
                 DroneController* droneController = dynamic_cast<DroneController*>(controller);
+                DroneController* droneController = orxonox_cast<DroneController*>(controller);
                 if(droneController != NULL)
+                {
 …
+    {
         PickupCarrier* carrier = this->getCarrier();
         Pawn* pawn = dynamic_cast<Pawn*>(carrier);
+        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
         if(pawn == NULL)
 …
         return pawn;
+    }
-    /**
-    @brief
-        Creates a duplicate of the input OrxonoxClass.
-    @param item
-        A pointer to the Orxonox class.
-    */
-    void DronePickup::clone(OrxonoxClass*& item)
+    {
-        if(item == NULL)
-            item = new DronePickup(this);
-        SUPER(DronePickup, clone, item);
-        DronePickup* pickup = dynamic_cast<DronePickup*>(item);
-        pickup->setDroneTemplate(this->getDroneTemplate());
-        pickup->initializeIdentifier();
+    }
+}

code/trunk/src/modules/pickup/items/DronePickup.h

-                      r7547
+                      r9348
             virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
-            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             const std::string& getDroneTemplate() const; //!< Get the name of the droneTemplate.
         protected:
+            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
+            void setDroneTemplate(std::string templatename); //!< Set the droneTemplate.
+            void setDroneTemplate(const std::string& templatename); //!< Set the droneTemplate.
         private:

code/trunk/src/modules/pickup/items/HealthPickup.cc

-                      r8864
+                      r9348
 #include "core/XMLPort.h"
-#include "pickup/PickupIdentifier.h"
 #include "worldentities/pawns/Pawn.h"
 …
     /**
     @brief
-        Initializes the PickupIdentifier of this pickup.
-    */
-    void HealthPickup::initializeIdentifier(void)
+    {
-        std::stringstream stream;
-        stream << this->getHealth();
-        std::string type1 = "health";
-        std::string val1 = stream.str();
-        this->pickupIdentifier_->addParameter(type1, val1);
-        std::string val2 = this->getHealthType();
-        std::string type2 = "healthType";
-        this->pickupIdentifier_->addParameter(type2, val2);
-        stream.clear();
-        stream << this->getHealthRate();
-        std::string val3 = stream.str();
-        std::string type3 = "healthRate";
-        this->pickupIdentifier_->addParameter(type3, val3);
+    }
-    /**
-    @brief
         Method for creating a HealthPickup object through XML.
     */
 …
         XMLPortParam(HealthPickup, "health", setHealth, getHealth, xmlelement, mode);
         XMLPortParam(HealthPickup, "healthRate", setHealthRate, getHealthRate, xmlelement, mode);
         XMLPortParam(HealthPickup, "healthType", setHealthType, getHealthType, xmlelement, mode);
+        XMLPortParam(HealthPickup, "healthType", setHealthTypeAsString, getHealthTypeAsString, xmlelement, mode);
         if(!this->isContinuous())
+            this->healthRate_ = 0.0f;
+        this->initializeIdentifier();
+            this->setHealthRate(0.0f); // TODO: this logic should be inside tick(), not in XMLPort
+    }
 …
             this->setHealth(this->getHealth()-health);
             switch(this->getHealthTypeDirect())
+            switch(this->getHealthType())
+            {
                 case pickupHealthType::permanent:
 …
                 float health = 0.0f;
                 switch(this->getHealthTypeDirect())
+                switch(this->getHealthType())
+                {
                     case pickupHealthType::permanent:
 …
         else
+        {
             if(this->getHealthTypeDirect() == pickupHealthType::temporary)
+            if(this->getHealthType() == pickupHealthType::temporary)
+            {
                 PickupCarrier* carrier = this->getCarrier();
                 Pawn* pawn = dynamic_cast<Pawn*>(carrier);
+                Pawn* pawn = orxonox_cast<Pawn*>(carrier);
                 if(pawn == NULL)
 …
+    {
         PickupCarrier* carrier = this->getCarrier();
         Pawn* pawn = dynamic_cast<Pawn*>(carrier);
+        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
         if(pawn == NULL)
 …
         return pawn;
+    }
-    /**
-    @brief
-        Creates a duplicate of the input OrxonoxClass.
-    @param item
-        A pointer to the Orxonox class.
-    */
-    void HealthPickup::clone(OrxonoxClass*& item)
+    {
-        if(item == NULL)
-            item = new HealthPickup(this);
-        SUPER(HealthPickup, clone, item);
-        HealthPickup* pickup = dynamic_cast<HealthPickup*>(item);
-        pickup->setHealth(this->getHealth());
-        pickup->setHealthRate(this->getHealthRate());
-        pickup->setHealthTypeDirect(this->getHealthTypeDirect());
-        pickup->initializeIdentifier();
+    }
 …
         Returns the health type as a string.
     */
     const std::string& HealthPickup::getHealthType(void) const
+    {
         switch(this->getHealthTypeDirect())
+    const std::string& HealthPickup::getHealthTypeAsString(void) const
+    {
+        switch(this->getHealthType())
+        {
             case pickupHealthType::limited:
 …
         The type as a string.
     */
     void HealthPickup::setHealthType(std::string type)
+    void HealthPickup::setHealthTypeAsString(const std::string& type)
+    {
         if(type == HealthPickup::healthTypeLimited_s)
             this->setHealthTypeDirect(pickupHealthType::limited);
+            this->setHealthType(pickupHealthType::limited);
         else if(type == HealthPickup::healthTypeTemporary_s)
             this->setHealthTypeDirect(pickupHealthType::temporary);
+            this->setHealthType(pickupHealthType::temporary);
         else if(type == HealthPickup::healthTypePermanent_s)
             this->setHealthTypeDirect(pickupHealthType::permanent);
+            this->setHealthType(pickupHealthType::permanent);
         else
             orxout(internal_error, context::pickups) << "Invalid healthType '" << type << "' in HealthPickup." << endl;

code/trunk/src/modules/pickup/items/HealthPickup.h

-                      r7551
+                      r9348
             virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
-            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             /**
 …
             @return Returns the health type as an enum.
             */
             inline pickupHealthType::Value getHealthTypeDirect(void) const
+            inline pickupHealthType::Value getHealthType(void) const
                 { return this->healthType_; }
             const std::string& getHealthType(void) const; //!< Get the health type of this pickup.
+            const std::string& getHealthTypeAsString(void) const; //!< Get the health type of this pickup.
         protected:
-            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
             void setHealth(float health); //!< Sets the health.
             void setHealthRate(float speed); //!< Set the rate at which health is transferred if the pickup is continuous.
 …
             @param type The type of this pickup as an enum.
             */
             inline void setHealthTypeDirect(pickupHealthType::Value type)
+            inline void setHealthType(pickupHealthType::Value type)
                 { this->healthType_ = type; }
             void setHealthType(std::string type); //!< Set the type of the HealthPickup.
+            void setHealthTypeAsString(const std::string& type); //!< Set the type of the HealthPickup.
         private:

code/trunk/src/modules/pickup/items/InvisiblePickup.cc

-                      r8858
+                      r9348
 #include "core/XMLPort.h"
-#include "pickup/PickupIdentifier.h"
 #include "worldentities/pawns/Pawn.h"
 …
     /**
     @brief
-        Initializes the PickupIdentifier of this pickup.
-    */
-    void InvisiblePickup::initializeIdentifier(void)
+    {
-        std::stringstream stream;
-        stream << this->getDuration();
-        std::string type1 = "duration";
-        std::string val1 = stream.str();
-        this->pickupIdentifier_->addParameter(type1, val1);
+    }
-    /**
-    @brief
         Method for creating a HealthPickup object through XML.
     */
 …
         SUPER(InvisiblePickup, XMLPort, xmlelement, mode);
         XMLPortParam(InvisiblePickup, "duration", setDuration, getDuration, xmlelement, mode);
-        this->initializeIdentifier();
+    }
 …
     /**
     @brief
-        Creates a duplicate of the input OrxonoxClass.
-    @param item
-        A pointer to the Orxonox class.
-    */
-    void InvisiblePickup::clone(OrxonoxClass*& item)
+    {
-        if(item == NULL)
-            item = new InvisiblePickup(this);
-        SUPER(InvisiblePickup, clone, item);
-        InvisiblePickup* pickup = dynamic_cast<InvisiblePickup*>(item);
-        pickup->setDuration(this->getDuration());
-        pickup->initializeIdentifier();
+    }
-    /**
-    @brief
         Sets the invisibility.
     @param invisibility
 …
+    {
         PickupCarrier* carrier = this->getCarrier();
         Pawn* pawn = dynamic_cast<Pawn*>(carrier);
+        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
         if(pawn == NULL)

code/trunk/src/modules/pickup/items/InvisiblePickup.h

-                      r7547
+                      r9348
             InvisiblePickup(BaseObject* creator); //!< Constructor.
             virtual ~InvisiblePickup(); //!< Destructor.
             virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode); //!< Method for creating a HealthPickup object through XML.
             virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
-            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             /**
 …
         protected:
-            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
             bool setInvisible(bool invisibility); //!< Set the Pawn to be invisible or visible again.
             void setDuration(float duration); //!< Sets the time the InvisibilityPickup will last.

code/trunk/src/modules/pickup/items/MetaPickup.cc

-                      r8858
+                      r9348
 #include "interfaces/PickupCarrier.h"
-#include "pickup/PickupIdentifier.h"
 #include "worldentities/pawns/Pawn.h"
 …
         this->addTarget(ClassIdentifier<PickupCarrier>::getIdentifier());
         this->setDurationTypeDirect(pickupDurationType::once);
+        this->setDurationType(pickupDurationType::once);
         this->metaType_ = pickupMetaType::none;
+    }
 …
     /**
     @brief
-        Helper method to initialize the PickupIdentifier.
-    */
-    void MetaPickup::initializeIdentifier(void)
+    {
-        std::string val = this->getMetaType();
-        std::string type = "metaType";
-        this->pickupIdentifier_->addParameter(type, val);
+    }
-    /**
-    @brief
         Method for creating a MetaPickup object through XML.
     */
 …
         SUPER(MetaPickup, XMLPort, xmlelement, mode);
+        XMLPortParam(MetaPickup, "metaType", setMetaType, getMetaType, xmlelement, mode);
+        this->initializeIdentifier();
+        XMLPortParam(MetaPickup, "metaType", setMetaTypeAsString, getMetaTypeAsString, xmlelement, mode);
+    }
 …
+        {
             PickupCarrier* carrier = this->getCarrier();
             if(this->getMetaTypeDirect() != pickupMetaType::none && carrier != NULL)
+            if(this->getMetaType() != pickupMetaType::none && carrier != NULL)
+            {
                 // If the metaType is destroyCarrier, then the PickupCarrier is destroyed.
                 if(this->getMetaTypeDirect() == pickupMetaType::destroyCarrier)
+                if(this->getMetaType() == pickupMetaType::destroyCarrier)
+                {
                     Pawn* pawn = orxonox_cast<Pawn*>(carrier);
 …
                     // If the metaType is use, then the Pickupable is set to used.
                     if(this->getMetaTypeDirect() == pickupMetaType::use && !pickup->isUsed())
+                    if(this->getMetaType() == pickupMetaType::use && !pickup->isUsed())
+                    {
                         pickup->setUsed(true);
+                    }
                     // If the metaType is drop, then the Pickupable is dropped.
                     else if(this->getMetaTypeDirect() == pickupMetaType::drop)
+                    else if(this->getMetaType() == pickupMetaType::drop)
+                    {
                         pickup->drop();
+                    }
                     // If the metaType is destroy, then the Pickupable is destroyed.
                     else if(this->getMetaTypeDirect() == pickupMetaType::destroy)
+                    else if(this->getMetaType() == pickupMetaType::destroy)
+                    {
                         pickup->Pickupable::destroy();
 …
     /**
     @brief
-        Creates a duplicate of the input OrxonoxClass.
-    @param item
-        A pointer to the Orxonox class.
-    */
-    void MetaPickup::clone(OrxonoxClass*& item)
+    {
-        if(item == NULL)
-            item = new MetaPickup(this);
-        SUPER(MetaPickup, clone, item);
-        MetaPickup* pickup = dynamic_cast<MetaPickup*>(item);
-        pickup->setMetaTypeDirect(this->getMetaTypeDirect());
-        pickup->initializeIdentifier();
+    }
-    /**
-    @brief
         Get the meta type of this MetaPickup.
     @return
         Returns a string with the meta type of the MetaPickup.
     */
     const std::string& MetaPickup::getMetaType(void) const
+    {
         switch(this->getMetaTypeDirect())
+    const std::string& MetaPickup::getMetaTypeAsString(void) const
+    {
+        switch(this->getMetaType())
+        {
             case pickupMetaType::none:
 …
         A string with the type to be set.
     */
     void MetaPickup::setMetaType(const std::string& type)
+    void MetaPickup::setMetaTypeAsString(const std::string& type)
+    {
         if(type == MetaPickup::metaTypeNone_s)
+        {
             this->setMetaTypeDirect(pickupMetaType::none);
+            this->setMetaType(pickupMetaType::none);
+        }
         else if(type == MetaPickup::metaTypeUse_s)
+        {
             this->setMetaTypeDirect(pickupMetaType::use);
+            this->setMetaType(pickupMetaType::use);
+        }
         else if(type == MetaPickup::metaTypeDrop_s)
+        {
             this->setMetaTypeDirect(pickupMetaType::drop);
+            this->setMetaType(pickupMetaType::drop);
+        }
         else if(type == MetaPickup::metaTypeDestroy_s)
+        {
             this->setMetaTypeDirect(pickupMetaType::destroy);
+            this->setMetaType(pickupMetaType::destroy);
+        }
         else if(type == MetaPickup::metaTypeDestroyCarrier_s)
+        {
             this->setMetaTypeDirect(pickupMetaType::destroyCarrier);
+            this->setMetaType(pickupMetaType::destroyCarrier);
+        }
         else

code/trunk/src/modules/pickup/items/MetaPickup.h

-                      r7547
+                      r9348
         The default value is <em>none</em>, which basically does nothing.
         The parameter <b>activation type</b> can be used to specify, whether the MetaPickup is used upon pickup (<em>immediate</em>) or not (<em>onUse</em>). With <em>immediate</em> being the default.
 …
             virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
-            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             /**
 …
             @return Returns an enum with the meta type of the MetaPickup.
             */
             inline pickupMetaType::Value getMetaTypeDirect(void) const
+            inline pickupMetaType::Value getMetaType(void) const
                 { return this->metaType_; }
             const std::string& getMetaType(void) const; //!< Get the meta type of this MetaPickup.
+            const std::string& getMetaTypeAsString(void) const; //!< Get the meta type of this MetaPickup.
         protected:
-            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
             /**
             @brief Set the meta type of the MetaPickup.
             @param type The meta type as an enum.
             */
             inline void setMetaTypeDirect(pickupMetaType::Value type)
+            inline void setMetaType(pickupMetaType::Value type)
                 { this->metaType_ =  type; }
             void setMetaType(const std::string& type); //!< Set the meta type of this MetaPickup.
+            void setMetaTypeAsString(const std::string& type); //!< Set the meta type of this MetaPickup.
         private:

code/trunk/src/modules/pickup/items/ShieldPickup.cc

-                      r8858
+                      r9348
 #include "core/XMLPort.h"
-#include "pickup/PickupIdentifier.h"
 #include "worldentities/pawns/Pawn.h"
 …
     /**
     @brief
-        Initializes the PickupIdentifier of this pickup.
-    */
-    void ShieldPickup::initializeIdentifier(void)
+    {
-        std::stringstream stream;
-        stream << this->getDuration();
-        std::string type1 = "duration";
-        std::string val1 = stream.str();
-        this->pickupIdentifier_->addParameter(type1, val1);
-        stream.clear();
-        stream << this->getShieldHealth();
-        std::string type2 = "ShieldHealth";
-        std::string val2 = stream.str();
-        this->pickupIdentifier_->addParameter(type2, val2);
-        stream.clear();
-        stream << this->getShieldAbsorption();
-        std::string type3 = "ShieldAbsorption";
-        std::string val3 = stream.str();
-        this->pickupIdentifier_->addParameter(type3, val3);
+    }
-    /**
-    @brief
         Method for creating a ShieldPickup object through XML.
     */
 …
         XMLPortParam(ShieldPickup, "shieldabsorption", setShieldAbsorption, getShieldAbsorption, xmlelement, mode);
         XMLPortParam(ShieldPickup, "duration", setDuration, getDuration, xmlelement, mode);
-        this->initializeIdentifier();
+    }
 …
+    {
         PickupCarrier* carrier = this->getCarrier();
         Pawn* pawn = dynamic_cast<Pawn*>(carrier);
+        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
         if(pawn == NULL)
 …
+        }
         return pawn;
+    }
-    /**
-    @brief
-        Creates a duplicate of the input OrxonoxClass.
-    @param item
-        A pointer to the Orxonox class.
-    */
-    void ShieldPickup::clone(OrxonoxClass*& item)
+    {
-        if(item == NULL)
-            item = new ShieldPickup(this);
-        SUPER(ShieldPickup, clone, item);
-        ShieldPickup* pickup = dynamic_cast<ShieldPickup*>(item);
-        pickup->setDuration(this->getDuration());
-        pickup->setShieldAbsorption(this->getShieldAbsorption());
-        pickup->setShieldHealth(this->getShieldHealth());
-        pickup->initializeIdentifier();
+    }

code/trunk/src/modules/pickup/items/ShieldPickup.h

-                      r7547
+                      r9348
             virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
-            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             /**
 …
         protected:
-            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
             void pickupTimerCallback(void); //!< Helper method. Is called by the Timer as soon as it expires.

code/trunk/src/modules/pickup/items/ShrinkPickup.cc

-                      r8713
+                      r9348
 #include "core/XMLPort.h"
-#include "pickup/PickupIdentifier.h"
 #include "worldentities/pawns/Pawn.h"
 …
+    }
-    void ShrinkPickup::initializeIdentifier(void)
+    {
-        std::stringstream stream;
-        stream << this->getShrinkFactor();
-        std::string type1 = "shrinkFactor";
-        std::string val1 = stream.str();
-        this->pickupIdentifier_->addParameter(type1, val1);
-        stream.clear();
-        stream << this->getDuration();
-        std::string val2 = stream.str();
-        std::string type2 = "duration";
-        this->pickupIdentifier_->addParameter(type2, val2);
-        stream.clear();
-        stream << this->getShrinkDuration();
-        std::string val3 = stream.str();
-        std::string type3 = "shrinkDuration";
-        this->pickupIdentifier_->addParameter(type3, val3);
+    }
    /**
     @brief
 …
         XMLPortParam(ShrinkPickup, "duration", setDuration, getDuration, xmlelement, mode);
         XMLPortParam(ShrinkPickup, "shrinkDuration", setShrinkDuration, getShrinkDuration, xmlelement, mode);
+        this->initializeIdentifier();
+    }
+    /**
+    @brief Sets the shrinking factor.
+    @param factor The factor, needs to greater than 1.
+    */
+    void ShrinkPickup::setShrinkFactor(float factor)
+    {
+        if(factor <= 1.0f)
+        {
+            orxout(internal_warning, context::pickups) << "Invalid shrinking factor in ShrinkPickup. Ignoring.." << endl;
+            return;
+        }
+        this->shrinkFactor_ = factor;
+    }
+    /**
+    @brief Set the duration for which the ship remains shrunken.
+    @param duration The duration, needs to be non-negative.
+    */
+    void ShrinkPickup::setDuration(float duration)
+    {
+        if(duration < 0.0f)
+        {
+            orxout(internal_warning, context::pickups) << "Invalid duration in ShrinkPickup. Ignoring.." << endl;
+            return;
+        }
+        this->duration_ = duration;
+    }
+    /**
+    @brief Set the shrink duration.
+    @param speed The shrink duration, needs to be positive.
+    */
+    void ShrinkPickup::setShrinkDuration(float speed)
+    {
+        if(speed <= 0.0f)
+        {
+            orxout(internal_warning, context::pickups) << "Invalid shrink duration in ShrinkPickup. Ignoring.." << endl;
+            return;
+        }
+        this->shrinkDuration_ = speed;
+    }
 …
+    {
         SUPER(ShrinkPickup, changedPickedUp);
         if(!this->isPickedUp() && this->isActive_)
+        {
 …
                 bool destroy = false;
                 // Stop shrinking if the desired size is reached.
                 if(this->timeRemainig_ <= 0.0f)
 …
+    {
         PickupCarrier* carrier = this->getCarrier();
         Pawn* pawn = dynamic_cast<Pawn*>(carrier);
+        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
         return pawn;
+    }
-    /**
-    @brief
-        Creates a duplicate of the input OrxonoxClass.
-    @param item
-        A pointer to the Orxonox class.
-    */
-    void ShrinkPickup::clone(OrxonoxClass*& item)
+    {
-        if(item == NULL)
-            item = new ShrinkPickup(this);
-        SUPER(ShrinkPickup, clone, item);
-        ShrinkPickup* pickup = dynamic_cast<ShrinkPickup*>(item);
-        pickup->setShrinkFactor(this->getShrinkFactor());
-        pickup->setDuration(this->getDuration());
-        pickup->setShrinkDuration(this->getShrinkDuration());
-        pickup->initializeIdentifier();
+    }
+}

code/trunk/src/modules/pickup/items/ShrinkPickup.h

-                      r8858
+                      r9348
             virtual void changedUsed(void); // Is called when the pickup has transited from used to unused or the other way around.
             virtual void changedPickedUp(void);
-            virtual void clone(OrxonoxClass*& item); // Creates a duplicate of the input OrxonoxClass.
             /**
 …
             inline float getShrinkFactor(void) const
                 { return this->shrinkFactor_; }
+            /**
+            @brief Sets the shrinking factor.
+            @param factor The factor, needs to greater than 1.
+            */
+            inline void setShrinkFactor(float factor)
+                { if(factor <= 1.0f) { orxout(internal_warning, context::pickups) << "Invalid shrinking factor in ShrinkPickup. Ignoring.." << endl; return; } this->shrinkFactor_ = factor; }
+            void setShrinkFactor(float factor);
             /**
             @brief Get the duration for which the ship remains shrunken.
 …
             inline float getDuration(void) const
                 { return this->duration_; }
+            /**
+            @brief Set the duration for which the ship remains shrunken.
+            @param duration The duration, needs to be non-negative.
+            */
+            inline void setDuration(float duration)
+                { if(duration < 0.0f) { orxout(internal_warning, context::pickups) << "Invalid duration in ShrinkPickup. Ignoring.." << endl; return; } this->duration_ = duration; }
+            void setDuration(float duration);
             /**
             @brief Get the shrink speed.
 …
             inline float getShrinkDuration(void) const
                 { return this->shrinkDuration_; }
+            /**
+            @brief Set the shrink duration.
+            @param speed The shrink duration, needs to be positive.
+            */
+            inline void setShrinkDuration(float speed)
+                { if(speed <= 0.0f) { orxout(internal_warning, context::pickups) << "Invalid shrink duration in ShrinkPickup. Ignoring.." << endl; return; } this->shrinkDuration_ = speed; }
+        protected:
+            void initializeIdentifier(void);
+            void setShrinkDuration(float speed);
         private:
 …
             float currentFactor_;       //!< The shrink factor that is currently applied.
             float timeRemainig_;        //!< The remaining shrink time.
             Pawn* carrierToPawnHelper(void);
             Timer durationTimer_;

code/trunk/src/modules/pickup/items/SpeedPickup.cc

-                      r8858
+                      r9348
 #include "core/XMLPort.h"
-#include "pickup/PickupIdentifier.h"
 #include "worldentities/pawns/SpaceShip.h"
 …
     /**
     @brief
-        Initializes the PickupIdentifier of this pickup.
-    */
-    void SpeedPickup::initializeIdentifier(void)
+    {
-        std::stringstream stream;
-        stream << this->getDuration();
-        std::string type1 = "duration";
-        std::string val1 = stream.str();
-        this->pickupIdentifier_->addParameter(type1, val1);
-        stream.clear();
-        stream << this->getSpeedAdd();
-        std::string type2 = "speedAdd";
-        std::string val2 = stream.str();
-        this->pickupIdentifier_->addParameter(type2, val2);
-        stream.clear();
-        stream << this->getSpeedMultiply();
-        std::string type3 = "speedMultiply";
-        std::string val3 = stream.str();
-        this->pickupIdentifier_->addParameter(type3, val3);
+    }
-    /**
-    @brief
         Method for creating a SpeedPickup object through XML.
     */
 …
         XMLPortParam(SpeedPickup, "speedAdd", setSpeedAdd, getSpeedAdd, xmlelement, mode);
         XMLPortParam(SpeedPickup, "speedMultiply", setSpeedMultiply, getSpeedMultiply, xmlelement, mode);
-        this->initializeIdentifier();
+    }
 …
+    {
         PickupCarrier* carrier = this->getCarrier();
         SpaceShip* ship = dynamic_cast<SpaceShip*>(carrier);
+        SpaceShip* ship = orxonox_cast<SpaceShip*>(carrier);
         if(ship == NULL)
 …
         return ship;
+    }
-    /**
-    @brief
-        Creates a duplicate of the input OrxonoxClass.
-    @param item
-        A pointer to the Orxonox class.
-    */
-    void SpeedPickup::clone(OrxonoxClass*& item)
+    {
-        if(item == NULL)
-            item = new SpeedPickup(this);
-        SUPER(SpeedPickup, clone, item);
-        SpeedPickup* pickup = dynamic_cast<SpeedPickup*>(item);
-        pickup->setDuration(this->getDuration());
-        pickup->setSpeedAdd(this->getSpeedAdd());
-        pickup->setSpeedMultiply(this->getSpeedMultiply());
-        pickup->initializeIdentifier();
+    }

code/trunk/src/modules/pickup/items/SpeedPickup.h

-                      r8727
+                      r9348
             virtual void changedUsed(void); //!< Is called when the pickup has transited from used to unused or the other way around.
-            virtual void clone(OrxonoxClass*& item); //!< Creates a duplicate of the input OrxonoxClass.
             /**
 …
         protected:
-            void initializeIdentifier(void); //!< Initializes the PickupIdentifier of this pickup.
             void pickupTimerCallback(void); //!< Function that gets called when timer ends.
 …
         private:
             void initialize(void); //!< Initializes the member variables.
             SpaceShip* carrierToSpaceShipHelper(void); //!< Helper to transform the PickupCarrier to a SpaceSHip, and throw an error message if the conversion fails.
+            SpaceShip* carrierToSpaceShipHelper(void); //!< Helper to transform the PickupCarrier to a SpaceShip, and throw an error message if the conversion fails.
             Timer durationTimer_; //!< Timer.

code/trunk/src/modules/pong/Pong.cc

-                      r9258
+                      r9348
         Is called when the player scored.
     */
     void Pong::playerScored(PlayerInfo* player)
+    {
         Deathmatch::playerScored(player);
+    void Pong::playerScored(PlayerInfo* player, int score)
+    {
+        Deathmatch::playerScored(player, score);
         if (this->center_ != NULL) // If there is a centerpoint.

code/trunk/src/modules/pong/Pong.h

r9258	r9348
73	73	virtual void spawnPlayer(PlayerInfo* player); //!< Spawns the input player.
74	74
75		virtual void playerScored(PlayerInfo* player); //!< Is called when the player scored.
	75	virtual void playerScored(PlayerInfo* player, int score = 1); //!< Is called when the player scored.
76	76
77	77	/**

code/trunk/src/modules/tetris/CMakeLists.txt

-                      r8706
+                      r9348
   TetrisCenterpoint.cc
   TetrisStone.cc
+  TetrisBrick.cc
+  TetrisScore.cc
+)
 …
   LINK_LIBRARIES
     orxonox
+    overlays
   SOURCE_FILES ${TETRIS_SRC_FILES}
+)

code/trunk/src/modules/tetris/Tetris.cc

-                      r8858
+                      r9348
  *      ...
  *   Co-authors:
+ *      ...
+ *
+ *      Johannes Ritz
+ *
+ *
+ *
+ *
+ *TASK c) end the game in a nicer way
+ *TASK d) save the highscore
+ *TASK e) eye candy
  */
 …
 #include "TetrisCenterpoint.h"
 #include "TetrisStone.h"
+#include "TetrisBrick.h"
 #include "infos/PlayerInfo.h"
 …
     @brief
         Constructor. Registers and initializes the object.
+    @ingroup Tetris
     */
     Tetris::Tetris(BaseObject* creator) : Deathmatch(creator)
 …
         RegisterObject(Tetris);
         this->activeStone_ = NULL;
+        this->activeBrick_ = 0;
         // Pre-set the timer, but don't start it yet.
         this->starttimer_.setTimer(1.0, false, createExecutor(createFunctor(&Tetris::startStone, this)));
+        this->starttimer_.setTimer(1.0, false, createExecutor(createFunctor(&Tetris::startBrick, this)));
         this->starttimer_.stopTimer();
         this->player_ = NULL;
+        this->setHUDTemplate("TetrisHUD");
+        this->futureBrick_ = 0;
+    }
 …
     void Tetris::cleanup()
+    {
+        if (this->activeBrick_)
+        {
+            this->activeBrick_->destroy();
+            this->activeBrick_ = 0;
+        }
+        if (this->futureBrick_)
+        {
+            this->futureBrick_->destroy();
+            this->futureBrick_ = 0;
+        }
+        for (std::list<SmartPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+            (*it)->destroy();
+        this->stones_.clear();
+    }
 …
         SUPER(Tetris, tick, dt);
+        if(this->activeStone_ != NULL)
+        {
+            if(!this->isValidStonePosition(this->activeStone_, this->activeStone_->getPosition()))
+            {
+                this->activeStone_->setVelocity(Vector3::ZERO);
+                this->createStone();
+                this->startStone();
+        if((this->activeBrick_ != NULL)&&(!this->hasEnded()))
+        {
+            if(!this->isValidBrickPosition(this->activeBrick_))
+            {
+                for (unsigned int i = 0; i < this->activeBrick_->getNumberOfStones(); i++)
+                    this->stones_.push_back(this->activeBrick_->getStone(i));
+                this->activeBrick_->setVelocity(Vector3::ZERO);
+                this->activeBrick_->releaseStones(this->center_);
+                this->findFullRows();
+                this->startBrick();
+            }
+        }
 …
             return false;
+        for(std::vector<TetrisStone*>::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        {
+            if(stone == *it)
+                continue;
+        for(std::list<SmartPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        {
             const Vector3& currentStonePosition = (*it)->getPosition(); //!< Saves the position of the currentStone
 …
+    }
+    /**
+    @brief
+        Check for each stone in a brick if it is moved the right way.
+    */
+    bool Tetris::isValidMove(TetrisBrick* brick, const Vector3& position, bool isRotation = false)
+    {
+        assert(brick);
+        for (unsigned int i = 0; i < brick->getNumberOfStones(); i++ )
+        {
+            TetrisStone* stone = brick->getStone(i);
+            Vector3 stonePosition; //the current stone's offset to position
+            if(isRotation)
+                stonePosition = rotateVector(stone->getPosition(), brick->getRotationCount()+1);
+            else
+                stonePosition = rotateVector(stone->getPosition(), brick->getRotationCount());
+            if(! this->isValidMove(stone, position + stonePosition ))
+            {
+                return false;
+            }
+            //catch illegal rotation (such that collisions with ground are not permitted)
+            if(isRotation)
+            {
+                if((position + stonePosition).y < this->center_->getStoneSize()/2.0f) //!< If the stone has reached the bottom of the level
+                {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     bool Tetris::isValidStonePosition(TetrisStone* stone, const Vector3& position)
+    {
         assert(stone);
+        // we use a reverse iterator because we have to check for collisions with the topmost stones first
+        for(std::vector<TetrisStone*>::const_reverse_iterator it = this->stones_.rbegin(); it != this->stones_.rend(); ++it)
+        {
+            if(stone == *it)
+        // check for collisions with all stones
+        for(std::list<SmartPtr<TetrisStone> >::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        {
+            //Vector3 currentStonePosition = rotateVector((*it)->getPosition(), this->activeBrick_->getRotationCount());
+            const Vector3& currentStonePosition = (*it)->getPosition(); //!< Saves the position of the currentStone
+            //!< Saves the position of the currentStone
+            //filter out cases where the falling stone is already below a steady stone
+            if(position.y < currentStonePosition.y - this->center_->getStoneSize()/2.0f)
                 continue;
-            const Vector3& currentStonePosition = (*it)->getPosition(); //!< Saves the position of the currentStone
             if((position.x == currentStonePosition.x) && (position.y < currentStonePosition.y + this->center_->getStoneSize()))
+            {
+                this->activeStone_->setPosition(Vector3(this->activeStone_->getPosition().x, currentStonePosition.y+this->center_->getStoneSize(), this->activeStone_->getPosition().z));
+                float y_offset = static_cast<int>((this->activeBrick_->getPosition().y-currentStonePosition.y+10)/10)*10 + currentStonePosition.y;
+                if(y_offset < 0) //filter out extreme cases (very rare bug)
+                    y_offset = 0;
+                this->activeBrick_->setPosition(Vector3(this->activeBrick_->getPosition().x, y_offset, this->activeBrick_->getPosition().z));
                 return false;
             }// This case applies if the stones overlap partially vertically
 …
         if(position.y < this->center_->getStoneSize()/2.0f) //!< If the stone has reached the bottom of the level
+        {
+            stone->setPosition(Vector3(stone->getPosition().x, this->center_->getStoneSize()/2.0f, stone->getPosition().z));
+            float yOffset = stone->getPosition().y + this->center_->getStoneSize()/2.0f;//calculate offset
+            if(yOffset < 0) //catch brake-throughs
+                yOffset = 0;
+            this->activeBrick_->setPosition(Vector3(this->activeBrick_->getPosition().x, yOffset, this->activeBrick_->getPosition().z));
             return false;
+        }
 …
         return true;
+    }
+    /**
+     * @brief This function determines wether a brick touches another brick or the ground.
+     *
+     */
+    bool Tetris::isValidBrickPosition(TetrisBrick* brick)
+    {
+        assert(brick);
+        const Vector3& brickPosition = this->activeBrick_->getPosition();
+        // check all stones in the brick
+        for (unsigned int i = 0; i < brick->getNumberOfStones(); i++ )
+        {
+            TetrisStone* stone = brick->getStone(i);
+            const Vector3& stonePosition = rotateVector(stone->getPosition(), brick->getRotationCount());
+            if(! this->isValidStonePosition(stone, brickPosition + stonePosition) )
+            {
+                // recurse because all stones have to checked again after the brick was re-positioned
+                this->isValidBrickPosition(brick);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+    @brief
+        A Vector3 is rolled 90 * degrees * amount (anticlockwise rotation)
+    */
+    Vector3 Tetris::rotateVector(Vector3 position, unsigned int amount)
+    {
+        float temp = 0;
+        for(unsigned int i = 0; i < amount; i++)
+        {
+            temp = position.x;
+            position.x = -position.y;
+            position.y = temp;
+        }
+        return position;
+    }
     /**
 …
         if (this->center_ != NULL) // There needs to be a TetrisCenterpoint, i.e. the area the game takes place.
+        {
             // Create the first stone.
             this->createStone();
+            // Create the first brick.
+            this->createBrick();
+        }
         else // If no centerpoint was specified, an error is thrown and the level is exited.
 …
     void Tetris::end()
+    {
+        this->activeBrick_->setVelocity(Vector3::ZERO);
+        if(this->activeBrick_ != NULL)
+        {
+            this->player_->stopControl();
+        }
         this->cleanup();
 …
+    }
+    /**
+    @brief
+        Starts the first stone.
+    */
+    void Tetris::startStone(void)
+    void Tetris::startBrick(void)
+    {
         if(this->player_ == NULL)
 …
         unsigned int cameraIndex = 0;
         if(this->activeStone_ != NULL)
+        if(this->activeBrick_ != NULL)
+        {
             // Get camera settings
             cameraIndex = this->activeStone_->getCurrentCameraIndex();
+            cameraIndex = this->activeBrick_->getCurrentCameraIndex();
             this->player_->stopControl();
+        }
+        // Make the last stone to be created the active stone.
+        this->activeStone_ = this->stones_.back();
+        this->player_->startControl(this->activeStone_);
+        this->activeStone_->setVelocity(0.0f, -this->center_->getStoneSpeed(), 0.0f);
+        this->activeStone_->setCameraPosition(cameraIndex);
+    }
+    /**
+    @brief
+        Creates a new stone.
+    */
+    void Tetris::createStone(void)
+    {
+        // Create a new stone and add it to the list of stones.
+        TetrisStone* stone = new TetrisStone(this->center_);
+        this->stones_.push_back(stone);
+        // Apply the stone template to the stone.
+        stone->addTemplate(this->center_->getStoneTemplate());
+        // Attach the stone to the Centerpoint and set the position of the stone to be at the top middle.
+        this->center_->attach(stone);
+            // destroy old active brick
+            this->activeBrick_->destroy();
+        }
+        // Make the last brick to be created the active brick.
+        this->activeBrick_ = this->futureBrick_;
+        this->futureBrick_ = 0;
+        // set its position
+        this->player_->startControl(this->activeBrick_);
         float xPos = (this->center_->getWidth()/2 + ((this->center_->getWidth() % 2)*2-1)/2.0f)*this->center_->getStoneSize();
         float yPos = (this->center_->getHeight()-0.5f)*this->center_->getStoneSize();
+        stone->setPosition(xPos, yPos, 0.0f);
+        stone->setGame(this);
+    }
+        this->activeBrick_->setPosition(xPos, yPos, 0.0f);
+        this->activeBrick_->setVelocity(0.0f, -this->center_->getStoneSpeed(), 0.0f);
+        this->activeBrick_->setCameraPosition(cameraIndex);
+        // create a new future brick
+        this->createBrick();
+        // check if the new brick is in a valid position, otherwise end the game
+        if (!this->isValidBrickPosition(this->activeBrick_))
+            this->end();
+    }
+    void Tetris::createBrick(void)             //TODO: random rotation offset between 0 and 3 (times 90°)
+    {
+        // create new futureBrick_
+        this->futureBrick_ = new TetrisBrick(this->center_);
+        // Apply the stone template to the stone.
+        this->futureBrick_->addTemplate(this->center_->getBrickTemplate());
+        // Attach the brick to the Centerpoint and set the position of the brick to be at the left side.
+        this->center_->attach(this->futureBrick_);
+        float xPos = (this->center_->getWidth()*1.6f + ((this->center_->getWidth() % 2)*2-1)/2.0f)*this->center_->getStoneSize();
+        float yPos = (this->center_->getHeight()-5.1f)*this->center_->getStoneSize();
+        this->futureBrick_->setPosition(xPos, yPos, 0.0f);
+        this->futureBrick_->setGame(this);
+    }
     /**
 …
+    }
+    /*TetrisCenterpoint* Tetris::getCenterpoint(void) const
+    {
+        return this->center_;
+    }*/
     /**
     @brief Set the TetrisCenterpoint (the playing field).
 …
+    }
+    /**
+    @brief Check each row if it is full. Removes all full rows. Update
+    @brief Manages score.
+    */
+    void Tetris::findFullRows()
+    {
+        unsigned int correctPosition = 0;
+        unsigned int stonesPerRow = 0;
+        for (unsigned int row = 0; row < this->center_->getHeight(); row++)
+        {
+            stonesPerRow = 0;
+            for(std::list<SmartPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
+            {
+                std::list<SmartPtr<TetrisStone> >::iterator it_temp = it++;
+                correctPosition = static_cast<unsigned int>(((*it_temp)->getPosition().y - 5)/this->center_->getStoneSize());
+                if(correctPosition == row)
+                {
+                    stonesPerRow++;
+                    if(stonesPerRow == this->center_->getWidth())
+                    {
+                        clearRow(row);
+                        row--; //the row counter has to be decreased in order to detect multiple rows!
+                        this->playerScored(this->player_);// add points
+                        //increase the stone's speed
+                        this->center_->setStoneSpeed(this->center_->getStoneSpeed()+1.0f);
+                    }
+                }
+            }
+        }
+    }
+    void Tetris::clearRow(unsigned int row)
+    {// clear the full row
+        for(std::list<SmartPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); )
+        {
+            if(static_cast<unsigned int>(((*it)->getPosition().y - 5)/this->center_->getStoneSize()) == row)
+            {
+                (*it)->destroy();
+                this->stones_.erase(it++);
+            }
+            else
+                ++it;
+        }
+      // adjust height of stones above the deleted row //TODO: check if this could be a source of a bug.
+        for(std::list<SmartPtr<TetrisStone> >::iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        {
+            if(static_cast<unsigned int>(((*it)->getPosition().y - 5)/this->center_->getStoneSize()) > row)
+                (*it)->setPosition((*it)->getPosition()-Vector3(0,10,0));
+        }
+    }
+}

code/trunk/src/modules/tetris/Tetris.h

-                      r8706
+                      r9348
         public:
             Tetris(BaseObject* creator); //!< Constructor. Registers and initializes the object.
             virtual ~Tetris(); //!< Destructor. Cleans up, if initialized.
+            virtual ~Tetris(); //!< Destructor. Cleans up, if initialized.
             virtual void start(void); //!< Starts the Tetris minigame.
 …
             PlayerInfo* getPlayer(void) const; //!< Get the player.
+            WeakPtr<TetrisCenterpoint> getCenterpoint(void)
+                { return this->center_; }
             bool isValidMove(TetrisStone* stone, const Vector3& position);
+            bool isValidMove(TetrisBrick* brick, const Vector3& position, bool isRotation);
+            Vector3 rotateVector(Vector3 position, unsigned int amount);
         protected:
             virtual void spawnPlayersIfRequested(); //!< Spawns player.
         private:
             void startStone(void); //!< Starts with the first stone.
             void createStone(void);
+            void startBrick(void);
+            void createBrick(void);
             void cleanup(void); //!< Cleans up the Gametype by destroying the ball and the bats.
             bool isValidStonePosition(TetrisStone* stone, const Vector3& position);
+            bool isValidBrickPosition(TetrisBrick* brick);
+            void findFullRows(void);
+            void clearRow(unsigned int row);
             PlayerInfo* player_;
             WeakPtr<TetrisCenterpoint> center_; //!< The playing field.
             std::vector<TetrisStone*> stones_; //!< A list of all stones in play.
             std::vector< std::vector<bool> > grid_;
             TetrisStone* activeStone_;
+            std::list<SmartPtr<TetrisStone> > stones_; //!< A list of all stones in play.
+            WeakPtr<TetrisBrick> activeBrick_;
+            WeakPtr<TetrisBrick> futureBrick_;
             Timer starttimer_; //!< A timer to delay the start of the game.
     };

code/trunk/src/modules/tetris/TetrisCenterpoint.cc

-                      r8706
+                      r9348
     @file TetrisCenterpoint.cc
     @brief Implementation of the TetrisCenterpoint class.
+    @ingroup Tetris
 */
 …
         this->stoneSize_ = 10.0f;
         this->stoneTemplate_ = "";
+        this->brickTemplate_ = "";
         this->stoneSpeed_ = 20.0f;
 …
         XMLPortParam(TetrisCenterpoint, "width", setWidth, getWidth, xmlelement, mode); // die Breite
         XMLPortParam(TetrisCenterpoint, "height", setHeight, setWidth, xmlelement, mode); // die Grösse
+        XMLPortParam(TetrisCenterpoint, "height", setHeight, getHeight, xmlelement, mode); // die Grösse //was sollte das mit setWidth??
         XMLPortParam(TetrisCenterpoint, "stoneSize", setStoneSize, getStoneSize, xmlelement, mode);
         XMLPortParam(TetrisCenterpoint, "stoneTemplate", setStoneTemplate, getStoneTemplate, xmlelement, mode);
+        XMLPortParam(TetrisCenterpoint, "brickTemplate", setBrickTemplate, getBrickTemplate, xmlelement, mode);
         XMLPortParam(TetrisCenterpoint, "stoneSpeed", setStoneSpeed, getStoneSpeed, xmlelement, mode);
+    }

code/trunk/src/modules/tetris/TetrisCenterpoint.h

-                      r8706
+                      r9348
 namespace orxonox
+{
+{//idea: add 2 triggers to the centerpoint (one to determine when a box would go above the centerpoint;
+//the other to find out when the lowest row is filled totally)
     /**
 …
             /**
+            @brief Set the template for the bricks.
+            @param template The template name to be applied to each brick.
+            */
+            void setBrickTemplate(const std::string& templateName)
+                { this->brickTemplate_ = templateName; }
+            /**
+            @brief Get the template for the bricks.
+            @return Returns the template name to be applied to each brick.
+            */
+            const std::string& getBrickTemplate(void) const
+                { return this->brickTemplate_; }
+            /**
             @brief Set the speed of the stones.
             @param speed The speed to be set.
 …
             float stoneSize_;
             std::string stoneTemplate_;
+            std::string brickTemplate_;
             float stoneSpeed_;

code/trunk/src/modules/tetris/TetrisPrereqs.h

r8706	r9348
68	68	class TetrisCenterpoint;
69	69	class TetrisStone;
	70	class TetrisBrick;
	71	class TetrisScore;
70	72	}
71	73

code/trunk/src/modules/tetris/TetrisStone.cc

-                      r8706
+                      r9348
     @file TetrisStone.cc
     @brief Implementation of the TetrisStone class.
+    @ingroup Tetris
 */
 …
         Constructor. Registers and initializes the object.
     */
     TetrisStone::TetrisStone(BaseObject* creator) : ControllableEntity(creator)
+    TetrisStone::TetrisStone(BaseObject* creator) : MovableEntity(creator)
+    {
         RegisterObject(TetrisStone);
         this->size_ = 10.0f;
         this->delay_ = false;
         this->delayTimer_.setTimer(0.2f, false, createExecutor(createFunctor(&TetrisStone::enableMovement, this)));
+        this->lockRotation_ = false;
+    }
 …
     void TetrisStone::moveFrontBack(const Vector2& value)
+    {
         if(value.x < 0)
+        if(value.x < 0) //speedup on key down
+        {
             this->setVelocity(this->getVelocity()*1.1);
+        }
+        else if(!this->lockRotation_) //rotate when key up is pressed
+        {
+            this->lockRotation_ = true; // multiple calls of this function have to be filtered out.
+            this->rotationTimer_.setTimer(0.1f, false, createExecutor(createFunctor(&TetrisStone::unlockRotation, this)));
+            Quaternion q(Degree(90), Vector3::UNIT_Z);
+            this->setOrientation(this->getOrientation()*q); //rotation: roll 90°
+        }
+    }

code/trunk/src/modules/tetris/TetrisStone.h

-                      r8706
+                      r9348
 #include "tetris/TetrisPrereqs.h"
 #include "worldentities/ControllableEntity.h"
+#include "worldentities/MovableEntity.h"
 #include "tools/Timer.h"
 …
     @ingroup Tetris
     */
     class _TetrisExport TetrisStone : public ControllableEntity
+    class _TetrisExport TetrisStone : public MovableEntity
+    {
         public:
 …
             void enableMovement(void)
                 { this->delay_ = false; }
+            void unlockRotation(void)
+                { this->lockRotation_ = false; }
             float size_; //!< The dimensions a stone has in the game world.
             bool delay_;
+            bool lockRotation_;
             Timer delayTimer_;
+            Timer rotationTimer_; ///!< This timer is used to filter out multiple rotation inputs.
             Tetris* tetris_;

code/trunk/src/modules/weapons/RocketController.cc

r8858	r9348
53	53	this->rocket_ = new SimpleRocket(this);
54	54	this->rocket_->setController(this);
55		this->setControllableEntity(~~dynamic_cast<ControllableEntity*>~~ (this->rocket_));
	55	this->setControllableEntity(orxonox_cast<ControllableEntity*>(this->rocket_));
56	56	}
57	57

code/trunk/src/orxonox/CMakeLists.txt

r8858	r9348
50	50	ADD_SUBDIRECTORY(items)
51	51	ADD_SUBDIRECTORY(overlays)
52		~~ADD_SUBDIRECTORY(pickup)~~
53	52	ADD_SUBDIRECTORY(sound)
54	53	ADD_SUBDIRECTORY(weaponsystem)

code/trunk/src/orxonox/CameraManager.cc

r8079	r9348
48	48	CameraManager::CameraManager()
49	49	{
	50	RegisterRootObject(CameraManager);
	51
50	52	assert(GameMode::showsGraphics());
51	53	}

code/trunk/src/orxonox/LevelInfo.cc

-                      r9016
+                      r9348
     // LevelInfoItem
     //! The list of allowed tags.
     /*static*/ std::set<std::string> LevelInfoItem::possibleTags_s = std::set<std::string>();
 …
             LevelInfoItem::possibleTags_s.insert("gametype");
             LevelInfoItem::possibleTags_s.insert("minigame");
+            LevelInfoItem::possibleTags_s.insert("shipselection");
+        }
+    }
 …
         SubString substr = SubString(tags, ",", " "); // Split the string into tags.
         const std::vector<std::string>& strings = substr.getAllStrings();
+        for (std::vector<std::string>::const_iterator it = strings.begin(); it != strings.end(); it++)
+            this->addTag(*it, false);
+        this->tagsUpdated();
+    }
+    /**
+    @brief
+        Set the starting ship models of the level
+    @param tags
+        A comma-seperated string of all the allowed ship models for the shipselection.
+    */
+    void LevelInfoItem::setStartingShips(const std::string& ships)
+    {
+        SubString substr = SubString(ships, ",", " "); // Split the string into tags.
+        const std::vector<std::string>& strings = substr.getAllStrings();
         for(std::vector<std::string>::const_iterator it = strings.begin(); it != strings.end(); it++)
             this->addTag(*it, false);
         this->tagsUpdated();
+            this->addStartingShip(*it, false);
+        this->startingshipsUpdated();
+    }
 …
     /**
     @brief
+        Add a ship model to allowed models for the shipselection
+    @param ship
+        The ship model to be added.
+    @param update
+        Whether the comma-seperated string of all ship models should be updated. Default is true.
+    @return
+        Returns true if the ship was successfully added, if the ship was already present it returns false.
+    */
+    bool LevelInfoItem::addStartingShip(const std::string& ship, bool update)
+    {
+        bool success = this->startingShips_.insert(ship).second;
+        if(update && success)
+            this->startingshipsUpdated();
+        return success;
+    }
+    /**
+    @brief
         Updates the comma-seperated string of all tags, if the set of tags has changed.
     */
 …
+    }
+    /**
+    @brief
+        Updates the comma-seperated string of all ships, if the set of tags has changed.
+    */
+    void LevelInfoItem::startingshipsUpdated(void)
+    {
+        std::stringstream stream;
+        std::set<std::string>::iterator temp;
+        for(std::set<std::string>::iterator it = this->startingShips_.begin(); it != this->startingShips_.end(); )
+        {
+            temp = it;
+            if(++it == this->startingShips_.end()) // If this is the last ship we don't add a comma.
+                stream << *temp;
+            else
+                stream << *temp << ", ";
+        }
+        this->startingShipsString_ = std::string(stream.str());
+    }
+    void LevelInfoItem::changeStartingShip(const std::string& model)
+    {
+        static std::string shipSelectionTag = "shipselection";
+        //HACK: Read Level XML File, find "shipselection", replace with ship model
+        std::string levelPath = "../levels/";
+        levelPath.append(this->getXMLFilename());
+        std::string tempPath = "../levels/";
+        tempPath.append("_temp.oxw");
+        orxout(user_status) << levelPath << endl;
+        orxout(user_status) << tempPath << endl;
+        std::ifstream myLevel (levelPath.c_str());
+        std::ofstream tempLevel (tempPath.c_str());
+        while(!myLevel.eof())
+        {
+            std::string buff;
+            std::getline(myLevel, buff);
+            std::string pawndesignString = "pawndesign=";
+            size_t found = buff.find(pawndesignString.append(shipSelectionTag));
+            if (found!= std::string::npos)
+                buff = buff.substr(0, found + 11) + model + buff.substr(found+11+shipSelectionTag.length(), std::string::npos);
+            tempLevel.write(buff.c_str(), buff.length());
+            tempLevel << std::endl;
+        }
+        myLevel.close();
+        tempLevel.close();
+        orxout(user_status) << "done" << endl;
+    }
     // LevelInfo
 …
         XMLPortParam(LevelInfo, "screenshot", setScreenshot, getScreenshot, xmlelement, mode);
         XMLPortParam(LevelInfo, "tags", setTags, getTags, xmlelement, mode);
+        XMLPortParam(LevelInfo, "startingships", setStartingShips, getStartingShips, xmlelement, mode);
+    }
 …
         info->setScreenshot(this->getScreenshot());
         info->setTags(this->getTags());
+        info->setStartingShips(this->getStartingShips());
         return info;
+    }

code/trunk/src/orxonox/LevelInfo.h

-                      r9016
+                      r9348
 #include "core/BaseObject.h"
+#include <iostream>
+#include <fstream>
 #include "core/OrxonoxClass.h"
 …
             */
             inline const std::string& getName(void) const { return this->name_; } // tolua_export
             /**
             @brief Set the screenshot of the Level.
 …
             inline bool hasTag(const std::string& tag) const { return this->tags_.find(tag) != this->tags_.end(); } // tolua_export
+            void setStartingShips(const std::string& ships); //!< Set the starting ship models of the level
+            bool addStartingShip(const std::string& ship, bool update = true); //!< Add a model to shipselection
+            /**
+            @brief Get the set of starting ship models the Level allows
+            @return Returns a comma-seperated string of all the allowed ship models for the shipselection.
+            */
+            inline const std::string& getStartingShips(void) const
+                { return this->startingShipsString_; }
+            /**
+            @brief Get whether the Level allows a specific starting ship model
+            @param ship The ship model for which is checked.
+            @return Returns true if the Level allows the input ship model
+            */
+            inline bool hasStartingShip(const std::string& ship) const { return this->startingShips_.find(ship) != this->startingShips_.end(); } // tolua_export
+            inline void selectStartingShip(const std::string& ship) { this->changeStartingShip(ship); } // tolua_export
             /**
             @brief Get the XML-filename of the Level.
 …
             inline const std::string& getXMLFilename(void) const { return this->xmlfilename_; } // tolua_export
         protected:
             /**
 …
         private:
+            void changeStartingShip (const std::string& model);
+            void startingshipsUpdated(void); //!< Updates the comma-seperated string of all possible starting ships.
             void tagsUpdated(void); //!< Updates the comma-seperated string of all tags, if the set of tags has changed.
             static void initializeTags(void); //!< Initialize the set of allowed tags.
             /**
 …
             std::set<std::string> tags_; //!< The set of tags the Level is tagged with.
             std::string tagsString_; //!< The comma-seperated string of all the tags the Level is tagged with.
+            std::set<std::string> startingShips_; //!< The set of starting ship models the Level allows.
+            std::string startingShipsString_; //!< The comma-seperated string of all the allowed ship models for the shipselection.
     }; // tolua_export
 …
         - @b description The description of the level.
         - @b screenshot The screenshot of the level.
         - @b tags A comma-seperated string of tags. Allowed tags are: <em>test</em>, <em>singleplayer</em>, <em>multiplayer</em>, <em>showcase</em>, <em>tutorial</em>, <em>presentation</em>.
+        - @b tags A comma-seperated string of tags. Allowed tags are: <em>test</em>, <em>singleplayer</em>, <em>multiplayer</em>, <em>showcase</em>, <em>tutorial</em>, <em>presentation</em>, <em>shipselection</em>.
+        - @b (optional) startingships The comma-seperated string of starting ship models
         An example would be:
         @code
 …
     @author
         Damian 'Mozork' Frick
+    @edit
+        Matthias Hutter
     @ingroup Orxonox
     */
 …
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Creates a LevelInfo object through XML.
             /**
             @brief Set the screenshot of the Level.
 …
             inline const std::string& getTags(void) const
                 { return this->LevelInfoItem::getTags(); }
+            /**
+            @brief Set the starting ship models of the level
+            @param A comma-seperated string of all the allowed ship models for the shipselection.
+            */
+            inline void setStartingShips(const std::string& ships)
+                { this->LevelInfoItem::setStartingShips(ships); }
+            /**
+            @brief Get the starting ship models of the level
+            @return Returns a comma-seperated string of all the allowed ship models for the shipselection.
+            */
+            inline const std::string& getStartingShips(void) const
+                { return this->LevelInfoItem::getStartingShips(); }
             LevelInfoItem* copy(void); //!< Copies the contents of this LevelInfo object to a new LevelInfoItem object.
     };
 …
+            }
     };
 } // tolua_export

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r8858
+                      r9348
     class TeamDeathmatch;
     class UnderAttack;
+    class TeamGametype;
     // graphics
 …
     class OrxonoxOverlay;
     class OverlayGroup;
-    // pickup
-    class PickupIdentifier;
     //sound

code/trunk/src/orxonox/Scene.cc

-                      r8858
+                      r9348
     void Scene::setSkybox(const std::string& skybox)
+    {
+        if (GameMode::showsGraphics() && this->sceneManager_)
+            this->sceneManager_->setSkyBox(true, skybox);
+        try
+        {
+            if (GameMode::showsGraphics() && this->sceneManager_)
+                this->sceneManager_->setSkyBox(true, skybox);
+        }
+        catch (const Ogre::Exception&)
+        {
+            orxout(internal_error) << "Could not load skybox '" << skybox << "':" << endl;
+            orxout(internal_error) << Exception::handleMessage() << endl;
+        }
         this->skybox_ = skybox;

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

Property svn:eol-style set to native

-                      r9265
+                      r9348
+{
   SetConsoleCommand("FormationController", "formationflight",  &FormationController::formationflight);
   SetConsoleCommand("FormationController", "masteraction",     &FormationController::masteraction);
   SetConsoleCommand("FormationController", "followme",         &FormationController::followme);
   SetConsoleCommand("FormationController", "passivebehaviour", &FormationController::passivebehaviour);
   SetConsoleCommand("FormationController", "formationsize",    &FormationController::formationsize);
   static const unsigned int STANDARD_MAX_FORMATION_SIZE = 9;
   static const int RADIUS_TO_SEARCH_FOR_MASTERS = 5000;
   static const float FORMATION_LENGTH =  110;
   static const float 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;
   FormationController::FormationController(BaseObject* creator) : Controller(creator)
+  {
+    SetConsoleCommand("FormationController", "formationflight",  &FormationController::formationflight);
+    SetConsoleCommand("FormationController", "masteraction",     &FormationController::masteraction);
+    SetConsoleCommand("FormationController", "followme",         &FormationController::followme);
+    SetConsoleCommand("FormationController", "passivebehaviour", &FormationController::passivebehaviour);
+    SetConsoleCommand("FormationController", "formationsize",    &FormationController::formationsize);
+    static const unsigned int STANDARD_MAX_FORMATION_SIZE = 9;
+    static const int RADIUS_TO_SEARCH_FOR_MASTERS = 5000;
+    static const float FORMATION_LENGTH =  110;
+    static const float 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;
+    FormationController::FormationController(BaseObject* creator) : Controller(creator)
+    {
         RegisterObject(FormationController);
 …
         this->team_=-1;
         this->target_.setCallback(createFunctor(&FormationController::targetDied, this));
+  }
   FormationController::~FormationController()
+  {
     if (this->isInitialized())
+    }
+    FormationController::~FormationController()
+    {
+        if (this->isInitialized())
+        {
             this->removeFromFormation();
 …
+            }
+        }
+  }
   void FormationController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    }
+    void FormationController::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
         SUPER(FormationController, XMLPort, xmlelement, mode);
 …
   /**
+    /**
         @brief Activates / deactivates formationflight behaviour
         @param form activate formflight if form is true
     */
   void FormationController::formationflight(const bool form)
+    void FormationController::formationflight(const bool form)
+    {
         for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
 …
+    }
   /**
+    /**
         @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))
 …
+    }
   /**
+    /**
         @brief Sets shooting behaviour of pawns.
         @param passive if true, bots won't shoot.
 …
+    }
   /**
+    /**
         @brief Sets maximal formation size
         @param size maximal formation size.
 …
+        }
         Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
+        Vector2 coord = get2DViewcoordinates(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
         float distance = (target - this->getControllableEntity()->getPosition()).length();
+        float rotateX = clamp(coord.x * 10, -1.0f, 1.0f);
+        float rotateY = clamp(coord.y * 10, -1.0f, 1.0f);
         if(this->state_ == FREE)
 …
+            {
                 // 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()->rotateYaw(-1.0f * ROTATEFACTOR_FREE * rotateX);
+                this->getControllableEntity()->rotatePitch(ROTATEFACTOR_FREE * rotateY);
+            }
+            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
 …
             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);
+                this->getControllableEntity()->rotateYaw(-1.0f * ROTATEFACTOR_MASTER * rotateX);
+                this->getControllableEntity()->rotatePitch(ROTATEFACTOR_MASTER * rotateY);
+            }
 …
+        {
            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);
+            this->getControllableEntity()->rotateYaw(-2.0f * ROTATEFACTOR_MASTER * rotateX);
+            this->getControllableEntity()->rotatePitch(2.0f * ROTATEFACTOR_MASTER * rotateY);
             if (distance < 300)
+            {
                  if (bHasTargetOrientation_)
+                    {
                         copyTargetOrientation();
+                    }
+                if (bHasTargetOrientation_)
+                {
+                    copyTargetOrientation();
+                }
                 if (distance < 100)
                 {   //linear speed reduction
+                { //linear speed reduction
                     this->getControllableEntity()->moveFrontBack(distance/100.0f*0.4f*SPEED_MASTER);
+                } else this->getControllableEntity()->moveFrontBack(1.2f*SPEED_MASTER);
+            } else {
+                }
+                else
+                    this->getControllableEntity()->moveFrontBack(1.2f*SPEED_MASTER);
+            }
+            else
                 this->getControllableEntity()->moveFrontBack(1.2f*SPEED_MASTER + distance/300.0f);
+            }
+        }
 …
+        {
             this->positionReached();
             bHasTargetOrientation_=false;
+        }
+    }
   void FormationController::moveToTargetPosition()
+            bHasTargetOrientation_=false;
+        }
+    }
+    void FormationController::moveToTargetPosition()
+    {
         this->moveToPosition(this->targetPosition_);
+    }
   //copy the Roll orientation of given Quaternion.
   void FormationController::copyOrientation(const Quaternion& orient)
+    //copy the Roll orientation of given Quaternion.
+    void FormationController::copyOrientation(const Quaternion& orient)
+    {
         //roll angle difference in radian
 …
    /**
+    /**
         @brief Unregisters a slave from its master. Initiated by a slave.
     */
 …
+        }
+    }
+ /**
+    /**
         @brief Commands the slaves of a master into a formation. Sufficiently fast not to be called within tick. Initiated by a master.
     */
+void FormationController::commandSlaves()
+    void FormationController::commandSlaves()
+    {
         if(this->state_ != MASTER) return;
 …
+        }
         else
         // formation:
+        // formation:
+        {
             dest += 1.0f*orient*WorldEntity::BACK;
             Vector3 pos = Vector3::ZERO;
                  bool left=true;
+            bool left=true;
             int i = 1;
 …
         if (specificMasterActionHoldCount_ == 0)
+         {
+        {
             this->specificMasterAction_ = NONE;
             this->searchNewTarget();
+         }
+        else specificMasterActionHoldCount_--;
+        }
+        else
+            specificMasterActionHoldCount_--;
+    }
 …
     void FormationController::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);
+        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);
+    }
 …
     void FormationController::spin()
+    {
             this->moveToTargetPosition();
             this->getControllableEntity()->rotateRoll(0.8f);
+        this->moveToTargetPosition();
+        this->getControllableEntity()->rotateRoll(0.8f);
+    }
 …
         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<FormationController*>::iterator it = allMasters.begin(); it != allMasters.end(); it++, i++)
+                    {
+                        if (!FormationController::sameTeam((*it)->getControllableEntity(), humanPawn, (*it)->getGametype())) continue;
+                        distance = posHuman - (*it)->getControllableEntity()->getPosition().length();
+                        if(distance < minDistance) index = i;
+                    }
+                allMasters[index]->followInit(humanPawn);
+            }
+    }
+            float posHuman = humanPawn->getPosition().length();
+            float distance = 0.0f;
+            float minDistance = FLT_MAX;
+            int index = 0;
+            int i = 0;
+            for(std::vector<FormationController*>::iterator it = allMasters.begin(); it != allMasters.end(); it++, i++)
+            {
+                if (!FormationController::sameTeam((*it)->getControllableEntity(), humanPawn, (*it)->getGametype())) continue;
+                distance = posHuman - (*it)->getControllableEntity()->getPosition().length();
+                if(distance < minDistance) index = i;
+            }
+            allMasters[index]->followInit(humanPawn);
+        }
+    }
     /**
 …
+    }
    /**
+    /**
         @brief Master begins to follow a randomly chosen human player of the same team. Is a "specific master action".
     */
 …
   /**
+    /**
         @brief Master follows target with adjusted speed. Called within tick.
     */
 …
   void FormationController::setTargetPosition(const Vector3& target)
+    void FormationController::setTargetPosition(const Vector3& target)
+    {
         this->targetPosition_ = target;
 …
+    }
   void FormationController::forgetTarget()
+    void FormationController::forgetTarget()
+    {
         this->target_ = 0;
 …
+    }
    void FormationController::targetDied()
+    void FormationController::targetDied()
+    {
         this->forgetTarget();
 …
+    }
   bool FormationController::sameTeam(ControllableEntity* entity1, ControllableEntity* entity2, Gametype* gametype)
+    bool FormationController::sameTeam(ControllableEntity* entity1, ControllableEntity* entity2, Gametype* gametype)
+    {
         if (entity1 == entity2)
 …
             return;
         Vector2 coord = get2DViewdirection(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
+        Vector2 coord = get2DViewcoordinates(this->getControllableEntity()->getPosition(), this->getControllableEntity()->getOrientation() * WorldEntity::FRONT, this->getControllableEntity()->getOrientation() * WorldEntity::UP, target);
         float distance = (target - this->getControllableEntity()->getPosition()).length();
 …
+            {
                 // 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);
+                this->getControllableEntity()->rotateYaw(-1.0f * ROTATEFACTOR_FREE * clamp(coord.x * 10, -1.0f, 1.0f));
+                this->getControllableEntity()->rotatePitch(ROTATEFACTOR_FREE * clamp(coord.y * 10, -1.0f, 1.0f));
                 this->getControllableEntity()->moveFrontBack(SPEED_FREE);
+            }

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

Property svn:eol-style set to native

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

r9016	r9348
298	298	//Used in HumanController for formationFlight
299	299	HumanController::hit(originator,contactpoint,damage);
300
	300
301	301	if (this->showDamageOverlay_ && !this->controlPaused_ && this->controllableEntity_ && !this->controllableEntity_->isInMouseLook())
302	302	{
…	…
397	397	try
398	398	{
399		wePtr = ~~dynamic~~_cast<WorldEntity>(Ogre::any_cast<OrxonoxClass>(itr->movable->getUserAny()));
	399	wePtr = orxonox_cast<WorldEntity>(Ogre::any_cast<OrxonoxClass>(itr->movable->getUserAny()));
400	400	}
401	401	catch (...)

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

-                      r8858
+                      r9348
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it; ++it)
+        {
+            if (dynamic_cast<Synchronisable*>(*it))
+                orxout(debug_output) << "object: " << it->getIdentifier()->getName() << " id: " << dynamic_cast<Synchronisable*>(*it)->getObjectID() << endl;
+            Synchronisable* synchronisable = orxonox_cast<Synchronisable*>(*it);
+            if (synchronisable)
+                orxout(debug_output) << "object: " << it->getIdentifier()->getName() << " id: " << synchronisable->getObjectID() << endl;
             else
                 orxout(debug_output) << "object: " << it->getIdentifier()->getName() << endl;

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

r8858	r9348
114	114	}
115	115
116		void Deathmatch::playerScored(PlayerInfo* player)
	116	void Deathmatch::playerScored(PlayerInfo* player, int score)
117	117	{
118		Gametype::playerScored(player);
	118	Gametype::playerScored(player, score);
119	119
120	120	if (player)

code/trunk/src/orxonox/gametypes/Deathmatch.h

r5781	r9348
48	48
49	49	virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
50		virtual void playerScored(PlayerInfo* player);
	50	virtual void playerScored(PlayerInfo* player, int score = 1);
51	51	};
52	52	}

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

-                      r8858
+                      r9348
 //Low; Codeoptimierung und Dokumentation
+/*
+short gaming manual:
+There are three different parties a player can belong to: victim, chaser or killer
+Every player starts as chaser. As long as there are not enough victims and killers, you can change your and other player's parties by shooting them.
+In order to win you have to earn as much points as possible:
+- as victim by escaping the chasers
+- as chaser by shooting the victim
+- as killer by killing the chasers
+What you shouldn't do is shooting at players of your own party. By doing so your score will decrease.
+P.S: If you don't want to be a victim: Get rid of your part by shooting a chaser.
+/**
+@brief
+    Short Gaming Manual:
+    There are three different parties a player can belong to: victim, chaser or killer
+    Every player starts as chaser. As long as there are not enough victims and killers, you can change your and other player's parties by shooting them.
+    In order to win you have to earn as much points as possible:
+    - as victim by escaping the chasers
+    - as chaser by shooting the victim
+    - as killer by killing the chasers
+    What you shouldn't do is shooting at players of your own party. By doing so your score will decrease.
+    P.S: If you don't want to be a victim: Get rid of your part by shooting a chaser.
 */
 #include "Dynamicmatch.h"
 …
         this->numberOf[killer]=0;
         this->tutorial=true;
         this->pointsPerTime=0.0f;
+        this->pointsPerTime=1.0f;
         this->setHUDTemplate("DynamicmatchHUD");
+    }
 …
             ColourValue(0.3f, 0.3f, 1.0f),  //piggycolour
             ColourValue(0.3f, 1.0f, 0.3f)   //killercolour  what about black: 0.0f, 0.0f, 0.0f
         };
         static std::vector<ColourValue> defaultcolours(colours, colours + sizeof(colours) / sizeof(ColourValue));
 …
         if (victim && victim->getPlayer()) //&& originator && originator->getPlayer() ??
+        {
         int target= playerParty_[victim->getPlayer()];
         int source= playerParty_[originator->getPlayer()];
+            int target = playerParty_[victim->getPlayer()];
+            int source = playerParty_[originator->getPlayer()];
             //Case: Not Enough Pigs: party change (= party management)
 …
                 //Give new pig boost
                 SpaceShip* spaceship = dynamic_cast<SpaceShip*>(victim);
+                SpaceShip* spaceship = orxonox_cast<SpaceShip*>(victim);
                 this->grantPigBoost(spaceship);
+            }
 …
+                }
                 //Give new pig boost
                 SpaceShip* spaceship = dynamic_cast<SpaceShip*>(victim);
+                SpaceShip* spaceship = orxonox_cast<SpaceShip*>(victim);
                 this->grantPigBoost(spaceship);
+            }
 …
             else if (friendlyfire && (source == target))
+            {
+                std::map<PlayerInfo*, Player>::iterator it = this->players_.find(originator->getPlayer());
+                if (it != this->players_.end())
+                    {
+                        it->second.frags_--;
+                    }
+            }
+        }// from far far away not to be removed!
+                    this->playerScored(originator->getPlayer(), -1);
+            }
+        }
         return false; //default: no damage
+    }
 …
             if (playerParty_[originator->getPlayer()] == killer) //reward the killer
+            {
+                std::map<PlayerInfo*, Player>::iterator it = this->players_.find(originator->getPlayer());
+                if (it != this->players_.end())
+                {
+                    it->second.frags_+=20; //value must be tested
+                }
+            }
+        return true;
+                    this->playerScored(originator->getPlayer(), 25);
+            }
+            return true;
+        }
         else return false;
 …
     /**
     @brief
         Grant the piggy a boost.
+        Grant the victim a boost.
     @param spaceship
         The SpaceShip to give the boost.
 …
     void Dynamicmatch::grantPigBoost(SpaceShip* spaceship)
+    {
         // Give pig boost
+        // Give victim boost
         if (spaceship)
+        {
+            WeakPtr<SpaceShip>* ptr = new WeakPtr<SpaceShip>(spaceship);
+            if(ptr == NULL)
+                return;
             spaceship->addSpeedFactor(5);
-            WeakPtr<SpaceShip>* ptr = new WeakPtr<SpaceShip>(spaceship);
             ExecutorPtr executor = createExecutor(createFunctor(&Dynamicmatch::resetSpeedFactor, this));
             executor->setDefaultValue(0, ptr);
 …
         if (this->hasStarted() && !gameEnded_)
+        {   pointsPerTime =pointsPerTime + dt;
+            gameTime_ = gameTime_ - dt;
+            if (pointsPerTime > 2.0f)//hard coded!! should be changed
+            {
+                pointsPerTime=0.0f;
+        {
+            pointsPerTime = pointsPerTime + dt; //increase points
+            gameTime_ = gameTime_ - dt; // decrease game time
+            if (pointsPerTime > 2.0f) //hard coded points for victim! should be changed
+            {
+                pointsPerTime = 0.0f;
                 rewardPig();
+            }
 …
+    }
+/**
+    @brief The reward function is called every 2 seconds via the tick function and makes the victim score points.
+*/
     void Dynamicmatch::rewardPig()
+    {
         for (std::map< PlayerInfo*, int >::iterator it = this->playerParty_.begin(); it != this->playerParty_.end(); ++it) //durch alle Spieler iterieren und alle piggys finden
+        {
+            if (it->second==piggy)
+            {
+                 //Spieler mit der Pig-party frags++
+                 std::map<PlayerInfo*, Player>::iterator it2 = this->players_.find(it->first);// still not sure if right syntax
+                 if (it2 != this->players_.end())
+                 {
+                     it2->second.frags_++;
+                 }
+            if (it->second==piggy)//Spieler mit der Pig-party frags++
+            {
+                 this->playerScored(it->first);
+            }
+        }
 …
+    {
         std::map<PlayerInfo*, int>::const_iterator it_player = this->playerParty_.find(player);
         Pawn* pawn = dynamic_cast<Pawn*>(player->getControllableEntity());
+        Pawn* pawn = orxonox_cast<Pawn*>(player->getControllableEntity());
             if (pawn)
+            {
 …
+    {
         //pigs: 1 + every 6th player is a pig
         if ( (1+this->getNumberOfPlayers()/6) > numberOf[piggy])
+        if ( (1 + getPlayerCount()/6) > numberOf[piggy])
+        {
             notEnoughPigs=true;
 …
+        }
         //killers: every 4th player is a killer
         if (getNumberOfPlayers()/4 > numberOf[killer])
+        if ( static_cast<unsigned int>(getPlayerCount()/4) > numberOf[killer])
+        {
             notEnoughKillers=true;

code/trunk/src/orxonox/gametypes/Dynamicmatch.h

-                      r8727
+                      r9348
             SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
         protected:
+            inline int getPlayerCount() const
+                 { return this->numberOf[chaser] + numberOf[piggy] + this->numberOf[killer]; }
             std::map< PlayerInfo*, int > playerParty_; //player's parties are recorded here

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

r9261	r9348
301	301	}
302	302
303		void Gametype::playerScored(PlayerInfo* player)
	303	void Gametype::playerScored(PlayerInfo* player, int score)
304	304	{
305	305	std::map<PlayerInfo*, Player>::iterator it = this->players_.find(player);
306	306	if (it != this->players_.end())
307		it->second.frags_++;
	307	it->second.frags_ += score;
308	308	}
309	309

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

-                      r9260
+                      r9348
             virtual bool playerChangedName(PlayerInfo* player);
             virtual void playerScored(PlayerInfo* player);
+            virtual void playerScored(PlayerInfo* player, int score = 1);
             virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
 …
             virtual void resetTimer(float t);
+            /**
+            @brief Get number of Players in game.
+            */
             inline unsigned int getNumberOfPlayers() const
+                { return this->gtinfo_->getNumberOfPlayers(); }
+                { return this->players_.size(); }
         protected:

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

r8858	r9348
211	211	if(!player->getControllableEntity())
212	212	return;
213		Pawn* pawn = ~~dynamic~~_cast<Pawn*>(player->getControllableEntity());
	213	Pawn* pawn = orxonox_cast<Pawn*>(player->getControllableEntity());
214	214	if(!pawn)
215	215	return;

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

r8858	r9348
283	283	if(!player->getControllableEntity())
284	284	return;
285		Pawn* pawn = ~~dynamic~~_cast<Pawn*>(player->getControllableEntity());
	285	Pawn* pawn = orxonox_cast<Pawn*>(player->getControllableEntity());
286	286	if(!pawn)
287	287	return;

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

Property svn:eol-style set to native

r9016	r9348
63	63	{
64	64	this->missionAccomplished_ = false;
65		this->end();
	65	this->end();
66	66	}
67	67	}
…	…
78	78	{
79	79	Gametype::end();
80		/*if (this->missionAccomplished_)
	80	/*if (this->missionAccomplished_)
81	81	this->gtinfo_->sendAnnounceMessage("Mission accomplished!");
82		else
	82	else
83	83	this->gtinfo_->sendAnnounceMessage("Mission failed!");
84		* */
	84	*/
85	85	}
86	86

code/trunk/src/orxonox/gametypes/Mission.h

Property svn:eol-style set to native

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

r8952	r9348
128	128
129	129	// collect Points for killing oppenents
130		void TeamBaseMatch::playerScored(PlayerInfo* player)
	130	void TeamBaseMatch::playerScored(PlayerInfo* player, int score)
131	131	{
132	132	int teamnr = this->getTeam(player);

code/trunk/src/orxonox/gametypes/TeamBaseMatch.h

r5929	r9348
47	47	virtual bool allowPawnDamage(Pawn* victim, Pawn* originator);
48	48
49		virtual void playerScored(PlayerInfo* player);
	49	virtual void playerScored(PlayerInfo* player, int score = 1);
50	50	virtual void showPoints();
51	51	virtual void endGame();

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

-                      r7182
+                      r9348
 #include "core/CoreIncludes.h"
+#include "core/ConfigValueIncludes.h"
+#include "interfaces/TeamColourable.h"
+#include "worldentities/TeamSpawnPoint.h"
+#include "chat/ChatManager.h"
+#include "infos/PlayerInfo.h"
 #include "worldentities/pawns/Pawn.h"
 …
     CreateUnloadableFactory(TeamDeathmatch);
     TeamDeathmatch::TeamDeathmatch(BaseObject* creator) : Deathmatch(creator)
+    TeamDeathmatch::TeamDeathmatch(BaseObject* creator) : TeamGametype(creator)
+    {
         RegisterObject(TeamDeathmatch);
-        this->teams_ = 2;
-        this->setConfigValues();
+    }
     void TeamDeathmatch::setConfigValues()
+    void TeamDeathmatch::start()
+    {
         SetConfigValue(teams_, 2);
+        TeamGametype::start();
+        static ColourValue colours[] =
+        {
+            ColourValue(1.0f, 0.3f, 0.3f),
+            ColourValue(0.3f, 0.3f, 1.0f),
+            ColourValue(0.3f, 1.0f, 0.3f),
+            ColourValue(1.0f, 1.0f, 0.0f)
+        };
+        static std::vector<ColourValue> defaultcolours(colours, colours + sizeof(colours) / sizeof(ColourValue));
+        std::string message("The match has started!");
+        ChatManager::message(message);
+    }
+        SetConfigValue(teamcolours_, defaultcolours);
+    void TeamDeathmatch::end()
+    {
+        TeamGametype::end();
+        std::string message("The match has ended.");
+        ChatManager::message(message);
+    }
     void TeamDeathmatch::playerEntered(PlayerInfo* player)
+    {
         Deathmatch::playerEntered(player);
+        TeamGametype::playerEntered(player);
+        std::vector<unsigned int> playersperteam(this->teams_, 0);
+        for (std::map<PlayerInfo*, int>::iterator it = this->teamnumbers_.begin(); it != this->teamnumbers_.end(); ++it)
+            if (it->second < static_cast<int>(this->teams_) && it->second >= 0)
+                playersperteam[it->second]++;
+        unsigned int minplayers = static_cast<unsigned int>(-1);
+        size_t minplayersteam = 0;
+        for (size_t i = 0; i < this->teams_; ++i)
+        {
+            if (playersperteam[i] < minplayers)
+            {
+                minplayers = playersperteam[i];
+                minplayersteam = i;
+            }
+        }
+        this->teamnumbers_[player] = minplayersteam;
+        const std::string& message = player->getName() + " entered the game";
+        ChatManager::message(message);
+    }
     bool TeamDeathmatch::playerLeft(PlayerInfo* player)
+    {
         bool valid_player = Deathmatch::playerLeft(player);
+        bool valid_player = TeamGametype::playerLeft(player);
         if (valid_player)
+            this->teamnumbers_.erase(player);
+        {
+            const std::string& message = player->getName() + " left the game";
+            ChatManager::message(message);
+        }
+        return valid_player;
+    }
+    bool TeamDeathmatch::playerChangedName(PlayerInfo* player)
+    {
+        bool valid_player = TeamGametype::playerChangedName(player);
+        if (valid_player)
+        {
+            const std::string& message = player->getOldName() + " changed name to " + player->getName();
+            ChatManager::message(message);
+        }
         return valid_player;
+    }
     bool TeamDeathmatch::allowPawnHit(Pawn* victim, Pawn* originator)
+    void TeamDeathmatch::pawnKilled(Pawn* victim, Pawn* killer)
+    {
+        return (!this->pawnsAreInTheSameTeam(victim, originator) || !originator);
+        if (victim && victim->getPlayer())
+        {
+            std::string message;
+            if (killer)
+            {
+                if (killer->getPlayer())
+                    message = victim->getPlayer()->getName() + " was killed by " + killer->getPlayer()->getName();
+                else
+                    message = victim->getPlayer()->getName() + " was killed";
+            }
+            else
+                message = victim->getPlayer()->getName() + " died";
+            ChatManager::message(message);
+        }
+        Gametype::pawnKilled(victim, killer);
+    }
     bool TeamDeathmatch::allowPawnDamage(Pawn* victim, Pawn* originator)
+    void TeamDeathmatch::playerScored(PlayerInfo* player, int score)
+    {
+        return (!this->pawnsAreInTheSameTeam(victim, originator) || !originator);
+    }
+        TeamGametype::playerScored(player, score);
+    bool TeamDeathmatch::allowPawnDeath(Pawn* victim, Pawn* originator)
+    {
+        return (!this->pawnsAreInTheSameTeam(victim, originator) || !originator);
+    }
+    SpawnPoint* TeamDeathmatch::getBestSpawnPoint(PlayerInfo* player) const
+    {
+        int desiredTeamNr = -1;
+        std::map<PlayerInfo*, int>::const_iterator it_player = this->teamnumbers_.find(player);
+        if (it_player != this->teamnumbers_.end())
+            desiredTeamNr = it_player->second;
+        // Only use spawnpoints of the own team (or non-team-spawnpoints)
+        std::set<SpawnPoint*> teamSpawnPoints = this->spawnpoints_;
+        for (std::set<SpawnPoint*>::iterator it = teamSpawnPoints.begin(); it != teamSpawnPoints.end(); )
+        if (player)
+        {
+            if ((*it)->isA(Class(TeamSpawnPoint)))
+            {
+                TeamSpawnPoint* tsp = orxonox_cast<TeamSpawnPoint*>(*it);
+                if (tsp && static_cast<int>(tsp->getTeamNumber()) != desiredTeamNr)
+                {
+                    teamSpawnPoints.erase(it++);
+                    continue;
+                }
+            }
+            ++it;
+        }
+        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*>::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)
+            {
+                if (index == randomspawn)
+                    return (*it);
+                ++index;
+            }
+            return fallbackSpawnPoint;
+        }
+        return 0;
+    }
+    void TeamDeathmatch::playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn)
+    {
+        if (!player)
+            return;
+        // Set the team colour
+        std::map<PlayerInfo*, int>::const_iterator it_player = this->teamnumbers_.find(player);
+        if (it_player != this->teamnumbers_.end() && it_player->second >= 0 && it_player->second < static_cast<int>(this->teamcolours_.size()))
+        {
+            if (pawn)
+            {
+                pawn->setRadarObjectColour(this->teamcolours_[it_player->second]);
+                std::set<WorldEntity*> pawnAttachments = pawn->getAttachedObjects();
+                for (std::set<WorldEntity*>::iterator it = pawnAttachments.begin(); it != pawnAttachments.end(); ++it)
+                {
+                    if ((*it)->isA(Class(TeamColourable)))
+                    {
+                        TeamColourable* tc = orxonox_cast<TeamColourable*>(*it);
+                        tc->setTeamColour(this->teamcolours_[it_player->second]);
+                    }
+                }
+            }
+            const std::string& message = player->getName() + " scores!";
+            ChatManager::message(message);
+        }
+    }
-    bool TeamDeathmatch::pawnsAreInTheSameTeam(Pawn* pawn1, Pawn* pawn2)
+    {
-        if (pawn1 && pawn2)
+        {
-            std::map<PlayerInfo*, int>::const_iterator it1 = this->teamnumbers_.find(pawn1->getPlayer());
-            std::map<PlayerInfo*, int>::const_iterator it2 = this->teamnumbers_.find(pawn2->getPlayer());
-            if (it1 != this->teamnumbers_.end() && it2 != this->teamnumbers_.end())
-                return (it1->second == it2->second);
+        }
-        return false;
+    }
-    int TeamDeathmatch::getTeam(PlayerInfo* player)
+    {
-        std::map<PlayerInfo*, int>::const_iterator it_player = this->teamnumbers_.find(player);
-        if (it_player != this->teamnumbers_.end())
-            return it_player->second;
-        else
-            return -1;
+    }
+}

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

-                      r9016
+                      r9348
 #include "OrxonoxPrereqs.h"
+#include <map>
+#include <vector>
+#include "Deathmatch.h"
+#include "TeamGametype.h"
 namespace orxonox
+{
     class _OrxonoxExport TeamDeathmatch : public Deathmatch
+    class _OrxonoxExport TeamDeathmatch : public TeamGametype
+    {
         public:
 …
             virtual ~TeamDeathmatch() {}
             void setConfigValues();
+            virtual void start();
+            virtual void end();
             virtual void playerEntered(PlayerInfo* player);
             virtual bool playerLeft(PlayerInfo* player);
+            virtual bool playerChangedName(PlayerInfo* player);
+            virtual bool allowPawnHit(Pawn* victim, Pawn* originator = 0);
+            virtual bool allowPawnDamage(Pawn* victim, Pawn* originator = 0);
+            virtual bool allowPawnDeath(Pawn* victim, Pawn* originator = 0);
+            virtual void playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn);
+            int getTeam(PlayerInfo* player);
+            inline const ColourValue& getTeamColour(int teamnr) const
+                { return this->teamcolours_[teamnr]; }
+        protected:
+            virtual SpawnPoint* getBestSpawnPoint(PlayerInfo* player) const;
+            bool pawnsAreInTheSameTeam(Pawn* pawn1, Pawn* pawn2);
+            std::map<PlayerInfo*, int> teamnumbers_;
+            std::vector<ColourValue> teamcolours_;
+            unsigned int teams_;
+            virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
+            virtual void playerScored(PlayerInfo* player, int score = 1);
     };
+}

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

Property svn:eol-style set to native

r9048	r9348
89	89	}
90	90
	91	/**
	92	@brief
	93	Function that determines the player's team number when entering the game for the first time.
	94	Override this function for other team structures.
	95	*/
91	96	void TeamGametype::findAndSetTeam(PlayerInfo* player)
92	97	{
…	…
130	135	this->allowedInGame_.erase(player);
131	136	}
132
133	137
134	138	return valid_player;

code/trunk/src/orxonox/gametypes/TeamGametype.h

Property svn:eol-style set to native

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

r9016	r9348
49	49	this->gameEnded_ = false;
50	50
51		~~//this->setHUDTemplate("UnderAttackHUD");~~
52		~~//This HUD is in conflict with the HUDEnemyHealthBar~~
53	51	this->setConfigValues();
54	52	this->timesequence_ = static_cast<int>(this->gameTime_);

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

r9016	r9348
68	68	{
69	69	RegisterObject(GametypeInfo);
70
	70
71	71	this->bStarted_ = false;
72	72	this->bEnded_ = false;
…	…
165	165	if(this->bStarted_)
166	166	{ return;}
167
	167
168	168	this->bStarted_ = true;
169	169	this->changedStarted();
170
171
	170
	171
172	172	}
173	173
…	…
195	195	if(this->startCountdown_ == countdown \|\| countdown < 0.0f)
196	196	return;
197
	197
198	198	this->startCountdown_ = countdown;
199	199	// Set the counter to the ceiling of the current countdown.
…	…
225	225	if(this->counter_ == 0)
226	226	return;
227
	227
228	228	this->counter_--;
229	229	this->changedCountdownCounter();
…	…
325	325	if(this->spawned_ == spawned)
326	326	return;
327
	327
328	328	this->spawned_ = spawned;
329	329	// Clear the notifications if the Player has spawned.
…	…
395	395	// TODO: Replace with notifications.
396	396
397		void GametypeInfo::sendAnnounceMessage(const std::string& message)
	397	void GametypeInfo::sendAnnounceMessage(const std::string& message) const
398	398	{
399	399	if (GameMode::isMaster())
…	…
404	404	}
405	405
406		void GametypeInfo::sendAnnounceMessage(const std::string& message, unsigned int clientID)
	406	void GametypeInfo::sendAnnounceMessage(const std::string& message, unsigned int clientID) const
407	407	{
408	408	if (GameMode::isMaster())
…	…
415	415	}
416	416
417		void GametypeInfo::sendKillMessage(const std::string& message, unsigned int clientID)
	417	void GametypeInfo::sendKillMessage(const std::string& message, unsigned int clientID) const
418	418	{
419	419	if (GameMode::isMaster())
…	…
426	426	}
427	427
428		void GametypeInfo::sendDeathMessage(const std::string& message, unsigned int clientID)
	428	void GametypeInfo::sendDeathMessage(const std::string& message, unsigned int clientID) const
429	429	{
430	430	if (GameMode::isMaster())
…	…
437	437	}
438	438
439		void GametypeInfo::sendStaticMessage(const std::string& message, unsigned int clientID, const ColourValue& colour)
	439	void GametypeInfo::sendStaticMessage(const std::string& message, unsigned int clientID, const ColourValue& colour) const
440	440	{
441	441	if (GameMode::isMaster())
…	…
448	448	}
449	449
450		void GametypeInfo::sendFadingMessage(const std::string& message, unsigned int clientID)
	450	void GametypeInfo::sendFadingMessage(const std::string& message, unsigned int clientID) const
451	451	{
452	452	if (GameMode::isMaster())
…	…
459	459	}
460	460
461		void GametypeInfo::dispatchAnnounceMessage(const std::string& message)
	461	void GametypeInfo::dispatchAnnounceMessage(const std::string& message) const
462	462	{
463	463	for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
…	…
465	465	}
466	466
467		void GametypeInfo::dispatchKillMessage(const std::string& message)
	467	void GametypeInfo::dispatchKillMessage(const std::string& message) const
468	468	{
469	469	for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
…	…
471	471	}
472	472
473		void GametypeInfo::dispatchDeathMessage(const std::string& message)
	473	void GametypeInfo::dispatchDeathMessage(const std::string& message) const
474	474	{
475	475	for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
…	…
477	477	}
478	478
479		void GametypeInfo::dispatchStaticMessage(const std::string& message, const ColourValue& colour)
	479	void GametypeInfo::dispatchStaticMessage(const std::string& message, const ColourValue& colour) const
480	480	{
481	481	for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)
…	…
483	483	}
484	484
485		void GametypeInfo::dispatchFadingMessage(const std::string& message)
	485	void GametypeInfo::dispatchFadingMessage(const std::string& message) const
486	486	{
487	487	for (ObjectList<GametypeMessageListener>::iterator it = ObjectList<GametypeMessageListener>::begin(); it != ObjectList<GametypeMessageListener>::end(); ++it)

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

-                      r9016
+                      r9348
                 { return this->bStarted_; }
             void changedStarted(void); // Is called when the game has changed to started.
             /**
             @brief Get whether the game has ended yet.
 …
                 { return this->readyToSpawn_; }
             void changedReadyToSpawn(bool ready); // Inform the GametypeInfo that the local player has changed its spawned status.
             /**
             @brief Get whether the local player is spawned.
 …
             inline const std::string& getHUDTemplate() const
                 { return this->hudtemplate_; }
-            inline unsigned int getNumberOfPlayers() const
-                {  return this->spawnedPlayers_.size(); }
             void sendAnnounceMessage(const std::string& message);
             void sendAnnounceMessage(const std::string& message, unsigned int clientID);
             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 sendAnnounceMessage(const std::string& message) const;
+            void sendAnnounceMessage(const std::string& message, unsigned int clientID) const;
+            void sendKillMessage(const std::string& message, unsigned int clientID) const;
+            void sendDeathMessage(const std::string& message, unsigned int clientID) const;
+            void sendStaticMessage(const std::string& message, unsigned int clientID, const ColourValue& colour) const;
+            void sendFadingMessage(const std::string& message, unsigned int clientID) const;
             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);
+            void dispatchAnnounceMessage(const std::string& message) const;
+            void dispatchKillMessage(const std::string& message) const;
+            void dispatchDeathMessage(const std::string& message) const;
+            void dispatchStaticMessage(const std::string& message,const ColourValue& colour) const;
+            void dispatchFadingMessage(const std::string& message) const;
         protected:
             void start(void); // Inform the GametypeInfo that the game has started.
 …
             unsigned int counter_; //!< The current integer value of the start countdown, the start countdown counter.
             std::string hudtemplate_;
             std::set<PlayerInfo*> spawnedPlayers_; //!< A set of players that are currently spawned.
             bool spawned_; //!< Whether the local Player is currently spawned.

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

r9257	r9348
173	173	this->changedControllableEntity();
174	174
175		RadarViewable* radarviewable = orxonox_cast<RadarViewable*>(entity);
	175	RadarViewable* radarviewable = orxonox_cast<RadarViewable*>(entity);
176	176	if (radarviewable != NULL)
177	177	radarviewable->setRadarName(this->getName());

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

-                      r8866
+                      r9348
 #include "infos/PlayerInfo.h"
-#include "pickup/PickupIdentifier.h"
 #include "worldentities/pawns/Pawn.h"
 …
         Constructor. Registers the objects and initializes its member variables.
     */
     Pickupable::Pickupable() : pickupIdentifier_(NULL), used_(false), pickedUp_(false)
+    Pickupable::Pickupable() : used_(false), pickedUp_(false)
+    {
         RegisterRootObject(Pickupable);
 …
         this->carrier_ = NULL;
-        this->pickupIdentifier_ = new PickupIdentifier(this);
         this->beingDestroyed_ = false;
         this->enabled_ = true;
 …
     Pickupable::~Pickupable()
+    {
-        if(this->pickupIdentifier_ != NULL)
+        {
-            orxout(verbose, context::pickups) << "Pickupable (&" << this << ") destroyed." << endl;
-            this->pickupIdentifier_->destroy();
+        }
+    }
 …
     void Pickupable::destroyPickup(void)
+    {
         if(!this->beingDestroyed_)
+        if(!this->isBeingDestroyed())
             this->OrxonoxClass::destroy();
         else
 …
     /**
     @brief
-        Creates a duplicate of the Pickupable.
-    @return
-        Returns the clone of this pickup as a pointer to a Pickupable.
-    */
-    Pickupable* Pickupable::clone(void)
+    {
-        OrxonoxClass* item = NULL;
-        this->clone(item);
-        Pickupable* pickup = dynamic_cast<Pickupable*>(item);
-        orxout(verbose, context::pickups) << "Pickupable (&" << this << ") cloned. Clone is new Pickupable (&" << pickup << ")." << endl;
-        return pickup;
+    }
-    /**
-    @brief
         Method to transcribe a Pickupable as a Rewardable to the player.
     @param player

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

-                      r8866
+                      r9348
         Pickups (@ref orxonox::Pickupable "Pickupables") are objects that (quite unsurprisingly) can be picked up. Additionally they can be used and unused (transition from used to not used), and also dropped.
-        A class of Pickups can incorporate many different types of pickups (see @ref orxonox::PickupIdentifier "PickupIdentifier"), each type is uniquely defined by a @ref orxonox::PickupIdentifier "PickupIdentifier". Each pickup has such an identifier identiying its type. This means that two pickups of the same type have identifiers which are equal.
     @author
         Damian 'Mozork' Frick
 …
         public:
             virtual ~Pickupable(); //!< Default destructor.
+            //! @brief Returns the representation name which refers to the name of the PickupRepresentation that is used to represent this pickup.
+            virtual const std::string& getRepresentationName() const = 0;
             /**
 …
             bool addTarget(Identifier* identifier); //!< Add a class, representetd by the input Identifier, as target of this Pickupable.
-            Pickupable* clone(void); //!< Creates a duplicate of the Pickupable.
-            /**
-            @brief Creates a duplicate of the input OrxonoxClass.
-                   This method needs to be implemented by any Class inheriting from Pickupable.
-            @param item A reference to a pointer to the OrxonoxClass that is to be duplicated.
-            */
-            virtual void clone(OrxonoxClass*& item) {}
-            /**
-            @brief Get the PickupIdentifier of this Pickupable.
-            @return Returns a pointer to the PickupIdentifier of this Pickupable.
-            */
-            virtual const PickupIdentifier* getPickupIdentifier(void) const
-                { 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.
 …
         protected:
-            /**
-            @brief Helper method to initialize the PickupIdentifier.
-            */
-            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 Check whether the Pickupable is in the process of being destroyed.
+            @return Returns true if so.
+            */
+            inline bool isBeingDestroyed(void)
+                { return this->beingDestroyed_; }
+            /**
             @brief Facilitates the creation of a PickupSpawner upon dropping of the Pickupable.
+                   This method must be implemented by any class directly inheriting from Pickupable. It is most easily done by just creating a new DroppedPickup, e.g.:
+                   DroppedPickup(BaseObject* creator, Pickupable* pickup, PickupCarrier* carrier, float triggerDistance);
+                   This method must be implemented by any class directly inheriting from Pickupable.
             @return Returns true if a spawner was created, false if not.
             */
             virtual bool createSpawner(void) = 0;
-            PickupIdentifier* pickupIdentifier_; //!< The PickupIdentifier of this Pickupable.
         private:
 …
     //! SUPER functions.
     SUPER_FUNCTION(10, Pickupable, changedUsed, false);
+    SUPER_FUNCTION(12, Pickupable, changedCarrier, false);
+    SUPER_FUNCTION(13, Pickupable, changedPickedUp, false);
+    SUPER_FUNCTION(11, Pickupable, clone, false);
+    SUPER_FUNCTION(11, Pickupable, changedCarrier, false);
+    SUPER_FUNCTION(12, Pickupable, changedPickedUp, false);
+}

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

-                      r9257
+                      r9348
         virtual ~RadarViewable();
                 virtual void setRadarName(const std::string& name)
+                        {
                                 if (this->radarName_ != name)
+                                {
                                         this->radarName_ = name;
                                         this->settingsChanged();
+                                }
+                        }
                 const std::string& getRadarName() const
                         { return this->radarName_; }
+        virtual void setRadarName(const std::string& name)
+            {
+                if (this->radarName_ != name)
+                {
+                    this->radarName_ = name;
+                    this->settingsChanged();
+                }
+            }
+        const std::string& getRadarName() const
+            { return this->radarName_; }
         inline void setRadarObjectCamouflage(float camouflage)
 …
         ColourValue radarObjectColour_;
         float scale_;
                 std::string radarName_;
+        std::string radarName_;
     };
+}

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

-                      r9016
+                      r9348
         this->setPriority( Priority::VeryHigh );
         this->registerVariables();
         this->team_ = -1;
+        this->team_ = -1;
+    }
 …
                 this->cameraPositionRootNode_->_update(true, false); // update the camera node because otherwise the camera will drag back in position which looks strange
                 NewHumanController* controller = dynamic_cast<NewHumanController*>(this->getController());
+                NewHumanController* controller = orxonox_cast<NewHumanController*>(this->getController());
                 if (controller)
                     controller->centerCursor();

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

-                      r9255
+                      r9348
             void setTargetInternal( uint32_t targetID );
             inline void setTeam(int team)
                 { this->team_ = team; }
             inline int getTeam() const
                 { return this->team_; }
+            inline void setTeam(int team)
+                { this->team_ = team; }
+            inline int getTeam() const
+                { return this->team_; }
         protected:
 …
             WeakPtr<WorldEntity> target_;
             int team_ ; //<! teamnumber
+            int team_ ; //<! teamnumber
     };
+}

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

-                      r9257
+                      r9348
         this->lastHitOriginator_ = 0;
+        // set damage multiplier to default value 1, meaning nominal damage
+        this->damageMultiplier_ = 1;
         this->spawnparticleduration_ = 3.0f;
 …
     void Pawn::damage(float damage, float healthdamage, float shielddamage, Pawn* originator)
+    {
+        // Applies multiplier given by the DamageBoost Pickup.
+        if (originator)
+            damage *= originator->getDamageMultiplier();
         if (this->getGametype() && this->getGametype()->allowPawnDamage(this, originator))
+        {

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

-                      r9254
+                      r9348
             virtual void addedWeaponPack(WeaponPack* wPack) {}
-            inline const WorldEntity* getWorldEntity() const
-                { return const_cast<Pawn*>(this); }
             inline void setSpawnParticleSource(const std::string& source)
                 { this->spawnparticlesource_ = source; }
 …
                 { return this->numexplosionchunks_; }
+            // These are used with the Damage Boost Pickup to use the damage multiplier.
+            inline void setDamageMultiplier(float multiplier)
+                { this->damageMultiplier_ = multiplier; }
+            inline float getDamageMultiplier() const
+                { return this->damageMultiplier_; }
             virtual void startLocalHumanControl();
 …
             float maxShieldHealth_;
             float initialShieldHealth_;
             float shieldAbsorption_; // Has to be between 0 and 1
+            float shieldAbsorption_; ///< Has to be between 0 and 1
             float reloadRate_;
             float reloadWaitTime_;
             float reloadWaitCountdown_;
+            float damageMultiplier_; ///< Used by the Damage Boost Pickup.
             WeakPtr<Pawn> lastHitOriginator_;

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

-                      r8892
+                      r9348
+    {
         SetConfigValue(bInvertYAxis_, false).description("Set this to true for joystick-like mouse behaviour (mouse up = ship down).");
         SetConfigValueExternal(bEnableMotionBlur_, "GraphicsSettings", "enableMotionBlur", true)
             .description("Enable or disable the motion blur effect when moving very fast")
 …
     void SpaceShip::resetCamera()
+    {
         if(this->hasLocalController() && this->hasHumanController())
+        {
+        if(this->hasLocalController() && this->hasHumanController())
+        {
             Camera *camera = this->getCamera();
             if (camera == 0)
 …
             camera->setPosition(this->cameraOriginalPosition_);
             camera->setOrientation(this->cameraOriginalOrientation_);
+        }
+        }
+    }

Context Navigation

Legend:

Download in other formats: