Necesitamos urgentemente un código fuente de Tetris, escrito en Java
Usa Java para implementar un minijuego: Tetris
Usa una matriz bidimensional para guardar el mapa del juego:
//? cada cuadrícula se guarda Un bloque, una matriz registra el estado del bloque
private?State?map[][]?=?new?State[rows][columns];123
Antes del juego, todas las cuadrículas del mapa se inicializan para que estén vacías:
/*?¿Inicializar todas las casillas para que estén vacías?*/
for?(int?i ?=?0;?i?
para?(int?j?=?0;?j?
map[i][j]?=?State.EMPTY;
}
}1234567
Mientras Al jugar, podemos ver que en los cuadrados de la interfaz, se deben dibujar todos los cuadrados del mapa. Por supuesto, además de dibujar los cuadrados, también se deben dibujar los puntos del juego y las cadenas finales del juego cuando sea necesario:
/** * ?Pinta el contenido del formulario, incluidos bloques de juego, puntos de juego o cadenas finales*/
@Override
public?void? paint(Gráficos?g)?{
super.paint(g);
for?(int?i?=?0;?i?
para?( int?j?=?0;?j?
si?(mapa[i][j]? ==?State.ACTIVE)?{?// ?Dibujar bloque activo
g.setColor(activeColor);
g.fillRoundRect(j?*?BLOCK_SIZE,?i? *?BLOCK_SIZE?+?25,
BLOCK_SIZE?-?1,?BLOCK_SIZE?-?1,?BLOCK_SIZE?/?5,
BLOCK_SIZE?/?5);
}?else?if? (map[i][j]?==?State.STOPED)?{?//?Dibujar un bloque fijo
g.setColor(stopedColor );
g.fillRoundRect( j?*?BLOCK_SIZE,?i?*?BLOCK_SIZE?+?25,
BLOCK_SIZE?-?1,?BLOCK_SIZE?-?1, ?BLOCK_SIZE?/?5,
BLOCK_SIZE?/?5);
}
}
}
/*?Imprimir partitura?*/
g.setColor(scoreColor);
g.setFont(new?Font("Times?New?Roman",?Font. BOLD,?30));
g.drawString("SCORE?:?"?+?totalScore,?5,?70);
//?El juego ha terminado , imprime la cadena final
if?( !isGoingOn)?{
g.setColor(Color.RED);
g.setFont(new?Font ("Times?New?Roman",?Font.BOLD,? 40));
g.drawString("¿JUEGO? ¡¿TERMINADO?!",?this.getWidth()?/?2?- ?140,
this.getHeight() ?/?
2);
}
}123456789101112131415161718192021222324252627282930313233343536
Generar varios gráficos compuestos por cuadrados a través de números aleatorios, generalmente siete tipos de gráficos: barras, campos, positivos 7- en forma de 7 invertida, en forma de T, en forma de Z y en forma de Z invertida, como generar una barra:
map[0][randPos]?=?map[0][randPos? -? 1]?=?map[0][randPos?+?1]?
=?map[0][randPos?+?2]?=?State.ACTIVE;123
Después de generar los gráficos, implemente la operación de caída.
Si encuentras un obstáculo, no puedes seguir cayendo:
isFall?=?true;?//?¿Puedes caer?
//?Comprueba desde la línea actual, si te encuentras con un obstáculo y entonces deja de caer
for?(int?i?=?0;?i?
for?(int? j?=? 0;?j?
//?Cuando el bloque de la fila atravesada es un bloque activo y el bloque de la siguiente fila es estático bloque, se encuentra un obstáculo
if?(map[rowIndex?-?i][j]?==?State.ACTIVE
&&?map[rowIndex?-?i ?+?1][j]?== ?State.STOPED)?{
isFall?=?false;?//?Dejar de caer
romper;
}
}
si?(!isFall)
romper;
}123456789101112131415
Si no se encuentran obstáculos, al caer, el gráfico del bloque baja una línea en su totalidad:
//?El gráfico baja una fila
for?(int?i? =?0;?i?
¿para?(int?j?=?0;?j?
if?(map[rowIndex?-?i][ j]?==?State.ACTIVE)?{?//?El bloque activo baja una fila
map[rowIndex?- ?i][j]?=?State.EMPTY;?// ?El bloque activo original se convierte en un bloque vacío
map[rowIndex?-?i?+?1][j]?=? State.ACTIVE;?//?El siguiente bloque de fila se convierte en un bloque activo
p>}
}
}12345678910
La operación es similar cuando se mueve hacia la izquierda o hacia la derecha:
/** *?Go left*/
private?void?left()?{
//?Marcar si hay un obstáculo a la izquierda
boolean? hasBlock?=?false;
/*?Determinar si hay un bloque a la izquierda?*/
for?(int?i?=?0;?i?
if?(map[rowIndex?-?i][0 ]?==?State.ACTIVE)?{?//?Determinar si el lado izquierdo es una pared
hasBlock?=?true;
break;?//?Hay es un bloqueo, por lo que no es necesario reciclar la línea de juicio
}?else?{
for?( int?j?=?1;?j?
if?(map[rowIndex?-?i][j ]?==?State.ACTIVE
&&?map[rowIndex?-?i][j?-?1]?==?State.STOPED)?{
hasBlock ?=?true;
break;?//?Si hay un obstáculo, no es necesario reciclar la columna de juicio
}
}
if ?(hasBlock)
break;?//?Si hay un bloqueo, no es necesario reciclar la línea de juicio
}
}
/* ?Si no hay ningún obstáculo a la izquierda, mueve el gráfico un bloque hacia la izquierda?*/
if?(!hasBlock)?{
for?(int ?i?=?0 ;?i?
kRows;?i++)?{
for?(int?j?=?1;?j?
si?(map[rowIndex ?-?i][j]?==?State.ACTIVE)?{
mapa[rowIndex?-?i][j]?=?State.EMPTY;
map[rowIndex?-?i][j?-?1]?=?State.ACTIVE;
}
}
}
//?Repaint
repaint();
}
}1234567891011121314151617181920212223242526272829303132333435363738394041
Al acelerar hacia abajo, se reduce el intervalo de tiempo entre cada caída de estado normal:
/** *?Ir directamente hacia abajo*/
private?void?down()?{
// ?Las marcas pueden acelerar la caída
inmediata?=?true;
}12345678
Cómo cambiar la dirección de los gráficos, aquí sólo un método muy sencillo para lograr el cambio de dirección Por supuesto, puede haber mejores algoritmos para lograr la operación de cambio de dirección. Puede estudiarlo usted mismo:
/** *?Rotar gráficos de bloques*/
privado. ?void ?rotate()?{
try?{
if?(shape?==?4)?{?//?Cuadrado, la misma forma antes y después de la rotación
return;
}?else?if?(shape?==?0)?{?//?Strip
//?Matriz temporal, colocar rotación Publicar gráficos
State[][]?tmp?=?new?State[4][4];
int?startColumn?=?0;
//?Encontrar la posición del primer bloque al principio del gráfico
for?(int?i?=?0;?i?
if?(map[rowIndex][i]?==?State.ACTIVE)?{
startColumn?=?i;
romper;
}
}
//?Compruebe si hay algún obstáculo después de la rotación. Si hay algún obstáculo, no gire.
¿para? (int?i?=?0; ?i?
¿para?(int?j?=?0;?j?
if ?(map[rowIndex?-?3?+?i][j?+?startColumn]?==?State.STOPED)?{
return;
}
}
}
if?(map[rowIndex][startColumn?+?1]?==?State. ¿ACTIVA)?{?//?Barra horizontal, transformada en barra vertical
for?(int?i?=?0;?i?
tmp[i][ 0]?=?State.ACTIVE;
for?(int?j?=?1;?j?
tmp[i] [j]?=?State.EMPTY;
}
}
blockRows?=?4;
}?else? {?//?Barras verticales, transformadas en barras horizontales
for?(int?j?=?0;?j?
p>
tmp[3][j]?=?State.ACTIVE;
for?(int?i?=?0;?i?
tmp[i][j]?=?State.EMPTY;
}
}
blockRows?=?1;
}
//?Modificar los gráficos en el mapa original a los gráficos transformados
for?(int?i?=?0;?i?< ? 4;?i++)?{
para?(int?j?=?0;?j?
mapa[rowIndex?- ?3?+?i][startColumn?+?j]?=?tmp[i][j];
}
}
}? else ?{
//?Matriz temporal para colocar los gráficos rotados
State[][]?tmp?=?new?State[3][3];
int?startColumn?=?columns;
//?Encuentra la posición del primer cuadrado al comienzo del gráfico
for?(int?j?=?0 ;?j ?
para?(int?i?=?0;?i?
if?( map[rowIndex?-?j][i]?==?State.ACTIVE)?{
startColumn?=?i?
}
}
}
//? Determinar si habrá obstáculos después de la transformación
for?(int? i?=? 0;?i?
para?(int?j?=?0;?j?
if?(mapa[rowIndex?-?2?+?j][startColumn?+?2?-?i]?==?State.STOPED)
return;
}
}
//?Transformar
for?(int?i?=?0;?i?
¿para?(int?j?=?0;?j?
tmp[2?-?j] [i]? =?map[rowIndex?-?2?+?i][startColumn?+?j];
}
}
/ /?Reemplazar el original Los gráficos en el mapa se modifican a los gráficos transformados
for?(int?i?=?0;?i?
¿para?(int? j?=?0;?j?
mapa[rowIndex?-?2?+?i][startColumn?+? j]?=?tmp[i ][j];
}
}
//?Repintar
repintar() ;
//?Remodificar el puntero de fila
for?(int?i?=?0;?i?
for?(int? j?=?0;?j?
if?(map[rowIndex?-?i][startColumn?+?j] ?!=?null
||?map[rowIndex?-?i][startColumn?+?j]?!=?State.EMPTY)?{
rowIndex?= ?rowIndex?-?i;
bloquearFilas?
=?3;
retorno;
}
}
}
}
}?catch?(Exception?e)?{
//?Cuando un subíndice de matriz está fuera de los límites, significa que la forma del gráfico no se puede cambiar y no se realiza ningún procesamiento
}
}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960 616263 646566676869707172737475767778798081828384858687888990919293949596979899100101
Cuando el gráfico se detiene cuando encuentra un obstáculo, debemos juzgar si hay una determinada fila o filas que se pueden eliminar. En este momento, primero podemos obtener los números individuales de los bloques en cada fila y luego hacer un juicio:
int[]?blocksCount?=?new?int[rows];?/ /?Registrar el número de columnas con bloques en cada fila
int?eliminarRows?=?0;?//?Número de filas eliminadas
/*?Calcular el número de bloques en cada fila?*/
for?(int?i?=?0; ?i?
blocksCount[i]?=? 0;
¿para?(int?j?=?0;?j?< ?columnas;?j++)?{
si?(mapa[i][j]? ==?State.STOPED)
blocksCount[i]++;
}
}1234567891011
Si hay un completo fila de bloques, eliminar la fila de bloques:
/*? ¿Implementar una fila completa de bloques Operación de eliminación de bloques?*/
for?(int?i?=?0; ?i?
if?(blocksCount[i] ?==?columns)?{
//?Borrar una fila
¿para?(int?m?=?i;?m?>=?0;?m-- )?{
para?(int?n?=?0;?n ?
mapa[m][n]?=? (m?==?0)Estado.EMPTY?:?mapa[m?-?1][ n];
}
}
eliminateRows++ ;?//?Registra el número de líneas eliminadas
}
}12345678910111213
Finalmente, podemos volver a dibujar y mostrar los puntos.
Repita las operaciones anteriores de generar gráficos, soltar gráficos, moverse hacia la izquierda y hacia la derecha y juzgar y eliminar filas, y se completará un Tetris simple.