Manual · 5

Editor de gráficos

El editor de gráficos dibuja con las piezas propias del TIA: dos jugadores, dos misiles, una bola y el playfield. Lo que ves es lo que mostrará el kernel, y al guardar se escriben las tablas que incluye tu programa.

Crea un archivo de gráficos con Archivo → Gráficos nuevos... Un archivo .vcsgfx es JSON cuyas filas se escriben con X y ., así que se lee como un dibujo y se compara bien en el control de versiones. Un archivo puede contener varios sprites y playfields.

Sprites en capas

Un sprite se compone de capas, y cada capa es uno de los objetos móviles del TIA: P0, P1, M0, M1 o BL. Cada capa tiene:

• su posición, en relojes de color en horizontal y en filas en vertical;
• su anchura: NUSIZ en los jugadores, y 1, 2, 4 u 8 en los misiles y la bola;
• su reflejo (REFP);
• un color para cada fila y fotograma.

Un personaje multicolor puede ser P0 y P1 superpuestos, con un misil como espada. En el lienzo, el botón izquierdo dibuja, el derecho borra, y Alt+clic sobre un color lo aplica a todos los fotogramas.

Cada herramienta de dibujo tiene su tecla: lápiz (P), línea (L), rectángulo (R, relleno con Shift+R), elipse (E, rellena con Shift+E) y rellenar (F). Shift y arrastrar con el lápiz mueve la capa entera. El lienzo puede mostrar el sprite sobre el color de fondo que elijas; es solo para dibujar, porque el programa pone su propio COLUBK.

Fases de parpadeo

Cada capa tiene una fase, de 1 a 4. Las capas de la misma fase se dibujan en los mismos fotogramas de vídeo, y las fases se turnan. Así un juego muestra más objetos de los que tiene el TIA: un objeto puede reutilizarse en otra fase, pero nunca dos veces en la misma. La vista previa alterna las fases al ritmo del televisor, o las muestra todas a la vez.

Dibujado como el TIA

El lienzo y la vista previa siguen el hardware:

• prioridades: P0 y M0 sobre P1 y M1, y estos sobre la bola y el playfield;
• cada misil toma el color de su jugador en esa línea;
• proporciones cercanas a las de un televisor, donde un ciclo de color es más ancho que una línea de alto;
• paletas NTSC y PAL calculadas a partir de los tonos y luminancias de cada norma, y los ocho colores fijos de SECAM. Se acercan, pero el emulador muestra los exactos.

Playfields

Un playfield tiene 40 columnas, y cada fila tiene lo suyo:

• modo: reflejado o repetido, el bit 0 de CTRLPF;
• colores de playfield y de fondo;
• mitad derecha, si la dibujas: una fila asimétrica, en la que el programa reescribe los registros a mitad de línea.

Así un playfield puede cambiar de modo, de color o de dibujo a mitad de pantalla y a mitad de línea. Pulsa M o R sobre una fila para reflejado o repetido, y A para hacerla asimétrica.

Perfiles de kernel

Un kernel es el código que dibuja la pantalla, y cada uno puede mostrar cosas distintas. Cada archivo de gráficos sabe qué kernel lo dibujará: uno tuyo en ensamblador o C, que puede usar todo el TIA, o uno de batari Basic. Por defecto es el del proyecto: el tuyo en ensamblador y C, y en batari Basic el que fija el programa principal con set kernel, junto con su set kernel_options y const pfres. Un archivo puede elegir otro.

El editor sigue al kernel. No ofrece los jugadores que el kernel no tiene (el motivo aparece al pasar el ratón), oculta los colores de fila que no puede cambiar, raya las columnas del playfield que no muestra y refleja las filas en multisprite.

Avisos

Bajo la vista previa, el editor avisa de lo que saldrá mal con este kernel:

• un objeto usado dos veces en una fase, o uno que el kernel no dibuja;
• el parpadeo, y a qué ritmo se muestra cada fase;
• jugadores extra que comparten líneas, que el kernel alternará;
• el color que los misiles y la bola comparten con otros objetos;
• en tu propio kernel, cuántas escrituras en registros necesitará cada línea y cuánto tiempo dejan las filas asimétricas;
• lo que un kernel de batari Basic no mostrará: columnas, la forma de misiles y bola, colores de fila sin la opción que los activa, el número de filas.

Animaciones

Un sprite tiene fotogramas y animaciones con nombre. Una animación es una lista de pasos, y cada paso muestra un fotograma durante un número de fotogramas de vídeo. Se repite o se detiene en su último paso. El mismo fotograma puede aparecer en varios pasos, con duraciones distintas (andar: 0-1-2-1). Al insertar, borrar o mover fotogramas, los pasos los siguen. La vista previa reproduce la animación que elijas.

Qué escribe al guardar

Al guardar el .vcsgfx se escribe junto a él un archivo en el lenguaje del proyecto, de modo que el programa siempre tiene el dibujo actual.

En ensamblador, la barra de herramientas elige cómo se reparten las tablas: todas en <nombre>.gfx.asm, un archivo por sprite y playfield (<nombre>.<elemento>.gfx.asm) o uno por grupo (<nombre>.<grupo>.gfx.asm), y a cada elemento se le puede dar un grupo. Los archivos que escribió una elección anterior se borran.

Ensamblador: <nombre>.gfx.asm

Tablas con etiqueta (<sprite>_<objeto>_Frame<n>, _Colour<n>), posiciones y tamaños como constantes, y los playfields como una tabla por registro (con PF0R, PF1R y PF2R para las mitades derechas, y tablas de CTRLPF y de colores si cambian). Las filas van de abajo arriba, como las leen casi todos los kernels. Las animaciones dan tablas de punteros a cada fotograma (_FramePtrLo/Hi, _ColourPtrLo/Hi) y, para cada animación, el fotograma y la duración de cada paso:

hero_walk_STEPS = 4
hero_walk_LOOP = 1
hero_walk_FRAME
        .byte 1,0,2,0
hero_walk_TICKS
        .byte 7,7,7,7

El programa lleva un contador y un número de paso, y de ahí lee el fotograma.

C para ELF: <nombre>.gfx.h

Arrays const uint8_t por capa y fotograma, de arriba abajo (como dibuja las líneas un bucle en C), con #define para la posición, el alto, la fase, NUSIZ y REFP. Cada animación es un array de pasos {fotograma, duración}, que se reproducen con dos funciones pequeñas:

#include "hero.gfx.h"

static vcsgfx_player hero;

void overblank(void) {
    vcsgfx_play(&hero, moving ? &hero_walk : &hero_idle);
    hero_frame = vcsgfx_animate(&hero);   // once per video frame
}

batari Basic: bloques dentro del programa

batari Basic incluye ensamblador, pero no código suyo, así que los bloques tienen que estar dentro del .bas. VCSIDE los mantiene ahí. Mira los gráficos en un programa de batari Basic.

Copiar e importar

Copiar como... deja en el portapapeles el sprite o playfield seleccionado como tablas de DASM, arrays de C o bloques de batari Basic para su kernel (player0: a player16:, playerNcolor:, playfield: de 32 o 16 columnas, pfcolors:, bkcolors:, los colores fijos como asignaciones, y DFnFRACINC para DPC+ y PXE).

Importar lee del portapapeles:

• las tablas del propio VCSIDE;
• las tablas en ensamblador de PlayerPal, con el color de cada fila en el comentario;
• bloques de batari Basic, en el orden de filas de su kernel;
• playfields del Tiny VCS Playfield Editor de masswerk, con su modo y el alto de línea.

Así los gráficos pueden ir y venir entre VCSIDE y esas herramientas.

Los ejemplos

Proyecto nuevo → Empezar con → Ejemplo: un sprite animado da un personaje dibujado en hero.vcsgfx con dos animaciones, idle y walk. El joystick lo mueve, y se vuelve hacia donde anda.

• En ensamblador, un kernel de dos líneas lee el fotograma a través de las tablas de punteros y avanza la animación durante el borrado vertical.
• En C, el kernel coloca al jugador con RESP0 y HMOVE en su posición exacta, de 0 a 159, y escribe GRP0 y COLUP0 en cada línea.