Después de ver la clase ActorJugador, es evidentemente que nos queda por explicar el funcionamiento del método act(). Lo que voy a hacer es instanciar,
o crear una nueva clase, de un nuevo tipo de actor, en este caso ActorPinchos, para representar mis pinchos, que no es muy complicado de hacer,
es exactamente igual. Sólo que en este caso, como recordáis cuando os introduje Pinchos, esta es la textura que utilicé para meter como excusa
el hablar de los TextureRegions, así que ActorPinchos va a necesitar que le pasemos, no una textura como parámetro, sino una TextureRegion,
para que sepa dónde están los límites de la textura que debe usar para dibujar. Aquí es lo mismo: hago el constructor y le paso como parámetro estos pinchos.
Y al igual que antes, le digo batch.draw(pinchos, getX(), getY()). En este caso, instanciarlo es igual de sencillo. Primero hago una textura de pinchos.
pinchos = new Texture(“pinchos.png”). En este caso tengo, no sólo que ocuparme de la textura, sino de la región. TextureRegion regionPinchos.
Empezáis a entender por qué un AssetManager hace más claro porque mirad cómo está quedando esto. RegionPincho será una nueva región,
y si no recuerdo mal los números deberían ser 0, 64, 128, 64. De memoria. Ahora lo que hago es instanciar mi ActorPinchos, al que le paso la región,
y con esto ya lo tengo cargado. stage.addActor(pinchos), y lo voy a colocar en la posición (400, 100). Realmente lo que quiero es explicaros cómo funciona
el método act, así que con que aparezca en la parte derecha me conformo. A ver donde aparece, porque francamente no lo sé. Bien. Muy inteligente por mi parte
olvidar llamar a la variable correcta, pero lo importante es que aparecerá en la parte derecha de la pantalla. ¿A dónde quiero llegar con esto?
Me interesa que los pinchos avancen hacia la izquierda hasta golpear al jugador. Para ello voy a utilizar el método act para que mi pincho tenga un movimiento
constante hacia la izquierda. Para ello es necesario utilizar la variable delta. ¿Por qué? Porque alguno dirá, “yo aquí digo en act,
que quiero moverlo a la izquierda, y es sencillo. Miro donde están mis pinchos, y le reajusto en X - 10 píxeles”. Esto es un error. No hagáis esto. Primero,
esto se hará 60 veces por segundo así que irá muy rápido. Demasiado rápido para mi gusto. En segundo lugar, porque si nuestro juego empieza a fluctuar,
imaginemos que el móvil empieza a hacer cosas de fondo u ocurre cualquier problema, como va a bajar la velocidad a la que se llama a act, porque baja el número
de veces que se puede llamar por segundo, va a acelerar, a frenar y crear un efecto desagradable. En su lugar lo que se hace es un efecto de movimiento
de velocidad uniforme, aprovechando que tenemos el parámetro delta. Para ello tengo Skitch abierto porque os quiero enseñar qué quiero conseguir.
Parto de la siguiente base. Tengo una pantalla, que asumo este rectángulo blanco por simplificar las cosas, que ocupa 640 de ancho más o menos.
Tengo aquí mis pinchos y tengo aquí mi personaje. Vamos a suponer que el personaje tiene hacia la derecha una distancia de 600 píxeles,
aunque me parece un poco excesivo, así que lo que vamos a hacer es reducirlo a 500. Los pinchos avanzan 500 píxeles a la izquierda y golpean al jugador.
Lo que quiero es darle al jugador un tiempo de 2 segundos. No quiero ponerlo muy difícil pero no quiero hacerlo lo más fácil del mundo.
La intención es que la clase pinchos recorra en dos segundos una distancia de 500 píxeles. Si hacemos el cálculo, y esto es una regla de 3,
mi objetito tiene que desplazarse una velocidad de -250 píxeles en la dirección X; es decir, cada segundo su posición X debe decrementarse en 250 píxeles.
El único problema es que no sabemos cuándo pasará un segundo, sólo que cada 0.01 o 0.02 segundos se va a invocar al método act, y se le va a decir cuántos
segundos han pasado desde la última vez que se llamó a act, siendo un valor muy pequeño y decimal. Así que lo último que hay que hacer es dividir esto
en paquetes pequeños y formar una regla de 3: si en un 1 avanzas 250 píxeles, en 0.01 segundos avanzas X. Si hago la cuenta, lo que tengo que hacer es calcular
la velocidad de forma lineal multiplicando delta por la velocidad en píxeles por segundo. Por ejemplo para hacer que un personaje de estos avance a una
velocidad de -250 px/seg, tengo que multiplicar -250 por delta, para determinar cuánto se tiene que desplazar en este paquetito de un par de milisegundos que
nos ha sido concedido. Por ejemplo, setX(getX() - 250 * delta). De este modo si ahora ha pasado 0.01 segundos se desplazará 2.5 píxeles,
si he hecho bien las cuentas. Si el juego va más lento y tarda 40 milisegundos… multiplicadlo, pero seguirá quedando un valor muy pequeño.
A través de estos incrementos obtenemos un desplazamiento más seguro. Si ahora lo coloco en la posición 500 tendré 2 segundos de tiempo hasta que desaparezca
por la parte izquierda de la pantalla. Tal que así. De hecho incluso me he pasado porque va muy lento. Lo importante es, que como veis
tenemos un problema un poco grave, porque si repito la animación, el personaje no se inmuta por la existencia de los pinchos.
Necesitamos introducir colisiones para que detecte que ha habido una colisión.
