onesquaredown.java

一个俄罗斯方块游戏

import java.awt.*;
import java.awt.event.*;
import java.util.*;


public class OneSquareDown implements Runnable{

int MAPX;
int MAPY;
int GRIDX;
int GRIDY;
	
Graphics g;
Component c;
Thread DownThread;
long GAME_SPEED;
long GAME_SCORE;
long GAME_LINE;
boolean GAME_RUNNING;
Paint P;



int MAP_ARRAY[][];//地图数组
int MAP_SHOW_ARRAY[][];//地图显示数组
Color MAP_COLOR_ARRAY[][];//地图颜色数组



int BRICK_WIDTH;	
int BRICK_SIDE;

int NEXT_BRICK_NUMBER;//下一个砖块组显示数量

boolean IS_SHOW_NEXT;//是否显示下一个砖块组

int NOW_BRICK;//现在动作砖块组编号
int NOW_BRICK_DIRECT;//现在动作砖块组的方向
int NOW_BRICK_X;//现在动作砖块组的x坐标
int NOW_BRICK_Y;//现在动作砖块组的y坐标
Square NowBrick;//现在动作的砖块组
Color NOW_BRICK_COLOR;//现在动作砖块组的颜色

ArrayList BrickArray;//所有砖块组类数组
ArrayList NextBrickArray;//下一个砖块组储存数组
ArrayList NextBrickColorArray;//下一个砖块组储存数组

public OneSquareDown(Graphics g,//绘图区
				  int mapx,int mapy,//地图坐标
				  int gridx,int gridy,//地图方格数
				  int brick_width,//砖块组宽
				  int brick_side,//砖块组边
				  int next_brick_number,//显示下一个砖块组数量
				  boolean is_show_next,//是否显示下一个砖块组
				  Component c){//组件
	//初始各参数
	this.c=c;
	this.g=g;
	this.MAPX=mapx;
	this.MAPY=mapy;
	this.GRIDX=gridx;
	this.GRIDY=gridy;
	this.BRICK_WIDTH=brick_width;
	this.BRICK_SIDE=brick_side;
	this.NEXT_BRICK_NUMBER=next_brick_number;
	this.IS_SHOW_NEXT=is_show_next;
	this.MAP_ARRAY=new int[GRIDX][GRIDY];
	this.MAP_SHOW_ARRAY=new int[GRIDX][GRIDY];
	this.MAP_COLOR_ARRAY=new Color[GRIDX][GRIDY];
	this.NOW_BRICK_X=0;
	this.NOW_BRICK_Y=0;
	this.GAME_SPEED=700;
	this.GAME_SCORE=0;
	this.GAME_LINE=0;
	
	//将地图数组归零
	for(int i=0;i<GRIDX;i++){
		for(int j=0;j<GRIDY;j++){
			this.MAP_ARRAY[i][j]=0;
			this.MAP_SHOW_ARRAY[i][j]=0;
		}			
	}
	
	//加入所有砖块组类型
	BrickArray=new ArrayList();//建立储存砖块组型态的数组
	BrickArray.add(new K_Square());
	BrickArray.add(new Y_Square());
	BrickArray.add(new L_Square());
	BrickArray.add(new FL_Square());
	BrickArray.add(new T_Square());
	BrickArray.add(new FZ_Square());
	BrickArray.add(new Z_Square());
	
	//产生下一砖块组数据
	NextBrickArray=new ArrayList();//建立储存预备砖块组编号的数组
	NextBrickColorArray=new ArrayList();//建立储存预备砖块组编号的数组
	for(int i=0;i<(NEXT_BRICK_NUMBER+1);i++){
		createNextBrick();
	}

	//建立绘出砖块组对象
	P=new Paint(this);
	
	//画出外框
	P.DrawMapFrame(0,0,GRIDX*BRICK_WIDTH+2*5,GRIDY*BRICK_WIDTH+2*5,5);
	P.DrawMapFrame(290,0,200,350,5);//预备方块外框
	P.DrawMapFrame(290,350,200,140,5);//游戏数据外框
	
	showNextBrickGroup();//显示提示方块组
	addNextBrick();//新增一个提示方块
	showNextBrick();//显示现在动作方块
	
	updateGame(0);//更新游戏数据
	
	DownThread=new Thread(this);
	DownThread.start();
}

//重绘窗口
public void paint(){
	//画出外框
	P.DrawMapFrame(0,0,GRIDX*BRICK_WIDTH+2*5,GRIDY*BRICK_WIDTH+2*5,5);
	P.DrawMapFrame(290,0,200,350,5);//预备方块
	P.DrawMapFrame(290,350,200,140,5);//游戏数据	
	showNextBrickGroup();
	updateGame(0);
	reLoadMap();
	showNextBrick();
				
}

//覆盖run()方法
public void run(){
	try{
		Thread.sleep(GAME_SPEED);  	
		keyPress(KeyEvent.VK_DOWN);
		DownThread=new Thread(this);
		DownThread.start();
	}catch(InterruptedException e){
		System.out.print("线程中断");
	}
}

//更新游戏数据
public void updateGame(int line){
	P.DrawMapFrame(290,350,200,140,5);

    GAME_SCORE+=line*line*10;

	GAME_LINE+=line;
    P.DrawFont("祝君好运!",300,390,25,Color.red,"标楷体");
	P.DrawFont("分数:"+GAME_SCORE,300,450,25,Color.green,"标楷体");		


}	
//产生下一组砖块
public void createNextBrick(){
	//产生预备砖块组编号
	NextBrickArray.add(new Integer((int)(Math.random()*BrickArray.size())));
	
	NextBrickColorArray.add(Color.blue);								  	
}

//检查砖块组是否可以放置
public boolean isPut(int x,int y,int type,int mode){
	Square sb=(Square)BrickArray.get(type);
	for(int i=0;i<=4;i++){
		for(int j=0;j<=4;j++){
			if(sb.BRICK_ARRAY[mode][i][j]==1){
				if((i+x)<0 || (i+x)>(GRIDX-1) || 
				   (j+y)<0 || (j+y)>(GRIDY-1) ||
				   MAP_ARRAY[i+x][j+y]==1){
					return false;				
				}	
			}
		}			
	}
	return true;				
}

//砖块组数组写入地图数组
public void addBrickToMap(){
	for(int i=0;i<=4;i++){
		for(int j=0;j<=4;j++){
			if((NOW_BRICK_X+i)>=0 && (NOW_BRICK_X+i)<GRIDX &&
			   (NOW_BRICK_Y+j)>=0 && (NOW_BRICK_Y+j)<GRIDY &&
			   NowBrick.BRICK_ARRAY[NOW_BRICK_DIRECT][i][j]==1){
				MAP_ARRAY[NOW_BRICK_X+i][NOW_BRICK_Y+j]=1;
	            MAP_COLOR_ARRAY[NOW_BRICK_X+i][NOW_BRICK_Y+j]=Color.blue;
               
			}				
		}				
	}	
}

//产生下一个砖块组
public void addNextBrick(){
	NextBrickArray.remove(0);
	NextBrickColorArray.remove(0);
	NOW_BRICK=((Integer)NextBrickArray.get(0)).intValue();
	NOW_BRICK_COLOR=(Color)NextBrickColorArray.get(0);
	NOW_BRICK_DIRECT=0;
	NOW_BRICK_X=(GRIDX-5)/2;
	NOW_BRICK_Y=0;
	NowBrick=(Square)BrickArray.get(NOW_BRICK);
	createNextBrick();
}

//显示下一个砖块组
public void showNextBrick(){
	if(this.isPut(NOW_BRICK_X,
	   			  NOW_BRICK_Y,
				  NOW_BRICK,
	              NOW_BRICK_DIRECT)){
		P.DrawBrickGroup(NOW_BRICK_X,
		   			     NOW_BRICK_Y,
					     NOW_BRICK,
		                 NOW_BRICK_DIRECT,
		                 Color.blue);
	                 
	}else{
		DownThread.stop();			
	}
}

//检查满行
public void checkFull(){
	boolean blFull=true;//满行旗标
	int delLine=0;//删除行数计数
	
	for(int j=NOW_BRICK_Y;j<(NOW_BRICK_Y+5);j++){
		blFull=true;
		for(int i=0;i<GRIDX;i++){
			if(j>=0 && j<GRIDY){
				if(MAP_ARRAY[i][j]!=1)
					blFull=false;					
			}else{
				blFull=false;					
			}
		}
		if(blFull){
			removeFull(j);//移除满行			
			delLine++;
		}
	}
	
	if(delLine>0)
		reLoadMap();
		
	updateGame(delLine);
	
}		

//移除满行
public void removeFull(int line){
	for(int j=line;j>0;j--){
		for(int i=0;i<GRIDX;i++){				
			MAP_ARRAY[i][j]=MAP_ARRAY[i][j-1];
			MAP_COLOR_ARRAY[i][j]=MAP_COLOR_ARRAY[i][j-1];
		}								
	}
	
	for(int i=0;i<GRIDX;i++){
		MAP_ARRAY[i][0]=0;
		MAP_COLOR_ARRAY[i][0]=Color.black;
	}
}

//重新加载地图砖块
public void reLoadMap(){
	for(int i=0;i<GRIDX;i++){
		for(int j=0;j<GRIDY;j++){
			if(MAP_ARRAY[i][j]==1)
				P.DrawBrick(i,j,MAP_COLOR_ARRAY[i][j]);
			else
				P.DrawBrick(i,j,Color.black);
		}				
	}	
}

//显示下一组砖块
public void showNextBrickGroup(){
		new Down(this).start();
		
}

//按键事件
public synchronized void keyPress(int KEYCODE){
	int x=NOW_BRICK_X;
	int y=NOW_BRICK_Y;
	int direct=NOW_BRICK_DIRECT;		
	switch(KEYCODE){
	case KeyEvent.VK_UP://上
		NOW_BRICK_DIRECT++;
		if(NOW_BRICK_DIRECT>=4)
			NOW_BRICK_DIRECT=0;
			
		if(isPut(NOW_BRICK_X,
				 NOW_BRICK_Y,
				 NOW_BRICK,
				 NOW_BRICK_DIRECT)){                   					                     
			P.DrawBrickGroup(x,y,direct);
		}else{
			NOW_BRICK_DIRECT--;
			if(NOW_BRICK_DIRECT<0)
				NOW_BRICK_DIRECT=3;
		}
		break;				
	case KeyEvent.VK_DOWN://下
		if(isPut(NOW_BRICK_X,
				 NOW_BRICK_Y+1,
				 NOW_BRICK,
				 NOW_BRICK_DIRECT)){
			NOW_BRICK_Y++;
			P.DrawBrickGroup(x,y,direct);
	
		}else{//到底
			showNextBrickGroup();
			addBrickToMap();
			checkFull();
			
			addNextBrick();
			
			showNextBrick();
		}
		break;
		
	case KeyEvent.VK_LEFT://左
		if(isPut(NOW_BRICK_X-1,
				 NOW_BRICK_Y,
				 NOW_BRICK,
				 NOW_BRICK_DIRECT)){
			NOW_BRICK_X--;
			P.DrawBrickGroup(x,y,direct);
		}		
		break;
					
	case KeyEvent.VK_RIGHT://右
		if(isPut(NOW_BRICK_X+1,
				 NOW_BRICK_Y,
				 NOW_BRICK,
				 NOW_BRICK_DIRECT)){
			NOW_BRICK_X++;
			P.DrawBrickGroup(x,y,direct);
		}
		break;
							

		case KeyEvent.VK_SPACE:
		if(DownThread.isAlive())
			DownThread.stop();					
		else{
			DownThread=new Thread(this);//产生控制下降的线程
			DownThread.start();
		}	
		break;	
	}				
}
}