Repito este tutorial que tengo en mi web y otros foros, con la esperanza de que no solo le sirva a alguien, si no, de encontrar algun programador, que quiera ayudarme a continuarlo, ya que no tengo el tiempo suficiente para seguirlo por el momento
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” XD
Ante todo gracias a Mairtrus por toda la ayuda prestada
Ire agregando nuevo contenido si veo que genera interes.
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 XD , 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, en otro foro
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 XD
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 XD
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
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!
