J2ME를 이용해서 넷빈으로 짠 테트리스 코딩입니다.
클래스는 3개 이고 스페이스 기능을 추가하려하는데 잘안되네요.
도와주세요
밑ㅇㅔ 있습니다.

import javax.microedition.lcdui.*;
import java.io.*;
import java.util.Random;

class TetrisTask extends Thread {
 int mode;
 final int MODE_NORMAL = 1;
 final int MODE_GAMEOVER = 2;
 final int MODE_START = 3;

 final int CELL_WIDTH = 10;
 final int CELL_HEIGHT = 15;

    final int ROTATE_0X0 = 0;
 final int ROTATE_3X3 = 1;
 final int ROTATE_4X4 = 2;

 final int NOBLOCK = 9;  

    final int COLOR_INIT = 0;
 final int COLOR_BLACK = 7;
 final int COLOR_R = 0, COLOR_G = 1, COLOR_B = 2;

 Random random = new Random();
 GameCanvas canvas; //Canvas

 int blockNumber;            //현재 블럭일번
 int nextBlock;              //다음 블럭번호
    final int TOTAL_BLOCK = 7;  //전체 블럭개수

 int backBoard[][] = new int[CELL_WIDTH][CELL_HEIGHT];    //전체 블럭 보드
 int blockDataBase[][][] = new int[TOTAL_BLOCK][4][4];    //전체 블럭 테이블
 int blockRotateType[] = new int[TOTAL_BLOCK];            //Rotate_Type

 int mbx;                //움직이는 block의 x 좌표
 int mby;                //움직이는 block의 y 좌표

 int movingBlockRotateType;
 int movingBlock[][] = new int[4][4];

 Image overImage;
 Image numberImage[] = new Image[10];
 Image scoreImage;
 Image nextImage;

 int score = 0;
 int speed = 1;
   
 int colorTable[][] = {
  { 200, 255, 120 }, 
  { 255,   0, 120 },
  { 255, 255, 120 },
  {   0, 120, 255 },
  {   0, 255, 120 },
  { 120, 120,   0 },
  { 120, 255, 255 },
  {   0,   0,   0 }
    };
 
    public TetrisTask(GameCanvas canvas) {
        this.canvas = canvas;
        try {
            overImage = Image.createImage("/go.png"); // Game Over 이미지
            scoreImage = Image.createImage("/gs.png"); // Game Score 이미지
            for (int i=0; i<10; i++) {
                numberImage[i] = Image.createImage("/" + i + ".png");
            }
            nextImage = Image.createImage("/gn.png"); // Next 블럭 이미지
        } catch(IOException ioe) {
            System.out.println("FILE IO ERROR: " + ioe);
        }

        int blockPattern0[][] = {
            { 9, 9, 9, 9 },
            { 9, 9, 9, 9 },
            { 0, 0, 0, 0 },
            { 9, 9, 9, 9 }
        };
        addPattern(blockPattern0, ROTATE_4X4);

        int blockPattern1[][] = {
            { 9, 9, 9, 9 },
            { 1, 9, 9, 9 },
            { 1, 1, 1, 9 },
            { 9, 9, 9, 9 }
        };
        addPattern(blockPattern1, ROTATE_3X3);

        int blockPattern2[][] =  {
            { 9, 9, 9, 9 },
            { 9, 9, 2, 9 },
            { 2, 2, 2, 9 },
            { 9, 9, 9, 9 }
        };
        addPattern(blockPattern2, ROTATE_3X3);

        int blockPattern3[][] =  {
            { 9, 9, 9, 9 },
            { 3, 3, 9, 9 },
            { 9, 3, 3, 9 },
            { 9, 9, 9, 9 }
        };
        addPattern(blockPattern3, ROTATE_3X3);

        int blockPattern4[][] =  {
            { 9, 9, 9, 9 },
            { 9, 4, 4, 9 },
            { 4, 4, 9, 9 },
            { 9, 9, 9, 9 }
        };
        addPattern(blockPattern4, ROTATE_3X3);

        int blockPattern5[][] =  {
            { 9, 9, 9, 9 },
            { 9, 5, 5, 9 },
            { 9, 5, 5, 9 },
            { 9, 9, 9, 9 }
        };
        addPattern(blockPattern5, ROTATE_0X0);

        int blockPattern6[][] =  {
            { 9, 9, 9, 9 },
            { 9, 6, 9, 9 },
            { 6, 6, 6, 9 },
            { 9, 9, 9, 9 }
        };
        addPattern(blockPattern6, ROTATE_3X3);

        nextBlock = (int)(Math.abs(random.nextInt()) % blockNumber);

        updateMovingBlock();
        mode = MODE_START;

        for(int i=0; i<CELL_WIDTH; i++) {
            for(int ii=0; ii<CELL_HEIGHT; ii++) {
                backBoard[i][ii] = COLOR_INIT;
            }
        }
    }

 protected void paint(Graphics g) { 
  try {
            sleep(100);
  } catch(Exception e) { }
  
  g.setColor(0, 0, 0);
  g.fillRect(0, 0,canvas.getWidth(),canvas.getHeight());
  
  try {
            for(int i=0; i<CELL_WIDTH; i++) {
                for(int ii=0; ii<CELL_HEIGHT; ii++) {
                    if(backBoard[i][ii] != NOBLOCK)
                        drawCell(g, backBoard[i][ii], i * 6 + 1, ii * 6 + 10, 5, 5);
                    else
                        drawCell(g, COLOR_BLACK, i * 6 + 1, ii * 6 + 10, 5, 5);
    }
   }
  } catch(Exception e) {}

  g.setColor(255, 255, 0);
  g.drawLine(61, 10, 61, 100);

  drawScore(g); 
  drawNextBlock(g); 
  drawMovingBlock(g);

  if(mode == MODE_GAMEOVER) {
            g.drawImage(overImage,canvas.getWidth()/4,5+canvas.getHeight()/4,
   g.HCENTER | g.VCENTER);
  }
 }

 protected void keyHandler(int action) {

        switch(action) {
            case Canvas.RIGHT: // right key
                if (mode != MODE_NORMAL) return;
                mbx++;
                if(!moveOK()) mbx--;
                canvas.repaint();
                break;

            case Canvas.LEFT: // left key
                if(mode != MODE_NORMAL) return;
                mbx--;
                if(!moveOK()) mbx++;
                canvas.repaint();
                break;

            case Canvas.DOWN: // down key
                if(mode == MODE_NORMAL)
                    normalProc();
                break;
          
            case Canvas.UP:
            case Canvas.FIRE:

/여기에 코딩을 추가해서 스페이스키를 코딩해야 하는데요 도와주세요
                         switch(mode) {
                    case MODE_NORMAL:
                        int tempBlock[][] = new int[4][4];
                        for(int i=0; i<4; i++) {
                            for(int ii=0; ii<4; ii++) {
                                tempBlock[i][ii] = movingBlock[i][ii];
                            }
                        }

                        int w;
                        if(movingBlockRotateType == ROTATE_3X3) {
                            w = movingBlock[2][0];
                            movingBlock[2][0] = movingBlock[2][2];
                            movingBlock[2][2] = movingBlock[0][2];
                            movingBlock[0][2] = movingBlock[0][0];
                            movingBlock[0][0] = w;
                            w = movingBlock[1][0];
                            movingBlock[1][0] = movingBlock[2][1];
                            movingBlock[2][1] = movingBlock[1][2];
                            movingBlock[1][2] = movingBlock[0][1];
                            movingBlock[0][1] = w;
                        }
                        if(movingBlockRotateType == ROTATE_4X4) {
                            w = movingBlock[2][0];
                            movingBlock[2][0] = movingBlock[0][2];
                            movingBlock[2][1] = movingBlock[0][2];
                            movingBlock[2][3] = movingBlock[0][2];
                            movingBlock[0][2] = w;
                            movingBlock[1][2] = w;
                            movingBlock[3][2] = w;
                        }

                        if(!moveOK()) {
                            for(int i=0; i<4; i++) {
                               for(int ii=0; ii<4; ii++) {
                                    movingBlock[i][ii]=tempBlock[i][ii];
                                }
                            }
                        } else {
                            canvas.repaint();
                        }
                        break;

                    case MODE_GAMEOVER:
                        mode = MODE_START;
                        score = 0;
                        break;
                } // endswitch(Fire mode)
            break;
        } // end-switch(action)

    }

 void drawCell(Graphics g,int cindex,int x,int y,int sx,int sy) {
        g.setColor(colorTable[cindex][COLOR_R],colorTable[cindex][COLOR_G],
                colorTable[cindex][COLOR_B]);
  g.fillRect(x, y, sx, sy);
 }

 void drawScore(Graphics g) {
  int n, s = 0;
        g.drawImage(scoreImage, 65, 52, g.LEFT | g.TOP);
        System.out.println("score:"+score);
        for(int i=4, j=0; i>=0; i--, j++) {
            int p = 0;
            p = pow(10,i);
            if (i < 1) p = 1;
            System.out.print("i:"+i+" p:"+p);
            n = (int)((score - s) / p);
            s += (n * p);
            System.out.println(", n:"+n+" s:"+s);
            g.drawImage(numberImage[n], 68 + (5 * j), 70, g.LEFT | g.TOP);
        }
 }

    int pow(int v, int n) {
      //System.out.println("v:"+v+" n:"+n);
  n--;
      //System.out.println("v:"+v+" n:"+n);
  if (n < 1) return v;
        return v * pow(v, n);
    }

 void drawNextBlock(Graphics g) {
  g.drawImage(nextImage, 65, 10, g.LEFT | g.TOP);
  for(int i=0; i<4; i++) {
            for(int ii=0; ii<4; ii++) {
                if(blockDataBase[nextBlock][i][ii] != NOBLOCK)
                    drawCell(g, blockDataBase[nextBlock][i][ii],
                        (i * 6) + 67, (ii * 6) + 25, 5, 5);
            }
        }
   }

    void drawMovingBlock(Graphics g) {
  for(int i=0; i<4; i++) {
            for(int ii=0; ii<4; ii++) {
                if(movingBlock[i][ii] != NOBLOCK) {
                    drawCell(g, movingBlock[i][ii], (i+mbx)*6 + 1,
                        (ii+mby)*6 + 10, 5, 5);
                }
            }
        }
  }

    public void run() {
        try {
            while(true) {
                switch(mode) {
                    case MODE_START:
                        startProc();
                        break;
                    case MODE_NORMAL:
                        normalProc();
                        break;
                    case MODE_GAMEOVER:
                        break;
                }
                Thread.sleep((int)(1000 / speed));
            }
        } catch(Exception e) {
            e.printStackTrace();
        }
 }

    public void addPattern(int ptrn[][], int rflag) {
  if(blockNumber >= TOTAL_BLOCK) return;
  for(int i=0; i<4; i++) {
            for(int ii=0; ii<4; ii++) {
                blockDataBase[blockNumber][i][ii] = ptrn[i][ii];
            }
  }
  blockRotateType[blockNumber] = rflag;
  blockNumber++;
 }
 
 void updateMovingBlock() {
        //System.out.println(nextBlock);
        for(int i=0; i<4; i++) {
            for(int ii=0; ii<4; ii++) {
                movingBlock[i][ii] = blockDataBase[nextBlock][i][ii];
                movingBlockRotateType = blockRotateType[nextBlock];
            }
        }
        mbx = 4;
        mby = 0;
        nextBlock = (int)(Math.abs(random.nextInt()) % blockNumber);
 }
 
 boolean moveOK() {
        try {
            for(int i=0; i<4; i++) {
                for(int ii=0; ii<4; ii++) {
                    if(movingBlock[i][ii] != NOBLOCK) {
                        if((i+mbx < 0) || (i+mbx >= CELL_WIDTH)
                            || (ii+mby < 0)|| (ii+mby >= CELL_HEIGHT)) {
                            return false;
                        }
                        if(backBoard[i+mbx][ii+mby] != NOBLOCK) {
                            return false;
                        }
                    }
                }
            }
        } catch(Exception e) {
            System.out.println("Exception in moveOK");
        }
        return true;
    }

 void startProc() {
  for(int i=0; i<CELL_WIDTH; i++) {
            for(int ii=0; ii<CELL_HEIGHT; ii++) {
                backBoard[i][ii] = NOBLOCK;
            }
        }
        mode = MODE_NORMAL;
        canvas.repaint();
 }

    void normalProc() {
        mby++;

  if(!moveOK()) { 
   mby--;
   freezeMovingBlock();
   canvas.repaint();
  }

        canvas.repaint();
  formALine();

        int w = (int)((score % 5000) / 1000);
  w++;
  speed = w;
    }

    void freezeMovingBlock() {
       
        for(int i=0; i<4; i++) {
            for(int ii=0; ii<4; ii++) {
                if(movingBlock[i][ii] != NOBLOCK) {
                    backBoard[i+mbx][ii+mby] = movingBlock[i][ii];
                }
             }
        }
        updateMovingBlock();
        canvas.repaint(); 
        if(!moveOK()) mode = MODE_GAMEOVER;
 }

    void formALine() {

  boolean flg;
  int lscore = 0;

  for(int i=(CELL_HEIGHT-1); i>=0; i--) {
            flg = true;
            //한 라인이 블럭으로 모두 채워지면
            for(int ii=0; ii<CELL_WIDTH; ii++) {
                if(backBoard[ii][i] == NOBLOCK)
                    flg = false;
            }
            //위의 라인들을 채워진 라인의 위치로 옮긴다.
            if(flg) {
                for(int y=i; y>=1; y--) {
                    for(int x=0; x<CELL_WIDTH; x++) {
                        backBoard[x][y] = backBoard[x][y-1];
                    }
                }
                //채워진 라인의 제거로 인해 남은라인들의  y좌표 수정
                i++;
                lscore++;
                canvas.repaint();
                try {
                    sleep(100);
                } catch(InterruptedException ie) { }
            }
        }

        switch(lscore) { //line 365 : 점수를 올린다.
            case 1:
                score += 123;
   break;
            case 2:
                score += 234;
   break;
            case 3:
                score += 567;
   break;
            case 4:
                score += 1234;
   break;
        }

        if(lscore > 0) {
            canvas.repaint();
            try {
                sleep(100);
            } catch(InterruptedException ie) { }
        }
 }
}