Programa Java de recompensa por puntuación alta, ¡urgente! ! !

//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()

gameScr.addKeyListener(gameScr ); /p>

temporizador = new MyTimer(gameScr);

timer.setDaemon(true);

timer.start();

temporizador. suspender();

add(gameScr);

Panel rightScr = nuevo Panel();

rightScr.setLayout(new GridLayout(2, 1,0) ,30));

rightScr.setSize(120,500);

add(rightScr

//Diseño del formulario de información correcto

MiPanel infoScr = nuevo MiPanel();

infoScr.setLayout(nuevo GridLayout(4,1,0,5));

infoScr.setSize(120,300); /p>

rightScr.add(infoScr);

//Definir etiqueta y valor inicial

Puntuación de etiquetap = new Label("Puntuación:",Label. LEFT);

Etiqueta nivelp = nueva Etiqueta("Nivel:",Label.LEFT

Etiqueta nombrep = nueva Etiqueta("Nombre: Zhang San",Label.LEFT

Etiqueta num = nueva Etiqueta("Número de estudiante

:110821332",Label.LEFT);

ScoreField = nuevo TextField(8);

LevelField = nuevo TextField(8);

ScoreField.setEditable( falso);

nivelField.setEditable(falso);

infoScr.add(nombre);

infoScr.add(nump); p> infoScr.add(puntuación);

infoScr.add(scoreField);

infoScr.add(nivelp);

infoScr.add(levelField)

scorep.setSize(nueva Dimensión(20,60));

scoreField.setSize(nueva Dimensión(20,60));

nivelp. 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 a la derecha

MyPanel controlScr = new MyPanel();

controlScr.setLayout(new GridLayout(5,1,0,5));

rightScr.add(controlScr

//Definir reproducción de botones

Botón play_b = new Button("Iniciar juego");

play_b.setSize(new Dimension(50,200));

play_b.addActionListener(new Command(Command.button_play). ,gameScr ));

//Definir botón Subir nivel

Botón level_up_b = new Botón("Aumentar nivel"); ( 50,200));

nivel_up_b.addActionListener(new Command(Command.button_levelup,gameScr));

//Definir botón Bajar nivel

Botón nivel_down_b = new Button("Reducir nivel");

level_down_b.setSize(new Dimension(50,200));

level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr)); /p>

//Definir botón Nivel Pausa

Botón pausa_b =nuevo Botón("Pausa del juego");

tSize(new Dimension(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(){

devolver nuevas Inserciones(30,50,30,50

}

}

); // Clase de lienzo del juego

clase GameCanvas extiende Canvas implementa KeyListener{

final int unitSize = 30; // Longitud del lado del cuadrado pequeño

int rowNum; Número de filas cuadradas

int columnNum; //Número de columnas cuadradas

int maxAllowRowNum; //Cuántas filas se pueden dejar sin cortar

int blockInitRow ; //La coordenada de la fila inicial del bloque recién aparecido

int blockInitCol; //La coordenada de la columna inicial del bloque recién aparecido

int [][] scrArr; Array

Block b; //Referencia a la otra parte

//Método de construcción de la clase canvas

GameCanvas(){

número de fila = 15;

número de columna = 10;

maxAllowNum = número de fila - 2;

b = nuevo bloque (este); blockInitRow = rowNum - 1;

blockInitCol = columnNum/2 - 2;

scrArr = new int [32][32]; >

//Método para inicializar la pantalla y borrar la matriz de pantalla

void initScr(){

for(int i=0;i p>

for (int j=0; j

scr

Arr[i][j]=0;

b.reset();

repintar();

}

/ /Actualizar método de lienzo

public void paint(Gráficos g){

for(int i = 0; i < rowNum; i++)

for(int j = 0; j < columnNum; j++)

drawUnit(i,j,scrArr[i][j]);

}

//Dibujar cuadrado método

public void drawUnit(int fila,int col,int tipo){

scrArr[fila][col] = tipo

Gráficos g = getGraphics; ();

switch(type){ //Método para expresar la velocidad de dibujo

case 0: g.setColor(Color.black);break //Con fondo Dibuja el color;

caso 1: g.setColor(Color.blue);break; //Dibuja el bloque que cae

caso 2: g.setColor(Color.magenta); Método para dibujar caído

}

g.fill3DRect(col*unitSize,getSize().height-(row+1)*unitSize,unitSize,unitSize, true

g.dispose();

}

public Block getBlock(){

return b //devuelve referencia a la instancia del bloque

}

//Devuelve el valor del atributo en la posición (fila,col) en la matriz de pantalla

public int getScrArrXY(int fila,int col ){

if (fila < 0 || fila >= numfila || col < 0 || col >= numcolumna)

return(-1); else

return(scrArr[row][col]);

}

// Devuelve el método de coordenadas de fila inicial del nuevo bloque

public int getInitRow(){

return(blockInitRow); //Devuelve las coordenadas de la fila inicial del nuevo bloque

}

//Regresa el nuevo bloque Método de coordenadas de columna inicial

public int getInitCol(){

return(blockInitCol // Devuelve la coordenada de 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;i

booleano isfull = true

L1:for(int j=0;j

lumnNum;j++)

if(scrArr[i][j] == 0){

k++

isfull = false

}

if(isfull) full_line_num++;

if(k!=0 && k-1!=i ​​​​&& ! isfull)

for(int j = 0; j < columnNum; j++){

if (scrArr[i][j] == 0)

dibujarUnidad( k-1,j,0);

else

dibujarUnidad(k-1,j,2

scrArr[k-1] [j ] = scrArr[i][j];

}

}

for(int i = k-1;i < rowNum; i++) {

for(int j = 0; j < 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

if(scrArr[maxAllowRowNum][col] !=0)

devuelve verdadero

}

devuelve falso

}

clave nula públicaTyped(KeyEvent e){

}

public void keyReleased (KeyEvent e){

}

//Método para procesar la entrada del teclado

public void keyPressed(KeyEvent e){

if (!ERS_Block.isPlay)

retorno

switch(e.getKeyCode()){

case KeyEvent.VK_DOWN:b. fallDown();romper ;

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 Ac

tionListener{

static final int button_play = 1; //Asigna un número al botón

static final int button_levelup =

static final int button_leveldown = 3;

estático final int button_quit = 4;

estático final int button_pause = 5

estático booleano pausa_resume = verdadero; int curButton ; //Botón actual

GameCanvas scr;

//Método de construcción de la clase del botón de control

Command(int button,GameCanvas scr){

curButton = botón;

this.scr=scr;

}

//Método de ejecución del botón

public void actionPerformed (ActionEvent e){

switch(curButton){

case button_play:if(!ERS_Block.isPlay){

scr.initScr();

case button_play:if(!ERS_Block.isPlay){

scr.initScr();

p>

ERS_Block.isPlay = true; /p>

ERS_Block.score = 0;

ERS_Block.scoreField.setText("0");

ERS_Block .timer.resume(); p> }

scr.requestFocus();

descanso;

caso button_levelup:if(ERS_Block .level < 10){

ERS_Block.level++;

ERS_Block.levelField.setText(""+ERS_Block.level);

ERS_Block.score = 0

ERS_Block.scoreField. setText(""+ERS_Block.score);

}

scr.requestFocus();

break

caso button_leveldown: if(ERS_Block.level > 1){

ERS_Block.level--;

ERS_Block.levelField.setText(""+ ERS_Block.level

); ERS_Block.score = 0;

ERS_Block.scoreField.setText(""+ERS_Block.score

}

scr.requestFocus(); p>

pausa;

caso button_pause:if(pause_resume){

ERS_Block.timer.suspend()

pausa_res

ume = falso;

}else{

ERS_Block.timer.resume();

pausa_resume = verdadero

}

scr.requestFocus();

romper;

caso button_quit:System.exit(0); >

}

}

//Bloquear clase

clase Bloquear {

static int[][] patrón = {

p>

{0x0f00,0x4444,0x0f00,0x4444},//Utiliza hexadecimal para representar, 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; // El 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

// 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.random() * 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(); p>

dispBlock(1);

p>

}

//Método para implementar el volteo de "bloques"

public void leftTurn( ){

if(assertValid(blockType,(turnState + 1)%4,row,col)){

dispBlock(0);

Estado = (turnState + 1)%4;

dispBlock(1);

}

}

//Implementar "bloque " "Método de desplazamiento a la izquierda

public void leftMove(){

if(assertValid(blockType,turnState,row,col-1)){

dispBlock ( 0);

col--;

dispBlock(1

}

}

/ /Implementar el movimiento correcto del bloque

public void rightMove(){

if(assertValid(blockType,turnState,row,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,row-1,col)){

dispBlock(0);

fila--; dispBlock(1);

return(true);

}else{

blockState = 2;

dispBlock(2);

return(false);

}

}

//Método para determinar si es correcto

booleano afirmarValid(int t,int s,int fila,int col){

int k = 0x8000

for(int i = 0; i < 4; i++){

for(int j = 0; j < 4; j++){

if((int)(patrón[t][s]&k) != 0){

int temp = scr.getScrArrXY(row-i,col+j

if (temp<0||temp==2)

devuelve falso;

p>

}

k = k >> 1

}

}

return true;

}

//Método de visualización sincronizado

public sincronizado void dispBlock(int s){

int k = 0x8000 ;

for (int i = 0; i < 4; i++){

for(int j = 0; j < 4; j++){

if(((int) patrón[tipodebloque][turnState

]&k) != 0){

scr.drawUnit(row-i,col+j,s

}

k=k>> 1;

}

}

}

}

//Hilo de sincronización

clase MyTimer extiende Thread{

GameCanvas scr;

public MyTimer(GameCanvas scr){

this.scr = scr; > }

public void run(){

while(true){

try{

sleep((10-ERS_Block. nivel + 1)*100);

}

catch(InterruptedException e){}

if(!scr.getBlock().fallDown()) {

scr.deleteFullLine();

if(scr.isGameEnd()){

ERS_Block.isPlay = false

suspender();

}else

scr.getBlock().reset()

}

}

}

}

clase WinListener extiende WindowAdapter{

public void windowClosing (WindowEvent l){

System.exit( 0);

}

}