Cómo hacer bloques virtuales en programación
Importar Java .
Importar evento Java
// /p>
La clase pública ERS_Block extiende el marco {
IsPlay booleano estático público = false
nivel int estático público = 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 ");
escucha de ventana win _ listener = nueva escucha de win()
ers. win _ listener);
}
//Método de construcción de la clase Tetris
ERS_Block (título de cadena){
Super(título );
setSize(600, 480);
establecer diseño (new GridLayout(1, 2));
juego Cr = nuevo lienzo de juego() ;
juegos Cr . addkey oyente(juegos Cr);
temporizador = nuevo mi temporizador(gameScr);
temporizador establecido daemon(verdadero); /p>
temporizador . start();
temporizador .suspender();
Agregar (gameScr); ();
derechos Cr . establecer diseño (new GridLayout(2, 1, 0, 30));
derechos Cr . >add(rights Cr);
//Diseño del formulario de información a la derecha
mi panel info SCR = new mi panel();
p>info SCR.set layout(new GridLayout(4,1,0,5));
infoScr.setSize(120,300);
derechos Cr add(infos Cr);
//Definir etiqueta y valor inicial
Etiqueta puntuaciónp = nueva etiqueta("puntuación:", Etiqueta. left);
Nivel de etiqueta p = nueva etiqueta("Serie:", tag.
izquierda);
campo de puntuación = new TextField(8);
campo de nivel = new TextField(8);
campo de puntuación editable (falso) ;
campo de nivel .set editable(false);
info SCR . p>
info SCR . agregar(campo de puntuación);
p>
info SCR .
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));
campo de puntuación . >
level field . settext(" 1 ");
//Diseño del formulario del botón de control a la derecha
mi panel control SCR = new my panel();
control SCR . establecer diseño (nuevo GridLayout(5, 1, 0, 5));
derechos Cr agregar(controles Cr);
/. /Definir botón reproducir
Botón play_b = new Button("Iniciar juego") ;
play_b.setSize(nueva dimensión(50,200));
play_b. addActionListener(new command(Command.button_play, gameScr));
//Definir el nivel del botón hacia arriba
Button level_up_b = new Button("Perfect Series");
level_up_b.setSize(nueva dimensión (50, 200));
level_up_b.addactionlistener(new Command(Command.button_level up,gameScr));
//Definir el nivel del botón hacia abajo
Botón nivel_down_ b = Nuevo botón("Reducir serie"
level_down_b.setSize(nueva dimensión(50, 200)); level_down_b.addactionlistener(new Command(Command . button_level down, gameScr));
//Definir pausa en el nivel del botón
Botón pausa_b = Nuevo botón ("Pausa del juego");
pause_b.setSize(nueva dimensión(50,200));
pause_b.addactionlistener(new Command(Command.button_pause,gameScr));
//Botón de definición para salir
Botón quit_b = new Botón("Salir del juego");
quit_b.setSize(nueva dimensión (50, 200));
addActionListe.
ner(nuevo comando(Command.button_quit, gameScr));
controla Cr add(play_b);
controla SCR .add(level_up_b);
controlar SCR agregar(nivel _ abajo _ b);
controlar SCR agregar(pausa _ b);
establecer visible(verdadero);
juegos Cr solicitud de enfoque();
}
}
//Reescribir. la clase MyPanel para dejar espacio alrededor del panel.
La clase MyPanel extiende el panel {
Insets públicos getInsets(){
Devuelve nuevos Insets(30, 50, 30, 50);
}
}
//Clase Game Canvas
La clase GameCanvas extiende Canvas para implementar KeyListener{
final int unitSize = 30 //La longitud del lado del cuadrado pequeño
int rowNum//El número de filas en el cuadrado
int columnNum//El número de columnas en la cuadrícula regular
int maxAllowRowNum // ¿Cuántas líneas no se pueden cortar?
int blockInitRow//Las coordenadas de la fila inicial del nuevo bloque.
int blockInitCol//Coordenadas de la columna inicial del nuevo bloque.
int[][]scrar; // Matriz de pantalla
Bloque B; //Cita rápida de la otra parte
//Método de construcción de la clase canvas
GameCanvas(){
rowNum = 15;
número de columna = 10
maxAllowRowNum = rowNum-2;
b = nuevo bloque (este);
bloque initrow = rowNum-1;
blockInitCol = columna num/2-2; new int [32][32];
}
//Inicializa la pantalla y borra la matriz de pantalla.
void initScr(){
for(int I = 0; i & ltrowNumi++)
for(int j = 0; j & ltrowNumj++) p>
scrArr[j]= 0;
b .
repintar();
//Método de actualización del lienzo
Pintura en blanco pública (gráfico g){
for(int I = 0;i<rowNumi++)
for(int j = 0; j & ltcolumnNumj++)
drawUnit(i, j, scrArr[j]);
}
//Método para dibujar un cuadrado
public void drawUnit(int fila, int col, int tipo){
scrArr[row][col]= tipo;
gráficos g = obtener gráficos() ;
Tch(type){ //Indica un método de dibujo rápido.
Caso 0: g . set color(color . negro); //Dibujar con fondo como color
Caso 1: g . ; //Dibuja un cuadrado que cae.
Caso 2: g. set color(color. magenta); Break; //Dibuja un método que ya está rezagado.
}
g.fill3DRect(col*unitSize,getSize().height-(row+1)*unitSize,unitSize,unitSize,true);
g . dispose();
}
Bloque público getBlock(){
Devuelve b; //Devuelve una referencia a la instancia del bloque.
}
//Devuelve el valor del atributo en la posición (fila, columna) en la matriz de pantalla.
public int getScrArrXY(int fila, int col){
if(fila & lt; 0 | | fila & gt= númerofila | | col & lt0 | | col & gt= columnNum)
return(-1);
Otros
return(scrArr[row][col]);
}
//Devuelve el método de coordenadas de línea inicial del nuevo bloque.
public int getInitRow(){
return(blockInitRow); //Devuelve las coordenadas de la fila inicial del nuevo bloque.
}
//Devuelve el método de coordenadas de la columna inicial del nuevo bloque.
public int getInitCol(){
return(blockInitCol); //Devuelve 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;i<rowNumi++){
booleano isfull = true
l 1 :para (int j = 0; j & ltcolumnNumj++)
if(scrArr[j] == 0){
k++;
isfull = false
interrumpir l 1;
}
si(está lleno)línea_completa_num++;
si (k! = 0 & amp& ampk -1! = i & amp& amp! está lleno)
for(int j = 0; j & ltcolumnNumj++){
if (scrArr[j] == 0)
drawUnit(k-1, j, 0);
Otros
drawUnit(k-1, j, 2);
scrArr[); k-1][j]= scrArr[j];
}
}
for(int I = k-1;i<rowNumi++ ){
for(int j = 0; j & ltcolumnNumj++){
drawUnit(i, j, 0);
scrArr[j]= 0 ;
}
}
ERS _ block . puntuación+= línea completa _ num;
ERS _ block settext("+ ERS _ block . score);
}
//Método para determinar si el juego ha terminado
El valor booleano es gamend(){
for(int col = 0; col & ltcolumnNumcol ++){
if(scrArr[maxAllowRowNum][col]!=0)
devuelve verdadero
}
Devuelve falso
}
Anulación pública escrita (KeyEvent e){
}
clave de anulación pública liberada (evento clave e){
}
//Método para procesar la entrada del teclado
Tecla de anulación pública (evento de clave e) {
Si (! ERS_Block.isPlay)
Return;
tch(e.getKeyCode()){
Evento clave del caso. VK _ DOWN:b . falldown(); romper;
Evento clave del caso. VK _Left:b . LEFT move();Break;
Evento clave de caso. VK _Derecha: b . movimiento DERECHO(); romper;
Evento clave de caso.
VK _space: b . giro a la izquierda(); romper
}
}
}
//Clase de control de procesamiento< / p>
El comando de clase implementa ActionListener{
static final int button _ play = 1 //Asigna un número al botón
static final int button _level up = 2 ;
botón int final estático _ nivel abajo = 3;
botón int final estático _ salir = 4
botón int final estático _ pausa = 5;
Booleano estático pausa_resume = true
int curButton//Botón actual
GameCanvas scr
//Construcción de la clase del botón de control Método
Comando(int botón, GameCanvas scr){
curButton = botón;
this.scr = scr
}
p>
//Método de ejecución del botón
Acción de anulación pública realizada (evento de acción e){
tch(botón de control){
Caso botón_ Reproducir: if(!ERS_Block.isPlay){
SCR . init SCR();
ERS _ block es reproducir = true; >ERS _ bloque.
ERS _ campo de puntuación. settext(" 0 "); ERS _ bloque . >
}
SCR . solicitar foco();
Romper;
botón de caso _ subir nivel:if(ERS _ bloque . nivel & lt 10){
ERS _ nivel de bloque++;
ERS _ campo de nivel de bloque. _ block . puntuación = 0;
ERS _ block . campo de puntuación settext("+ERS _ block . puntuación);
}
SCR . solicitud focus();
Romper;
botón caso _ nivel abajo:if(ERS _ bloque . nivel > 1){
ERS _ nivel bloque . -;
ERS _ bloque nivel campo . settext("+ERS _ bloque . nivel);
ERS _ bloque . puntuación = 0;
ERS _ block . campo de puntuación . settext("+ERS _ block . puntuación);
}
SCR . request focus();
Break;
botón caso _ pausa:if(pausa _ reanudar){
ERS _ bloque
k . temporizador . suspender();
pausa _ reanudar = false
}de lo contrario{
ERS _ temporizador . >
pausa _ reanudar = verdadero
}
SCR solicitud de enfoque();
romper
botón de caso _ quit:system . exit(0);
}
}
}
//Bloquear clase
Bloque de clase {
Static int[][] mode = {
{0x0f00, 0x4444, 0x0f00, 0x4444}, //Representado en hexadecimal, esta fila representa las 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 módulo (0-6)
int turnState//El estado de inversión del bloque (0 -3)
int blockState//Estado de caída rápida
int fila, col//Coordenadas del bloque en el lienzo
GameCanvas scr
Método de construcción de clase de bloque
Bloque(GameCanvas scr){
this.scr = scr
tipo de bloque =(int)(math . random( )* 1000)% 7;
turnState =(int)(math . random()* 1000)% 4;
estado de bloque = 1;
fila = SCR . geti nitrow();
col = SCR .
}
//Reinicializa el bloque y muestra el nuevo bloque.
Restablecimiento de vacío público(){
tipo de bloque =(int)(math . random()* 1000)%
turnState =(int ) (matemáticas. aleatorio()* 1000)% 4;
estado de bloque = 1;
fila = SCR . .getinitcol();
disp block(1);
}
//Método para implementar el volteo de "bloques"
public voidturnleft(){
if(assertValid(blockType, (turnState + 1)%4, fila, col)){
disp block(0);
estado de giro =(estado de giro+1)% 4;
disp block(1);
}
}
/ /Método para implementar el desplazamiento a la izquierda "bloquear"
public void leftMove(){
if(assertValid(blockType, turnState, row, col-1)){
bloque de visualización(0);
col-;
bloque de visualización(1);
}
}
//Mueve el bloque hacia la derecha.
public void rightMove(){
if(assertValid(blockType, turnState, fila, col+1)){
disp block(0);
col++;
disp block(1);
}
}
//Implementar operación de descarte de bloque método
fallDown booleano público(){
if(blockState == 2)
Retorno (falso);
if( afirmarValido (blockType, turnState, fila-1, col)){
disp block(0);
Fila-;
disp block(1); /p>
Retorno (verdadero);
} En caso contrario {
estado de bloque = 2;
disp block(2);
Retorno (falso);
}
}
//Método para determinar si es correcto o no
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 & lt4;j++){
if((int)(patrón[t][s]&k)!= 0){
int temp = scr.getScrArrXY(fila-i, col+j);
if(temp<0||temperature==2)
Devuelve falso
}
k = k & gt& gt1;
}
}
Devuelve verdadero
}
//Método de visualización sincronizada
bloque de visualización vacía sincronizada pública (int s){
int k = 0x8000
for( int I = 0;i<4;i++){
for(int j = 0;j<4;j++){
if(((int) patrón[tipo de bloque][turnState] &k)! = 0){
scr.drawUnit(fila-i, col+j, s);
}
k = k & gt& gt1;
}
}
}
}
//Hilo de sincronización
Clase MyTimer Hilo extendido {
GameCanvas scr
Public MyTimer(GameCanvas scr){
this.scr = scr
}
ejecución pública vacía(){
mientras(verdadero){
intenta{
dormir((10-ERS _ bloque. nivel+1) * 100);
}
catch(InterruptedException e){}
if (! scr.getBlock().
fallDown()){
SCR . eliminar línea completa();
if(SCR . isgamend()){
ERS _ block es jugar =. false;
Pendiente();
}En caso contrario
scr.getBlock(). reset();
}
}
}
}
La clase WinListener extiende WindowAdapter{
cierre de ventana vacía pública (evento de ventana l){
salida(0);
}
}
.