Index: code/trunk/src/modules/pickup/items/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/pickup/items/CMakeLists.txt	(revision 8220)
+++ code/trunk/src/modules/pickup/items/CMakeLists.txt	(revision 8706)
@@ -6,3 +6,4 @@
   SpeedPickup.cc
   ShieldPickup.cc
+  ShrinkPickup.cc
 )
Index: code/trunk/src/modules/pickup/items/ShrinkPickup.cc
===================================================================
--- code/trunk/src/modules/pickup/items/ShrinkPickup.cc	(revision 8706)
+++ code/trunk/src/modules/pickup/items/ShrinkPickup.cc	(revision 8706)
@@ -0,0 +1,278 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+
+/**
+    @file ShrinkPickup.cc
+    @brief Implementation of the HealthPickup class.
+*/
+
+
+#include "ShrinkPickup.h"
+
+#include <sstream>
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+
+#include "pickup/PickupIdentifier.h"
+#include "worldentities/pawns/Pawn.h"
+
+#include "weaponsystem/WeaponSlot.h"
+#include "weaponsystem/Weapon.h"
+#include "worldentities/CameraPosition.h"
+
+namespace orxonox
+{
+    CreateFactory(ShrinkPickup);
+
+        /**
+    @brief
+        Constructor: Initializes the Pickup.
+    */
+    ShrinkPickup::ShrinkPickup(BaseObject* creator) : Pickup(creator)
+    {
+        RegisterObject(ShrinkPickup);
+
+        this->initialize();
+        this->shrinkFactor_ = 5.0f;
+        this->shrinkSpeed_ = 5.0f;
+        this->duration_ = 5.0f;
+        this->isActive_ = false;
+        this->isTerminating_ = false;
+
+        this->size_ = 0;
+        this->defaultCameraPos_ = 0.0f;
+        this->defaultScale_ = Vector3::UNIT_SCALE;
+        this->actualScale_ = Vector3::UNIT_SCALE;
+        this->smallScale_ = Vector3::UNIT_SCALE;
+        this->defaultMass_ = 1.0f;
+        this->actualMass_ = 1.0f;
+        this->smallMass_ = 1.0f;
+        this->pawn_ = NULL;
+    }
+
+    ShrinkPickup::~ShrinkPickup()
+    {
+
+    }
+
+    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->getShrinkSpeed();
+        std::string val3 = stream.str();
+        std::string type3 = "shrinkSpeed";
+        this->pickupIdentifier_->addParameter(type3, val3);
+    }
+
+   /**
+    @brief
+        Method for creating a ShrinkhPickup object through XML.
+    */
+    void ShrinkPickup::XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode)
+    {
+        SUPER(ShrinkPickup, XMLPort, xmlelement, mode);
+
+        XMLPortParam(ShrinkPickup, "shrinkFactor", setShrinkFactor, getShrinkFactor, xmlelement, mode);
+        XMLPortParam(ShrinkPickup, "duration", setDuration, getDuration, xmlelement, mode);
+        XMLPortParam(ShrinkPickup, "shrinkSpeed", setShrinkSpeed, getShrinkSpeed, xmlelement, mode);
+
+        this->initializeIdentifier();
+    }
+
+    /**
+    @brief
+        Sets the shrinking factor.
+    @param factor
+        The factor.
+    */
+    void ShrinkPickup::setShrinkFactor(float factor)
+    {
+        this->shrinkFactor_ = factor;
+    }
+
+    /**
+    @brief
+        Sets the duration.
+    @param duration
+        The duration.
+    */
+    void ShrinkPickup::setDuration(float duration)
+    {
+        this->duration_ = duration;
+    }
+
+    /**
+    @brief
+        Sets the shrinking speed.
+    @param speed
+        The speed.
+    */
+    void ShrinkPickup::setShrinkSpeed(float speed)
+    {
+        this->shrinkSpeed_ = speed;
+    }
+
+    void ShrinkPickup::initialize(void)
+    {
+        this->addTarget(ClassIdentifier<Pawn>::getIdentifier());
+    }
+
+    /**
+    @brief
+        Prepares for shrinking (collecting several informations).
+    */
+    void ShrinkPickup::changedUsed(void)
+    {
+        SUPER(ShrinkPickup, changedUsed);
+
+        if(this->isUsed())
+        {
+            this->pawn_ = this->carrierToPawnHelper();
+            if(this->pawn_ == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
+                this->Pickupable::destroy();
+
+            //Collect scaling information.
+            this->defaultScale_ = this->pawn_->getScale3D();
+            this->defaultMass_ = this->pawn_->getMass();
+
+            this->smallScale_ = this->defaultScale_ / this->shrinkFactor_;
+            this->smallMass_ = this->defaultMass_ / this->shrinkFactor_;
+
+            this->actualScale_ = this->defaultScale_;
+            this->actualMass_ = this->defaultMass_;
+
+            this->cameraPositions_ = this->pawn_->getCameraPositions();
+            this->size_ = this->cameraPositions_.size();
+            this->isActive_ = true;    //start shrinking now.
+            this->durationTimer_.setTimer(this->duration_, false, createExecutor(createFunctor(&ShrinkPickup::terminate, this)));    //Set timer for termination.
+        }
+    }
+
+    /**
+    @brief
+        Updates the scales of the ship.
+    @param dt
+        Time since last call.
+    */
+    void ShrinkPickup::tick(float dt)
+    {
+        if(this->isActive_ == true && this->actualScale_ > this->smallScale_)    //if the ship has not reached the target scale, continue shrinking
+        {
+            float factor = 1 + dt*this->shrinkSpeed_;
+
+            this->actualScale_ /= factor;
+            this->actualMass_ /= factor;
+
+            this->pawn_->setScale3D(this->actualScale_);
+            this->pawn_->setMass(this->actualMass_);
+
+            for(int index = 0; index < this->size_; index++)
+            {
+                CameraPosition* cameraPos = this->pawn_->getCameraPosition(index);
+                if(cameraPos == NULL)
+                continue;
+                cameraPos->setPosition(cameraPos->getPosition()*factor);
+            }
+        }
+        else this->isActive_ = false;
+
+        if(this->isTerminating_ == true && this->actualScale_ < this->defaultScale_)    //grow until the ship reaches its default scale.
+        {
+            float factor = 1 + dt*this->shrinkSpeed_;
+
+            this->actualScale_ *= factor;
+            this->actualMass_ *= factor;
+
+            this->pawn_->setScale3D(this->actualScale_);
+            this->pawn_->setMass(this->actualMass_);
+
+            for(int index = 0; index < this->size_; index++)
+            {
+                CameraPosition* cameraPos = this->pawn_->getCameraPosition(index);
+                if(cameraPos == NULL)
+                continue;
+                cameraPos->setPosition(cameraPos->getPosition()/factor);
+            }
+        }
+        else if(this->isTerminating_ == true)
+            this->Pickupable::destroy();
+
+    }
+
+    /**
+    @brief
+        Initializes the termination.
+    */
+    void ShrinkPickup::terminate(void)
+    {
+        this->isActive_ = false;
+        this->isTerminating_ = true;
+        setUsed(false);
+    }
+
+    Pawn* ShrinkPickup::carrierToPawnHelper(void)
+    {
+        PickupCarrier* carrier = this->getCarrier();
+        Pawn* pawn = dynamic_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->setShrinkSpeed(this->getShrinkSpeed());
+
+        pickup->initializeIdentifier();
+    }
+}
Index: code/trunk/src/modules/pickup/items/ShrinkPickup.h
===================================================================
--- code/trunk/src/modules/pickup/items/ShrinkPickup.h	(revision 8706)
+++ code/trunk/src/modules/pickup/items/ShrinkPickup.h	(revision 8706)
@@ -0,0 +1,124 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Damian 'Mozork' Frick
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file ShrinkPickup.h
+    @brief Declaration of the ShrinkPickup class.
+    @ingroup PickupItems
+*/
+
+
+#ifndef _ShrinkPickup_H__
+#define _ShrinkPickup_H__
+
+#include "pickup/PickupPrereqs.h"
+
+#include <string>
+#include <vector>
+
+#include "pickup/Pickup.h"
+#include "tools/interfaces/Tickable.h"
+
+namespace orxonox {
+
+    /**
+    @author
+        Sandro Sgier
+
+    @ingroup PickupItems
+    */
+
+    /**
+    @brief
+        The ShrinkPickup is a Pickupable that causes the pawn to shrink to a certain size for a certain time with a certain speed, all of them specified in the following variables:
+        - The @b shrinkFactor It determines how much the ship is going to shrink (e.g. the factor 2 would make the ship shrinking to half its size).
+        - The @b duration Specifies how long the ship will keep small.
+        - The @b shrinkSpeed Defines how fast the ship shrinks and grows.
+
+
+        An example of a XML implementation of a HealthPickup would be:
+        @code
+        <HealthPickup
+            shrinkFactor = "5.0"
+            duration = "5.0"
+            shrinkSpeed = "5.0"
+        />
+        @endcode
+
+    @author
+        Sandro Sgier
+
+    @ingroup PickupItems
+    */
+
+    class _PickupExport ShrinkPickup : public Pickup, public Tickable
+    {
+        public:
+            ShrinkPickup(BaseObject* creator); //!< Constructor.
+            virtual ~ShrinkPickup(); //!< Destructor.
+            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.
+            virtual void XMLPort(Element& xmlelement, orxonox::XMLPort::Mode mode);
+            inline float getShrinkFactor(void) const
+                { return this->shrinkFactor_; }
+            inline float getDuration(void) const
+                { return this->duration_; }
+            inline float getShrinkSpeed(void) const
+                { return this->shrinkSpeed_; }
+            void setShrinkFactor(float factor);
+            void setDuration(float duration);
+            void setShrinkSpeed(float speed);
+            void tick(float dt);
+
+        protected:
+            void initializeIdentifier(void);
+
+        private:
+            void initialize(void);
+            float duration_;            //!< determines how long the pickup will be active
+            float shrinkFactor_;        //shrink factor of the space ship
+            float shrinkSpeed_;         //speed of shrinking
+            bool isActive_;             //true if ship is shrinking or small
+            bool isTerminating_;        //true if ship is growing
+            int size_;                  //number of camera positions
+            std::list<SmartPtr<CameraPosition> > cameraPositions_;
+            float defaultCameraPos_;    //all default, actual and small values...
+            Ogre::Vector3 defaultScale_;
+            Ogre::Vector3 actualScale_;
+            Ogre::Vector3 smallScale_;
+            float defaultMass_;
+            float actualMass_;
+            float smallMass_;            
+            Pawn* carrierToPawnHelper(void);
+            Pawn* pawn_;
+            Timer durationTimer_;
+            void terminate(void);
+    };
+}
+
+#endif
