Index: code/branches/presentation/src/orxonox/objects/pickup/BaseItem.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/BaseItem.cc	(revision 2500)
+++ code/branches/presentation/src/orxonox/objects/pickup/BaseItem.cc	(revision 2500)
@@ -0,0 +1,77 @@
+/* has to be added to player
+   multimap<std::string, BaseItem*> Equipment;*/
+
+
+#include "BaseItem.h"
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "util/String.h"
+#include "objects/worldentities/pawns/Pawn.h"
+
+
+namespace orxonox
+{
+BaseItem::BaseItem(BaseObject* creator) : BaseObject(creator)
+{
+	RegisterObject(BaseItem);
+
+	this->playerBaseClass_ = 0;
+}
+
+BaseItem::~BaseItem()
+{
+}
+    void BaseItem::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(BaseItem, XMLPort, xmlelement, mode);
+
+        XMLPortParam(BaseItem, "playerclass", setPlayerBaseClassName, getPlayerBaseClassName, xmlelement, mode);
+    }
+
+bool BaseItem::addTo (Pawn* player)
+{
+
+	return player->getPickUp().insert(this);
+	/*if(checkSlot(player)==true)
+	player->pickUp.Equipment.insert ( std::pair<std::string, BaseItem*>(this->getName(),this) );
+	else
+	COUT(3) << "swap?" << std::endl;*/
+}
+bool BaseItem::remove(Pawn* player)
+{
+ 	/*if(player->pickUp.Equipment.find(this->getName())!= player->pickUp.Equipment.end())
+ 	{
+ 	std::multimap<std::string,BaseItem*>::iterator it;
+ 	it=player->pickUp.Equipment.find(this->getName());
+  	player->pickUp.Equipment.erase (it);
+  	return true;
+  	}
+  	else
+  	return false;*/
+  	return player->getPickUp().erase(this);
+}
+bool BaseItem::checkSlot(Pawn* player)
+{
+	/*std::multimap<std::string,BaseItem*>::iterator it;
+	for ( it=player->getPickUp().getEquipment().begin() ; it != player->getPickUp().getEquipment().end(); it++ )
+	{
+	if((*it).second->playerBaseClass_==this->playerBaseClass_)
+		//das isch schmarre...machs mit isExactlyA(...)
+	return false;
+	}
+	return true;*/
+	return player->getPickUp().checkSlot(this);
+}
+void BaseItem::setPlayerBaseClassName(const std::string& name)
+{
+	this->playerBaseClass_ = ClassByString(name);
+}
+
+const std::string& BaseItem::getPlayerBaseClassName() const
+{
+	if (this->playerBaseClass_)
+		return this->playerBaseClass_->getName();
+	else
+		return BLANKSTRING;
+}
+}
Index: code/branches/presentation/src/orxonox/objects/pickup/BaseItem.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/BaseItem.h	(revision 2500)
+++ code/branches/presentation/src/orxonox/objects/pickup/BaseItem.h	(revision 2500)
@@ -0,0 +1,37 @@
+#ifndef _BaseItem_H__
+#define _BaseItem_H__
+
+#include "core/BaseObject.h"
+#include "OrxonoxPrereqs.h"
+
+namespace orxonox
+{
+	class ShipEquipment;
+
+	class _OrxonoxExport BaseItem : public BaseObject
+	{
+	public:
+	BaseItem( BaseObject* creator);
+	virtual ~BaseItem();
+	bool checkSlot(Pawn* player);
+	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+
+	virtual bool pickedUp(Pawn* player) { return true; }
+	virtual bool dropped(Pawn* player) { return true; } //erst bei festen Items
+	bool remove(Pawn* player);
+	bool addTo(Pawn* player);
+
+	inline void setPlayerBaseClass(Identifier* identifier)
+		{ this->playerBaseClass_ = identifier; }
+	inline Identifier* getPlayerBaseClass() const
+		{ return this->playerBaseClass_; }
+
+	private:
+	void setPlayerBaseClassName(const std::string& name);
+	const std::string& getPlayerBaseClassName() const;
+
+	Identifier* playerBaseClass_;
+	};
+}
+
+#endif /* _BaseItem_H__ */
Index: code/branches/presentation/src/orxonox/objects/pickup/CMakeLists.txt
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/CMakeLists.txt	(revision 2493)
+++ code/branches/presentation/src/orxonox/objects/pickup/CMakeLists.txt	(revision 2500)
@@ -1,5 +1,7 @@
 SET( SRC_FILES
-  ShipEquipmentClasses.cc
-  ShipItem.cc
+  PickupSpawner.cc
+  Item.cc
+  Turbo.cc
+  ShipEquipment.cc
 )
 
Index: code/branches/presentation/src/orxonox/objects/pickup/PickupSpawner.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/PickupSpawner.cc	(revision 2500)
+++ code/branches/presentation/src/orxonox/objects/pickup/PickupSpawner.cc	(revision 2500)
@@ -0,0 +1,120 @@
+#include "PickupSpawner.h"
+#include "BaseItem.h"
+#include "objects/worldentities/pawns/Pawn.h"
+#include "objects/worldentities/triggers/DistanceTrigger.h"
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "core/Template.h"
+
+namespace orxonox
+{
+CreateFactory(PickupSpawner);
+
+PickupSpawner::PickupSpawner(BaseObject* creator) : StaticEntity(creator)
+{
+	RegisterObject(PickupSpawner);
+
+	this->template_ = 0;
+	this->distance_ = 20;
+	this->respawntimer_= 0;
+}
+
+PickupSpawner::~PickupSpawner()
+{
+}
+
+void PickupSpawner::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+{
+	SUPER(PickupSpawner, XMLPort, xmlelement, mode);
+
+	XMLPortParam(PickupSpawner, "item", setItemTemplate, getItemTemplate, xmlelement, mode);
+	XMLPortParam(PickupSpawner, "distance", setDistance, getDistance, xmlelement, mode).defaultValues(20.0f);
+	XMLPortParam(PickupSpawner, "respawntimer", setRespawnTimer, getRespawnTimer, xmlelement, mode);
+
+}
+
+void PickupSpawner::tick(float dt)
+{
+  if (this->isActive())
+  {
+    for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
+    {
+      Vector3 distanceVec = it->getWorldPosition() - this->getWorldPosition();
+      if (distanceVec.length() < this->distance_)
+        this->triggering(*it);
+    }
+  }
+}
+
+void PickupSpawner::setItemTemplate(const std::string& itemtemplate)
+{
+	this->itemtemplate_ = itemtemplate;
+	this->template_ = Template::getTemplate(itemtemplate);
+}
+
+void PickupSpawner::triggering(Pawn* player)
+{
+	if (this->isActive() && this->template_ && this->template_->getBaseclassIdentifier())
+	{
+		COUT(0) << "ITEM PICKED UP" << std::endl;
+		//if(player->isA(itemtemplate_->getPlayerBaseClass()))
+		{
+		BaseObject* newobject = this->template_->getBaseclassIdentifier()->fabricate(this);
+		BaseItem* newitem = dynamic_cast<BaseItem*>(newobject);
+		if (newitem)
+		{
+			newitem->addTemplate(this->itemtemplate_);
+			if (newitem->pickedUp(player)== true)
+			{
+				if(respawntimer_!=0)
+					this->triggerRespawnTimer();
+				this->setActive(false);
+				this->fireEvent();
+			}
+			else
+				delete newobject;
+		}
+		}
+		//else
+		//	delete newobject;
+	}
+}
+
+void PickupSpawner::triggerRespawnTimer()
+{
+
+	if(respawntimer_!=0)
+	{
+		ExecutorMember<BaseObject>* executor = createExecutor(createFunctor(&BaseObject::setActive));
+		executor->setDefaultValues(true);
+		RespawnTimer_.setTimer(this->respawntimer_, false, (BaseObject*)this, executor);
+		COUT(0) << "TIMER SET" << std::endl;
+	}
+}
+void PickupSpawner::changedActivity()
+{
+/*
+	COUT(0) << "Visble?" << std::endl;
+	if(isActive())
+	{
+		setVisible(true);
+		COUT(0) << "Visble!" << std::endl;
+	}
+	if(isActive()==false)
+	{
+		setVisible(false);
+		COUT(0) << "INvisble!" << std::endl;
+	}
+
+*/
+	SUPER(PickupSpawner, changedActivity);
+
+	for (std::set<WorldEntity*>::iterator it = this->getAttachedObjects().begin(); it != this->getAttachedObjects().end(); ++it)
+		(*it)->setVisible(this->isActive());
+}
+
+
+}
+
+
+
Index: code/branches/presentation/src/orxonox/objects/pickup/PickupSpawner.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/PickupSpawner.h	(revision 2500)
+++ code/branches/presentation/src/orxonox/objects/pickup/PickupSpawner.h	(revision 2500)
@@ -0,0 +1,67 @@
+#ifndef _PickupSpawner_H__
+#define _PickupSpawner_H__
+
+#include "OrxonoxPrereqs.h"
+#include "BaseItem.h"
+#include "tools/Timer.h"
+#include "objects/worldentities/StaticEntity.h"
+#include "objects/Tickable.h"
+
+namespace orxonox
+{
+	class _OrxonoxExport PickupSpawner : public StaticEntity, public Tickable
+	{
+	public:
+	PickupSpawner(BaseObject* creator);
+	virtual ~PickupSpawner();
+	virtual void changedActivity();
+	virtual void tick(float dt);
+	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+	virtual void triggering(Pawn* trigger); // Wenn ein Spieler in die Naehe kommt
+	void triggerRespawnTimer();
+
+	/*inline void setVisibility(bool visible)
+		{ this->setActive(visible); }
+	inline float getVisibility() const
+		{ return this->isActive(); }*/
+
+	void setItemTemplate(const std::string& itemtemplate);
+	inline const std::string& getItemTemplate() const
+		{ return this->itemtemplate_; }
+
+	inline void setDistance(float distance)
+		{ this->distance_ = distance; }
+	inline float getDistance() const
+		{ return this->distance_; }
+	inline void setRespawnTimer (float respawntimer)
+		{ this->respawntimer_ = respawntimer; }
+	inline float getRespawnTimer() const
+		{ return this->respawntimer_; }
+
+	private:
+	std::string itemtemplate_;
+	Template* template_;
+	float distance_;
+	float respawntimer_;
+	Timer<BaseObject> RespawnTimer_;
+	};
+}
+
+#endif /* _PickupSpawner_H__ */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Index: code/branches/presentation/src/orxonox/objects/pickup/ShipEquipment.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/ShipEquipment.cc	(revision 2500)
+++ code/branches/presentation/src/orxonox/objects/pickup/ShipEquipment.cc	(revision 2500)
@@ -0,0 +1,97 @@
+#include "BaseItem.h"
+#include "ShipEquipment.h"
+#include "objects/worldentities/pawns/Pawn.h"
+
+
+namespace orxonox
+{
+/**
+@brief
+    Insert a permanent Item to the Equipment. Is usually called by the addTo function in Items.
+
+@param item
+    pointer to the item which is to be inserted.
+
+@return
+    if new item has sucessfully been added it will return true, in any other case the return value is false.
+*/
+	bool ShipEquipment::insert(BaseItem* item)
+	{
+	if(checkSlot(item)==NULL)
+	{
+		Equipment.insert ( std::pair<std::string, BaseItem*>(item->getName(),item) );
+		return true;
+	}
+	else
+	{
+		COUT(3) << "SWAP?" <<  endl;
+		//Abfrage- irgendne ifschleife...
+		if((checkSlot(item)->dropped(player))==true);
+		{
+			Equipment.insert ( std::pair<std::string, BaseItem*>(item->getName(),item) );
+			COUT(3) << "SWAPPED!" <<  endl;
+			return true;
+		}
+		return false;
+	}
+
+	return false;
+	};
+
+/**
+@brief
+    Erases a permanent Item in the Equipment. Is usually called by the remove/dropped function in Items.
+
+@param item
+    pointer to the item which is to be erased.
+
+@return
+    if new item has sucessfully been erased it will return true, in any other case the return value is false.
+*/
+	bool ShipEquipment::erase (BaseItem* item)
+	{
+	std::multimap<std::string,BaseItem*>::iterator it = Equipment.find(item->getName());
+	if(it != Equipment.end())
+ 	{
+  		Equipment.erase (it);
+  		return true;
+  	}
+  	return false;
+	};
+	/*void print(std::multimap<std::string, BaseItem*> eut)
+	{
+		std::multimap<std::string,BaseItem*>::iterator it;
+		COUT(3) << "Liste:" <<  endl;
+		for ( it=eut.begin() ; it != eut.end(); ++it )
+		    COUT(3) << (*it).first << endl;
+
+	}*/
+/**
+@brief
+    Erases all permanent Items in the Equipment. Its Triggered by hitting the L button.
+
+*/
+	void ShipEquipment::eraseAll()
+	{
+		//print(Equipment);
+		for (std::multimap<std::string,BaseItem*>::iterator it = Equipment.begin(); it != Equipment.end(); )
+		{
+
+			(it++)->second->dropped(this->getPlayer());
+		}
+		//print(Equipment);
+	}
+
+	BaseItem* ShipEquipment::checkSlot(BaseItem* item)
+	{
+	std::multimap<std::string,BaseItem*>::iterator it;
+	for ( it= getPlayer()->getPickUp().getEquipment().begin() ; it != getPlayer()->getPickUp().getEquipment().end(); it++ )
+	{
+		//if((*it).second->getPlayerBaseClass()==item->getPlayerBaseClass())
+		if(item->isExactlyA((*it).second->getIdentifier()))
+		return (*it).second;
+	}
+	return NULL;
+	};
+
+}
Index: code/branches/presentation/src/orxonox/objects/pickup/ShipEquipment.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/ShipEquipment.h	(revision 2493)
+++ code/branches/presentation/src/orxonox/objects/pickup/ShipEquipment.h	(revision 2500)
@@ -1,26 +1,51 @@
-
 #ifndef _ShipEquipment_H__
 #define _ShipEquipment_H__
 #include <string>
-#include <multimap>
+#include <map>
+
+/*
+multimap<std::string, BaseItem*> equipment_;
+equipment_.insert(pair<std::string, BaseItem*>("Weapon", new BaseItem()));*/
 
 
-/*
-multimap<std::string, Item*> equipment_;
-equipment_.insert(pair<std::string, Item*>("Weapon", new Item()));*/
+/*          std::map<std::itemtype, BaseItem*> EQClasses;
+            EQClasses["jacke"] = 0;
+            BaseItem* item = itemMap_["jacke"];
 
-
+           if (itemMap_["jacke"])
+           if (itemMap_.find("jacke") != itemMap_.end()) */
 namespace orxonox
 {
+    class BaseItem;
+/**
+@brief
+    ShipEquipment is the inventory of a player. It's part of the Pawn class.
+
+*/
     class _OrxonoxExport ShipEquipment
     {
         public:
-            void AddItem(Shipitem toAddItem);
-            void RemoveItem(Shipitem toRemoveItem);
-            bool CheckifValid(Shipitem toBeChecked);
-            int
-
+	inline int getSpace()
+	{
+	return Usable.size()+Trunk.size();
+	};
+	bool insert(BaseItem* item);
+	bool erase (BaseItem* item);
+	//void print(std::multimap<std::string, BaseItem*> eut);
+	void eraseAll();
+	//bool checkSlot(BaseItem* item);
+	BaseItem* checkSlot(BaseItem* item);
+//	const std::multimap<std::string, BaseItem*>& getEquipment() const { return this->Equipment; }
+	inline std::multimap<std::string, BaseItem*>& getEquipment() {return this->Equipment;}
+	inline std::multimap<std::string, BaseItem*>& getUsable() {return this->Usable;}
+	inline std::multimap<std::string, BaseItem*>& getTrunk() {return this->Trunk;}
+	inline Pawn* getPlayer() {return this->player ;}
+	inline void setPlayer(Pawn* setplayer)
+	{this->player = setplayer;}
         private:
-            std::multimap<std::string, Item*> Equipment;
+            Pawn* player;//!< Is a pointer to the belonging player
+            std::multimap<std::string, BaseItem*> Equipment;//!< the Equipment for permanent Items
+            std::multimap<std::string, BaseItem*> Usable;//!< Where Usables are stored
+            std::multimap<std::string, BaseItem*> Trunk;//!< Every other Item is stored here
     };
 }
@@ -39,7 +64,3 @@
 
 
-
-
-
-
 #endif
Index: code/branches/presentation/src/orxonox/objects/pickup/ShipEquipmentClasses.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/ShipEquipmentClasses.cc	(revision 2493)
+++ code/branches/presentation/src/orxonox/objects/pickup/ShipEquipmentClasses.cc	(revision 2500)
@@ -57,9 +57,7 @@
                 }
                 break;
-            default:;
             }
         case Useable:
             return CheckifSpace();
-        case default:;
         }
         return true;
@@ -67,5 +65,5 @@
 
     /*Adds the Item to the Ship*/
-    void ShipEquipment::AddItem(Shipitem* toAddItem)
+    void ShipEquipment::AddItem(ShipItem* toAddItem)
     {
         if(CheckifValid(toAddItem)==true)
@@ -90,3 +88,49 @@
         }
     }
+
+    /*Adds the Item to the Ship*/
+    void ShipEquipment::AddItem(Shipitem* toAddItem)
+    {
+        if(CheckifValid(toAddItem)==true)
+        {
+            switch(toAddItem.CheckType()){
+                case Permanent:
+                    Equipment.insert ( pair<std::string, ShipItem*>(toAddItem.itemname,toAddItem) );
+                    break;
+                case Usable:
+                    Usable.insert ( pair<std::string, ShipItem*>(toAddItem.itemname,toAddItem) );
+                    break;
+                case Trunk:
+                    Trunk.insert ( pair<std::string, ShipItem*>(toAddItem.itemname,toAddItem) );
+                    break;
+            }
+        }
+        else if(toAddItem.CheckType()==Permanent)
+        {
+            if(CheckifSpace()==true)
+                Trunk.insert ( pair<std::string, ShipItem*>(toAddItem.itemname,toAddItem) );
+        }
+    }
+
+    void ShipEquipment::SwitchItem(Permanent* toSwitchItem)
+    {
+        multimap<string, ShipItem*>::iterator it;
+        string equippedname;
+        equippedname=GetNameofPermanent(toSwitchItem.CheckSubType());
+        it=Equipment.find(equippedname);
+        Trunk.insert (find(equippedname));
+        Equipment.erase (it);
+        Equipment.insert(pair<std::string, ShipItem*>(toSwitchItem.itemname,toSwitchItem)
+    }
+
+    string ShipEquipment::GetNameofPermanent (subItemTypePermanent NametoGet)
+    {
+        multimap<string, ShipItem*>::iterator it;
+        for ( it=Equipment.begin() ; it != Equipment.end(); it++ ){
+            if((*it).second->CheckSubType()==NametoGet){
+                return (*it).first.itemname;
+            }
+        }
+        return 0;
+    }
 }
Index: code/branches/presentation/src/orxonox/objects/pickup/ShipEquipmentClasses.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/ShipEquipmentClasses.h	(revision 2493)
+++ code/branches/presentation/src/orxonox/objects/pickup/ShipEquipmentClasses.h	(revision 2500)
@@ -8,11 +8,11 @@
 
 /*
-multimap<std::string, Item*> equipment_;
-equipment_.insert(pair<std::string, Item*>("Weapon", new Item()));*/
+multimap<std::string, BaseItem*> equipment_;
+equipment_.insert(pair<std::string, BaseItem*>("Weapon", new BaseItem()));*/
 
 
-/*          std::map<std::itemtype, Item*> EQClasses;
+/*          std::map<std::itemtype, BaseItem*> EQClasses;
             EQClasses["jacke"] = 0;
-            Item* item = itemMap_["jacke"];
+            BaseItem* item = itemMap_["jacke"];
 
            if (itemMap_["jacke"])
@@ -23,13 +23,15 @@
     {
         public:
-            void AddItem(Shipitem* toAddItem);
+            /*void AddItem(Shipitem* toAddItem);
             void RemoveItem(Shipitem* toRemoveItem);
             bool CheckifValid(Shipitem* toBeChecked);
             bool CheckifSpace();
+            void SwitchItem(Permanent* toSwitchItem);
+            string GetNameofPermanent (subItemTypePermanent NametoGet);*/ //holt den Namen des getragenen Items im jeweiligen Slot.
 
         private:
-            multimap<std::string, ShipItem*> Equipment;
-            multimap<std::string, ShipItem*> Usable;
-            multimap<std::string, ShipItem*> Trunk;
+            multimap<std::string, BaseItem*> Equipment;
+            multimap<std::string, BaseItem*> Usable;
+            multimap<std::string, BaseItem*> Trunk;
     };
 }
Index: code/branches/presentation/src/orxonox/objects/pickup/ShipItem.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/ShipItem.cc	(revision 2493)
+++ code/branches/presentation/src/orxonox/objects/pickup/ShipItem.cc	(revision 2500)
@@ -5,10 +5,20 @@
     itemtype ShipItem::CheckType()
     {
-        return this.type;
+        return this->type;
     }
 
     subItemTypePermanent CheckSubType()
     {
-        return this.subtype_permanent;
+        return this->subtype_permanent;
     }
+
+    subItemTypePowerups CheckSubType()
+    {
+        return this->subtype_powerups;
+    }
+    subItemTypeUsable CheckSubType()
+    {
+        return this->subtype_usables;
+    }
+
 }
Index: code/branches/presentation/src/orxonox/objects/pickup/ShipItem.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/ShipItem.h	(revision 2493)
+++ code/branches/presentation/src/orxonox/objects/pickup/ShipItem.h	(revision 2500)
@@ -21,5 +21,5 @@
         public:
             itemType CheckType();
-            virtual
+            //virtual ChecksubType();
 
         private:
@@ -27,5 +27,4 @@
             string itemname;
     };
-
 
     /* Useables are Items the Player can choose when to activate and then show an instant action/effect
@@ -37,5 +36,5 @@
             Rockets,
             Repairkits,
-            Triggers,		//trigger events usable by the player (Quests f.exp.)
+            Triggers,       //trigger events usable by the player (Quests f.exp.)
             Boosters,
             Shields,
Index: code/branches/presentation/src/orxonox/objects/pickup/Turbo.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/Turbo.cc	(revision 2500)
+++ code/branches/presentation/src/orxonox/objects/pickup/Turbo.cc	(revision 2500)
@@ -0,0 +1,127 @@
+#include "Turbo.h"
+
+#include "objects/worldentities/pawns/SpaceShip.h"
+#include "core/Executor.h"
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+
+namespace orxonox
+{
+
+
+	CreateFactory(Turbo);
+
+	Turbo::Turbo(BaseObject* creator) : BaseItem(creator)
+	{
+		RegisterObject(Turbo);
+
+		this->boost_ = 0;
+		this->duration_ = 0;
+		this->accboost_ = 1;
+		this->rotacc_= 0;
+	}
+
+	Turbo::~Turbo()
+	{
+	}
+
+    void Turbo::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(Turbo, XMLPort, xmlelement, mode);
+
+        XMLPortParam(Turbo, "boost", setBoost, getBoost, xmlelement, mode);
+        XMLPortParam(Turbo, "duration", setDuration, getDuration, xmlelement, mode);
+        XMLPortParam(Turbo, "accboost", setAccBoost, getAccBoost, xmlelement, mode);
+        XMLPortParam(Turbo, "rotacc", setRotAcc, getRotAcc, xmlelement, mode);
+    }
+
+	bool Turbo::pickedUp(Pawn* player)
+	{
+
+		if(player-> isA(this->getPlayerBaseClass()))
+			{
+			SpaceShip* ship = dynamic_cast <SpaceShip*>(player);
+			if(duration_==0 )
+			{
+				if(addTo(player))
+				{
+						COUT(3)<<"ITEM EQUIPPED"<<std::endl;
+						this->setSpeedBoost(ship);
+						return true;
+				}
+				return false;
+			}
+			else
+			{
+				this->setSpeedBoost(ship);
+				return true;
+			}
+			return false;
+			}
+		return false;
+
+	}
+
+
+	void Turbo::unsetSpeedBoost(SpaceShip* ship)
+	{
+/*
+	ship->setMaxSpeed( ship->getMaxSpeed() - this->boost_);
+	ship->setTransAcc( ship->getTransAcc()/this->accboost_);
+	ship->setMaxRotation( ship->getMaxRotation()-this->rotacc_);
+	ship->setRotAcc( ship->getRotAcc()-this->rotacc_);
+	COUT(3)<<"BOOST UNSET"<<std::endl;
+	COUT(3)<<"Speed:"<< ship->getMaxSpeed()<<std::endl;
+*/
+        ship->setPermanentBoost(false);
+	}
+
+	void Turbo::setSpeedBoost(SpaceShip* ship)
+	{
+/*
+	COUT(3)<<"Speed:"<< ship->getMaxSpeed()<<std::endl;
+	ship->setMaxSpeed( ship->getMaxSpeed() + this->boost_);
+	ship->setTransAcc( ship->getTransAcc()*this->accboost_);
+	ship->setMaxRotation( ship->getMaxRotation()+this->rotacc_);
+	ship->setRotAcc( ship->getRotAcc()+this->rotacc_);
+*/
+    ship->setPermanentBoost(true);
+    ship->setBoost(true);
+
+	if( this->duration_ != 0)
+	{
+		ExecutorMember<Turbo>* executor = createExecutor(createFunctor(&Turbo::unsetSpeedBoost));
+		executor->setDefaultValues(ship);
+		turbotimer_.setTimer(this->duration_, false, this, executor);
+	}
+//	COUT(3)<<"Speed:"<< ship->getMaxSpeed()<<std::endl;
+	}
+	bool Turbo::dropped(Pawn* player)
+	{
+		if (this->duration_ == 0)
+		{
+			COUT(0) << "ITEM DROPPED" << std::endl;
+			if(remove(player)==true);
+			{
+			SpaceShip* ship = dynamic_cast <SpaceShip*>(player);
+			this->unsetSpeedBoost(ship);
+			}
+		}
+		return true;
+	}
+
+}
+/*<Template baseclass="Turbo" name=turboitem>
+      <Turbo playerclass="SpaceShip" boost=150 duration=10 accboost=10 />
+    </Template>
+
+    <PickupSpawner item=turboitem>
+      <attached>
+        <Billboard material="Examples/Flare" scale=0.2 colour="0.0, 0.0, 1.0, 1.0" />
+      </attached>
+    </PickupSpawner>*/
+
+
+
+
+
Index: code/branches/presentation/src/orxonox/objects/pickup/Turbo.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/pickup/Turbo.h	(revision 2500)
+++ code/branches/presentation/src/orxonox/objects/pickup/Turbo.h	(revision 2500)
@@ -0,0 +1,56 @@
+#ifndef _Turbo_H__
+#define _Turbo_H__
+
+#include "tools/Timer.h"
+#include "BaseItem.h"
+#include "OrxonoxPrereqs.h"
+#include "util/Math.h"
+
+namespace orxonox
+{
+	class _OrxonoxExport Turbo : public BaseItem
+	{
+
+	public:
+	Turbo(BaseObject* creator);
+	virtual ~Turbo();
+
+	virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+
+	virtual bool pickedUp(Pawn* player);
+	virtual bool dropped(Pawn* player); //erst bei festen Items
+
+	void setSpeedBoost(SpaceShip* ship);
+	void unsetSpeedBoost(SpaceShip* ship);
+
+	inline void setBoost(float boost)
+		{ this->boost_ = boost; }
+	inline float getBoost() const
+		{ return this->boost_; }
+
+	inline void setDuration(float duration)
+		{ this->duration_ = duration; }
+	inline float getDuration() const
+		{ return this->duration_; }
+
+	inline void setRotAcc(Degree rotacc)
+		{ this->rotacc_ = rotacc; }
+	inline Degree getRotAcc() const
+		{ return this->rotacc_; }
+
+
+	inline void setAccBoost(float accboost)
+		{ this->accboost_ = accboost; }
+	inline float getAccBoost() const
+		{ return this->accboost_; }
+
+	private:
+	Timer<Turbo> turbotimer_;
+	float boost_;
+	float duration_;
+	float accboost_;
+	Degree rotacc_;
+	};
+}
+
+#endif /* _Turbo_H__ */
