Index: /code/branches/presentation/data/levels/tetris.oxw
===================================================================
--- /code/branches/presentation/data/levels/tetris.oxw	(revision 8564)
+++ /code/branches/presentation/data/levels/tetris.oxw	(revision 8564)
@@ -0,0 +1,61 @@
+<LevelInfo
+ name = "Tetris"
+ description = "Tetris in space!"
+ tags = ""
+/>
+
+<?lua
+  include("HUDTemplates3.oxo")
+  include("stats.oxo")
+  include("templates/lodInformation.oxt")
+?>
+
+<Template name=tetrisstonecameras defaults=0>
+  <TetrisStone>
+    <camerapositions>
+      <CameraPosition position="55,75,200" absolute=true />
+      <CameraPosition position="0,50,160" drag=true mouselook=true />
+      <CameraPosition position="0,50,0" pitch=-90 drag=true mouselook=true />
+    </camerapositions>
+  </TetrisStone>
+</Template>
+
+<Template name=tetrisstone>
+  <TetrisStone camerapositiontemplate=tetrisstonecameras>
+    <attached>
+      <Model position="0,0,0" mesh="crate.mesh" scale=1 />
+    </attached>
+  </TetrisStone>
+</Template>
+
+<Level
+ name         = "Presentation"
+ description  = "A simple testlevel"
+ gametype     = "Tetris"
+>
+  <templates>
+    <Template link=lodtemplate_default />
+  </templates>
+
+  <Scene
+   ambientlight = "0.5, 0.5, 0.5"
+   skybox       = "Orxonox/skypanoramagen1"
+  >
+    <Light type=directional position="0,0,0" direction="0.253, 0.593, -0.765" diffuse="1.0, 0.9, 0.9, 1.0" specular="1.0, 0.9, 0.9, 1.0" />
+
+    <?lua
+      for i = 1, 10, 1 do
+    ?>
+      <SpawnPoint position="<?lua print(math.random() * 1000 - 500) ?>,<?lua print(math.random() * 1000 - 500) ?>,<?lua print(math.random() * 1000 - 500) ?>" lookat="0,0,0" />
+    <?lua end ?>
+
+    <TetrisCenterpoint name=tetriscenter width=11 height=15 stoneSize=10 stoneTemplate=tetrisstone stoneSpeed=10 position="-55,-75,0">
+        <attached>
+            <Model position="55,-1,0" mesh="cube.mesh" scale3D="57,1,11" />
+            <Model position="-1,76,0" mesh="cube.mesh" scale3D="1,76,1" />
+            <Model position="111,76,0" mesh="cube.mesh" scale3D="1,76,1" />
+        </attached>
+    </TetrisCenterpoint>
+
+  </Scene>
+</Level>
Index: /code/branches/presentation/src/modules/CMakeLists.txt
===================================================================
--- /code/branches/presentation/src/modules/CMakeLists.txt	(revision 8563)
+++ /code/branches/presentation/src/modules/CMakeLists.txt	(revision 8564)
@@ -34,4 +34,5 @@
 ADD_SUBDIRECTORY(portals)
 ADD_SUBDIRECTORY(questsystem)
+ADD_SUBDIRECTORY(tetris)
 ADD_SUBDIRECTORY(weapons)
 ADD_SUBDIRECTORY(docking)
Index: /code/branches/presentation/src/modules/pong/PongBat.h
===================================================================
--- /code/branches/presentation/src/modules/pong/PongBat.h	(revision 8563)
+++ /code/branches/presentation/src/modules/pong/PongBat.h	(revision 8564)
@@ -100,5 +100,5 @@
                 { this->length_ = length; }
             /**
-            @brief get the length of the bat.
+            @brief Get the length of the bat.
             @return Returns the length of the bat (in z-direction) as percentage of the height of the playing field.
             */
Index: /code/branches/presentation/src/modules/tetris/CMakeLists.txt
===================================================================
--- /code/branches/presentation/src/modules/tetris/CMakeLists.txt	(revision 8564)
+++ /code/branches/presentation/src/modules/tetris/CMakeLists.txt	(revision 8564)
@@ -0,0 +1,13 @@
+SET_SOURCE_FILES(TETRIS_SRC_FILES
+  Tetris.cc
+  TetrisCenterpoint.cc
+  TetrisStone.cc
+)
+
+ORXONOX_ADD_LIBRARY(tetris
+  MODULE
+  FIND_HEADER_FILES
+  LINK_LIBRARIES
+    orxonox
+  SOURCE_FILES ${TETRIS_SRC_FILES}
+)
Index: /code/branches/presentation/src/modules/tetris/Tetris.cc
===================================================================
--- /code/branches/presentation/src/modules/tetris/Tetris.cc	(revision 8564)
+++ /code/branches/presentation/src/modules/tetris/Tetris.cc	(revision 8564)
@@ -0,0 +1,283 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file Tetris.cc
+    @brief Implementation of the Tetris class.
+*/
+
+#include "Tetris.h"
+
+#include "core/CoreIncludes.h"
+#include "core/EventIncludes.h"
+#include "core/command/Executor.h"
+
+#include "gamestates/GSLevel.h"
+
+#include "TetrisCenterpoint.h"
+#include "TetrisStone.h"
+#include "infos/PlayerInfo.h"
+
+namespace orxonox
+{
+
+    CreateUnloadableFactory(Tetris);
+
+    /**
+    @brief
+        Constructor. Registers and initializes the object.
+    */
+    Tetris::Tetris(BaseObject* creator) : Deathmatch(creator)
+    {
+        RegisterObject(Tetris);
+
+        this->activeStone_ = NULL;
+
+        // Pre-set the timer, but don't start it yet.
+        this->starttimer_.setTimer(1.0, false, createExecutor(createFunctor(&Tetris::startStone, this)));
+        this->starttimer_.stopTimer();
+
+        this->player_ = NULL;
+    }
+
+    /**
+    @brief
+        Destructor. Cleans up, if initialized.
+    */
+    Tetris::~Tetris()
+    {
+        if (this->isInitialized())
+            this->cleanup();
+    }
+
+    /**
+    @brief
+        Cleans up the Gametype.
+    */
+    void Tetris::cleanup()
+    {
+
+    }
+
+    void Tetris::tick(float dt)
+    {
+        SUPER(Tetris, tick, dt);
+
+        if(this->activeStone_ != NULL)
+        {
+            std::pair<bool, TetrisStone*> valid = this->isValidMove(this->activeStone_, this->activeStone_->getPosition());
+            if(!valid.first)
+            {
+                this->activeStone_->setVelocity(Vector3::ZERO);
+                if(valid.second != NULL)
+                {
+                    Vector3 position = Vector3(this->activeStone_->getPosition().x, valid.second->getPosition().y+this->center_->getStoneSize(), this->activeStone_->getPosition().z);
+                    this->activeStone_->setPosition(position);
+                }
+                this->createStone();
+                this->startStone();
+            }
+        }
+    }
+
+    std::pair<bool, TetrisStone*> Tetris::isValidMove(TetrisStone* stone, const Vector3& position)
+    {
+        assert(stone);
+
+        std::pair<bool, TetrisStone*> valid = std::pair<bool, TetrisStone*>(true, NULL);
+        
+        if(position.x < this->center_->getStoneSize()/2.0)  //!< If the stone touches the left edge of the level
+            valid.first = false;
+        else if(position.x > (this->center_->getWidth()-0.5)*this->center_->getStoneSize()) //!< If the stone touches the right edge of the level
+            valid.first = false;
+        else if(position.y < this->center_->getStoneSize()/2.0) //!< If the stone has reached the bottom of the level
+        {
+            valid.first = false;
+            stone->setPosition(Vector3(stone->getPosition().x, this->center_->getStoneSize()/2.0, stone->getPosition().z));
+        }
+
+        for(std::vector<TetrisStone*>::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
+        {
+            if(stone == *it)
+                continue;
+
+            const Vector3& currentStonePosition = (*it)->getPosition(); //!< Saves the position of the currentStone
+
+            if((position.x == currentStonePosition.x) && (position.y == currentStonePosition.y))
+            {
+                stone->setVelocity(Vector3::ZERO);
+                this->createStone();
+                this->startStone();
+                valid.first = false;
+                return valid;
+            }// This case applies if the stones overlap completely
+            else if((position.x == currentStonePosition.x) && (position.y < currentStonePosition.y + this->center_->getStoneSize()))
+            {
+                valid.first = false;
+                valid.second = *it;
+                return valid;
+            }// This case applies if the stones overlap partially vertically
+        }
+
+        return valid;
+    }
+
+    /**
+    @brief
+        Starts the Tetris minigame.
+    */
+    void Tetris::start()
+    {
+        if (this->center_ != NULL) // There needs to be a TetrisCenterpoint, i.e. the area the game takes place.
+        {
+            // Create the first stone.
+            this->createStone();
+        }
+        else // If no centerpoint was specified, an error is thrown and the level is exited.
+        {
+            COUT(1) << "Error: No Centerpoint specified." << std::endl;
+            GSLevel::startMainMenu();
+            return;
+        }
+
+        // Start the timer. After it has expired the stone is started.
+        this->starttimer_.startTimer();
+
+        // Set variable to temporarily force the player to spawn.
+        bool temp = this->bForceSpawn_;
+        this->bForceSpawn_ = true;
+
+        // Call start for the parent class.
+        Deathmatch::start();
+
+        // Reset the variable.
+        this->bForceSpawn_ = temp;
+    }
+
+    /**
+    @brief
+        Ends the Tetris minigame.
+    */
+    void Tetris::end()
+    {
+        this->cleanup();
+
+        // Call end for the parent class.
+        Deathmatch::end();
+    }
+
+    /**
+    @brief
+        Spawns player.
+    */
+    void Tetris::spawnPlayersIfRequested()
+    {
+        // Spawn a human player.
+        for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+            if (it->first->isHumanPlayer() && (it->first->isReadyToSpawn() || this->bForceSpawn_))
+                this->spawnPlayer(it->first);
+    }
+
+    /**
+    @brief
+        Spawns the input player.
+    @param player
+        The player to be spawned.
+    */
+    void Tetris::spawnPlayer(PlayerInfo* player)
+    {
+        assert(player);
+
+        if(this->player_ == NULL)
+        {
+            this->player_ = player;
+            this->players_[player].state_ = PlayerState::Alive;
+        }
+    }
+
+    /**
+    @brief
+        Starts the first stone.
+    */
+    void Tetris::startStone(void)
+    {
+        if(this->player_ == NULL)
+            return;
+        
+        if(this->activeStone_ != NULL)
+            this->player_->stopControl();
+        
+        // Make the last stone to be created the active stone.
+        this->activeStone_ = this->stones_.back();
+        
+        this->player_->startControl(this->activeStone_);
+        this->activeStone_->setVelocity(0.0f, -this->center_->getStoneSpeed(), 0.0f);
+    }
+
+    /**
+    @brief
+        Creates a new stone.
+    */
+    void Tetris::createStone(void)
+    {
+        // Create a new stone and add it to the list of stones.
+        TetrisStone* stone = new TetrisStone(this->center_);
+        this->stones_.push_back(stone);
+        
+        // Apply the stone template to the stone.
+        stone->addTemplate(this->center_->getStoneTemplate());
+        
+        // Attach the stone to the Centerpoint and set the position of the stone to be at the top middle.
+        this->center_->attach(stone);
+        float xPos = (this->center_->getWidth()/2 + ((this->center_->getWidth() % 2)*2-1)/2.0)*this->center_->getStoneSize();
+        float yPos = (this->center_->getHeight()-0.5)*this->center_->getStoneSize();
+        stone->setPosition(xPos, yPos, 0.0f);
+        stone->setGame(this);
+    }
+
+    /**
+    @brief
+        Get the player.
+    @return
+        Returns a pointer to the player. If there is no player, NULL is returned.
+    */
+    PlayerInfo* Tetris::getPlayer(void) const
+    {
+        return this->player_;
+    }
+
+    /**
+    @brief Set the TetrisCenterpoint (the playing field).
+    @param center A pointer to the TetrisCenterpoint to be set.
+    */
+    void Tetris::setCenterpoint(TetrisCenterpoint* center)
+    {
+        this->center_ = center;
+    }
+
+}
Index: /code/branches/presentation/src/modules/tetris/Tetris.h
===================================================================
--- /code/branches/presentation/src/modules/tetris/Tetris.h	(revision 8564)
+++ /code/branches/presentation/src/modules/tetris/Tetris.h	(revision 8564)
@@ -0,0 +1,92 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file Tetris.h
+    @brief Declaration of the Tetris class.
+    @ingroup Tetris
+*/
+
+#ifndef _Tetris_H__
+#define _Tetris_H__
+
+#include "tetris/TetrisPrereqs.h"
+
+#include "tools/Timer.h"
+
+#include "gametypes/Deathmatch.h"
+
+namespace orxonox
+{
+
+    /**
+    @brief
+
+    @author
+
+    @ingroup Tetris
+    */
+    class _TetrisExport Tetris : public Deathmatch
+    {
+        public:
+            Tetris(BaseObject* creator); //!< Constructor. Registers and initializes the object.
+            virtual ~Tetris(); //!< Destructor. Cleans up, if initialized.           
+
+            virtual void start(void); //!< Starts the Tetris minigame.
+            virtual void end(void); ///!< Ends the Tetris minigame.
+
+            virtual void tick(float dt);
+
+            virtual void spawnPlayer(PlayerInfo* player); //!< Spawns the input player.
+
+            void setCenterpoint(TetrisCenterpoint* center);
+
+            PlayerInfo* getPlayer(void) const; //!< Get the player.
+
+            std::pair<bool, TetrisStone*> isValidMove(TetrisStone* stone, const Vector3& position);
+
+        protected:
+            virtual void spawnPlayersIfRequested(); //!< Spawns player.
+
+        private:
+            void startStone(void); //!< Starts with the first stone.
+            void createStone(void);
+            void cleanup(void); //!< Cleans up the Gametype by destroying the ball and the bats.
+            
+            PlayerInfo* player_;
+
+            WeakPtr<TetrisCenterpoint> center_; //!< The playing field.
+            std::vector<TetrisStone*> stones_; //!< A list of all stones in play.
+            std::vector< std::vector<bool> > grid_;
+            TetrisStone* activeStone_;
+            
+            Timer starttimer_; //!< A timer to delay the start of the game.
+    };
+}
+
+#endif /* _Tetris_H__ */
Index: /code/branches/presentation/src/modules/tetris/TetrisCenterpoint.cc
===================================================================
--- /code/branches/presentation/src/modules/tetris/TetrisCenterpoint.cc	(revision 8564)
+++ /code/branches/presentation/src/modules/tetris/TetrisCenterpoint.cc	(revision 8564)
@@ -0,0 +1,101 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file TetrisCenterpoint.cc
+    @brief Implementation of the TetrisCenterpoint class.
+*/
+
+#include "TetrisCenterpoint.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+
+#include "Tetris.h"
+
+namespace orxonox
+{
+    CreateFactory(TetrisCenterpoint);
+
+    /**
+    @brief
+        Constructor. Registers and initializes the object and checks whether the gametype is actually Tetris.
+    */
+    TetrisCenterpoint::TetrisCenterpoint(BaseObject* creator) : StaticEntity(creator)
+    {
+        RegisterObject(TetrisCenterpoint);
+
+        this->width_ = 10;
+        this->height_ = 11;
+        this->stoneSize_ = 10.0f;
+        this->stoneTemplate_ = "";
+        this->stoneSpeed_ = 20.0f;
+        
+        this->checkGametype();
+    }
+
+    /**
+    @brief
+        Method to create a TetrisCenterpoint through XML.
+    */
+    void TetrisCenterpoint::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(TetrisCenterpoint, XMLPort, xmlelement, mode);
+
+        XMLPortParam(TetrisCenterpoint, "width", setWidth, getWidth, xmlelement, mode); // die Breite
+        XMLPortParam(TetrisCenterpoint, "height", setHeight, setWidth, xmlelement, mode); // die Grösse
+        XMLPortParam(TetrisCenterpoint, "stoneSize", setStoneSize, getStoneSize, xmlelement, mode); 
+        XMLPortParam(TetrisCenterpoint, "stoneTemplate", setStoneTemplate, getStoneTemplate, xmlelement, mode);
+        XMLPortParam(TetrisCenterpoint, "stoneSpeed", setStoneSpeed, getStoneSpeed, xmlelement, mode);
+    }
+
+    /**
+    @brief
+        Is called when the gametype has changed.
+    */
+    void TetrisCenterpoint::changedGametype()
+    {
+        SUPER(TetrisCenterpoint, changedGametype);
+
+        // Check, whether it's still Tetris.
+        this->checkGametype();
+    }
+
+    /**
+    @brief
+        Checks whether the gametype is Tetris and if it is, sets its centerpoint.
+    */
+    void TetrisCenterpoint::checkGametype()
+    {
+        if (this->getGametype() != NULL && this->getGametype()->isA(Class(Tetris)))
+        {
+            Tetris* tetrisGametype = orxonox_cast<Tetris*>(this->getGametype().get());
+            tetrisGametype->setCenterpoint(this);
+        }
+    }
+}
Index: /code/branches/presentation/src/modules/tetris/TetrisCenterpoint.h
===================================================================
--- /code/branches/presentation/src/modules/tetris/TetrisCenterpoint.h	(revision 8564)
+++ /code/branches/presentation/src/modules/tetris/TetrisCenterpoint.h	(revision 8564)
@@ -0,0 +1,144 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file TetrisCenterpoint.h
+    @brief Declaration of the TetrisCenterpoint class.
+    @ingroup Tetris
+*/
+
+#ifndef _TetrisCenterpoint_H__
+#define _TetrisCenterpoint_H__
+
+#include "tetris/TetrisPrereqs.h"
+
+#include <string>
+
+#include <util/Math.h>
+
+#include "worldentities/StaticEntity.h"
+
+namespace orxonox
+{
+    
+    /**
+    @brief
+        
+    
+    @author
+        
+    @ingroup Tetris
+    */
+    class _TetrisExport TetrisCenterpoint : public StaticEntity
+    {
+        public:
+            TetrisCenterpoint(BaseObject* creator); //!< Constructor. Registers and initializes the object and checks whether the gametype is actually Tetris.
+            virtual ~TetrisCenterpoint() {}
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method to create a TetrisCenterpoint through XML.
+
+            virtual void changedGametype(); //!< Is called when the gametype has changed.
+            
+            /**
+            @brief Set the width of the playing field.
+            @param width The width in number of tiles.
+            */
+            void setWidth(unsigned int width)
+                { this->width_ = width; }
+            /**
+            @brief Get the width of the playing field.
+            @return Returns the width in number of tiles.
+            */
+            unsigned int getWidth(void) const
+                { return this->width_; }
+                
+            /**
+            @brief Set the height of the playing field.
+            @param height The height in number of tiles.
+            */
+            void setHeight(unsigned int height)
+                { this->height_ = height; }
+            /**
+            @brief Get the height of the playing field.
+            @return Returns the height in number of tiles.
+            */
+            unsigned int getHeight(void) const
+                { return this->height_; }
+                
+            /**
+            @brief Set the size of a single stone.
+            @param size The dimensions a stone has in the game world. (A stone is a cube)
+            */
+            void setStoneSize(float size)
+                { this->stoneSize_ = size; }
+            /**
+            @brief Get the size of a single stone.
+            @return Returns the dimensions a stone has in the game world.
+            */
+            float getStoneSize(void) const
+                { return this->stoneSize_; }
+                
+            /**
+            @brief Set the template for the stones.
+            @param template The template name to be applied to each stone.
+            */
+            void setStoneTemplate(const std::string& templateName)
+                { this->stoneTemplate_ = templateName; }
+            /**
+            @brief Get the template for the stones.
+            @return Returns the template name to be applied to each stone.
+            */
+            const std::string& getStoneTemplate(void) const
+                { return this->stoneTemplate_; }
+            
+            /**
+            @brief Set the speed of the stones.
+            @param speed The speed to be set.
+            */
+            void setStoneSpeed(float speed)
+                { this->stoneSpeed_ = speed; }
+            /**
+            @brief Get the speed of the stones.
+            @return Returns the speed a moving stone has.
+            */
+            float getStoneSpeed(void)
+                { return this->stoneSpeed_; }
+
+        private:
+            void checkGametype(); //!< Checks whether the gametype is Tetris and if it is, sets its centerpoint.
+            
+            unsigned int width_;
+            unsigned int height_;
+            float stoneSize_;
+            std::string stoneTemplate_;
+            float stoneSpeed_;
+
+    };
+}
+
+#endif /* _TetrisCenterpoint_H__ */
Index: /code/branches/presentation/src/modules/tetris/TetrisPrereqs.h
===================================================================
--- /code/branches/presentation/src/modules/tetris/TetrisPrereqs.h	(revision 8564)
+++ /code/branches/presentation/src/modules/tetris/TetrisPrereqs.h	(revision 8564)
@@ -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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+@file
+@brief
+    Shared library macros, enums, constants and forward declarations for the tetris module
+*/
+
+#ifndef _TetrisPrereqs_H__
+#define _TetrisPrereqs_H__
+
+#include "OrxonoxConfig.h"
+#include "OrxonoxPrereqs.h"
+
+//-----------------------------------------------------------------------
+// Shared library settings
+//-----------------------------------------------------------------------
+
+#if defined(ORXONOX_PLATFORM_WINDOWS) && !defined(TETRIS_STATIC_BUILD)
+#  ifdef TETRIS_SHARED_BUILD
+#    define _TetrisExport __declspec(dllexport)
+#  else
+#    if defined( __MINGW32__ )
+#      define _TetrisExport
+#    else
+#      define _TetrisExport __declspec(dllimport)
+#    endif
+#  endif
+#elif defined ( ORXONOX_GCC_VISIBILITY )
+#  define _TetrisExport  __attribute__ ((visibility("default")))
+#else
+#  define _TetrisExport
+#endif
+
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+
+namespace orxonox
+{
+    class Tetris;
+    class TetrisCenterpoint;
+    class TetrisStone;
+}
+
+#endif /* _TetrisPrereqs_H__ */
Index: /code/branches/presentation/src/modules/tetris/TetrisStone.cc
===================================================================
--- /code/branches/presentation/src/modules/tetris/TetrisStone.cc	(revision 8564)
+++ /code/branches/presentation/src/modules/tetris/TetrisStone.cc	(revision 8564)
@@ -0,0 +1,102 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file TetrisStone.cc
+    @brief Implementation of the TetrisStone class.
+*/
+
+#include "TetrisStone.h"
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+
+#include "Tetris.h"
+
+namespace orxonox
+{
+    CreateFactory(TetrisStone);
+
+    /**
+    @brief
+        Constructor. Registers and initializes the object.
+    */
+    TetrisStone::TetrisStone(BaseObject* creator) : ControllableEntity(creator)
+    {
+        RegisterObject(TetrisStone);
+        
+        this->size_ = 10.0f;
+        this->delay_ = false;
+        this->delayTimer_.setTimer(0.2f, false, createExecutor(createFunctor(&TetrisStone::enableMovement, this)));
+    }
+
+    /**
+    @brief
+        Overloaded the function to rotate the stone.
+    @param value
+        A vector whose first component is the angle by which to rotate.
+    */
+    void TetrisStone::moveFrontBack(const Vector2& value)
+    {
+        if(value.x < 0)
+        {
+            this->setVelocity(this->getVelocity()*1.1);
+        }
+    }
+
+    /**
+    @brief
+        Overloaded the function to steer the stone right and left
+    @param value
+        A vector whose first component is the direction in which we want to steer the stone.
+    */
+    void TetrisStone::moveRightLeft(const Vector2& value)
+    {
+        if(!this->delay_)
+        {
+            const Vector3& position = this->getPosition();
+            Vector3 newPos = Vector3(position.x+value.x/abs(value.x)*this->size_, position.y, position.z);
+            if(!this->tetris_->isValidMove(this, newPos).first)
+                return;
+
+            //this->previousPosition_ = position;
+            this->setPosition(newPos);
+            this->delay_ = true;
+            this->delayTimer_.startTimer();
+        }
+    }
+
+    /**
+    @brief
+        Is called when the player changed.
+    */
+    void TetrisStone::changedPlayer()
+    {
+        this->setVelocity(0, 0, 0);
+    }
+}
Index: /code/branches/presentation/src/modules/tetris/TetrisStone.h
===================================================================
--- /code/branches/presentation/src/modules/tetris/TetrisStone.h	(revision 8564)
+++ /code/branches/presentation/src/modules/tetris/TetrisStone.h	(revision 8564)
@@ -0,0 +1,92 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file TetrisStone.h
+    @brief Declaration of the TetrisStone class.
+    @ingroup Tetris
+*/
+
+#ifndef _TetrisStone_H__
+#define _TetrisStone_H__
+
+#include "tetris/TetrisPrereqs.h"
+
+#include "worldentities/ControllableEntity.h"
+#include "tools/Timer.h"
+
+namespace orxonox
+{
+
+    /**
+    @brief
+
+    @author
+
+    @ingroup Tetris
+    */
+    class _TetrisExport TetrisStone : public ControllableEntity
+    {
+        public:
+            TetrisStone(BaseObject* creator); //!< Constructor. Registers and initializes the object.
+            virtual ~TetrisStone() {}
+
+            virtual void moveFrontBack(const Vector2& value); //!< Overloaded the function to steer the bat up and down.
+            virtual void moveRightLeft(const Vector2& value); //!< Overloaded the function to steer the bat up and down.
+
+            virtual void changedPlayer(); //!< Is called when the player changed.
+
+            /**
+            @brief Set the size of the stone.
+            @param size The dimensions a stone has in the game world. (A stone is a cube)
+            */
+            void setSize(float size)
+                { this->size_ = size; }
+            /**
+            @brief Get the size of the stone.
+            @return Returns the dimensions a stone has in the game world. (A stone is a cube)
+            */
+            float getSize(void) const
+                { return this->size_; }
+
+            void setGame(Tetris* tetris)
+                { assert(tetris); tetris_ = tetris; }
+
+        private:
+            void enableMovement(void)
+                { this->delay_ = false; }
+            
+            float size_; //!< The dimensions a stone has in the game world.
+            bool delay_;
+            Timer delayTimer_;
+
+            Tetris* tetris_;
+    };
+}
+
+#endif /* _TetrisStone_H__ */
