LIBGDX tarefa 2 6 Alternativa
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 }