Changeset 9348 for code/trunk/src/modules

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/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

Context Navigation

Legend:

Download in other formats: