Fuente del artículo: csdn Autor: Chen Wanfei
Sobre el autor
Chen Wanfei, hombre, tiene una licenciatura en matemáticas y software de la Universidad Central Sur. Fue programador senior y analista de sistemas en Beijing Great Wall Software. Tiene una amplia experiencia en el desarrollo de j2se y j2ee. Actualmente trabajando en la investigación de j2me. Puede ser contactado en [email protected]
resumen
Este artículo brinda un plan de diseño para un juego de Tetris basado en MIDP1.0 y brinda el código fuente de implementación completo. La característica más importante del juego es la adaptabilidad de la pantalla. No importa el tamaño de pantalla de varios teléfonos móviles y PDA, el juego siempre puede obtener el mejor efecto de visualización. El juego ha sido probado en cuatro emuladores del kit de herramientas inalámbrico J2me 2.1.
Descargo de responsabilidad: el código de este juego provino originalmente de un proyecto japonés de código abierto (ver referencia 1) y el autor lo modificó significativamente.
Aquí hay algunas capturas de pantalla del juego:
diseño
1. Proceso de operación
El proceso de operación de este juego es muy simple. Después de que el usuario inicia el MIDlet, ingresa a la pantalla principal del juego y la pantalla comienza a mostrar la pantalla de bienvenida. Después de que el usuario presiona el botón [Inicio], puede comenzar a jugar. Cuando el usuario quiere hacer una pausa, presiona el botón [Inicio] nuevamente y el juego se pausa si el usuario presiona el botón [Inicio] nuevamente. pausado, el juego continúa ejecutándose. Cada vez que se presiona el botón [Salir], el MIDlet del juego finalizará.
El diagrama de flujo de la pantalla del juego es el siguiente:
2. Algoritmo
El diseño de juegos MIDP esencialmente utiliza un hilo o un temporizador para generar eventos de redibujo y utiliza hilos y entradas del usuario para cambiar el estado del juego. Este juego no es una excepción. Después de iniciar MIDlet, se genera inmediatamente un hilo de redibujado que dibuja la pantalla cada 50 ms. Por supuesto, existen algunas medidas de optimización al volver a dibujar. No es necesario volver a dibujar todos los píxeles de la pantalla, pero hay selecciones, como los objetos que caen que se han fijado en el lienzo del juego (hay 7 tipos de objetos que caen en total). , que consta de 4 Compuesto por pequeños ladrillos, cada objeto que cae tiene un color fijo y se puede girar hacia arriba, abajo, izquierda y derecha, por lo que no es necesario volver a dibujarlo. El lienzo del juego es un CommandListener que puede aceptar comandos de teclado del usuario y controlar las acciones de izquierda, derecha, abajo y rotación del objeto que cae. El control de flujo de todo el juego se refleja en el método paint() del objeto lienzo del juego. paint() dibuja la pantalla del juego actual según el estado actual del juego. La pantalla de bienvenida y la pantalla Game Over son bastante sencillas de dibujar. Dibujar la pantalla de pausa del juego también es bastante fácil, simplemente configura una bandera para que cuando se ejecute paint(), no sea necesario volver a dibujar la acción. Para dibujar la pantalla cuando el juego se está ejecutando, el objeto que cae debe dibujarse en la posición actual del objeto que cae. Antes de dibujar el objeto que cae, determine si el objeto que cae aún puede caer. Si puede caer, déjelo caer un espacio y luego dibújelo. Si el objeto que cae ya no puede caer, determine si el juego está en el estado Game Over. está en Game Si el juego está en el estado Over, establezca el estado del juego en Game over, de modo que el lienzo dibuje la imagen Game Over la próxima vez que se vuelva a dibujar si el juego no está en el estado Game Over. , arregle los objetos que caen y verifique los objetos que caen en el lienzo del juego al mismo tiempo. Verifique todas las filas debajo de la fila actual para ver si es necesario eliminar la fila. Si es necesario eliminar la fila, borre los datos de la fila eliminada en el juego. mapa y luego dibuje la fila eliminada con un color de fondo. Luego inicializa un nuevo objeto que cae y dibuja este nuevo objeto que cae. El diagrama de flujo del método de pintura es el siguiente:
3.Estructura de datos
Este juego involucra las siguientes estructuras de datos.
área de juego
El área de juego es parte de la pantalla del teléfono móvil o PDA. El área es un cuadrado y la longitud del lado debe ser divisible por 16 (porque el área de juego rusa es exactamente un cuadrado de 16 ladrillos pequeños de largo y 16 ladrillos pequeños). ancho). Esta zona debe estar centrada en la pantalla, tanto horizontal como verticalmente. El área de juego está dividida en 2 partes horizontalmente, una parte tiene 12 ladrillos pequeños de ancho para mostrar el contenedor del juego y la otra parte tiene 4 ladrillos pequeños de ancho para mostrar el siguiente objeto que cae y anotar.
ladrillos pequeños
Los ladrillos pequeños son parte del contenedor de entrega y juego. Aparece como un cuadrado, con una longitud de lado de 1/16 de la longitud del lado del área de juego. Cuando se dibuje cada ladrillo pequeño, se dejará 1 píxel en los cuatro lados y se dibujará en blanco o gris para que haya un espacio entre los ladrillos. Cada ladrillo pequeño también tiene un ID, que va del 1 al 8. Podemos usar una matriz de colores (llamada BRICK_COLORS en el programa) para almacenar estos 8 colores. Si la identificación de un determinado ladrillo pequeño es 3, entonces el color del ladrillo pequeño es BRICK_COLORS [3-1].
objeto que cae
La caída es esencialmente un cuadrado hecho de 16 ladrillos pequeños. Hay un total de 7 tipos de objetos que caen, como los que tienen forma de "campo", forma de "L", etc. Hay 4 variaciones de rotación para cada objeto que cae. Cada objeto que cae tiene un ID, que va del 1 al 7. Porque para un objeto que cae, su color es fijo. También podemos usar el valor del subíndice de ese color en la matriz BRICK_COLORS más 1 como identificación del objeto que cae.
Por ejemplo, el objeto que cae en forma de "L" tiene un ID de 3 y su variación es:
Entonces, ¿qué estructura de datos se utiliza para almacenar un objeto que cae? Tomemos como ejemplo un objeto que cae en forma de "L":
Debido a que cada objeto que cae tiene cuatro estados, podemos considerar usar una matriz de longitud 4 para almacenar los cuatro estados de un objeto que cae. Cada elemento de la matriz representa un estado del objeto que cae. Entonces, ¿qué se debe usar para representar un determinado estado de un objeto que cae? Como se puede ver en la figura anterior, lo más apropiado es usar una matriz bidimensional de 4X4 para almacenar el estado de un objeto que cae. Cuando aparecen ladrillos de colores, el valor es 1, y cuando solo hay color de fondo y no es necesario dibujar, el valor es 0. Por lo tanto, los cuatro estados de todo el objeto que cae en forma de "L" se pueden representar mediante una matriz tridimensional:
protegido int blockpattern3[][][] = {
{{0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 1, 0}, {0, 0, 0, 0}},
{{0, 0, 0, 0}, {0, 1, 1, 1}, {0, 1, 0, 0}, {0, 0, 0, 0}},
{{0, 0, 0, 0}, {0, 1, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0}},
{{0, 0, 0, 0}, {0, 0, 1, 0}, {1, 1, 1, 0}, {0, 0, 0, 0}}
};mapa del juego
El mapa del juego se utiliza para almacenar fichas fijas en el contenedor del juego. El contenedor del juego tiene 12 unidades de ladrillos pequeños de ancho y 16 unidades de ladrillos pequeños de alto, incluidas las dos paredes izquierda y derecha y el fondo del contenedor de abajo. Por lo tanto, se utiliza una matriz bidimensional de 16X12 (llamada mapdata en el programa) para almacenar ladrillos fijos. Si mapdata [i] [j] = k (k! = 0), entonces significa que hay un pequeño ladrillo fijo en la fila i y la columna j del contenedor del juego, y el valor de color del pequeño ladrillo es BRICK_COLORS [k]. -1]. Si k = 0, significa que no hay ladrillos en la fila i y la columna j.
Por lo tanto, para el siguiente tiempo de ejecución del juego, el valor de mapdata es {{8,0,0,0,0,0,0,0,0,0,0,8}{8,0,0,0,0 , 0,0,0,0,0,0,8}{8,0,0,0,0,0,0,0,0,0,0,8}{8,0,0,0,0 , 0,0,0,0,0,0,8}{8,0,0,0,0,0,0,0,0,0,0,8}{8,0,0,0,0 , 0,0,0,0,0,0,8}
{8,0,0,0,0,0,0,0,0,0,0,0,8}{8,0,0,0,0,0,0,0,0,0,0,8} {}{8,0,0,0,0,0,0,0,0,0,0,8}{8,0,0,0,0,0,0,0,0,0,0, 8}
{8,0,0,0,0,0,0,0,0,1,1,8}{8,0,0,0,0,0,0,0,0,1,1,8} {8,0,0,0,0,0,7,7,5,1,1,8}{8,0,5,0,0,7,2,5,5,1,1,8}
{8,8,8,8,8,8,8,8,8,8,8,8}}
Código fuente y código ejecutable.
Hay 3 archivos en total: src.rar, ketrisgame.jad, ketrisgame.jar Nota: src.rar contiene todos los códigos fuente. También hay archivos de recursos necesarios para que el programa se ejecute en ketrisgame.jar. Después de instalar wtk2.1, coloque ketrisgame.jad y ketrisgame.jar en el mismo directorio (tenga en cuenta que la ruta del directorio no puede contener caracteres ni espacios chinos), haga doble clic en Archivo ketrisgame.jad. Puedes ejecutar el juego en el emulador.
Referencias
http://www.javadrive.jp/j2me/game/3/index.html
<j2me en pocas palabras>
<Introducción a la programación de teléfonos móviles/PDA en Java>