Tetris- Not functioning properly

[Schandha Ravi]

Hi All,

I tried to run a code which was developed by one of my friends but the code is not running as expected. I tried to debug the code to figure out the problem, but was not successful. Would some one mind to look into this and explain me the problem..

This code is based on Tetris game

    
class Tetris extends JPanel implements ActionListener
{
   // Declaration of game status.
   static final int STATE_GAME_INIT = 0;
   static final int STATE_GAME_RUNNING = 1;
   static final int STATE_GAME_PAUSED = 2;
   static final int STATE_GAME_OVER = 3;
 
// Declaration of Tetris shapes
   static final int shapes[][] = {{0,2,2,2},{0,1,1,1},{0,1,2,3},{0,0,0,1},
{0,1,1,2}, {0,2,2,3},{0,3,3,0}, {0,0,1,1},{0,1,2,2},{0,2,3,3},{0,3,0,0},
{0,1,0,1},{0,2,1,2}, {0,2,3,2},{0,3,0,3}};
   static final int GAME_WIDTH=12, GAME_HEIGHT=20;
   static int game[][];
   static int gameState=STATE_GAME_INIT;
// Declaration of elements in Tetris.
   ImageIcon img[];
   static int imgWidth, imgHeight;
   ImageIcon cursor;
   static int cursorRow, cursorColoumn;
   static boolean selected=false;
   static int selectedRow, selectedColomn;
   static boolean newPair=true;
   // Declaration of game score.
      public int totalScore=0;
// Inner class for implemementing pair elements.
   class Pair
   {
      public int pairLeftRow, pairLeftColor, pairRightRow, pairRightColor, pairColomn;
      private boolean pairLeftPlaced, pairRightPlaced;
 
      // Pair Constructor.
      public Pair()
      {
         pairLeftColor=(int)(5*Math.random());
         pairRightColor=(int)(5*Math.random());
         pairColomn=(int)((GAME_WIDTH-1)*Math.random());
         pairLeftRow=pairRightRow=0;
         pairLeftPlaced=pairRightPlaced=false;
      }
 
// For dropping elements.
      public void move()
      {
         if( (pairLeftRow+1==GAME_HEIGHT) || (game[pairColomn][pairLeftRow+1]!=-1) )
         {
            game[pairColomn][pairLeftRow]=pairLeftColor;
            pairLeftPlaced=true;
         }
         else
         {
            pairLeftRow++;
         }
 
         if( (pairRightRow+1==GAME_HEIGHT) || (game[pairColomn+1][pairRightRow+1]!=-1) )
         {
            game[pairColomn+1][pairRightRow]=pairRightColor;
            pairRightPlaced=true;
         }
         else
         {
            pairRightRow++;
         }
      }
 
// Declaration to settle moving pairs as fixed elements.
      public boolean isPlaced()
      {
         return( pairLeftPlaced && pairRightPlaced );
      }
   }
 
   // Declaration to store the elements  as pair.
   Vector pairVector = new Vector(0,1);
 
// Declaration of Timer.
   static Timer timer;
 
// Declaration of Tetris class constructor.
   public Tetris()
   {
   // Setting the properties to the Game Board.
      setBackground(Color.white);
      setFocusable(true);
      requestFocus();
 
// Declaring and assigning of Tetris elements into ImageIcon array.
      img = new ImageIcon[5];
      img[0] = new ImageIcon("blue.png");
      img[1] = new ImageIcon("green.png");
      img[2] = new ImageIcon("pink.png");
      img[3] = new ImageIcon("red.png");
      img[4] = new ImageIcon("yellow.png");
      cursor = new ImageIcon("cursor.png");
 
// To know the dimensions of the block images and setting the size of the Game Board.
      imgWidth=img[0].getIconWidth();
      imgHeight=img[0].getIconHeight();
 
      setSize(getWidth(),getHeight());
 
      // To add KeyListener to Game Board and to handle the key pressed events.
      addKeyListener( new KeyAdapter()
                      {
                         public void keyPressed(KeyEvent e)
                         {
                            switch(gameState)
                            {
// Case to start the game.
                               case STATE_GAME_INIT:
                                  switch(e.getKeyCode())
                                  {
                                     case KeyEvent.VK_ENTER:
                                        gameState=STATE_GAME_RUNNING;
                                        timer.start();
                                     break;
 }
// Case to move the cursor and swapping the elements.
                               case STATE_GAME_RUNNING:
                               switch(e.getKeyCode())
                               {
                                  case KeyEvent.VK_UP:
                                     if(cursorRow>0)
                                        cursorRow--;
                                     if(selected)
                                     {
                                        selected=false;
                                        if(game[cursorColoumn][cursorRow]!=-1)
                                        {
                                           int color=game[selectedColomn][selectedRow];
                                           game[selectedColomn][selectedRow]=game[cursorColoumn][cursorRow];
                                           game[cursorColoumn][cursorRow]=color;
                                        }
                                     }
                                  break;
                                  case KeyEvent.VK_LEFT:
                                     if(cursorColoumn>0)
                                        cursorColoumn--;
                                     if(selected)
                                     {
                                        selected=false;
                                        if(game[cursorColoumn][cursorRow]!=-1)
                                        {
                                           int color=game[selectedColomn][selectedRow];
                                           game[selectedColomn][selectedRow]=game[cursorColoumn][cursorRow];
                                           game[cursorColoumn][cursorRow]=color;
                                        }
                                     }
                                  break;
                                  case KeyEvent.VK_RIGHT:
                                     if( cursorColoumn < (GAME_WIDTH-1) )
                                        cursorColoumn++;
                                     if(selected)
                                     {
                                        selected=false;
                                        if(game[cursorColoumn][cursorRow]!=-1)
                                        {
                                           int color=game[selectedColomn][selectedRow];
                                           game[selectedColomn][selectedRow]=game[cursorColoumn][cursorRow];
                                           game[cursorColoumn][cursorRow]=color;
                                        }
                                     }
                                  break;
                                  case KeyEvent.VK_DOWN:
                                     if( cursorRow < (GAME_HEIGHT-1) )
                                        cursorRow++;
                                     if(selected)
                                     {
                                        selected=false;
                                        if(game[cursorColoumn][cursorRow]!=-1)
                                        {
                                           int color=game[selectedColomn][selectedRow];
                                           game[selectedColomn][selectedRow]=game[cursorColoumn][cursorRow];
                                           game[cursorColoumn][cursorRow]=color;
                                        }
                                     }
                                  break;
                                  // To swap the element blocks.
                                  case KeyEvent.VK_CONTROL:
                                     if(game[cursorColoumn][cursorRow]!=-1)
                                     {
                                        selectedRow=cursorRow;
                                        selectedColomn=cursorColoumn;
                                        selected=true;
                                     }
                                  break;
                                  // Logic to pause the game.
                                  case KeyEvent.VK_PAUSE:
                                     timer.stop();
                                     gameState=STATE_GAME_PAUSED;
                                  break;
                               }
   checkGame();
   break;
                               // Case to release the paused game.
                               case STATE_GAME_PAUSED:
                                  switch(e.getKeyCode())
                                  {
                                     case KeyEvent.VK_PAUSE:
                                        gameState=STATE_GAME_RUNNING;
                                        timer.start();
                                     break;
                                  }
                               break;
                            }
                            repaint();
                         }
                      }
                    );
 
      game = new int[GAME_WIDTH][GAME_HEIGHT];
 
// Initializing the timer.
      timer = new Timer(10,this);
   }
 
   static long time=0;
   static int t1=100;
 
//  This is used to generate the components randomly in pairs and to check and update the game.
   public void actionPerformed(ActionEvent e)
   {
      if(time==2000)
      {
         time=0;
         t1=t1-10;
      }
      if(time%t1==0)
      {
         newPair=true;
      }
 
      if(newPair)
      {
         pairVector.addElement(new Pair());
         newPair=false;
      }
      else
      {
         for(int i=0;i<pairVector.size();i++)
            ((Pair)(pairVector.elementAt(i))).move();
 
         if( ( !pairVector.isEmpty() ) && (((Pair)(pairVector.firstElement())).isPlaced()) )
            pairVector.remove(0);
      }
 
      checkGame();
      if(updateGame())
      {
         checkGame();
      }
 
      time++;
      repaint();
   }
 
    // This method checks for the fixed elements.
   public void checkGame()
   {
      for(int colomn=0;colomn<GAME_WIDTH;colomn++)
         for(int row=0;row<GAME_HEIGHT;row++)
            if(game[colomn][row]!=-1)
               checkShape(colomn,row);
   }
 
// Used for chechking the Tetris shapes.
   public void checkShape(int colomn, int row)
   {
      for(int shape=0;shape<15;shape++)
      {
         clearShape(colomn,row,shape,1);
      }
   }
 
// Used to clear the Tetris shapes formed.
   public boolean clearShape(int colomn,int row,int shape,int next)
   {
      if(next==4)
      {
         game[colomn][row]=-1;
     System.out.print("Score : "+totalScore);
 totalScore=totalScore+10;
         return true;
      }
 
      switch(shapes[shape][next])
      {
         case 0:
            if( (row-1>=0) && (game[colomn][row]==game[colomn][row-1]) )
               if(clearShape(colomn,row-1,shape,next+1))
               {
                  game[colomn][row]=-1;
                  return true;
               }
               else return false;
            else return false;
         case 1:
            if( (colomn+1<GAME_WIDTH) && (game[colomn][row]==game[colomn+1][row]) )
               if(clearShape(colomn+1,row,shape,next+1))
               {
                  game[colomn][row]=-1;
                  return true;
               }
               else return false;
            else return false;
         case 2:
            if( (row+1<GAME_HEIGHT) && (game[colomn][row]==game[colomn][row+1]) )
               if(clearShape(colomn,row+1,shape,next+1))
               {
                  game[colomn][row]=-1;
                  return true;
               }
               else return false;
            else return false;
         case 3:
            if( (colomn-1>=0) && (game[colomn][row]==game[colomn-1][row]) )
               if(clearShape(colomn-1,row,shape,next+1))
               {
                  game[colomn][row]=-1;
                  return true;
               }
               else return false;
            else return false;
      }
      return false;
   }
 
// This is used to get the visibility of the components and game status.
   public void paintComponent( Graphics g )
   {
      super.paintComponent(g);
 
      switch(gameState)
      {
         case STATE_GAME_INIT:
            g.setFont(new Font("Serif",Font.ITALIC|Font.BOLD,60));
            g.drawString("New Game",50,200);
        g.setFont(new Font("Serif",Font.BOLD,40));
            g.drawString("ENTER",75,300);
         break;
 
         case STATE_GAME_PAUSED:
            g.setFont(new Font("Serif",Font.ITALIC|Font.BOLD,40));
            g.drawString("Game Paused",50,200);
 case STATE_GAME_RUNNING:
            g.setColor(Color.black);
 
            for(int i=0;i<GAME_WIDTH;i++)
               for(int j=0;j<GAME_HEIGHT;j++)
                  if(game[i][j]!=-1)
                     img[game[i][j]].paintIcon(this,g,i*imgWidth,j*imgHeight);
 
            for(int i=0;i<pairVector.size();i++)
            {
               img[((Pair)(pairVector.elementAt(i))).pairLeftColor].paintIcon(this,g,((Pair)(pairVector.elementAt(i))).pairColomn*imgWidth,((Pair)(pairVector.elementAt(i))).pairLeftRow*imgHeight);
               img[((Pair)(pairVector.elementAt(i))).pairRightColor].paintIcon(this,g,(((Pair)(pairVector.elementAt(i))).pairColomn+1)*imgWidth,((Pair)(pairVector.elementAt(i))).pairRightRow*imgHeight);
            }
 
            cursor.paintIcon(this,g,(cursorColoumn)*imgWidth-2,(cursorRow)*imgHeight-2);
 
            for(int colomn=0;colomn<GAME_WIDTH;colomn++)
               if(game[colomn][0]!=-1)
                  gameState=STATE_GAME_OVER;
         break;
 
         case STATE_GAME_OVER:
            timer.stop();
            g.setFont(new Font("Serif",Font.ITALIC|Font.BOLD,60));
            g.drawString("Game Over",50,200);
        g.setFont(new Font("Serif",Font.BOLD,30));
            g.drawString("You Scored "+ totalScore,50,300);
         break;
      }
   }
 
// Getter method to get the game board width.
   public int getWidth()
   {
      return (imgWidth*GAME_WIDTH);
   }
 
// Getter method to get the game board height.
   public int getHeight()
   {
      return (imgHeight*GAME_HEIGHT);
   }
 
// Updates the game after the Tetris shapes are formed.
   public boolean updateGame()
   {
      boolean check=false;
      for(int colomn=0;colomn<GAME_WIDTH;colomn++)
         for(int row=GAME_HEIGHT-1;row>0;row--)
            if( (game[colomn][row]==-1) && (game[colomn][row-1]!=-1) )
            {
               game[colomn][row]=game[colomn][row-1];
               game[colomn][row-1]=-1;
               check=true;
            }
      return check;
   }
}
 
// The class with main method.
public class TetrisGame
{
   public static void main(String args[])
   {
   // Declaration and creation of JFrame object
      JFrame app = new JFrame("Tetris");
      // To set the BorderLayout to the Game Board and set this Layout as center to Game Board.
      app.getContentPane().setLayout(new BorderLayout());
      final Tetris tetris = new Tetris();
      app.getContentPane().add(tetris, BorderLayout.CENTER);
      // To set the size of Window using getWidth() & getHeight() methods and block the resizable capability of Window.
      app.setSize(tetris.getWidth()+8, tetris.getHeight()+34 );
 
// To add WindowListener to this win
      app.addWindowListener(
         new WindowAdapter()
         {
            public void windowClosing(WindowEvent e)
            {
               System.exit(0);
            }
         }
      );
      app.setVisible(true);
  app.setResizable(false);
   }
}
 

When I ran this, the starting score is displayed as 3430. When I debugged the code, instead of "0".

Can some one help me in understanding the problem and the possible solution to correct that.
[ July 31, 2008: Message edited by: Schandha Ravi ]

[vanlalhmangaiha khiangte]

  
 
 // This method checks for the fixed elements.
   public void checkGame()
   {
      for(int colomn=0;colomn<GAME_WIDTH;colomn++)
         for(int row=0;row<GAME_HEIGHT;row++)
            if(game[colomn][row]!=-1)
               checkShape(colomn,row);
   }
 
// Used for chechking the Tetris shapes.
   public void checkShape(int colomn, int row)
   {
      for(int shape=0;shape<15;shape++)
      {
         clearShape(colomn,row,shape,1);
      }
   }
 
// Used to clear the Tetris shapes formed.
   public boolean clearShape(int colomn,int row,int shape,int next)
   {
      if(next==4)
      {
         game[colomn][row]=-1;
     System.out.print("Score : "+totalScore);
 totalScore=totalScore+10;
         return true;
      }
 
      switch(shapes[shape][next])
      {
         case 0:
            if( (row-1>=0) && (game[colomn][row]==game[colomn][row-1]) )
               if(clearShape(colomn,row-1,shape,next+1))
               {
                  game[colomn][row]=-1;
                  return true;
               }
               else return false;
            else return false;
         case 1:
            if( (colomn+1<GAME_WIDTH) && (game[colomn][row]==game[colomn+1][row]) )
               if(clearShape(colomn+1,row,shape,next+1))
               {
                  game[colomn][row]=-1;
                  return true;
               }
               else return false;
            else return false;
         case 2:
            if( (row+1<GAME_HEIGHT) && (game[colomn][row]==game[colomn][row+1]) )
               if(clearShape(colomn,row+1,shape,next+1))
               {
                  game[colomn][row]=-1;
                  return true;
               }
               else return false;
            else return false;
         case 3:
            if( (colomn-1>=0) && (game[colomn][row]==game[colomn-1][row]) )
               if(clearShape(colomn-1,row,shape,next+1))
               {
                  game[colomn][row]=-1;
                  return true;
               }
               else return false;
            else return false;
      }
      return false;
   }
  

Here is the problem :-

This method checkGame() loops N rows and N columns
This will in turn call checkShape() method which will loop 15 times i.e for the shape for each row and column
This will in turn call clearShape() method which loops till next value becomes 4 adn updates the totalscore and then so on ....

I tried printing rows and columns when the total score is updated,
You can try the below code to see when totalscore is updated

public boolean clearShape(int colomn,int row,int shape,int next)
   {
         
 if(next==4)
      {
         game[colomn][row]=-1;
System.out.print(" colomn:"+colomn+" row:"+row+" shape:"+shape);
    totalScore=totalScore+10;
         return true;
      }
 

I believe the logic is completely off ...

regards,