Index: code/trunk/src/modules/gametypes/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/gametypes/CMakeLists.txt	(revision 8952)
+++ code/trunk/src/modules/gametypes/CMakeLists.txt	(revision 9016)
@@ -2,4 +2,7 @@
   SpaceRace.cc
   RaceCheckPoint.cc
+  SpaceRaceManager.cc
+  OldSpaceRace.cc
+  OldRaceCheckPoint.cc
 )
 
Index: code/trunk/src/modules/gametypes/GametypesPrereqs.h
===================================================================
--- code/trunk/src/modules/gametypes/GametypesPrereqs.h	(revision 8952)
+++ code/trunk/src/modules/gametypes/GametypesPrereqs.h	(revision 9016)
@@ -66,4 +66,5 @@
 {
     class SpaceRace;
+    class OldSpaceRace;
 }
 
Index: code/trunk/src/modules/gametypes/OldRaceCheckPoint.cc
===================================================================
--- code/trunk/src/modules/gametypes/OldRaceCheckPoint.cc	(revision 9016)
+++ code/trunk/src/modules/gametypes/OldRaceCheckPoint.cc	(revision 9016)
@@ -0,0 +1,120 @@
+/*
+ *   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:
+ *      Mauro Salomon
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OldRaceCheckPoint.h"
+
+#include "util/Convert.h"
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "chat/ChatManager.h"
+
+#include "OldSpaceRace.h"
+
+namespace orxonox
+{
+    CreateFactory(OldRaceCheckPoint);
+
+    OldRaceCheckPoint::OldRaceCheckPoint(BaseObject* creator): DistanceTrigger(creator), RadarViewable(creator, static_cast<WorldEntity*>(this))
+    {
+        RegisterObject(OldRaceCheckPoint);
+
+        this->bCheckpointIndex_ = 0;
+        this->bIsLast_ = false;
+        this->bTimeLimit_ = 0;
+
+        this->setRadarObjectColour(ColourValue::Blue);
+        this->setRadarObjectShape(RadarViewable::Triangle);
+        this->setRadarVisibility(false);
+    }
+
+    OldRaceCheckPoint::~OldRaceCheckPoint()
+    {
+    }
+
+    void OldRaceCheckPoint::tick(float dt)
+    {
+        SUPER(OldRaceCheckPoint, tick, dt);
+
+        OldSpaceRace* gametype = orxonox_cast<OldSpaceRace*>(this->getGametype().get());
+        assert(gametype);
+        if (this->getCheckpointIndex() == gametype->getCheckpointsReached())
+            this->setRadarVisibility(true);
+        else
+            this->setRadarVisibility(false);
+    }
+
+    void OldRaceCheckPoint::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(OldRaceCheckPoint, XMLPort, xmlelement, mode);
+
+        XMLPortParam(OldRaceCheckPoint, "checkpointindex", setCheckpointIndex, getCheckpointIndex, xmlelement, mode).defaultValues(0);
+        XMLPortParam(OldRaceCheckPoint, "islast", setLast, getLast, xmlelement, mode).defaultValues(false);
+        XMLPortParam(OldRaceCheckPoint, "timelimit", setTimelimit, getTimeLimit, xmlelement, mode).defaultValues(0);
+    }
+
+    void OldRaceCheckPoint::triggered(bool bIsTriggered)
+    {
+        DistanceTrigger::triggered(bIsTriggered);
+
+        OldSpaceRace* gametype = orxonox_cast<OldSpaceRace*>(this->getGametype().get());
+        if (gametype && this->getCheckpointIndex() == gametype->getCheckpointsReached() && bIsTriggered)
+        {
+            gametype->clock_.capture();
+            float time = gametype->clock_.getSecondsPrecise();
+            if (this->bTimeLimit_!=0 && time > this->bTimeLimit_)
+            {
+                gametype->timeIsUp();
+                gametype->end();
+            }
+            else if (this->getLast())
+                gametype->end();
+            else
+            {
+                gametype->newCheckpointReached();
+                this->setRadarObjectColour(ColourValue::Green); //sets the radar colour of the checkpoint to green if it is reached, else it is red.
+            }
+        }
+    }
+
+    void OldRaceCheckPoint::setTimelimit(float timeLimit)
+    {
+        this->bTimeLimit_ = timeLimit;
+        if (this->bTimeLimit_ != 0)
+        {
+            OldSpaceRace* gametype = orxonox_cast<OldSpaceRace*>(this->getGametype().get());
+            if (gametype)
+            {
+                const std::string& message =  "You have " + multi_cast<std::string>(this->bTimeLimit_)
+                            + " seconds to reach the check point " + multi_cast<std::string>(this->bCheckpointIndex_+1);
+                const_cast<GametypeInfo*>(gametype->getGametypeInfo())->sendAnnounceMessage(message);
+                ChatManager::message(message);
+            }
+        }
+    }
+
+}
Index: code/trunk/src/modules/gametypes/OldRaceCheckPoint.h
===================================================================
--- code/trunk/src/modules/gametypes/OldRaceCheckPoint.h	(revision 9016)
+++ code/trunk/src/modules/gametypes/OldRaceCheckPoint.h	(revision 9016)
@@ -0,0 +1,77 @@
+/*
+ *   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:
+ *      Mauro Salomon
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _OldRaceCheckPoint_H__
+#define _OldRaceCheckPoint_H__
+
+#include "gametypes/GametypesPrereqs.h"
+
+#include "objects/triggers/DistanceTrigger.h"
+#include "interfaces/RadarViewable.h"
+
+namespace orxonox
+{
+    /**
+    @brief
+        The OldRaceCheckPoint class enables the creation of a check point to use in a OldSpaceRace level.
+        !!! Don't forget to control the indexes of your check points and to set one last check point!!!
+    */
+    class _GametypesExport OldRaceCheckPoint : public DistanceTrigger, public RadarViewable
+    {
+        public:
+            OldRaceCheckPoint(BaseObject* creator);
+            virtual ~OldRaceCheckPoint();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void tick(float dt);
+
+            protected:
+            virtual void triggered(bool bIsTriggered);
+            inline void setLast(bool isLast)
+                { this->bIsLast_ = isLast; }
+            inline bool getLast()
+                { return this->bIsLast_; }
+            inline void setCheckpointIndex(int checkpointIndex)
+                { this->bCheckpointIndex_ = checkpointIndex; }
+            inline int getCheckpointIndex()
+                { return this->bCheckpointIndex_; }
+            virtual void setTimelimit(float timeLimit);
+            inline float getTimeLimit()
+                { return this->bTimeLimit_;}
+            inline const WorldEntity* getWorldEntity() const
+                { return this; }
+
+        private:
+            int bCheckpointIndex_; //The index of this check point. This value will be compared with the number of check points reached in the level. The check points must be indexed in ascending order beginning from zero and without any jumps between the indexes.
+            bool bIsLast_; //True if this check point is the last of the level. There can be only one last check point for each level and there must be a last check point in the level.
+            float bTimeLimit_; //The time limit (from the start of the level) to reach this check point. If the check point is reached after this time, the game ends and the player looses.
+      
+    };
+}
+
+#endif /* _OldRaceCheckPoint_H__ */
Index: code/trunk/src/modules/gametypes/OldSpaceRace.cc
===================================================================
--- code/trunk/src/modules/gametypes/OldSpaceRace.cc	(revision 9016)
+++ code/trunk/src/modules/gametypes/OldSpaceRace.cc	(revision 9016)
@@ -0,0 +1,104 @@
+/*
+ *   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:
+ *     Mauro Salomon
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OldSpaceRace.h"
+
+#include "core/CoreIncludes.h"
+#include "chat/ChatManager.h"
+#include "util/Convert.h"
+#include "util/Math.h"
+
+namespace orxonox
+{
+    CreateUnloadableFactory(OldSpaceRace);
+
+    OldSpaceRace::OldSpaceRace(BaseObject* creator) : Gametype(creator)
+    {
+        RegisterObject(OldSpaceRace);
+        this->checkpointsReached_ = 0;
+        this->bTimeIsUp_ = false;
+        this->numberOfBots_ = 0;
+    }
+
+    void OldSpaceRace::end()
+    {
+        this->Gametype::end();
+
+        if (this->bTimeIsUp_)
+        {
+            this->clock_.capture();
+            int s = this->clock_.getSeconds();
+            int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
+            const std::string& message = multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms) + " seconds !!\n"
+                        + "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);
+            ChatManager::message(message);
+        }
+        else
+        {
+            this->clock_.capture();
+            int s = this->clock_.getSeconds();
+            int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
+            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);
+            ChatManager::message(message);
+/*
+            float time = this->clock_.getSecondsPrecise();
+            this->scores_.insert(time);
+            std::set<float>::iterator it;
+            for (it=this->scores_.begin(); it!=this->scores_.end(); it++)
+                orxout(level::message) << multi_cast<std::string>(*it) << endl;
+*/
+        }
+    }
+
+    void OldSpaceRace::start()
+    {
+        Gametype::start();
+
+        std::string message("The match has started! Reach the check points as quickly as possible!");
+        const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+        ChatManager::message(message);
+    }
+
+    void OldSpaceRace::newCheckpointReached()
+    {
+        this->checkpointsReached_++;
+        this->clock_.capture();
+        int s = this->clock_.getSeconds();
+        int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
+        const std::string& message = "Checkpoint " + multi_cast<std::string>(this->getCheckpointsReached())
+                        + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms)
+                        + " seconds.";
+        const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+        ChatManager::message(message);
+    }
+
+}
Index: code/trunk/src/modules/gametypes/OldSpaceRace.h
===================================================================
--- code/trunk/src/modules/gametypes/OldSpaceRace.h	(revision 9016)
+++ code/trunk/src/modules/gametypes/OldSpaceRace.h	(revision 9016)
@@ -0,0 +1,79 @@
+/*
+ *   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:
+ *      Mauro Salomon
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _OldSpaceRace_H__
+#define _OldSpaceRace_H__
+
+#include "gametypes/GametypesPrereqs.h"
+
+#include <set>
+#include <string>
+
+#include <util/Clock.h>
+
+#include "gametypes/Gametype.h"
+
+#include "OldRaceCheckPoint.h"
+
+namespace orxonox
+{
+  /**
+  @brief
+    The OldSpaceRace class enables the creation of a space race level, where the player has to reach check points in a given order.
+  */
+    class _GametypesExport OldSpaceRace : public Gametype
+    {
+        friend class OldRaceCheckPoint;
+
+        public:
+            OldSpaceRace(BaseObject* creator);
+            virtual ~OldSpaceRace() {}
+
+            virtual void start();
+            virtual void end();
+
+            virtual void newCheckpointReached();
+
+            inline void setCheckpointsReached(int n)
+                { this->checkpointsReached_ = n;}
+            inline int getCheckpointsReached()
+                { return this->checkpointsReached_; }
+            inline void timeIsUp()
+                { this->bTimeIsUp_ = true;}
+
+        protected:
+
+        private:
+            int checkpointsReached_; //The current number of check points reached by the player.
+            std::set<float> scores_; //The times of the players are saved in a set.
+            bool bTimeIsUp_; //True if one of the check points is reached too late.
+            Clock clock_; //The clock starts running at the beginning of the game. It is used to give the time at each check point, the give the time at the end of the game, and to stop the game if a check point is reached too late.
+    };
+}
+
+#endif /* _OldSpaceRace_H__ */
Index: code/trunk/src/modules/gametypes/RaceCheckPoint.cc
===================================================================
--- code/trunk/src/modules/gametypes/RaceCheckPoint.cc	(revision 8952)
+++ code/trunk/src/modules/gametypes/RaceCheckPoint.cc	(revision 9016)
@@ -34,4 +34,7 @@
 #include "chat/ChatManager.h"
 
+#include <infos/PlayerInfo.h>
+#include <worldentities/ControllableEntity.h>
+
 #include "SpaceRace.h"
 
@@ -39,11 +42,14 @@
 {
     CreateFactory(RaceCheckPoint);
+    
+     
 
-    RaceCheckPoint::RaceCheckPoint(BaseObject* creator): DistanceTrigger(creator), RadarViewable(creator, static_cast<WorldEntity*>(this))
+    RaceCheckPoint::RaceCheckPoint(BaseObject* creator): DistanceMultiTrigger(creator), RadarViewable(creator, static_cast<WorldEntity*>(this))
     {
         RegisterObject(RaceCheckPoint);
-
-        this->bCheckpointIndex_ = 0;
-        this->bIsLast_ = false;
+        this->setDistance(100);
+        this->setBeaconMode("off");
+        this->setBroadcast(false);
+        this->setSimultaneousTriggerers(100);
         this->bTimeLimit_ = 0;
 
@@ -51,9 +57,14 @@
         this->setRadarObjectShape(RadarViewable::Triangle);
         this->setRadarVisibility(false);
+        this->settingsChanged();
+        this->reached_=NULL;
+      
     }
+    
 
-    RaceCheckPoint::~RaceCheckPoint()
-    {
-    }
+   RaceCheckPoint::~RaceCheckPoint()
+   {
+    
+   }
 
     void RaceCheckPoint::tick(float dt)
@@ -63,8 +74,4 @@
         SpaceRace* gametype = orxonox_cast<SpaceRace*>(this->getGametype().get());
         assert(gametype);
-        if (this->getCheckpointIndex() == gametype->getCheckpointsReached())
-            this->setRadarVisibility(true);
-        else
-            this->setRadarVisibility(false);
     }
 
@@ -72,32 +79,23 @@
     {
         SUPER(RaceCheckPoint, XMLPort, xmlelement, mode);
-
+        Vector3 v= Vector3(0,0,0);
         XMLPortParam(RaceCheckPoint, "checkpointindex", setCheckpointIndex, getCheckpointIndex, xmlelement, mode).defaultValues(0);
         XMLPortParam(RaceCheckPoint, "islast", setLast, getLast, xmlelement, mode).defaultValues(false);
         XMLPortParam(RaceCheckPoint, "timelimit", setTimelimit, getTimeLimit, xmlelement, mode).defaultValues(0);
+    XMLPortParamTemplate(RaceCheckPoint, "nextcheckpoints", setNextcheckpoint, getNextcheckpoint, xmlelement, mode,const Vector3&).defaultValues(v);
     }
 
-    void RaceCheckPoint::triggered(bool bIsTriggered)
+    void RaceCheckPoint::fire(bool bIsTriggered,BaseObject* player)
     {
-        DistanceTrigger::triggered(bIsTriggered);
-
+        DistanceMultiTrigger::fire((bool)bIsTriggered,player);
+        
         SpaceRace* gametype = orxonox_cast<SpaceRace*>(this->getGametype().get());
-        if (gametype && this->getCheckpointIndex() == gametype->getCheckpointsReached() && bIsTriggered)
-        {
-            gametype->clock_.capture();
-            float time = gametype->clock_.getSecondsPrecise();
-            if (this->bTimeLimit_!=0 && time > this->bTimeLimit_)
-            {
-                gametype->timeIsUp();
-                gametype->end();
-            }
-            else if (this->getLast())
-                gametype->end();
-            else
-            {
-                gametype->newCheckpointReached();
-                this->setRadarObjectColour(ColourValue::Green); //sets the radar colour of the checkpoint to green if it is reached, else it is red.
-            }
-        }
+        assert(gametype);
+        ControllableEntity* entity = (ControllableEntity*) player;
+     
+        PlayerInfo* player2 = entity->getPlayer();
+     
+        if(bIsTriggered)
+            this->reached_=player2;
     }
 
@@ -108,4 +106,5 @@
         {
             SpaceRace* gametype = orxonox_cast<SpaceRace*>(this->getGametype().get());
+            assert(gametype);
             if (gametype)
             {
Index: code/trunk/src/modules/gametypes/RaceCheckPoint.h
===================================================================
--- code/trunk/src/modules/gametypes/RaceCheckPoint.h	(revision 8952)
+++ code/trunk/src/modules/gametypes/RaceCheckPoint.h	(revision 9016)
@@ -32,5 +32,7 @@
 #include "gametypes/GametypesPrereqs.h"
 
-#include "objects/triggers/DistanceTrigger.h"
+
+
+#include "objects/triggers/DistanceMultiTrigger.h"
 #include "interfaces/RadarViewable.h"
 
@@ -40,7 +42,7 @@
     @brief
         The RaceCheckPoint class enables the creation of a check point to use in a SpaceRace level.
-        !!! Don't forget to control the indexes of your check points and to set one last check point!!!
+         Don't forget to control the indexes of your check points and to set one last check point
     */
-    class _GametypesExport RaceCheckPoint : public DistanceTrigger, public RadarViewable
+    class _GametypesExport RaceCheckPoint : public DistanceMultiTrigger, public RadarViewable
     {
         public:
@@ -50,26 +52,38 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void tick(float dt);
+            inline void setCheckpointIndex(int checkpointIndex)
+                { this->bCheckpointIndex_ = checkpointIndex; }
+            inline int getCheckpointIndex()
+                { return this->bCheckpointIndex_; }
 
-            protected:
-            virtual void triggered(bool bIsTriggered);
+            inline void setNextcheckpoint(const Vector3& checkpoints)
+                { this->nextcheckpoints_=checkpoints; }
+            inline void setNextcheckpoint(float x, float y, float z)
+                { this->setNextcheckpoint(Vector3(x, y, z)); }
+            inline const Vector3& getNextcheckpoint() const
+                { return this->nextcheckpoints_; }
             inline void setLast(bool isLast)
                 { this->bIsLast_ = isLast; }
             inline bool getLast()
                 { return this->bIsLast_; }
-            inline void setCheckpointIndex(int checkpointIndex)
-                { this->bCheckpointIndex_ = checkpointIndex; }
-            inline int getCheckpointIndex()
-                { return this->bCheckpointIndex_; }
+
+            bool bIsLast_; //True if this check point is the last of the level. There can be only one last check point for each level and there must be a last check point in the level.
+            float bTimeLimit_; //The time limit (from the start of the level) to reach this check point. If the check point is reached after this time, the game ends and the player looses.
+            PlayerInfo* reached_;
+                
+            inline float getTimeLimit()
+                { return this->bTimeLimit_; }
+    
+        protected:
+            virtual void fire(bool bIsTriggered,BaseObject* player);
             virtual void setTimelimit(float timeLimit);
-            inline float getTimeLimit()
-                { return this->bTimeLimit_;}
+            
             inline const WorldEntity* getWorldEntity() const
                 { return this; }
 
         private:
-            int bCheckpointIndex_; //The index of this check point. This value will be compared with the number of check points reached in the level. The check points must be indexed in ascending order beginning from zero and without any jumps between the indexes.
-            bool bIsLast_; //True if this check point is the last of the level. There can be only one last check point for each level and there must be a last check point in the level.
-            float bTimeLimit_; //The time limit (from the start of the level) to reach this check point. If the check point is reached after this time, the game ends and the player looses.
-      
+            int bCheckpointIndex_; //The index of this check point. The race starts with the check point with the index 0
+            Vector3 nextcheckpoints_; //the indexes of the next check points
+            
     };
 }
Index: code/trunk/src/modules/gametypes/SpaceRace.cc
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRace.cc	(revision 8952)
+++ code/trunk/src/modules/gametypes/SpaceRace.cc	(revision 9016)
@@ -29,8 +29,13 @@
 #include "SpaceRace.h"
 
+
+#include "items/Engine.h"
+
 #include "core/CoreIncludes.h"
 #include "chat/ChatManager.h"
 #include "util/Convert.h"
 #include "util/Math.h"
+
+#include "items/Engine.h"
 
 namespace orxonox
@@ -41,8 +46,15 @@
     {
         RegisterObject(SpaceRace);
-        this->checkpointsReached_ = 0;
+        
         this->bTimeIsUp_ = false;
         this->numberOfBots_ = 0;
+        this->cantMove_=false;
+        
     }
+       
+    
+  // void SpaceRace::SetConfigValues(){
+    //SUPER(Gametype,setConfigValues);
+    //this->Gametype::SetConfigValue(initialStartCountdown_, 3.0f);}
 
     void SpaceRace::end()
@@ -56,6 +68,5 @@
             int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
             const std::string& message = multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms) + " seconds !!\n"
-                        + "You didn't reach the check point " + multi_cast<std::string>(this->checkpointsReached_+1)
-                        + " before the time limit. You lose!";
+                        + "You didn't reach the check point  before the time limit. You lose!";
             const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
             ChatManager::message(message);
@@ -70,11 +81,10 @@
             const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
             ChatManager::message(message);
-/*
+
             float time = this->clock_.getSecondsPrecise();
             this->scores_.insert(time);
             std::set<float>::iterator it;
-            for (it=this->scores_.begin(); it!=this->scores_.end(); it++)
-                orxout(level::message) << multi_cast<std::string>(*it) << endl;
-*/
+            
+
         }
     }
@@ -82,23 +92,100 @@
     void SpaceRace::start()
     {
-        Gametype::start();
 
-        std::string message("The match has started! Reach the check points as quickly as possible!");
+        this->spawnPlayersIfRequested();
+        Gametype::checkStart(); 
+        this->cantMove_=true; 
+        
+        for(ObjectList<Engine>::iterator it = ObjectList<Engine>::begin(); it; ++it) 
+        {
+            it->setActive(false);
+            
+        } 
+        this->addBots(this->numberOfBots_); 
+    }
+    
+    void SpaceRace::tick(float dt)
+    {
+        SUPER(SpaceRace,tick,dt);
+    
+        if(!this->isStartCountdownRunning() && this->cantMove_)
+        {
+            for(ObjectList<Engine>::iterator it = ObjectList<Engine>::begin(); it; ++it) 
+            { 
+                it->setActive(true);
+                
+            }
+            this->cantMove_= false;
+            
+            std::string message("The match has started! Reach the check points as quickly as possible!");
+            const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
+            ChatManager::message(message);            
+        }
+   
+    }
+
+    
+    
+    void SpaceRace::newCheckpointReached(SpaceRaceManager* p, int index,PlayerInfo* pl)
+    {
+        this->checkpointReached_[pl]=index;
+        this->clock_.capture();
+        int s = this->clock_.getSeconds();
+        int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
+        const std::string& message = "Checkpoint " + multi_cast<std::string>(index)
+            + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms)
+            + " seconds.";// Message is too long for a normal screen.
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
         ChatManager::message(message);
     }
-
-    void SpaceRace::newCheckpointReached()
-    {
-        this->checkpointsReached_++;
+   
+    void SpaceRace::newCheckpointReached(RaceCheckPoint* p, PlayerInfo* pl)
+    {   
+        int index = p->getCheckpointIndex();
+        this->checkpointReached_[pl]=index;
         this->clock_.capture();
         int s = this->clock_.getSeconds();
         int ms = static_cast<int>(this->clock_.getMilliseconds()-1000*s);
-        const std::string& message = "Checkpoint " + multi_cast<std::string>(this->getCheckpointsReached())
-                        + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms)
-                        + " seconds.";
+        const std::string& message = "Checkpoint " + multi_cast<std::string>(index)
+            + " reached after " + multi_cast<std::string>(s) + "." + multi_cast<std::string>(ms)
+            + " seconds.";
         const_cast<GametypeInfo*>(this->getGametypeInfo())->sendAnnounceMessage(message);
         ChatManager::message(message);
     }
+        
+    
+    void SpaceRace::playerEntered(PlayerInfo* player)
+    {
+        Gametype::playerEntered(player);
+    
+        this->checkpointReached_[player]=-1;
+        //this->playersAlive_++;
+    }
+    
+    bool SpaceRace::playerLeft(PlayerInfo* player)
+    {
+        return Gametype::playerLeft(player);
+        // bool valid_player = true;
+        //if (valid_player)
+       // {
+        //    this->playersAlive_--;
+        //}
 
+       // return valid_player;
+    }
+    
+    bool SpaceRace::allowPawnHit(Pawn* victim, Pawn* originator)
+    {
+        return false;
+    }
+
+    bool SpaceRace::allowPawnDamage(Pawn* victim, Pawn* originator)
+    {
+        return false;
+    }
+
+    bool SpaceRace::allowPawnDeath(Pawn* victim, Pawn* originator)
+    {
+        return false;
+    }
 }
Index: code/trunk/src/modules/gametypes/SpaceRace.h
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRace.h	(revision 8952)
+++ code/trunk/src/modules/gametypes/SpaceRace.h	(revision 9016)
@@ -34,4 +34,5 @@
 #include <set>
 #include <string>
+# include <vector>
 
 #include <util/Clock.h>
@@ -39,5 +40,5 @@
 #include "gametypes/Gametype.h"
 
-#include "RaceCheckPoint.h"
+#include "SpaceRaceManager.h"
 
 namespace orxonox
@@ -50,4 +51,5 @@
     {
         friend class RaceCheckPoint;
+       
 
         public:
@@ -58,20 +60,33 @@
             virtual void end();
 
-            virtual void newCheckpointReached();
+            virtual void newCheckpointReached(SpaceRaceManager* p, int index,PlayerInfo* pl);
+            virtual void newCheckpointReached(RaceCheckPoint* p, PlayerInfo* pl);
 
-            inline void setCheckpointsReached(int n)
-                { this->checkpointsReached_ = n;}
-            inline int getCheckpointsReached()
-                { return this->checkpointsReached_; }
+            inline void setCheckpointReached(int n, PlayerInfo* p)
+                { this->checkpointReached_[p] = n;}
+            inline int getCheckpointReached(PlayerInfo* p)
+                { return this->checkpointReached_[p]; }
+
             inline void timeIsUp()
                 { this->bTimeIsUp_ = true;}
+            void tick(float dt);
+            Clock clock_; //The clock starts running at the beginning of the game. It is used to give the time at each check point, the give the time at the end of the game, and to stop the game if a check point is reached too late.
 
+
+            bool allowPawnHit(Pawn* victim, Pawn* originator);
+
+            bool allowPawnDamage(Pawn* victim, Pawn* originator);
+
+            bool allowPawnDeath(Pawn* victim, Pawn* originator);
         protected:
-
+            virtual void playerEntered(PlayerInfo* player); //!< Initializes values.
+            virtual bool playerLeft(PlayerInfo* player); //!< Manages all local variables.
         private:
-            int checkpointsReached_; //The current number of check points reached by the player.
+            bool cantMove_;
+            std::map<PlayerInfo*, int>checkpointReached_; //The number of the last check point reached by each player.
             std::set<float> scores_; //The times of the players are saved in a set.
             bool bTimeIsUp_; //True if one of the check points is reached too late.
-            Clock clock_; //The clock starts running at the beginning of the game. It is used to give the time at each check point, the give the time at the end of the game, and to stop the game if a check point is reached too late.
+            
+            int playersAlive_;
     };
 }
Index: code/trunk/src/modules/gametypes/SpaceRaceManager.cc
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRaceManager.cc	(revision 9016)
+++ code/trunk/src/modules/gametypes/SpaceRaceManager.cc	(revision 9016)
@@ -0,0 +1,195 @@
+/*
+ *   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:
+ *     Celine Eggenberger
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "SpaceRaceManager.h"
+#include "SpaceRace.h"
+#include "infos/PlayerInfo.h"
+
+#include "core/XMLPort.h"
+
+#include "core/CoreIncludes.h"
+
+#include "util/Convert.h"
+#include "util/Math.h"
+
+
+
+namespace orxonox
+{
+    CreateFactory(SpaceRaceManager);
+
+    SpaceRaceManager::SpaceRaceManager(BaseObject* creator) : BaseObject(creator)
+    {
+        RegisterObject(SpaceRaceManager);
+         
+        this->firstcheckpointvisible_=false;
+         
+    }
+
+    SpaceRaceManager::~SpaceRaceManager()
+    {
+        if (this->isInitialized())
+        {
+            for (size_t i = 0; i < this->checkpoints_.size(); ++i)
+                this->checkpoints_[i]->destroy();
+        }
+    }
+   
+    void SpaceRaceManager::addCheckpoint(RaceCheckPoint* checkpoint)
+    {
+        this->checkpoints_.push_back(checkpoint);
+    }
+
+    RaceCheckPoint* SpaceRaceManager::getCheckpoint(unsigned int index) const
+    {
+        if (index < this->checkpoints_.size())
+            return this->checkpoints_[index];
+        else
+            return 0;
+    }
+    
+    int SpaceRaceManager::getIndex(RaceCheckPoint* r) 
+    {
+        for (size_t i = 0; i < this->checkpoints_.size(); ++i)
+            if (this->checkpoints_[i]==r) {return i;}
+           
+        return -1;
+    }
+    
+    void SpaceRaceManager::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(SpaceRaceManager, XMLPort, xmlelement, mode);
+
+        
+        XMLPortObject(SpaceRaceManager, RaceCheckPoint, "checkpoints", addCheckpoint, getCheckpoint,  xmlelement, mode);
+    }
+    
+    void SpaceRaceManager::tick(float dt)
+    {
+        SUPER(SpaceRaceManager,tick,dt);
+     
+        if(this->checkpoints_[0] != NULL && !this->firstcheckpointvisible_)
+        {
+            this->checkpoints_[0]->setRadarVisibility(true);
+            this->firstcheckpointvisible_=true;
+        }
+         
+        for (size_t i = 0; i < this->checkpoints_.size(); ++i)
+        {
+            if(this->checkpoints_[i]->reached_!=NULL)
+                this->checkpointReached(this->checkpoints_[i],this->checkpoints_[i]->reached_);
+        }
+    }
+    
+    
+    void SpaceRaceManager::checkpointReached(RaceCheckPoint* check, PlayerInfo* player)
+    {
+        SpaceRace* gametype = orxonox_cast<SpaceRace*>(this->getGametype().get());
+        assert(gametype);
+        
+        bool b =false;    
+            
+        int index=gametype->getCheckpointReached(player);
+        Vector3 v=Vector3 (-1,-1,-1);
+        if (index>-1)
+        {
+            RaceCheckPoint* tmp= this->getCheckpoint(index);
+            v= tmp->getNextcheckpoint();
+       
+            if (this->getCheckpoint(v.x) == check)
+            {
+                b = true;
+            }    
+       
+            if (this->getCheckpoint(v.y) == check)
+            {
+                b = true;
+            }    
+            if (this->getCheckpoint(v.z) == check)
+            {
+                b = true;
+            }    
+        }
+        else
+        {
+            b = (this->getIndex(check) == 0);
+        }
+            
+        if (gametype && b)
+        {
+            gametype->clock_.capture();
+            float time = gametype->clock_.getSecondsPrecise();
+            if (check->getTimeLimit()!=0 && time > check->getTimeLimit())
+            {
+                gametype->timeIsUp();
+                gametype->end();
+            }
+            else if (check->getLast())
+                gametype->end();
+            else
+				{
+                if (index > -1)this->setRadVis(player,false);
+                	else this->getCheckpoint(0)->setRadarVisibility(false);
+                gametype->newCheckpointReached(check,player);
+               
+                
+                this->setRadVis(player, true);
+            }
+        }
+        check->reached_=NULL;
+    }
+    
+    void SpaceRaceManager::setRadVis(PlayerInfo* player, bool b)
+    {
+        SpaceRace* gametype = orxonox_cast<SpaceRace*>(this->getGametype().get());
+        assert(gametype);
+        int index = gametype->getCheckpointReached(player);
+        Vector3 v = Vector3(-1,-1,-1);
+        RaceCheckPoint* tmp = this->getCheckpoint(index);
+        v = tmp->getNextcheckpoint();
+    
+        if(v.x > -1)
+        {
+            this->getCheckpoint(v.x)->setRadarVisibility(b);
+            this->getCheckpoint(v.x)->settingsChanged();
+        }
+        if(v.y > -1)
+        {
+            this->getCheckpoint(v.y)->setRadarVisibility(b);
+            this->getCheckpoint(v.y)->settingsChanged();
+        }
+        if(v.z > -1)
+        {
+            this->getCheckpoint(v.z)->setRadarVisibility(b);
+           this->getCheckpoint(v.z)->settingsChanged();
+        }
+        
+        
+    }
+    
+}
Index: code/trunk/src/modules/gametypes/SpaceRaceManager.h
===================================================================
--- code/trunk/src/modules/gametypes/SpaceRaceManager.h	(revision 9016)
+++ code/trunk/src/modules/gametypes/SpaceRaceManager.h	(revision 9016)
@@ -0,0 +1,79 @@
+/*
+ *   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:
+ *      Mauro Salomon
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _SpaceRaceManager_H__
+#define _SpaceRaceManager_H__
+
+#include "gametypes/GametypesPrereqs.h"
+
+#include <set>
+#include <string>
+#include <vector>
+
+#include <util/Clock.h>
+
+#include "gametypes/Gametype.h"
+#include "tools/interfaces/Tickable.h"
+#include "RaceCheckPoint.h"
+
+
+
+namespace orxonox
+{
+  /**
+  @brief
+    The SpaceRaceManager class controls a space race level, where the player has to reach check points in a given order.
+  */
+    class _GametypesExport SpaceRaceManager : public BaseObject, public Tickable
+    {
+        friend class RaceCheckPoint;
+    
+        public:
+            SpaceRaceManager(BaseObject* creator);
+            virtual ~SpaceRaceManager() ;
+
+            void XMLPort(Element& xmlelement, XMLPort::Mode mode); 
+            int getIndex(RaceCheckPoint* r);
+            void addCheckpoint(RaceCheckPoint* checkpoint);
+            RaceCheckPoint* getCheckpoint(unsigned int index) const;
+        
+            void checkpointReached(RaceCheckPoint* check, PlayerInfo* player);
+        
+            void tick(float dt);
+    
+        protected:
+            void setRadVis(PlayerInfo* player, bool b);//sets RadarVisibility of the checkpoints the player can reach.
+    
+        private:
+            std::vector<RaceCheckPoint*> checkpoints_;
+            bool firstcheckpointvisible_;//true if the first check point is visible.
+        
+    };
+}
+
+#endif /* _SpaceRaceManager_H__ */
Index: code/trunk/src/modules/objects/triggers/DistanceMultiTrigger.h
===================================================================
--- code/trunk/src/modules/objects/triggers/DistanceMultiTrigger.h	(revision 8952)
+++ code/trunk/src/modules/objects/triggers/DistanceMultiTrigger.h	(revision 9016)
@@ -91,5 +91,5 @@
     @ingroup MultiTrigger
     */
-    class _ObjectsExport DistanceMultiTrigger : public MultiTrigger
+    class _ObjectsExport DistanceMultiTrigger : public MultiTrigger 
     {
 
Index: code/trunk/src/modules/objects/triggers/MultiTrigger.h
===================================================================
--- code/trunk/src/modules/objects/triggers/MultiTrigger.h	(revision 8952)
+++ code/trunk/src/modules/objects/triggers/MultiTrigger.h	(revision 9016)
@@ -157,5 +157,5 @@
             bool isTriggered(BaseObject* triggerer = NULL); //!< Get whether the MultiTrigger is triggered for a given object.
 
-            void fire(bool status, BaseObject* originator = NULL);  //!< Helper method. Creates an Event for the given status and originator and fires it.
+            virtual void fire(bool status, BaseObject* originator = NULL);  //!< Helper method. Creates an Event for the given status and originator and fires it.
             void broadcast(bool status); //!< Helper method. Broadcasts an Event for every object that is a target.
 
Index: code/trunk/src/modules/overlays/hud/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/overlays/hud/CMakeLists.txt	(revision 8952)
+++ code/trunk/src/modules/overlays/hud/CMakeLists.txt	(revision 9016)
@@ -7,4 +7,5 @@
   HUDHealthBar.cc
   HUDTimer.cc
+  HUDEnemyHealthBar.cc
   ChatOverlay.cc
   AnnounceMessage.cc
Index: code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.cc
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.cc	(revision 9016)
+++ code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.cc	(revision 9016)
@@ -0,0 +1,210 @@
+/*
+ *   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:
+ *      Matthias Spalinger
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "HUDEnemyHealthBar.h"
+
+#include <OgreCamera.h>
+
+#include "util/Convert.h"
+#include "core/ConfigValueIncludes.h"
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "infos/PlayerInfo.h"
+#include "overlays/OverlayGroup.h"
+#include "CameraManager.h"
+#include "graphics/Camera.h"
+#include "util/Math.h"
+#include "HUDNavigation.h"
+#include "core/input/InputManager.h"
+#include "controllers/HumanController.h"
+#include "core/GraphicsManager.h"
+#include "Scene.h"
+#include "Radar.h"
+#include "controllers/NewHumanController.h"
+
+namespace orxonox
+{
+    CreateFactory(HUDEnemyHealthBar);
+
+    HUDEnemyHealthBar::HUDEnemyHealthBar(BaseObject* creator) : HUDHealthBar(creator)
+    {
+        RegisterObject(HUDEnemyHealthBar);
+
+        this->setConfigValues();
+        setSensibility(0.1f);
+        this->owner_ = 0;
+        markerLimit_ = 3; //TODO connect with markerLimit_ from the settings / from HUDNavigation.cc
+        currentYaw = 0;
+        currentPitch = 0;
+
+        this->getOverlayText()->setCaption("");
+    }
+
+    HUDEnemyHealthBar::~HUDEnemyHealthBar()
+    {
+        sortedObjectList_.clear();
+    }
+
+    void HUDEnemyHealthBar::setConfigValues()
+    {
+        SetConfigValue(useEnemyBar_, true);
+    }
+
+    void HUDEnemyHealthBar::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(HUDEnemyHealthBar, XMLPort, xmlelement, mode);
+
+        XMLPortParam ( HUDEnemyHealthBar, "sensibility", setSensibility, getSensibility, xmlelement, mode );
+    }
+
+    bool compareDist ( std::pair<RadarViewable*, unsigned int > a, std::pair<RadarViewable*, unsigned int > b )
+    {
+        return a.second<b.second;
+    }
+
+    void HUDEnemyHealthBar::tick(float dt)
+    {
+        if (!useEnemyBar_){
+            this->setValue(0); //TODO hide it instead of setting it to 0
+            this->getOverlayText()->setCaption("");
+            return;
+        }
+
+        Camera* cam = CameraManager::getInstance().getActiveCamera();
+        if ( cam == NULL )
+            return;
+        const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
+
+        unsigned int markerCount_ = 0;
+
+        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 ( compareDist );
+
+        for ( sortedList::iterator listIt = sortedObjectList_.begin(); listIt != sortedObjectList_.end(); ++markerCount_, ++listIt )
+        {
+            if ( markerCount_ < markerLimit_ )
+            {        
+                // Transform to screen coordinates and reverse x-axis
+                Vector3 pos = (camTransform * listIt->first->getRVWorldPosition());
+                pos.x = -pos.x;                
+
+                // get mouse position
+                if(this->getOwner() && dynamic_cast<ControllableEntity*>(this->getOwner())->getController() && dynamic_cast<NewHumanController*>(dynamic_cast<ControllableEntity*>(this->getOwner())->getController()))
+                {
+                    currentYaw = dynamic_cast<NewHumanController*>(dynamic_cast<ControllableEntity*>(this->getOwner())->getController())->getCurrentYaw();
+                    currentPitch = dynamic_cast<NewHumanController*>(dynamic_cast<ControllableEntity*>(this->getOwner())->getController())->getCurrentPitch();
+                }
+                // Compare cursor position to object position
+                if ( fabs(pos.x - currentYaw) < sens_ && fabs(pos.y - currentPitch) < sens_ )
+                {
+                    this->owner_ = orxonox_cast<Pawn*>(listIt->first);
+                    break;
+                }
+            }
+            this->owner_ = 0;
+        }
+
+
+
+        if (this->owner_)
+        {
+            this->setValue(this->owner_->getHealth() / this->owner_->getInitialHealth());
+            this->getOverlayText()->setCaption(multi_cast<std::string>(static_cast<int>(this->owner_->getHealth())));
+        }
+        else
+        {
+            this->setValue(0);      //TODO hide it instead of setting it to zero
+            this->getOverlayText()->setCaption("");
+        }
+
+        if (this->getTextUseBarColour())
+            this->getOverlayText()->setColour(this->getCurrentBarColour());
+    }
+
+    void HUDEnemyHealthBar::addObject ( RadarViewable* object )
+    {
+        if( showObject(object)==false )
+            return;
+    
+        if ( sortedObjectList_.size() >= markerLimit_ )
+            if ( object == NULL )
+                return;
+    
+        sortedObjectList_.push_front ( std::make_pair ( object, ( unsigned int ) 0 ) );
+
+        //remove duplicates
+        sortedObjectList_.unique();
+    }
+
+    bool HUDEnemyHealthBar::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 HUDEnemyHealthBar::removeObject ( RadarViewable* viewable )
+    {
+        for ( sortedList::iterator listIt = sortedObjectList_.begin(); listIt != sortedObjectList_.end(); ++listIt )
+        {
+            if ( (listIt->first) == viewable )
+            {
+                sortedObjectList_.erase ( listIt );
+                break;
+            }
+    
+        }
+
+    }
+
+    void HUDEnemyHealthBar::objectChanged(RadarViewable* viewable)
+    {
+        // TODO: niceification neccessary - and while you're at it: the same function exists in HUDNavigation.cc ;)
+        removeObject(viewable);
+        addObject(viewable);
+    }
+
+    void HUDEnemyHealthBar::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 );
+        }
+    }
+
+}
Index: code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.h
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.h	(revision 9016)
+++ code/trunk/src/modules/overlays/hud/HUDEnemyHealthBar.h	(revision 9016)
@@ -0,0 +1,83 @@
+/*
+ *   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:
+ *      Matthias Spalinger
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _HUDEnemyHealthBar_H__
+#define _HUDEnemyHealthBar_H__
+
+#include "interfaces/RadarViewable.h"
+#include "worldentities/pawns/Pawn.h"
+
+#include "HUDHealthBar.h"
+#include "interfaces/RadarListener.h"
+
+namespace orxonox
+{
+    class _OverlaysExport HUDEnemyHealthBar : public HUDHealthBar, public RadarListener
+    {
+        public:
+            HUDEnemyHealthBar(BaseObject* creator);
+            virtual ~HUDEnemyHealthBar();
+            void setConfigValues();
+
+            bool compareDistance ( std::pair<RadarViewable*, unsigned int > a, std::pair<RadarViewable*, unsigned int > b );
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void tick(float dt);
+
+            //RadarListener interface
+            void addObject ( RadarViewable* object );
+            void removeObject ( RadarViewable* viewable );
+            void objectChanged(RadarViewable* viewable);
+            virtual void radarTick ( float dt ) {}
+            inline float getRadarSensitivity() const
+                { return 1.0f; }
+
+            void changedOwner();
+
+        private:
+
+            void setSensibility (float sense){
+                this->sens_ = sense;}
+            float getSensibility(){
+                return this->sens_;}
+
+            bool showObject(RadarViewable* rv);
+        
+            typedef std::list < std::pair<RadarViewable*, unsigned int > > sortedList;
+            sortedList sortedObjectList_;
+
+            Pawn* owner_;
+            float sens_;
+            bool useEnemyBar_;
+            unsigned int markerLimit_;
+
+            float currentYaw;
+            float currentPitch;
+    };
+}
+#endif /* _HUDEnemyHealthBar_H__ */
Index: code/trunk/src/modules/overlays/hud/HUDHealthBar.h
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDHealthBar.h	(revision 8952)
+++ code/trunk/src/modules/overlays/hud/HUDHealthBar.h	(revision 9016)
@@ -110,4 +110,9 @@
                 { return this->textoverlay_->getSpaceWidth(); }
 
+            inline void setOverlayText(SmartPtr<OverlayText> textoverlay)
+                { this->textoverlay_ = textoverlay; }
+            inline SmartPtr<OverlayText> getOverlayText() const
+                {return this->textoverlay_; }
+
         private:
             WeakPtr<Pawn> owner_;
Index: code/trunk/src/modules/overlays/hud/HUDNavigation.cc
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDNavigation.cc	(revision 8952)
+++ code/trunk/src/modules/overlays/hud/HUDNavigation.cc	(revision 9016)
@@ -25,4 +25,5 @@
  *      Reto Grieder
  *      Oliver Scheuss
+ *      Matthias Spalinger
  *
  */
@@ -63,5 +64,5 @@
 {
   SetConfigValue(markerLimit_, 3);
-
+  SetConfigValue(showDistance, false);
 }
 
@@ -75,8 +76,8 @@
 
     // Set default values
-    setFont ( "Monofur" );
-    setTextSize ( 0.05f );
-    setNavMarkerSize ( 0.05f );
-    setDetectionLimit( 10000.0f );
+    this->setFont ( "Monofur" );
+    this->setTextSize ( 0.05f );
+    this->setNavMarkerSize ( 0.05f );
+    this->setDetectionLimit( 10000.0f ); 
 }
 
@@ -97,8 +98,8 @@
     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 );
+    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 ); 
 }
 
@@ -144,5 +145,17 @@
 }
 
-
+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 )
@@ -165,4 +178,5 @@
     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 )
@@ -170,5 +184,6 @@
         ObjectMap::iterator it = activeObjectList_.find ( listIt->first );
         closeEnough_ = listIt->second < detectionLimit_ ;
-        if ( markerCount_ < markerLimit_ && (closeEnough_ ||  detectionLimit_ < 0) ) // display on HUD if the statement is true
+        // display radarviewables on HUD if the marker limit and max-distance is not exceeded 
+        if ( markerCount_ < markerLimit_ && (closeEnough_ ||  detectionLimit_ < 0) ) 
         {
 
@@ -176,6 +191,17 @@
             // 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 ) );
-            float textLength = multi_cast<std::string> ( dist ).size() * it->second.text_->getCharHeight() * 0.3f;
+            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->getRVName()); 
+            textLength = it->first->getRVName().size() * it->second.text_->getCharHeight() * 0.3f;
+            }
 
             // Transform to screen coordinates
@@ -194,6 +220,4 @@
             else
                 outOfView = pos.x < -1.0 || pos.x > 1.0 || pos.y < -1.0 || pos.y > 1.0;
-            // Get Distance to HumanController and save it in the TextAreaOverlayElement.
-            it->second.text_->setCaption ( multi_cast<std::string> ( dist ) );
 
             if ( outOfView )
@@ -207,4 +231,10 @@
                     it->second.wasOutOfView_ = true;
                 }
+
+                //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
@@ -263,4 +293,5 @@
                   //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;
                 }
@@ -280,5 +311,5 @@
             it->second.text_->show();
         }
-        else // do not display on HUD
+        else // do not display on HUD 
         {
             it->second.panel_->hide();
@@ -312,5 +343,5 @@
 void HUDNavigation::addObject ( RadarViewable* object )
 {
-    if( showObject(object) == false )
+    if( showObject(object)==false )
         return;
 
@@ -399,5 +430,5 @@
         return false;
     assert( rv->getWorldEntity() );
-    if ( rv->getWorldEntity()->isVisible() == false || rv->getRadarVisibility() == false )
+    if ( rv->getWorldEntity()->isVisible()==false || rv->getRadarVisibility()==false )
         return false;
     return true;
Index: code/trunk/src/modules/overlays/hud/HUDNavigation.h
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDNavigation.h	(revision 8952)
+++ code/trunk/src/modules/overlays/hud/HUDNavigation.h	(revision 9016)
@@ -24,4 +24,5 @@
  *   Co-authors:
  *      Reto Grieder
+ *      Matthias Spalinger
  *
  */
@@ -54,4 +55,5 @@
     virtual void tick ( float dt );
 
+    // RadarListener interface
     virtual void addObject ( RadarViewable* object );
     virtual void removeObject ( RadarViewable* viewable );
@@ -66,4 +68,6 @@
     inline float getRadarSensitivity() const
     { return 1.0f; }
+
+    unsigned int getMarkerLimit() { return this->markerLimit_; }
 
 private:
@@ -81,12 +85,11 @@
     // XMLPort accessors
     void setNavMarkerSize ( float size )
-    { navMarkerSize_ = size; this->sizeChanged(); }
+        { navMarkerSize_ = size; this->sizeChanged(); }
     float getNavMarkerSize() const
-    { return navMarkerSize_; }
-
-    void setDetectionLimit( float limit )
-    { this->detectionLimit_ = limit; }
-    float getDetectionLimit() const
-    { return this->detectionLimit_; }
+        { return navMarkerSize_; }
+    void setDetectionLimit( float limit ) 
+        { this->detectionLimit_ = limit; } 
+    float getDetectionLimit() const 
+        { return this->detectionLimit_; }
 
     void setTextSize ( float size );
@@ -102,12 +105,15 @@
     sortedList sortedObjectList_;
 
+    float getArrowSizeX(int dist);    
+    float getArrowSizeY(int dist);
 
     float navMarkerSize_;
     std::string fontName_;
     float textSize_;
+    bool showDistance;
 
-    unsigned int markerLimit_; //TODO: is it possible to set this over the console and/or the IG-Setting
-    float detectionLimit_; //!< Objects that are more far away than detectionLimit_ are not displayed on the HUD. 10000.0f is the default value.
-                           //!< In order to bypass this behaviour, set a negative detectionLimit_. Then the detection range is "infinite".
+    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. 
+
 };
 }
Index: code/trunk/src/modules/pong/Pong.cc
===================================================================
--- code/trunk/src/modules/pong/Pong.cc	(revision 8952)
+++ code/trunk/src/modules/pong/Pong.cc	(revision 9016)
@@ -37,6 +37,8 @@
 #include "core/EventIncludes.h"
 #include "core/command/Executor.h"
+#include "core/ConfigValueIncludes.h"
 
 #include "gamestates/GSLevel.h"
+#include "chat/ChatManager.h"
 
 #include "PongCenterpoint.h"
@@ -45,5 +47,4 @@
 #include "PongBot.h"
 #include "PongAI.h"
-
 namespace orxonox
 {
@@ -75,4 +76,6 @@
         // Set the type of Bots for this particular Gametype.
         this->botclass_ = Class(PongBot);
+	this->scoreLimit_ = 10;
+	this->setConfigValues();
     }
 
@@ -280,6 +283,26 @@
         }
 
+        // If a palyer gets 21 points, he won the game -> end of game
+        
+        PlayerInfo* player1 = this->getLeftPlayer();
+        PlayerInfo* player2 = this->getRightPlayer();
+        if(player1==NULL||player2==NULL) return; //safety
+        if(this->getScore(player1) >= scoreLimit_)
+        {
+            std::string name1=player1->getName();
+            std::string message(name1 + " has won!");
+            ChatManager::message(message);
+            this->end();
+        }
+        else if(this->getScore(player2) >= scoreLimit_)
+        {
+             std::string name2=player2->getName();
+             std::string message2(name2 + " has won!");
+             ChatManager::message(message2);
+             this->end();
+        }
         // Restart the timer to start the ball.
         this->starttimer_.startTimer();
+
     }
 
@@ -321,3 +344,12 @@
             return 0;
     }
+
+    /**
+     @brief
+         Make scoreLimit_ configurable e.g. in the menu.
+     */
+    void Pong::setConfigValues()
+    {
+        SetConfigValue(scoreLimit_, 10).description("The player first reaching those points wins.");
+    }
 }
Index: code/trunk/src/modules/pong/Pong.h
===================================================================
--- code/trunk/src/modules/pong/Pong.h	(revision 8952)
+++ code/trunk/src/modules/pong/Pong.h	(revision 9016)
@@ -81,6 +81,7 @@
             void setCenterpoint(PongCenterpoint* center)
                 { this->center_ = center; }
-
-            PlayerInfo* getLeftPlayer() const; //!< Get the left player.
+            void setConfigValues(); //!< Makes scoreLimit configurable.
+            
+	    PlayerInfo* getLeftPlayer() const; //!< Get the left player.
             PlayerInfo* getRightPlayer() const; //!< Get the right player.
 
@@ -94,5 +95,6 @@
             WeakPtr<PongBall> ball_; //!< The Pong ball.
             WeakPtr<PongBat> bat_[2]; //!< The two bats.
-            Timer starttimer_; //!< A timer to delay the start of the game.
+	    Timer starttimer_; //!< A timer to delay the start of the game.
+            int scoreLimit_; //!< If a player scored that much points, the game is ended.
     };
 }
Index: code/trunk/src/modules/pong/PongAI.h
===================================================================
--- code/trunk/src/modules/pong/PongAI.h	(revision 8952)
+++ code/trunk/src/modules/pong/PongAI.h	(revision 9016)
@@ -80,5 +80,5 @@
             void delayedMove(); //!< Is called, when a delayed move takes effect.
 
-            PongBall* ball_; //!< A pointer to the ball.
+            WeakPtr<PongBall> ball_; //!< A weak pointer to the ball.
             Vector2 ballDirection_; //!< Vector to store the (x,z) direction in which the ball is flying.
             float ballEndPosition_; //!< The calculated end position of the ball.
Index: code/trunk/src/modules/pong/PongScore.cc
===================================================================
--- code/trunk/src/modules/pong/PongScore.cc	(revision 8952)
+++ code/trunk/src/modules/pong/PongScore.cc	(revision 9016)
@@ -60,4 +60,6 @@
         this->bShowLeftPlayer_ = false;
         this->bShowRightPlayer_ = false;
+        this->player1_ = NULL;
+	this->player2_ = NULL;
     }
 
@@ -98,42 +100,49 @@
         if (this->owner_ != NULL)
         {
-            // Get the two players.
-            PlayerInfo* player1 = this->owner_->getLeftPlayer();
-            PlayerInfo* player2 = this->owner_->getRightPlayer();
-
-            std::string name1;
-            std::string name2;
-
-            std::string score1("0");
-            std::string score2("0");
-
-            // Save the name and score of each player as a string.
-            if (player1 != NULL)
+	    if(!this->owner_->hasEnded())
             {
-                name1 = player1->getName();
-                score1 = multi_cast<std::string>(this->owner_->getScore(player1));
-            }
-            if (player2 != NULL)
-            {
-                name2 = player2->getName();
-                score2 = multi_cast<std::string>(this->owner_->getScore(player2));
+                //get the two players
+                player1_ = this->owner_->getLeftPlayer();
+                player2_ = this->owner_->getRightPlayer();
             }
 
-            // Assemble the strings, depending on what should all be displayed.
-            std::string output1;
-            if (this->bShowLeftPlayer_)
+            if(this->owner_->hasStarted())
             {
-                if (this->bShowName_ && this->bShowScore_ && player1 != NULL)
-                    output1 = name1 + " - " + score1;
-                else if (this->bShowScore_)
-                    output1 = score1;
-                else if (this->bShowName_)
-                    output1 = name1;
-            }
+                // Get the two players.
 
-            std::string output2;
-            if (this->bShowRightPlayer_)
-            {
-                if (this->bShowName_ && this->bShowScore_ && player2 != NULL)
+                std::string name1;
+                std::string name2;
+
+                std::string score1("0");
+                std::string score2("0");
+
+                // Save the name and score of each player as a string.
+                if (player1_ != NULL)
+                {
+                    name1 = player1_->getName();
+                    score1 = multi_cast<std::string>(this->owner_->getScore(player1_));
+                }
+                if (player2_ != NULL)
+                {
+                    name2 = player2_->getName();
+                    score2 = multi_cast<std::string>(this->owner_->getScore(player2_));
+                }
+
+                // Assemble the strings, depending on what should all be displayed.
+                std::string output1;
+                if (this->bShowLeftPlayer_)
+                {
+                    if (this->bShowName_ && this->bShowScore_ && player1_ != NULL)
+                         output1 = name1 + " - " + score1;
+                    else if (this->bShowScore_)
+                         output1 = score1;
+                    else if (this->bShowName_)
+                         output1 = name1;
+                }
+
+                std::string output2;
+                if (this->bShowRightPlayer_)
+                {
+                if (this->bShowName_ && this->bShowScore_ && player2_ != NULL)
                     output2 = score2 + " - " + name2;
                 else if (this->bShowScore_)
@@ -143,14 +152,14 @@
             }
 
-            std::string output("PONG");
-            if (this->bShowName_ || this->bShowScore_)
-            {
-                if (this->bShowLeftPlayer_ && this->bShowRightPlayer_)
-                    output = output1 + ':' + output2;
-                else if (this->bShowLeftPlayer_ || this->bShowRightPlayer_)
-                    output = output1 + output2;
+                std::string output("PONG");
+                if (this->bShowName_ || this->bShowScore_)
+                {
+                    if (this->bShowLeftPlayer_ && this->bShowRightPlayer_)
+                        output = output1 + ':' + output2;
+                    else if (this->bShowLeftPlayer_ || this->bShowRightPlayer_)
+                        output = output1 + output2;
+                }
+                this->setCaption(output);
             }
-
-            this->setCaption(output);
         }
     }
Index: code/trunk/src/modules/pong/PongScore.h
===================================================================
--- code/trunk/src/modules/pong/PongScore.h	(revision 8952)
+++ code/trunk/src/modules/pong/PongScore.h	(revision 9016)
@@ -122,4 +122,6 @@
             bool bShowLeftPlayer_; //!< Whether the left player is shown.
             bool bShowRightPlayer_; //!< Whether the right player is shown.
+            PlayerInfo* player1_; //!< Store information about left player permanently.
+            PlayerInfo* player2_; //!< Same for the right player. To end the game properly.
     };
 }
Index: code/trunk/src/modules/weapons/projectiles/Rocket.cc
===================================================================
--- code/trunk/src/modules/weapons/projectiles/Rocket.cc	(revision 8952)
+++ code/trunk/src/modules/weapons/projectiles/Rocket.cc	(revision 9016)
@@ -66,5 +66,4 @@
         this->localAngularVelocity_ = 0;
         this->lifetime_ = 100.0f;
-        this->bIsRocket_= true;
 
         if (GameMode::isMaster())
@@ -135,5 +134,4 @@
         if(this->isInitialized())
         {
-            this->bIsRocket_= false;
             if (GameMode::isMaster())
             {
@@ -163,5 +161,6 @@
         
         this->player_ = this->getShooter()->getPlayer();
-        this->getShooter()->getPlayer()->startTemporaryControl(this);
+        if(this->player_)
+            this->player_->startTemporaryControl(this);
 
         if( GameMode::isMaster() )
Index: code/trunk/src/modules/weapons/projectiles/Rocket.h
===================================================================
--- code/trunk/src/modules/weapons/projectiles/Rocket.h	(revision 8952)
+++ code/trunk/src/modules/weapons/projectiles/Rocket.h	(revision 9016)
@@ -122,4 +122,5 @@
 
             WeakPtr<PlayerInfo> player_; //!< The player that controls the Rocket.
+            //WeakPtr<Pawn> pawn_; //!< The pawn that controls the Rocket. TODO
             Timer destroyTimer_; //!< Timer to destroy the projectile after its lifetime has run out.
             float lifetime_; //!< The time the projectile exists.
Index: code/trunk/src/modules/weapons/weaponmodes/LightningGun.cc
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/LightningGun.cc	(revision 8952)
+++ code/trunk/src/modules/weapons/weaponmodes/LightningGun.cc	(revision 9016)
@@ -52,5 +52,5 @@
         this->reloadTime_ = 1.0f;
         this->damage_ = 0.0f;
-        this->speed_ = 250.0f;
+        this->speed_ = 700.0f;
 
         this->setMunitionName("LaserMunition");
