Después de probarla y saber que la pantalla LCD en color de 320*240 de mi amigo era buena, quise hacer algo para jugar con ella. Entonces usé la pantalla LCD para escribir una fórmula rusa estándar.
Después de probar y saber que la pantalla LCD a color de 320*240 de mi amigo era buena, quise hacer algo para jugar con ella. Entonces usé la pantalla LCD para escribir un juego de Tetris estándar, controlado por arm7 (s3c44B0). Hagamos un resumen detallado para profundizar nuestra comprensión. En segundo lugar, los colegas interesados pueden intentar hacerlo con un microcontrolador, ¡lo cual es más interesante!
Hablemos primero del principio: (El principio se resumió después de consultar la información de nuestros antepasados en Internet. Nos gustaría agradecer a aquellos predecesores que publicaron la información en Internet y nos proporcionaron una plataforma. para aprender). Lo primero que hay que hacer es el trabajo de modelado.
Construcción de modelos: Creo que el modelado es muy importante en la programación de juegos, y la expresión y descripción del lenguaje son habilidades básicas. El juego Tetris estándar tiene los siguientes gráficos:
Implementación ARM de Tetris (2)
(2008-12-09 13:43:12)
Reimprimir
Etiqueta:
brazo
Tetris
Modelado
Charla varias
Obviamente podemos usar una matriz de 5 * 5 para representarlos respectivamente: se puede entender que en la imagen de arriba, cada gráfico tiene un tamaño de 5 * 5 y a su valor correspondiente en la matriz se le asigna 1 en el punto negro. el resto es 0. Por ejemplo, en la primera imagen se puede utilizar "Franjas Horizontales"
a[5][5]={ 0, 0, 0, 0, 0
0, 0, 0, 0, 0
1, 1, 1, 1, 0
0, 0, 0, 0, 0
0, 0, 0, 0, 0}
representa. El resto se puede deducir por analogía. Para la operación de transformación de este gráfico, solo necesita escribir una función void rotateBox(int box1[5][5], int box2[5][5]) para invertir la matriz.
void rotateBox(int box1[5][5], int box2[5][5])
{
int x, y;
p>
for(x = 0; x lt; 5; x)
for(y = 4; y gt; = 0; y--)
box2[ y][x] = box1[x][4 - y]; //4-y representa un giro simétrico a lo largo del eje central y,
}
Podemos usar una matriz tridimensional que representa los 7 cuadros básicos: (por supuesto MAX_C=7 aquí)
int box[MAX_C][5][5] = {
{
p>{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0},
{1, 1, 1, 1, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0}
} ,
{
{0, 0, 0, 0, 0},
{0, 0, 1, 0 , 0},
{0, 1, 1, 1, 0},
{0, 0, 0, 0, 0},
{ 0, 0, 0, 0 , 0}
},
{
{0, 0, 0, 0, 0},
{0, 1 , 1, 0, 0},
{0, 0, 1, 1, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0}
},
{
{0, 0, 0, 0, 0},
{0, 0, 1, 1, 0},
{0, 1, 1, 0, 0},
{0, 0, 0, 0, 0},
{0, 0, 0, 0, 0}
},
{
{ 0, 0, 0, 0, 0},
{0, 1, 1, 0, 0},
{0, 0, 1 , 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0}
},
{
{0, 0, 0, 0, 0},
{0, 0, 1, 1, 0},
{ 0, 0, 1, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 0, 0}
},
{
{0, 0, 0, 0, 0},
{0, 0, 1, 1, 0},
{0, 0, 1, 1, 0},
{0, 0, 0, 0, 0},
{0 , 0, 0, 0, 0}
}
};
Implementación ARM de Tetris (3)
(2008 - 12-09 13:44:14)
Repost
Etiqueta:
Tetris
brazo
Modelado
Charla varias
El siguiente modelo a construir es el fondo. El área de visualización del juego Tetris que configuramos aquí tiene 20 filas y 12 columnas. Según la idea anterior, también podemos abstraerlo en una matriz de 20 * 12, pero para facilitar la determinación de la colisión más adelante, lo abstraemos en una matriz de 22 * 16 int map [MAX_Y] [MAX_X]. Las columnas 0, 1, 14 y 15 están inicialmente configuradas en 1, y las dos filas inferiores, es decir, 20 y 21, están inicialmente configuradas en 1. El diagrama esquemático es el siguiente:
Usamos; la siguiente función para implementar la matriz anterior:
void initMap(void) {
int x, y
for(y = 0; y lt; MAX_Y; y) {
for(x = 0; x lt; MAX_X; x ) {
si(x lt; 2 || x gt; MAX_X - 3 || y gt; MAX_Y - 3)
mapa[y][x] = 1;
más mapa[y][x] =
}
}
Bien, ahora que se han establecido los dos primeros modelos, el resto será fácil de entender. Podemos pensar en el fondo como el cuadro grande de arriba y en cada forma básica como el cuadro pequeño de arriba. Todo el juego es simplemente el movimiento de la caja pequeña dentro de la caja grande (cayendo, moviéndose hacia la izquierda y hacia la derecha). La dificultad es cómo juzgar que el cuadro pequeño ha caído hasta el límite del cuadro grande.
Implementación ARM de Tetris (4)
(2008-12-09 13:45:01)
Reimpreso
Categoría: Artículo técnico
Colisión de jueces: al modelar el cuadro grande (fondo) anteriormente, el cuadro grande estaba rodeado por 2 capas de 1.
Entonces podemos juzgar la colisión entre la caja pequeña y la caja grande de esta manera. A la matriz de cuadros pequeños se le aplica un AND con el valor en su posición correspondiente en la matriz de cuadros grandes.
Obviamente, si el valor de AND es 1, prueba que los valores del cuadro grande y del cuadro pequeño son ambos 1, e indica que ocurrió una colisión aquí. Y en el primer fondo (cuadro grande), todos son 0 y solo hay dos capas de 1 en el borde. En este momento, solo se usa para determinar si el cuadro pequeño está fuera de los límites. Cuando el cuadro pequeño aterriza en la parte inferior del cuadro grande, el contenido del cuadro pequeño se escribe correspondientemente en la matriz del cuadro grande, de modo que el cuadro grande (fondo) se pueda actualizar.
int test(int mx, int my, int box[5][5])//Prueba si las cajas grandes y pequeñas chocan
{
int x, y;
for(x = 4; x gt; =0; x--)
for(y = 4; y gt;=0; y-- )
if(map[y mx][x my] amp; amp; box[x][4-y])//¿Por qué es 4-y en lugar de y?
return 0;
return 1;
}
void putBox(void) //Integra el cuadro pequeño colisionado en el cuadro grande para obtener un nuevo cuadro grande. caja
{
int x, y
for(y = 0; y lt; 5; y)
for( x = 0; x lt; 5; x )
if(curbox[y][x])
mapa[4-x curx][y cury] = curbox[y] ][ x];
}
Puedes utilizar los siguientes dos diagramas esquemáticos para expresarlo vívidamente:
El proceso general: entonces, el proceso de nuestro principal El programa se puede expresar así:
while(1)//Un bucle de juego
{
if(!newfall())
{
p>
Uart_Printf("¡Se acabó el juego!. ¡Presiona cualquier tecla!\n");
TGlib_disp_hzk16(180, 32, "¡Se acabó el juego!. Presiona". ¡cualquier clave!\n");
break; //Si no se pueden crear nuevos gráficos, el juego finaliza
}
dis_next_box(); / /Mostrar el siguiente
while(1) //Un bucle de caída gráfico
{
if(!drop())
{
putBox(); // Agrega el gráfico al fondo
clear_line(); //Si hay una línea completa, cancela la capa y actualiza la puntuación y el nivel.
break; //Salga del bucle de colocación del gráfico, dé la bienvenida al siguiente
}
dis_map() //Visualización de fondo en tiempo real
dis_box(curx, cury, curbox); // Visualización de gráficos en tiempo real
p>Delay_ms((6-level)*100); //Retraso para el control de velocidad de caída
}
}
}