LIBGDX tarefa 2 6 Alternativa

De Manuais Informática - IES San Clemente.
Ir a la navegación Ir a la búsqueda

Tal como comentaba anteriormente temos moitas formas de programar o xogo, algunhas máis óptimas que outras.


Normalmente canto máis flexible é a solución máis complexa é de facer, pero despois nos permite engadir novos elementos moito máis rápido.


Vos vou amosar unha posible solución ó problema dos elementos móbiles. Loxicamente non tedes que facela, simplemente queda como posible alternativa á forma que estamos a desenrolar, existindo outros métodos seguro que máis óptimos...


Código da clase ElementoMovil
Obxectivo: Representa calquera elemento móbil do xogo.

 1 public class ElementoMobil extends Personaxe {
 2 
 3 	public static enum TIPOS_ELEMENTOS {COCHE, AUTOBUS, TRONCO, ROCA};
 4 	private TIPOS_ELEMENTOS tipo;
 5 
 6 	/**
 7 	 * Filas que se correponden con os elementos do xogo que se moven
 8 	 * @param fila: dende 0 ata 3 son para os coches; dende 4 a 6 son para os troncos
 9 	 */
10 	public ElementoMobil(){
11 		
12 	}
13 	public ElementoMobil(Vector2 posicion, Vector2 tamano, float velocidade_max,TIPOS_ELEMENTOS tipo) {
14 		super(posicion, tamano, velocidade_max);
15 		this.setTipo(tipo);
16 		// TODO Auto-generated constructor stub
17 		
18 		velocidade=velocidade_max;
19 	}
20 	
21 	public TIPOS_ELEMENTOS getTipo() {
22 		return tipo;
23 	}
24 	public void setTipo(TIPOS_ELEMENTOS tipo) {
25 		this.tipo = tipo;
26 	}
27 
28 
29 	@Override
30 	public void update(float delta) {
31 		// TODO Auto-generated method stub
32 
33 		setPosicion(posicion.x+delta*velocidade,posicion.y);
34 		
35 		
36 	}
37 
38 }


Nesta clase non hai moito que comentar.

Agora creo unha nova clase que vai ter nun array todos os elementos móbiles.

Código da clase Elementos
Obxectivo: Representa todos os elementos móbiles do xogo.

  1 public class Elementos {
  2 
  3 	private int posfilas[]={220,260,300,345,365,380,400,40,100};
  4 	private int velocidades[]={-35,95,-55,50,-45,35,-65,30,-50};
  5 
  6 	
  7 	private Array<ElementoMobil> elementos;
  8 	private float tempoParaCrearMax;
  9 	private float tempoParaCrearMin;
 10 	
 11 	private int numElementos;
 12 	
 13 	private float crono;
 14 	
 15 	
 16 	public Elementos(float tempomin,float tempomax,int numelementos){
 17 		elementos = new Array<ElementoMobil>();
 18 		setTempoparacrearMax(tempoParaCrearMax);
 19 		crono = tempoParaCrearMax;
 20 		setTempoparacrearMin(tempomin);
 21 		setNumelementos(numelementos);
 22 	}
 23 
 24 	private int getFila(ElementoMobil.TIPOS_ELEMENTOS tipoelem){
 25 		int fila=0;
 26 		
 27 		switch(tipoelem){
 28 		case AUTOBUS:
 29 		case COCHE:
 30 			fila = MathUtils.random(3,6);
 31 			break;
 32 		case ROCA:
 33 			fila = MathUtils.random(7,8);
 34 			break;
 35 		case TRONCO:
 36 			fila = MathUtils.random(0,2);
 37 			break;
 38 		default:
 39 			break;
 40 		
 41 		}
 42 		return fila;
 43 		
 44 	}
 45 	
 46 	public void engadirElemento(ElementoMobil.TIPOS_ELEMENTOS tipoelem){
 47 		int fila=0;
 48 		fila = getFila(tipoelem);
 49 		
 50 		ElementoMobil elemento = new ElementoMobil();
 51 		
 52 		elemento.posicion = new Vector2();
 53 		elemento.tamano = new Vector2();
 54 		
 55 		switch(tipoelem){
 56 		case AUTOBUS:
 57 			elemento.setTipo(TIPOS_ELEMENTOS.AUTOBUS);
 58 			elemento.setTamano(30,15);
 59 			break;
 60 		case COCHE:
 61 			elemento.setTipo(TIPOS_ELEMENTOS.COCHE);
 62 			elemento.setTamano(20,15);
 63 			break;
 64 		case ROCA:
 65 			elemento.setTipo(TIPOS_ELEMENTOS.ROCA);
 66 			elemento.setTamano(60,60);
 67 			break;
 68 		case TRONCO:
 69 			elemento.setTipo(TIPOS_ELEMENTOS.TRONCO);
 70 			elemento.setTamano(80,40);
 71 			break;
 72 		default:
 73 			break;
 74 		
 75 		}
 76 			
 77 
 78 		elemento.velocidade = velocidades[fila];
 79 		// Os pares sean da esquerda
 80 		if(velocidades[fila] >0)	
 81 			elemento.setPosicion(-elemento.tamano.x, posfilas[fila]);
 82 		else
 83 			elemento.setPosicion(Mundo.TAMANO_MUNDO_ANCHO, posfilas[fila]);
 84 		
 85 		for (ElementoMobil elem : elementos){
 86 			if (Intersector.overlaps(elem.getRectangulo(), elemento.getRectangulo())){
 87 				return;
 88 			}
 89 		}
 90 		elementos.add(elemento);
 91 
 92 		
 93 	}
 94 	
 95 	public void update(float delta){
 96 		crono-=delta;
 97 		for (ElementoMobil elem : elementos){
 98 			elem.update(delta);
 99 		}
100 		for (ElementoMobil elem : elementos){
101 			if (elem.velocidade<0)	{ // Vai cara a esquerda
102 				if (elem.posicion.x <= -elem.tamano.x){
103 					elementos.removeValue(elem, true);
104 					break;
105 				}
106 			}
107 			else{
108 				if (elem.posicion.x >= Mundo.TAMANO_MUNDO_ANCHO){
109 					elementos.removeValue(elem, true);
110 					break;
111 				}
112 			}
113 		}
114 	}
115 	
116 	public Array<ElementoMobil>getElementos(){
117 		return elementos;
118 	}
119 	
120 	public float getCrono(){
121 		return crono;
122 	}
123 	public void setCrono(float tempo){
124 		crono=tempo;
125 	}
126 
127 	public float getTempoparacrearMax() {
128 		return tempoParaCrearMax;
129 	}
130 
131 	public void setTempoparacrearMax(float tempoparacrear) {
132 		this.tempoParaCrearMax = tempoparacrear;
133 	}
134 
135 	public float getTempoparacrearMin() {
136 		return tempoParaCrearMin;
137 	}
138 
139 	public void setTempoparacrearMin(float tempoparacrearmin) {
140 		this.tempoParaCrearMin = tempoparacrearmin;
141 	}
142 
143 	public int getNumelementos() {
144 		return numElementos;
145 	}
146 
147 	public void setNumelementos(int numelementos) {
148 		this.numElementos = numelementos;
149 	}
150 	
151 }


Expliquemos previamente dita clase:

  • Liñas 3-4: representan cada unha das filas de elementos móbiles. Indican a súa posición e velocidade. Lembrar que todos os elementos móbiles de cada liña teñen a mesma velocidade.
  • Liña 7: array que ten todos os elementos móbiles de todas as filas. Por simplificar, este array vai levar todos os coches (un obxecto desta clase), todas as rochas (outro obxecto desta clase) e todos os troncos (outro obxecto desta clase).
  • Liñas 8-9: esta clase vai crear aleatoriamente os elementos. Cando creamos un novo elemento xeramos un número aleatorio entre estes dous números, que será o tempo que terá que pasar ata instancialo.
  • Liña 11: número máximo de elementos na pantalla. Por exemplo, podemos facer que non haia máis de 20 coches en pantalla (incluídas todas as filas).
  • Liña 13: cronómetro usado para crear novos elementos.
  • Liñas 24-44: método getFila: método que devolve unha fila de forma aleatoria onde se vai crear un novo elemento móbil. Depende do tipo (coche, tronco e rocha) teremos rango de filas diferentes.
  • Liñas 46-93: método engadirElemento: engade un novo elemento. Xa falaremos da clase Intersector no punto de xestión das colisións.
  • Liñas 95-114: método update: actualiza a posición de todos os elementos. Se chegan os limites eliminao do array.


Código da clase Mundo
Obxectivo: Engadimos os elementos móbiles.

 1     private Elementos vehiculos;
 2     private Elementos troncos;
 3     private Elementos rocas;
 4     
 5     public Mundo(){
 6     	alien = new Alien(new Vector2(100,20), new Vector2(15,15),100);
 7     	nave = new Nave(new Vector2(0,480),new Vector2(40,20),60);
 8     	
 9     	vehiculos = new Elementos(1.5f,3f,20);
10     	troncos = new Elementos(2f,5f,6);
11     	rocas = new Elementos(2f,5f,3);
12     }
13 
14 	public Elementos getVehiculos(){
15 		return vehiculos;
16 	}
17 	public Elementos getTroncos(){
18 		return troncos;
19 	}
20 	public Elementos getRocas(){
21 		return rocas;
22 	}
23     ...................


  • Estamos a engadir 20 coches, 6 troncos e 3 rochas. Se fai de forma aleatoria e a medida que se van eliminando do array se van engadindo novos elementos. Isto se fai na clase controladora.

Código da clase ControladorXogo
Obxectivo: Xestionamos os elementos móbiles.

 1 	private void controlarVehiculos(float delta){
 2 
 3 		// Actualizamos posición e elininamos
 4 		Elementos vehiculos = meuMundo.getVehiculos();
 5 		vehiculos.update(delta);
 6 
 7 		// Engadimos os vehiculos
 8 		 if (vehiculos.getCrono()<=0){
 9 		vehiculos.setCrono(MathUtils.random(vehiculos.getTempoparacrearMin(),vehiculos.getTempoparacrearMax()));
10 			if (vehiculos.getElementos().size<vehiculos.getNumelementos()){
11 				int rand = MathUtils.random(1);
12 				ElementoMobil.TIPOS_ELEMENTOS tipo;
13 				if (rand==0)
14 					tipo = TIPOS_ELEMENTOS.AUTOBUS;
15 				else
16 					tipo = TIPOS_ELEMENTOS.COCHE;
17 					
18 				vehiculos.engadirElemento(tipo);
19 				vehiculos.engadirElemento(tipo);
20 			}
21 		}
22 		
23 		// Actualizamos posición e elininamos
24 		Elementos troncos = meuMundo.getTroncos();
25 		troncos.update(delta);
26 
27 		// Engadimos os troncos
28 		if (troncos.getCrono()<=0){
29 			troncos.setCrono(MathUtils.random(troncos.getTempoparacrearMin(),troncos.getTempoparacrearMax()));
30 			if (troncos.getElementos().size<troncos.getNumelementos()){
31 				troncos.engadirElemento(TIPOS_ELEMENTOS.TRONCO);
32 			}
33 		}
34 		
35 		// Actualizamos posición e elininamos
36 		Elementos rocas = meuMundo.getRocas();
37 		rocas.update(delta);
38 
39 		// Engadimos os troncos
40 		if (rocas.getCrono()<=0){
41 			rocas.setCrono(MathUtils.random(rocas.getTempoparacrearMin(),rocas.getTempoparacrearMax()));
42 			if (rocas.getElementos().size<rocas.getNumelementos()){
43 				rocas.engadirElemento(TIPOS_ELEMENTOS.ROCA);
44 			}
45 		}
46 		
47 
48 		
49 	}
50 
51 	public void update(float delta){
52 		
53 		controlarVehiculos(delta);
54 		
55 	}