How to debug this key listener

Question

how would I figure out what this key listener is actually doing, if anything?
piece1 is a new piece object that has a center at certain part on a matrix, with its width being at startPlaceX.
What I think should happened here is that when the user presses the left arrow key, it calls moveXLeft, which in turn, decrements the spot on the matrix that the current piece is.
In otherwords, how can I tell that the keyListener is doing anything? I have a function in my actionListener
  public void startAnimation()
       if (animationTimer == null)
          animationTimer = new Timer(ANIMATION_DELAY, new TimerHandler());
          animationTimer.start();
       else
          if (!animationTimer.isRunning())
               animationTimer.restart();
    public class TimerHandler implements ActionListener
      public void actionPerformed(ActionEvent actionEvent)
                 piece1.moveDown(board);
             piece1.drawIt(board, true);
                     repaint();
     public void moveDown(int[][]board)
          //startPlaceY++;
               startPlaceY++;that works (IE, every given interval, it moves the specified piece down by 1)
here is the code in question
     public void moveXLeft(int [][]temp)
          startPlaceX--;
          //startPlaceY+= change;
    public class KeyHandler implements KeyListener
         public void keyPressed(KeyEvent event)
             switch (event.getKeyCode())
                  case KeyEvent.VK_LEFT:
                       piece1.moveXLeft(board);
                       //x -= size;
                       break;
                  case KeyEvent.VK_RIGHT:
                       piece1.moveXRight(-1);
                       //x += size;
                       break;
             repaint();
         public void keyReleased(KeyEvent event) {}
         public void keyTyped(KeyEvent event) {}
    }if you need any more info, please say so.
Edited by: thenextbesthang on Dec 16, 2007 12:33 PM
Edited by: thenextbesthang on Dec 16, 2007 12:33 PM

Answer 1

heres the whole of my code (right now)
import java.awt.* ;
import java.awt.event.* ;
import javax.swing.* ;
import java.awt.font.* ;
import java.awt.geom.* ;
public class project3{
public static void main(String[] args)
        JFrame window = new JFrame();
         window.setTitle("Tetris");
    commenceGame begin = new commenceGame();
         begin.init();         
         begin.startAnimation();
         window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);         
         window.getContentPane().add(begin);
         window.pack(); 
         window.setVisible( true );
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class Pieces{
     public int x;
     public int y;
     public int cross[][] =  {{1,1,1},
               {0,1,0}};
     private int leftL[][] =  {{2,2,2},
                     {2,0,0}};
     private int rightL[][] = {{3,3,3},
                                        {0,0,3}};
     private int leftS[][] =  {{0,4,4},
                    {4,4,0}};
     private int rightS[][] = {{5,5,0},
                    {0,5,5}};
     private int square[][] = {{6,6},
                    {6,6}};
     private int tetris[][]=    {{7,7,7,7}};
     private int blankSquare[][] ={{0}};
     public int startPlaceY;
     public int startPlaceX;
     public int shape;
     public int replacement_board[][];
     public Pieces()
          x = 0;
          y = 1;
          startPlaceX = 4;
          startPlaceY = 0;     
          shape = (int)(Math.random()*7);
          replacement_board = new int[20][10];          
     public int[][] drawIt(int[][]temp2_board, boolean por)
          //1
          //temp2_board = replacement_board;
          makeTetris(temp2_board);     
          //if(por) makeCross(temp2_board);//2
     //     temp2_board = replacement_board;
     //     else    reMakeCross(replacement_board);
/*          switch(shape)
            case 0:
                   makeCross(temp2_board);           
                 break;
            case 1:
                   makeLeftL(temp2_board);           
                 break;      
            case 2:
                   makeRightL(temp2_board);           
                 break; 
            case 3:
                   makeLeftS(temp2_board);           
                 break;      
            case 4:
                   makeRightS(temp2_board);           
                 break; 
            case 5:
                   makeSquare(temp2_board);           
                 break;      
            case 6:
                    makeTetris(temp2_board);      
                 break;               
          return temp2_board;
     public int[][] makeCross(int[][]temp)
           replacement_board= temp;
          for(int i=0;i<temp.length;i++)
               for(int j = 0;j<temp[0].length;j++)
                    temp[i][j] = 0;
          int color;                    
        for(int i = 0;i<2;i++)
             for(int j = 0;j<3;j++)
                  color = cross[i][j];
                  temp[startPlaceX+i][startPlaceY+j] = color;
        return(temp);
     //this method is designed to take the initial condition and create the new matrix
     public int[][] makeLeftL(int[][]temp)
          for(int i=0;i<temp.length;i++)
               for(int j = 0;j<temp[0].length;j++)
                    temp[i][j] = 0;
          int color;                    
        for(int i = 0;i<2;i++)
             for(int j = 0;j<3;j++)
                  color = leftL[i][j];
                  temp[startPlaceX+i][startPlaceY+j] = color;
        return temp;
     public int[][] makeRightL(int[][]temp)
          for(int i=0;i<temp.length;i++)
               for(int j = 0;j<temp[0].length;j++)
                    temp[i][j] = 0;
          int color;                    
        for(int i = 0;i<2;i++)
             for(int j = 0;j<3;j++)
                  color = rightL[i][j];
                  temp[startPlaceX+i][startPlaceY+j] = color;
        return temp;
     public int[][] makeLeftS(int[][]temp)
          for(int i=0;i<temp.length;i++)
               for(int j = 0;j<temp[0].length;j++)
                    temp[i][j] = 0;
          int color;                    
        for(int i = 0;i<2;i++)
             for(int j = 0;j<3;j++)
                       color = leftS[i][j];
                  temp[startPlaceX+i][startPlaceY+j] = color;
        return temp;
     public int[][] makeRightS(int[][]temp)
          for(int i=0;i<temp.length;i++)
               for(int j = 0;j<temp[0].length;j++)
                    temp[i][j] = 0;
          int color;                    
        for(int i = 0;i<2;i++)
             for(int j = 0;j<3;j++)
                  color = rightS[i][j];
                  temp[startPlaceX+i][startPlaceY+j] = color;
        return temp;     
     public int[][] makeSquare(int[][]temp)
          for(int i=0;i<temp.length;i++)
               for(int j = 0;j<temp[0].length;j++)
                    temp[i][j] = 0;
          int color;                    
        for(int i = 0;i<2;i++)
             for(int j = 0;j<2;j++)
                  color = square[i][j];
                  temp[startPlaceX+i][startPlaceY+j] = color;
        return temp;
     public int[][] makeTetris(int[][]temp)
          for(int i=0;i<temp.length;i++)
               for(int j = 0;j<temp[0].length;j++)
                    temp[i][j] = 0;
          int color;                    
        for(int i = 0;i<4;i++)
             for(int j = 0;j<1;j++)
                  color = tetris[j];
          temp[startPlaceX+i][startPlaceY+j] = color;
return temp;
     public int[][] makeBlankSquare(int[][]temp, boolean check)
          int color;                    
for(int i = 0;i<1;i++)
     for(int j = 0;j<1;j++)
          if(check) color = blankSquare[i][j];
          else color = 0;
          temp[startPlaceX+i][startPlaceY+j] = color;
return temp;
     public void moveDown(int[][]board)
          //startPlaceY++;
               startPlaceY++;
          replacement_board = board;
          System.out.println(startPlaceY);
          //temp[startPlaceX+i][startPlaceY+j] = color;
               replacement_board = board;
               if(board[startPlaceY][startPlaceX] &&
               board[startPlaceY+1][startPlaceX] &&
               board[startPlaceY-1][startPlaceX] &&
               board[startPlaceY][startPlaceX+1] &&
               board[i][j]==1) board[i][j]=0;
               for(int i=0;i<board.length;i++)
                    for(int j = 0;j<board[0].length;j++)
                         System.out.print(board[i][j] + " ");
                    System.out.println();
               System.out.println();
               //System.out.println(startPlaceY);
               //makeCross(board);
               //return replacement_board;               
     public void moveXLeft(int [][]temp)
          startPlaceX--;
          //startPlaceY+= change;
     public void moveXRight(int [][]temp)
          startPlaceX++;
          makeCross(replacement_board);
          //startPlaceY+= change;
     public int[][] killLiving(int[][]temp)
          for(int i = 0;i<temp.length;i++)
               for(int j = 0;j<temp[0].length;j++)
                    if(temp[i][j]!= 0)
                         temp[i][j] = -1;
     return temp;
}          import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class commenceGame extends JPanel
     public int x;//starting x location of block
     public int y;//starting y location of block
     public int width;//width of block
     public int height;//height of block
     public int board[][];
     /*{{-1,-1, -1, -1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},
                                   {-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1},     
                                   {-1,-1, -1, -1,-1,-1,-1,-1,-1,-1,-1,-1,-1}};//game play board*/
     public int temp_storage_board[][];
     public int xBoard;//width of board matrix
     public int yBoard;//height of board matrix
     public Timer animationTimer;
     public int ANIMATION_DELAY;
     Pieces piece1;//the piece that gets modified
     Pieces piece2;//the piece that is the result of the modification
     public commenceGame()
          xBoard = 10;
          yBoard = 20;
          width = 20;
          height = 20;
          x = 5;
          y = 0;          
          board = new int[yBoard][xBoard];
          //this is the board where pieces appear
          temp_storage_board = new int[yBoard][xBoard];//this is the main board          
          piece1 = new Pieces();
          piece1.drawIt(board, true);
     //     piece2 = new Pieces();
     //     piece2.drawIt(board, false);
          ANIMATION_DELAY = 500;
public void init()
          JPanel panel = new beginGame();
          add(panel);
public class beginGame extends JPanel
          public beginGame()
               setPreferredSize(new Dimension(400,800));
               setBackground(Color.white);               
public void paintComponent(Graphics g)
               super.paintComponent(g);
               Graphics2D g2 = (Graphics2D)g;
               temp_storage_board = board;
          for (int i = 0 ; i < yBoard; i++)
                    for (int j = 0 ; j < xBoard; j++)
                              if(temp_storage_board[i][j] == 1) drawCross(g2, i, j);
                              else if(temp_storage_board[i][j] == 2) drawLeftL(g2, i, j);
                              else if(temp_storage_board[i][j] == 3) drawRightL(g2, i, j);
                              else if(temp_storage_board[i][j] == 4) drawLeftS(g2, i, j);
                              else if(temp_storage_board[i][j] == 5) drawRightS(g2, i, j);
                              else if(temp_storage_board[i][j] == 6) drawSquare(g2, i, j);
                              else if(temp_storage_board[i][j] == 7) drawTetris(g2, i, j);
                              else if(temp_storage_board[i][j] == -1) drawDeadSquare(g2, i, j);                               
          public void drawCross(Graphics2D g2, int x, int y)     
               // piece1.makeCross(board, true);
               g2.setColor(Color.red);
               g2.fillRect(x*width,y*height,width,height);
               g2.setColor(Color.black);
               g2.drawRect(x*width,y*height,width,height);
          //else if (board[i][x] == 2)
          public void drawLeftL(Graphics2D g2, int x, int y)                    
               // piece1.makeLeftL(board, true);
               g2.setColor(Color.red);
               g2.fillRect(x*width,y*height,width,height);
               g2.setColor(Color.black);
               g2.drawRect(x*width,y*height,width,height);
               //else if (board[i][x] == 3)
          public void drawRightL(Graphics2D g2, int x, int y)
               // piece1.makeRightL(board, true);
               g2.setColor(Color.cyan);
               g2.fillRect(x*width,y*height,width,height);
               g2.setColor(Color.black);
               g2.drawRect(x*width,y*height,width,height);
               //else if (board[i][x] == 4)
          public void drawLeftS(Graphics2D g2, int x, int y)
               // piece1.makeLeftS(board, true);
               g2.setColor(Color.orange);
               g2.fillRect(x*width,y*height,width,height);
               g2.setColor(Color.black);
               g2.drawRect(x*width,y*height,width,height);
               //else if (board[i][x] == 5)
          public void drawRightS(Graphics2D g2, int x, int y)
               // piece1.makeRightS(board, true);
               g2.setColor(Color.yellow);
               g2.fillRect(x*width,y*height,width,height);
               g2.setColor(Color.black);
               g2.drawRect(x*width,y*height,width,height);
               //else if (board[i][x] == 6)
          public void drawSquare(Graphics2D g2, int x, int y)
               // piece1.makeSquare(board, true);
               g2.setColor(Color.blue);
               g2.fillRect(x*width,y*height,width,height);
               g2.setColor(Color.black);
               g2.drawRect(x*width,y*height,width,height);
               //else if (board[i][x] == 7)
          public void drawTetris(Graphics2D g2, int x, int y)
               // piece1.makeTetris(board, true);
               g2.setColor(Color.green);
               g2.fillRect(x*width,y*height,width,height);
               g2.setColor(Color.black);
               g2.drawRect(x*width,y*height,width,height);
          //     else if (board[i][x] == 0)
          public void drawBlankSquare(Graphics2D g2, int x, int y)
               // piece1.makeBlankSquare(board, true);
               g2.setColor(Color.white);
               g2.fillRect(x*width,y*height,width,height);
               //else if (board[i][x] == -1)
          public void drawDeadSquare(Graphics2D g2, int x, int y)
               // piece1.makeDeadSquare(board, true);
               g2.setColor(Color.gray);
               g2.fillRect(x*width,y*height,width,height);
public void startAnimation()
if (animationTimer == null)
animationTimer = new Timer(ANIMATION_DELAY, new TimerHandler());
animationTimer.start();
else
if (!animationTimer.isRunning())
animationTimer.restart();
public class TimerHandler implements ActionListener
public void actionPerformed(ActionEvent actionEvent)
          // System.out.println("aP");
          piece1.moveDown(board);
     //     piece1.moveXLeft(board);
          piece1.drawIt(board, true);
          repaint();
          if (piece1.startPlaceY> 10)
               piece1.killLiving(board);
     //y += size;
     //if (y > height) y = 10;
public class KeyHandler implements KeyListener
     public void keyPressed(KeyEvent event)
     switch (event.getKeyCode())
          case KeyEvent.VK_LEFT:
               piece1.moveXLeft(board);
               //x -= size;
               break;
          case KeyEvent.VK_RIGHT:
               piece1.moveXRight(board);
               //x += size;
               break;
     repaint();
     public void keyReleased(KeyEvent event) {}
     public void keyTyped(KeyEvent event) {}
Basically, what this does is creates an applet, picks a random piece, and makes the piece fall down until it reaches the end (at which point it can't fall down any further)
As I mentioned before, the method: public class TimerHandler implements ActionListener
public void actionPerformed(ActionEvent actionEvent)
          // System.out.println("aP");
          piece1.moveDown(board);works, because the thing DOES fall down.
However, when I try to replicate that with the keyListener, using essentially the same process, it doesn't work.
I'll look up what yall said