Capitulo 2: Todo sobre los SPRITES del C64

"Los sprites monocromos, se dice que son de alta resolución, por qué tienen un tamaño de píxel exacto 1:1, posibilitando unos sprites muy definidos (de un color), al contrario que sucede con los multicolores en baja resolución, donde su tamaño horizontal es sacrificado a la mitad en favor de mayor colorido: Son los llamados píxeles ladrillo"

Bienvenidos de nuevo al apasionante mundo de los “duendecillos” que pululan nuestras pantallas, a veces bajo nuestro control, a veces movidos por una misteriosa "inteligencia".

En el anterior capítulo se presentó por encima, de forma general qué y como son, aprendimos que habian Sprites por Software y Sprites por Hardware, vimos también de que otras formas se los denomina en otros sistemas. Todo ello se presentaba de una forma lo más alejada posible de tecnicismos, de cara a poder ofrecer una breve y amena introducción al tema apta para todos los públicos.

 

Pues bien, a partir de ahora, los siguientes capítulos van a ir siendo progresivamente más técnicos (que no más difíciles de entender, si leéis atentamente) y poco a poco vamos a ir desentrañando todos sus misterios, y ya veréis como pronto vais a poder incluirlos en vuestros juegos o aplicaciones. Los conocimientos adquiridos aquí, aunque van a estar centrados en el Commodore 64, son educativamente válidos (a nivel teórico) para hacerse una idea de cómo se programan en otros sistemas, pues todo hay que decirlo, la forma de programarlos tiene algunos puntos en común (a nivel lógico, no técnicamente, quizás) con otros sistemas.

En el capítulo de hoy veremos como se estructuran internamente los sprites, para lo cual aprenderemos como funcionan los números binarios y profundizaremos en las características técnicas de los sprites monocromos en alta resolución, dejando para el siguiente capítulo los sprites multicolores.

Así pues ir preparando vuestro c64/c128 o en su defecto ('¡Sí! por “defecto”) emulador favorito, ¡por que empezamos ya mismo!

Estructura interna de los sprites

Antes de poder usarlos, evidentemente hay que definirlos y esto es lo primero que aprenderemos a hacer. Como se mencionó en el primer capítulo, sabemos que un sprite se define como una sucesión de puntos (pixels) encendidos o apagados según un patrón de datos que determinan su color, reservándose uno de ellos para representar al color del fondo de la pantalla. Dicha matriz, tiene un ancho y un alto (en pixeles) bien definidos.

Pues bien, no es ninguna sorpresa si os digo que esa sucesión de píxeles que definen a los sprites se codifican con números. Sabiendo como funcionan los ordenadores ¿De que otra forma iba a ser si no, verdad?

Codificar mediante un número quiere decir “darle un significado”, asi hay códigos numéricos que expresan si un punto está encendido o apagado, o el brillo de un píxel....

Es un convencionalismo que los ingenieros del hardware han decidido de antemano para que los programadores podamos desarrollar nuestros programas trabajando mano a mano con sus chips (comunicándonos a nivel binario con ellos). Todo en un ordenador, internamente, no es mas que una “conversación” (tediosa para un humano) de “unos” y “ceros” que “viajan” continuamente, a través de las diversas líneas de sus circuitos electrónicos.

De todo esto se deduce que resulta muy útil conocer bien como funciona la aritmética binaria. De momento, de forma gráfica y para que os vayáis haciendo una idea, imaginad que el ordenador solo tiene “dos dedos” –sistema binario- para contar, al contrario que nosotros (que tenemos “diez dedos” –sistema decimal-), por lo que mediante este sistema podremos expresar un número únicamente con dos dígitos : el  1 y el 0 …

(Haz Click aquí mismo, si deseas saber un poco más acerca del sistema binario)

El C64 es un ordenador de 8 bits (técnicamente tiene un bus de datos de 8 bits, y un bus de direcciones de 16 bits), esto quiere decir que básicamente opera con “palabras” de 8 bits, también llamadas Bytes.. Y digo “palabras”, porque cada bit seria como una “letra”. Como un bit (acrónimo de dígito binario) solo puede tener dos estados estamos ante un sistema cuya base es 2, y si elevamos esa base a la cantidad de digitos que queremos expresar en una palabra de 1 Byte (8 bits o digitos): tendriamos 2 elevado a 8 , expresión matemática cuyo resultado es 256. Y este precisamente será el valor máximo que puede representarse mediante un byte (números del 0 al 255)...

Si llegados a este punto, todo esto os resulta complicado, no os preocupéis, incluso sin llegar saber todo esto también podréis trabajar con sprites, gracias a que existen mucho programas (editores de sprites) que nos calcularán todos los datos binarios que los componen, por nosotros, o también podéis utilizar una buena calculadora que convierta números binarios, si os gusta la artesanía pura y dura.

Pero para tener una idea más exacta sobre este tema (y para la programación en general), sí que resulta muy interesante que dominéis todos estos conceptos con soltura…

Una vez entendido como funcionan los números binarios ya estamos perfectamente capacitados para entender como se estructuran internamente los sprites en la memoria del ordenador.

Como ya habiamos mencionado en el anterior capítulo, el encargado de procesar los sprites es el chip gráfico Vic-II. Éste busca continuamente en la memoria los patrones de cada uno de los sprites que debe representar según ciertos datos que los definen además, como por ejemplo su color, si están activados o desactivados… etc.

El Vic-II nos ofrece dos posibilidades importantes a la hora de definir a un sprite: monocromo (alta resolución) o multicolor (baja resolución).

Podemos definir hasta 8 sprites distintos (algunos más, con técnicas avanzadas como la multiplexión), y cada uno podrá ser del tipo que queramos (mono o multi), además pueden ser mostrados en cualquiera de los modos gráficos, sin ningún problema.

Los sprites Monocromos (Alta resolución)

Hoc init exit : La alta resolución puede resultar más colorista de lo que piensan muchos…

Comenzaremos, por su mayor sencillez, para iniciarnos en el tema, con los sprites monocromos. Éstos podrán ser representados con un color, más el color del fondo. Un píxel con el valor 0, adoptará el color del fondo, y un píxel con el valor 1 adoptará el color que hayamos definido para el sprite.

Los sprites monocromos, se dice que son de alta resolución, por qué tienen un tamaño de píxel exacto 1:1, posibilitando unos sprites muy definidos (de un color), al contrario que sucede con los multicolores en baja resolución, donde su tamaño horizontal es sacrificado a la mitad en favor de mayor colorido: Son los llamados píxeles ladrillo.

Las dimensiones que nos ofrece el VIC-II para los sprites monocromos es de 24 píxeles horizontales x 21 píxeles verticales.

¡Entonces ya lo tenemos! Tan solo habria que poner un uno o un cero en el lugar de la memoria que el vic-II espera para representar el sprite que quieramos y todo listo!

Pues... asi es... pero... con una cosa muy importante a tener en cuenta: si pusieramos un byte por cada píxel, cada sprite nos ocuparía en memoria, ¡la friolera de 504 bytes!

Through the Trap Door lucía unos grandes y simpáticos sprites monocromos

Algo que en realidad se reduce a 63 bytes (¡que barbaridad!), ya que los ingeniosos creadores de los geniales chips gráficos ya se dieron cuenta que no habia que desperdiciar nada (algo que hoy en día no se si se tiene en cuenta). ¿Adivinais como lo consiguen esto? ¡Pues claro! Gracias a los números binarios… No obstante, es el sistema que nativamente comprende el ordenador.

En un byte podemos codificar 8 pixels consecutivos de nuestro sprite. Así pues, con 63 bytes habremos codificado toda nuestra parrilla. Y en memoria cada byte estaría almacenado consecutivamente, teniendo en cuenta el siguiente orden:

 

Byte 0	Byte 1	Byte 2
Byte 3	Byte 4	Byte 5
Byte 6	Byte 7	Byte 8
Byte 9	Byte 10	Byte 11
Byte 12	Byte 13	Byte 14
Byte 15	Byte 16	Byte 17
Byte 18	Byte 19	Byte 20
Byte 21	Byte 22	Byte 23
Byte 24	Byte 25	Byte 26
Byte 27	Byte 28	Byte 29
Byte 30	Byte 31	Byte 32
Byte 33	Byte 34	Byte 35
Byte 36	Byte 37	Byte 38
Byte 39	Byte 40	Byte 41
Byte 42	Byte 43	Byte 44
Byte 45	Byte 46	Byte 47
Bytte 48	Byte 49	Byte 50
Byte 51	Byte 52	Byte 53
Byte 54	Byte 55	Byte 56
Byte 57	Byte 58	Byte 59
Byte 60	Byte 61	Byte 62

Tabla 1.0: Estructura interna de los sprites en la memoria.

 

Y ahora que sabéis como se representa un byte en formato binario, es fácil ver que cada byte de esa tabla contiene información para 8 bits (pixels) que se corresponden con la parrilla de un sprite.

Esta organización de los datos es también la misma que se utiliza para los sprites multicolores, salvo que el valor numérico de los bytes se interpretan distintamente y la información de cada píxel ocupa 2 bit (de ahí que la resolución se reduce a la mitad) para poder expresar hasta 4 colores distintos (incluido el color del fondo de la pantalla).

Una muestra de los sprites monstruosamente grandes del Turrican para C64

No es necesario que usemos todos los 24x21 pixeles de un sprite, podemos definir sprites más pequeños, aunque tendremos que poner a 0 los apartados de la parrilla que no fueramos a usar, de lo contrario contendrian datos aleatorios que “mancharian” el dibujo de nuestro sprite.

Para hacer sprites más grandes que el tamaño standard, podremos combinar varios sprites y ponerlos juntos como si de un mosaico se tratara. En capitulos más avanzados, veremos como hacer este tipo de técnicas, incluso usando multiplexión de sprites, para poder hacer un “mosaico” aun más grande de lo normal, con ejemplos prácticos.

Con esta idea de “mosaicos”, a alguien se le ocurrió la idea de superponer sprites para crear un curioso efecto que "parcheara" el efecto pixel ladrillo de los sprites de baja resolución. Y es que, como cada sprite puede dibujarse en cualquiera de las dos resoluciones, podemos usar uno de alta resolución para perfilar el contorno de un otro dibujado en baja resolución simplemente superponiendo el sprite que representa al perfil (en alta resolución) encima del otro en multicolor. Con eso se consigue un bonito efecto que da detalle y colorido a nuestros sprites, aunque eso sí, habremos reducido el número total de sprites disponibles (siempre podremos multiplexarlos, claro).

Imágenes del juego Uwol: Quest for money juntoa  imagenes de prueba para el diseño de su personaje con "Outlined" sprites.

Esta es una técnica conocida como Sprites Overlay (de forma sinónima tambien se les conoce como Outlined sprites), y fue muy utilizada por compañias comerciales de la época, como por ejemplo Ocean o Imagine, entre otras.... 

Robocop también fue otro juego que presentó "sprites Overlay" en su diseño.

Como ejemplos de juegos que usan esta técnica tendriamos a Robocop, el Batman The Movie, el Navy Seals, Street Fighter...
Los sprites Overlay están muy en boga en la escena actual de videojuegos para Commodore 64 y poco a poco se está haciendo muy popular, por lo vistoso que queda. Por ejemplo el reciente juego para c64: Nanako in the CJMC o también el Uwol: Quest for Money del mismo autor; ambos lucen unos magníficos "sprites Overlay" en sus personajes y enemigos.

Muestra de la popularidad que está alcanzando esta técnica es también el hecho de la inclusión de esta característica en la última versión de Sprite pad (la última es la 1.7). Éste es un estupendísimo (y popular) programa para editar sprites para c64 desde PC, que incluso nos permite crear animaciones. Es un programa que os recomiendo usar para hacer vuestros sprites, y ya deberíais de estar bajándolo (si es que no lo tenéis ya) desde la página web de su autor (Subchrist).

Spritepad :

http://www.coder.myby.co.uk/spritepad.htm

Nos vemos en el siguiente capítulo, donde pondremos en práctica todos estos conocimientos y aprenderemos nuevos conceptos sobre este apasionante tema...