Crea tus Juegos con 8BP

8BP: Rutas de sprites con lógicas masivas

3.9
(7)

Hola amigos de 8 Bits de Poder. En el artículo de hoy veremos como trabajar con rutas de sprites con lógicas masivas, permitiendo de este modo que nuestro juego para Amstrad CPC tenga gran cantidad de sprites en movimiento simultáneamente. ¡Vamos a ello!

Para mover sprites a través de trayectorias existe un comando llamado |ROUTEALL que lo hace muy eficientemente, pero como ejercicio para comprender la filosofía de lógicas masivas es muy interesante estudiar este difícil pero emblemático caso de lógicas masivas. Para programar el videojuego “Anunnaki” empleé la técnica que voy a describir a continuación, ya que aun no había programado la capacidad de enrutamiento de sprites en 8BP. Básicamente empleé lógicas masivas en el enrutamiento de las naves enemigas.

rutas avanzadas

Pero espera… ¿Es posible que no sepas nada de 8 Bits de Poder? Puedes leer el primer artículo del curso de programación en Amstrad CPC de 8BP.

Rutas de sprites con lógicas masivas en 8BP

Comencemos imaginando una trayectoria para una hilera de 8 naves enemigas. las naves pasan una a una por una serie de «nodos de control», que son lugares en el espacio donde deben cambiar su dirección, definida por sus velocidades en X, e Y, es decir (Vx,Vy)

Una forma de controlar que las 8 naves cambien de dirección en dichos lugares sería comparar sus coordenadas X,Y con la de cada uno de los nodos de control y si coinciden con alguno de ellos, entonces aplicamos las velocidades nuevas asociadas al cambio en ese nodo. Puesto que hablamos de 2 coordenadas, 8 naves y 4 nodos, estamos ante:

2 x 8 x 4 = 64 comprobaciones en cada fotograma

Esto no es viable si queremos velocidad desde BASIC, pues no es una estrategia computacionalmente eficiente. Puesto que estamos ante un escenario «determinista«, podemos estar seguros en cada instante de tiempo donde van a encontrarse cada una de las naves y por lo tanto en lugar de hacer comprobaciones en el espacio, podemos únicamente centrarnos en la coordenada temporal (que es el número de fotograma del juego o el también llamado número de «ciclo de juego»). No consideres al tiempo en segundos, sino en fotogramas.

rutas de sprites
Trayectoria definida con nodos de control

Puesto que conocemos a la velocidad a la que se mueven las naves, podemos saber cuando la primera de ellas pasará por el primer nodo. A ese instante lo llamaremos t(1). También asumiremos que debido a la separación entre las naves, la segunda de las naves pasará por el nodo en el instante t(1)+10. La tercera en t(1)+20 y la octava en t(1)+70. En lugar de usar fotogramas como unidades de tiempo, usemos decenas de fotogramas: en ese caso los instantes serán t(1), (1)+1, t(1)+2 , etc.


Sabiendo esto podemos controlar el tiempo con dos variables: una contará las decenas (i) y otra las unidades (j). Para controlar el cambio de las 8 naves en el primer nodo podemos escribir:

j=j+1: IF j=10 THEN j=0: i=i+1: IF i>=t(1) AND i<t(1) +8 THEN [actualiza velocidad de nave  i-t(1) con los valores de velocidad del nodo 1]

Como vemos con una sola línea podemos ir cambiando las velocidades de cada nave a medida que van pasando cada una de ellas por el nodo 1. Cada vez que “j” se hace cero, incrementamos la variable “i” y actualizamos una de las naves. Durante los primeros 80 instantes de tiempo (8 en decenas de fotogramas) se van actualizando cada una de las 8 naves, justo cuando pasan por el nodo de control, es decir, en el instante t(1) se actualiza el Sprite 0, en el (t1)+1 se actualiza el Sprite 1, en el t(1)+2 se actualiza el Sprite 2, etc.

El Sprite number que aparece en la línea es i-t(1) , de ese modo si t(1) 1ueremos que sea el fotograma 40, ( t1=4) entonces cuando “i” sea 4 se empezara a actualizar el Sprite 0, y cuando “i” valga 11 se actualizará el Sprite 7 (8 naves en total).


Ahora vamos a aplicar lo mismo a los 4 nodos. Podríamos ejecutar 4 comprobaciones en lugar de una, pero sería ineficiente. Además, si tuviésemos muchos nodos esto supondría muchas comprobaciones. Podemos hacerlo solo con una, teniendo en cuenta que la primera nave pasa por un nodo en un instante t(n) y la octava nave pasa por ese nodo en t(n)+7

Cuando la primera nave pasa por el primer nodo, tiene sentido pensar en empezar a comprobar el nodo 2, pero no el nodo 3 ni el 4. Ya tenemos el nodo mayor que vamos a controlar.

En cuanto al nodo menor, podemos asumir que, aunque tengamos 20 nodos, estén lo suficientemente separados como para que no haya naves atravesando más de 3 nodos a la vez (vamos a suponer eso y usaremos ese «3» como parámetro). Por lo tanto, el nodo menor a comprobar es el mayor – 3. Al nodo menor lo vamos a llamar «nmin» y al mayor «nmax».  ( nmin = nmax-3 ). El caso que queramos tener plena libertad para poder definir cualquier trayectoria, nmin debe ser nmax menos el número de naves de la hilera.

10 j=j+1: IF j=10 THEN j=0: i=i+1: n=nmax
20 IF n<nmin THEN 50:' no hay que actualizar mas naves
30 IF i>=t(n) AND i<t(n)+8 THEN [actualiza nave i-t(n) con velocidades de nodo n]:IF i-t(n)=0 THEN nmax=nmax+1: nmin=nmax-3
40 n=n-1

50 ' mas instrucciones del juego

Como ves, cuando se incrementa en 1 la decena de tiempo (variable “i”), se empieza a comprobar si hay alguna nave en uno de los nodos desde «nmax» hasta «nmin», actualizando una sola nave en cada fotograma. Si la nave que se actualiza es la cero, entonces el nodo máximo se incrementa, pues esa nave va camino del siguiente nodo.

Para el siguiente fotograma se decrementa el numero de nodo ( instrucción n = n-1 ) de modo que lo que comprobaremos será si hay una nave en el nodo anterior, asi sucesivamente hasta nmin. Siempre, eso si, comprobando una única nave en cada fotograma.


En resumen, hemos transformado 64 comprobaciones en solo 1, usando «Lógicas masivas». Y si la trayectoria tuviese 40 en lugar de 4 nodos, ¡habríamos transformado 640 operaciones en una sola!

El videojuego “annunaki” utiliza esta técnica para manejar las trayectorias de dos hileras simétricas de 6 naves cada una. Es complicado pero como ves desde BASIC puedes tomar el control de 12 naves y hacerlas moverse siguiendo caprichosas trayectorias, usando más inteligencia que potencia, gracias a la técnica de lógicas masivas.

8BP: Rutas de sprites con lógicas masivas 2
Dos hileras con lógicas masivas

La próxima semana veremos cómo trabajar con trayectorias en 8BP complejas con el comando ROUTEALL.

Hasta aquí hemos llegado por hoy con el curso de programación en Amstrad CPC de 8 bits de poder Si tienes alguna duda puedes escribir en comentarios y te contestaré lo antes posible.

Todos los recursos, como manuales, ejemplos y juegos compilados de este curso los puedes encontrar en el repositorio Github de 8BP.

Hasta la semana que viene amigos 😄

¿Te ha Resultado útil este artículo?

Ayúdanos a mejorar y danos tu opinión:

Mostrar más

2 comentarios

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Publicaciones relacionadas

Botón volver arriba