Index: code/trunk/src/libraries/util/Math.cc
===================================================================
--- code/trunk/src/libraries/util/Math.cc	(revision 9834)
+++ code/trunk/src/libraries/util/Math.cc	(revision 9939)
@@ -23,5 +23,5 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Wolfgang Roenninger
  *
  */
@@ -147,5 +147,5 @@
 
     /**
-        @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object, multiplied with the viewing distance to the object (0° = 0, 180° = 1).
+        @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object, multiplied with the viewing distance to the object (0� = 0, 180� = 1).
         @param myposition My position
         @param mydirection My viewing direction
@@ -189,4 +189,152 @@
         else
             return orxonox::Vector2( -sin_value * radius, cos_value * radius);
+    }
+
+
+    /**
+            @brief Gets the 2D project vector for the 3D Radar .
+            @param myposition My position
+            @param mydirection My viewing direction
+            @param myorthonormal My orthonormalvector (pointing upwards through my head)
+            @param otherposition The position of the other object
+            @param mapangle The angle between line of sight on screen and the 3Dmap-x/z-plain in radian
+            @param detectionlimit The limit in which objects are shown on the map
+            @return The viewing direction
+    */
+    orxonox::Vector2 get3DProjection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle, const float detectionlimit)
+    {
+    	// Orxonox Vectors: x_direction you are looking, y_direction points up, z_direction points to the right
+    	orxonox::Vector3 distance = otherposition - myposition;	// get vector from Ship to object
+
+    	// new coordinate system:	x_axsis:	mydirection		(points front)
+    	//							y_axsis:	myorthonormal	(points up)
+    	//							z_axsis:	myside			(points right)
+
+    	orxonox::Vector3 myside = mydirection.crossProduct(myorthonormal); // get 3. base vector
+
+    	distance = 4*distance / detectionlimit; // shrink vector on map
+    	if(distance.length() > 1.0f) // if object would wander outside of the map
+    	    	{
+    	    	distance = distance / distance.length();
+    	   		}
+
+    	// perform a coordinate transformation to get distance in relation of the position of the ship
+    	orxonox::Vector3 distanceShip = getTransformedVector(distance, mydirection, myorthonormal, myside);
+
+    	// calculate 2D vector on the map (with angle between x/z - plain and line of sight)
+    	float xcoordinate = distanceShip.z; // z; cause x direction on screen is to the right side
+    	float ycoordinate = distanceShip.x*sin(mapangle)+distanceShip.y*cos(mapangle);
+    	return orxonox::Vector2(xcoordinate , ycoordinate);
+    }
+
+    /**
+               @brief Gets if a object is over the x/z - plain on map
+               @param myposition My position
+               @param mydirection My viewing direction
+               @param myorthonormal My orthonormalvector (pointing upwards through my head)
+               @param otherposition The position of the other object
+               @param mapangle The angle you look on the 3Dmap in radian
+               @return If distancevector to the other object has a positive y-coordinate
+
+               Examples:
+                Returns true if object is over x/z - plain
+                Returns false if object is below x/z -plain
+    */
+    bool isObjectHigherThanShipOnMap(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle)
+    {
+    	// Orxonox Vectors: x_direction you are looking, y_direction points up, z_direction points to the right
+    	orxonox::Vector3 distance = otherposition - myposition;
+
+    	// new coordinate system:	x_axsis:	mydirection		(points front)
+    	//							y_axsis:	myorthonormal	(points up)
+       	//							z_axsis:	myside			(points right)
+
+       	orxonox::Vector3 myside = mydirection.crossProduct(myorthonormal); // get vector from Ship to object
+
+
+       	// perform a coordinate transformation to get distance in relation of the position of the ship
+       	orxonox::Vector3 distanceShip = getTransformedVector(distance, mydirection, myorthonormal, myside);
+
+       	if(distanceShip.y >= 0)
+       		return true;
+       	else
+       		return false;
+    }
+
+    /**
+                   @brief A value between 0 and 10, in order how other object is in front or in back
+                   @param myposition My position
+               	   @param mydirection My viewing direction
+               	   @param myorthonormal My orthonormalvector (pointing upwards through my head)
+               	   @param otherposition The position of the other object
+               	   @param detectionlimit The limit in which objects are shown on the map
+                   @return value between 0 and 100
+    */
+    int determineMap3DZOrder(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float detectionlimit)
+    {
+    	orxonox::Vector3 distance = otherposition - myposition;	// get vector from Ship to object
+    	orxonox::Vector3 myside = mydirection.crossProduct(myorthonormal); 	// get vector to the side
+
+    	distance = 4*distance / detectionlimit; // shrink vector on map
+    	if(distance.length() > 1.0f) // if object would wander outside of the map
+    	{
+    		distance = distance / distance.length();
+    	}
+
+    	// perform a coordinate transformation to get distance in relation of the position of the ship
+       	orxonox::Vector3 distanceShip = getTransformedVector(distance, mydirection, myorthonormal, myside);
+
+       	return (int) 50 - 100*distanceShip.x;
+    }
+
+
+    /**
+                @brief Gets the new vector after a coordinate transformation
+                @param distance Vector which will be transformed
+                @param mydirection New x basevector
+                @param myorthonormal New y basevector
+                @param otherposition New z basevector
+                @return direction in the new coordinates
+
+                x is vector in old coordinates
+                y is vector in old coordinates
+                T is transform matrix with:
+                	T = (t1 , t2 , t3)
+                	t1 = mydirection
+                	t2 = myorthonormal
+                	t3 = myside
+
+                y = T^(-1)*x
+            */
+    orxonox::Vector3 getTransformedVector(const orxonox::Vector3& distance, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& myside)
+    {
+    	// inverse of the transform matrix
+    	float determinant = +mydirection.x * (myorthonormal.y*myside.z - myside.y*myorthonormal.z)
+    						-mydirection.y * (myorthonormal.x*myside.z - myorthonormal.z*myside.x)
+    						+mydirection.z * (myorthonormal.x*myside.y - myorthonormal.y*myside.x);
+    	float invdet = 1/determinant;
+
+    	// transform matrix
+    	orxonox::Vector3 xinvtransform;
+    	orxonox::Vector3 yinvtransform;
+    	orxonox::Vector3 zinvtransform;
+
+    	xinvtransform.x = (myorthonormal.y * myside.z        - myside.y        * myorthonormal.z)*invdet;
+    	xinvtransform.y = (mydirection.z   * myside.y        - mydirection.y   * myside.z       )*invdet;
+    	xinvtransform.z = (mydirection.y   * myorthonormal.z - mydirection.z   * myorthonormal.y)*invdet;
+    	yinvtransform.x = (myorthonormal.z * myside.x        - myorthonormal.x * myside.z       )*invdet;
+    	yinvtransform.y = (mydirection.x   * myside.z        - mydirection.z   * myside.x       )*invdet;
+    	yinvtransform.z = (myorthonormal.x * mydirection.z   - mydirection.x   * myorthonormal.z)*invdet;
+    	zinvtransform.x = (myorthonormal.x * myside.y        - myside.x        * myorthonormal.y)*invdet;
+    	zinvtransform.y = (myside.x        * mydirection.y   - mydirection.x   * myside.y       )*invdet;
+    	zinvtransform.z = (mydirection.x   * myorthonormal.y - myorthonormal.x * mydirection.y  )*invdet;
+
+    	// coordinate transformation
+    	orxonox::Vector3 distanceShip;
+    	distanceShip.x = xinvtransform.x * distance.x + yinvtransform.x * distance.y + zinvtransform.x * distance.z;
+    	distanceShip.y = xinvtransform.y * distance.x + yinvtransform.y * distance.y + zinvtransform.y * distance.z;
+    	distanceShip.z = xinvtransform.z * distance.x + yinvtransform.z * distance.y + zinvtransform.z * distance.z;
+
+    	return distanceShip;
     }
 
Index: code/trunk/src/libraries/util/Math.h
===================================================================
--- code/trunk/src/libraries/util/Math.h	(revision 9834)
+++ code/trunk/src/libraries/util/Math.h	(revision 9939)
@@ -23,5 +23,5 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Wolfgang Roenninger
  *
  */
@@ -92,4 +92,8 @@
     _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
     _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
+    _UtilExport orxonox::Vector2 get3DProjection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle, const float detectionlimit);
+    _UtilExport bool isObjectHigherThanShipOnMap(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle);
+    _UtilExport int determineMap3DZOrder(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float detectionlimit);
+    _UtilExport orxonox::Vector3 getTransformedVector(const orxonox::Vector3& distance, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& myside);
     _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
 
Index: code/trunk/src/modules/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/CMakeLists.txt	(revision 9834)
+++ code/trunk/src/modules/CMakeLists.txt	(revision 9939)
@@ -39,2 +39,3 @@
 ADD_SUBDIRECTORY(docking)
 ADD_SUBDIRECTORY(towerdefense)
+ADD_SUBDIRECTORY(invader)
Index: code/trunk/src/modules/docking/Dock.cc
===================================================================
--- code/trunk/src/modules/docking/Dock.cc	(revision 9834)
+++ code/trunk/src/modules/docking/Dock.cc	(revision 9939)
@@ -69,4 +69,6 @@
         XMLPortObject(Dock, DockingAnimation, "animations", addAnimation, getAnimation, xmlelement, mode);
         XMLPortEventSink(Dock, BaseObject, "execute", execute, xmlelement, mode);
+        XMLPortEventSink(Dock, BaseObject, "undocking", undocking, xmlelement, mode);
+
     }
 
@@ -76,5 +78,53 @@
 
         XMLPortEventSink(Dock, BaseObject, "execute", execute, xmlelement, mode);
-    }
+
+        XMLPortEventSink(Dock, BaseObject, "undocking", undocking, xmlelement, mode);
+    }
+
+
+    bool Dock::undocking(bool bTriggered, BaseObject* trigger)
+    {
+
+    	PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
+    	PlayerInfo* player = NULL;
+
+    	// Check whether it is a player trigger and extract pawn from it
+    	if(pTrigger != NULL)
+    	{
+    	      if(!pTrigger->isForPlayer()) {  // The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
+    	      orxout(verbose, context::docking) << "Docking:execute PlayerTrigger was not triggered by a player.." << endl;
+    	      return false;
+    	      }
+    	      player = pTrigger->getTriggeringPlayer();
+    	}
+    	else
+    	{
+    	      orxout(verbose, context::docking) << "Docking::execute Not a player trigger, can't extract pawn from it.." << endl;
+    	      return false;
+    	}
+    	if(player == NULL)
+    	{
+    	      orxout(verbose, context::docking) << "Docking::execute Can't retrieve PlayerInfo from Trigger. (" << trigger->getIdentifier()->getName() << ")" << endl;
+    	      return false;
+    	}
+
+ 	    if(bTriggered)
+    	{
+    	      // Add player to this Docks candidates
+    	      candidates_.insert(player);
+
+    	      // Show docking dialog
+    	      this->showUndockingDialogHelper(player);
+    	}
+    	else
+    	{
+    	      // Remove player from candidates list
+    	      candidates_.erase(player);
+    	}
+
+    	return true;
+    }
+
+
 
     bool Dock::execute(bool bTriggered, BaseObject* trigger)
@@ -119,4 +169,22 @@
         return true;
     }
+
+
+    void Dock::showUndockingDialogHelper(PlayerInfo* player)
+        {
+            assert(player);
+
+            if(!player->isHumanPlayer())
+                return;
+
+            if(GameMode::isMaster())
+            {
+                if(GameMode::showsGraphics())
+                    GUIManager::showGUI("UndockingDialog");
+            }
+            else
+                callStaticNetworkFunction(Dock::showDockingDialog, player->getClientID());
+
+        }
 
     void Dock::showDockingDialogHelper(PlayerInfo* player)
@@ -177,4 +245,5 @@
         if (animations_.empty())
             return dockingAnimationFinished(player);
+
         else
             DockingAnimation::invokeAnimation(true, player, animations_);
Index: code/trunk/src/modules/docking/Dock.h
===================================================================
--- code/trunk/src/modules/docking/Dock.h	(revision 9834)
+++ code/trunk/src/modules/docking/Dock.h	(revision 9939)
@@ -62,4 +62,5 @@
             // Trigger interface
             bool execute(bool bTriggered, BaseObject* trigger);
+            bool undocking(bool bTriggered, BaseObject* trigger);
 
             // XML interface
@@ -85,4 +86,6 @@
             void dock()
                 { this->dock(HumanController::getLocalControllerSingleton()->getPlayer()); }
+            void undock()
+                { this->undock(HumanController::getLocalControllerSingleton()->getPlayer()); }
             static unsigned int getNumberOfActiveDocks();
             static Dock* getActiveDockAtIndex(unsigned int index);
@@ -95,4 +98,5 @@
             // Network functions
             void showDockingDialogHelper(PlayerInfo* player);
+            void showUndockingDialogHelper(PlayerInfo* player);
             static void showDockingDialog();
 
Index: code/trunk/src/modules/docking/MoveToDockingTarget.cc
===================================================================
--- code/trunk/src/modules/docking/MoveToDockingTarget.cc	(revision 9834)
+++ code/trunk/src/modules/docking/MoveToDockingTarget.cc	(revision 9939)
@@ -66,6 +66,9 @@
     {
         //TODO: Investigate strange things...
-        this->parent_->detach((WorldEntity*)player->getControllableEntity());
+    	//this->parent_->detach((WorldEntity*)player->getControllableEntity());
 
+    	//TODO: Check the issue with this detach call.
+    	//I have removed the line because the detach call only caused a warning and terminated. And because I didn't find a attach call either.
+    	//Didn't find the need for the line.
         this->parent_->undockingAnimationFinished(player);
         return true;
Index: code/trunk/src/modules/invader/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/invader/CMakeLists.txt	(revision 9939)
+++ code/trunk/src/modules/invader/CMakeLists.txt	(revision 9939)
@@ -0,0 +1,22 @@
+SET_SOURCE_FILES(Invader_SRC_FILES
+BUILD_UNIT InvaderBuildUnit.cc
+  Invader.cc
+  InvaderCenterPoint.cc
+  InvaderShip.cc
+  InvaderEnemy.cc
+  InvaderEnemyShooter.cc
+  InvaderWeapon.cc
+  InvaderWeaponEnemy.cc
+  InvaderHUDinfo.cc
+END_BUILD_UNIT
+)
+
+ORXONOX_ADD_LIBRARY(Invader
+  MODULE
+  FIND_HEADER_FILES
+  LINK_LIBRARIES
+    orxonox
+    overlays
+    weapons
+  SOURCE_FILES ${Invader_SRC_FILES}
+)
Index: code/trunk/src/modules/invader/Invader.cc
===================================================================
--- code/trunk/src/modules/invader/Invader.cc	(revision 9939)
+++ code/trunk/src/modules/invader/Invader.cc	(revision 9939)
@@ -0,0 +1,186 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file Invader.cc
+    @brief Implementation of the Invader class.
+*/
+
+#include "Invader.h"
+
+#include "core/CoreIncludes.h"
+#include "core/EventIncludes.h"
+#include "core/command/Executor.h"
+#include "core/config/ConfigValueIncludes.h"
+
+#include "gamestates/GSLevel.h"
+#include "chat/ChatManager.h"
+
+// ! HACK
+#include "infos/PlayerInfo.h"
+
+#include "InvaderCenterPoint.h"
+#include "InvaderShip.h"
+#include "InvaderEnemy.h"
+#include "InvaderEnemyShooter.h"
+
+#include "core/command/ConsoleCommand.h"
+#include "worldentities/BigExplosion.h"
+
+namespace orxonox
+{
+    RegisterUnloadableClass(Invader);
+
+    Invader::Invader(Context* context) : Deathmatch(context)
+    {
+        RegisterObject(Invader);
+        this->center_ = 0;
+        init();
+        this->setHUDTemplate("InvaderHUD");
+    }
+
+    void Invader::init()
+    {
+        bEndGame = false;
+        lives = 3;
+        level = 1;
+        point = 0;
+        bShowLevel = false;
+        multiplier = 1;
+        b_combo = false;
+        // spawn enemy every 3.5 seconds
+        enemySpawnTimer.setTimer(3.5f, true, createExecutor(createFunctor(&Invader::spawnEnemy, this)));
+        comboTimer.setTimer(3.0f, true, createExecutor(createFunctor(&Invader::comboControll, this)));
+    }
+
+    void Invader::levelUp()
+    {
+        level++;
+        if (getPlayer() != NULL)
+        {   
+            for (int i = 0; i < 7; i++)
+            {
+                WeakPtr<BigExplosion> chunk = new BigExplosion(this->center_->getContext());
+                chunk->setPosition(Vector3(600, 0, 100 * i - 300));
+                chunk->setVelocity(Vector3(1000, 0, 0));  //player->getVelocity()
+                chunk->setScale(20);
+            }
+        }
+        addPoints(multiplier * 42);
+        multiplier *= 2;
+        toggleShowLevel();
+        showLevelTimer.setTimer(1.0f, false, createExecutor(createFunctor(&Invader::toggleShowLevel, this)));
+    }
+
+    WeakPtr<InvaderShip> Invader::getPlayer()
+    {
+        if (player == NULL)
+        {
+            for (ObjectList<InvaderShip>::iterator it = ObjectList<InvaderShip>::begin(); it != ObjectList<InvaderShip>::end(); ++it)
+                player = *it;
+        }
+        return player;
+    }
+
+    void Invader::spawnEnemy()
+    {
+        if (getPlayer() == NULL)
+            return;
+        srand(player->getPosition().x + player->getPosition().y);
+        for (int i = 0; i < (3*log10(level) + 1); i++)
+        {
+            WeakPtr<InvaderEnemy> newPawn;
+            if (rand() % 42/(1 + level*level) == 0)
+            {
+                newPawn = new InvaderEnemyShooter(this->center_->getContext());
+                newPawn->addTemplate("enemyinvadershooter");
+            }
+            else
+            {
+                newPawn = new InvaderEnemy(this->center_->getContext());
+                newPawn->addTemplate("enemyinvader");
+            }
+            newPawn->setPlayer(player);
+            newPawn->level = level;
+            // spawn enemy at random points in front of player.
+            newPawn->setPosition(player->getPosition() + Vector3(500 + 100 * i, 0, float(rand())/RAND_MAX * 400 - 200));
+        }
+    }
+
+    void Invader::costLife()
+    {
+        lives--;
+        multiplier = 1;
+        // end the game in 30 seconds.
+        if (lives <= 0)
+            enemySpawnTimer.setTimer(30.0f, false, createExecutor(createFunctor(&Invader::end, this)));
+    };
+
+    void Invader::comboControll()
+    {
+        if (b_combo)
+            multiplier++;
+        // if no combo was performed before, reset multiplier
+        else
+            multiplier = 1;
+        b_combo = false;
+    }
+
+    void Invader::start()
+    {
+        init();
+        // Set variable to temporarily force the player to spawn.
+        this->bForceSpawn_ = true;
+
+        if (this->center_ == NULL)  // abandon mission!
+        {
+            orxout(internal_error) << "Invader: No Centerpoint specified." << endl;
+            GSLevel::startMainMenu();
+            return;
+        }
+        // Call start for the parent class.
+        Deathmatch::start();
+    }
+    void Invader::addPoints(int numPoints)
+    {
+        if (!bEndGame)
+        {
+            point += numPoints * multiplier;
+            b_combo = true;
+        }
+    }
+
+    void Invader::end()
+    {
+        // DON'T CALL THIS!
+        //      Deathmatch::end();
+        // It will misteriously crash the game!
+        // Instead startMainMenu, this won't crash.
+        GSLevel::startMainMenu();
+    }
+}
Index: code/trunk/src/modules/invader/Invader.h
===================================================================
--- code/trunk/src/modules/invader/Invader.h	(revision 9939)
+++ code/trunk/src/modules/invader/Invader.h	(revision 9939)
@@ -0,0 +1,93 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file Invader.h
+    @brief Gametype.
+    @ingroup Invader
+*/
+
+#ifndef _Invader_H__
+#define _Invader_H__
+
+#include "invader/InvaderPrereqs.h"
+
+#include "gametypes/Deathmatch.h"
+
+#include "InvaderCenterPoint.h"
+
+#include "tools/Timer.h"
+
+namespace orxonox
+{
+
+    class _InvaderExport Invader : public Deathmatch
+    {
+        public:
+            Invader(Context* context);
+
+            virtual void start();
+            virtual void end();
+
+            void spawnEnemy();
+
+            void setCenterpoint(InvaderCenterPoint* center)
+            { this->center_ = center; }
+
+            int getLives(){return this->lives;}
+            int getLevel(){return this->level;}
+            int getPoints(){return this->point;}
+            int getMultiplier(){return this->multiplier;}
+
+            void costLife();
+            void levelUp();
+            void addPoints(int numPoints);
+            // checks if multiplier should be reset.
+            void comboControll();
+            void init();
+            int lives;
+            int multiplier;
+            bool bEndGame;
+            bool bShowLevel;
+        private:
+            void toggleShowLevel(){bShowLevel = !bShowLevel;}
+            WeakPtr<InvaderShip> getPlayer();
+            WeakPtr<InvaderCenterPoint> center_;
+            WeakPtr<InvaderShip> player;
+
+            Timer enemySpawnTimer;
+            Timer comboTimer;
+            Timer showLevelTimer;
+            //Context* context;
+            int level;
+            int point;
+            bool b_combo;
+    };
+}
+
+#endif /* _Invader_H__ */
Index: code/trunk/src/modules/invader/InvaderCenterPoint.cc
===================================================================
--- code/trunk/src/modules/invader/InvaderCenterPoint.cc	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderCenterPoint.cc	(revision 9939)
@@ -0,0 +1,72 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderCenterPoint.cc
+    @brief Implementation of the InvaderCenterPoint class.
+*/
+
+#include "InvaderCenterPoint.h"
+
+#include "core/CoreIncludes.h"
+
+#include "Invader.h"
+
+namespace orxonox
+{
+    RegisterClass(InvaderCenterPoint);
+
+    InvaderCenterPoint::InvaderCenterPoint(Context* context) : StaticEntity(context)
+    {
+        RegisterObject(InvaderCenterPoint);
+
+        this->checkGametype();
+    }
+
+    void InvaderCenterPoint::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(InvaderCenterPoint, XMLPort, xmlelement, mode);
+    }
+
+    void InvaderCenterPoint::changedGametype()
+    {
+        SUPER(InvaderCenterPoint, changedGametype);
+
+        // Check, whether it's still Invader.
+        this->checkGametype();
+    }
+
+    void InvaderCenterPoint::checkGametype()
+    {
+        if (this->getGametype() != NULL && this->getGametype()->isA(Class(Invader)))
+        {
+            Invader* InvaderGametype = orxonox_cast<Invader*>(this->getGametype().get());
+            InvaderGametype->setCenterpoint(this);
+        }
+    }
+}
Index: code/trunk/src/modules/invader/InvaderCenterPoint.h
===================================================================
--- code/trunk/src/modules/invader/InvaderCenterPoint.h	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderCenterPoint.h	(revision 9939)
@@ -0,0 +1,58 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderCenterPoint.h
+    @brief Declaration of the InvaderCenterPoint class.
+    @ingroup Invader
+*/
+
+#ifndef _InvaderCenterPoint_H__
+#define _InvaderCenterPoint_H__
+
+#include "invader/InvaderPrereqs.h"
+
+#include "worldentities/StaticEntity.h"
+
+namespace orxonox
+{
+    class _InvaderExport InvaderCenterPoint : public StaticEntity
+    {
+        public:
+            InvaderCenterPoint(Context* context); //checks whether the gametype is actually Invader.
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+
+            virtual void changedGametype(); //!< Is called when the gametype has changed.
+        private:
+            void checkGametype();
+
+    };
+}
+
+#endif /* _InvaderCenterPoint_H__ */
Index: code/trunk/src/modules/invader/InvaderEnemy.cc
===================================================================
--- code/trunk/src/modules/invader/InvaderEnemy.cc	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderEnemy.cc	(revision 9939)
@@ -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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderEnemy.h
+    @brief Declaration of the InvaderEnemy class.
+*/
+
+#include "invader/InvaderPrereqs.h"
+#include "InvaderEnemy.h"
+#include "InvaderShip.h"
+
+namespace orxonox
+{
+    RegisterClass(InvaderEnemy);
+
+    InvaderEnemy::InvaderEnemy(Context* context) : Pawn(context)
+    {
+        RegisterObject(InvaderEnemy);
+        enableCollisionCallback();
+        lifetime = 0;
+    }
+
+    void InvaderEnemy::tick(float dt)
+    {
+        lifetime += dt;
+        // die after 5 seconds.
+        if (lifetime > 5000)
+            removeHealth(2000);
+
+        if (player != NULL)
+        {
+            float newZ = 2/(pow(abs(getPosition().x - player->getPosition().x) * 0.01, 2) + 1) * (player->getPosition().z - getPosition().z);
+            setVelocity(Vector3(1000 - level * 100 , 0, newZ));
+        }
+        SUPER(InvaderEnemy, tick, dt);
+    }
+
+    inline bool InvaderEnemy::collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
+    {
+        if(orxonox_cast<InvaderShip*>(otherObject))
+            removeHealth(2000);
+        return false;
+    }
+
+    WeakPtr<Invader> InvaderEnemy::getGame()
+    {
+        if (game == NULL)
+        {
+            for (ObjectList<Invader>::iterator it = ObjectList<Invader>::begin(); it != ObjectList<Invader>::end(); ++it)
+                game = *it;
+        }
+        return game;
+    }
+
+    void InvaderEnemy::damage(float damage, float healthdamage, float shielddamage, Pawn* originator)
+    {
+        Pawn::damage(damage, healthdamage, shielddamage, originator);
+        if (getGame() && orxonox_cast<InvaderShip*>(originator) != NULL && getHealth() <= 0)
+            getGame()->addPoints(42);
+    }
+}
Index: code/trunk/src/modules/invader/InvaderEnemy.h
===================================================================
--- code/trunk/src/modules/invader/InvaderEnemy.h	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderEnemy.h	(revision 9939)
@@ -0,0 +1,72 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderEnemy.h
+    @brief Declaration of the InvaderEnemy class.
+*/
+
+#ifndef _InvaderEnemy_H__
+#define _InvaderEnemy_H__
+
+#include "invader/InvaderPrereqs.h"
+
+#include "worldentities/pawns/SpaceShip.h"
+
+namespace orxonox
+{
+    class _InvaderExport InvaderEnemy : public Pawn
+    {
+        public:
+            InvaderEnemy(Context* context);
+
+            virtual void tick(float dt);
+            virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
+            virtual void damage(float damage, float healthdamage, float shielddamage, Pawn* originator);
+            virtual void setPlayer(WeakPtr<InvaderShip> player){this->player = player;}
+
+            int level;
+        protected:
+            WeakPtr<Invader> getGame();
+            WeakPtr<Invader> game;
+            WeakPtr<InvaderShip> player;
+            Camera* camera;
+            bool isFireing;
+            float speed, damping;
+            float lastTimeFront, lastTimeLeft;
+            float lifetime;
+            struct Velocity
+            {
+                float x;
+                float y;
+            } velocity, desiredVelocity;
+
+    };
+}
+
+#endif /* _InvaderEnemy_H__ */
Index: code/trunk/src/modules/invader/InvaderEnemyShooter.cc
===================================================================
--- code/trunk/src/modules/invader/InvaderEnemyShooter.cc	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderEnemyShooter.cc	(revision 9939)
@@ -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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderEnemyShooter.h
+    @brief Declaration of the InvaderEnemyShooter class.
+*/
+
+#include "invader/InvaderPrereqs.h"
+#include "InvaderEnemyShooter.h"
+// #include "worldentities/pawns/SpaceShip.h"
+
+namespace orxonox
+{
+    RegisterClass(InvaderEnemyShooter);
+
+    InvaderEnemyShooter::InvaderEnemyShooter(Context* context) : InvaderEnemy(context)
+    {
+        RegisterObject(InvaderEnemyShooter);
+        enableCollisionCallback();
+        lifetime = 0;
+        // shoot every second
+        shootTimer.setTimer(1.0f, true, createExecutor(createFunctor(&InvaderEnemyShooter::shoot, this)));
+    }
+
+    void InvaderEnemyShooter::tick(float dt)
+    {
+        lifetime += dt;
+        // die after 20 seconds.
+        if (lifetime > 20000)
+            removeHealth(2000);
+
+        if (player != NULL)
+        {
+            float distPlayer = player->getPosition().z - getPosition().z;
+            // orxout() << "i'm different!" << endl;
+            float newZ = 2/(pow(abs(getPosition().x - player->getPosition().x) * 0.01, 2) + 1) * distPlayer;
+            setVelocity(Vector3(950 - abs(distPlayer), 0, newZ));
+        }
+        Pawn::tick(dt);
+    }
+
+    void InvaderEnemyShooter::shoot()
+    {
+        ControllableEntity::fire(0);
+    }
+
+    void InvaderEnemyShooter::damage(float damage, float healthdamage, float shielddamage, Pawn* originator)
+    {
+        Pawn::damage(damage, healthdamage, shielddamage, originator);
+        if (getGame() && orxonox_cast<InvaderShip*>(originator) != NULL && getHealth() <= 0)
+            getGame()->addPoints(3*42);
+    }
+}
Index: code/trunk/src/modules/invader/InvaderEnemyShooter.h
===================================================================
--- code/trunk/src/modules/invader/InvaderEnemyShooter.h	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderEnemyShooter.h	(revision 9939)
@@ -0,0 +1,58 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderEnemyShooter.h
+    @brief Declaration of the InvaderEnemyShooter class.
+*/
+
+#ifndef _InvaderEnemyShooter_H__
+#define _InvaderEnemyShooter_H__
+
+#include "invader/InvaderPrereqs.h"
+
+#include "invader/InvaderEnemy.h"
+#include "tools/Timer.h"
+
+namespace orxonox
+{
+    class _InvaderExport InvaderEnemyShooter : public InvaderEnemy
+    {
+        public:
+            InvaderEnemyShooter(Context* context);
+
+            virtual void tick(float dt);
+            virtual void damage(float damage, float healthdamage, float shielddamage, Pawn* originator);
+        protected:
+            void shoot();
+            Timer shootTimer;
+
+    };
+}
+
+#endif /* _InvaderEnemyShooter_H__ */
Index: code/trunk/src/modules/invader/InvaderHUDinfo.cc
===================================================================
--- code/trunk/src/modules/invader/InvaderHUDinfo.cc	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderHUDinfo.cc	(revision 9939)
@@ -0,0 +1,137 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *
+ */
+
+#include "InvaderHUDinfo.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "util/Convert.h"
+// #include "Invader.h"
+
+namespace orxonox
+{
+    RegisterClass(InvaderHUDinfo);
+
+    InvaderHUDinfo::InvaderHUDinfo(Context* context) : OverlayText(context)
+    {
+        RegisterObject(InvaderHUDinfo);
+
+        this->InvaderGame = 0;
+        this->bShowLives_ = false;
+        this->bShowLevel_ = false;
+        this->bShowPoints_ = false;
+        this->bShowMultiplier_ = false;
+    }
+
+    void InvaderHUDinfo::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(InvaderHUDinfo, XMLPort, xmlelement, mode);
+
+        XMLPortParam(InvaderHUDinfo, "showlives",     setShowLives,     getShowLives,     xmlelement, mode).defaultValues(false);
+        XMLPortParam(InvaderHUDinfo, "showPoints",     setShowPoints,     getShowPoints,     xmlelement, mode).defaultValues(false);
+        XMLPortParam(InvaderHUDinfo, "showLevel",     setShowLevel,     getShowLevel,     xmlelement, mode).defaultValues(false);
+        XMLPortParam(InvaderHUDinfo, "showMultiplier",     setShowMultiplier,     getShowMultiplier,     xmlelement, mode).defaultValues(false);
+    }
+
+    void InvaderHUDinfo::tick(float dt)
+    {
+        SUPER(InvaderHUDinfo, tick, dt);
+
+        if (this->InvaderGame)
+        {
+            if (this->bShowLives_)
+            {
+                const std::string& lives = multi_cast<std::string>(this->InvaderGame->getLives());
+                this->setCaption(lives);
+            }
+            else if(this->bShowLevel_)
+            {
+                const std::string& Level = multi_cast<std::string>(this->InvaderGame->getLevel());
+                if (this->InvaderGame->lives <= 0)
+                {
+                    setPosition(Vector2(0.1, 0.65));
+                    this->setCaption("Game ends in 30 seconds.\nPress (e)xit / (q)uit to go to the main menu.\nTo restart fly out of the screen!");
+                    setTextSize(0.05);
+                    this->InvaderGame->bEndGame = true;
+                }
+                else if (this->InvaderGame->bShowLevel)
+                {
+                    setTextSize(0.1);
+                    setPosition(Vector2(0.3, 0.55));
+                    std::stringstream sstm;
+                    sstm << "Level " << Level;
+                    this->setCaption(sstm.str()); // + level
+                }
+                else
+                {
+                    setTextSize(0.04);
+                    setPosition(Vector2(0.14, 0.055));
+                    this->setCaption(Level);
+                }
+            }
+            else if(this->bShowPoints_)
+            {
+                const std::string& points = multi_cast<std::string>(this->InvaderGame->getPoints());
+                if (this->InvaderGame->lives <= 0)
+                {
+                    setTextSize(0.2);
+                    setPosition(Vector2(0.1, 0.25));
+                    this->setCaption("Final score:\n" + points);
+                    this->setColour(ColourValue(1, 0, 0, 1));
+                }
+                else
+                {
+                    setTextSize(0.04);
+                    setPosition(Vector2(0.14, 0.1));
+                    this->setColour(ColourValue(1, 1, 1, 1));
+                    this->setCaption(points);
+                }
+            }
+            else if(this->bShowMultiplier_)
+            {
+                int mult = this->InvaderGame->getMultiplier();
+                const std::string& Multiplier = "X " + multi_cast<std::string>(mult);
+                this->setCaption(Multiplier);
+                this->setColour(ColourValue(1, 0, 0, clamp(float(mult * 0.1), 0.0f, 1.0f)));
+                this->setTextSize(clamp(float(mult * 0.1), 0.0f, 1.0f) * 0.01 + 0.04);
+            }
+        }
+    }
+
+    void InvaderHUDinfo::changedOwner()
+    {
+        SUPER(InvaderHUDinfo, changedOwner);
+
+        if (this->getOwner() && this->getOwner()->getGametype())
+        {
+            this->InvaderGame = orxonox_cast<Invader*>(this->getOwner()->getGametype().get());
+        }
+        else
+        {
+            this->InvaderGame = 0;
+        }
+    }
+}
Index: code/trunk/src/modules/invader/InvaderHUDinfo.h
===================================================================
--- code/trunk/src/modules/invader/InvaderHUDinfo.h	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderHUDinfo.h	(revision 9939)
@@ -0,0 +1,75 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *
+ */
+
+#ifndef _InvaderHUDinfo_H__
+#define _InvaderHUDinfo_H__
+
+#include "overlays/OverlaysPrereqs.h"
+
+#include "tools/interfaces/Tickable.h"
+#include "overlays/OverlayText.h"
+
+namespace orxonox
+{
+    class _OverlaysExport InvaderHUDinfo : public OverlayText, public Tickable
+    {
+        public:
+            InvaderHUDinfo(Context* context);
+
+            virtual void tick(float dt);
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void changedOwner();
+
+            inline void setShowLives(bool value)
+                { this->bShowLives_ = value; }
+            inline bool getShowLives() const
+                { return this->bShowLives_; }
+
+            inline void setShowLevel(bool value)
+                { this->bShowLevel_ = value; }
+            inline bool getShowLevel() const
+                { return this->bShowLevel_; }
+
+            inline void setShowPoints(bool value)
+                { this->bShowPoints_ = value; }
+            inline bool getShowPoints() const
+                { return this->bShowPoints_; }
+
+            inline void setShowMultiplier(bool value)
+                { this->bShowMultiplier_ = value; }
+            inline bool getShowMultiplier() const
+                { return this->bShowMultiplier_; }
+
+
+        private:
+            Invader* InvaderGame;
+            bool bShowLives_;
+            bool bShowLevel_;
+            bool bShowPoints_;
+            bool bShowMultiplier_;
+    };
+}
+#endif /* _InvaderHUDinfo_H__ */
Index: code/trunk/src/modules/invader/InvaderPrereqs.h
===================================================================
--- code/trunk/src/modules/invader/InvaderPrereqs.h	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderPrereqs.h	(revision 9939)
@@ -0,0 +1,80 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the Invader module
+*/
+
+#ifndef _InvaderPrereqs_H__
+#define _InvaderPrereqs_H__
+
+#include "OrxonoxConfig.h"
+#include "OrxonoxPrereqs.h"
+
+//-----------------------------------------------------------------------
+// Shared library settings
+//-----------------------------------------------------------------------
+
+#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(Invader_STATIC_BUILD)
+#  ifdef Invader_SHARED_BUILD
+#    define _InvaderExport __declspec(dllexport)
+#  else
+#    if defined( __MINGW32__ )
+#      define _InvaderExport
+#    else
+#      define _InvaderExport __declspec(dllimport)
+#    endif
+#  endif
+#  define _InvaderPrivate
+#elif defined (ORXONOX_GCC_VISIBILITY)
+#  define _InvaderExport  __attribute__ ((visibility("default")))
+#  define _InvaderPrivate __attribute__ ((visibility("hidden")))
+#else
+#  define _InvaderExport
+#  define _InvaderPrivate
+#endif
+
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+
+namespace orxonox
+{
+    class Invader;
+    class InvaderCenterPoint;
+    class InvaderShip;
+    class InvaderEnemy;
+    class InvaderEnemyShooter;
+    class InvaderWeapon;
+    class InvaderWeaponEnemy;
+    class InvaderHUDinfo;
+}
+
+#endif /* _InvaderPrereqs_H__ */
Index: code/trunk/src/modules/invader/InvaderShip.cc
===================================================================
--- code/trunk/src/modules/invader/InvaderShip.cc	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderShip.cc	(revision 9939)
@@ -0,0 +1,188 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderShip.cc
+    @brief Implementation of the InvaderShip class.
+*/
+
+#include "InvaderShip.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "Invader.h"
+
+namespace orxonox
+{
+    RegisterClass(InvaderShip);
+
+    InvaderShip::InvaderShip(Context* context) : SpaceShip(context)
+    {
+        RegisterObject(InvaderShip);
+
+        speed = 500;
+        isFireing = false;
+        damping = 10;
+    }
+
+    void InvaderShip::tick(float dt)
+    {
+        Vector3 pos = getPosition();
+
+        //Movement calculation
+        lastTimeFront += dt * damping;
+        lastTimeLeft += dt * damping;
+        lastTime += dt;
+
+        velocity.x = interpolate(clamp(lastTimeLeft, 0.0f, 1.0f), desiredVelocity.x, 0.0f);
+        velocity.y = interpolate(clamp(lastTimeFront, 0.0f, 1.0f), desiredVelocity.y, 0.0f);
+
+        //Execute movement
+        if (this->hasLocalController())
+        {
+            float dist_y = velocity.y * dt;
+            float dist_x = velocity.x * dt;
+            if(dist_y + posforeward > -42*3 && dist_y + posforeward < 42*6)
+                posforeward += dist_y;
+            else
+            {
+                velocity.y = 0;
+                // restart if game ended
+                if (getGame())
+                    if (getGame()->bEndGame)
+                    {
+                        getGame()->start();
+                        return;
+                    }
+            }
+            if (pos.z + dist_x > 42*2.5 || pos.z + dist_x < -42*3)
+                velocity.x = 0;
+            pos += Vector3(1000 + velocity.y, 0, velocity.x) * dt;
+        }
+
+        // shoot!
+        if (isFireing)
+            ControllableEntity::fire(0);
+
+        // Camera
+        WeakPtr<Camera> camera = this->getCamera();
+        if (camera != NULL)
+        {
+            camera->setPosition(Vector3(-pos.z, -posforeward, 0));
+            camera->setOrientation(Vector3::UNIT_Z, Degree(90));
+        }
+
+
+
+        // bring back on track!
+        if(pos.y != 0)
+            pos.y = 0;
+
+        setPosition(pos);
+        setOrientation(Vector3::UNIT_Y, Degree(270));
+
+        // Level up!
+        if (pos.x > 42000)
+        {
+            updateLevel();
+            setPosition(Vector3(0, 0, pos.z)); // pos - Vector3(30000, 0, 0)
+        }
+
+        SUPER(InvaderShip, tick, dt);
+    }
+
+    void InvaderShip::updateLevel()
+    {
+        lastTime = 0;
+        if (getGame())
+            getGame()->levelUp();
+    }
+
+    void InvaderShip::moveFrontBack(const Vector2& value)
+    {
+        lastTimeLeft = 0;
+        desiredVelocity.x = -value.x * speed;
+    }
+
+    void InvaderShip::moveRightLeft(const Vector2& value)
+    {
+        lastTimeFront = 0;
+        desiredVelocity.y = value.y * speed * 42;
+    }
+    void InvaderShip::boost(bool bBoost)
+    {
+        isFireing = bBoost;
+    }
+    inline bool InvaderShip::collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
+    {
+        // orxout() << "touch!!! " << endl; //<< otherObject << " at " << contactPoint;
+        WeakPtr<InvaderEnemy> enemy = orxonox_cast<InvaderEnemy*>(otherObject);
+        WeakPtr<Projectile> shot = orxonox_cast<Projectile*>(otherObject);
+        // ensure that this gets only called once per enemy.
+        if (enemy != NULL && lastEnemy != enemy)
+        {
+            lastEnemy = enemy;
+
+            removeHealth(20);
+            if (getGame())
+            {
+                getGame()->multiplier = 1;                   
+            }
+        }
+        // was shot, decrease multiplier
+        else if (shot != NULL  && lastShot != shot)
+        {
+            if (getGame() && orxonox_cast<InvaderEnemy*>(shot->getShooter()) != NULL)
+            {
+                if (getGame()->multiplier > 1)
+                {
+                    lastShot = shot;
+                    getGame()->multiplier -= 1;     
+                }
+            }
+        }
+        return false;
+        // SUPER(InvaderShip, collidesAgainst, otherObject, contactPoint);
+    }
+
+    WeakPtr<Invader> InvaderShip::getGame()
+    {
+        if (game == NULL)
+        {
+            for (ObjectList<Invader>::iterator it = ObjectList<Invader>::begin(); it != ObjectList<Invader>::end(); ++it)
+                game = *it;
+        }
+        return game;
+    }
+
+    void InvaderShip::death()
+    {
+        getGame()->costLife();
+        SpaceShip::death();
+    }
+}
Index: code/trunk/src/modules/invader/InvaderShip.h
===================================================================
--- code/trunk/src/modules/invader/InvaderShip.h	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderShip.h	(revision 9939)
@@ -0,0 +1,90 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderShip.h
+    @brief Declaration of the InvaderShip class.
+*/
+
+#ifndef _InvaderShip_H__
+#define _InvaderShip_H__
+
+#include "invader/InvaderPrereqs.h"
+
+#include "worldentities/pawns/SpaceShip.h"
+#include "graphics/Camera.h"
+#include "weapons/projectiles/Projectile.h"
+
+namespace orxonox
+{
+    class _InvaderExport InvaderShip : public SpaceShip
+    {
+        public:
+            InvaderShip(Context* context);
+
+            virtual void tick(float dt);
+
+            // overwrite for 2d movement
+            virtual void moveFrontBack(const Vector2& value);
+            virtual void moveRightLeft(const Vector2& value);
+
+            // Starts or stops fireing
+            virtual void boost(bool bBoost);
+
+            //no rotation!
+            virtual void rotateYaw(const Vector2& value){}; 
+            virtual void rotatePitch(const Vector2& value){};
+            //return to main menu if game has ended.
+            virtual void rotateRoll(const Vector2& value){if (getGame()) if (getGame()->bEndGame) getGame()->end();};
+
+            virtual void updateLevel();
+
+            virtual inline bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
+
+        protected:
+            virtual void death();
+        private:
+            WeakPtr<Invader> getGame();
+            WeakPtr<Invader> game;
+            Camera* camera;
+            bool isFireing;
+            float speed, damping, posforeward;
+            float lastTimeFront, lastTimeLeft, lastTime;
+            struct Velocity
+            {
+                float x;
+                float y;
+            } velocity, desiredVelocity;
+
+            WeakPtr<InvaderEnemy> lastEnemy;
+            WeakPtr<Projectile> lastShot;
+
+    };
+}
+
+#endif /* _InvaderShip_H__ */
Index: code/trunk/src/modules/invader/InvaderWeapon.cc
===================================================================
--- code/trunk/src/modules/invader/InvaderWeapon.cc	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderWeapon.cc	(revision 9939)
@@ -0,0 +1,88 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      --
+ *
+ */
+
+/**
+    @file InvaderWeapon.h
+    @brief Implementation of the InvaderWeapon class.
+*/
+
+#include "InvaderWeapon.h"
+
+#include "core/CoreIncludes.h"
+// #include "core/XMLPort.h"
+// #include "core/command/Executor.h"
+
+#include "graphics/Model.h"
+#include "weaponsystem/Weapon.h"
+#include "weaponsystem/WeaponPack.h"
+#include "weaponsystem/WeaponSystem.h"
+#include "worldentities/WorldEntity.h"
+#include "worldentities/pawns/Pawn.h"
+
+#include "weapons/projectiles/Projectile.h"
+#include "weapons/MuzzleFlash.h"
+
+namespace orxonox
+{
+    RegisterClass(InvaderWeapon);
+
+    InvaderWeapon::InvaderWeapon(Context* context) : HsW01(context)
+    {
+        RegisterObject(InvaderWeapon);
+    }
+
+    InvaderWeapon::~InvaderWeapon(){}
+
+    void InvaderWeapon::shot()
+    {
+        assert( this->getWeapon() && this->getWeapon()->getWeaponPack() && this->getWeapon()->getWeaponPack()->getWeaponSystem() && this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn() );
+
+        // Create the projectile.projectile
+        projectile = new Projectile(this->getContext());
+        WeakPtr<Model> model = new Model(projectile->getContext());
+        model->setMeshSource(mesh_);
+        model->setCastShadows(false);
+        projectile->attach(model);
+        model->setScale(5);
+
+        this->computeMuzzleParameters(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn()->getAimPosition());
+        // only shoot in foreward direction
+        projectile->setOrientation(Quaternion(sqrt(0.5),0,sqrt(0.5),0));
+        projectile->setPosition(this->getMuzzlePosition());
+        // only shoot in foreward direction
+        projectile->setVelocity(Vector3(1, 0, 0) * 2000);
+
+        projectile->setShooter(this->getWeapon()->getWeaponPack()->getWeaponSystem()->getPawn());
+        projectile->setDamage(this->getDamage());
+        projectile->setShieldDamage(this->getShieldDamage());
+        projectile->setHealthDamage(this->getHealthDamage());
+
+        // Display the muzzle flash.
+        this->InvaderWeapon::muzzleflash();
+    }
+}
Index: code/trunk/src/modules/invader/InvaderWeapon.h
===================================================================
--- code/trunk/src/modules/invader/InvaderWeapon.h	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderWeapon.h	(revision 9939)
@@ -0,0 +1,55 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderWeapon.h
+    @brief Definition of the InvaderWeapon class.
+*/
+
+#ifndef _InvaderWeapon_H__
+#define _InvaderWeapon_H__
+
+#include "weapons/weaponmodes/HsW01.h"
+#include "weapons/WeaponsPrereqs.h"
+
+#include "tools/Timer.h"
+
+namespace orxonox
+{
+    class _InvaderExport InvaderWeapon : public HsW01
+    {
+        public:
+            InvaderWeapon(Context* context);
+            virtual ~InvaderWeapon();
+        protected:
+            virtual void shot();
+            WeakPtr<Projectile> projectile;
+    };
+}
+
+#endif /* _InvaderWeapon_H__ */
Index: code/trunk/src/modules/invader/InvaderWeaponEnemy.cc
===================================================================
--- code/trunk/src/modules/invader/InvaderWeaponEnemy.cc	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderWeaponEnemy.cc	(revision 9939)
@@ -0,0 +1,55 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      --
+ *
+ */
+
+/**
+    @file InvaderWeaponEnemy.h
+    @brief Implementation of the InvaderWeaponEnemy class.
+*/
+
+#include "InvaderWeaponEnemy.h"
+
+namespace orxonox
+{
+    RegisterClass(InvaderWeaponEnemy);
+
+    InvaderWeaponEnemy::InvaderWeaponEnemy(Context* context) : InvaderWeapon(context)
+    {
+        RegisterObject(InvaderWeaponEnemy);
+    }
+
+    void InvaderWeaponEnemy::shot()
+    {
+    	InvaderWeapon::shot();
+        // SUPER(InvaderWeaponEnemy, shot);
+        // only shoot in foreward direction
+        projectile->setVelocity(Vector3(1, 0, 0) * 300);
+        // projectile->setOrientation(Quaternion(sqrt(0.5),0,sqrt(0.5),0));
+    }
+}
+
+
Index: code/trunk/src/modules/invader/InvaderWeaponEnemy.h
===================================================================
--- code/trunk/src/modules/invader/InvaderWeaponEnemy.h	(revision 9939)
+++ code/trunk/src/modules/invader/InvaderWeaponEnemy.h	(revision 9939)
@@ -0,0 +1,53 @@
+/*
+ *   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:
+ *      Florian Zinggeler
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file InvaderWeaponEnemy.h
+    @brief Definition of the InvaderWeaponEnemy class.
+*/
+
+#ifndef _InvaderWeaponEnemy_H__
+#define _InvaderWeaponEnemy_H__
+
+// #include "weapons/weaponmodes/HsW01.h"
+// #include "weapons/WeaponsPrereqs.h"
+#include "invader/InvaderWeapon.h"
+#include "tools/Timer.h"
+
+namespace orxonox
+{
+    class _InvaderExport InvaderWeaponEnemy : public InvaderWeapon
+    {
+        public:
+            InvaderWeaponEnemy(Context* context);
+        protected:
+            virtual void shot();
+    };
+}
+
+#endif /* _InvaderWeaponEnemy_H__ */
Index: code/trunk/src/modules/objects/ForceField.cc
===================================================================
--- code/trunk/src/modules/objects/ForceField.cc	(revision 9834)
+++ code/trunk/src/modules/objects/ForceField.cc	(revision 9939)
@@ -45,7 +45,11 @@
     /*static*/ const std::string ForceField::modeSphere_s = "sphere";
     /*static*/ const std::string ForceField::modeInvertedSphere_s = "invertedSphere";
+
+    /*static*/ const std::string ForceField::modeHomogen_s = "homogen";
+
     /*static*/ const std::string ForceField::modeNewtonianGravity_s = "newtonianGravity";
     /*static*/ const float ForceField::gravConstant_ = 6.673e-11;
     /*static*/ const float ForceField::attenFactor_ = 1;
+
 
     /**
@@ -89,4 +93,5 @@
         XMLPortParam(ForceField, "length", setLength  , getLength  , xmlelement, mode).defaultValues(2000);
         XMLPortParam(ForceField, "mode", setMode, getMode, xmlelement, mode);
+        XMLPortParam(ForceField, "forcedirection", setForceDirection, getForceDirection, xmlelement, mode).defaultValues(Vector3(0,-400,0));
     }
     
@@ -196,4 +201,19 @@
             }
         }
+        else if(this->mode_ == forceFieldMode::homogen)
+        {
+        	// Iterate over all objects that could possibly be affected by the ForceField.
+        	for (ObjectList<MobileEntity>::iterator it = ObjectList<MobileEntity>::begin(); it != ObjectList<MobileEntity>::end(); ++it)
+        	{
+        		Vector3 distanceVector = it->getWorldPosition() - this->getWorldPosition();
+        	    float distance = distanceVector.length();
+        	    if (distance < this->radius_ && distance > this->massRadius_)
+        	    {
+        	    	// Add a Acceleration in forceDirection_.
+        	    	// Vector3(0,0,0) is the direction, where the force should work.
+        	    	it->addAcceleration(forceDirection_ , Vector3(0,0,0));
+        	    }
+        	}
+        }
     }
 
@@ -214,4 +234,8 @@
         else if(mode == ForceField::modeNewtonianGravity_s)
             this->mode_ = forceFieldMode::newtonianGravity;
+
+        else if(mode == ForceField::modeHomogen_s)
+            this->mode_ = forceFieldMode::homogen;
+
         else
         {
@@ -239,4 +263,8 @@
             case forceFieldMode::newtonianGravity:
                 return ForceField::modeNewtonianGravity_s;
+
+            case forceFieldMode::homogen:
+                return ForceField::modeHomogen_s;
+
             default:
                 return ForceField::modeTube_s;
Index: code/trunk/src/modules/objects/ForceField.h
===================================================================
--- code/trunk/src/modules/objects/ForceField.h	(revision 9834)
+++ code/trunk/src/modules/objects/ForceField.h	(revision 9939)
@@ -1,2 +1,3 @@
+
 /*
  *   ORXONOX - the hottest 3D action shooter ever to exist
@@ -57,5 +58,6 @@
             sphere, //!< The ForceField has a spherical shape.
             invertedSphere, //!< The ForceField has a spherical shape but "inverted" behavior.
-            newtonianGravity //!< The ForceField imitates Newtonian gravitation for use in stellar bodies.
+            newtonianGravity, //!< The ForceField imitates Newtonian gravitation for use in stellar bodies.
+            homogen //!< Local homogenous Force field with changeable direction for the Space Station
         };
     }
@@ -66,4 +68,5 @@
 
         The following parameters can be set to specify the behavior of the ForceField.
+        - @b forcedirection The direction and the strength of the homogenous force field. Default is 0,-400,0.
         - @b velocity The amount of force the ForceField excerts. Default is 100.
         - @b diameter The diameter of the ForceField. Default is 500.
@@ -147,4 +150,11 @@
                 { return this->halfLength_*2; }
 
+            inline void setForceDirection(Vector3 forcedir)
+                { this->forceDirection_ = forcedir; }
+
+            inline Vector3 getForceDirection()
+                { return this->forceDirection_; }
+
+
             void setMode(const std::string& mode); //!< Set the mode of the ForceField.
             const std::string& getMode(void); //!< Get the mode of the ForceField.
@@ -156,4 +166,6 @@
             static const std::string modeInvertedSphere_s;
             static const std::string modeNewtonianGravity_s;
+
+            static const std::string modeHomogen_s;
 
             float velocity_; //!< The velocity of the ForceField.
@@ -167,4 +179,5 @@
             //! Attenuation factor for Newtonian ForceFields
             static const float attenFactor_;
+            Vector3 forceDirection_;
   };
 }
Index: code/trunk/src/modules/overlays/OverlaysPrereqs.h
===================================================================
--- code/trunk/src/modules/overlays/OverlaysPrereqs.h	(revision 9834)
+++ code/trunk/src/modules/overlays/OverlaysPrereqs.h	(revision 9939)
@@ -80,4 +80,5 @@
     class BarColour;
     class ChatOverlay;
+    class CountDown;
     class DeathMessage;
     class GametypeFadingMessage;
Index: code/trunk/src/modules/overlays/debugging/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/overlays/debugging/CMakeLists.txt	(revision 9834)
+++ code/trunk/src/modules/overlays/debugging/CMakeLists.txt	(revision 9939)
@@ -2,3 +2,4 @@
   DebugFPSText.cc
   DebugRTRText.cc
+  DebugPositionText.cc
 )
Index: code/trunk/src/modules/overlays/debugging/DebugPositionText.cc
===================================================================
--- code/trunk/src/modules/overlays/debugging/DebugPositionText.cc	(revision 9939)
+++ code/trunk/src/modules/overlays/debugging/DebugPositionText.cc	(revision 9939)
@@ -0,0 +1,61 @@
+/*
+ *   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:
+ *      Johannes Ritz
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "DebugPositionText.h"
+
+#include "util/Convert.h"
+#include "core/CoreIncludes.h"
+#include "core/Game.h"
+
+#include "controllers/NewHumanController.h"
+
+namespace orxonox
+{
+    RegisterClass(DebugPositionText);
+
+    DebugPositionText::DebugPositionText(Context* context) : OverlayText(context)
+    {
+        RegisterObject(DebugPositionText);
+    }
+
+    DebugPositionText::~DebugPositionText()
+    {
+    }
+
+    void DebugPositionText::tick(float dt)
+    {
+        SUPER(DebugPositionText, tick, dt);
+        
+        ObjectList<NewHumanController>::iterator it = ObjectList<NewHumanController>::begin();
+        if (it && it->getControllableEntity() )
+        {
+            Vector3 pos = it->getControllableEntity()->getPosition();
+            this->setCaption(multi_cast<std::string>(pos));
+        }
+    }
+}
Index: code/trunk/src/modules/overlays/debugging/DebugPositionText.h
===================================================================
--- code/trunk/src/modules/overlays/debugging/DebugPositionText.h	(revision 9939)
+++ code/trunk/src/modules/overlays/debugging/DebugPositionText.h	(revision 9939)
@@ -0,0 +1,48 @@
+/*
+ *   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:
+ *      Johannes Ritz
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _DebugPositionText_H__
+#define _DebugPositionText_H__
+
+#include "overlays/OverlaysPrereqs.h"
+
+#include "tools/interfaces/Tickable.h"
+#include "overlays/OverlayText.h"
+
+namespace orxonox
+{
+    class _OverlaysExport DebugPositionText : public OverlayText, public Tickable
+    {
+    public:
+        DebugPositionText(Context* context);
+        virtual ~DebugPositionText();
+
+        virtual void tick(float dt);
+    };
+}
+#endif /* _DebugPositionText_H__ */
Index: code/trunk/src/modules/overlays/hud/CMakeLists.txt
===================================================================
--- code/trunk/src/modules/overlays/hud/CMakeLists.txt	(revision 9834)
+++ code/trunk/src/modules/overlays/hud/CMakeLists.txt	(revision 9939)
@@ -18,3 +18,4 @@
   PauseNotice.cc
   LastTeamStandingInfos.cc
+  CountDown.cc
 )
Index: code/trunk/src/modules/overlays/hud/CountDown.cc
===================================================================
--- code/trunk/src/modules/overlays/hud/CountDown.cc	(revision 9939)
+++ code/trunk/src/modules/overlays/hud/CountDown.cc	(revision 9939)
@@ -0,0 +1,113 @@
+/*
+ *   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:
+ *      Johannes Ritz
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file CountDown.cc
+    @brief Countdown HUD element, counting down from CountDown::counter_ to zero.
+    
+    In use it would like this:
+        @code
+        <OverlayGroup name="spacefightHUD" scale = "1, 1">
+          <CountDown
+              position    = "0.49, 0.05"
+              pickpoint   = "0.0, 0.0"
+              font        = "ShareTechMono"
+              textsize    = 0.06
+              colour      = "1.0, 1.0, 1.0, 1.0"
+              align       = "right"                  
+              counter     = "10.0"
+              speedfactor = "1.0"
+              active      = "false"
+           >
+            <events>
+              <activity>
+                <EventListener event="startcounting" />
+              </activity>
+            </events>
+          </CountDown>
+        </OverlayGroup>
+        @endcode
+        The counter is triggered by an event called "startcounting" and counts from 10 to 0.
+*/
+
+#include "CountDown.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+#include "infos/PlayerInfo.h"
+#include "util/Convert.h"
+
+namespace orxonox
+{
+    RegisterClass(CountDown);
+
+    CountDown::CountDown(Context* context) : OverlayText(context)
+    {
+        RegisterObject(CountDown);
+
+        this->owner_ = 0;
+        this->hasStopped_ = false;
+    }
+    
+    CountDown::~CountDown()
+    {
+    }
+    
+    void CountDown::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(CountDown, XMLPort, xmlelement, mode);
+        XMLPortParam(CountDown, "counter", setCounter, getCounter, xmlelement, mode).defaultValues(10);
+        XMLPortParam(CountDown, "speedfactor", setSpeed, getSpeed, xmlelement, mode).defaultValues(1);
+    }
+    
+    void CountDown::tick(float dt)
+    {
+        SUPER(CountDown, tick, dt);
+        if (this->isActive() && !this->hasStopped_)
+        {
+            if (this->counter_ <= 0)
+            {
+                this->counter_ = 0;
+                this->hasStopped_ = true;
+                this->setCaption("");
+            }
+            else
+            {
+                this->counter_ -= dt*speed_;
+                this->setCaption(multi_cast<std::string>((int)this->counter_)); //TODO: evtl. initialize with +0.5f
+            }
+        }
+    }
+
+    void CountDown::changedOwner()
+    {
+        SUPER(CountDown, changedOwner);
+
+        this->owner_ = orxonox_cast<PlayerInfo*>(this->getOwner());
+    }
+}
Index: code/trunk/src/modules/overlays/hud/CountDown.h
===================================================================
--- code/trunk/src/modules/overlays/hud/CountDown.h	(revision 9939)
+++ code/trunk/src/modules/overlays/hud/CountDown.h	(revision 9939)
@@ -0,0 +1,68 @@
+/*
+ *   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:
+ *      Johannes Ritz
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _CountDown_H__
+#define _CountDown_H__
+
+#include "overlays/OverlaysPrereqs.h"
+
+#include "tools/interfaces/TimeFactorListener.h"
+#include "tools/interfaces/Tickable.h"
+#include "overlays/OverlayText.h"
+
+namespace orxonox
+{
+    class _OverlaysExport CountDown : public OverlayText, public Tickable
+    {
+        public:
+            CountDown(Context* context);
+            virtual ~CountDown();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void changedOwner();
+            virtual void tick(float dt);
+
+            inline void setCounter(float value)
+                { this->counter_ = value + 0.99f; }
+            inline float getCounter() const
+                { return this->counter_; }
+            inline void setSpeed(float value)
+                { this->speed_ = value; }
+            inline float getSpeed() const
+                { return this->speed_; }
+                
+        protected:
+
+        private:
+            PlayerInfo* owner_;
+            float counter_;
+            float speed_;
+            bool hasStopped_;
+    };
+}
+#endif /* _CountDown_H__ */
Index: code/trunk/src/modules/overlays/hud/HUDNavigation.cc
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDNavigation.cc	(revision 9834)
+++ code/trunk/src/modules/overlays/hud/HUDNavigation.cc	(revision 9939)
@@ -74,6 +74,6 @@
         OrxonoxOverlay(context)
     {
-        RegisterObject(HUDNavigation)
-;        this->setConfigValues();
+        RegisterObject(HUDNavigation);
+        this->setConfigValues();
 
         // Set default values
Index: code/trunk/src/modules/overlays/hud/HUDRadar.cc
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDRadar.cc	(revision 9834)
+++ code/trunk/src/modules/overlays/hud/HUDRadar.cc	(revision 9939)
@@ -25,4 +25,5 @@
  *   Co-authors:
  *      Reto Grieder
+ *      Wolfgang Roenninger
  *
  */
@@ -41,4 +42,5 @@
 #include "Scene.h"
 #include "Radar.h"
+#include "core/config/ConfigValueIncludes.h"
 
 namespace orxonox
@@ -50,4 +52,5 @@
     {
         RegisterObject(HUDRadar);
+        this->setConfigValues();
 
         this->marker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
@@ -60,10 +63,23 @@
         this->setHalfDotSizeDistance(3000.0f);
         this->setMaximumDotSize(0.1f);
+        this->setMaximumDotSize3D(0.07f);
 
         this->shapeMaterials_[RadarViewable::Dot]      = "RadarDot.png";
         this->shapeMaterials_[RadarViewable::Triangle] = "RadarTriangle.png";
         this->shapeMaterials_[RadarViewable::Square]   = "RadarSquare.png";
-        this->setDetectionLimit( 10000.0f );
         this->owner_ = 0;
+
+        this->map3DFront_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+        	.createOverlayElement("Panel", "HUDRadar_mapDreiDFront_" + getUniqueNumberString()));
+        this->map3DFront_->setMaterialName("Orxonox/Radar3DFront");
+        this->overlay_->add2D(this->map3DFront_);
+        this->map3DFront_->hide();
+
+        this->map3DBack_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+        	.createOverlayElement("Panel", "HUDRadar_mapDreiDBack_" + getUniqueNumberString()));
+        this->map3DBack_->setMaterialName("Orxonox/Radar3DBack");
+        this->overlay_->add2D(this->map3DBack_);
+        this->map3DBack_->hide();
+
     }
 
@@ -73,4 +89,7 @@
         {
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->marker_);
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->map3DFront_);
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->map3DBack_);
+
             for (std::map<RadarViewable*,Ogre::PanelOverlayElement*>::iterator it = this->radarObjects_.begin();
                 it != this->radarObjects_.end(); ++it)
@@ -80,4 +99,11 @@
         }
     }
+
+
+
+    void HUDRadar::setConfigValues()
+       {
+           SetConfigValue(RadarMode_, true);
+       }
 
     void HUDRadar::XMLPort(Element& xmlelement, XMLPort::Mode mode)
@@ -88,4 +114,11 @@
         XMLPortParam(HUDRadar, "halfDotSizeDistance", setHalfDotSizeDistance, getHalfDotSizeDistance, xmlelement, mode);
         XMLPortParam(HUDRadar, "maximumDotSize", setMaximumDotSize, getMaximumDotSize, xmlelement, mode);
+        XMLPortParam(HUDRadar, "maximumDotSize3D", setMaximumDotSize3D, getMaximumDotSize3D, xmlelement, mode);
+        XMLPortParam(HUDRadar, "material2D", set2DMaterial, get2DMaterial, xmlelement, mode);
+        XMLPortParam(HUDRadar, "material3DMiddle", set3DMaterial, get3DMaterial, xmlelement, mode);
+        XMLPortParam(HUDRadar, "material3DFront", set3DMaterialFront, get3DMaterialFront, xmlelement, mode);
+        XMLPortParam(HUDRadar, "material3DBack", set3DMaterialBack, get3DMaterialBack, xmlelement, mode);
+        XMLPortParam(HUDRadar, "mapAngle3D", setMapAngle, getMapAngle, xmlelement, mode);
+        XMLPortParam(HUDRadar, "detectionLimit", setDetectionLimit, getDetectionLimit, xmlelement, mode);
     }
 
@@ -152,4 +185,21 @@
         // update the distances for all objects
         std::map<RadarViewable*,Ogre::PanelOverlayElement*>::iterator it;
+
+
+        if(RadarMode_)
+        {
+        	this->setBackgroundMaterial(material3D_);
+        	this->map3DFront_->_notifyZOrder(this->overlay_->getZOrder() * 100 + 250); // it seems that the ZOrder of overlayelements is 100 times the ZOrder of the overlay
+        	this->map3DBack_->_notifyZOrder(this->overlay_->getZOrder() * 100 - 250); // 250 a little bit buffer so that the two shels are displayed all in the front / in the back
+        	this->map3DFront_->show();
+        	this->map3DBack_->show();
+        }
+        else
+        {
+        	this->setBackgroundMaterial(material2D_);
+        	this->map3DFront_->hide();
+        	this->map3DBack_->hide();
+        }
+
         for( it = this->radarObjects_.begin(); it != this->radarObjects_.end(); ++it )
         {
@@ -165,11 +215,34 @@
             float distance = (wePointer->getWorldPosition() - this->owner_->getPosition()).length();
             // calculate the size with 1/distance dependency for simplicity (instead of exp(-distance * lambda)
-            float size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * it->first->getRadarObjectScale();
+
+            float size;
+            if(RadarMode_)
+            	size = maximumDotSize3D_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * it->first->getRadarObjectScale();
+            else
+            	size = maximumDotSize_ * halfDotSizeDistance_ / (halfDotSizeDistance_ + distance) * it->first->getRadarObjectScale();
             it->second->setDimensions(size, size);
 
             // calc position on radar...
-            Vector2 coord = get2DViewcoordinates(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition());
+            Vector2 coord;
+
+            if(RadarMode_)
+            {
+            	coord = get3DProjection(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition(), 0.6435011, detectionLimit_);
+
+            	// set zOrder on screen
+            	bool overXZPlain = isObjectHigherThanShipOnMap(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition(), this->mapAngle_);
+
+            	int zOrder = determineMap3DZOrder(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition(), detectionLimit_);
+            	if(overXZPlain == false /*&& (it->second->getZOrder() >  100 * this->overlay_->getZOrder())*/) // it appears that zOrder of attached Overlayelements is 100 times the zOrder of the Overlay
+            		it->second->_notifyZOrder(this->overlay_->getZOrder() * 100 - 70 + zOrder);
+            	if(overXZPlain == true /*&& (it->second->getZOrder() <= 100 * this->overlay_->getZOrder())*/)
+            		it->second->_notifyZOrder(this->overlay_->getZOrder() * 100 + 70 + zOrder);
+            }
+            else
+            	coord = get2DViewcoordinates(this->owner_->getPosition(), this->owner_->getOrientation() * WorldEntity::FRONT, this->owner_->getOrientation() * WorldEntity::UP, wePointer->getWorldPosition());
+
             coord *= math::pi / 3.5f; // small adjustment to make it fit the texture
             it->second->setPosition((1.0f + coord.x - size) * 0.5f, (1.0f - coord.y - size) * 0.5f);
+
             if( distance < detectionLimit_ || detectionLimit_ < 0 )
                 it->second->show();
@@ -182,4 +255,6 @@
                 this->marker_->setDimensions(size * 1.5f, size * 1.5f);
                 this->marker_->setPosition((1.0f + coord.x - size * 1.5f) * 0.5f, (1.0f - coord.y - size * 1.5f) * 0.5f);
+                if(RadarMode_)
+                	this->marker_->_notifyZOrder(it->second->getZOrder() -1);
                 this->marker_->show();
             }
Index: code/trunk/src/modules/overlays/hud/HUDRadar.h
===================================================================
--- code/trunk/src/modules/overlays/hud/HUDRadar.h	(revision 9834)
+++ code/trunk/src/modules/overlays/hud/HUDRadar.h	(revision 9939)
@@ -35,4 +35,5 @@
 #include <map>
 #include <vector>
+#include <string>
 
 #include "util/OgreForwardRefs.h"
@@ -51,4 +52,5 @@
         virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
         virtual void changedOwner();
+        void setConfigValues();
 
     private:
@@ -57,15 +59,32 @@
         void setHalfDotSizeDistance(float distance) { this->halfDotSizeDistance_ = distance; }
 
-        void setDetectionLimit( float limit )
-        { this->detectionLimit_ = limit; }
-        float getDetectionLimit() const
-        { return this->detectionLimit_; }
+        void setDetectionLimit( float limit ) { this->detectionLimit_ = limit; }
+        float getDetectionLimit() const { return this->detectionLimit_; }
 
         float getMaximumDotSize() const { return this->maximumDotSize_; }
         void setMaximumDotSize(float size) { this->maximumDotSize_ = size; }
 
+        float getMaximumDotSize3D() const { return this->maximumDotSize3D_; }
+        void setMaximumDotSize3D(float size) { this->maximumDotSize3D_ = size;}
+
+        std::string get2DMaterial() const {return this->material2D_; }
+        void set2DMaterial(std::string material2D) { this->material2D_ = material2D; }
+
+        std::string get3DMaterial() const {return this->material3D_; }
+        void set3DMaterial(std::string material3D) { this->material3D_ = material3D; }
+
+        std::string get3DMaterialFront() const {return this->material3DFront_; }
+        void set3DMaterialFront(std::string material3DFront) { this->material3DFront_ = material3DFront; }
+
+        std::string get3DMaterialBack() const {return this->material3DBack_; }
+        void set3DMaterialBack(std::string material3DBack) { this->material3DBack_ = material3DBack; }
+
         float getRadarSensitivity() const { return this->sensitivity_; }
         // used also by RadarListener interface!
         void setRadarSensitivity(float sensitivity) { this->sensitivity_ = sensitivity; }
+
+        // Determines angle between line of sight and x/z-plain on the 3D minimap
+        float getMapAngle() const { return this->mapAngle_; }
+        void setMapAngle(float mapAngle) { this->mapAngle_ = mapAngle; }
 
         // RadarListener interface
@@ -85,6 +104,18 @@
         Ogre::PanelOverlayElement* marker_;
 
+        bool RadarMode_; // Determines, if Radar runs in 3D or 2D Mode
+
         float halfDotSizeDistance_;
         float maximumDotSize_;
+        float maximumDotSize3D_;
+        float mapAngle_;
+
+        std::string material2D_;		//Material name for 2D map
+        std::string material3D_;		//Material names For the 3D minimap
+        std::string material3DFront_;
+        std::string material3DBack_;
+
+        Ogre::PanelOverlayElement* map3DFront_; //Overlayelements for the 3D minimap to be able to draw the points in a semi 3D matter
+        Ogre::PanelOverlayElement* map3DBack_;
 
         float sensitivity_;
Index: code/trunk/src/modules/pong/Pong.cc
===================================================================
--- code/trunk/src/modules/pong/Pong.cc	(revision 9834)
+++ code/trunk/src/modules/pong/Pong.cc	(revision 9939)
@@ -47,4 +47,5 @@
 #include "PongBot.h"
 #include "PongAI.h"
+
 namespace orxonox
 {
@@ -117,4 +118,5 @@
             }
         }
+
     }
 
Index: code/trunk/src/modules/pong/PongBall.cc
===================================================================
--- code/trunk/src/modules/pong/PongBall.cc	(revision 9834)
+++ code/trunk/src/modules/pong/PongBall.cc	(revision 9939)
@@ -40,4 +40,7 @@
 
 #include "PongBat.h"
+
+#include "sound/WorldSound.h"
+#include "core/XMLPort.h"
 
 namespace orxonox
@@ -66,4 +69,21 @@
 
         this->registerVariables();
+
+        //initialize sound
+        if (GameMode::isMaster())
+             {
+                 this->defScoreSound_ = new WorldSound(this->getContext());
+                 this->defScoreSound_->setVolume(1.0f);
+                 this->defBatSound_ = new WorldSound(this->getContext());
+                 this->defBatSound_->setVolume(0.4f);
+                 this->defBoundarySound_ = new WorldSound(this->getContext());
+                 this->defBoundarySound_->setVolume(0.5f);
+             }
+             else
+             {
+                 this->defScoreSound_ = 0;
+                 this->defBatSound_ = 0;
+                 this->defBoundarySound_ = 0;
+             }
     }
 
@@ -81,4 +101,13 @@
             delete[] this->batID_;
         }
+    }
+
+    //xml port for loading sounds
+    void PongBall::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(PongBall, XMLPort, xmlelement, mode);
+        XMLPortParam(PongBall, "defScoreSound",  setDefScoreSound,  getDefScoreSound,  xmlelement, mode);
+        XMLPortParam(PongBall, "defBatSound",  setDefBatSound,  getDefBatSound,  xmlelement, mode);
+        XMLPortParam(PongBall, "defBoundarySound",  setDefBoundarySound,  getDefBoundarySound,  xmlelement, mode);
     }
 
@@ -117,5 +146,6 @@
         if (position.z > this->fieldHeight_ / 2 || position.z < -this->fieldHeight_ / 2)
         {
-            // Its velocity in z-direction is inverted (i.e. it bounces off).
+            defBoundarySound_->play(); //play boundary sound
+        	// Its velocity in z-direction is inverted (i.e. it bounces off).
             velocity.z = -velocity.z;
             // And its position is set as to not overstep the boundary it has just crossed.
@@ -142,5 +172,6 @@
                     if (fabs(distance) <= 1) // If the bat is there to parry.
                     {
-                        // Set the ball to be exactly at the boundary.
+                        defBatSound_->play(); //play bat sound
+                    	// Set the ball to be exactly at the boundary.
                         position.x = this->fieldWidth_ / 2;
                         // Invert its velocity in x-direction (i.e. it bounces off).
@@ -155,4 +186,5 @@
                     else if (GameMode::isMaster() && position.x > this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))
                     {
+                    	defScoreSound_->play();//play score sound
                         if (this->getGametype() && this->bat_[0])
                         {
@@ -169,5 +201,6 @@
                     if (fabs(distance) <= 1) // If the bat is there to parry.
                     {
-                        // Set the ball to be exactly at the boundary.
+                        defBatSound_->play(); //play bat sound
+                    	// Set the ball to be exactly at the boundary.
                         position.x = -this->fieldWidth_ / 2;
                         // Invert its velocity in x-direction (i.e. it bounces off).
@@ -182,4 +215,5 @@
                     else if (GameMode::isMaster() && position.x < -this->fieldWidth_ / 2 * (1 + this->relMercyOffset_))
                     {
+                    	defScoreSound_->play();//play score sound
                         if (this->getGametype() && this->bat_[1])
                         {
@@ -262,3 +296,54 @@
             this->bat_[1] = orxonox_cast<PongBat*>(Synchronisable::getSynchronisable(this->batID_[1]));
     }
+
+    void PongBall::setDefScoreSound(const std::string &pongSound)
+    {
+        if( defScoreSound_ )
+            defScoreSound_->setSource(pongSound);
+        else
+            assert(0); // This should never happen, because soundpointer is only available on master
+    }
+
+    const std::string& PongBall::getDefScoreSound()
+    {
+        if( defScoreSound_ )
+            return defScoreSound_->getSource();
+        else
+            assert(0);
+        return BLANKSTRING;
+    }
+
+    void PongBall::setDefBatSound(const std::string &pongSound)
+    {
+        if( defBatSound_ )
+            defBatSound_->setSource(pongSound);
+        else
+            assert(0); // This should never happen, because soundpointer is only available on master
+    }
+
+    const std::string& PongBall::getDefBatSound()
+    {
+        if( defBatSound_ )
+            return defBatSound_->getSource();
+        else
+            assert(0);
+        return BLANKSTRING;
+    }
+
+    void PongBall::setDefBoundarySound(const std::string &pongSound)
+    {
+        if( defBoundarySound_ )
+            defBoundarySound_->setSource(pongSound);
+        else
+            assert(0); // This should never happen, because soundpointer is only available on master
+    }
+
+    const std::string& PongBall::getDefBoundarySound()
+    {
+        if( defBoundarySound_ )
+            return defBoundarySound_->getSource();
+        else
+            assert(0);
+        return BLANKSTRING;
+    }
 }
Index: code/trunk/src/modules/pong/PongBall.h
===================================================================
--- code/trunk/src/modules/pong/PongBall.h	(revision 9834)
+++ code/trunk/src/modules/pong/PongBall.h	(revision 9939)
@@ -42,4 +42,5 @@
 #include "worldentities/MovableEntity.h"
 
+
 namespace orxonox
 {
@@ -63,4 +64,6 @@
 
             virtual void tick(float dt);
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
             /**
@@ -123,4 +126,11 @@
             static const float MAX_REL_Z_VELOCITY;
 
+            void setDefScoreSound(const std::string& engineSound);
+            const std::string& getDefScoreSound();
+            void setDefBatSound(const std::string& engineSound);
+            const std::string& getDefBatSound();
+            void setDefBoundarySound(const std::string& engineSound);
+            const std::string& getDefBoundarySound();
+
         private:
             void registerVariables();
@@ -135,4 +145,7 @@
             unsigned int* batID_; //!< The object IDs of the bats, to be able to synchronize them over the network.
             float relMercyOffset_; //!< Offset, that makes the player not loose, when, in all fairness, he would have.
+            WorldSound* defScoreSound_;
+            WorldSound* defBatSound_;
+            WorldSound* defBoundarySound_;
     };
 }
Index: code/trunk/src/modules/pong/PongScore.cc
===================================================================
--- code/trunk/src/modules/pong/PongScore.cc	(revision 9834)
+++ code/trunk/src/modules/pong/PongScore.cc	(revision 9939)
@@ -41,4 +41,5 @@
 
 #include "Pong.h"
+#include "sound/WorldSound.h" /////////////////////////////
 
 namespace orxonox
Index: code/trunk/src/modules/pong/PongScore.h
===================================================================
--- code/trunk/src/modules/pong/PongScore.h	(revision 9834)
+++ code/trunk/src/modules/pong/PongScore.h	(revision 9939)
@@ -124,4 +124,6 @@
             WeakPtr<PlayerInfo> player1_; //!< Store information about left player permanently.
             WeakPtr<PlayerInfo> player2_; //!< Same for the right player. To end the game properly.
+            WorldSound* scoreSound_;
+
     };
 }
Index: code/trunk/src/modules/weapons/weaponmodes/HsW01.h
===================================================================
--- code/trunk/src/modules/weapons/weaponmodes/HsW01.h	(revision 9834)
+++ code/trunk/src/modules/weapons/weaponmodes/HsW01.h	(revision 9939)
@@ -59,5 +59,5 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-        private:
+        protected:
             /**
             @brief Set the mesh.
@@ -109,5 +109,5 @@
                 { return this->delay_; }
 
-            void shot();
+            virtual void shot();
             void muzzleflash();
 
Index: code/trunk/src/orxonox/MoodManager.h
===================================================================
--- code/trunk/src/orxonox/MoodManager.h	(revision 9834)
+++ code/trunk/src/orxonox/MoodManager.h	(revision 9939)
@@ -51,5 +51,5 @@
 
         private:
-            virtual void moodChanged(const std::string& mood) = 0;
+            virtual bool moodChanged(const std::string& mood) = 0;
 
             static void changedMood(const std::string& mood);
Index: code/trunk/src/orxonox/controllers/NewHumanController.cc
===================================================================
--- code/trunk/src/orxonox/controllers/NewHumanController.cc	(revision 9834)
+++ code/trunk/src/orxonox/controllers/NewHumanController.cc	(revision 9939)
@@ -443,5 +443,5 @@
 
         if (pawn)
-            pawn->setAimPosition( mouseRay.getOrigin() + mouseRay.getDirection() * 1200 );
+            pawn->setAimPosition( mouseRay.getOrigin() + mouseRay.getDirection() * 3000 );
 
         if( this->getControllableEntity() && this->getControllableEntity()->getTarget() != 0 )
Index: code/trunk/src/orxonox/gamestates/GSMainMenu.cc
===================================================================
--- code/trunk/src/orxonox/gamestates/GSMainMenu.cc	(revision 9834)
+++ code/trunk/src/orxonox/gamestates/GSMainMenu.cc	(revision 9939)
@@ -85,5 +85,5 @@
     {
         if (GameMode::playsSound())
-            this->ambient_->destroy();
+            this->ambient_->destroy(); //CHECK Thilo destroy ?preDestroy()? !!!!!!!
 
         InputManager::getInstance().destroyState("MainMenuHackery");
Index: code/trunk/src/orxonox/gametypes/Gametype.cc
===================================================================
--- code/trunk/src/orxonox/gametypes/Gametype.cc	(revision 9834)
+++ code/trunk/src/orxonox/gametypes/Gametype.cc	(revision 9939)
@@ -171,5 +171,4 @@
                     entity->setOrientation(oldentity->getWorldOrientation());
                 }
-
                 it->first->startControl(entity);
             }
Index: code/trunk/src/orxonox/graphics/ParticleEmitter.cc
===================================================================
--- code/trunk/src/orxonox/graphics/ParticleEmitter.cc	(revision 9834)
+++ code/trunk/src/orxonox/graphics/ParticleEmitter.cc	(revision 9939)
@@ -45,5 +45,5 @@
     RegisterClass(ParticleEmitter);
 
-    ParticleEmitter::ParticleEmitter(Context* context) : StaticEntity(context)
+    ParticleEmitter::ParticleEmitter(Context* context) : MovableEntity(context)
     {
         RegisterObject(ParticleEmitter);
Index: code/trunk/src/orxonox/graphics/ParticleEmitter.h
===================================================================
--- code/trunk/src/orxonox/graphics/ParticleEmitter.h	(revision 9834)
+++ code/trunk/src/orxonox/graphics/ParticleEmitter.h	(revision 9939)
@@ -33,9 +33,9 @@
 
 #include <string>
-#include "worldentities/StaticEntity.h"
+#include "worldentities/MovableEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport ParticleEmitter : public StaticEntity
+    class _OrxonoxExport ParticleEmitter : public MovableEntity
     {
         public:
Index: code/trunk/src/orxonox/infos/PlayerInfo.cc
===================================================================
--- code/trunk/src/orxonox/infos/PlayerInfo.cc	(revision 9834)
+++ code/trunk/src/orxonox/infos/PlayerInfo.cc	(revision 9939)
@@ -229,5 +229,11 @@
             return;
 
-        this->controllableEntity_->getController()->setActive(false);
+        Controller* tmp =this->controllableEntity_->getController();
+        if (tmp == NULL)
+        {
+        	orxout(verbose) <<  "PlayerInfo: pauseControl, Controller is NULL " << endl;
+        	return;
+        }
+        tmp->setActive(false);
         //this->controllableEntity_->getController()->setControllableEntity(NULL);
         this->controllableEntity_->setController(0);
Index: code/trunk/src/orxonox/interfaces/RadarViewable.h
===================================================================
--- code/trunk/src/orxonox/interfaces/RadarViewable.h	(revision 9834)
+++ code/trunk/src/orxonox/interfaces/RadarViewable.h	(revision 9939)
@@ -63,4 +63,10 @@
         virtual void setRadarName(const std::string& name)
             {
+            // The following if-clause hides objects with radarname "HIDDEN"
+                if (name == "HIDDEN")
+                {
+                    this->bVisibility_ = 0;
+                    this->settingsChanged();
+                }
                 if (this->radarName_ != name)
                 {
Index: code/trunk/src/orxonox/items/MultiStateEngine.cc
===================================================================
--- code/trunk/src/orxonox/items/MultiStateEngine.cc	(revision 9834)
+++ code/trunk/src/orxonox/items/MultiStateEngine.cc	(revision 9939)
@@ -61,4 +61,6 @@
             this->defEngineSndNormal_->setLooping(true);
             this->defEngineSndBoost_->setLooping(true);
+            this->defEngineSndNormal_->setVolume(0.8f);
+            this->defEngineSndBoost_->setVolume(0.5f);
             this->lua_ = new LuaState();
         }
Index: code/trunk/src/orxonox/sound/AmbientSound.cc
===================================================================
--- code/trunk/src/orxonox/sound/AmbientSound.cc	(revision 9834)
+++ code/trunk/src/orxonox/sound/AmbientSound.cc	(revision 9939)
@@ -79,11 +79,11 @@
     }
 
-    void AmbientSound::setAmbientSource(const std::string& source)
+    bool AmbientSound::setAmbientSource(const std::string& source)
     {
         this->ambientSource_ = source;
-        this->moodChanged(MoodManager::getInstance().getMood());
+        return(this->moodChanged(MoodManager::getInstance().getMood()));
     }
 
-    void AmbientSound::moodChanged(const std::string& mood)
+    bool AmbientSound::moodChanged(const std::string& mood)
     {
         if (GameMode::playsSound())
@@ -95,10 +95,17 @@
                 orxout(user_info) << "Loading ambient sound " << path << "..." << endl; // TODO: make this output internal if we implement sound streaming
                 this->setSource(path);
+
+                // all went fine
+                return true;
             }
             else
             {
                 orxout(internal_warning, context::sound) << this->ambientSource_ << ": Not a valid name! Ambient sound will not change." << endl;
+
+                // everything went southways
+                return false;
             }
         }
+        return false;
     }
 
Index: code/trunk/src/orxonox/sound/AmbientSound.h
===================================================================
--- code/trunk/src/orxonox/sound/AmbientSound.h	(revision 9834)
+++ code/trunk/src/orxonox/sound/AmbientSound.h	(revision 9939)
@@ -54,5 +54,5 @@
         void pause();
 
-        void setAmbientSource(const std::string& source);
+        bool setAmbientSource(const std::string& source);
         inline const std::string& getAmbientSource() const
             { return this->ambientSource_; }
@@ -68,5 +68,5 @@
         void preDestroy();
         float getRealVolume();
-        void moodChanged(const std::string& mood);
+        bool moodChanged(const std::string& mood);
         inline void ambientSourceChanged()
             { this->setAmbientSource(this->ambientSource_); }
Index: code/trunk/src/orxonox/sound/BaseSound.cc
===================================================================
--- code/trunk/src/orxonox/sound/BaseSound.cc	(revision 9834)
+++ code/trunk/src/orxonox/sound/BaseSound.cc	(revision 9939)
@@ -47,5 +47,5 @@
     BaseSound::BaseSound()
         : bPooling_(false)
-        , volume_(1.0)
+        , volume_(0.7)
         , bLooping_(false)
         , state_(Stopped)
Index: code/trunk/src/orxonox/sound/SoundManager.cc
===================================================================
--- code/trunk/src/orxonox/sound/SoundManager.cc	(revision 9834)
+++ code/trunk/src/orxonox/sound/SoundManager.cc	(revision 9939)
@@ -218,5 +218,5 @@
             .description("Defines the overall volume.")
             .callback(this, &SoundManager::checkSoundVolumeValidity);
-        SetConfigValueAlias(volume_[SoundType::Music], "ambientVolume_", 1.0f)
+        SetConfigValueAlias(volume_[SoundType::Music], "ambientVolume_", 0.7f)
             .description("Defines the ambient volume.")
             .callback(this, &SoundManager::checkAmbientVolumeValidity);
Index: code/trunk/src/orxonox/sound/WorldAmbientSound.cc
===================================================================
--- code/trunk/src/orxonox/sound/WorldAmbientSound.cc	(revision 9834)
+++ code/trunk/src/orxonox/sound/WorldAmbientSound.cc	(revision 9939)
@@ -33,7 +33,12 @@
 #include "core/XMLPort.h"
 #include "AmbientSound.h"
+#include "core/command/ConsoleCommand.h"
+#include <exception>
+
 
 namespace orxonox
 {
+	SetConsoleCommand("WorldAmbientSound", "nextsong",      &WorldAmbientSound::nextSong);
+
     RegisterClass(WorldAmbientSound);
 
@@ -44,6 +49,15 @@
         this->ambientSound_ = new AmbientSound();
         this->registerVariables();
+        soundList_.push_back("Earth.ogg");
+        soundList_.push_back("Jupiter.ogg");
+        soundList_.push_back("Mars.ogg");
+        soundList_.push_back("allgorythm-lift_up.ogg");
+        soundList_.push_back("allgorythm-resonance_blaster.ogg");
+        soundList_.push_back("AlphaCentauri.ogg");
+        soundList_.push_back("Asteroid_rocks.ogg");
+        soundList_.push_back("Ganymede.ogg");
+        soundList_.push_back("luke_grey_-_hypermode.ogg");
+
     }
-
     WorldAmbientSound::~WorldAmbientSound()
     {
@@ -51,4 +65,5 @@
         {
             this->ambientSound_->destroy();
+            WorldAmbientSound::soundList_.clear();
         }
     }
@@ -94,3 +109,17 @@
             this->ambientSound_->stop();
     }
+
+    void WorldAmbientSound::nextSong()
+    {
+
+    	//HACK: Assuption - there is only one WorldAmbientSound in a level and only one level is used.
+    	for (ObjectList<WorldAmbientSound>::iterator it = ObjectList<WorldAmbientSound>::begin();
+    	     it != ObjectList<WorldAmbientSound>::end(); ++it)
+    	{
+    		while(it->ambientSound_->setAmbientSource(WorldAmbientSound::soundList_[WorldAmbientSound::soundNumber_]) == false){
+    			WorldAmbientSound::soundNumber_ = (WorldAmbientSound::soundNumber_ + 1) % WorldAmbientSound::soundList_.size();
+    		}
+    		WorldAmbientSound::soundNumber_ = (WorldAmbientSound::soundNumber_ + 1) % WorldAmbientSound::soundList_.size();
+    	}
+    }
 }
Index: code/trunk/src/orxonox/sound/WorldAmbientSound.h
===================================================================
--- code/trunk/src/orxonox/sound/WorldAmbientSound.h	(revision 9834)
+++ code/trunk/src/orxonox/sound/WorldAmbientSound.h	(revision 9939)
@@ -34,4 +34,7 @@
 #include "core/BaseObject.h"
 #include "network/synchronisable/Synchronisable.h"
+#include <string>
+#include <vector>
+
 
 namespace orxonox
@@ -54,9 +57,29 @@
             void play();
 
+            //This function changes the current ambient song.
+            //You can call nextSong() active in the level
+            //by pressing the key 'M'.
+            static void nextSong();
+
         private:
             void registerVariables();
 
+            //Vector with the diffrent available level sounds.
+            //The sound names are pushed in the WorldAmbientSound-constructor.
+            static std::vector<std::string> soundList_;
+
+            // This value will be initialized below, don't make this into
+            // a const, since we want to change it in nextSong().
+            static int soundNumber_;
+
+
             AmbientSound* ambientSound_;
     };
+
+    // This is an initialization for the soundnumber variable. Since it is
+    // static, we have to initialize it this way.
+    int WorldAmbientSound::soundNumber_ = 0;
+    std::vector<std::string> WorldAmbientSound::soundList_;
+
 }
 
Index: code/trunk/src/orxonox/sound/WorldSound.cc
===================================================================
--- code/trunk/src/orxonox/sound/WorldSound.cc	(revision 9834)
+++ code/trunk/src/orxonox/sound/WorldSound.cc	(revision 9939)
@@ -81,5 +81,5 @@
             alSourcef(this->audioSource_, AL_REFERENCE_DISTANCE, refDist);
             // TODO: 500 is very magical here. Derive something better
-            alSourcef(this->audioSource_, AL_MAX_DISTANCE, refDist * 500);
+            alSourcef(this->audioSource_, AL_MAX_DISTANCE, refDist * 20);
         }
         this->tick(0); // update position, orientation and velocity
Index: code/trunk/src/orxonox/weaponsystem/WeaponMode.cc
===================================================================
--- code/trunk/src/orxonox/weaponsystem/WeaponMode.cc	(revision 9834)
+++ code/trunk/src/orxonox/weaponsystem/WeaponMode.cc	(revision 9939)
@@ -79,4 +79,5 @@
             this->defSndWpnFire_ = new WorldSound(this->getContext());
             this->defSndWpnFire_->setLooping(false);
+            this->defSndWpnFire_->setVolume(0.8f);
             this->bSoundAttached_ = false;
         }
Index: code/trunk/src/orxonox/worldentities/BigExplosion.cc
===================================================================
--- code/trunk/src/orxonox/worldentities/BigExplosion.cc	(revision 9834)
+++ code/trunk/src/orxonox/worldentities/BigExplosion.cc	(revision 9939)
@@ -43,7 +43,43 @@
     RegisterClass(BigExplosion);
 
-    BigExplosion::BigExplosion(Context* context) : StaticEntity(context)
+    BigExplosion::BigExplosion(Context* context) : MobileEntity(context)
     {
         RegisterObject(BigExplosion);
+
+        if ( GameMode::showsGraphics() && ( !this->getScene() || !this->getScene()->getSceneManager() ) )
+            ThrowException(AbortLoading, "Can't create BigExplosion, no scene or no scene manager given.");
+
+        this->bStop_ = false;
+        this->LOD_ = LODParticle::Normal;
+
+        if ( GameMode::showsGraphics() )
+        {
+            try
+            {
+                this->init();
+            }
+            catch (const std::exception& ex)
+            {
+                orxout(internal_error) << "Couldn't load particle effect in BigExplosion: " << ex.what() << endl;
+                this->initZero();
+            }
+        }
+        else
+        {
+            this->initZero();
+        }
+
+        if (GameMode::isMaster())
+        {
+            this->destroyTimer_.setTimer(rnd(2, 4), false, createExecutor(createFunctor(&BigExplosion::stop, this)));
+        }
+
+        this->registerVariables();
+    }
+
+    BigExplosion::BigExplosion(Context* context, Vector3 initVelocity) : MobileEntity(context)
+    {
+        RegisterObject(BigExplosion);
+        this->setVelocity(initVelocity);
 
         if ( GameMode::showsGraphics() && ( !this->getScene() || !this->getScene()->getSceneManager() ) )
@@ -100,5 +136,5 @@
         this->debris4_->setSyncMode(0);
 
-        this->explosion_ = new StaticEntity(this->getContext());
+        this->explosion_ = new MobileEntity(this->getContext());
         this->explosion_->setSyncMode(0);
 
@@ -148,5 +184,10 @@
         this->debrisEntity4_->attach(debris4_);
 
+        // ///////////////////////
+        // TODO: particleSpawner is a static entity. It should probably be dynamic, for better explosions.
+        //
         ParticleSpawner* effect = new ParticleSpawner(this->getContext());
+        orxout() << "vel " << this->getVelocity() << endl;
+        // effect->setVelocity(this->getVelocity());
         effect->setDestroyAfterLife(true);
         effect->setSource("Orxonox/explosion2b");
@@ -155,4 +196,5 @@
 
         ParticleSpawner* effect2 = new ParticleSpawner(this->getContext());
+        // effect2->setVelocity(Vector3(rnd(-1, 1), rnd(-1, 1), rnd(-1, 1))*rnd(10, 200));
         effect2->setDestroyAfterLife(true);
         effect2->setSource("Orxonox/smoke6");
Index: code/trunk/src/orxonox/worldentities/BigExplosion.h
===================================================================
--- code/trunk/src/orxonox/worldentities/BigExplosion.h	(revision 9834)
+++ code/trunk/src/orxonox/worldentities/BigExplosion.h	(revision 9939)
@@ -22,5 +22,5 @@
  *   Author:
  *      Benjamin de Capitani
- *   Co-authors:
+ *   Co-authors:§
  *      ...
  *
@@ -33,12 +33,13 @@
 
 #include "tools/Timer.h"
-#include "StaticEntity.h"
+#include "MobileEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport BigExplosion : public StaticEntity
+    class _OrxonoxExport BigExplosion : public MobileEntity
     {
         public:
             BigExplosion(Context* context);
+            BigExplosion(Context* context, Vector3 initVelocity);
             virtual ~BigExplosion();
 
@@ -60,5 +61,5 @@
             bool                  bStop_;
 
-            StaticEntity*         explosion_;
+            MobileEntity*         explosion_;
 
             MovableEntity*        debrisEntity1_;
Index: code/trunk/src/orxonox/worldentities/pawns/Pawn.cc
===================================================================
--- code/trunk/src/orxonox/worldentities/pawns/Pawn.cc	(revision 9834)
+++ code/trunk/src/orxonox/worldentities/pawns/Pawn.cc	(revision 9939)
@@ -46,4 +46,5 @@
 #include "weaponsystem/WeaponPack.h"
 #include "weaponsystem/WeaponSet.h"
+#include "sound/WorldSound.h"
 
 #include "controllers/FormationController.h"
@@ -100,4 +101,14 @@
 
         this->setSyncMode(ObjectDirection::Bidirectional); // needed to synchronise e.g. aimposition
+
+        if (GameMode::isMaster())
+        {
+            this->explosionSound_ = new WorldSound(this->getContext());
+            this->explosionSound_->setVolume(1.0f);
+        }
+        else
+        {
+            this->explosionSound_ = 0;
+        }
     }
 
@@ -109,4 +120,5 @@
                 this->weaponSystem_->destroy();
         }
+
     }
 
@@ -135,6 +147,9 @@
         XMLPortParam(Pawn, "reloadwaittime", setReloadWaitTime, getReloadWaitTime, xmlelement, mode).defaultValues(1.0f);
 
+        XMLPortParam(Pawn, "explosionSound",  setExplosionSound,  getExplosionSound,  xmlelement, mode);
+
         XMLPortParam ( RadarViewable, "radarname", setRadarName, getRadarName, xmlelement, mode );
     }
+
 
     void Pawn::registerVariables()
@@ -290,5 +305,5 @@
     void Pawn::kill()
     {
-        this->damage(this->health_);
+    	this->damage(this->health_);
         this->death();
     }
@@ -314,5 +329,6 @@
         if (this->getGametype() && this->getGametype()->allowPawnDeath(this, this->lastHitOriginator_))
         {
-            // Set bAlive_ to false and wait for PawnManager to do the destruction
+            explosionSound_->play();
+        	// Set bAlive_ to false and wait for PawnManager to do the destruction
             this->bAlive_ = false;
 
@@ -365,6 +381,8 @@
         this->setDestroyWhenPlayerLeft(false);
 
-        BigExplosion* chunk = new BigExplosion(this->getContext());
+        orxout() << "big explosion: " << this->getVelocity() << endl;
+        BigExplosion* chunk = new BigExplosion(this->getContext(), this->getVelocity());
         chunk->setPosition(this->getPosition());
+        // chunk->setVelocity(this->getVelocity());
 
     }
@@ -376,4 +394,5 @@
             effect->setPosition(this->getPosition());
             effect->setOrientation(this->getOrientation());
+            effect->setVelocity(this->getVelocity());
             effect->setDestroyAfterLife(true);
             effect->setSource("Orxonox/explosion2b");
@@ -384,4 +403,5 @@
             effect->setPosition(this->getPosition());
             effect->setOrientation(this->getOrientation());
+            effect->setVelocity(this->getVelocity());
             effect->setDestroyAfterLife(true);
             effect->setSource("Orxonox/smoke6");
@@ -392,4 +412,5 @@
             effect->setPosition(this->getPosition());
             effect->setOrientation(this->getOrientation());
+            effect->setVelocity(this->getVelocity());
             effect->setDestroyAfterLife(true);
             effect->setSource("Orxonox/sparks");
@@ -527,4 +548,21 @@
 
 
+    void Pawn::setExplosionSound(const std::string &explosionSound)
+    {
+        if(explosionSound_ )
+            explosionSound_->setSource(explosionSound);
+        else
+            assert(0); // This should never happen, because soundpointer is only available on master
+    }
+
+    const std::string& Pawn::getExplosionSound()
+    {
+        if( explosionSound_ )
+            return explosionSound_->getSource();
+        else
+            assert(0);
+        return BLANKSTRING;
+    }
+
 
 }
Index: code/trunk/src/orxonox/worldentities/pawns/Pawn.h
===================================================================
--- code/trunk/src/orxonox/worldentities/pawns/Pawn.h	(revision 9834)
+++ code/trunk/src/orxonox/worldentities/pawns/Pawn.h	(revision 9939)
@@ -36,4 +36,5 @@
 #include "interfaces/RadarViewable.h"
 #include "worldentities/ControllableEntity.h"
+
 
 namespace orxonox // tolua_export
@@ -178,4 +179,7 @@
             virtual void changedVisibility();
 
+            void setExplosionSound(const std::string& engineSound);
+            const std::string& getExplosionSound();
+
         protected:
             virtual void preDestroy();
@@ -231,4 +235,7 @@
 
             Vector3 aimPosition_;
+
+            WorldSound* explosionSound_;
+
     }; // tolua_export
 } // tolua_export
