Tutorial programacion Megadrive - Basico

Como indica el titulo, este es un tutorial básico de programación para Megadrive. Es un tutorial solo apto para novatos, ya que los contenidos serán muy simples. Ademas, quiero ser practico, aquí no dare un tutorial de “hola mundo”, si no, que ire directo a lo divertido los “sprites”

Ante todo gracias a Mairtrus por toda la ayuda prestada

Ire agregando nuevo contenido si veo que genera interes.

Ademas, realmente no lo se, pero supongo que no tengo mucho nivel como programador, así que espero muchas correcciones por parte de los lectores!


Para este tutorial escogí el lenguaje BASIC, por su simpleza, y porque existe un compilador muy bueno para Megadrive llamado Basiegaxorz

http://devster.monkeeh.com/sega/basiegaxorz/

Descargen e instalen la versión “Newest and Latest - BasiEgaXorz v1.37 Using the ASMX Assembler”

Nota muy importante, basiegaxor trae una ayuda brutal, y muchos ejemplos, USENLOS!!!!!!

Una característica muy buena del Basiegaxorz, es que se puede incluir codigo ASM, por lo que en realidad se convierte en una herramienta muy potente incluso para programadores avanzados, pero claro, asm escapa a este tutorial, si alguien le interesa se ASM bastante bien...creo

Asumo que ya al menos han leido algun tutorial de basic basico , por si no es el caso, echenle un vistazo el tutorial de Basic generico del link de abajo. Al menos necesitan saber lo que es un “for” “if” “end if” …etc etc

http://cfievalladolid2.net/tecno/cyr_01/control/lengua_BASIC/index.htm


Dicho esto, es recomendable que lean el tutorial que hice de trabajo con tiles, aquí mismo en EOL
http://www.elotrolado.net/hilo_trabajo-tiles-megadrive_1349365



TUTORIAL 1: MANEJO DE TILES Y SPRITES


Si leyeron mi tutorial de Trabajo tiles en megadrive, sabran que tiene 64k de video, muestra 64 colores en pantalla, en 4 paletas de 15 colores cada una, y normalmente se usa la resolución de 320x224 (entre otras)


También ya sabrán (no lo sabes? Es porque no leistes mi post de tiles!! ) que un tile es un cuadrado de 8x8 pixeles, y que la megadrive tiene memoria para almacenar 1344 tiles simultaneos (43008 bytes de VRAM), pero los primeros 256 estan reservados para texto, lo que deja 1088 tiles utiles.

Si usamos como resolucion 320x224, tendremos que hacer esta cuenta

1 tile: 8x8=64 pixeles
Pantalla: 320*224=71680/64= 1120

O sea se necesitan 1120 tiles para llenar la pantalla completa.En teoria no cabria una pantalla completa en la memoria, pero si pasamos de usar texto, podemos utilizar los 256 tiles reservados, lo que nos daría suficiente para llenar una pantalla, y además nos sobrarían 224 tiles para usarlos sabiamente….


Como dije, el “tile” es la unidad mas pequeña en la que se puede trabajar.Asi que todo estara generado por tiles.O sea la pantalla de la megadrive, no tiene 320x224 pixeles, si no 40x28 tiles

Vamos como primer intento de programación a poner un sprite, y un simple fondo. Bajen el siguiente pack con todo listo para usar

http://theelf-megadev.com/Ejemplos/sonic_ejemplo.zip

Lo primero necesitamos un buen programa para editar graficos, aconsejo el Paint Shop pro, ya que tiene un manejo de paletas increíble. En linux, se puede usar con wine.

Y lo mas importante, un programa para transformar gráficos en tiles, y ese es el imagenesis

http://devster.monkeeh.com/sega/imagenesis/

NOTA: X es la resolución horizontal, Y es la vertical

Imagenesis es simple de usar FILE->OPEN abrimos una imagen BMP a 16 colores, en Mode, tenemos dos opciones

En dirección X luego a Y, se usa para fondos por ejemplo
En dirección Y luego a X, se usa para Sprites

Abrimos la imagen fondo.bmp ,seleccionamos 15 colores,4bpp,1plane,8x8 tile, y le damos a ACTIONS->Quantize now



Fijarse en los datos en la parte de abajo, muy importantes, 11 colors in 320 tiles.

Si vamos a a ACTIONS->EXPORT TILE DATA, nos aparecerá una ventana, donde si seleccionamos en Format BASIC, nos mostrara un montón de datos en este formato

DATALONG $11121112 ‘Tile #0

Si se fijan bien, cada tile esta formado por 64 caracteres, que representan los píxeles, y los números son el color de cada píxel (de 0 a 15)


En ACTIONS-> Export pallette data, veremos un dato en este formato

DATAINT $0EA0, $0EA0,…etc

Esos son los 16 colores de la paleta del grafico en el que estamos trabajando.

Todos los datos de este grafico estan en el archivo 1.bex


A continuación, abrimos el basiegaxorz, y cargamos el archivo 1.bex, veriamos esto



Noten que al final del archivo, esta cargado el grafico, ya transformado a codigo BASIC

Aquí tenemos varios comandos muy utiles

loadtiles suelo,320,256: Este comando, lo que hace es cargar los tiles en memoria de video, carga el tile “suelo”, que tiene 320 tiles (recuerden del imagenesis), en la posición 256 (como explique la MD tiene 1344 espacios para tiles)

Pallettes suelo_pal,0,0,16 : Aquí cargamos la paleta de colores, en este caso “suelo_pal”. El primer 0 es porque cargamos la paleta como la primera de las 4 (0,1,2,3), el segundo 0 es para indicarle cuantos colores cargamos, lo dejamos en 0 porque los queremos todos, y el 16 final es para indicar cuantos colores tiene nuestra paleta.

Drawtilesinc 256,0,20,40,8: Muestra los tiles en pantalla, el comando seria

Drawtilesinc 256, X, Y, ancho, alto

256 es la posición de tiles donde empezara a leer, X en 0 porque comenzamos en la parte izquierda, Y es 40 porque nuestra imagen tiene 8 de alto, y 40x8 es el tamaño de nuestra imagen.[/quote]

Ahora si le damos TOOLS->Compile, nos generara un archivo basic.bin, en la carpeta del basiegaxorz, que podremos cargar con cualquier emulador de megadrive




Ahora, cerramos el archivo, 1.bex, y abrimos el 2.bex, aquí ya carge el sprite “sonic.bmp”, que anteriormente transforme en imagenesis


Veremos nuevos comandos utiles:

sonic=addsprite(4,3): Aquí cargamos el sprite del sonic, donde le indicamos que tiene 4 tiles de alto, por 3 de ancho.

propsprite sonic,576,1: Aquí cargamos el sprite en memoria de video, donde 576 es el numero de tile de comienzo (256+320 del fondo), y el 1 es la paleta de colores a usar.

x=160: Le asignamos un valor a x para el movesprite

movesprite sonic,x,303: Finalmente movemos el sprite al sitio de pantalla que mas nos guste, en este caso a las coordenadas X=32, Y=175 (ACLARACION: tanto X como Y comienzan en 128 no en 0)

Cerramos el 2.bex, y abrimos el 3.bex, aquí hay varios comandos basicos de acceso al joystick, y un loop para que el programa este siempre leyendo el pad.

Do / loop: Todo lo que este dentro del Do/Loop se repetira por el infinito, es un bucle

J=joypad(): Asignamos el pad a una variable J para que sea mas facil de leer


if j.2 then
movesprite sonic, x,303
x--
end if

Aquí básicamente, le decimos que si se presiona el botón 2 del pad, mover el sprite x lugares en negativo. Como el comando esta dentro de un bucle, x—hace que mientras se mantenga presionado el botón 2, se reste 1 a x

El resultado final, es el sonic de Master System en nuestra megadrive




TUTORIAL 2: ARCHIVOS BINARIOS


En un proyecto pequeño, tener los graficos trasformados en formato BASIC, no es molestia. Pero a medida que nuestro proyecto crece, nos damos cuenta que un archivo de codigo, con 80 o 90 mil lineas, como que no es muy saludable…



Aquí se aprecia, el codigo y el tile grafico, si se ve bien, es lo mismo uno que otro


Asi que para evitar este problema, se cargan los datos en formato binario.Aqui un paso a paso para exportar a binario en el Imagenesis

1) Cargamos la imagen (bmp a 16colores)
2) Actions -> Quantize Now
3) Actions -> Export tile data
4) En FORMAT, cambiamos el valor por BINARY, y presionamos Save Data
5) Guardamos el archivo resultante en la misma carpeta donde esta el codigo, y le damos una extencion que nos resulte facil de recordar, por ejemplo, del sprite del sonic

Para graficos: sonic.img Para paleta: Sonic.pal

Una vez salvado el grafico, en el BasiEgaXorz, solo tenemos que suplantar el codigo de Basic por un comando que carge el archivo binario

Sonic:
DATALONG $00000000 ' Tile #0
DATALONG $00000000
.... etc


Sonic:
datafile sonic.img,BIN

Dejo para descargar un ejemplo practico, del sonic tambien, donde se carga los graficos desde un archivo binario

http://theelf-megadev.com/Ejemplos/Ejemplo_carga_binarios.zip

Mi opinión es que lo mejor es cargar los escenarios como binario, y los sprites como codigo Basic.

En este ejemplo, ademas de cargar archivos binarios, puse varios ejemplos de animacion de sprites, para el siguiente tutorial


TUTORIAL 3: CARGA Y DESCARGA DE SPRITES + ANIMACION


Como habrán visto en la descarga “Ejemplo carga binarios”, aquí el Sonic, ya camina con una pequeña animación, y también esta animado cuando se acerca al borde.

http://theelf-megadev.com/Ejemplos/Ejemplo_carga_binarios.zip




En este ejemplo, 5.bex, solo use comandos simples que ya habíamos visto en el tutorial numero 1.

El codigo de la intro...

Código: Seleccionar todo

dedo=addsprite(4,3)

loadtiles introtile,240,1
loadtiles dedo,12,241
pallettes intro_pal,0,0,16
pallettes dedo_pal,1,0,16
Drawtilesinc 1,10,8,20,12
propsprite dedo,241,1

while joypad()=0:

     sleep 10
    movesprite dedo,295,205
    sleep 10
    movesprite dedo,0,0
     wend
   
     waitpadup 0   

FreeAllSprites
sleep 10

Para el intro, use una imagen de sonic que se carga con loadtiles intro tile,240,1, y se muestra con Drawtilesinc 1,10,8,20,12.

El dedo es un sprite de 4x3 pixeles, que se carga dentro de un bucle while. Básicamente este bucle lo que dice es:

while joypad()=0: > mientras no se presione un boton
sleep 10 > espero un tiempo
movesprite dedo,295,205 > muestro el sprite del dedo
sleep 10 > espero un tiempo
movesprite dedo,0,0 > y lo oculto llevándolo fuera de pantalla
wend > cierro el bucle
FreeAllSprites > descargo todos los sprites de pantalla antes de cargar el juego

Veamos la animacion al caminar de sonic

Código: Seleccionar todo

If j.2 Then
     x=x-2
       If FrameCount < 10 Then
             pallettes sonic_r_pal,1,0,16
             propsprite sonic_l1,1197,1
             movesprite sonic_l1,x,y
        ElseIf FrameCount < 20 Then
            propsprite sonic_l2,1209,1
             movesprite sonic_l2,x,y
         ElseIf FrameCount < 30 Then
             propsprite sonic_l3,1221,1
            movesprite sonic_l3,x,y
        Else
            FrameCount = -1
        End If   
        FrameCount++


En la animación de caminar, del ejempo de arriba, se crea una variable Framecount que va de 0 a 30, y cada 10, carga un nuevo frame del sonic, y lo mueve 2 pixeles en la direccion que se presione en el joystick, un codigo muy simple.


TUTORIAL 4: MAPAS DE TILES

Bueno, como muchos de ustedes se darian cuenta, de la forma que estamos trabajando actualmente, poco mas de una pantalla se puede hacer, ya que se nos acaba la memoria de video de la megadrive.

Como sabrán, la vram de la megadrive puede almacenar 1343 tiles, y una pantalla de 320x224 nos ocupa 1120 tiles, dejando solo 223 para los sprites, y eso sin usar texto claro.

La solucion a este problema, son los mapas. Y que son? Pues en cada pantalla, existen multitud de tiles repetidos. Pues lo que se hace es hacer un mapa de la pantalla, donde se especifica en que lugar esta cada tile, y si es repetido o no.

De esta forma con pocos tiles, se puede generar una pantalla completa. Es muy recomendable leer a este punto si hay dudas, mi post de trabajo con tiles.

Para este ejemplo, hice una pantalla con 68 tiles. (saque los tiles de uno de mis juegos favoritos de NES, el Shaterhand)


Para generar el mapa, se hace en el imagenesis, abrimos el bmp con el fondo a optimizar

MODE-> 15color,4bpp,OPTIMIZED
Luego ACTION-> Quantize Now
Y ahora veremos una nueva opcion, ACTION -> EXPORT TILE MAP

Podemos salvar el mapa tanto en binario como en codigo Basic, es lo mismo.

Esta vez lo hare todo en codigo Basic asi es mas facil de ver


[url]http://theelf-megadev.com/Ejemplos/7_Ejemplo_mapas.zip[/url]

El codigo es muy simple, y esta bien explicado creo

Dim Map(39,27) as Integer 'Creamos un mapa de 40x28 tiles

pallettes fondo_pal,0,0,16 'Cargamos la paleta
loadtiles fondo,67,1 'Y cargamos los 67 tiles



reload fondo_map 'Cargamos el mapa

For Y=0 to 27 'la imagen tiene 40x28 tiles, asi que cargamos todos los tiles, del Y=0 al 27
For X=0 to 39 'al X=0 a 39
readint Map(X,Y) 'Y leemos el mapa
Next X
Next Y

For Y=0 to 27
For X=0 to 39
DrawTile Map(X,Y)+pallette(0)+1,X,Y 'Y dibujamos una pantalla completa, leyendo el mapa,
Next X 'usando la paleta 0, y comenzando del tile 1
Next Y 'Siempre en direccion primero X luego Y

En este codigo lo que se hace es crear un mapa del tamaño de la pantalla, o sea 40x28 tiles.
Luego, se carga el mapa generado por el imagenesis, y se lee desde X=0 a X=39 y de Y=0 a Y=27
Una vez leido, se vuelca en la vram, usando el mapa como guia, usando el comando DrawTile

Asi que en ralidad lo que vemos es la pantalla de arriba, pero la realidad son los tiles de abajo




TUTORIAL 5: SCROLL


En el tutorial anterior, vimos los mapas, algo muy util para poder cargar una pantalla sin ocupar toda la VRAM de la Megadrive.
Esta tecnica es la base de este tutorial, ya que sin ella, no podriamos cargar mas que una pantalla a la vez.

Lo primero es entender las limitaciones de hardware. El tamaño maximo de pantalla que permite gestionar la Megadrive es de 512x512 pixeles o 64x64 tiles.

La megadrive permite dos planos de scroll (A,B) y un tercer plano fijo, (Window) que no permite scroll.

Saviendo esto, ya podemos ir al codigo.

Aqui dejo dos ejemplos. En el primero se crean dos planos de scroll, uno fijo, y el otro movil.

- Primer ejemplo

Aqui cargo un plano de scroll fijo, con una imagen en primer plano, scroll A,tomada prestada del LB2, y un plano B de scroll movil, que es un escenario completo tambien del LB2

http://theelf-megadev.com/Ejemplos/Ejemplo_scroll_1.zip

Segundo ejemplo

http://theelf-megadev.com/Ejemplos/Ejemplo_scroll_2.zip

MIRROR DE LOS DOS EJEMPLOS EN MEDIAFIRE
http://www.mediafire.com/file/wj4nqvngzvx/Ejemplos%20scroll.zip

Lo nuevo del codigo son los siguientes comandos

settextplane <-- Define el plano de scroll donde se dibujaran los textos

setgfxplane <-- Define el plano de scroll para los comandos que dibujen tiles (DrawTile, DrawTiles)
Este comando permite tres opciones, SCROLL_A/SCROLL_B/WINDOW. Que define en que planos se dibujaran los tiles.

setscrollplane <-- Define el plano de scroll actual. Puede ser el A,B,o Window

Por ultimo el comando que hace el scroll en si mismo, los comandos basicos son

scroll permite UP/DOWN/LEFT/RIGHT (arriba,abajo,izquierda,derecha) y la cantidad de pixeles del scroll.

scroll left,1 <---- mueve el plano seleccionado de scroll, 1 pixel a la izquierda
scroll down,4 <---- mueve el plano seleccionado de scroll, 4 pixel hacia abajo

TUTORIAL 6: AUDIO

Bueno, ya tenemos mas o menos definida la parte grafica, scroll, sprites, tiles... pero nos falta la sonora.

Vamos a ver como usar el YMH2612, para reproducir un WAV.

Aqui un ejemplo, que carga un archivo "Segapcm.bin" de un tamaño de 27000 bytes, y lo reproduce

http://theelf-megadev.com/Ejemplos/Ejemplo%20Audio.zip

El codigo

Código: Seleccionar todo

'Gracias Mairtrus por el codigo y las explicaciones

Const #PCMLongitude = 27000  'Definimos el largo en bytes del archivo 26,3 KB = 27.000 bytes



   
do
  ink 2
  locate 1,1
  Print "Ejemplo de sonido PCM"
  Print " El archivo sega.pcm es un WAV sin los primeros 52bytes"
  Print ""
  Print ""
  print " presionar A para reproducir"

SonidoSega:
if JoyPad(0).6 then   
          enable INTERRUPTVBLANK
          on VBLANK gosub PlaySega 'llamamos a la funcion PlaySega
    end if      
loop






PlaySEGA:
    while peek(&hA04000).7  ' espera hasta que se desocupe
    wend
    poke &hA04000,&h2B      ' en el registro $2B, si el bit más alto es 0, el*
    while peek(&hA04000).7  ' espera hasta que se desocupe
    wend
    poke &hA04001,&h80      '*canal 6 es un FM más, caso contrario es para DAC

    while peek(&hA04000).7  ' espera hasta que se desocupe
    wend
    poke &hA04002,&hB6      ' el registro $B4 es para poner en el parlante izquierdo, derecho o ambos (Pannig en ingles, Balance en español). Que sea $B6 es porque, al ser el canal FM 6 el canal 2 de la segunda parte, $B4+2=$B6
    while peek(&hA04000).7  'wait for busy
    wend
    poke &hA04003,&hC0      ' Al poner los 2 bits más altos, pone el canal izquierdo y derecho simultaneamente, o sea lo hace stereo (pone 80 o 40 y vas a ver se escucha por un solo parlante)
     
    while peek(&hA04000).7  ' espera hasta que se desocupe
    wend
    poke &hA04000,&h2A      ' esta es la direccion donde se escribe el dato de 8bits que conforma el sample PCM

    reload PCMData
    for i=1 to #PCMLongitude
        while peek(&hA04000).7  ' espera hasta que se desocupe
        wend
        read Nota
        poke &hA04001, Nota ' Y aqui escribe el dato que carga desde la muestra
        halt
    next i
gosub SonidoSega


PCMData:
DATAFILE segapcm.bin,BIN

Basicamente el archivo segapcm.bin, es un archivo wav de 8bits, 14khz, sin los primeros 52bytes, editado en un editor hexadecimal.

Si quieren reproducir archivos wav sin modificar, solo hay que cambiar una linea

Código: Seleccionar todo

reload PCMData

Por esta

reload PCMData,52

De esta forma, se carga el archivo desde el byte 52

Deveran experimentar diferentes tiempos de espera para diferentes calidades de wav (8khz,11khz,22khz..etc)



Espero les sea util esta primera guia, y estoy ansioso por oir los comentarios/criticas, y posibles proyectos!! estoy preparando varias guias mas!