Changeset 9082 for code/branches/pCuts/src/modules/tetris

Timestamp:

Apr 11, 2012, 3:53:43 PM (13 years ago)

Author:

jo

Message:

Trying to create tetris bricks. Rough implementation done. Still having a nasty camera bug. (see the debug output concerning the cameraIndex)

Location:

code/branches/pCuts/src/modules/tetris

Files:

• CMakeLists.txt (modified) (1 diff)
• Tetris.cc (modified) (13 diffs)
• Tetris.h (modified) (2 diffs)
• TetrisBrick.cc (added)
• TetrisBrick.h (added)
• TetrisCenterpoint.cc (modified) (2 diffs)
• TetrisCenterpoint.h (modified) (3 diffs)
• TetrisPrereqs.h (modified) (1 diff)
• TetrisStone.cc (modified) (1 diff)
• TetrisStone.h (modified) (1 diff)

code/branches/pCuts/src/modules/tetris/CMakeLists.txt

@@ -3 +3 @@
   TetrisCenterpoint.cc
   TetrisStone.cc
+  TetrisBrick.cc
 )
 

code/branches/pCuts/src/modules/tetris/Tetris.cc

@@ -42 +42 @@
 #include "TetrisCenterpoint.h"
 #include "TetrisStone.h"
+#include "TetrisBrick.h"
 #include "infos/PlayerInfo.h"
 
@@ -57 +58 @@
         RegisterObject(Tetris);
 
-        this->activeStone_ = NULL;
+        this->activeBrick_ = NULL;
 
         // Pre-set the timer, but don't start it yet.
-        this->starttimer_.setTimer(1.0, false, createExecutor(createFunctor(&Tetris::startStone, this)));
+        this->starttimer_.setTimer(1.0, false, createExecutor(createFunctor(&Tetris::startBrick, this)));
         this->starttimer_.stopTimer();
 
@@ -82 +83 @@
     void Tetris::cleanup()
     {
+        /*for(int i = 0;i < this->stones_.size(); i++) //TODO: Why isn't there any code like this
+        {                                              // compensating the 'new' statement?
+            delete this->stones_[i];
+        }//*/
 
     }
@@ -89 +94 @@
         SUPER(Tetris, tick, dt);
 
-        if(this->activeStone_ != NULL)
-        {
-            if(!this->isValidStonePosition(this->activeStone_, this->activeStone_->getPosition()))
+        if(this->activeBrick_ != NULL)
+        {
+            if(!this->isValidBrickPosition(this->activeBrick_, this->activeBrick_->getPosition()))
             {
-                this->activeStone_->setVelocity(Vector3::ZERO);
-                this->createStone();
-                this->startStone();
+                this->activeBrick_->setVelocity(Vector3::ZERO);
+                this->createBrick();
+                this->startBrick();
             }
         }
@@ -123 +128 @@
     }
 
+    /**
+    @brief
+        Check for each stone in a brick wether it is moved the right way.
+    */
+    bool Tetris::isValidMove(TetrisBrick* brick, const Vector3& position)
+    {
+        assert(brick);
+
+        for (unsigned int i = 0; i < brick->getNumberOfStones(); i++ )
+        {
+            TetrisStone* stone = brick->getStone(i);
+            if(! this->isValidMove(stone, position + stone->getPosition())) // wrong position??
+                return false;
+            orxout()<< "stoneRelativePoistion: " << stone->getPosition() << endl;
+            orxout()<< "stoneTotalPoistion: " << position + stone->getPosition() << endl;
+        }
+        return true;
+
+    }
+
+
+
     bool Tetris::isValidStonePosition(TetrisStone* stone, const Vector3& position)
     {
@@ -130 +157 @@
         for(std::vector<TetrisStone*>::const_reverse_iterator it = this->stones_.rbegin(); it != this->stones_.rend(); ++it)
         {
-            if(stone == *it)
+            if(this->activeBrick_->contains(*it))
                 continue;
 
@@ -137 +164 @@
             if((position.x == currentStonePosition.x) && (position.y < currentStonePosition.y + this->center_->getStoneSize()))
             {
-                this->activeStone_->setPosition(Vector3(this->activeStone_->getPosition().x, currentStonePosition.y+this->center_->getStoneSize(), this->activeStone_->getPosition().z));
+                this->activeBrick_->setPosition(Vector3(this->activeBrick_->getPosition().x, currentStonePosition.y+this->center_->getStoneSize(), this->activeBrick_->getPosition().z));
                 return false;
             }// This case applies if the stones overlap partially vertically
@@ -144 +171 @@
         // after we checked for collision with all stones, we also check for collision with the bottom
         if(position.y < this->center_->getStoneSize()/2.0f) //!< If the stone has reached the bottom of the level
-        {
-            stone->setPosition(Vector3(stone->getPosition().x, this->center_->getStoneSize()/2.0f, stone->getPosition().z));
+        {//TODO: correct positioning !!
+                this->activeBrick_->setPosition(Vector3(this->activeBrick_->getPosition().x, this->center_->getStoneSize()/2.0f, this->activeBrick_->getPosition().z));
             return false;
         }
@@ -152 +179 @@
     }
 
+    bool Tetris::isValidBrickPosition(TetrisBrick* brick, const Vector3& position)
+    {
+        assert(brick);
+
+        for (unsigned int i = 0; i < brick->getNumberOfStones(); i++ )
+        {
+            TetrisStone* stone = brick->getStone(i);
+            if(! this->isValidStonePosition(stone, position + stone->getPosition()) ) // wrong position??
+                return false;
+        }
+        return true;
+
+    }
+
     /**
     @brief
@@ -161 +202 @@
         {
             // Create the first stone.
-            this->createStone();
+            this->createBrick();
         }
         else // If no centerpoint was specified, an error is thrown and the level is exited.
@@ -225 +266 @@
     }
 
-    /**
-    @brief
-        Starts the first stone.
-    */
-    void Tetris::startStone(void)
+
+
+    void Tetris::startBrick(void)
     {
         if(this->player_ == NULL)
@@ -235 +274 @@
 
         unsigned int cameraIndex = 0;
-        if(this->activeStone_ != NULL)
+        if(this->activeBrick_ != NULL)
         {
             // Get camera settings
-            cameraIndex = this->activeStone_->getCurrentCameraIndex();
+            cameraIndex = this->activeBrick_->getCurrentCameraIndex();
+            orxout() << "cameraIndex: " << this->activeBrick_->getCurrentCameraIndex() << endl;
             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);
-        this->activeStone_->setCameraPosition(cameraIndex);
-    }
-
-    /**
-    @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);
-        
+
+        // Make the last brick to be created the active brick.
+        this->activeBrick_ = this->bricks_.back();
+
+        this->player_->startControl(this->activeBrick_);
+        this->activeBrick_->setVelocity(0.0f, -this->center_->getStoneSpeed(), 0.0f);
+        orxout() << "velocity: " << this->center_->getStoneSpeed() << endl;
+        this->activeBrick_->setCameraPosition(cameraIndex);
+    }
+
+    void Tetris::createBrick(void)             //TODO: random rotation offset between 0 and 3 (times 90°)
+    {
+        // Create a new brick and add it to the list of bricks && to the list of stones.
+        TetrisBrick* brick = new TetrisBrick(this->center_);
+        this->bricks_.push_back(brick);
+        for (unsigned int i = 0; i < brick->getNumberOfStones(); i++)
+        {
+            this->stones_.push_back(brick->getStone(i));
+        }
+
         // 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);
+        brick->addTemplate(this->center_->getStoneTemplate()); // TODO: find error concerning the cameras
+
+        // Attach the brick to the Centerpoint and set the position of the brick to be at the top middle.
+        this->center_->attach(brick);
         float xPos = (this->center_->getWidth()/2 + ((this->center_->getWidth() % 2)*2-1)/2.0f)*this->center_->getStoneSize();
         float yPos = (this->center_->getHeight()-0.5f)*this->center_->getStoneSize();
-        stone->setPosition(xPos, yPos, 0.0f);
-        stone->setGame(this);
-    }
+        brick->setPosition(xPos, yPos, 0.0f);
+        brick->setGame(this);
+    }
+
 
     /**
@@ -282 +324 @@
     }
 
+    /*TetrisCenterpoint* Tetris::getCenterpoint(void) const
+    {
+        return this->center_;
+    }*/
+
     /**
     @brief Set the TetrisCenterpoint (the playing field).

code/branches/pCuts/src/modules/tetris/Tetris.h

@@ -68 +68 @@
 
             PlayerInfo* getPlayer(void) const; //!< Get the player.
+            WeakPtr<TetrisCenterpoint> getCenterpoint(void)
+                { return this->center_; }
 
             bool isValidMove(TetrisStone* stone, const Vector3& position);
+            bool isValidMove(TetrisBrick* brick, const Vector3& position);
 
         protected:
@@ -75 +78 @@
 
         private:
-            void startStone(void); //!< Starts with the first stone.
-            void createStone(void);
+            void startBrick(void);
+            void createBrick(void);
             void cleanup(void); //!< Cleans up the Gametype by destroying the ball and the bats.
             bool isValidStonePosition(TetrisStone* stone, const Vector3& position);
+            bool isValidBrickPosition(TetrisBrick* brick, const Vector3& position);
             
             PlayerInfo* player_;
 
             WeakPtr<TetrisCenterpoint> center_; //!< The playing field.
+            std::vector<TetrisBrick*> bricks_; //!< A list of all bricks in play.
             std::vector<TetrisStone*> stones_; //!< A list of all stones in play.
             std::vector< std::vector<bool> > grid_;
-            TetrisStone* activeStone_;
+            TetrisBrick* activeBrick_;
             
             Timer starttimer_; //!< A timer to delay the start of the game.

code/branches/pCuts/src/modules/tetris/TetrisCenterpoint.cc

@@ -55 +55 @@
         this->stoneSize_ = 10.0f;
         this->stoneTemplate_ = "";
+        this->brickTemplate_ = "";
         this->stoneSpeed_ = 20.0f;
         
@@ -69 +70 @@
 
         XMLPortParam(TetrisCenterpoint, "width", setWidth, getWidth, xmlelement, mode); // die Breite
-        XMLPortParam(TetrisCenterpoint, "height", setHeight, setWidth, xmlelement, mode); // die Grösse
+        XMLPortParam(TetrisCenterpoint, "height", setHeight, getHeight, xmlelement, mode); // die Grösse //was sollte das mit setWidth??
         XMLPortParam(TetrisCenterpoint, "stoneSize", setStoneSize, getStoneSize, xmlelement, mode); 
         XMLPortParam(TetrisCenterpoint, "stoneTemplate", setStoneTemplate, getStoneTemplate, xmlelement, mode);
+        XMLPortParam(TetrisCenterpoint, "brickTemplate", setBrickTemplate, getBrickTemplate, xmlelement, mode);
         XMLPortParam(TetrisCenterpoint, "stoneSpeed", setStoneSpeed, getStoneSpeed, xmlelement, mode);
     }

code/branches/pCuts/src/modules/tetris/TetrisCenterpoint.h

@@ -45 +45 @@
 
 namespace orxonox
-{
+{//idea: add 2 triggers to the centerpoint (one to determine when a box would go above the centerpoint;
+//the other to find out when the lowest row is filled totally)
     
     /**
@@ -118 +119 @@
             
             /**
+            @brief Set the template for the bricks.
+            @param template The template name to be applied to each brick.
+            */
+            void setBrickTemplate(const std::string& templateName)
+                { this->brickTemplate_ = templateName; }
+            /**
+            @brief Get the template for the bricks.
+            @return Returns the template name to be applied to each brick.
+            */
+            const std::string& getBrickTemplate(void) const
+                { return this->brickTemplate_; }
+
+            /**
             @brief Set the speed of the stones.
             @param speed The speed to be set.
@@ -137 +151 @@
             float stoneSize_;
             std::string stoneTemplate_;
+            std::string brickTemplate_;
             float stoneSpeed_;
 

code/branches/pCuts/src/modules/tetris/TetrisPrereqs.h

@@ -68 +68 @@
     class TetrisCenterpoint;
     class TetrisStone;
+    class TetrisBrick;
 }
 

code/branches/pCuts/src/modules/tetris/TetrisStone.cc

@@ -36 +36 @@
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
-
-#include <OgreSceneNode.h>
 
 #include "Tetris.h"

code/branches/pCuts/src/modules/tetris/TetrisStone.h

@@ -88 +88 @@
             bool lockRotation_;
             Timer delayTimer_;
-            Timer rotationTimer_;
+            Timer rotationTimer_; ///!< This timer is used to filter out multiple rotation inputs.
 
             Tetris* tetris_;