Uncaught exception 的问题 高人请进 ！！！

Question

程序 等等我给你找  一个俄罗斯方块的游戏 j2me的 不过和j2me没啥实质关系......................................................................
block.java/*
 * Created on 2004-7-6
 *
 */import java.util.Random;import javax.microedition.lcdui.Graphics;
/**
 * @author ShiL_Genius
 *
 */
public class Block {

//Block[S][x][y] 
//第一个 [] 表示block的不同重翻转的状态
//第二个[] 表示block的行 第三个[]表示列

private static boolean LeftL[][][]={ //0
{
{true,false,false},
{true,false,false},
{true,true,false}
},
{
{false,false,true},
{true,true,true},
{false,false,false}
},
{
{false,true,true},
{false,false,true},
{false,false,true}
},
{
{true,true,true},
{true,false,false},
{false,false,false}
}
};

private static boolean RightL[][][]={ //1
{
{false,false,true},
{false,false,true},
{false,true,true}
},
{
{true,false,false},
{true,true,true},
{false,false,false}
},
{
{true,true,false},
{true,false,false},
{true,false,false}
},
{
{true,true,true},
{false,false,true},
{false,false,false}
}
};

private static boolean Shan[][][]={ //2
{
{false,true,false},
{true,true,true},
{false,false,false}
},
{
{true,false,false},
{true,true,false},
{true,false,false}
},
{
{true,true,true},
{false,true,false},
{false,false,false}
},
{
{false,false,true},
{false,true,true},
{false,false,true}
}
};

private static boolean LeftZ[][][]={ //3
{
{false,true,true},
{true,true,false},
{false,false,false}
},
{
{true,false,false},
{true,true,false},
{false,true,false}
}
};

private static boolean RightZ[][][]={ //4
{
{true,true,false},
{false,true,true},
{false,false,false}
},
{
{false,true,false},
{true,true,false},
{true,false,false}
}
};

private static boolean I[][][]={ //5
{

{false,false,false},
{true,true,true},
{false,false,false}
},
{
{false,true,false},
{false,true,false},
{false,true,false}
}
};

private static boolean Square[][][]={ //6
{
{true,true,false},
{true,true,false},
{false,false,false}
}
};

public boolean B[][][][]={LeftL,RightL,Shan,LeftZ,RightZ,I,Square};


private java.util.Random random;
public int curShape; //现在的block的形状
public int nextShape; //下一个block的形状
public int curState; //现在block的状态
public int B_X;    //block的x
public int B_Y; //block的y

public Block(){
B_X=MyCanvas.G_W/2; 
B_Y=0;
random=new Random();
curShape=nextShape();
nextShape=nextShape();
}
//block向下移动一个单位
public synchronized void down(){
B_Y+=MyCanvas.BRICK_WIDTH/3;
}
//向右
public synchronized void right(){
B_X+=MyCanvas.BRICK_WIDTH;
}
//向左
public synchronized void left(){
B_X-=MyCanvas.BRICK_WIDTH;
}

//前一个block落下 设置下一个block状态 
public synchronized void setNewShape(){
curShape=nextShape;
nextShape=nextShape();
B_X=MyCanvas.G_W/2;
B_Y=0;
}

//random 产生下一个block形状的代号
private int nextShape(){
return Math.abs(random.nextInt()) % 7;
}

//循环状态
public synchronized void changeStatus(){
if(curState+1==B[curShape].length){
curState=0;
}else{
curState++;
}
}

/*
public int[][] getCurBlock(){

}

public int[][][] getNextBlock(){
return B[nextShape];
}
*/

public int getX(){
return B_X;
}

public int getY(){
return B_Y;
}

//画每个 block的 基本brick
private synchronized void drawBrick(Graphics g,int x,int y){
g.fillRect(B_X+x*MyCanvas.BRICK_WIDTH,B_Y+y*MyCanvas.BRICK_WIDTH,
MyCanvas.BRICK_WIDTH,MyCanvas.BRICK_WIDTH);
}
//通过 从GameCanvas传来的的Graphics 在缓冲画布上画画
public synchronized void drawBlock(Graphics g){
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(B[curShape][curState][i][j]){
g.fillRect(B_X+j*MyCanvas.BRICK_WIDTH,B_Y+i*MyCanvas.BRICK_WIDTH,
MyCanvas.BRICK_WIDTH,MyCanvas.BRICK_WIDTH);
}
}
}
}}

Answer 1

......................................................................
matrix.javaimport javax.microedition.lcdui.Graphics;/*
 * Created on 2004-7-7
 *
 *//**
 * @author ShiL_Genius
 * 
 * 思想: 把整个屏幕看成是一个2维数组
 */
public class Matrix {

private boolean matrix[][]; //二维数组的screen
private boolean rowEx[]; //数组表示 行里是否有 block 有为true
private int M_Row; //总体行数
private int M_Col; //总体列数
private int wallX; //我想在画布的 1/4处画 一条竖线 左面显示 
// 下一个要落下的block的形状和 积分 右边是游戏区
private int startX; //游戏区的开始 x坐标
private int del_1; //若一行满了要消除 最多能删3行 block数据结构决定 
private int del_2; //从第一个开始使用 纪录消除的行号
private int del_3; //-1代表没有
private int lala; //积分

private Block block;

private int B_X;
private int B_Y;

public Matrix(int row,int col){ //从MyCanvas得到计算过的 行和列

M_Row=row;
M_Col=col;

// System.out.println("row: "+row+" col: "+col);

wallX=row/4;

// System.out.println("wallX: "+wallX);

startX=wallX+MyCanvas.BRICK_WIDTH;

// System.out.println("statrX: "+startX);

del_1=-1;
del_2=-1;
del_3=-1;

lala=0;

matrix =new boolean[row][col];
rowEx =new boolean[row];
block=new Block();

// B_X=block.B_X/MyCanvas.BRICK_WIDTH;
// B_Y=block.B_Y/MyCanvas.BRICK_WIDTH;

//清空
for(int i=0;i<row;i++){
for(int j=0;j<col;j++)
matrix[i][j]=false;
rowEx[i]=false;
}

//设置左边1/4的那条竖线
for(int i=0;i<row;i++){
matrix[i][wallX]=true;
matrix[i][M_Col-1]=true;
}
//set bottom line
for(int j=0;j<col;j++){
matrix[M_Row-1][j]=true;

matrix[M_Row-2][j]=true;

}
rowEx[M_Row-2]=true;
rowEx[M_Row-1]=true;
}

public synchronized void drawMatrix(Graphics g){

//set color I don't know what is it exactaly
g.setColor(126,0,56);

//画1/4的竖线
for(int i=0;i<M_Row;i++){
g.fillRect(wallX*MyCanvas.BRICK_WIDTH,i*MyCanvas.BRICK_WIDTH,
MyCanvas.BRICK_WIDTH,MyCanvas.BRICK_WIDTH);
//画右边的竖线
g.fillRect((M_Col-1)*MyCanvas.BRICK_WIDTH,i*MyCanvas.BRICK_WIDTH,
MyCanvas.BRICK_WIDTH,MyCanvas.BRICK_WIDTH);
}

//画整个游戏区  
for(int i=M_Row-1;i>0;i--){
if(rowEx[i]){ //如果这一列存在block
for(int j=0;j<M_Col;j++){
if(matrix[i][j]){
drawBrick(g,i,j);
}
}
}
}
}

//具体画砖块
private synchronized void drawBrick(Graphics g,int i,int j){
g.fillRect(j*MyCanvas.BRICK_WIDTH,i*MyCanvas.BRICK_WIDTH,
MyCanvas.BRICK_WIDTH,MyCanvas.BRICK_WIDTH);
}

//如果block落下 不动后 设置行列的状态
public synchronized void setElement(int i,int j){
matrix[i][j]=true;
rowEx[i]=true;
}

//得到这个点的状态
public boolean getElement(int i,int j){
return matrix[i][j];
}

//落下每一个块后 监测有没有要消去的行
private synchronized void detectDel(){
int count=0;
for(int i=M_Row-2;i>0&&del_3==-1;i--){ //从倒数第二行开始检测
if(rowEx[i]){
count=0;
for(int j=0;j<M_Col;j++){
if(matrix[i][j]){
count++;
}
}
System.out.println(M_Col-wallX-2+"  "+count);
if(count==M_Col-wallX-2){           //这一行所有元素已满
if(del_1!=-1){
del_1=i;
}else
if(del_2!=-1){
del_2=i;
}else{
del_3=i;
}
}
}
}
}

//落定一个块要调用的函数
public synchronized void OOO(){
down();
toDead();
detectDel();
refrush();
}

//删除满的那一行
private synchronized void refrush(){
//form up to down
if(del_3!=-1){
upDel(del_3);
del_3=-1;
lala+=2;
}
if(del_2!=-1){
upDel(del_2);
del_2=-1;
lala+=2;
}
if(del_1!=-1){
upDel(del_1);
del_1=-1;
lala++;
}
}

//拷贝删掉的上面所有的部分
private synchronized void upDel(int del){
int k=del-1;
for(;k>0;k--){
if(rowEx[k]){
for(int j=0;j<M_Col-1;j++){
matrix[del][j]=matrix[k][j];
}
}else break;
}
for(int j=0;j<M_Col-1;j++){
matrix[k][j]=false;
}
}


private synchronized void fillMatrix(){
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(block.B[block.curShape][block.curState][i][j]){
// this.setElement(block.getY()/MyCanvas.BRICK_WIDTH-2+i,block.getX()/MyCanvas.BRICK_WIDTH-2+j);
// this.setElement(block.getY()/MyCanvas.BRICK_WIDTH+i,block.getX()/MyCanvas.BRICK_WIDTH+j);
this.setElement(B_Y+i,B_X+j);
rowEx[B_Y+i]=true;
}
}
}
}


private synchronized void updateBlock(){
B_X=block.B_X/MyCanvas.BRICK_WIDTH;
B_Y=block.B_Y/MyCanvas.BRICK_WIDTH;
}

Answer 2

// 碰撞检测 left
private synchronized boolean crashLeft(){
try{
synchronized(block){

if(B_X-1<wallX){
return true;
}else
if(block.B[block.curShape][block.curState][0][0]&&matrix[B_Y][B_X-1]){
return true;
}else if(block.B[block.curShape][block.curState][1][0]&&matrix[B_Y][B_X-1]){
return true;
}else if(block.B[block.curShape][block.curState][2][0]&&matrix[B_Y][B_X-1]){
return true;
}else if(block.B[block.curShape][block.curState][0][1]&&matrix[B_Y][B_X]){
return true;
}else if(block.B[block.curShape][block.curState][1][1]&&matrix[B_Y][B_X]){
return true;
}else if(block.B[block.curShape][block.curState][2][1]&&matrix[B_Y][B_X]){
return true;
}
}
}catch(Exception e){
System.out.println("lalala");
}
return false;

}


private synchronized boolean singleCrashLeft(){
try{
synchronized(block){

if(B_X-1<wallX){
return true;
}
if(block.B[block.curShape][block.curState][0][0]&&matrix[B_Y][B_X]){
return true;
} 
if(block.B[block.curShape][block.curState][1][0]&&matrix[B_Y][B_X]){
return true;
} 
if(block.B[block.curShape][block.curState][2][0]&&matrix[B_Y][B_X]){
return true;
}
}
}catch(Exception e){
System.out.println("lalala");
}
return false;

}

public void left(){
if(!crashLeft()){
block.left();
}
}

private synchronized boolean crashRight(){
try{
synchronized(block){

    if(B_X+2+1>M_Col-1){
     return true;
     }else if(block.B[block.curShape][block.curState][0][2]&&matrix[B_Y][B_X+2+1]){
return true;
     }else if(block.B[block.curShape][block.curState][1][2]&&matrix[B_Y][B_X+2+1]){
return true;
     }else if(block.B[block.curShape][block.curState][2][2]&&matrix[B_Y][B_X+2+1]){
return true;
     }else if(block.B[block.curShape][block.curState][0][1]&&matrix[B_Y][B_X+2]){
return true;
     }else if(block.B[block.curShape][block.curState][1][1]&&matrix[B_Y][B_X+2]){
return true;
     }else if(block.B[block.curShape][block.curState][2][1]&&matrix[B_Y][B_X+2]){
return true;
     }
}
}catch(Exception e){
System.out.println("lalala");
}
return false;

}

private synchronized boolean singleCrashRight(){
try{
synchronized(block){

if(B_X+2>M_Col-1){
return true;
}else if(block.B[block.curShape][block.curState][0][2]&&matrix[B_Y][B_X+2]){
return true;
}else if(block.B[block.curShape][block.curState][1][2]&&matrix[B_Y][B_X+2]){
return true;
}else if(block.B[block.curShape][block.curState][2][2]&&matrix[B_Y][B_X+2]){
return true;
}
}
}catch(Exception e){
System.out.println("lalala");
}
return false;

}

public void right(){
if(!crashRight()){
block.right();
}
}

public void changeStatus(){
block.changeStatus();
try{
if(singleCrashLeft()){
block.right();
}else if(singleCrashRight()){
block.left();
}else if(crashDown()){
block.B_Y--;
}
}catch(Exception e){
System.out.println("FUCK I am in change");
}
}

private void toDead(){

System.out.println("B_X: "+B_X+"  "+"B_Y: "+B_Y);
}

private synchronized boolean crashDown(){
synchronized(block){
if(B_Y+3>M_Row-1){
return true;
}
try{
if(block.B[block.curShape][block.curState][2][0]&&matrix[B_Y+3][B_X]){
return true;
}
else
if(block.B[block.curShape][block.curState][2][1]&&matrix[B_Y+3][B_X+1]){
return true;
}
else
if(block.B[block.curShape][block.curState][2][2]&&matrix[B_Y+3][B_X+2]){
return true;
}
else
//
if(block.B[block.curShape][block.curState][1][0]&&matrix[B_Y+2][B_X]){
return true;
}
else
if(block.B[block.curShape][block.curState][1][1]&&matrix[B_Y+2][B_X+1]){
return true;
}
else
if(block.B[block.curShape][block.curState][1][2]&&matrix[B_Y+2][B_X+2]){
return true;
}
else
//
if(block.B[block.curShape][block.curState][0][0]&&matrix[B_Y+1][B_X]){
return true;
}
else
if(block.B[block.curShape][block.curState][0][1]&&matrix[B_Y+1][B_X+1]){
return true;
}
else
if(block.B[block.curShape][block.curState][0][2]&&matrix[B_Y+1][B_X+2]){
return true;
}

}catch(Exception e){
System.out.println("I here guys! :) catch me :)");
}
}
return false;
}

public void down(){
if(!crashDown())
block.down();
else{
this.fillMatrix();
block.setNewShape();
}
updateBlock();
// System.out.println(M_Row);
// if(B_Y>=M_Row-4){
// block.setNewShape();
// }
}

public void drawBlock(Graphics g){
block.drawBlock(g);
}


/*
public void drawBlock(Graphics g){
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(block.B[block.curShape][block.curState][i][j]){
g.fillRect(B_X+j*MyCanvas.BRICK_WIDTH,B_Y+i*MyCanvas.BRICK_WIDTH,
MyCanvas.BRICK_WIDTH,MyCanvas.BRICK_WIDTH);
}
}
}
}
*/
}

Answer 3

算了 不指望了  这里没人知道  mIm

Answer 4

你数组每控制对头阿，越界访问了。程序太长了你还是自己debug一下，应该不难跟踪的，呵呵