Programación de la Neogeo

Pues a raíz de ver el Fast Striker me ha dado el gusanillo de buscar info sobre la programación de la negrita. Por ahora voy a ir investigando el fuente del juego frogfest:

http://frogfeast.rastersoft.net/NeoGeoSrc.html

Ahi viene las instrucciones de lo que hay que bajarse y como configurarlo, en resumen es:

- Te bajas esto (compilador) y lo descomprimes en C:

http://frogfeast.rastersoft.net/Files/NeoDev.zip

- Si no usas visual studio 6 debes bajar el nmake de microsoft:

http://support.microsoft.com/default.as ... us;Q132084

- Creas el directorio 'mutnat' en 'C:\MAME\ROMS\', tb necesitarás la rom del mutation nation y la bios de neogeo dentro de la carpeta roms, lo que compilemos le copiará a la carpeta 'mutnat' y mame cargará esas roms en vez de las del zip del juego.

- Añades 'c:\NeoDev\bin' al path o ejecutas setmvs.bat.

- Te bajas el fuente del juego de la rana de aquí:

http://frogfeast.rastersoft.net/Files/NeoGeoSrc.zip

- Y para compilarlo desde msdos y en la carpeta del fuente haces ' nmake FrogDebug.mak' o lo compilas desde visual studio.

Por si estais perrongos, he subido este zip con la carpeta neodev lista para compilar el frogfest junto con el pack de las neolib que subió ulmez en speksnk. Para compilar primero debéis ejecutar el setmvs.bat o añadir el path a mano. Luego en la carpeta tutos, entrais al que os interese, ejecutáis el compile.bat, si no ha habido errores podréis ejecutar el go.bat que abrirá el mame y probará la rom resultante. Tb incluye los tutos 1 y 2, si se le puede llamar tutos

http://rapidshare.com/files/382400537/NeoDev.zip.html

TUTO 1 - Hola Mundo

- Un hola mundo básico sería sustituyendo el main.c por:

#include "Defines.h"
#include "Main.h"
#include "Routines.h"
#include "Sprites.h"

extern WORD FontPal[];

#define FONTPAL 2

int main()
{
LoadPalette(FontPal, 0x400040, 0x20);

DrawString( "HOLA MUNDO", FONTPAL, 15, 15);
DrawString("neogeo forever", FONTPAL, 13, 17);

while (TRUE)
WaitVBlank();

return 0;
}



TUTO 2 - Controles

Para probar los controles tendriamos un main.c como el siguiente:

#include "Defines.h"
#include "Main.h"
#include "Routines.h"
#include "Sprites.h"

extern WORD FontPal[];

#define FONTPAL 2

DWORD OldJoyVal1;
DWORD OldJoyVal2;

int main()
{
DWORD JoyVal1;
DWORD JoyVal2;

LoadPalette(FontPal, 0x400040, 0x20);

DrawString( "PRUEBA PAD", FONTPAL, 15, 3);
DrawString("neogeo forever", FONTPAL, 13, 5);

while (TRUE)
{
WaitVBlank();

JoyVal1 = ReadJoystickA();
JoyVal2 = ReadJoystickB();

if (JoyVal1 != OldJoyVal1)
OldJoyVal1 = JoyVal1;

if (JoyVal2 != OldJoyVal2)
OldJoyVal2 = JoyVal2;

DrawString("J1 A: ", FONTPAL, 3, 8);
DrawNumber(((OldJoyVal1 & JOYA_A)!= 0), FONTPAL, 14, 8);
DrawString("J1 B: ", FONTPAL, 3, 10);
DrawNumber(((OldJoyVal1 & JOYA_B)!= 0), FONTPAL, 14, 10);
DrawString("J1 C: ", FONTPAL, 3, 12);
DrawNumber(((OldJoyVal1 & JOYA_C)!= 0), FONTPAL, 14, 12);
DrawString("J1 D: ", FONTPAL, 3, 14);
DrawNumber(((OldJoyVal1 & JOYA_D)!= 0), FONTPAL, 14, 14);
DrawString("J1 START: ", FONTPAL, 3, 16);
DrawNumber(((OldJoyVal1 & JOYA_START)!= 0), FONTPAL, 14, 16);
DrawString("J1 SELECT: ", FONTPAL, 3, 18);
DrawNumber(((OldJoyVal1 & JOYA_SELECT)!= 0), FONTPAL, 14, 18);
DrawString("J1 UP: ", FONTPAL, 3, 20);
DrawNumber(((OldJoyVal1 & JOYA_UP)!= 0), FONTPAL, 14, 20);
DrawString("J1 DOWN: ", FONTPAL, 3, 22);
DrawNumber(((OldJoyVal1 & JOYA_DOWN)!= 0), FONTPAL, 14, 22);
DrawString("J1 LEFT: ", FONTPAL, 3, 24);
DrawNumber(((OldJoyVal1 & JOYA_LEFT)!= 0), FONTPAL, 14, 24);
DrawString("J1 RIGHT: ", FONTPAL, 3, 26);
DrawNumber(((OldJoyVal1 & JOYA_RIGHT)!= 0), FONTPAL, 14, 26);


DrawString("J2 A: ", FONTPAL, 19, 8);
DrawNumber(((OldJoyVal2 & JOYA_A)!= 0), FONTPAL, 30, 8);
DrawString("J2 B: ", FONTPAL, 19, 10);
DrawNumber(((OldJoyVal2 & JOYA_B)!= 0), FONTPAL, 30, 10);
DrawString("J2 C: ", FONTPAL, 19, 12);
DrawNumber(((OldJoyVal2 & JOYA_C)!= 0), FONTPAL, 30, 12);
DrawString("J2 D: ", FONTPAL, 19, 14);
DrawNumber(((OldJoyVal2 & JOYA_D)!= 0), FONTPAL, 30, 14);
DrawString("J2 START: ", FONTPAL, 19, 16);
DrawNumber(((OldJoyVal2 & JOYA_START)!= 0), FONTPAL, 30, 16);
DrawString("J2 SELECT: ", FONTPAL, 19, 18);
DrawNumber(((OldJoyVal2 & JOYA_SELECT)!= 0), FONTPAL, 30, 18);
DrawString("J2 UP: ", FONTPAL, 19, 20);
DrawNumber(((OldJoyVal2 & JOYA_UP)!= 0), FONTPAL, 30, 20);
DrawString("J2 DOWN: ", FONTPAL, 19, 22);
DrawNumber(((OldJoyVal2 & JOYA_DOWN)!= 0), FONTPAL, 30, 22);
DrawString("J2 LEFT: ", FONTPAL, 19, 24);
DrawNumber(((OldJoyVal2 & JOYA_LEFT)!= 0), FONTPAL, 30, 24);
DrawString("J2 RIGHT: ", FONTPAL, 19, 26);
DrawNumber(((OldJoyVal2 & JOYA_RIGHT)!= 0), FONTPAL, 30, 26);

}

return 0;
}



Bueno, vamos al tema con lo que he ido investigando de las NEOLIB

Gráficamente la consola tiene un plano que no puede hacer scroll, sirve para puntuaciones, text, etc. Se llama capa 'fix' y puede tener hasta 16 paletas de 16 colores. Luego están los sprites (no hay planos como en megadrive, super nintendo etc.), concretamente son 384, que pueden estar formados por 1 tile (16x16 pixels) hasta 1 x 32 tiles en vertical (16x512 pixels), cada tile puede tener 16 colores. Esto se ve fácil en el shot factory de nebula, cuando vamos desactivando sprites, 'desaparecen' tiras verticales. Los sprites pueden reducirse verticalmente y horizontalmente (no es zoom tipo super nintendo) y unir varios para que se comporten como uno solo ( por eso, por ejemplo, el fondo del art of fighting se reduce entero del tirón). Existen 2 bancos de 256 paletas de 16 colores cada una (256 x 16 = 4096 colores en pantalla).

Un 'juego' para neogeo (más o menos) se corresponde de las roms:

-s1 que contiene los tiles de la capa fix. Se compone de 16 mapas de 128x128 pixels, cada mapa puede tener una paleta de 16 colores (16 paletas de 16 colores = 256 colores). El texto de max 330 mega... y logo de snk de la bios está en esta rom, por lo que si cambiamos esta rom nos saldrá la bios corrupta. Después de pelearme con ella he logrado que salga más o menos, lo único que el logo de snk me sale en gris. Se puede desactivar esa secuencia de la bios cambiando en el common_crt0_cart.s sustituir:

.word 0x0
.word LOGO_START

por

.word 0x0000
.word 0x0138

Así es como deberia verse:


Así es como sale si tocamos la rom s al tuntun:


Y así se está ahora mismo las imagenes que he metido yo en mi rom s, lo del logo de neogeo es por las roms c. Están en la carpeta src/shared:



- roms c1,c2... que tienen los tiles para los sprites, ahi tb se guarda el logo de neogeo del arranque de la bios, todavia no he llegado a eso

- Las roms p1, p2... son el código del programa del 68000.

- El m1 es el programa del z80, el driver para el sonido, ahi se ejecuta el programa que llama al yamaha.

- Las v1, v2... son las roms que tienen los samplers y las notas de las canciones.

El hola mundo con las neolib sería así:

#include <stdlib.h>
#include <video.h>

extern PALETTE palettes;

int main(void)
{

// void setpalette(int npal, int nb, const PPALETTE palette);
setpalette(0, 1, (const PPALETTE)&palettes); // empezando en ‘npal’, crea ‘nb’ paletas, usando la definicion de colores guardada en ‘palette’

// void textout(int x, int y, int pal, int bank, const char *txt);
textout(14, 10, 0, 0, "HOLA MUNDO"); // muestra una cadena en x,y usando una paleta y en un banco 'fix'especifico
textout(12, 12, 0, 0, "neogeo forever");

while(1)
{
// void wait_vbl(void);
wait_vbl(); // espera el refresco vertical

// void textoutf(int x, int y, int pal, int bank, const char *fmt, ...);
textoutf(12, 20, 0, 0, "Vbl Counter:%d", _vbl_count); // similar al textout pero con formato printf
}
}




Para el tema de los controles hay varios métodos, por bios o directamente del hardware:

#include <stdlib.h>
#include <video.h>
#include <input.h>

extern PALETTE palettes[];

const char * const pos_names[] = {
"UP ",
"DOWN ",
"LEFT ",
"RIGHT ",
"A ",
"B ",
"C ",
"D ",
"START ",
"SELECT"
};

static const DWORD pos_masks[10] = {
JOY_UP,
JOY_DOWN,
JOY_LEFT,
JOY_RIGHT,
JOY_A,
JOY_B,
JOY_C,
JOY_D,
JOY_START,
JOY_SELECT
};

int main(void)
{
DWORD direct, bios, onchange, repeat, line, i, j;

// void setpalette(int npal, int nb, const PPALETTE palette);
setpalette(0, 1, (const PPALETTE)&palettes); // empezando en ‘npal’, crea ‘nb’ paletas, usando la definicion de colores guardada en ‘palette’

textout(11, 0, 0, 0, "prueba controles"); // muestra una cadena en x,y usando una paleta y en un banco 'fix'especifico

while(1){

// espera el refresco vertical
wait_vbl();

line = 2;

// para ambos puertos
for(i=0;i<2;i++)
{
textoutf(1, line++, 0, 0, "<PORT%d> DIRECT BIOS ONCHANGE REPEAT",
i+1);

// lee el estado del control del puerto especificado (0,1) por el metodo indicado
// DWORD poll_joystick(DWORD port, DWORD flags);
direct = poll_joystick(i, READ_DIRECT); // directamente a traves del hardware
bios = poll_joystick(i, READ_BIOS); // a traves de la bios
onchange = poll_joystick(i, READ_BIOS_CHANGE); // a traves de la bios solo si cambia
repeat = poll_joystick(i, READ_BIOS_REPEAT); // a traves de la bios a intervales regulares

line++;

for(j=0;j<10;j++)
{
textoutf(1, line++, 0, 0, "%s %d %d %d %d",
pos_names[j],
(direct & pos_masks[j]) ? 1 : 0,
(bios & pos_masks[j]) ? 1 : 0,
(onchange & pos_masks[j]) ? 1 : 0,
(repeat & pos_masks[j]) ? 1 : 0);
}

line++;
}
}
}


// void setpalette(int npal, int nb, const PPALETTE palette);
setpalette(0, 1, (const PPALETTE)&palettes); // empezando en ‘npal’, crea ‘nb’ paletas, usando la definicion de colores guardada en ‘palette’

// void textout(int x, int y, int pal, int bank, const char *txt);
textout(14, 10, 0, 0, "HOLA MUNDO"); // muestra una cadena en x,y usando una paleta y en un banco 'fix'especifico
textout(12, 12, 0, 0, "neogeo forever");

while(1)
{
// void wait_vbl(void);
wait_vbl(); // espera el refresco vertical

// void textoutf(int x, int y, int pal, int bank, const char *fmt, ...);
textoutf(12, 20, 0, 0, "Vbl Counter:%d", _vbl_count); // similar al textout pero con formato printf
}
}



Para los sprites valdría con:

extern PALETTE palettes[];
extern TILEMAP mysprite[];
int sprite_num_player1; // numero del sprite

int main(void)
{

while(1) {
setpalette(0, 2, (const PPALETTE)&palettes);
set_current_sprite(2);
sprite_num_player1 = write_sprite_data(100, 100, 15, 255, 3, 3, (const PTILEMAP)&mysprite);
}
return 0;
}

Pero no me funciona muy bien la cosa (las paletas por ejemplo), si alguno tiene un ratito y puede ayudarme con esto se lo agardecería

Aquí os dejo el zip con todo listo para compilar, primero en C:\NeoDev\src ejecutais build-libs.bat para compilar las librerias, luego podeis hacer build-samples para ver si todo funciona.

En C:\NeoDev\src\samples teneis los fuentes, se tiene que hacer compile.bat (compila), makeroms.bat (crea las roms), go.bat (renombra las roms, las copia en C:\mame\roms\puzzledp y ejecuta mame). Recordad bajaros mame, el juego puzzle de pon y la bios de neogeo.

http://rapidshare.com/files/385386345/NeoDev.zip.html







ANEXO - INFO TECNICA

Neo Geo

System Information:
Resolution: 320(304?)x224
Color Palette: 65,536
Maximum Colors On-Screen: 4,096
Maximum Sprites On-Screen: 380
Minimum Sprite Size: 1x2
Maximum Sprite Size: 16x512
Maximum Amount of Game Planes: 3(?)
Sound Channels: 4-FM synthesis, 7-Digital, 3-PSG, 1-Noise channel
Yamaha 2610 sound chip.
Internal RAM: Work RAM: 64Kb
58MBit DRAM, 512KBit VRAM and 64KBit SRAM (CD version only).
512KBit DRAM, 512KBit VRAM (Cartridge version).

Graphics information:
$00000 - $DFFF: Blocks of sprite data, each $80 bytes:
Each $80 block is made up of $20 double words, their format is:
Word: Sprite number (16 bits)
Byte: Palette number (8 bits)
Byte: Bit 0: X flip
Bit 1: Y flip
Bit 2: Automatic animation flag (4 tiles?)
Bit 3: Automatic animation flag (8 tiles?)
Bit 4: MSB of sprite number (confirmed, Karnov_r, Mslug). See note.
Bit 5: MSB of sprite number (MSlug2)
Bit 6: MSB of sprite number (Kof97)
Bit 7: Unknown for now

Each double word sprite is drawn directly underneath the previous one,
based on the starting coordinates.

$7000 - $7a00 : Front plane fix tiles (8*8), 2 bytes each

$8000: Control for sprites banks, arranged in words
Bit 0 to 3 - Y zoom LSB
Bit 4 to 7 - Y zoom MSB (ie, 1 byte for Y zoom).
Bit 8 to 11 - X zoom, $f is full size (no scale).
Bit 12 to 15 - Unknown, probably unused

$8200: Control for sprite banks, arranged in words
Bit 0 to 5: Number of sprites in this bank (see note below).
Bit 6 - If set, this bank is placed to right of previous bank
(same Y-coord).
Bit 7 to 15 - Y position for sprite bank.

$8400: Control for sprite banks, arranged in words
Bit 0 to 5: Unknown
Bit 7 to 15 - X position for sprite bank.

Memory Locations:
$00 Stack pointer
$04 Initial PC ($C11002)
$10 Pointer to debug dip switches (Dword)
$64 VBlank pointer
$100 "NEO-GEO", 0
$108 NGH Number, a unique number assigned to each cart. (Word) (Thanks to Apollo69
for this info.)
$10A ?
$10E Pointer to debug dip switches (Dword)
$112 ?
$114 Starting Sprite Number / $100 for the Neo Geo logo.
Logo is (64 x 64 chars. 4096 bytes total in each bank).
$116 Pointer to Japanese configuration
configuration:
"Name " 16 bytes
? (Dword)
$0364 (?) Dword
$14132401(?) Word
$11A Pointer to English configuration
$11E Pointer to Spanish(?) configuration
$122 Entry point of the software
$182 Pointer to security code.
$10F6EE (DWORD) Contains a copy of 68000 (IRQ Vector).
$10FD83 Nationality of the machine (0 = Japanese / 1 & 2 = English)
$10FDAE Set to zero before booting to force complete initialization.
$10FE80 Set to FF to activate debug mode.
$300000 (Write) Watchdog Reset
$300001
$300000 Controller #1
bit 7 : Button D
bit 6 : Button C
bit 5 : Button B
bit 4 : button A
bit 3 : Right
bit 2 : Left
bit 1 : Down
bit 0 : Up

$300001 Dipswitches
bit 0 : Selftest
bit 1 : Unknown (Unused ?) \ something to do with
bit 2 : Unknown (Unused ?) / auto repeating keys ?
bit 3 : \
bit 4 : | communication setting ?
bit 5 : /
bit 6 : free play
bit 7 : stop mode ?

$300080 Controller #4 - Test switch in here
$300081
$31001c Unknown (ghost pilots)
$320000 Sound CPU
$320001
$320001
The Neo Geo contains an NEC 4990 Serial I/O calendar & clock accesed
through $320001, $380050, $280050 (shadow adress). A schematic
for this device can be found on the NEC webpages.
bit 0 : COIN 1
bit 1 : COIN 2
bit 2 : SERVICE
bit 3 : UNKNOWN
bit 4 : UNKNOWN
bit 5 : UNKNOWN
bit 6 : 4990 test pulse bit.
bit 7 : 4990 data bit.


$340000 Controller #2 (same bits as $300000)
$380000 Status byte
0 PAD1 START
1 PAD1 SELECT
2 PAD2 START
3 PAD2 SELECT
4 --\ MEMORY CARD
5 --/ INSERTED
6 MEMORY CARD WRITE PROTECTION
7 UNUSED (?)
$380011 Backup bank select
$380051 4990 control write register
bit 0: C0
bit 1: C1
bit 2: C2
bit 3-7: unused.

$00 = register hold.
$02 = shift.
$03 = time read (reset register).
$04 = ????.

$3a0001 Enable display.
$3a0003 Swap in Bios ($80 bytes vector table of BIOS)
$3a000a Select board FIX char rom
$3a000b
$3a000c Neogeo Sram Lock
$3a000d
$3a000e Neogeo Setpalbank1
$3a000f
$3a001a Select game FIX char rom
$3a001b
$3a001c Neogeo Sram Unlock
$3a001d
$3a001e Neogeo SetPalbank0 Palette banking
$3a001f
$3a0011 Disable display
$3a001b set bios vector table (?) mirror ?
$3a001d unlock backup ram
$3a0013 Swap in Rom ($80 bytes vector table of ROM bank)
$3c000c IRQ acknowledge
4 = IRQ 1
2 = IRQ 2
1 = IRQ 3 (does any game use this?)

$3c000e $3c000f Control R
The format of this very important location is: AAAA AAAA B??? CDDD

A is most likely the video beam line, however from how it is used it
doesn't seem to be a 0-255 direct map: the top bit is often masked out.

I think the top bit of A is: (vblank OR irq2). sdodgeb loops waiting for
it to be 1; zedblade heavily depends on it to work correctly.

B is used together with A in one place, so most likely video beam position

Maybe AAAAAAAAB is a 9-bit video line counter.
It is tested individually in many cases (e.g. samsho3) so it might not be
the low bit of the raster line.

C is definitely a PAL/NTSC flag. Evidence:
1) trally changes the position of the speed indicator depending on
it (0 = lower 1 = higher).
2) samsho3 sets a variable to 60 when the bit is 0 and 50 when
it's 1. This is obviously the video refresh rate in Hz.
3) samsho3 sets another variable to 256 or 307. This could be the
total screen height (including vblank), or close to that.
Some game (e.g. lstbld2, samsho3) do this (or similar):
bclr #$0, $3c000e.l
when the bit is set, so 3c000e (whose function is unknown) has to
be related
D is unknown (counter of some kind, used in a couple of places).
in blazstar, this controls the background speed in level 2.

IO addresses
$3c0000 Read/Write location in VRAM.
$3c0002 Read/Write into VRAM
$3c0004 Value to increment VRAM address by (based on words)
$3c0006 Unknown, set vblank counter (?)
$3c0008 shadow adress for $3c0000.
$3c000a shadow adress for $3c0002.

68k Addresses
$000000 $0fffff Rom bank 1
$100000 $10ffff Ram bank 1
$200000 $2fffff Rom bank 2
$2ffff0 $2fffff Neo Bankswitch Write
$400000 $401fff Neogeo Palette Ram Read
$800000 $800fff NeoGeo Memcard Read
Memory card is a 2kb battery backed RAM.
It is accessed thru $800000-$800FFF.
Even bytes are always $FF
Odd bytes are memcard data ($800 bytes)

$c00000 $c1ffff System Bios Rom
$d00000 $d0ffff 64k battery backed SRAM

trally writes to 200000-200003 as well, probably looking for a serial
link both games write to 0000fe before writing to 200000. The two
things could be related. Sidekicks reads and writes to several
addresses in this range, using this for copy protection.

BIOS Routines/Locations (Thanks to Fabrice Martinez for these)
After calling $C0044A during the VBlank interrupt the following locations will be set:
$10FD95 Controller 1
$10FD96 Copy of 10FD95 (for comparison)
$10FD97 Impulse
$10FD98 Auto-repeat

$10FD9B Controller 2
$10FD9C Copy of 10FD9C
$10FD9D Impulse
$10FD9E Auto-Repeat

Z80 Addresses
$0000 $7fff Rom
$8000 $bfff Bank 5
$c000 $dfff Bank 6
$e000 $efff Bank 7
$f000 $f7ff Bank 8
$f800 $ffff Ram

Character layout
8 x 8 chars
4096 in total
4 bits per pixel (planes are packed in a nibble)
32 bytes per char

Sprite Layout
16 x 16
4 bits per pixel
128 bytes per sprite