Index: code/branches/hud/src/core/Iterator.h
===================================================================
--- code/branches/hud/src/core/Iterator.h	(revision 1612)
+++ code/branches/hud/src/core/Iterator.h	(revision 1613)
@@ -92,4 +92,5 @@
             {
                 this->element_ = element;
+                return *this;
             }
 
Index: code/branches/hud/src/orxonox/CMakeLists.txt
===================================================================
--- code/branches/hud/src/orxonox/CMakeLists.txt	(revision 1612)
+++ code/branches/hud/src/orxonox/CMakeLists.txt	(revision 1613)
@@ -4,4 +4,5 @@
   Orxonox.cc
   Radar.cc
+  RadarViewable.cc
   Settings.cc
 
@@ -18,6 +19,5 @@
   overlays/hud/HUDSpeedBar.cc
   overlays/hud/HUDText.cc
-  overlays/hud/RadarObject.cc
-  overlays/hud/RadarViewable.cc
+  overlays/hud/HUDRadar.cc
 
   tolua/tolua_bind.cc
Index: code/branches/hud/src/orxonox/Orxonox.cc
===================================================================
--- code/branches/hud/src/orxonox/Orxonox.cc	(revision 1612)
+++ code/branches/hud/src/orxonox/Orxonox.cc	(revision 1613)
@@ -76,4 +76,5 @@
 #include "GraphicsEngine.h"
 #include "Settings.h"
+#include "Radar.h"
 
 // globals for the server or client
@@ -99,4 +100,5 @@
     , startLevel_(0)
     , hud_(0)
+    , radar_(0)
     //, auMan_(0)
     , timer_(0)
@@ -126,4 +128,7 @@
       delete this->hud_;
 
+    if (this->radar_)
+      delete this->radar_;
+
     Loader::close();
     //if (this->auMan_)
@@ -342,7 +347,9 @@
     // Load the HUD
     COUT(3) << "Orxonox: Loading HUD" << std::endl;
-
     hud_ = new Level(Settings::getDataPath() + "overlay/hud.oxo");
     Loader::load(hud_);
+
+    // Start the Radar
+    this->radar_ = new Radar();
 
     return true;
Index: code/branches/hud/src/orxonox/Orxonox.h
===================================================================
--- code/branches/hud/src/orxonox/Orxonox.h	(revision 1612)
+++ code/branches/hud/src/orxonox/Orxonox.h	(revision 1613)
@@ -95,4 +95,5 @@
       Level*                startLevel_;    //!< current hard coded default level
       Level*                hud_;           //!< 'level' object fo the HUD
+      Radar*                radar_;         //!< represents the Radar (not the HUD part)
       //audio::AudioManager*  auMan_;         //!< audio manager
       Ogre::Timer*          timer_;         //!< Main loop timer
Index: code/branches/hud/src/orxonox/Radar.cc
===================================================================
--- code/branches/hud/src/orxonox/Radar.cc	(revision 1612)
+++ code/branches/hud/src/orxonox/Radar.cc	(revision 1613)
@@ -34,7 +34,7 @@
 #include "OrxonoxStableHeaders.h"
 #include "Radar.h"
+#include <float.h>
 #include "objects/WorldEntity.h"
-#include "overlays/hud/RadarViewable.h"
-
+#include "objects/SpaceShip.h"
 #include "core/CoreIncludes.h"
 //#include "core/ConfigValueIncludes.h"
@@ -47,11 +47,36 @@
     }
 
+    SetConsoleCommand(Radar, cycleNavigationFocus, true).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(Radar, releaseNavigationFocus, true).setAccessLevel(AccessLevel::User);
 
     Radar* Radar::instance_s = 0;
 
     Radar::Radar()
+        : focus_(0)
+        , objectTypeCounter_(0)
     {
         assert(instance_s == 0);
         instance_s = this;
+
+        // TODO: make this mapping configurable. Maybe there's a possibility with self configured
+        //       configValues..
+        this->objectTypes_["Asteroid"] = RadarViewable::Dot;
+        this->objectTypes_["SpaceShip"] = RadarViewable::Square;
+        this->objectTypes_["AsdfQwerty"] = RadarViewable::Triangle;
+
+        /*WorldEntity* object;
+        object = new WorldEntity();
+        object->setPosition(2000.0, 0.0, 0.0);
+        addRadarObject(object, ColourValue(0.5, 0, 0, 1));
+        object = new WorldEntity();
+        object->setPosition(0.0, 2000.0, 0.0);
+        addRadarObject(object, ColourValue(0.5, 0, 0, 1));
+        object = new WorldEntity();
+        object->setPosition(0.0, 0.0, 2000.0);
+        addRadarObject(object, ColourValue(0.5, 0, 0, 1));
+        object = new WorldEntity();
+        object->setPosition(10000.0,16000.0,0.0);
+        addRadarObject(object);*/
+
     }
 
@@ -61,5 +86,110 @@
     }
 
-    Radar& Radar::getInstance()
+    /*void Radar::unregisterObject(RadarViewable* object)
+    {
+        if (this->focus_ == object)
+            this->focus_ = 0;
+        // TODO: check for focus
+    }*/
+
+    const RadarViewable* Radar::getFocus()
+    {
+        return *(this->itFocus_);
+    }
+
+    RadarViewable::Shape Radar::addObjectDescription(const std::string name)
+    {
+        std::map<std::string, RadarViewable::Shape>::iterator it = this->objectTypes_.find(name);
+        if (it == this->objectTypes_.end())
+            return this->objectTypes_[name] = RadarViewable::Square; // default, configure!!
+        else
+            return this->objectTypes_[name];
+    }
+
+
+    void Radar::tick(float dt)
+    {
+        if (this->focus_ != *(this->itFocus_))
+        {
+            // focus object was deleted, release focus
+            this->focus_ = 0;
+            this->itFocus_ = 0;
+        }
+
+        for (Iterator<RadarListener> itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        {
+            for (Iterator<RadarViewable> itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
+            {
+                if ((*itElement) != SpaceShip::getLocalShip() && (*itListener)->getRadarSensitivity() > (*itElement)->getRadarObjectCamouflage())
+                    (*itListener)->displayObject(*itElement, *itElement == this->focus_);
+            }
+
+            (*itListener)->radarTick(dt);
+
+            if (this->focus_ == 0)
+                (*itListener)->hideMarker();
+        }
+    }
+
+    void Radar::cycleFocus()
+    {
+        if (*(ObjectList<RadarViewable>::begin()) == 0)
+        {
+            // list is empty
+            this->itFocus_ = 0;
+            this->focus_ = 0;
+        }
+        else
+        {
+            Vector3 localPosition = SpaceShip::getLocalShip()->getPosition();
+            Vector3 targetPosition = localPosition;
+            if (*(this->itFocus_))
+                targetPosition = this->itFocus_->getWorldPosition();
+
+            // find the closed object further away than targetPosition
+            float currentDistance = localPosition.squaredDistance(targetPosition);
+            float nextDistance = FLT_MAX;
+            float minimumDistance = FLT_MAX;
+            Iterator<RadarViewable> itFallback = 0;
+
+            for (Iterator<RadarViewable> it = ObjectList<RadarViewable>::begin(); it; ++it)
+            {
+                if (*it == SpaceShip::getLocalShip())
+                    continue;
+
+                float targetDistance = localPosition.squaredDistance((*it)->getWorldPosition());
+                if (targetDistance > currentDistance && targetDistance < nextDistance)
+                {
+                    this->itFocus_ = it;
+                    nextDistance = targetDistance;
+                }
+                if (targetDistance < minimumDistance)
+                {
+                    itFallback = it;
+                    minimumDistance = targetDistance;
+                }
+            }
+
+            if (nextDistance == FLT_MAX)
+            {
+                // we already had the furthest object
+                this->itFocus_ = itFallback;
+                this->focus_ = *itFallback;
+            }
+            else
+            {
+                this->focus_ = *(this->itFocus_);
+            }
+        }
+    }
+
+    void Radar::releaseFocus()
+    {
+        this->itFocus_ = 0;
+        this->focus_ = 0;
+    }
+
+
+    /*static*/ Radar& Radar::getInstance()
     {
         assert(instance_s);
@@ -67,19 +197,18 @@
     }
 
-    void Radar::unregisterObject(RadarViewable* object)
-    {
-        // TODO: check for focus
-    }
-
-    void Radar::tick(float dt)
-    {
-        for (Iterator<RadarListener> itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
-        {
-            for (Iterator<RadarViewable> itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
-            {
-                if ((*itListener)->getRadarSensitivity() > (*itElement)->getRadarObjectVisibility())
-                    (*itListener)->displayObject(*itElement);
-            }
-        }
+    /*static*/ void Radar::cycleNavigationFocus()
+    {
+        // avoid using getInstance because of the assert().
+        // User might call this fuction even if HUDNavigation doesn't exist.
+        if (instance_s)
+            instance_s->cycleFocus();
+    }
+
+    /*static*/ void Radar::releaseNavigationFocus()
+    {
+        // avoid using getInstance because of the assert().
+        // User might call this fuction even if HUDNavigation doesn't exist.
+        if (instance_s)
+            instance_s->releaseFocus();
     }
 }
Index: code/branches/hud/src/orxonox/Radar.h
===================================================================
--- code/branches/hud/src/orxonox/Radar.h	(revision 1612)
+++ code/branches/hud/src/orxonox/Radar.h	(revision 1613)
@@ -38,10 +38,12 @@
 
 #include <string>
+#include "core/Iterator.h"
 #include "core/OrxonoxClass.h"
 #include "objects/Tickable.h"
+#include "RadarViewable.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport RadarListener : public OrxonoxClass
+    class _OrxonoxExport RadarListener : virtual public OrxonoxClass
     {
     public:
@@ -49,6 +51,8 @@
         virtual ~RadarListener() { }
 
-        virtual void displayObject(RadarViewable* viewable) = 0;
+        virtual void displayObject(RadarViewable* viewable, bool bIsMarked) = 0;
+        virtual void hideMarker() = 0;
         virtual float getRadarSensitivity() = 0;
+        virtual void radarTick(float dt) = 0;
     };
 
@@ -69,13 +73,26 @@
         ~Radar();
 
-        void unregisterObject(RadarViewable* object);
-
-        void tick(float dt);
+        //void unregisterObject(RadarViewable* object);
+        const RadarViewable* getFocus();
+        RadarViewable::Shape addObjectDescription(const std::string name);
 
         static Radar& getInstance();
         static Radar* getInstancePtr() { return instance_s; }
 
+        static void cycleNavigationFocus();
+        static void releaseNavigationFocus();
+
     private:
         Radar(Radar& instance);
+        void tick(float dt);
+
+        void releaseFocus();
+        void updateFocus();
+        void cycleFocus();
+
+        Iterator<RadarViewable> itFocus_;
+        RadarViewable* focus_;
+        std::map<std::string, RadarViewable::Shape> objectTypes_;
+        int objectTypeCounter_; 
 
         static Radar* instance_s;
Index: code/branches/hud/src/orxonox/RadarViewable.cc
===================================================================
--- code/branches/hud/src/orxonox/RadarViewable.cc	(revision 1613)
+++ code/branches/hud/src/orxonox/RadarViewable.cc	(revision 1613)
@@ -0,0 +1,70 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+#include "RadarViewable.h"
+#include "core/Debug.h"
+#include "Radar.h"
+
+namespace orxonox
+{
+    /**
+        @brief Constructor.
+    */
+    RadarViewable::RadarViewable()
+        : radarObjectCamouflage_(0.0f)
+        , radarObjectType_(Dot)
+        , radarObject_(0)
+        , radarObjectDescription_("staticObject")
+    {
+        RegisterRootObject(RadarViewable);
+    }
+
+    void RadarViewable::setRadarObjectDescription(const std::string& str)
+    {
+        Radar* radar = Radar::getInstancePtr();
+        if (radar)
+            this->radarObjectType_ = radar->addObjectDescription(str);
+        else
+        {
+            CCOUT(2) << "Attempting to access the radar, but the radar is non existent." << std::endl;
+        }
+        this->radarObjectDescription_ = str;
+    }
+
+    /*void RadarViewable::unregisterFromRadar()
+    {
+        Radar* radar = Radar::getInstancePtr();
+        if (radar)
+            radar->unregisterObject(this);
+        else
+        {
+            CCOUT(2) << "Attempting to unregister an object to the radar, but the radar is non existent." << std::endl;
+        }
+    }*/
+}
Index: code/branches/hud/src/orxonox/RadarViewable.h
===================================================================
--- code/branches/hud/src/orxonox/RadarViewable.h	(revision 1613)
+++ code/branches/hud/src/orxonox/RadarViewable.h	(revision 1613)
@@ -0,0 +1,87 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _RadarViewable_H__
+#define _RadarViewable_H__
+
+#include "OrxonoxPrereqs.h"
+#include <string>
+#include "core/OrxonoxClass.h"
+#include "util/Math.h"
+
+namespace orxonox
+{
+    /**
+    @brief Interface for receiving window events.
+    */
+    class _OrxonoxExport RadarViewable : virtual public OrxonoxClass
+    {
+    public:
+        enum Shape
+        {
+            Square,
+            Dot,
+            Triangle
+        };
+
+    public:
+        RadarViewable();
+        virtual ~RadarViewable() { }//unregisterFromRadar(); }
+
+        float getRadarObjectCamouflage() const { return this->radarObjectCamouflage_; }
+        void setRadarObjectCamouflage(float camouflage) { this->radarObjectCamouflage_ = camouflage; }
+
+        const ColourValue& getRadarObjectColour() const { return this->radarObjectColour_; }
+        void setRadarObjectColour(const ColourValue& colour) { this->radarObjectColour_ = colour; }
+
+        const std::string& getRadarObjectDescription() const { return this->radarObjectDescription_; }
+        void setRadarObjectDescription(const std::string& str);
+
+        const WorldEntity* getWorldEntity() const { return this->radarObject_; }
+        const Vector3& getWorldPosition() const { validate(); return this->radarObject_->getWorldPosition(); }
+        Vector3 getOrientedVelocity() const
+            { validate(); return this->radarObject_->getOrientation() * this->radarObject_->getVelocity(); }
+
+        Shape getRadarObjectType() const { return this->radarObjectType_; }
+
+    protected:
+        WorldEntity* radarObject_;
+        //void unregisterFromRadar();
+
+    private:
+        void validate() const { if (!this->radarObject_)
+        { COUT(1) << "Assertation: Every RadarViewable has to be assigned a WorldEntity pointer!" << std::endl; assert(0); } }
+
+        float radarObjectCamouflage_;
+        Shape radarObjectType_;
+        std::string radarObjectDescription_;
+        ColourValue radarObjectColour_;
+    };
+}
+
+#endif /* _RadarViewable_H__ */
Index: code/branches/hud/src/orxonox/objects/SpaceShip.cc
===================================================================
--- code/branches/hud/src/orxonox/objects/SpaceShip.cc	(revision 1612)
+++ code/branches/hud/src/orxonox/objects/SpaceShip.cc	(revision 1613)
@@ -42,5 +42,5 @@
 #include "core/Debug.h"
 #include "GraphicsEngine.h"
-#include "core/input/InputManager.h"
+//#include "core/input/InputManager.h"
 #include "tools/ParticleInterface.h"
 #include "RotatingProjectile.h"
@@ -49,5 +49,4 @@
 #include "core/ConsoleCommand.h"
 #include "network/Client.h"
-#include "overlays/hud/HUDRadar.h"
 
 namespace orxonox
@@ -133,4 +132,6 @@
         this->health_ = 100;
 
+        this->radarObject_ = static_cast<WorldEntity*>(this);
+
         COUT(3) << "Info: SpaceShip was loaded" << std::endl;
     }
@@ -144,13 +145,6 @@
             if (this->tt2_)
                 delete this->tt2_;
-
-            if (setMouseEventCallback_)
-                InputManager::removeMouseHandler("SpaceShip");
-
             if (this->cam_)
                 delete this->cam_;
-
-            if (!this->myShip_)
-                HUDRadar::getInstance().removeRadarObject(this);
         }
     }
@@ -161,5 +155,5 @@
           myShip_=true;
         else
-          HUDRadar::getInstance().addRadarObject(this, this->getProjectileColour());
+          this->setRadarObjectColour(this->getProjectileColour());
       }
       if(Model::create())
Index: code/branches/hud/src/orxonox/objects/SpaceShip.h
===================================================================
--- code/branches/hud/src/orxonox/objects/SpaceShip.h	(revision 1612)
+++ code/branches/hud/src/orxonox/objects/SpaceShip.h	(revision 1613)
@@ -36,9 +36,10 @@
 #include "Camera.h"
 #include "Model.h"
+#include "RadarViewable.h"
 #include "tools/BillboardSet.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport SpaceShip : public Model
+    class _OrxonoxExport SpaceShip : public Model, public RadarViewable
     {
         public:
Index: code/branches/hud/src/orxonox/overlays/hud/HUDNavigation.cc
===================================================================
--- code/branches/hud/src/orxonox/overlays/hud/HUDNavigation.cc	(revision 1612)
+++ code/branches/hud/src/orxonox/overlays/hud/HUDNavigation.cc	(revision 1613)
@@ -42,6 +42,5 @@
 #include "objects/CameraHandler.h"
 #include "overlays/OverlayGroup.h"
-#include "RadarObject.h"
-#include "HUDRadar.h"
+#include "Radar.h"
 
 namespace orxonox
@@ -49,8 +48,5 @@
     CreateFactory(HUDNavigation);
 
-    SetConsoleCommand(HUDNavigation, cycleNavigationFocus, true).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(HUDNavigation, releaseNavigationFocus, true).setAccessLevel(AccessLevel::User);
-
-    HUDNavigation* HUDNavigation::instance_s = 0;
+    //HUDNavigation* HUDNavigation::instance_s = 0;
 
     using namespace Ogre;
@@ -61,10 +57,9 @@
       , aimMarker_(0)
       , navText_(0)
-      , focus_(0)
     {
         RegisterObject(HUDNavigation);
         
-        assert(instance_s == 0); // singleton class
-        HUDNavigation::instance_s = this;
+        /*assert(instance_s == 0); // singleton class
+        HUDNavigation::instance_s = this;*/
     }
 
@@ -83,5 +78,5 @@
         }
 
-        HUDNavigation::instance_s = 0;
+        //HUDNavigation::instance_s = 0;
     }
 
@@ -117,5 +112,4 @@
 
             overlay_->add2D(container_);
-            overlay_->hide();
         }
 
@@ -181,9 +175,16 @@
     void HUDNavigation::tick(float dt)
     {
-        if (!focus_)
+        if (!Radar::getInstance().getFocus())
+        {
+            this->overlay_->hide();
             return;
+        }
+        else
+        {
+            this->overlay_->show();
+        }
 
         // set text
-        int dist = (int) getDist2Focus()/100.0f;
+        int dist = (int) getDist2Focus();
         navText_->setCaption(convertToString(dist));
         float textLength = convertToString(dist).size() * navText_->getCharHeight() * 0.3;
@@ -192,5 +193,5 @@
         Matrix4 transformationMatrix = navCam->getProjectionMatrix() * navCam->getViewMatrix();
         // transform to screen coordinates
-        Vector3 pos = transformationMatrix * focus_->getPosition();
+        Vector3 pos = transformationMatrix * Radar::getInstance().getFocus()->getWorldPosition();
 
         bool outOfView;
@@ -266,5 +267,5 @@
 
             Vector3 aimpos = transformationMatrix * getPredictedPosition(SpaceShip::getLocalShip()->getPosition(),
-                    Projectile::getSpeed(), focus_->getPosition(), focus_->getOrientedVelocity());
+                    Projectile::getSpeed(), Radar::getInstance().getFocus()->getWorldPosition(), Radar::getInstance().getFocus()->getOrientedVelocity());
 
             if (wasOutOfView_)
@@ -288,72 +289,8 @@
     }
 
-    void HUDNavigation::cycleFocus()
-    {
-        if (!focus_)
-        {
-            // Get closest object
-            float distance = (unsigned int) -1;
-            Vector3 shipPos = SpaceShip::getLocalShip()->getPosition();
-            it_ = HUDRadar::getInstance().getRadarObjects().begin();
-
-            for (std::list<RadarObject*>::iterator it = HUDRadar::getInstance().getRadarObjects().begin(); it != HUDRadar::getInstance().getRadarObjects().end(); ++it)
-            {
-                float newdist = (*it)->getPosition().squaredDistance(shipPos);
-                if (newdist < distance)
-                {
-                    distance = newdist;
-                    it_ = it;
-                }
-            }
-
-            if (it_ != HUDRadar::getInstance().getRadarObjects().end())
-            {
-                focus_ = *it_;
-
-                // move the focused object to the begin of the list, so we will iterate through all other objects when cycling
-                HUDRadar::getInstance().getRadarObjects().erase(it_);
-                HUDRadar::getInstance().getRadarObjects().insert(HUDRadar::getInstance().getRadarObjects().begin(), focus_);
-                it_ = HUDRadar::getInstance().getRadarObjects().begin();
-            }
-        }
-        else if (it_ != HUDRadar::getInstance().getRadarObjects().end())
-        {
-            focus_->resetMaterial();
-            ++it_;
-            if (it_ != HUDRadar::getInstance().getRadarObjects().end())
-                focus_ = *it_;
-            else
-                focus_ = 0;
-        }
-        else
-        {
-            focus_ = 0;
-        }
-        updateFocus();
-    }
-
-    void HUDNavigation::updateFocus()
-    {
-        if (focus_)
-        {
-            overlay_->show();
-            focus_->setColour(ColourValue::White);
-        }
-        else
-        {
-            overlay_->hide();
-        }
-    }
-
-    void HUDNavigation::releaseFocus()
-    {
-        this->focus_ = 0;
-        this->updateFocus();
-    }
-
     float HUDNavigation::getDist2Focus() const
     {
-        if (focus_)
-            return (focus_->getPosition() - SpaceShip::getLocalShip()->getPosition()).length();
+        if (Radar::getInstance().getFocus())
+            return (Radar::getInstance().getFocus()->getWorldPosition() - SpaceShip::getLocalShip()->getPosition()).length();
         else
             return 0;
@@ -377,24 +314,8 @@
     }
 
-    /*static*/ HUDNavigation& HUDNavigation::getInstance()
+    /*static*/ /*HUDNavigation& HUDNavigation::getInstance()
     {
         assert(instance_s);
         return *instance_s;
-    }
-
-    /*static*/ void HUDNavigation::cycleNavigationFocus()
-    {
-        // avoid using getInstance because of the assert().
-        // User might call this fuction even if HUDNavigation doesn't exist.
-        if (instance_s)
-            instance_s->cycleFocus();
-    }
-
-    /*static*/ void HUDNavigation::releaseNavigationFocus()
-    {
-        // avoid using getInstance because of the assert().
-        // User might call this fuction even if HUDNavigation doesn't exist.
-        if (instance_s)
-            instance_s->releaseFocus();
-    }
+    }*/
 }
Index: code/branches/hud/src/orxonox/overlays/hud/HUDNavigation.h
===================================================================
--- code/branches/hud/src/orxonox/overlays/hud/HUDNavigation.h	(revision 1612)
+++ code/branches/hud/src/orxonox/overlays/hud/HUDNavigation.h	(revision 1613)
@@ -50,14 +50,14 @@
         void tick(float dt);
 
-        void cycleFocus();
+        //void cycleFocus();
         float getDist2Focus() const;
 
-        inline RadarObject* getFocus() const
+        /*inline RadarObject* getFocus() const
             { return this->focus_; }
-        void releaseFocus();
+        void releaseFocus();*/
 
-        static void cycleNavigationFocus();
+        /*static void cycleNavigationFocus();
         static void releaseNavigationFocus();
-        static HUDNavigation& getInstance();
+        static HUDNavigation& getInstance();*/
 
       protected:
@@ -87,9 +87,7 @@
         float aimMarkerSize_;                       //!< One paramter size of the aim marker
         Ogre::TextAreaOverlayElement* navText_;     //!< Text overlay to display the target distance
-        std::list<RadarObject*>::iterator it_;
-        RadarObject* focus_;                        // next pointer of linked list
         bool wasOutOfView_;                         //!< Performance booster variable: setMaterial is not cheap
 
-        static HUDNavigation* instance_s;
+        //static HUDNavigation* instance_s;
   };
 }
Index: code/branches/hud/src/orxonox/overlays/hud/HUDRadar.cc
===================================================================
--- code/branches/hud/src/orxonox/overlays/hud/HUDRadar.cc	(revision 1612)
+++ code/branches/hud/src/orxonox/overlays/hud/HUDRadar.cc	(revision 1613)
@@ -37,4 +37,5 @@
 #include "objects/SpaceShip.h"
 #include "objects/WorldEntity.h"
+#include "tools/TextureGenerator.h"
 #include "RadarViewable.h"
 
@@ -42,8 +43,5 @@
 {
     CreateFactory(HUDRadar);
-    CreateFactory(RadarColour);
     CreateFactory(RadarShape);
-
-    HUDRadar* HUDRadar::instance_s = 0;
 
     using namespace Ogre;
@@ -51,9 +49,8 @@
     HUDRadar::HUDRadar()
       : background_(0)
+      , marker_(0)
+      , sensitivity_(1.0f)
     {
         RegisterObject(HUDRadar);
-
-        assert(instance_s == 0);
-        instance_s = this;
     }
 
@@ -62,5 +59,5 @@
         if (this->isInitialized())
         {
-            if (this->background_)
+            /*if (this->background_)
                 OverlayManager::getSingleton().destroyOverlayElement(this->background_);
             while (this->radarDots_.size() > 0)
@@ -68,8 +65,6 @@
                 OverlayManager::getSingleton().destroyOverlayElement(this->radarDots_[this->radarDots_.size() - 1]);
                 this->radarDots_.pop_back();
-            }
-        }
-
-        instance_s = 0;
+            }*/
+        }
     }
 
@@ -78,5 +73,18 @@
         OrxonoxOverlay::XMLPort(xmlElement, mode);
 
-        XMLPortObject(HUDRadar, RadarColour, "shapes", addShape, getShape, xmlElement, mode, false, true);
+        if (mode == XMLPort::LoadObject)
+        {
+            this->sensitivity_ = 1.0f;
+            this->halfDotSizeDistance_ = 3000.0f;
+            this->maximumDotSize_ = 0.1;
+        }
+
+        XMLPortParam(HUDRadar, "sensitivity", setRadarSensitivity, getRadarSensitivity, xmlElement, mode);
+        XMLPortParam(HUDRadar, "halfDotSizeDistance", setHalfDotSizeDistance, getHalfDotSizeDistance, xmlElement, mode);
+        XMLPortParam(HUDRadar, "maximumDotSize", setMaximumDotSize, getMaximumDotSize, xmlElement, mode);
+
+        shapeMaterials_[RadarViewable::Dot]      = "RadarSquare.tga";
+        shapeMaterials_[RadarViewable::Triangle] = "RadarSquare.tga";
+        shapeMaterials_[RadarViewable::Square]   = "RadarSquare.tga";
 
         if (mode == XMLPort::LoadObject)
@@ -86,52 +94,12 @@
             overlay_->add2D(background_);
 
-            // create an array of all possible materials
-            unsigned int iMaterial = 0;
-            for (std::map<unsigned int, RadarShape*>::const_iterator itShape = shapes_.begin(); itShape != shapes_.end(); ++itShape)
-            {
-                Ogre::MaterialPtr originalMaterial = (Ogre::MaterialPtr)(Ogre::MaterialManager::getSingleton().getByName((*itShape).second->getAttribute()));
-                for (std::map<unsigned int, RadarColour*>::const_iterator itColour = colours_.begin(); itColour != colours_.end(); ++itColour)
-                {
-                    Ogre::MaterialPtr newMaterial = originalMaterial->clone((*itShape).second->getAttribute() + convertToString(iMaterial++));
-                    newMaterial->getTechnique(0)->getPass(0)->setAmbient((*itColour).second->getAttribute()); 
-                    materialNames_[(*itShape).first + ((*itColour).first << 8)] = newMaterial->getName();
-                }
-            }
-
-            /*WorldEntity* object;
-            object = new WorldEntity();
-            object->setPosition(2000.0, 0.0, 0.0);
-            addRadarObject(object, ColourValue(0.5, 0, 0, 1));
-            object = new WorldEntity();
-            object->setPosition(0.0, 2000.0, 0.0);
-            addRadarObject(object, ColourValue(0.5, 0, 0, 1));
-            object = new WorldEntity();
-            object->setPosition(0.0, 0.0, 2000.0);
-            addRadarObject(object, ColourValue(0.5, 0, 0, 1));
-            object = new WorldEntity();
-            object->setPosition(10000.0,16000.0,0.0);
-            addRadarObject(object);*/
-        }
-    }
-
-    void HUDRadar::addColour(RadarColour* colour)
-    {
-        this->colours_[colour->getIndex()] = colour;
-    }
-
-    RadarColour* HUDRadar::getColour(unsigned int index) const
-    {
-        if (index < this->colours_.size())
-        {
-            std::map<unsigned int, RadarColour*>::const_iterator it = colours_.begin();
-            for (unsigned int i = 0; i != index; ++it, ++i)
-                ;
-            return (*it).second;
-        }
-        else
-            return 0;
-    }
-
-    void HUDRadar::addShape(RadarShape* shape)
+            marker_ = (Ogre::PanelOverlayElement*)Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", getName() + "_Marker");
+            marker_->setMaterialName("Orxonox/RadarMarker");
+            overlay_->add2D(marker_);
+            marker_->hide();
+        }
+    }
+
+    /*void HUDRadar::addShape(RadarShape* shape)
     {
         this->shapes_[shape->getIndex()] = shape;
@@ -149,7 +117,74 @@
         else
             return 0;
-    }
-
-    void HUDRadar::tick(float dt)
+    }*/
+
+    void HUDRadar::displayObject(RadarViewable* object, bool bIsMarked)
+    {
+        const WorldEntity* wePointer = object->getWorldEntity();
+
+        // Just to be sure that we actually have a WorldEntity
+        // We could do a dynamic_cast, but that's a lot slower
+        if (!wePointer)
+        {
+            CCOUT(4) << "Cannot display a non-WorldEntitiy on the radar" << std::endl;
+            return;
+        }
+
+        /*static int counter = 0;
+        if (++counter < 1120 && counter > 120)
+        {
+            // we have to create a new entry
+            Ogre::PanelOverlayElement* panel = static_cast<Ogre::PanelOverlayElement*>(
+                Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberStr()));
+            // get right material
+            panel->setMaterialName("Orxonox/RadarSquare");
+            panel->setDimensions(0.03, 0.03);
+            panel->setPosition((1.0 + (rand() & 0xFF) / 256.0 - 0.001) * 0.5, (1.0 - (rand() & 0xFF) / 256.0 - 0.001) * 0.5);
+            panel->show();
+            this->overlay_->add2D(panel);
+            this->overlay_->show();
+        }*/
+
+        // try to find a panel already created
+        Ogre::PanelOverlayElement* panel;
+        std::map<RadarViewable*, Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.find(object);
+        if (it == this->radarDots_.end())
+        {
+            // we have to create a new entry
+            panel = static_cast<Ogre::PanelOverlayElement*>(
+                Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberStr()));
+            radarDots_[object] = panel;
+            // get right material
+            panel->setMaterialName(TextureGenerator::getMaterialName(
+                shapeMaterials_[object->getRadarObjectType()], object->getRadarObjectColour()));
+            this->overlay_->add2D(panel);
+        }
+        else
+            panel = (*it).second;
+
+        // set size to fit distance...
+        float distance = (wePointer->getWorldPosition() - SpaceShip::getLocalShip()->getPosition()).length();
+        // calculate the size with 1/distance dependency for simplicity (instead of exp(-distance * lambda)
+        float size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance);
+        panel->setDimensions(size, size);
+
+        // calc position on radar...
+        Vector2 coord = get2DViewcoordinates(SpaceShip::getLocalShip()->getPosition(), SpaceShip::getLocalShip()->getDir(), SpaceShip::getLocalShip()->getOrth(), wePointer->getWorldPosition());
+        coord *= Ogre::Math::PI / 3.5; // small adjustment to make it fit the texture
+        panel->setPosition((1.0 + coord.x - size) * 0.5, (1.0 - coord.y - size) * 0.5);
+
+        if (bIsMarked)
+        {
+            this->marker_->show();
+            this->marker_->setDimensions(size * 1.2, size * 1.2);
+            this->marker_->setPosition((1.0 + coord.x - size * 1.2) * 0.5, (1.0 - coord.y - size * 1.2) * 0.5);
+        }
+    }
+
+    void HUDRadar::radarTick(float dt)
+    {
+    }
+
+    /*void HUDRadar::tick(float dt)
     {
         // iterate through all RadarObjects
@@ -159,33 +194,9 @@
             if ((*it)->isVisibleOnRadar())
             {
-                WorldEntity* object = (*it)->getWorldEntity();
-                // Just to be sure that we actually have a WorldEntity
-                // We could do a dynamic_cast, but that's a lot slower
-                assert(object);
-
-                // set size to fit distance...
-                float size = 1.0/((object->getWorldPosition() - SpaceShip::getLocalShip()->getPosition()).length());
-                size = clamp(size * 100.0f, 0.02f, 0.12f);
-                if (i == radarDots_.size())
-                {
-                    // we have to create a new panel
-                    radarDots_.push_back(static_cast<Ogre::PanelOverlayElement*>(
-                        Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + convertToString(i))));
-                }
-                radarDots_[i]->setDimensions(size, size);
-
-                // calc position on radar...
-                Vector2 coord = get2DViewcoordinates(SpaceShip::getLocalShip()->getPosition(), SpaceShip::getLocalShip()->getDir(), SpaceShip::getLocalShip()->getOrth(), object->getWorldPosition());
-                coord *= Ogre::Math::PI / 3.5; // small adjustment to make it fit the texture
-                radarDots_[i]->setPosition((1.0 + coord.x) * 0.5, (1.0 - coord.y) * 0.5);
-
-                // apply the right material
-                RadarPoint description = (*it)->getDescription();
-                radarDots_[i]->setMaterialName(materialNames_[description.shape_ + (description.colour_ << 8)]);
             }
         }
-    }
-
-    void HUDRadar::listObjects()
+    }*/
+
+    /*void HUDRadar::listObjects()
     {
         COUT(3) << "List of RadarObjects:\n";
@@ -196,10 +207,4 @@
             COUT(3) << i++ << ": " << (*it)->getWorldEntity()->getWorldPosition() << std::endl;
         }
-    }
-
-    /*static*/ HUDRadar& HUDRadar::getInstance()
-    {
-        assert(instance_s);
-        return *instance_s;
-    }
+    }*/
 }
Index: code/branches/hud/src/orxonox/overlays/hud/HUDRadar.h
===================================================================
--- code/branches/hud/src/orxonox/overlays/hud/HUDRadar.h	(revision 1612)
+++ code/branches/hud/src/orxonox/overlays/hud/HUDRadar.h	(revision 1613)
@@ -92,5 +92,5 @@
 
 
-    class _OrxonoxExport HUDRadar : public OrxonoxOverlay, public Tickable, public RadarListener
+    class _OrxonoxExport HUDRadar : public OrxonoxOverlay, public RadarListener//, public Tickable
     {
       public:
@@ -100,21 +100,36 @@
         void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
-        void addShape(RadarShape* shape);
-        RadarShape* getShape(unsigned int index) const;
+        /*void addShape(RadarShape* shape);
+        RadarShape* getShape(unsigned int index) const;*/
 
-        void tick(float dt);
+        float getRadarSensitivity() const { return this->sensitivity_; }
+        void setRadarSensitivity(float sensitivity) { this->sensitivity_ = sensitivity; }
 
-        void listObjects();
+        float getHalfDotSizeDistance() const { return this->halfDotSizeDistance_; }
+        void setHalfDotSizeDistance(float distance) { this->halfDotSizeDistance_ = distance; }
+
+        float getMaximumDotSize() const { return this->maximumDotSize_; }
+        void setMaximumDotSize(float size) { this->maximumDotSize_ = size; }
+
+        //void tick(float dt);
+
+        //void listObjects();
 
       private:
-        void addColour(RadarColour* colour);
-        RadarColour* getColour(unsigned int index) const;
+        void displayObject(RadarViewable* viewable, bool bIsMarked);
+        void hideMarker() { this->marker_->hide(); }
+        float getRadarSensitivity() { return 1.0f; }
+        void radarTick(float dt);
 
-        std::map<unsigned int, std::string> materialNames_;
-        std::map<unsigned int, RadarColour*> colours_;
-        std::map<unsigned int, RadarShape*> shapes_;
+        std::map<RadarViewable::Shape, std::string> shapeMaterials_;
 
         Ogre::PanelOverlayElement* background_;
         std::map<RadarViewable*, Ogre::PanelOverlayElement*> radarDots_;
+        Ogre::PanelOverlayElement* marker_;
+
+        float halfDotSizeDistance_;
+        float maximumDotSize_;
+
+        float sensitivity_;
     };
 }
Index: code/branches/hud/src/orxonox/overlays/hud/RadarViewable.cc
===================================================================
--- code/branches/hud/src/orxonox/overlays/hud/RadarViewable.cc	(revision 1612)
+++ 	(revision )
@@ -1,56 +1,0 @@
-/*
- *   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:
- *      Reto Grieder
- *   Co-authors:
- *      ...
- *
- */
-
-#include "OrxonoxStableHeaders.h"
-#include "RadarViewable.h"
-#include "core/Debug.h"
-#include "Radar.h"
-
-namespace orxonox
-{
-    /**
-        @brief Constructor.
-    */
-    RadarViewable::RadarViewable()
-        : radarObjectVisibility_(1.0f)
-        , radarObject_(0)
-    {
-        RegisterRootObject(RadarViewable);
-    }
-
-    void RadarViewable::unregisterFromRadar()
-    {
-        Radar* radar = Radar::getInstancePtr();
-        if (radar)
-            radar->unregisterObject(this);
-        else
-        {
-            CCOUT(2) << "Attempting to unregister an object to the radar, but the radar is non existent." << std::endl;
-        }
-    }
-}
Index: code/branches/hud/src/orxonox/overlays/hud/RadarViewable.h
===================================================================
--- code/branches/hud/src/orxonox/overlays/hud/RadarViewable.h	(revision 1612)
+++ 	(revision )
@@ -1,67 +1,0 @@
-/*
- *   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:
- *      Reto Grieder
- *   Co-authors:
- *      ...
- *
- */
-
-#ifndef _RadarViewable_H__
-#define _RadarViewable_H__
-
-#include "OrxonoxPrereqs.h"
-#include <string>
-#include "core/OrxonoxClass.h"
-#include "util/Math.h"
-
-namespace orxonox
-{
-    /**
-    @brief Interface for receiving window events.
-    */
-    class _OrxonoxExport RadarViewable : virtual public OrxonoxClass
-    {
-    public:
-        RadarViewable();
-        virtual ~RadarViewable() { unregisterFromRadar(); }
-
-        void unregisterFromRadar();
-
-        float getRadarObjectVisibility() const { return this->radarObjectVisibility_; }
-        void setRadarObjectVisibility(float visibility) { this->radarObjectVisibility_ = visibility; }
-
-        const std::string& getRadarObjectType() const { return this->radarObjectType_; }
-        void setRadarObjectType(const std::string& type) { this->radarObjectType_ = type; }
-
-        const ColourValue& getRadarObjectColour() const { return this->radarObjectColour_; }
-        void setRadarObjectColour(const ColourValue& colour) { this->radarObjectColour_ = colour; }
-
-    private:
-        float radarObjectVisibility_;
-        WorldEntity* radarObject_;
-        std::string radarObjectType_;
-        ColourValue radarObjectColour_;
-    };
-}
-
-#endif /* _RadarViewable_H__ */
Index: code/branches/hud/src/orxonox/tools/TextureGenerator.cc
===================================================================
--- code/branches/hud/src/orxonox/tools/TextureGenerator.cc	(revision 1612)
+++ code/branches/hud/src/orxonox/tools/TextureGenerator.cc	(revision 1613)
@@ -77,6 +77,5 @@
             textureUnitState->setTextureName(textureName);
             textureUnitState->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, colour);
-            colourMap[colour] = materialName;
-            return colourMap[colour];
+            return (colourMap[colour] = materialName);
         }
         else
Index: code/branches/hud/visual_studio/vc8/orxonox.vcproj
===================================================================
--- code/branches/hud/visual_studio/vc8/orxonox.vcproj	(revision 1612)
+++ code/branches/hud/visual_studio/vc8/orxonox.vcproj	(revision 1613)
@@ -189,4 +189,26 @@
 			</File>
 			<File
+				RelativePath="..\..\src\orxonox\RadarViewable.cc"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						ObjectFile="$(IntDir)\$(InputName)1.obj"
+						XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Release|Win32"
+					>
+					<Tool
+						Name="VCCLCompilerTool"
+						ObjectFile="$(IntDir)\$(InputName)1.obj"
+						XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
+					/>
+				</FileConfiguration>
+			</File>
+			<File
 				RelativePath="..\..\src\orxonox\Settings.cc"
 				>
@@ -484,12 +506,4 @@
 					<File
 						RelativePath="..\..\src\orxonox\overlays\hud\HUDText.cc"
-						>
-					</File>
-					<File
-						RelativePath="..\..\src\orxonox\overlays\hud\RadarObject.cc"
-						>
-					</File>
-					<File
-						RelativePath="..\..\src\orxonox\overlays\hud\RadarViewable.cc"
 						>
 					</File>
@@ -523,4 +537,8 @@
 			</File>
 			<File
+				RelativePath="..\..\src\orxonox\RadarViewable.h"
+				>
+			</File>
+			<File
 				RelativePath="..\..\src\orxonox\Settings.h"
 				>
@@ -698,16 +716,4 @@
 					<File
 						RelativePath="..\..\src\orxonox\overlays\hud\HUDText.h"
-						>
-					</File>
-					<File
-						RelativePath="..\..\src\orxonox\overlays\hud\OverlayElementFactories.h"
-						>
-					</File>
-					<File
-						RelativePath="..\..\src\orxonox\overlays\hud\RadarObject.h"
-						>
-					</File>
-					<File
-						RelativePath="..\..\src\orxonox\overlays\hud\RadarViewable.h"
 						>
 					</File>
