Tutorial J2ME programacion JavaMovil

Juegos Java

Tutorial 4- Controlando a nuestro Sprite con el teclado

INTRODUCCIÓN:

En la tutorial anterior vimos como un sprite se mueve de un lado a otro de nuestra pantalla, ahora crearemos otro sprite y lo controlaremos con el joystick y/o teclado de nuestro dispositivo móvil.

Clases que intervendrán en el siguiente ejemplo:

- Demo1
- SSCanvas
- Sprite

Aqui el código completo, más abajo se analizará los cambios añadidos

//importamos las clases de java que utilizaremos en nuestro programa
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;


/*aqui nuestro MIDlet, esta clase sera la primera en ser ejecutada cuando se
ejecute el programa*/
public class Demo1 extends MIDlet {    
    //metodo cuando el midlet arranca
    public void startApp() {
        //creamos un objeto SSCanvas (nuestra pantalla de juego)
        SSCanvas screen=new SSCanvas();
        //indicamos al dispositivo que screen (instancia de SSCanvas) será la 
		//nueva pantalla activa
        Display.getDisplay(this).setCurrent(screen);   
        new Thread(screen).start(); //arrancamos el bucle (nuevo hilo de ejecución)
    }
    
    //metodo cuando el midlet entra en pausa
    public void pauseApp() {
    }
    
    //metodo cuando el midlet es destruido
    public void destroyApp(boolean unconditional) {
    }
}


//esta clase es la encargada de hacer funcionar nuestra aplicación gráfica 
class SSCanvas extends Canvas implements Runnable{ 
    private Sprite ball;
    private Sprite player;
    
    //metodo constructor
    public SSCanvas(){
        //instanciamos (creamos) el objeto ball a partir de la clase Sprite
        ball = new Sprite(getWidth()/2,getHeight()/2,20,20);
        player = new Sprite(getWidth()/2,getHeight()/3,30,30);
    }
    
    public void run(){
        while(true){
            //actualizamos la posicion de la bola
            ball.compute(getWidth(),getHeight());  
            player.computePlayer(getWidth(),getHeight());
            //forzamos el repintado de la pantalla
            repaint();
            serviceRepaints();
            try {
                Thread.sleep(30);            
            } catch (InterruptedException e) {        
            }
        }
    }
    //metodo de la clase canvas para pintar en pantalla
    public void paint(Graphics g){          
        //seleccionamos el color negro para pintar el fondo
	g.setColor(0,0,0);
	//pintamos el fondo de pantalla con un rectangulo con el tamaño de
	//la pantalla getWidth() y getHeight() es un método de la clase canvas
	//que nos devuelve el ancho y alto de la pantalla
        g.fillRect(0,0,getWidth(),getHeight());       
        //pintamos la bola en pantalla
        ball.draw(g);
        player.draw(g);
    }    
    
    /*sobrecarga de método para detectar cuando una tecla es soltada 
    por el usuario*/
    public void keyReleased(int keyCode) {
	int action=getGameAction(keyCode);		
	switch (action) {
            case LEFT:    
                player.keyUp(player.LEFT);
		break;
            case RIGHT:	
                player.keyUp(player.RIGHT);
		break;
            case UP:
                player.keyUp(player.UP);
		break;
            case DOWN:	
                player.keyUp(player.DOWN);
		break;	
            case FIRE:                
                break;            
        }
    }

    //sobrecarga del método que detecta cuando una tecla es pulsada por el usuario
    public void keyPressed(int keyCode) {
	int action=getGameAction(keyCode);       		
        switch (action) {
            case LEFT:
                player.keyPress(player.LEFT);               
                break;
            case RIGHT:
                player.keyPress(player.RIGHT);		
		break;
            case UP:
                player.keyPress(player.UP);                
                break;
            case DOWN:
		player.keyPress(player.DOWN); 
		break;
            case FIRE:		    
		break;                     
         }        
    }
}

class Sprite{
    //atributos privados
    protected int x; 
    protected int y;
    protected int width;
    protected int height;
    protected int incX,incY;
    private boolean startX=false;
    private boolean startY=false;
    
    //declaracion de constantes
    protected static final int LEFT = 1;
    protected static final int RIGHT = 2;
    protected static final int UP = 3;
    protected static final int DOWN = 4;
    protected static final int FIRE = 5;
    
    
    //metodo constructor 
    public Sprite(int x,int y,int width,int height){
        this.x=x;
        this.y=y;
        this.width=width;
        this.height=height;
        incX=3;
        incY=3;
    }
    
    //metodo que actualiza la posición del sprite
    public void compute(int screenW, int screenH){
        if(x <= 0)incX=3;
        else if(x+width >= screenW)incX=-3;
        
        x+=incX;
    }
    
    //metodo que actualiza la posicion del sprite que controlamos por teclado
    public void computePlayer(int screenW, int screenH) {
        if(x + incX > 0 && (x + incX) < (screenW - width)){
            x+=incX;          			
            if(startX==false)incX=0;
        }
        if(y + incY > 0 && (y + incY) < (screenH - height)){
            y+=incY;
            if(startY==false)incY=0;
        }          
    }	
    
    //metodo para detener el desplazamiento del sprite
     public void keyUp(int keyCode) {
	switch (keyCode) {
            case LEFT:
		startX=false;				
		break;
            case RIGHT:
		startX=false;
		break;
            case UP:
		startY=false;
            	break;
            case DOWN:
		startY=false;
		break;								
        }		
    }
	
    //método para indicar la dirección del desplazamiento
    public void keyPress(int keyCode) {	
        switch (keyCode) {
            case LEFT:
                incX=-5;
                startX=true;					
                break;
            case RIGHT:
                incX=5;	
                startX=true;			
                break;
            case UP:
                incY=-5;
                startY=true;
                break;
            case DOWN:
                incY=5;
                startY=true;
                break;
            case FIRE:                    
                break;
        }
    }    
    
    //metodo que muestra en pantalla al sprite
    public void draw(Graphics g){
        g.setColor(250,0,0);
        g.fillArc(x,y, width, height,0, 360);        
    }
}

EXPLICACION DEL CÓDIGO (solo se explicara los cambios, osea lo resaltado en verde)

Clase Demo1: No sufre ningún cambio a la versión de la tutorial anterior

Clase SSCanvas: El principal cambio es añadir la capacidad de escuchar (leer) desde el teclado del ratón los eventos producidos por este (eventos son las acciones que puede producir un objeto, en el caso del teclado son cuando una tecla es pulsada, es soltada, etc). Con esto haremos que uno de los sprites (el que llamamos player) podamos moverlo por la pantalla en el sentido que le indiquemos por medio del teclado o joystick del movil. El otro cambio es crear un sprite más llamado player que será con el que interactuemos con el teclado y unas lineas más de codigo para actualizar su posición y el pintado en pantalla.

Clase Sprite: Aqui añadiremos más atributos para controlar el estado del desplazamiento (utilizado por player), otros atributos estáticos para identificar las teclas pulsadas y 3 métodos más. El primer método es computePlayer que controlara el movimiento del sprite cuando se utilice un teclado, luego dos métodos que que controlaran en que dirección debe desplazarse, el primero keyDown activa el desplazamiento y keyUp desactiva el desplazamiento.

EXPLICACIÓN DEL CÓDIGO LINEA A LINEA

CLASE SSCanvas

 /*sobrecarga de método para detectar cuando una tecla es soltada por el usuario*/
 public void keyReleased(int keyCode) {
	int action=getGameAction(keyCode);		
	switch (action) {
            case LEFT:    
                player.keyUp(player.LEFT);
		break;
            case RIGHT:	
                player.keyUp(player.RIGHT);
		break;
            case UP:
                player.keyUp(player.UP);
		break;
            case DOWN:	
                player.keyUp(player.DOWN);
		break;	
            case FIRE:                
                break;            
        }
    }

    //sobrecarga del método que detecta cuando una tecla es pulsada por el usuario
    public void keyPressed(int keyCode) {
	int action=getGameAction(keyCode);       		
        switch (action) {
            case LEFT:
                player.keyPress(player.LEFT);               
                break;
            case RIGHT:
                player.keyPress(player.RIGHT);		
		break;
            case UP:
                player.keyPress(player.UP);                
                break;
            case DOWN:
		player.keyPress(player.DOWN); 
		break;
            case FIRE:		    
		break;                     
         }        
    }

En la clase SSCanvas se añaden dos métodos, que son una sobrecarga del método keyReleased y key Pressed ambos pertenecientes a la clase Canvas. El primero detecta cuando una tecla es soltada y el segundo cuando la tecla es pulsada. el Parametro que se pasa en ambos métodos es un entero que corresponde al identificador de la tecla, pero como cada fabricante de moviles puede asignar valores diferentes para una misma tecla se dispone del método getGameAction quien nos devuelve un entero que corresponde a unos valores constantes definidas en J2ME. Estas constantes nos dice que tecla fue pulsada, por ejemplo si el usuario pulsa en su movil el joystick a la izquierda o la tecla 4 getGameAction nos retornara el valor de la constante LEFT y asi para el resto de teclas.

Hay más modificaciones en el código de SSCanvas pero no se detalla ya que es la creación del sprite player y es muy similar al sprite ball.

Clase Sprite

    private int incX,incY;
    private boolean startX=false;
    private boolean startY=false;
    
    //declaracion de constantes
    protected static final int LEFT = 1;
    protected static final int RIGHT = 2;
    protected static final int UP = 3;
    protected static final int DOWN = 4;
    protected static final int FIRE = 5;

Se añaden nuevos atributos para controlar al sprite desde el teclado del movil, los atributos booleanos startX y startY se usan para cuando se pulsa y suelta la una tecla del movil. las constantes la usaremos para controlar la dirección del movilmiento de nuestro sprite.

    //metodo que actualiza la posicion del sprite 
    public void computePlayer(int screenW, int screenH) {
        if(x + incX > 0 && (x + incX) < (screenW - width)){
            x+=incX;          			
            if(startX==false)incX=0;
        }
        if(y + incY > 0 && (y + incY) < (screenH - height)){
            y+=incY;
            if(startY==false)incY=0;
        }          
    }

Este método se encarga de actualizar la posición del sprite controlado por teclado, haciendo que si startX o startY valen True incrementan o decrementan la posición x, y respectivamente. Además controlamos que el sprite no se salga de pantalla.

    //metodo para detener el desplazamiento del sprite
     public void keyUp(int keyCode) {
	switch (keyCode) {
            case LEFT:
		startX=false;				
		break;
            case RIGHT:
		startX=false;
		break;
            case UP:
		startY=false;
            	break;
            case DOWN:
		startY=false;
		break;								
        }		
    }

Método que es llamado cuando una tecla es soltada (luego de ser pulsada), y su función será de desactivar el desplazamiento en la dirección que se encontraba activada.

   //método para indicar la dirección del desplazamiento
    public void keyPress(int keyCode) {	
        switch (keyCode) {
            case LEFT:
                incX=-5;
                startX=true;					
                break;
            case RIGHT:
                incX=5;	
                startX=true;			
                break;
            case UP:
                incY=-5;
                startY=true;
                break;
            case DOWN:
                incY=5;
                startY=true;
                break;
            case FIRE:                    
                break;
        }
    }

Método que es llamado cuando una tecla es pulsada, su función es la de activar el desplazamiento del sprite asignando varlo true a stratX o startY y asignando un valor a incX o incY.

Para ver el programa en acción copia y pega el código como se explica en la tutorial 2.

<< Anterior | Indice | Siguiente >>

GLOSARIO

Java: lenguaje de programación creado por SUN Microsystems. es un lenguaje orientado a objetos y multiplataformas.
Clase: definiciones de las propiedades y comportamiento de un tipo de objeto concreto.
Objeto: entidad provista de un conjunto de propiedades o atributos (datos) y de comportamiento o funcionalidad (métodos). Corresponden a los objetos reales del mundo que nos rodea, o a objetos internos del sistema (del programa). Es una instancia a una clase.
Método: algoritmo asociado a un objeto (o a una clase de objetos), cuya ejecución se desencadena tras la recepción de un "mensaje". Desde el punto de vista del comportamiento, es lo que el objeto puede hacer. Un método puede producir un cambio en las propiedades del objeto, o la generación de un "evento" con un nuevo mensaje para otro objeto del sistema.
Evento: un suceso en el sistema (tal como una interacción del usuario con la máquina, o un mensaje enviado por un objeto). El sistema maneja el evento enviando el mensaje adecuado al objeto pertinente. También se puede definir como evento, a la reacción que puede desencadenar un objeto, es decir la acción que genera.
Constante: una constante es un valor definido en tiempo de diseño y que nunca cambia a lo largo de la ejecución del programa.
Sprite: es cualquier objeto que aparece en nuestro videojuego. Normalmente tiene asociado algunos atributos, siendo los más básicos una imagen y una posición.
Sobrecarga: se le llama así a un método que existiendo en la clase de la que se hereda (con la sentencia implements) se la vuelve a declarar en la clase actual.
Metodo constructor : se le llama así al método que se ejecuta al crearse un objeto de él (instancia), para crear un método constructor éste debe empezar con la palabra public void, seguido del nombre de la clase los parámetros son opcionales se puede pasar ningún a varios parámetros.