Curso Para hacer juegos con J2ME

[maxwellnewage]

Sprites
Durante los capítulos siguientes se profundiza en los diferentes aspectos
concernientes a la programación de videojuegos. Ya dispones de las
herramientas necesarias para emprender la aventura, así que siéntate
cómodamente, flexiona tus dedos y prepárate para la diversión. Para ilustrar
las técnicas que se describirán en los próximos capítulos desarrollaremo s un pequeño
videojuego. Va a ser un juego sin grandes pretensiones, pero que nos va a ayudar a
entender los diferentes aspectos que encierra este fascinante mundo. Nuestro juego va a
consistir en lo que se ha dado en llamar shooter en el argot de los videojuegos. Quizás te
resulte más familiar “matamarcianos”. En este tipo de juegos manejamos una nave que
tiene que ir destruyendo a todos los enemigos que se pongan en su camino. En nuestro
caso, va a estar ambientado en la segunda guerra mundial, y pilotaremos un avión que
tendrá que destruir una orda de aviones enemigos. El juego es un homenaje al mítico
1942.
Este capítulo lo vamos a dedicar a los sprites. Seguro que alguna vez has jugado a
Space Invaders. En este juego, una pequeña nave situada en la parte inferior de la
pantalla dispara a una gran cantidad de naves enemigas que van bajando por la pantalla
hacia el jugador. Pues bien, nuestra nave es un sprite, al igual que los enemigos, las
balas y los escudos. Podemos decir que un sprite es un elemento gráfico determinado
(una nave, un coche, etc...) que tiene entidad propia y sobre la que podemos definir y
modificar ciertos atributos, como la posición en la pantalla, si es o no visible, etc... Un
sprite, pues, tiene capacidad de movimiento. Distinguimos dos tipos de movimiento en los
sprites: el movimiento externo, es decir, el movimiento del sprite por la pantalla, y el
movimiento interno o animación.
Para posicionar un sprite en la pantalla hay que especificar sus coordenadas. Es como
el juego de los barquitos, en el que para identificar un cuadrante hay que indicar una letra
para el eje vertical (lo llamaremos eje Y) y un número para el eje horizontal (al que
llamaremos eje X). En un ordenador, un punto en la pantalla se representa de forma
parecida. La esquina superior izquierda representa el centro de coordenadas. La figura siguiente muestra el eje de coordenadas en una pantalla con una resolución de 320 por
200 píxeles.
Un punto se identifica dando la distancia en el eje X al lateral izquierdo de la pantalla y
la distancia en el eje Y a la parte superior de la pantalla. Las distancias se miden en
píxeles. Si queremos indicar que un sprite está a 100 píxeles de distancia del eje vertical
y 150 del eje horizontal, decimos que está en la coordenada (100,150).
Imagina ahora que jugamos a un videjuego en el que manejamos a un hombrecillo.
Podremos observar cómo mueve las piernas y los brazos según avanza por la pantalla.
Éste es el movimiento interno o animación. La siguiente figura muestra la animación del
sprite de un gato.
Otra característica muy interesante de los sprites es que nos permiten detectar
colisiones entre ellos. Esta capacidad es realmente interesante si queremos conocer
cuando nuestro avión ha chocado con un enemigo o con uno de sus misiles.

[maxwellnewage]

Control de sprites
Vamos a realizar una pequeña librería (y cuando digo pequeña, quiero decir realmente
pequeña) para el manejo de los sprites. Luego utilizaremos esta librería en nuestro juego,
por supuesto, también puedes utilizarla en tus propios juegos, así como ampliarla, ya que
cubrirá sólo los aspectos básicos en lo referente a sprites.
Dotaremos a nuestra librería con capacidad para movimiento de sprites, animación (un
soporte básico) y detección de colisiones.
Para almacenar el estado de los Sprites utilizaremos las siguientes variables.

Código:

private int posx,posy;
private boolean active;
private int frame,nframes;
private Image[] sprites;

Necesitamos la coordenada en pantalla del sprite (que almacenamos en posx y posy.
La variable active nos servirá para saber si el sprite está activo. La variable frame
almacena el frame actual del sprite, y nframes el número total de frames de los que está
compuesto. Por último, tenemos un array de objetos Image que contendrá cada uno de
los frames del juego.
Como puedes observar no indicamos el tamaño del array, ya que aún no sabemos
cuantos frames tendrá el sprite. Indicaremos este valor en el constructor del sprite.

Código:

// constructor. 'nframes' es el número de frames del Sprite.
public Sprite(int nframes) {
// El Sprite no está activo por defecto.
active=false;
frame=1;
this.nframes=nframes;
sprites=new Image[nframes+1];
}

El constructor se encarga de crear tantos elementos de tipo Image como frames tenga
el sprite. También asignamos el estado inicial del sprite.
La operación más importante de un sprite es el movimiento por la pantalla. Veamos los
métodos que nos permitirán moverlo.

Código:

public void setX(int x) {
posx=x;
}
public void setY(int y) {
posy=y;
}
int getX() {
return posx;
}
int getY() {
return posy;
}

Como puedes observar, el código para posicionar el sprite en la pantalla no puede ser
más simple. Los métodos setX() y setY() actualizan las variables de estado del sprite
(posx,posy). Los métodos getX() y getY() realizan la operación contraria, es decir,
nos devuelve la posición del sprite.
Además de la posición del sprite, nos va a interesar en determinadas condiciones
conocer el tamaño del mismo.

Código:

int getW() {
return sprites[nframes].getWidth();
}
int getH() {
return sprites[nframes].getHeight();
}

Los métodos getW() y getH() nos devuelven el ancho y el alto del sprite en píxeles.
Para ello recurrimos a los métodos getWidth() y getHeigth() de la clase Image.
Otro dato importante del sprite es si está activo en un momento determinado.

Código:

public void on() {
active=true;
}
5 1
public void off() {
active=false;
}
public boolean isActive() {
return active;
}

Necesitaremos un método que active el sprite, al que llamaremos on(), y otro para
desactivarlo, que como podrás imaginar, llamaremos off(). Nos resta un método para
conocer el estado del sprite. Hemos llamado al método isActive().
En lo referente al estado necesitamos algún método para el control de frames, o lo que
es lo mismo, de la animación interna del sprite.

Código:

public void selFrame(int frameno) {
frame=frameno;
}
public int frames() {
return nframes;
}
public void addFrame(int frameno, String path) {
try {
sprites[frameno]=Image.createImage(path);
} catch (IOException e) {
System.err.println("Can`t load the image " + path + ": " + e.toString());
}
}

El método selFrame() fija el frame actual del sprite, mientras que el método
frame() nos devolverá el número de frames del sprite.
El método addFrame() nos permite añadir frames al sprite. Necesita dos
parámetros. El parámetro frameno, indica el número de frame, mientras que el
parámetro path indica el camino y el nombre del gráfico que conformará dicho frame.
Para dibujar el sprite, vamos a crear el método draw(). Lo único que hace este
método es dibujar el frame actual del sprite en la pantalla.

Código:

public void draw(Graphics g) {
g.drawImage (sprites[frame], posx, posy, Graphics.HCENTER|Graphics.VCENTER);
}

Nos resta dotar a nuestra librería con la capacidad de detectar colisiones entre sprites.
La detección de colisiones entre sprites puede enfocarse desde varios puntos de vista.
Imaginemos dos sprites, nuestro avión y un disparo enemigo. En cada vuelta del game
loop tendremos que comprobar si el disparo ha colisionado con nuestro avión. Podríamos
considerar que dos sprites colisionan cuando alguno de sus píxeles visibles (es decir, no
transparentes) toca con un píxel cualquiera del otro sprite. Esto es cierto al 100%, sin
embargo, la única forma de hacerlo es comprobando uno por uno los píxeles de ambos
sprites. Evidentemente esto requiere un gran tiempo de computación, y es inviable en la
práctica. En nuestra librería hemos asumido que la parte visible de nuestro sprite coincide
más o menos con las dimensiones de la superficie que lo contiene. Si aceptamos esto, y
teniendo en cuenta que una superficie tiene forma cuadrangular, la detección de una
colisión entre dos sprites se simplifica bastante. Sólo hemos de detectar el caso en el que
dos cuadrados se solapen.

[maxwellnewage]

En la primera figura no existe colisión, ya que no se solapan las superficies (las
superficies están representadas por el cuadrado que rodea al gráfico). La segunda figura
muestra el principal problema de este método, ya que nuestra librería considerará que ha
habido colisión cuando realmente no ha sido así. A pesar de este pequeño inconveniente,
este método de detección de colisiones es el más rápido. Es importante que la superficie
tenga el tamaño justo para albergar el gráfico. Este es el aspecto que tiene nuestro
método de detección de colisiones.

Código:

boolean collide(Sprite sp) {
int w1,h1,w2,h2,x1,y1,x2,y2;
w1=getW(); // ancho del sprite1
h1=getH(); // altura del sprite1
w2=sp.getW(); // ancho del sprite2
h2=sp.getH(); // alto del sprite2
x1=getX(); // pos. X del sprite1
y1=getY(); // pos. Y del sprite1
x2=sp.getX(); // pos. X del sprite2
y2=sp.getY(); // pos. Y del sprite2
if (((x1+w1)>x2)&&((y1+h1)>y2)&&((x2+w2)>x1)&&((y2+h2)>y1)) {
return true;
} else {
return false;
}
}

Se trata de comprobar si el cuadrado (superficie) que contiene el primer sprite, se
solapa con el cuadrado que contiene al segundo.
Hay otro métodos más precisos que nos permiten detectar colisiones. Consiste en
dividir el sprite en pequeñas superficies rectangulares tal y como muestra la próxima
figura.
Se puede observar la mayor precisión de este método. El proceso de detección
consiste en comprobar si hay colisión de alguno de los cuadros del primer sprite con
alguno de los cuadrados del segundo utilizando la misma comprobación que hemos
utilizado en el primer método para detectar si se solapan dos rectangulos. Se deja como
ejercicio al lector la implementación de este método de detección de colisiones. A
continuación se muestra el listado completo de nuestra librería.

Código:

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.util.*;
import java.io.*;
class Sprite {
private int posx,posy;
private boolean active;
private int frame,nframes;
private Image[] sprites;
// constructor. 'nframes' es el número de frames del Sprite.
public Sprite(int nframes) {
// El Sprite no está activo por defecto.
active=false;
frame=1;
this.nframes=nframes;
sprites=new Image[nframes+1];
}
public void setX(int x) {
posx=x;
}
public void setY(int y) {
posy=y;
}
int getX() {
return posx;
}
int getY() {
return posy;
}
int getW() {
return sprites[nframes].getWidth();
}
int getH() {
return sprites[nframes].getHeight();
}
public void on() {
active=true;
}
public void off() {
active=false;
}
public boolean isActive() {
return active;
}
public void selFrame(int frameno) {
frame=frameno;
}
public int frames() {
return nframes;
}
// Carga un archivo tipo .PNG y lo añade al sprite en
// el frame indicado por 'frameno'
public void addFrame(int frameno, String path) {
try {
sprites[frameno]=Image.createImage(path);
} catch (IOException e) {
System.err.println("Can`t load the image " + path + ": " + e.toString());
}
}
boolean collide(Sprite sp) {
int w1,h1,w2,h2,x1,y1,x2,y2;
w1=getW(); // ancho del sprite1
h1=getH(); // altura del sprite1
w2=sp.getW(); // ancho del sprite2
h2=sp.getH(); // alto del sprite2
x1=getX(); // pos. X del sprite1
y1=getY(); // pos. Y del sprite1
x2=sp.getX(); // pos. X del sprite2
y2=sp.getY(); // pos. Y del sprite2
if (((x1+w1)>x2)&&((y1+h1)>y2)&&((x2+w2)>x1)&&((y2+h2)>y1)) {
return true;
} else {
return false;
}
}
// Dibujamos el Sprite
public void draw(Graphics g) {
g.drawImage(sprites[frame],posx,posy,Graphics.HCENTER|Graphics.VCENTER);
}
}

Veamos un ejemplo práctico de uso de nuestra librería. Crea un nuevo proyecto en
KToolBar, y añade el programa siguiente en el directorio ‘src’, junto con la librería
Sprite.java. Por supuesto necesitarás incluir el gráfico hero.png en el directorio ‘res’.
En los siguientes capítulos vamos a basarnos en esta librería para el control de los
Sprites del juego que vamos a crear.

Código:

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class SpriteTest extends MIDlet implements CommandListener {
private Command exitCommand, playCommand, endCommand;
private Display display;
private SSCanvas screen;
public SpriteTest() {
display=Display.getDisplay(this);
exitCommand = new Command("Salir",Command.SCREEN,2);
screen=new SSCanvas();
screen.addCommand(exitCommand);
screen.setCommandListener(this);
}
public void startApp() throws MIDletStateChangeException {
display.setCurrent(screen);
}
public void pauseApp() {}
public void destroyApp(boolean unconditional) {}
public void commandAction(Command c, Displayable s) {
if (c == exitCommand) {
destroyApp(false);
notifyDestroyed();
}
}
}
class SSCanvas extends Canvas {
private Sprite miSprite=new Sprite(1);
public SSCanvas() {
// Cargamos los sprites
miSprite.addFrame(1,"/hero.png");
// Iniciamos los Sprites
miSprite.on();
}
public void paint(Graphics g) {
// Borrar pantalla
g.setColor(255,255,255);
g.fillRect(0,0,getWidth(),getHeight());
// situar y dibujar sprite
miSprite.setX(50);
miSprite.setY(50);
miSprite.draw(g);
}
}

[maxwellnewage]

Un Universo en tu móvil.
Ahora que hemos desarrollado una herramienta para el control de sprites, vamos a
aprender a sacarle partido. Con nuestra librería seremos capaces de mostrar en la
pantalla del dispositivo todo lo que va ocurriendo en el juego, pero también hemos
de ser capaces de leer la información desde el teclado del móvil para responder a
las instrucciones que da el jugador. También es importante que el movimiento del juego sea
suave y suficientement e rápido. En este capítulo examinaremos las capacidades de
animación de los midlets, incluido el scrolling, así como la interfaz con el teclado.
Animando nuestro avión
Lectura del teclado
Toda aplicación interactiva necesita un medio para comunicarse con el usuario. Vamos a
utilizar para ello tres métodos que nos ofrece la clase Canvas. Los métodos keyPressed(),
keyReleased() y keyRepeated(). Estos métodos son llamados cuando se produce un
evento relacionado con la pulsación de una tecla. keyPressed() es llamado cuando se
produce la pulsación de una tecla, y cuando soltamos la tecla es invocado el método
keyReleased(). El método keyRepeated() es invocado de forma repetitiva cuando
dejamos una tecla pulsada.
Los tres métodos recogen como parámetro un número entero, que es el código unicode de
la tecla pulsada. La clase Canvas también nos ofrece el método getGameAction(), que
convertirá el código a una constante independiente del fabricante del dispositivo. La siguiente
tabla, muestra una lista de constantes de códigos estándar.
KEY_NUM0, KEY_NUM1, KEY_NUM2,
KEY_NUM3, KEY_NUM4, KEY_NUM5,
KEY_NUM6, KEY_NUM7, KEY_NUM8,
KEY_NUM9
Teclas numéricas
KEY_POUND Tecla ‘almohadilla’
KEY_STAR Tecla asterisco
GAME_A, GAME_B, GAME_C, GAME_D Teclas especiales de juego
UP Arriba
DOWN Abajo
LEFT Izquierda
RIGHT Derecha
FIRE Disparo
Los fabricantes de dispositivos móviles suelen reservar unas teclas con funciones más o
menos precisas de forma que todos los juegos se controlen de forma similar. Otros, como el
caso del Nokia 7650 ofrecen un mini-joystick. Usando las constantes de la tabla anterior,
podemos abstraernos de las peculiaridades de cada fabricante. Por ejemplo, en el Nokia
7650, cuando movamos el joystick hacia arriba se generara el código UP.
Vemos un ejemplo de uso:

Código:

public void keyPressed(int keyCode) {
int action=getGameAction(keyCode);
switch (action) {
case FIRE:
// Disparar
break;
case LEFT:
// Mover a la izquierda
break;
case RIGHT:
// Mover a la derecha
break;
case UP:
// Mover hacia arriba
break;
case DOWN:
// Mover hacia abajo
break;
}
}

Puede parecer lógico utilizar keyRepeated() para controlar un sprite en la pantalla, ya
que nos interesa que mientras pulsemos una tecla, este se mantenga en movimiento. En
principio esta sería la manera correcta de hacerlo, pero en la practica, no todos los dispositivos
soportan la autorepetición de teclas (incluido el emulador de Sun). Vamos a solucionarlo con
el uso de los otros dos métodos. Lo que queremos conseguir es que en el intervalo de tiempo
que el jugador está pulsando una tecla, se mantenga la animación. Este intervalo de tiempo es
precisamente el transcurrido entre que se produce la llamada al método keyPressed() y la
llamada a keyReleased(). Un poco más abajo veremos como se implementa esta técnica.
Threads
Comenzamos este libro con una introducción a Java. De forma intencionada, y debido a lo
voluminoso que es el lenguaje Java, algunos temas no fueron cubiertos. Uno de estos temas
fueron los threads. Vamos a verlos someramente, ahora que ya estamos algo más
familiarizados con el lenguaje, y lo utilizaremos en nuestro juego.
Muy probablemente el sistema operativo que utilizas tiene capacidades de multiproceso o
multitarea. En un sistema de este tipo, puedes ejecutar varias aplicaciones al mismo tiempo. A
cada una de estas aplicaciones las denominamos procesos. Podemos decir que el sistema
operativo es capaz de ejecutar múltiples procesos simultáneamente. Sin embargo, en
ocasiones es interesante que dentro de proceso se lancen uno o más subprocesos de forma
simultánea. Vamos a utilizar un ejemplo para aclarar el concepto. Piensa en tu navegador web
favorito. Cuando lo lanzas, es un proceso más dentro de la lista de procesos que se estan
ejecutando en el sistema operativo. Ahora, supongamos que cargamos en el navegador una
web llena de imágenes, e incluso algunas de ellas animadas. Si observas el proceso de carga,
verás que no se cargan de forma secuencial una tras otra, sino que comienzan a cargarse
varias a la vez. Esto es debido a que el proceso del navegador lanza varios subprocesos, uno
por cada imagen, que se encargan de cargarlas, y en su caso, de animarlas de forma
independiente al resto de imágenes. Cada uno de estos subprocesos se denomina thread
(hilo o hebra en castellano).
En Java, un thread puede estar en cuatro estados posibles.
• Ejecutándose: Está ejecutándose.
• Preparado: Está preparado para pasar al estado de ejecución.
• Suspendido: En espera de algún evento.
• Terminado: Se ha finalizado la ejecución.
La clase que da soporte para los threads en Java es java.lang.Thre ad. En todo
momento podremos tener acceso al thread que está en ejecución usando el método
Thread.current Thread().
Para que una clase pueda ser ejecutada como un thread ha de implementar la interfaz
java.lang.Runn able, en concreto, el método run(). Éste es el método que se ejecutará
cuando lancemos el thread:

Código:

public class Hilo implements Runnable {
public void run(){
// código del thread
}
}

Para arrancar un thread usamos su método start().

Código:

// Creamos el objeto (que implementa Runable)
Hilo miHilo = new Hilo();
// Creamos un objeto de la clase Thread
// Al que pasamos como parámetro al objeto miHilo
Thread miThread = new Thread( miHilo );
// Arrancamos el thread
miThread.start();

Si sólo vamos a utilizar el thread una vez y no lo vamos a reutilizar, siempre podemos
simplificarlo.

Código:

Hilo miHilo = new Hilo();
new Thread(miHilo).start();

La clase Thread nos ofrece algunos métodos más, pero los más interesantes son stop(),
que permite finalizar un thread, y sleep(int time), que lo detiene durante los
milisegundos que le indiquemos como parámetro.
El Game Loop
Cuando jugamos a un juego parece que todo pasa a la vez, en el mismo instante, sin
embargo, sabemos que un procesador sólo puede realizar una acción a la vez. La clave es
realizar cada una de las acciones tan rápidamente como sea posible y pasar a la siguiente, de
forma que todas se completen antes de visualizar el siguiente frame del juego.
El “game loop” o bucle de juego es el encargado de “dirigir” en cada momento que tarea se
está realizando. En la figura 6.1. podemos ver un ejemplo de game loop, y aunque más o
menos todos son similares, no tienen por que tener exactamente la misma estructura.
Analicemos el ejemplo.
Lo primero que hacemos es leer los dispositivos de entrada para ver si el jugador ha
realizado alguna acción. Si hubo alguna acción por parte del jugador, el siguiente paso es
procesarla, esto es, actualizar su posición, disparar, etc..., dependiendo de qué acción sea. En
el siguiente paso realizamos la lógica de juego, es decir, todo aquello que forma parte de la
acción y que no queda bajo control del jugador, por ejemplo, el movimiento de los enemigos,
cálculo de trayectoria de sus disparos, comprobación de colisiones entre la nave enemiga y la
del jugador, etc... Fuera de la lógica del juego quedan otras tareas que realizamos en la
siguiente fase, como son actualizar el scroll de fondo (si lo hubiera), activar sonidos (si fuera necesario), realizar trabajos de sincronización, etc.. Ya por último, nos resta volcar todo a la
pantalla y mostrar el siguiente frame. Esta fase es llamada “fase de render”.
Normalmente, el game loop tendrá un aspecto similar a lo siguiente:

Código:

int done = 0;
while (!done) {
// Leer entrada
// Procesar entrada
// Lógica de juego
// Otras tareas
// Mostrar frame
}

Antes de que entremos en el game loop, tendremos que realizar múltiples tareas, como
inicializar todas las estructuras de datos, etc...
El siguiente ejemplo es mucho más realista. Está implementado en un thread.

Código:

public void run() {
iniciar();
while (true) {
// Actualizar fondo de pantalla
doScroll();
// Actualizar posición del jugador
computePlayer();
// Actualizar pantalla
repaint();
serviceRepaints();
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
System.out.println(e.toString());
}
}
}

Lo primero que hacemos es inicializar el estado del juego. Seguidamente entramos en el
bucle principal del juego o game loop propiamente dicho. En este caso, es un bucle infinito,
pero en un juego real, tendríamos que poder salir usando una variable booleana que se
activara al producirse la destrucción de nuestro avión o cualquier otro evento que suponga la
salida del juego.
Ya dentro del bucle, lo que hacemos es actualizar el fondo de pantalla -en la siguiente
sección entraremos en los detalles de este proceso-, a continuación, calculamos la posición
de nuestro avión para posteriormente forzar un repintado de la pantalla con una llamada a
repaint() y serviceRepaint s(). Por último, utilizamos el método sleep()
perteneciente a la clase Thread para introducir un pequeño retardo. Este retardo habrá de
ajustarse a la velocidad del dispositivo en que ejecutemos el juego.
Movimiento del avión
Para mover nuestro avión utilizaremos, como comentamos en la sección dedicada a la
lectura del teclado, los métodos keyPressed() y keyReleased(). Concretamente, lo que
vamos a hacer es utilizar dos variables para almacenar el factor de incremento a aplicar en el
movimiento de nuestro avión en cada vuelta del bucle del juego. Estas variables son deltaX
y deltaY para el movimiento horizontal y vertical, respectivament e.

Código:

public void keyReleased(int keyCode) {
int action=getGameAction(keyCode);
switch (action) {
case LEFT:
deltaX=0;
break;
case RIGHT:
deltaX=0;
break;
case UP:
deltaY=0;
break;
case DOWN:
deltaY=0;
break;
}
}
public void keyPressed(int keyCode) {
int action=getGameAction(keyCode);
switch (action) {
case LEFT:
deltaX=-5;
break;
case RIGHT:
deltaX=5;
break;
case UP:
deltaY=-5;
break;
case DOWN:
deltaY=5;
break;
}
}

[maxwellnewage]

Cuando pulsamos una tecla, asignamos el valor correspondient e al desplazamiento
deseado, por ejemplo, si queremos mover el avión a la derecha, el valor asignado a deltaX
será 5. Esto significa que en cada vuelta del game loop, sumaremos 5 a la posición de avión,
es decir, se desplazará 5 píxeles a la derecha. Cuando se suelta la tecla, inicializamos a 0 la
variable, es decir, detenemos el movimiento.
La función encargada de calcular la nueva posición del avión es, pues, bastante sencilla.

Código:

void computePlayer() {
// actualizar posición del avión
if (hero.getX()+deltaX>0 && hero.getX()+deltaX<getWidth() &&
hero.getY()+deltaY>0 && hero.getY()+deltaY<getHeight()) {
hero.setX(hero.getX()+deltaX);
hero.setY(hero.getY()+deltaY);
}
}

Simplemente sumamos deltaX a la posición X del avión y deltaY a la posición Y. Antes
comprobamos que el avión no sale de los límites de la pantalla.

[dante189]

no es mas facil ke hubieras puesto el link de la descarga del curso en vez de tanto copy y paste?