Aprender Java creando un juego (Parte 4)

Buen día para todos mis lectores, después de algunos días de ausencia, aquí les tengo la cuarta parte del proyecto de la tortuga en el entorno Greenfoot, como les había dicho ya, nuestra tortuga enfrentará una situación aún más peligrosa (porque ya bastante riesgo era morir de una sobredosis de pizza), la pondremos en la mira de un depredador, para ser más precisos, una serpiente, así que aquí les va...

Hemos creado ya una tortuga controlada por teclado que camina y come pizza. En este articulo, empezaremos a hacer las cosas más interesantes introduciendo un depredador que está tras nuestra tortuga—nuestra tortuga no solo debe recolectar las rebanadas de pizza, ¡sino que también debe evitar ser comida por una serpiente mientras o hace! Vamos a continuar desde donde dejamos nuestro proyecto la vez anterior, así que si te perdiste los artículos pasados, quizá sea una buena idea verlos primero para ver cómo llegamos hasta aquí (Parte 1, Parte 2, Parte 3).

Limpiando Nuestro Código

El método act de nuestra tortuga, como lo dejamos la última vez, se muestra a continuación:

Antes de que vayamos a añadir más funcionalidad a nuestro programa (y, en el proceso, hacer nuestro código más complejo), es una buena idea tomarse un minuto para mejorar la estructura de nuestro código. Especialmente, nuestro método act se está volviendo un poco largo, y está comenzando a tomar algo de esfuerzo para leerlo y darse cuenta de lo que hace.

En general, deberíamos apegarnos a mantener nuestros métodos cortos y claros (o como diría Steve Oualline, apegarnos al principio KISS: “Keep It Simple, Stupid”). Podemos hacer esto rompiendo el método act en múltiples métodos, cada uno definiendo una tarea lógica. En nuestro ejemplo, nuestro método act hace dos tareas lógicas distintas:

• Movimiento (moverse hacia adelante y posiblemente girando)
• Buscar pizza (y posiblemente comiéndola)

Podemos mover cada una de estas dos tareas en un método por separado, y entonces llamar a cada método desde el método act. En esta versión del código, hemos definido dos métodos adicionales, moveAndTurn y eat. Da una buena mirada a continuación para ver cómo fue hecho esto:

Cada una de las definiciones de método tiene una sección al inicio conteniendo algunos asteriscos. Por ejemplo, el método eat comienza con esto:

Este es un comentario de método.Un comentario es escrito para el programador (no para la computadora). El comentario explica, en tus palabras, (o las de otro programador si estás viendo el comentario de alguien más) el propósito del método que está debajo. Las líneas siguientes al comentario definen el método. Te darás cuenta que los cuerpos de los métodos contienen exactamente el mismo código que estaba previamente en el cuerpo del método act.

Ahora, el método act contiene sólo llamadas a los dos nuevos métodos:

Nota que esta versión de nuestro código hace exactamente lo mismo que la versión anterior—es funcionalmente equivalente. De todas formas, a causa de que lo hemos cortado en partes más pequeñas, es ahora más fácil de leer, y podemos reconocer más fácilmente qué hace el método act.

Deberías hacer los mismos cambios en tu propio código.

¡Serpientes Abordo!

Ahora que hemos mejorado la estructura de nuestro código, podemos seguir adelante añadiendo cosas a nuestro proyecto. Queremos introducir un enemigo de nuestra tortuga: serpientes.

Comienza por crear otra subclase de Actor, llamada Snake, con la imagen de una serpiente. Recuerda, puedes crear una subclase de Actor dando click derecho a la clase Actor y eligiendo New subclass. Nombra a la clase Snake y elige una imagen de serpiente de la categoría Animals como se muestra a continuación:

Compila tu scenario y pon unas cuantas serpientes en el mundo como se muestra a continuación:

Quizá quieras salvar el mundo de nuevo (click derecho en la imagen de fondo del mundo y elige Save the World) agrega tus serpientes al mundo salvado.

Comportamiento de la serpiente

Inicialmente, nuestra serpiente no hace nada.

Nos gustaría que ellas se movieran en toda la pantalla al azar y trataran de comerse a la tortuga.

La meta para el jugador, entonces, es controlar a la tortuga y comer todas las rebanadas de pizza mientras evade las serpientes.

Podemos empezar copiando todos los tres métodos de la clase Turtle (act, moveAndTurn, eat) en la clase Snake.

Haz esto usando copy y paste para remplazar el método act que está vacío por default en la clase Snake. Asegúrate de ver las llaves { } —El cuerpo de la clase aún necesita una llave que abra ‘{’ y otra que cierre ‘}’. En este punto, quizá quieras compilar y correr tu scenario para probar lo que hace. No es exactamente lo que queremos aún, pero hace algo. (Verás que las serpientes siguen tus presiones de tecla, exactamente como lo hace la tortuga.)

Hay dos cosas que nos gustaría cambiar en la clase Snake del comportamiento copiado de la tortuga. Primero, las serpientes deberían comer tortugas, no pizza. Y segundo, las serpientes deberían moverse por su cuenta (al azar), en lugar de ser controladas por el teclado.

Podemos hacer el primer cambio dirigiéndonos al método eat de la serpiente y reemplazando todas las menciones de “pizza” con “turtle”, como se muestra a continuación:

Presta atención a la capitalización: Letras mayúsculas y minúsculas deben ser usadas exactamente como se muestran. Cuando escribimos Turtle (con T mayúscula), nos estamos refiriendo a la clase Turtle. Cuando escribimos en minúsculas (turtle), nos estamos refiriendo a una variable.

Prueba tu scenario. Las serpientes deberían comer tortugas, no pizza.

Caminando al azar

En este momento, las serpientes siguen controladas por las mismas teclas que dirigen a las tortugas. Eso no es bueno. Podemos cambiar esto, primer haciendo a la serpiente correr en círculos.

Elimina el código del cuerpo del método moveAndTurn de la serpiente que implementa un giro controlado por teclado, y reemplazalo con una simple sentencia turn(3). El método debería verse ahora así:

Inténtalo. Las serpientes ahora se mueven por su cuenta (aún cuando es en un patrón muy predecible).
Ahora queremos hacer el movimiento más aleatorio. Para hacer esto, podemos usar un método de la clase Greenfoot llamado getRandomNumber. Este método va a darnos un número aleatorio entre 0 y el límite especificado. Por ejemplo, lo siguiente nos dará un número aleatorio entre 0 y 19 (el límite especificado en sí siempre es excluido):
Podemos usar este método para hacer las vueltas de las serpientes menos predecibles.Si usamos un número aleatorio como parámetro para el método turn (en lugar del número 3 que usábamos anteriormente), la serpiente debería caminar más aleatoriamente:
Si intentas esto, te darás cuenta de que la serpiente sigue moviéndose en círculo, aunque es un círculo algo irregular. La razón es que las vueltas—aún cuando tienen algo de aleatorias—son siempre vueltas a la derecha.

Para arreglar esto, necesitamos hacer a la serpiente girar a la izquierda también. Girar a la izquierda puede hacerse girando en un ángulo negativo. En lugar de girar entre 0 y 20 grados, nos gustaría girar entre menos 20 grados y 20 grados.

Podemos lograr esto con el siguiente cambio:

Eso es, primero obtenemos un número aleatorio usando 40 como el límite especificado, y entonces restamos 20 de él. El resultado estará entre -20 y 20. (En realidad, si piensas con cuidado sobre ello, esto es un tanto incorrecto. El resultado sería entre -20 y 19. ¿Puedes descubrir por qué? ¿Puedes corregirlo? No es realmente muy importante en nuestro contexto corregir esta ligera imprecisión—la serpiente se mueve erráticamente, así que un poco de tendencia no duele mucho.)

Intenta esta instrucción de giro (en lugar del anterior turn(3)) en tu propio código.

¡Verás que el juego de pronto se vuelve mucho más interesante!

Mejorando el juego

Hay muchas formas en las cuales podrías mejorar este juego. En lugar de hablarlo deberías probar algo de eso ahora mismo, te mostraré algo más útil: cómo puedes averiguar más por tu cuenta.

Hasta ahora, introdujimos varios métodos útiles que podemos usar, como move y turn en la clase Actor y getRandomNumber de la clase Greenfoot. Así que, ¿cómo descubrir que otros métodos están para usarlos?

La respuesta está en buscar la documentación de clase. Elige Greenfoot Class Documentation del menú Help de Greenfoot. Esto abrirá un explorador web que enlista todas las clases en el sistema Greenfoot. (Verás que hay seis clases: Actor, World, Greenfoot, GreenfootImage, GreenfootSound y MouseInfo.)

Da click en la clase Greenfoot para ver la documentación para esta clase. Si tú te desplazas un poco en la página, verás una lista d métodos disponibles en la clase. Están los métodos getRandomNumber e isKeyDown que ya hemos usado y un buen número de otros tantos.

El formato mostrado está en el llamado javadoc. Es un formato estándar para documentar métodos Java, y esto ayuda a determinar lo que clases particulares pueden hacer. La documentación incluye el tipo devuelto (lo que el método regresa cuando lo llamas), la firma (que es, el nombre y parámetros), y un comentario explicando lo que hace el método. Aquí, puedes averiguar todo acerca de otros métodos disponibles y cómo puedes llamarlos.

Por ahora, te dejaré explorar estos métodos por tu cuenta. (Las clases más interesantes para mirar inicialmente son Actor y Greenfoot.)

Tip: Puedes ver y descargar muchos programas Greenfoot Java en el sitio web de Greenfoot.

Conclusión

En este artículo, aprendiste unas cuantas cosas específicas acerca del código Java y algunos principios generales:

• El código debe ser estructurado de manera que tengas métodos pequeños y cada uno haga una tarea lógica. (El método act en sí debería muchas veces contener sólo llamadas a otros métodos.)
• Los números aleatorios se pueden usar para crear comportamiento aleatorio en nuestro programa (como movimiento aleatorio).
• Puedes encontrar acerca de los métodos disponibles en las clases Greenfoot buscando en la documentación de clase Greenfoot.
• La documentación de clase es provista en formato javadoc, el cual te muestra información acerca de todas las clases disponibles y acerca de cada método dentro de cada clase.

Y bien, eso es todo por este artículo, espero lo hayan disfrutado, no se pierdan los siguientes porque se añadirá más “inteligencia” a la serpiente y en el camino aprenderemos más de la clase World de Greenfoot.

Si no quieren perderse lo que sigue, pero tampoco pueden venir a revisar mis entradas cada que recuerden, lo ideal sería suscribirse vía mail, ¿cómo? Escribiendo su correo en la parte superior derecha de mi blog, donde dice “Noticias del blog a tu Email” dan click en “Submit” y de esa forma cada que suba una entrada tendrán un aviso en su bandeja de correo, y pues ya saben, criticas, dudas, peticiones o comentarios abajo, saludos.

Traducción: El Blog De Baro.

Escrito por: Michael Kölling.

Fuente: Java Magazine.


Entradas Relacionadas:
Aprender Java creando un juego (Parte 6)
Aprender Java creando un juego (Parte 5)
Aprender Java creando un juego (Parte 3)
Aprender Java creando un juego (Parte 2)
Aprender Java creando un juego (Parte 1)