Buscando urgentemente el código fuente del Tetris y otros minijuegos
Tetris: código fuente de Java proporcionado
importar java.awt.*
importar java.awt.event.*; // Clase Tetris
clase pública ERS_Block extiende Frame{
public static boolean isPlay=false
public static int nivel=1, puntuación= 0; /p>
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 (título);
setSize(600, 480);
setLayout(new GridLayout(1, 2));
gameScr = nuevo GameCanvas();
gameScr.addKeyListener(gameScr);
temporizador = nuevo MyTimer(gameScr);
timer.setDaemon(true); temporizador = nuevo MyTimer(gameScr);
timer.setDaemon(true);
p>
timer.start(); ();
add(gameScr);
Panel rightScr = nuevo Panel()
rightScr.setLayout(nuevo GridLayout(2, 1, 0, 30));
rightScr.setSize(120, 500);
add( rightScr
//Diseño del formulario de información correcto
MiPanel infoScr = new MiPanel();
infoScr.setLayout(new GridLayout(4, 1, 0, 5));
infoScr.setSize(120, 300). );
rightScr.add(infoScr);
//Definir etiqueta y valor de inicialización
Puntuación de etiquetap = new Label("Puntuación:", Etiqueta. IZQUIERDA);
Etiqueta nivelp = nueva Etiqueta("Nivel:", Etiqueta.LEFT
p>
scoreField = nueva);
TextField(8);
levelField = nuevo TextField(8);
scoreField.setEditable(false);
levelField.setEditable(false); p>
p>
infoScr.add(puntuación);
infoScr.add(scoreField
infoScr.add(nivelp); p>infoScr.add (levelField);
scorep.setSize(nueva Dimensión(20, 60));
scoreField.setSize(nueva Dimensión(20, 60)); /p>
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
//Define); botón jugar
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"); p>level_up_b.setSize(new Dimension(50, 200));
level_up_b.addActionListener(new Command(Command.button_levelup, gameScr));
//Definir botón Bajar nivel
Botón nivel_down_b =nuevo Botón("Reducir nivel");
level_down_b.setSize(nueva Dimensión(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"); pausa_b.setSize (nueva dimensión (50, 200));
pause_b.addActionListener (nueva comunicación
and(Command.button_pause, gameScr));
//Definir botón Salir
Botón quit_b = new Botón("Salir del juego"); setSize(nueva Dimensión(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); quit_b);
setVisible(verdadero);
gameScr.requestFocus();
}
}
//Reescribe la clase MyPanel para dejar espacio alrededor del Panel
clase MyPanel extends Panel{
public Insets getInsets(){
return new Insets( 30 , 50, 30, 50);
}
}
//Clase de lienzo de juego
clase GameCanvas extiende Canvas implementa KeyListener {
final int unitSize = 30; //Longitud de los lados del cuadrado pequeño
int rowNum; //Número de filas del cuadrado
int columnNum; / El número de columnas cuadradas
int maxAllowRowNum; //Cuántas filas se permiten sin cortar
int blockInitRow //La coordenada de fila inicial del nuevo bloque
int blockInitCol; //Coordenadas de la columna inicial del nuevo bloque
int [][] scrArr; //Matriz de pantalla
Bloque b;
p>//Método de construcción de la clase canvas
GameCanvas(){
rowNum = 15
columnNum = 10; /p>
maxAllowRowNum = filaNum - 2;
b = nuevo bloque (este);
blockInitRow = filaNum - 1
blockInitCol = columnaNum; /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; ilt; rowNum; i )
for (int j=0; jlt; columnNum; j )
scrArr[j]=0
b.reset();
aint();
}
//Actualizar método de lienzo
pintura vacía pública (Gráficos g){
for(int i = 0; i lt; número de fila; i)
for(int j = 0; j lt; número de columna; j)
drawUnit(i, j, scrArr[j]);
}
//Cómo dibujar un cuadrado
public void drawUnit(int fila, int col, int tipo){
scrArr[row][col] = type;
Gráficos g = getGraphics();
tch(type){ //Método para expresar la velocidad de dibujo
caso 0: g.setColor(Color.black); //Dibuja con el fondo como color
caso 1: g.setColor(Color.blue);
caso 2: g.setColor(Color.magenta); //Método para dibujar ya eliminado
}
g.fill3DRect(col*unitSize) , getSize().height-(fila 1)*unitSize, unitSize, unitSize, true
g.dispose()
}
public); Block getBlock(){
return b; //Devuelve la referencia de la instancia del bloque
}
//Devuelve la posición (fila, columna) en la matriz de pantalla Valor del atributo
public int getScrArrXY(int fila, int col){
if (fila lt; 0 || fila gt; = filaNum || col lt; 0 | | col gt ; = numcolumna)
return(-1
else
return(scrArr[fila][col]);
}
//Devuelve el método de coordenadas de la fila inicial del nuevo bloque
public int getInitRow(){
return(blockInitRow); Devuelve la coordenada de fila inicial del nuevo bloque Coordenadas de fila
}
//Devuelve las coordenadas de columna inicial del nuevo bloque método
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; ilt; rowNum; i; ){
booleano isfull = true
L1: for(int j=0; jlt; columnNum; j)
if(scrArr[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[j] == 0)
drawUnit(k-1, j, 0); p> else
drawUnit(k-1,j,2);
scrArr[k-1][j] = scrArr[j]; }
}
for(int i = k-1; i lt; rowNum; i){
for(int j = 0; j lt; columnNum; j ){
drawUnit(i, j, 0);
scrArr[j]=0; }
ERS_Block.score = full_line_num;
ERS_Block.scoreField.setText("" ERS_Block.score
}
/); /Juicio sobre si el juego ha terminado método
boolean isGameEnd(){
for (int col = 0; col lt; columnNum; col){
if (scrArr[maxAllowRowNum ][col] !=0)
devuelve verdadero
}
devuelve falso
}
p>
clave vacía pública Typed(KeyEvent e){
}
clave vacía públicaReleased(KeyEvent e){
}
//Procesando el método de entrada del teclado
public void keyPressed(KeyEvent e){
if(!ERS_Block.isPlay)
return; p>tch (e.getKeyCode()){
case KeyEvent.VK_DOWN: b.fallDown(); break
case KeyEvent.VK_LEFT: b.leftMove();
caso KeyEvent.VK_LEFT: b.leftMove();
p>
caso KeyEvent.VK_RIGHT: b.rightMove();
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_pause = 5; >
static boolean pause_resume = true;
int curButton; //Botón actual
GameCanvas scr
//Método de construcción de la clase del botón de control
Comando(int botón, GameCanvas scr){
curButton = botón
this.scr=scr
}
//Método de ejecución del botón
public void actionPerformed (ActionEvent e){
tch(curButton){
case button_play: if(!ERS_Block .isPlay){
scr.initScr();
ERS_Block.isPlay = verdadero;
ERS_Block.score = 0; ERS_Block.scoreField.setText("0");
ERS_Block.timer.resume()
}
scr.requestFocus(); >
romper;
caso 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
}
p>
ERS_Block.scoreField.setText("" ERS_Block.score
}
p>
scr.requestFocus();
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);
}
scr.requestFocus();
romper;
caso button_pause: if(pause_resume) {
ERS_Block.timer.suspend(); /p>
pause_resume = false
}else{
ERS_Block.tim
er.resume();
pause_resume = true;
}
scr.requestFocus()
romper; >
case button_quit: System.exit(0);
}
}
}
//Bloquear clase
clase Bloque {
static int[][] patrón = {
{0x0f00, 0x4444, 0x0f00, 0x4444}, // expresado en hexadecimal a, esto La 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 volteo del bloque (0-3)
int blockState; // Estado de caída rápida
int row, col // Las coordenadas del bloque en el canvas
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.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 <; /p>
turnState = (int)(Math.random() * 1000)4;
blockState = 1
fila = scr.getInitRow(); p>
col = scr.getInitCol();
dispBlock(1);
}
//Método para implementar el cambio de "bloque"
public void leftTurn(){
if(assertValid(blockType, (turnState 1)4, fila, col)){
dispBlock(0); /p>
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); p>
dispBlock(0);
col--; p>
}
}
//Implementar el movimiento correcto del bloquear
public void rightMove(){
if( afirmarValid(blockType, turnState, fila, col 1)){
dispBlock(0); p>
col;
dispBlock(1);
}
}
//Método para implementar la operación de caída de bloques.
fallDown booleano público(){
if( blockState == 2)
return(false);
if(assertValid( blockType, turnState, fila-1, col)){
dispBlock(0
fila--;
dispBlock(1); >
return(true);
}else{
blockState = 2;
dispBlock(2); (falso);
}
}
p>
//Método para determinar si es correcto
booleano afirmarValido (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)
return false;
}
k = k gt;
}
}
devuelve verdadero;
}
//Método de visualización sincrónica
público sincronizado void dispBlock(int s){
int k = 0x8000
; p>
for (int i = 0; i lt; 4; i ){
for (int j = 0; j lt; 4; j ){
si (((int)pattern[blockType][turnState]amp;k) != 0){
scr.drawUnit(row-i, col j, s);
k=kgt; 1;
}
< p>}
}
}
//Hilo de sincronización
clase MyTimer extiende el hilo{
GameCanvas scr
public MyTimer(GameCanvas scr){
this.scr = scr
}
public void run(){
mientras(verdadero){
intenta{
dormir((10-ERS_Block.level 1)*100); /p>
catch(InterruptedException e){}
if(!scr.getBlock().fallDown()){
scr.deleteFullLine(); >
if(scr.isGameEnd()){
ERS_Block.isPlay = false
suspend()
}else
;scr.getBlock().reset();
}
}
}
}
clase WinListener extiende WindowAdapter{
ventana vacía públicaClosing (WindowEvent l){
System.exit(0); >}