Escribe un pequeño juego usando Java, es Tetris
UI del paquete;
importar java.awt.*;
importar java.awt.event.*;
//Rusia Clase de bloque
clase pública ERS_Block extiende Frame{
pública estática booleana isPlay=false;
pública estática int nivel=1, puntuación=0;
campo de puntuación de TextField estático público, campo de nivel;
temporizador MyTimer estático público;
GameCanvas gameScr;
principal vacío estático público (String[] argus) {
ERS_Block ers = new ERS_Block("Juego Tetris V1.0 Autor: Vincent");
WindowListener win_listener = new WinListener();
ers . addWindowListener(win_listener);
}
//Método de construcción de la clase Tetris
ERS_Block(String title){
super (title
setSize(600, 480);
setLayout(new GridLayout(1, 2));
gameScr = nuevo GameCanvas(); p>
gameScr.addKeyListener(gameScr);
temporizador = new MyTimer(gameScr);
timer.setDaemon(true); start();
timer.suspend();
add(gameScr);
Panel rightScr = nuevo Panel();
rightScr.setLayout(nuevo GridLayout(2,1,0,30));
rightScr.setSize(120,500);
añadir(rightScr);
rightScr.setSize(120,500);
add(rightScr);
p>//Diseño del formulario de información a la derecha
MyPanel infoScr = new MiPanel();
infoScr.setLayout(nuevo GridLayout(4, 1, 0, 5) );
infoScr.setSize(120, 300);
rightScr.add(infoScr);
//Definir etiquetas y valores iniciales
Etiqueta puntuaciónp = new Label("Puntuación:", Label.LEFT);
Nivel de etiquetap = nueva etiqueta("Series:", Label.LEFT);
scoreField = nuevo TextField(8);
levelField = nuevo texto
Field(8);
scoreField.setEditable(false);
levelField.setEditable(false);
infoScr.add(scorep);
infoScr.add(scoreField);
infoScr.add(levelp);
infoScr.add(levelField);
scorep.setSize( nueva Dimensión(20,60));
scoreField.setSize(nueva Dimensión(20,60));
levelp.setSize(nueva Dimensión(20,60));
levelField.setSize(nueva dimensión(20, 60));
scoreField.setText("0");
levelField.setText("1") ;
//Diseño del formulario del botón de control derecho
MyPanel controlScr = new MyPanel();
controlScr.setLayout(new GridLayout(5, 1, 0, 5));
rightScr.add(controlScr);
//Definir botón de reproducción
Botón play_b = new Botón("Iniciar juego") ;
play_b.setSize(nueva Dimensión(50, 200));
play_b.addActionListener(nuevo Comando(Command.button_play, gameScr));
//Definir botón Nivel ARRIBA
Botón level_up_b = new Button("Aumentar nivel");
level_up_b.setSize(new Dimension(50, 200));
level_up_b.addActionListener(new Command(Command.button_levelup, gameScr));
//Definir botón Nivel hacia abajo
Botón level_down_b =new Botón("Nivel inferior") ;
level_down_b.setSize(new Dimension(50, 200));
level_down_b.addActionListener(new Command(Command.button_leveldown, gameScr));
// Definir botón Nivel Pausa
Botón pausa_b =nuevo Botón("Pausa del juego");
pause_b.setSize(nueva Dimensión(50, 200));
pausa_b.addActionListener(new Command(Command.button_pause, gameScr));
//Definir botón Salir
Botón quit_b =
new Button("Salir del juego");
quit_b.setSize(new Dimension(50, 200));
quit_b.addActionListener(new Command(Command.button_quit, gameScr)) ;
controlScr.add(play_b);
controlScr.add(level_up_b);
controlScr.add(level_down_b);
controlScr.add(pause_b);
controlScr.add(quit_b);
setVisible(true);
gameScr.requestFocus();
}
}
//Reescribe la clase MyPanel para dejar espacio alrededor del Panel
clase MyPanel extiende Panel{
Inserciones públicas getInsets(){
devuelve nuevas Inserciones(30, 50, 30, 50
}
}
/ /Clase de lienzo de juego
clase GameCanvas extiende Canvas implementa KeyListener{
final int unitSize = 30; // Longitud del lado del cuadrado pequeño
int rowNum; de filas cuadradas
int columnNum; //Número de columnas cuadradas
int maxAllowRowNum; //Cuántas filas sin cortar se permiten
int blockInitRow; coordenada de fila inicial del bloque recién aparecido
int blockInitCol; //La coordenada de columna inicial del bloque recién aparecido
int [][] scrArr //Matriz de pantalla
Bloque b; //Referencia a la otra parte
//Método de construcción de la clase canvas
GameCanvas(){
rowNum = 15 ;
columnNum = 10;
maxAllowRowNum = filaNum - 2;
b = nuevo bloque (este); - 1;
blockInitCol = columnNum/2 - 2;
scrArr = nuevo int [32][32]; >//Método para inicializar la pantalla y borrar la matriz de pantalla
void initScr(){
for(int i=0; ilt; rowNum; i)
for (int j=0; jlt; columnNum; j)
{ scrArr[i][j]=0 }
b.reset();< /p; >
repaint();
}
//Método de actualización del lienzo
pintura pública vacía (Gráficos g){
for(int i = 0; i lt; filaNum; i)
for(int j = 0; j lt; columnNum; j )
drawUnit(i, j, scrArr[i][j]);
}
//Cómo dibujar un cuadrado
public void drawUnit(int row, int col, int type){
scrArr[row][col] = type;
p>Gráficos g = getGraphics();
switch(type){ //Método para expresar dibujo rápido
caso 0: g.setColor(Color. black) ;break; //Dibuja con el fondo como color
caso 1: g.setColor(Color.blue break; //Dibuja el bloque que cae
caso 2: g. setColor(Color.magenta); break; //El método para dibujar ya se eliminó
}
g.fill3DRect(col*unitSize, getSize().height-(row 1). )* tamaño de unidad, tamaño de unidad, tamaño de unidad, verdadero
g.dispose();
}
bloque público getBlock(){
return b; //Devuelve la referencia de la instancia del bloque
}
//Devuelve el valor del atributo de la posición (fila, columna) en la matriz de pantalla
public int getScrArrXY (int fila, int col){
if (fila lt; 0 || fila gt; = filaNum || col lt; 0 || col gt; = columnaNum)
return (-1);
else
return(scrArr[fila][col]);
}
//devuelve el método de coordenadas de fila inicial del nuevo bloque
public int getInitRow(){
return(blockInitRow); //Devuelve la coordenada de fila inicial del nuevo bloque
p>}
//Devuelve las coordenadas de la columna inicial del nuevo bloque
public int getInitCol(){
return(blockInitCol); /Devolver las coordenadas de la columna inicial del nuevo bloque
}
//Método de eliminación de línea completa
void deleteFullLine(){
int full_line_num = 0;
int k = 0;
for (int i=0; ilt; rowNum; i ){
boolean isfull = true;
L1: for( int j=0; jlt; columnNum; j )
if(scrArr[i][j] == 0){
k ;
isfull = false;
romper L1;
}
if(isfull) full_line_num;
if(k!=0 amp; amp; k-1!=i amp；amp； !isfull)
>
for(int j = 0; j lt; columnNum; j ){
if (scrArr[i][j] == 0)
drawUnit(k- 1, j, 0);
else
drawUnit(k-1, j, 2);
scrArr[k-1][j] = scrArr[i][j];
}
}
for(int i = k-1; i lt; rowNum; i){
for(int j = 0; j lt; columnNum; j){
drawUnit(i, j, 0);
scrArr[i][j] =0;
}
}
ERS_Block.score = full_line_num;
ERS_Block.scoreField.setText("" ERS_Block.score );
}
//Método para determinar si el juego ha terminado
boolean isGameEnd(){
for (int col = 0; col lt; columnNum; col ){
if(scrArr[maxAllowRowNum][col] !=0)
devuelve verdadero;
}
devuelve falso;
}
clave pública vacía Typed(KeyEvent e){
}
clave pública vacía liberada (KeyEvent e ){
}
//Método para procesar la entrada del teclado
tecla pública vacíaPresionada(KeyEvent e){
if (!ERS_Block .isPlay)
return;
switch(e.getKeyCode()){
case KeyEvent.VK_DOWN: b.fallDown(); ;
p>
caso KeyEvent.VK_LEFT: b.leftMove(); romper;
caso KeyEvent.VK_RIGHT: b.rightMove(); romper;
case KeyEvent.VK_SPACE: b.leftTurn(); break;
}
}
}
//Procesamiento clase de control
clase Comando implementa ActionListener{
static final int button_play = 1; //Asigna un número al botón
static final int button_levelup = 2;
estático final int button_leveldown = 3
estático final int button_quit = 4
estático final int button_pause = 5
estático booleano pausa_resume = tr
ue;
int curButton; //Botón actual
GameCanvas scr;
//Método de construcción de la clase del botón de control
Comando ( botón int, GameCanvas scr){
curButton = botón;
this.scr=scr;
}
//Botón Métodos de ejecución
public void actionPerformed (ActionEvent e){
switch(curButton){
case button_play: if(!ERS_Block.isPlay){
scr.initScr();
ERS_Block.isPlay = true;
ERS_Block.score = 0;
ERS_Block.scoreField.setText(" 0 ");
ERS_Block.timer.resume();
}
scr.requestFocus();
romper;
} p>
case button_levelup: if(ERS_Block.level lt; 10){
ERS_Block.level;
ERS_Block.levelField.setText(" " ERS_Block.level);
ERS_Block.score = 0;
ERS_Block.scoreField.setText("" ERS_Block.score);
}
scr.requestFocus ();
romper;
caso button_leveldown: if(ERS_Block.level gt; 1){
ERS_Block.level- -;
ERS_Block.levelField.setText("" ERS_Block.level);
ERS_Block.score = 0;
ERS_Block.scoreField.setText("" ERS_Block.score);
ERS_Block.scoreField.setText("" ERS_Block.score); p>
}
scr.requestFocus();
romper;
caso button_pause: if(pause_resume){
ERS_Block.timer.suspend();
pause_resume = false;
}else{
ERS_Block.timer.resume();
pause_resume = true;
}
scr.requestFocus() ;
romper;
caso button_quit: System.exit(0 );
}
}
}
//Bloquear clase
clase Bloquear {
static int[][] patrón = {
{0x0f00，
0x4444, 0x0f00, 0x4444}, // expresado en hexadecimal, esta línea representa los cuatro estados de la barra
{0x04e0, 0x0464, 0x00e4, 0x04c4},
{0x4620 , 0x6c00 , 0x4620, 0x6c00},
{0x2640, 0xc600, 0x2640, 0xc600},
{0x6220, 0x1700, 0x2230, 0x0740},
{ 0x6440, 0x0e20, 0x44c0, 0x8e00},
{0x0660, 0x0660, 0x0660, 0x0660}
};
int blockType; //El número de modo del bloque (0-6)
int turnState; //Estado de inversión del bloque (0-3)
int blockState; //Estado de caída rápida
int row, col; //Las coordenadas del bloque en el lienzo
GameCanvas scr;
//Método de construcción de la clase de bloque
Block(GameCanvas scr){
this.scr = scr;
blockType = (int)(Math.random() * 1000)7;
turnState = (int)(Math . aleatorio() * 1000)4;
blockState = 1;
fila = scr.getInitRow();
col = scr.getInitCol();
}
//Reinicializa el bloque y muestra el nuevo bloque
public void reset(){
blockType = (int) ( Math.random() * 1000)7;
turnState = (int)(Math.random() * 1000)4;
blockState = 1;
fila = scr.getInitRow();
col = scr.getInitCol();
dispBlock(1);
}
//Método para implementar el volteo de "bloques"
public void leftTurn(){
if(assertValid(blockType, (turnState 1)4, row, col)){< / p>
dispBlock(0);
turnState = (turnState 1)4;
dispBlock(1);
}
}
//Método para implementar el desplazamiento a la izquierda de "bloque"
public void leftMove(){
if(assertValid(blockType, turnState, fila, col-1)){
dispBlock(0);
col--;
dispBlock(1);
}
}
//Implementar el movimiento correcto del bloque
public void rightMove(){
if(assertValid(blockType , turnState, fila, col
1)){
dispBlock(0);
col;
dispBlock(1);
}
}
//Método para implementar la operación de caída de bloques
public boolean fallDown(){
if(blockState == 2)
return(false);
if(assertValid(blockType, turnState, fila-1, col)){
dispBlock(0);
fila --;
dispBlock(1);
return(true);
}else{
blockState = 2;< / p>
dispBlock(2);
return(false);
}
}
//Determinar si es correcto método
booleano afirmarValid(int t, int s, int fila, int col){
int k = 0x8000;
for(int i = 0; i lt; 4; i ){
for(int j = 0; j lt; 4; j ){
if((int)(patrón[t][ s] amp; k) != 0){
int temp = scr.getScrArrXY(fila-i, col j);
if (templt; 0||temp== 2)
devuelve falso;
}
k = k gt 1;
}
}
return true;
}
//Método de visualización sincronizado
público sincronizado void dispBlock(int s){
int k = 0x8000;
for (int i = 0; i lt; 4; i){
for(int j = 0; j lt; 4; j ){
if(((int)pattern[blockType][turnState]amp;k) != 0){
scr.drawUnit(fila-i, col j, s
}
k=kgt;
}
}
}
}
//Hilo de sincronización
clase MyTimer extends Thread{
GameCanvas scr;
public MyTimer( GameCanvas scr){
this.scr = scr;
}
ejecución pública vacía(){
mientras (verdadero){
intenta{
sleep((10-ERS_Block.level 1)*100);
}
catch( InterruptedException e) {}
if(!scr.getBlock().fallDown(
)){
scr.deleteFullLine();
if(scr.isGameEnd()){
ERS_Block.isPlay = false;
suspend();
}else
scr.getBlock().reset();
}
}
}
}
la clase WinListener extiende WindowAdapter{
public void windowClosing (WindowEvent l){
System. salida(0);
}
}