LIBGDX As colisions

De MediaWiki
Saltar a: navegación, buscar

UNIDADE 2: As colisións

Introducción

Para detectar o choque imos utilizar a clase Intersector. Os método de dita clase van devolver un booleano que vai indicar se se produce algunha intersección entre dúas figuras xeométricas.

Tamén pode comprobar se un raio (un punto cun vector dirección) choca cun plano ou figura xeométrica así como calcular distancias entre puntos ou puntos e figuras xeométricas.

Importante: Non é necesario instanciar a clase Intersector. Todos os seus métodos son de clase e polo tanto para chamar a calquera deles só é necesario facer Intersector.nomeDoMétodo.

Como funciona a clase Intersector

Algúns dos métodos que nos ofrece:
Dita clase ten multitude de métodos que son fáciles de entender xa polo seu nome...
Devolve a distancia entre unha liña e un punto. Os parámetros que se dan a este método serían a liña, definida por catro coordenadas e un punto, definido por dous coordenadas. Está sobrecargado.
Comproba se un raio (un punto cun vector dirección) intersecciona cun BoundingBox (unha figura xeométrica en forma de cubo ou prima. O veremos na parte 3D).
Devolve true ou false dependendo se os dous círculos indicados se solapan.
Está sobrecargado e temos métodos que:


Un exemplo...

Preparación: Agora ides facer unha copia da clase RendererXogo, xa que imos modificala para amosarvos como se poden controlar os choques. Premede co rato sobre a clase, botón dereito e escollede a opción Copy. Despois repetides a operación pero escolledes a opción Paste. Vos preguntará un nome para a clase. Indicade UD2_5_RendererXogo.

Modificade a pantalla PantallaXogo para que chame a esta clase.


Código da clase UD2_5_RendererXogo
Obxectivo: Facer que o alien se mova co dedo e comprobar cando choca coa nave espacial.

  1. package com.plategaxogo2d.renderer;
  2.  
  3. import com.badlogic.gdx.Gdx;
  4. import com.badlogic.gdx.graphics.Color;
  5. import com.badlogic.gdx.graphics.GL20;
  6. import com.badlogic.gdx.graphics.OrthographicCamera;
  7. import com.badlogic.gdx.graphics.g2d.SpriteBatch;
  8. import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
  9. import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
  10. import com.badlogic.gdx.math.Circle;
  11. import com.badlogic.gdx.math.Intersector;
  12. import com.badlogic.gdx.math.Rectangle;
  13. import com.badlogic.gdx.math.Vector3;
  14. import com.plategaxogo2d.angel.AssetsXogo;
  15. import com.plategaxogo2d.angel.Controis;
  16. import com.plategaxogo2d.angel.Utiles;
  17. import com.plategaxogo2d.modelo.Alien;
  18. import com.plategaxogo2d.modelo.Mundo;
  19. import com.plategaxogo2d.modelo.Nave;
  20.  
  21. /*
  22.  * Comprobamos como funciona a clase Intersector.
  23.  */
  24.  
  25. public class UD2_5_RendererXogo {
  26.  
  27.     private OrthographicCamera camara2d;
  28.     private SpriteBatch spritebatch;
  29.     private ShapeRenderer shaperender;
  30.  
  31.         private Mundo meuMundo;
  32.  
  33.  
  34.     public UD2_5_RendererXogo(Mundo mundo) {
  35.                 this.meuMundo = mundo;
  36.  
  37.         camara2d = new OrthographicCamera();
  38.         spritebatch = new SpriteBatch();
  39.         shaperender = new ShapeRenderer();
  40.     }
  41.  
  42.    
  43.         private void debuxarAlien(){
  44.                 Alien alien = meuMundo.getAlien();
  45.                 spritebatch.draw(AssetsXogo.textureAlien, alien.getPosicion().x,alien.getPosicion().y,alien.getTamano().x,alien.getTamano().y);
  46.         }
  47.        
  48.         private void debuxarNave(){
  49.                 Nave nave = meuMundo.getNave();
  50.                 spritebatch.draw(AssetsXogo.textureNave, nave.getPosicion().x,nave.getPosicion().y,nave.getTamano().x,nave.getTamano().y);
  51.         }
  52.        
  53.        
  54.     /**
  55.      * Debuxa todos os elementos graficos da pantalla
  56.      *
  57.      * @param delta
  58.      *            : tempo que pasa entre un frame e o seguinte.
  59.      */
  60.     public void render(float delta) {
  61.                 Gdx.gl.glClearColor(0, 0, 0, 1);
  62.                 Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
  63.  
  64.                 spritebatch.begin();
  65.                
  66.                         debuxarNave();
  67.                        
  68.                         debuxarAlien();
  69.  
  70.                 spritebatch.end();
  71.                
  72.                 debugger();
  73.                
  74.     }
  75.  
  76.         private void debugger(){
  77.                
  78.                 shaperender.begin(ShapeType.Line);
  79.                 shaperender.setColor(Color.YELLOW);
  80.  
  81.                 Alien alien = meuMundo.getAlien();
  82.                 shaperender.rect(alien.getPosicion().x, alien.getPosicion().y, alien.getTamano().x, alien.getTamano().y);
  83.                
  84.                 shaperender.setColor(Color.RED);
  85.                 Nave nave = meuMundo.getNave();
  86.                 shaperender.rect(nave.getPosicion().x, nave.getPosicion().y, nave.getTamano().x, nave.getTamano().y);
  87.                
  88.                 shaperender.end();
  89.                
  90.         }
  91.  
  92.  
  93.     public void resize(int width, int height) {
  94.  
  95.                 camara2d.setToOrtho(false, Mundo.TAMANO_MUNDO_ANCHO,
  96.                                 Mundo.TAMANO_MUNDO_ALTO);
  97.                 camara2d.update();
  98.  
  99.                 spritebatch.setProjectionMatrix(camara2d.combined);
  100.                 shaperender.setProjectionMatrix(camara2d.combined);
  101.  
  102.     }
  103.  
  104.     public void dispose() {
  105.             spritebatch.dispose();
  106.     }
  107.  
  108.  
  109. }



Agora, por simplificar, non imos usar a interface InputProcessor e imos chamar directamente a métodos do paquete Gdx.input que nos van devolver a última coordenada pulsada na pantalla. Modificamos o método render e poñemos este código.


  1.     public void render(float delta) {
  2.                 Gdx.gl.glClearColor(0, 0, 0, 1);
  3.                 Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
  4.  
  5.                 if (Gdx.input.justTouched()){
  6.                         float posx=Gdx.input.getX();
  7.                         float posy = Gdx.input.getY();
  8.                        
  9.                         Vector3 dedo = new Vector3(posx,posy,0);
  10.                         camara2d.unproject(dedo);
  11.                        
  12.                         Alien alien = meuMundo.getAlien();
  13.                         alien.setPosicion(dedo.x,dedo.y);
  14.                         Rectangle rectangulo_alien = new Rectangle(alien.getPosicion().x,alien.getPosicion().y,
  15.                                         alien.getTamano().x,alien.getTamano().y);
  16.                        
  17.                         Nave nave = meuMundo.getNave();
  18.                         Rectangle rectangulo_nave = new Rectangle(nave.getPosicion().x,nave.getPosicion().y,
  19.                                                                                                  nave.getTamano().x,nave.getTamano().y);
  20.                        
  21.                         if (Intersector.overlaps(rectangulo_alien, rectangulo_nave)){
  22.                                 Utiles.imprimirLog("UD2_5_RendererXogo", "RENDER", "CHOCA CON NAVE");
  23.                         }
  24.                 }
  25. }

Comentarios:

  • Liña 5: comproba se se pulsa a pantalla.
  • LIñas 6-7: obtén a coordenada en pixeles de pantalla da última posición.
  • Liñas 9-10: pasa de coordenadas de pantalla a coordenadas do noso mundo. Xa visto anteriormente.
  • Liñas 12-13: obtén o alien e o move á posición pulsada.
  • Liña 14: crea un rectángulo coa posición e o tamaño do alien.
  • Liñas 17-19: obtén a nave e crea un rectángulo coa posición e o tamaño.
  • Liñas 21-23: comproba se os dous rectángulos 'chocan' e manda unha mensaxe en caso afirmativo.


Exercicio proposto: poderíamos mover o Alien co dedo. Teríamos que utilizar a interface InputProcessor, ir ó evento adecuado e comprobar se estamos enriba do alien para facer que se move ás coordenadas indicadas polo evento (pasadas previamente a coordenadas do noso mundo).



Recomendación: No caso de xestionar controis de movemento, como frechas de tipo arriba-abaixo-esquerda-dereita, se pode utilizar a clase Circle para representar o dedo pulsado na pantalla e usar o método static boolean overlaps(Circle c, Rectangle r) para comprobar se se premeu a frecha.


Nota: Volvede a facer que a clase PantallaXogo chame á clase RendererXogo.



TAREFA 2.8.B A FACER: Esta parte está asociada á realización dunha tarefa.


Facer que o Alien se mova cos elementos móbiles

Despois de facer a tarefa 2.8 xa controlades ó Alien. Imos facer que cando pase por enriba dun elemento móbil o Alien se mova con él.

Seríades capaces de facelo ?


Como ven pensades temos que poñer o código na clase ControladorXogo e o imos facer no método controlarAlien de dita clase.

Agora temos que pensar se imos necesitar gardar algún valor novo para controlar este estado.

Unha posible solución pode ser a de gardar unha velocidade que se lle sume á velocidade que ten o propio alien. Dita velocidade se modifica en función de se sube a un elemento móbil. Agora xa sabemos como controlar cando o alien intersecciona cun elemento móbil.

Mans a obra.

Nota: eu vos dou unha posible solución pero cada un pode facelo como queira.

Código da clase Alien
Obxectivo: engadimos un campo novo de nome velocidadeMontado. Sumámoslle á velocidade do alien dito valor que será modificado cando o alien suba a un elemento móbil.

  1.         private float velocidadeMontado;
  2.         ...........
  3.         public Alien(Vector2 posicion, Vector2 tamano, float velocidade_max) {
  4.                 super(posicion, tamano, velocidade_max);
  5.  
  6.                 velocidade = new Vector2(0,0);
  7.                 setVelocidade_montado(0);
  8.          }
  9.          ...........
  10.         public float getVelocidade_montado() {
  11.                 return velocidadeMontado;
  12.         }
  13.  
  14.         public void setVelocidade_montado(float velocidade_montado) {
  15.                 this.velocidadeMontado = velocidade_montado;
  16.         }
  17.        
  18.         public void update(float delta){
  19.              setPosicion(getPosicion().x+(velocidade.x+velocidadeMontado)*delta,
  20.                          getPosicion().y+velocidade.y*delta);
  21.                
  22.         }

Agora só queda modificar dito valor e darlle a velocidade do elemento móbil cando estea enriba del. Pero antes de facer isto imos a refinar un pouco o código. Se intentamos facer isto sen máis imos ter que crear dous rectángulos e darlles a posición do alien e a posición de cada un dos elementos móbiles, chamando á clase Intersector para comprobar se se tocan.

En vez disto, podemos modificar a clase Personaxe e crear unha propiedade rectángulo que se modifique cando se cambie de posición (o tamaño do rectángulo non varía).

Código da clase Personaxe
Obxectivo: creamos unha propiedade rectangulo de tipo Rectangle que vai gardar a posición actual e o tamaño do Personaxe. Usado pola clase Intersector.

  1. import com.badlogic.gdx.math.Rectangle;
  2. ...........
  3. public abstract class Personaxe {
  4.        
  5.         private Rectangle rectangulo;
  6.  
  7.         /**
  8.           * Constructor por defecto
  9.         */
  10.         public Personaxe(){
  11.                 rectangulo = new Rectangle();
  12.         }
  13.         public Personaxe(Vector2 posicion, Vector2 tamano, float velocidade_max) {
  14.                 this.posicion = posicion;
  15.                 this.tamano = tamano;
  16.                 this.velocidade_max = velocidade_max;
  17.                
  18.                 rectangulo = new Rectangle(posicion.x,posicion.y,tamano.x,tamano.y);
  19.         }
  20.         ...........
  21.  
  22.         public void setTamanoRectangulo(float width,float height){
  23.                 rectangulo.setWidth(width);
  24.                 rectangulo.setHeight(height);
  25.         }
  26.         ...........
  27.         /**
  28.          * Actualiza a posición do rectángulo asociado á forma do gráfico
  29.          *
  30.          */
  31.         public void actualizarRectangulo(){
  32.                 rectangulo.x=posicion.x;
  33.                 rectangulo.y=posicion.y;
  34.         }
  35.  
  36.         /**
  37.          * Devolve o rectángulo asociado
  38.          * @return rectangulo
  39.          */
  40.         public Rectangle getRectangulo(){
  41.                 return rectangulo;
  42.         }
  43.  
  44.         public void setPosicion(Vector2 posicion) {
  45.             this.posicion = posicion;
  46.             actualizarRectangulo();
  47.         }
  48.  
  49.        /**
  50.         * Modifica a posición
  51.         *
  52.         * @param x: nova posición x
  53.         * @param y: nova posición y
  54.         */
  55.         public void setPosicion(float x, float y) {
  56.             posicion.x = x;
  57.             posicion.y = y;
  58.             actualizarRectangulo();
  59.         }
  60.  
  61.         /**
  62.          * Asina un novo tamano
  63.          * @param tamano: o novo tamano.
  64.          */
  65.         public void setTamano(Vector2 tamano) {
  66.                 this.tamano=tamano;
  67.                 setTamanoRectangulo(tamano.x,tamano.y);
  68.         }
  69.        
  70.         public void setTamano(float width, float height) {
  71.                 this.tamano.set(width,height);
  72.                 setTamanoRectangulo(width, height);
  73.         }
  74.        
  75.         ...........
  76. }


NOTA IMPORTANTE: O método update das clases que derivan da clase Personaxes (como ElementoMobil) debe chamar ó método setPosicion() para moverse:

  1.         @Override
  2.         public void update(float delta) {
  3.         // TODO Auto-generated method stub
  4.                setPosicion(posicion.add(velocidade*delta,0));
  5.         }

NON DEBEMOS FACER ASI:

  1.         @Override
  2.         public void update(float delta) {
  3.          // TODO Auto-generated method stub
  4.             posicion.add((velocidade*delta),0);
  5.         }


Agora só queda modifica a clase controladorXogo para ver cando coinciden e modificar a velocidadeMontado do alien. Exercicio proposto: Intentádeo facelo.



Posible solución:


Código da clase ControladorXogo
Obxectivo: Modificamos o método controlarAlien para controlar cando chocan os rectángulos do alien cos dos elementos móbiles.

  1.         private void controlarAlien(float delta){
  2.                
  3.                 // Actualiza Alien
  4.                 alien.update(delta);
  5.                
  6.                
  7.                 // Impide que se mova fora dos límites da pantalla
  8.                 if (alien.getPosicion().x <=0){
  9.                         alien.setPosicion(0, alien.getPosicion().y);
  10.                 }
  11.                 else {
  12.                         if (alien.getPosicion().x >= Mundo.TAMANO_MUNDO_ANCHO-alien.getTamano().x){
  13.                                 alien.setPosicion(Mundo.TAMANO_MUNDO_ANCHO-alien.getTamano().x, alien.getPosicion().y);
  14.                         }
  15.                        
  16.                 }
  17.                
  18.                 if (alien.getPosicion().y <=Controis.FONDO_NEGRO.height){
  19.                         alien.setPosicion(alien.getPosicion().x,Controis.FONDO_NEGRO.height);
  20.                 }
  21.                 else {
  22.                         if (alien.getPosicion().y >= Mundo.TAMANO_MUNDO_ALTO-alien.getTamano().y){
  23.                                 alien.setPosicion(alien.getPosicion().x, Mundo.TAMANO_MUNDO_ALTO-alien.getTamano().y);
  24.                         }
  25.                        
  26.                 }
  27.  
  28.                 // Controla que suba enriba dun elemento móvil
  29.                 alien.setVelocidade_montado(0);
  30.                 for (ElementoMobil elem : meuMundo.getRochas()){
  31.                         if (Intersector.overlaps(elem.getRectangulo(), alien.getRectangulo())){
  32.                                 alien.setVelocidade_montado(elem.getVelocidade());
  33.                         }
  34.                 }
  35.                 for (ElementoMobil elem : meuMundo.getTroncos()){
  36.                         if (Intersector.overlaps(elem.getRectangulo(), alien.getRectangulo())){
  37.                                 alien.setVelocidade_montado(elem.getVelocidade());
  38.                         }
  39.                 }
  40.  
  41.                
  42.         }


Se vos fixades e xogades, o alien ten o rectángulo asociado demasiado grande e iso fai que teñamos este efecto:

LIBGDX UD2 10 colision 1.jpg

Como podedes observar o alien está pegado á rocha e é arrastrado.

Para solucionalo podemos facer que o rectángulo do alien sexa máis pequeno (a mitade) pero tamén temos que sobreescribir o método que actualiza o rectángulo xa que o queremos centrado (se non tería a metade de tamaño pero estaría situado abaixo á esquerda.

Código da clase Alien
Obxectivo: axustar o tamaño e posición do rectángulo.

  1. public class Alien extends Personaxe {
  2.  
  3.         public Alien(Vector2 posicion, Vector2 tamano, float velocidade_max) {
  4.                 super(posicion, tamano, velocidade_max);
  5.                
  6.                 velocidade = new Vector2(0,0);
  7.                 setVelocidade_montado(0);
  8.  
  9.                 getRectangulo().setSize(tamano.x/2);
  10.         }
  11.         ..............
  12.         @Override
  13.         public void actualizarRectangulo(){
  14.  
  15.                 getRectangulo().x = getPosicion().x+getTamano().x/4;
  16.                 getRectangulo().y = getPosicion().y+getTamano().y/4;
  17.                
  18.         }
  19.        ..............
  20.  
  21. }




Controlar os choques dos coches có Alien

Controlar isto xa non ten problema ningún.

Código da clase ControladorXogo
Obxectivo: Xestionar os choques cos coches.

  1.         private void controlarAlien(float delta){
  2.                 ............
  3.  
  4.                 // Controla se lle colle un vehículo
  5.                 for (ElementoMobil elem : meuMundo.getCoches()){
  6.                         if (Intersector.overlaps(elem.getRectangulo(), alien.getRectangulo())){
  7.                                  // ALIEN MORTO
  8.                         }
  9.                 }
  10.                
  11.          }


Controlar cando o alien cae na lava ou na auga

Igual que fixemos antes a solución é bastante sinxela. O único complicado é descubrir as coordenadas e tamaño da auga e lava.

Podemos crear un array de zonas perigosas e comprobar se está dentro dunha delas. Tamén temos que definir as zonas seguras, xa que no lugar onde está a nave hai unhas pasarelas que son seguras e teremos que definilas. A definición de ditas zonas a podemos ter na clase Mundo utilizando un array de Rectangles.

Código da clase Mundo
Obxectivo: definimos nun array de Rectangle as zonas perigosas e seguras.
Nota: Estas zonas están definidas para un tamaño de mundo de 300 por 500.

  1.     public static final Rectangle ZONAS_PERIGOSAS[]={new Rectangle(0,40,300,120),new Rectangle(0,220,300,120), new Rectangle(0,420,300,80)};
  2.     public static final Rectangle ZONAS_SEGURAS[]={new Rectangle(40,420,20,60),new Rectangle(140,420,20,60), new Rectangle(240,420,20,60)};  // AS PLATAFORMAS QUE ESTAN ENRIBA DA LAVA.

Agora só temos que controlar se o alien pisa algunha delas, PERO....... temos que ter en conta cando está enriba dun tronco ou rocha para que non comprobe as zonas. Como podemos sabelo ? Pois mirando o valor da velocidade_montado do alien que cando está enriba dun tronco ou rocha ten un valor diferente a 0.

Código da clase ControladorXogo
Obxectivo: verificar se o alien está nunha zona segura ou perigosa.

  1.         private void controlarAlien(float delta){
  2.                 ..............
  3.  
  4.                 // Controla se cae a auga ou lava
  5.                 if (alien.getVelocidade_montado()==0){
  6.                         boolean seguro=false;
  7.                         // Se está nunha zona segura xa non mira as perigosas
  8.                         for(int cont=0; cont < Mundo.ZONAS_SEGURAS.length;cont++){
  9.                                 if (Intersector.overlaps(Mundo.ZONAS_SEGURAS[cont], alien.getRectangulo())){
  10.                                         seguro=true;
  11.                                         break;
  12.                                 }
  13.                         }
  14.                         if (!seguro){
  15.                                 for(int cont=0; cont < Mundo.ZONAS_PERIGOSAS.length;cont++){
  16.                                         if (Intersector.overlaps(Mundo.ZONAS_PERIGOSAS[cont], alien.getRectangulo())){
  17.                                                 // ALIEN MORRE
  18.                                         }
  19.                                 }
  20.                         }
  21.                 }

Avanzando no noso xogo

Relacionados con a xestión de atropellos, lava e auga :) imos xestionar as vidas salvadas/perdidas do alien.

Unha proposta de solución:
A idea e ter nun array as vidas salvadas e mortas e debuxalas na parte inferior da pantalla.

Exercicio proposto: facer o anterior.

Posible solución:
Como sempre temos que pensar que información imos necesitar para engadir esta funcionalidade e onde gardala.

No noso caso dita información será gardada na clase Alien.

Código da clase Alien
Obxectivo: xestionar as vidas salvadas / perdidas.

  1. import com.badlogic.gdx.utils.Array;
  2. ..........
  3. public class Alien extends Personaxe {
  4.  
  5.         public static enum TIPOS_VIDA{INICIAL,SALVADO,MUERTO};
  6.         private Array<TIPOS_VIDA>numVidas;
  7.         ...............
  8.         public Alien(Vector2 posicion, Vector2 tamano, float velocidade_max) {
  9.                 super(posicion, tamano, velocidade_max);
  10.                
  11.                 velocidade = new Vector2(0,0);
  12.                 setVelocidade_montado(0);
  13.  
  14.                 getRectangulo().setSize(tamano.x/2);
  15.  
  16.                 numVidas = new Array<Alien.TIPOS_VIDA>();
  17.         }
  18.         ...............
  19.         public Array<TIPOS_VIDA> getNumVidas() {
  20.                 return numVidas;
  21.         }
  22.  
  23.         public void setNumVidas(TIPOS_VIDA vida) {
  24.                 numVidas.add(vida);
  25.         }
  26.        
  27.         public int getNumVidasSalvadas(){
  28.                 int num=0;
  29.                 for (TIPOS_VIDA vida : numVidas){
  30.                         if (vida == TIPOS_VIDA.SALVADO) num++;
  31.                 }
  32.                
  33.                 return num;
  34.         }
  35.        ...............
  36.  
  37. }


Agora queda debuxar as vidas....como imos debuxalas nunha posición da pantalla podemos gardar dita posición na clase Controis.
Código da clase Controis
Obxectivo: Gardar a posición onde se debuxan as vidas.

  1.         public final static int POSVIDAS = 60;




Agora debuxamos as vidas na posición indicada na clase RendererXogo.
Código da clase RendererXogo
Obxectivo: Debuxar as vidas.

  1.         ..............
  2.         private void debuxarVidas(){
  3.                 Texture textura;
  4.                 int posx=Controis.POSVIDAS;
  5.                 for(Alien.TIPOS_VIDA vida : meuMundo.getAlien().getNumVidas()){
  6.                         if(vida == Alien.TIPOS_VIDA.MUERTO)
  7.                                 textura = AssetsXogo.textureAlienDead;
  8.                         else if(vida == Alien.TIPOS_VIDA.SALVADO)
  9.                                         textura = AssetsXogo.textureAlienRescue;
  10.                         else
  11.                                 textura = AssetsXogo.textureAlien;
  12.  
  13.                         spritebatch.draw(textura,posx,0,10,10);
  14.                         posx+=12;
  15.                 }
  16.         }
  17.         ..............
  18.     public void render(float delta) {
  19.                 Gdx.gl.glClearColor(0, 0, 0, 1);
  20.                 Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
  21.  
  22.                 spritebatch.begin();
  23.                
  24.                         debuxarFondo();
  25.                
  26.                         debuxarNave();
  27.                        
  28.                         debuxarCoches();
  29.                         debuxarRochas();
  30.                         debuxarTroncos();
  31.                        
  32.                         debuxarAlien();
  33.  
  34.                         debuxarControis();
  35.                         debuxarVidas();
  36.                 spritebatch.end();
  37.                
  38.                 if (debugger) {
  39.                         debugger();
  40.                 }
  41.     }
  42.         ..............


Nota: É importante a orde de debuxo xa que se chamamos a debuxarVidas antes que a debuxarControis, o punto negro que conforma a banda inferior tapará as vidas.

E por último temos que modificar á clase ControladorXogo para engadir á vida / morte ó array de vidas en función de se chegamos á nave ou morremos polo camiño...

Código da clase ControladorXogo
Obxectivo: Xestionar as vidas.

  1.         private void controlarAlien(float delta){
  2.                 ............
  3.  
  4.                 // Controla se lle colle un vehículo
  5.                 for (ElementoMobil elem : meuMundo.getCoches()){
  6.                         if (Intersector.overlaps(elem.getRectangulo(), alien.getRectangulo())){
  7.                                 alien.setNumVidas(TIPOS_VIDA.MUERTO);
  8.                         }
  9.                 }
  10.  
  11.                 // Controla se cae a auga ou lava
  12.                 if (alien.getVelocidade_montado()==0){
  13.                         boolean seguro=false;
  14.                         // Se está nunha zona segura xa non mira as perigosas
  15.                         for(int cont=0; cont < Mundo.ZONAS_SEGURAS.length;cont++){
  16.                                 if (Intersector.overlaps(Mundo.ZONAS_SEGURAS[cont], alien.getRectangulo())){
  17.                                         seguro=true;
  18.                                         break;
  19.                                 }
  20.                         }
  21.                         if (!seguro){
  22.                                 for(int cont=0; cont < Mundo.ZONAS_PERIGOSAS.length;cont++){
  23.                                         if (Intersector.overlaps(Mundo.ZONAS_PERIGOSAS[cont], alien.getRectangulo())){
  24.                                                 alien.setNumVidas(TIPOS_VIDA.MUERTO);
  25.                                         }
  26.                                 }
  27.                         }
  28.                 }
  29.                
  30.         }



Como está agora encheremos de vidas mortas a parte inferior xa que non nos movemos e os coches seguen pasando por enriba.

Para evitalo imos a engadir á clase Alien un método para inicializar o alien cando morre.

Código da clase Alien
Obxectivo: inicializar o alien cando morre.

  1.         public void inicializarAlien(){
  2.           setPosicion(100, 20);
  3.           setVelocidade_montado(0);
  4.           setVelocidadeX(0);
  5.           setVelocidadeY(0);
  6.           setTamano(15,15);
  7.           getRectangulo().setSize(tamano.x/2);
  8.        }


Código da clase ControladorXogo
Obxectivo: inicializar o alien cando morre.

  1.         private void controlarAlien(float delta){
  2.                 .................
  3.                 // Controla se lle colle un vehículo
  4.                 for (ElementoMobil elem : meuMundo.getCoches()){
  5.                         if (Intersector.overlaps(elem.getRectangulo(), alien.getRectangulo())){
  6.                                 alien.setNumVidas(TIPOS_VIDA.MUERTO);
  7.                                 alien.inicializarAlien();
  8.                         }
  9.                 }
  10.  
  11.                 // Controla se cae a auga ou lava
  12.                 if (alien.getVelocidade_montado()==0){
  13.                         boolean seguro=false;
  14.                         // Se está nunha zona segura xa non mira as perigosas
  15.                         for(int cont=0; cont < Mundo.ZONAS_SEGURAS.length;cont++){
  16.                                 if (Intersector.overlaps(Mundo.ZONAS_SEGURAS[cont], alien.getRectangulo())){
  17.                                         seguro=true;
  18.                                         break;
  19.                                 }
  20.                         }
  21.                         if (!seguro){
  22.                                 for(int cont=0; cont < Mundo.ZONAS_PERIGOSAS.length;cont++){
  23.                                         if (Intersector.overlaps(Mundo.ZONAS_PERIGOSAS[cont], alien.getRectangulo())){
  24.                                                 alien.setNumVidas(TIPOS_VIDA.MUERTO);
  25.                                                 alien.inicializarAlien();
  26.                                         }
  27.                                 }
  28.                         }
  29.                 }
  30.  
  31.          }



TAREFA 2.9 A FACER: Esta parte está asociada á realización dunha tarefa.





-- Ángel D. Fernández González -- (2014).