Desarrollo en Mega Drive

● Historia de la Mega Drive

● Especificaciones
● Arquitectura
● SGDK
● Configuración e instalación del entorno
● Visual Studio Code
● Genesis Code
● Emulador
● Hola Mundo
● Controles
● Fondos
● Sprites
● Música y Sonido
● Scroll
● Avanzado: Mapas con TILED
Historia de la mega Drive

La Sega Mega drive o Sega

Genesis (En américa) es una
videoconsola con un procesador de
16 bits; fue lanzada en Japón en
1988 y posteriormente en américa
(1989) y europa (1990).
Esta videoconsola, compitió con la
famosa SNES(super nintendo)
vendiendo más de 30 millones de
consolas.
Historia de la mega Drive

Además, de tener un gran catálogo,

tenia varios periféricos como
sensores de movimiento, ratón,
Lector de CD, ampliaciones,etc...
Especificaciones
Arquitectura
Motorola 68000

A la hora de desarrollar para Mega

Drive, se necesitaba antiguamente
conocer las instrucciones para este
procesador.
Kits de Desarrollo

Antiguamente, existían
kits de desarrollo para
mega drive que incluían
también para desarrollo
de Mega-CD.

Solo estaban disponibles

con licencia de SEGA y
eran muy costosos.
SGDK

SGDK (Sega Genesis Development Kit); es un

conjunto de herramientas y librerías que nos va a
permitir desarrollar juegos para Sega Mega Drive
usando el lenguaje C.
SGDK es libre y gratuito, incluye una librería,
herramientas para gestión de recursos y un
compilador gcc para crear las roms. Ha sido
desarrollado entre otros por Estephane
Dallongeville.
https://github.com/Stephane-D/SGDK
Tiene Licencia MIT excepto gcc que tiene
licencia GPL3.
SGDK (Instalación)
WINDOWS

1. Instalar Java JRE (Oracle u OpenJDK).

2. Descargar y descomprimir release:

https://github.com/Stephane-D/SGDK/releases/tag/v1.65

3. Crear la variable de entorno GDK apuntando a donde hemos

descargado el SGDK (Opcional).
SGDK (Instalación)
LINUX

No se puede usar por defecto SGDK en linux pero hay otros proyectos como GenDev.

1. Instalar los siguientes paquetes

a. texinfo
b. java (openjdk).
2. Descargar fichero .deb o comprimido de release:

https://github.com/kubilus1/gendev/releases

3. Si se ha descargado el paquete deb (solo debian), instalarlo.

4. Establecer la variable de entorno GENDEV a la carpeta donde este GENDEV (por

defecto /opt/gendev)
SGDK (Instalación)
MACOS

Puedes consultar las instrucciones para MACOS en la siguiente

dirección:

https://zerasul.github.io/taller-megadrive/sgdk/instalacion/macos/

Sin embargo, esas instrucciones pueden estar deprecadas.

Recomendamos usar Docker.
SGDK (Instalación)
DOCKER

Este método de instalación es válido para cualquier Sistema Operativo con soporte para
contenedores Docker.

1. Descargar y descomprimir SGDK de la página de Release.

https://github.com/Stephane-D/SGDK/releases/tag/v1.65

2. Construir la imagen:

3. Para ejecutar la compilación ejecutar el siguiente comando:

Emuladores

Para poder probar nuestro juego de

forma más rápida, usaremos
emuladores; aunque existen varios,
vamos a mostrar aquí algunos
como:

● Gens
● Fusion
● Blastem
Emuladores
Gens

Gens; o su versión modificada,

Gens Kmod(Solo windows), es un
emulador de Mega Drive que nos
añade una serie de herramientas
para desarrollo.

● Visor de la memoria del VDP

● Visor de Sprites
● Depuración del 68K.
https://zerasul.github.io/taller-megadrive/res/gens2.12kmod.zip
Emuladores
Fusion

Kega Fusión o fusion, es un

emulador que también nos ayudará
a ver nuestros juegos de forma
aproximada al hardware real.

https://segaretro.org/Kega_Fusion
Emuladores
Blastem

Blastem es considerado el
emulador que mejor se aproxima al
hardware.

● Visor de la memoria del VDP

● Depuración del 68K.

https://www.retrodev.com/blastem/
Visual Studio Code
Para ayudarnos a desarrollar, vamos a usar el editor Visual Studio
Code. Este editor, nos va a ayudar a tener nuestro código más
legible y nos ayudará, gracias a una extensión, a utilizar SGDK.
Genesis Code

Genesis code, es una extensión para Visual Studio code, que nos va a
ayudar a crear juegos para Sega mega Drive usando SGDK. Nos va a
permitir de forma muy fácil comenzar a compilar, ejecutar y probar
nuestro juego.

Además, de añadir funcionalidades al editor como autocompletado

para ficheros de recursos, o un visor personalizado de imágenes.
Genesis Code

Para instalar Genesis code, acceder

a la parte de extensiones de Visual
Studio Code, buscarla y pulsar
instalar.
Genesis Code

Por último, puedes ver la

configuración de la extensión
accediendo a la misma
(file->preferences->settings).
En ella podemos configurar
directamente las variables de
entorno a utilizar (GDK,
GENDEV, MARSDEV); además
de configurar el emulador a
utilizar y tipo de toolchain.
Hola Mundo
Una vez configurado nuestro
entorno, vamos a mostrar
como crear un proyecto nuevo.
Para crear un proyecto,
usaremos el comando
“Genesis Code: Create
Project”. Para ejecutar un
comando pulsar ctrl+mayus+p.
Seleccionar la carpeta donde
queremos que se cree el
proyecto.
Hola Mundo
Con el proyecto creado,
veremos 3 carpetas:

● src: para el código

fuente.
● inc: para los ficheros
de cabecera (.h).
● res: para ficheros de
recursos.
Hola Mundo
Una vez creado nuestro proyecto,
usaremos el comando “Genesis Code:
Compile & Run”, para compilar y ejecutar
nuestro proyecto.

NOTA: Debes tener configurado el

emulador para que se ejecute.

NOTA2: Por desgracia, Genesis Code aún

no tiene soporte para docker. Tendrás que
compilar a mano… (Estamos trabajando en
la nueva versión…)

Para compilar manualmente se puede usar

este comando:
Desarrollo de videojuegos para Mega drive

Una vez instalado y configurado nuestro entorno, ya podemos

comenzar a ver cómo se crean los videojuegos para Mega Drive.
Vamos a ver los siguientes puntos:
● Controles
● Fondos
● Sprites
● Música y Sonido
● Tiles
● Maps
Controles

A la hora de crear videojuegos,

tenemos que tener en cuenta
los controles para que el
jugador pueda interactuar.

Mega Drive, tiene por defecto 2

puertos de controlador DIN-9 o
tipo Atari.
Controles
Con SGDK, podemos tener en
cuenta hasta 8 controladores, y
además tener soporte para
ratón.

Además, con SGDK podemos

controlar los mandos de 3 o de
6 botones.
Controles
A la hora de trabajar con
controles, podemos hacerlo de
dos formas:

● Síncrona
● Asíncrona.
Controles Síncronos
Se trata de leer en cada iteración de nuestro bucle, que botones
están pulsados.
Controles asíncronos

Muchas veces para hacer más eficiente la lectura de los controladores, se usa la
forma asíncrona; que se basa en usar Interrupciones hardware, para poder
ejecutar una función al pulsar un botón.
En SGDK podemos usar la función JOY_setEventHandler Para definir una función
a utilizar.

Donde la función, debe tener la siguiente cabecera:

Fondos
A la hora de trabajar con imágenes y gráficos en Mega Drive, tenemos
que tener en cuenta las siguientes características:
● Solo existen 2 planos para dibujar.
● En cada refresco, se pintan 2 planos.
● Cada plano está compuesto por tiles (que tienen tamaño de 8x8
pixels).
● Solo se pueden almacenar 4096 tiles.
● Solo se pueden dibujar 4 paletas de 16 colores cada una.
● En total solo se pueden dibujar 61 colores en pantalla.
● En cada paleta, el primer color es el transparente (excepto el
primer color de la primera paleta que será el fondo).
Fondos

Para trabajar con recursos de nuestro juego, tenemos que definirlo y

posteriormente tratarlo con la herramienta rescomp que viene incluida
en el SGDK.
rescomp, lee ficheros con extensión .res con la información del
recurso a tratar (imágenes de fondo, sprites, música, mapas…).

https://raw.githubusercontent.com/Stephane-D/SGDK/master/bin/rescomp.txt
Fondos
Para utilizar ficheros de imagen
en SGDK, necesitaremos que
estén en formato indexado (no
RGB) con una paleta de colores
de 16 colores; en formato bmp.
png y jpeg.

Existen varios programas para

ayudarnos; como puede ser
GIMP, aserprite,etc...
Fondos

Una vez incluida y rellenado el

fichero .res, compilamos
nuestro proyecto (en genesis
code “Genesis Code: compile
project”) y nos generará un
fichero .h con la información
para incluir en nuestro código
fuente.
Fondos

Para dibujar uno de los fondos con una imagen, usaremos la función
“VDP_drawImageEx“; la cual tiene los siguientes parámetros:
● Plano a dibujar (BG_A o BG_B)
● dirección de la imagen a dibujar (usaremos el nombre de nuestro recurso).
Recuerda incluir el fichero .h generado.
● tile base: Índice del tile a usar en VRAM. Se utilizará para ello, la macro
TILE_ATTR_FULL.
● Posición X.
● Posición Y.
● Cargar paleta. TRUE para cargar paleta o FALSE para lo contrario.
● DMA. Usar CPU o DMA para indicar si se cargará desde CPU o usando el
DMA (Direct Memory Access).
Fondos
TILE_ATTR_FULL; esta macro nos permitirá definir el tile base del
que dibujar. Este tile estará cargado en la VRAM del VDP. Su
parámetros son:
● Paleta: paleta a utilizar (PAL0,PAL1,PAL2 o PAL3).
● Prioridad; indica si el plano se dibuja con prioridad o no.
● flipH: volteo horizontal.
● flipV: volteo vertical.
● indice: índice a utilizar. Normalmente se calcula a partir de
TILE_USERINDEX.
Fondos
Hemos visto que se puede dibujar
los fondos con o sin prioridad; esto
nos permitirá dar sensación de
profundidad.

NOTA: Existe un plano especial

llamado Window que se utiliza para
dibujar normalmente la interfaz de
usuario. Suele sobrescribir en el
plano A.
Sprites

Un sprite, es un mapa de bits que normalmente es manejado por

hardware específico sin necesidad de intervenir la CPU. Normalmente
asociado a un objeto del juego.
Sprites
Para usar Sprites en Mega Drive, necesitamos tener en cuenta las
siguientes restricciones:
● Los Sprites tienen su propio plano
● La posición en pantalla va en pixels no en Tiles.
● Podemos tener en total 80 sprites por pantalla
● Solo se pueden tener 20 sprites por línea horizontal
● La manera de cargar un sprites es igual que los planos (en
pixeles).
● Un Sprite debe ser divisible por 8 para poder cargarlo.
● El tamaño “máximo” de un sprite en SGDK es de 16x6 tiles (128 x
128 píxeles) aunque ya se permiten de más tamaño, haciendo
composiciones.
Sprites
Como cualquier recurso de nuestro juego, tenemos que añadirlo
usando un fichero .res:

● SPRITE: Tipo de recursos

● nombre_variable: para referenciar
● ruta del recurso: relativa a la carpeta res.
● Ancho de cada Frame en tiles
● Alto de cada Frame en tiles
● Tipo de Compresión
● Tipo de caja de colisión (Aún no tiene uso es para futura
implementación).
Sprites
Tras definir el recurso, compilaremos para generar nuestro fichero .h que
podremos añadir.
Además en nuestro código debemos hacer los siguientes pasos:
1. Inicializar el motor de sprites:

2. Añadir el sprite y asignar su paleta.

3. Actualizar el sprite en cada frame.

Sprites
La función SPR_addSprite, tiene los siguientes parámetros:

● dirección de memoria del sprite.

● posición x en pixeles.
● posición y en pixeles.
● Tile Base: Se define usando la macro TILE_ATTR.

La Macro TILE_ATTR tiene los siguientes parámetros:

● Paleta a utilizar.
● Flag de prioridad.
● Flag de Volteado Horizontal.
● Flag de Volteado Vertical.
Sprites
Una parte importante a la hora de trabajar con sprites, es definir
cuándo se va a utilizar una animación.

La imagen anterior es una “hoja de Sprite” o SpriteSheet que define

las animaciones y frames de un sprite. Cada fila corresponde a una
animación y cada columna a un frame. Por lo que la imagen anterior,
corresponde a 4 animaciones de 3 frames cada una.
Sprites

Se puede usar la función SPR_setAnim(sprite, nº animación) para

definir qué animación utilizar.

Cada animación es una fila comenzando por la fila 0

Sprites
Los Sprites tienen su propio plano y pueden ser dibujados con o sin
prioridad. Podemos usar la función
SPR_setPriorityAttribut(sprite,TRUE|FALSE), para definir la prioridad.
Matemáticas y física en SGDK

EL procesador motorola 68K, no tiene soporte para coma flotante; por

lo tanto no podemos usar decimales como normalmente lo haríamos.
Por ello SGDK, define dos tipos para trabajar con decimales.
Matemáticas y física en SGDK
Además trae una serie de funciones que para ayudarnos:

https://zerasul.github.io/taller-megadrive/devretro/sprites/#matematicas-y-fisica-en-sgdk
Música y Sonido
Una parte importante de nuestro juego, será la música y sonido;
gracias a la Mega Drive, podemos hacerlo usando los chips que trae:

● Yamaha YM212 de 6 canales estéreo (FM).

● Texas Intrument PSG TI6489 con sonido 8 bits.

Estos dos chips son orquestados por el procesador Z80.

NOTA: el procesador z80 en modo Master System no tendrá acceso

al chip FM.
Música y Sonido

Para trabajar con la música en el YM2612 o el PSG, necesitaremos un

programa para poder definirla normalmente en formato vgm(XGM); estos
programas llamados “trackers” nos van a permitir crear la música.
Música y Sonido

Como cualquier recurso, tenemos que crear un fichero .res; tanto para
ficheros en formato XGM o WAV como sonido.

● XGM: Tipo de recurso para música.

● nombre de la variable.
● ruta del fichero vgm
● Timing: AUTO, PAL o NTSC.
Música y Sonido

Para definir un fichero de sonido:

● WAV: Tipo de recurso para sonido.

● nombre de la variable.
● ruta del fichero vgm
● Driver: PCM, A2ADPCM, 4PCM, XGM
Una vez añadidos los recursos, compilamos para generar el fichero .h.
Música y sonido
Para ejecutar la música usaremos la función SND_startPlay_XGM.

Donde:

● music: nombre de la variable del recurso.

Para ejecutar sonido, tenemos que hacerlo en dos pasos:

1. Ejecutar la función SND_setPCM_XGM; con los siguientes parámetros:

● identificador: Número identificando el recurso.
● Variable: variable de nuestro recurso.
● Tamaño: normalmente se usa sizeof(variable).
2. Ejecutar la función SND_startPlayPCM_XGM con los siguientes parámetros:
● ID: Identificador del recurso(debe coincidir con el de la anterior función).
● N: Nº de veces a ejecutar.
● Canal: Canal de sonido a ejecutar. Por ejemplo SOUND_PCM_CH2.
Scroll

En algunas ocasiones, nuestros fondos, van a ser mayores que la

parte visible de pantalla.
Por ello, necesitaremos poder mostrar partes de las imágenes; para
poder mostrar solo la parte actual.
Scroll
SGDK, permite hacer Scroll tanto vertical como horizontalmente; por
lo que se pueden extender los planos tanto como se necesiten;
cargando previamente en la memoria de vídeo. Normalmente se
suelen seguir los siguientes pasos:

1. Cargar toda la imagen visible

2. Conforme se avanza en una dirección hacer scroll.
3. En la parte no visible, se cargan los tiles que se necesiten por
filas o columnas.
Scroll

Para poder usar el scroll, necesitaremos usar varias funciones.

1.- Dibujar la imagen visible usando VDP_drawImageEx.

2.- Establecer el modo de Scroll, vertical y horizontal por plano (o línea). con la función VDP_setScrollingMode.

3. En cada iteración, cuando se quiera mover el scroll, usar la función VDP_setHorizontalScroll junto al plano y
el offset; que está en pixeles (Positivo izquierda, negativo, derecha).

4. Conforme se va avanzando, se pueden ir generando tiles en la parte no visible; dando la sensación de infinito.
Tilesets

Hemos visto que usando Scroll, podemos tener imágenes más

grandes que los propios fondos; sin embargo, estas imágenes pueden
ocupar mucho espacio en ROM. Por lo que se podrían generar
dinámicamente usando Tileset.

Un Tileset es un conjunto de mapa de bits que nos van a permitir

generar de forma dinámica imágenes mayores a partir de
combinación de estas imágenes.
Tilesets

En la imagen contigua, puede

verse un Tileset que puede
usarse para generar Mapas a
partir de los elementos del
mismo.
Existen muchas herramientas
para poder dibujar estos
mapas; nosotros usaremos
TILED.
Tilesets

TILED es una
herramienta de código
abierto y multiplataforma
bajo licencia GPL que nos
va a permitir tanto
generar mapas, como
poder gestionar los
tilesets.

https://www.mapeditor.org/
Tilesets
Con TILED, generamos cada uno de los mapas de distintos niveles
(podemos generar distintas capas para después dibujarlas en distintos
planos).
Posteriormente lo podemos guardar en formato TMX o Json, e
importarlo en nuestro proyecto usando Genesis Code.
Tilesets
Para comprender cómo funciona,
Generamos un mapa y copiaremos
las coordenadas del mapa a mano.

Una vez dibujado nuestro mapa,

vamos a abrir el fichero TMX con un
editor de texto.

Allí veremos una serie de números

dentro de la etiqueta <data>.

NOTA: Guardar el mapa con formato

csv y cada tile debe ocupar 8x8
pixeles.
Tileset
Para importarlo y usarlo en nuestro juego, realizaremos los siguientes pasos:

1. Copiar las coordenadas y guardarlo en un fichero map.h en nuestro directorio

inc.

2. Incluir el fichero map.h. Añadir el tileset como recurso a nuestro juego usando
un fichero .res.

3. Cargar el tileset y paleta.

4. Recorrer la pantalla e ir dibujando cada Tile.

Referencias

● Mega Drive
● Sega Retro: Technical Information
● SGDK
● Gens
● Blastem
● Kega Fusion
● Visual Studio Code
● Genesis Code
● Open Game Art
● Deflemask
● TILED