Index: code/branches/tetris/src/modules/tetris/Tetris.cc
===================================================================
--- code/branches/tetris/src/modules/tetris/Tetris.cc	(revision 8561)
+++ code/branches/tetris/src/modules/tetris/Tetris.cc	(revision 8563)
@@ -87,32 +87,61 @@
         SUPER(Tetris, tick, dt);
 
-        if(this->activeStone_ != NULL && !this->isValidMove(this->activeStone_, this->activeStone_->getPosition()))
-        {
-            this->activeStone_->setVelocity(Vector3::ZERO);
-            //this->grid_[(int)(position.x/this->center_->getStoneSize())][(int)(position.y/this->center_->getStoneSize())] = true;
-            this->createStone();
-            this->startStone();
-        }
-    }
-
-    bool Tetris::isValidMove(TetrisStone* stone, const Vector3& position)
+        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
-            return false;
+            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
-            return false;
-        
-        if(position.y < this->center_->getStoneSize()/2.0) //!< If the stone has reached the bottom of the level
-        {
-            stone->setVelocity(Vector3::ZERO);
-            //this->grid_[(int)(position.x/this->center_->getStoneSize())][(int)(position.y/this->center_->getStoneSize())] = true;
-            this->createStone();
-            this->startStone();
-            return false;
-        }
-
-        return this->correctStonePos(stone, position);
+            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;
     }
 
@@ -232,37 +261,4 @@
     /**
     @brief
-        Validate the stone position.
-    @return
-        Returns whether the supplied stone is in the correct position.
-    */
-    bool Tetris::correctStonePos(TetrisStone* stone, const Vector3& position)
-    {
-        assert(stone);
-
-        for(std::vector<TetrisStone*>::const_iterator it = this->stones_.begin(); it != this->stones_.end(); ++it)
-        {
-            if(stone == *it)
-                continue;
-
-            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();
-                return false;
-            }// This case applies if the stones overlap completely
-            if((position.x == currentStonePosition.x) && (position.y < currentStonePosition.y + this->center_->getStoneSize()))
-            {
-                return false;
-            }// This case applies if the stones overlap partially vertically
-        }
-
-        return true;
-    }
-
-    /**
-    @brief
         Get the player.
     @return
@@ -281,12 +277,4 @@
     {
         this->center_ = center;
-
-        /*this->grid_.resize(this->center_->getWidth());
-        for(std::vector< std::vector<bool> >::iterator it = this->grid_.begin(); it != this->grid_.end(); it++)
-        {
-            (*it).resize(this->center_->getHeight());
-            for(std::vector<bool>::iterator it2 = (*it).begin(); it2 != (*it).end(); it2++)
-                (*it).insert(it2, false);
-        }*/
     }
 
Index: code/branches/tetris/src/modules/tetris/Tetris.h
===================================================================
--- code/branches/tetris/src/modules/tetris/Tetris.h	(revision 8561)
+++ code/branches/tetris/src/modules/tetris/Tetris.h	(revision 8563)
@@ -69,5 +69,5 @@
             PlayerInfo* getPlayer(void) const; //!< Get the player.
 
-            bool isValidMove(TetrisStone* stone, const Vector3& position);
+            std::pair<bool, TetrisStone*> isValidMove(TetrisStone* stone, const Vector3& position);
 
         protected:
@@ -78,5 +78,4 @@
             void createStone(void);
             void cleanup(void); //!< Cleans up the Gametype by destroying the ball and the bats.
-            bool correctStonePos(TetrisStone* stone, const Vector3& position); //!< Check whether the supplied stone is in an allowed position
             
             PlayerInfo* player_;
Index: code/branches/tetris/src/modules/tetris/TetrisStone.cc
===================================================================
--- code/branches/tetris/src/modules/tetris/TetrisStone.cc	(revision 8561)
+++ code/branches/tetris/src/modules/tetris/TetrisStone.cc	(revision 8563)
@@ -54,10 +54,4 @@
         this->delay_ = false;
         this->delayTimer_.setTimer(0.2f, false, createExecutor(createFunctor(&TetrisStone::enableMovement, this)));
-        this->previousPosition_ = Vector3::ZERO;
-    }
-
-    void TetrisStone::tick(float dt)
-    {
-        SUPER(TetrisStone, tick, dt);
     }
 
@@ -70,5 +64,8 @@
     void TetrisStone::moveFrontBack(const Vector2& value)
     {
-        
+        if(value.x < 0)
+        {
+            this->setVelocity(this->getVelocity()*1.1);
+        }
     }
 
@@ -85,5 +82,5 @@
             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))
+            if(!this->tetris_->isValidMove(this, newPos).first)
                 return;
 
Index: code/branches/tetris/src/modules/tetris/TetrisStone.h
===================================================================
--- code/branches/tetris/src/modules/tetris/TetrisStone.h	(revision 8561)
+++ code/branches/tetris/src/modules/tetris/TetrisStone.h	(revision 8563)
@@ -57,6 +57,4 @@
             virtual ~TetrisStone() {}
 
-            virtual void tick(float dt);
-
             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.
@@ -77,7 +75,4 @@
                 { return this->size_; }
 
-            const Vector3& getPreviousPosition() const
-                { return this->previousPosition_; }
-
             void setGame(Tetris* tetris)
                 { assert(tetris); tetris_ = tetris; }
@@ -91,5 +86,4 @@
             Timer delayTimer_;
 
-            Vector3 previousPosition_;
             Tetris* tetris_;
     };
