static int DrvInit()
{
int nLen;
BurnSetRefreshRate(CAVE_REFRESHRATE);
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (unsigned char *)0;
if ((Mem = (unsigned char *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
EEPROMInit(&eeprom_interface_93C46_8bit);
// Load the roms into memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(CaveTileRAM[0], 0x100000, 0x107FFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x180000, 0x187FFF, SM_RAM);
SekMapMemory(CavePalSrc, 0x200000, 0x207FFF, SM_RAM);
SekMapMemory(Ram01, 0x300000, 0x30FFFF, SM_RAM);
SekSetReadWordHandler(0, korokoroReadWord);
SekSetReadByteHandler(0, korokoroReadByte);
SekSetWriteWordHandler(0, korokoroWriteWord);
SekSetWriteByteHandler(0, korokoroWriteByte);
SekClose();
}
nCaveRowModeOffset = 1;
CavePalInit(0x8000);
CaveTileInit();
CaveSpriteInit(1, 0x300000);
CaveTileInitLayer(0, 0x200000, 4, 0x4400);
YMZ280BInit(16934400, &TriggerSoundIRQ, 3);
bDrawScreen = true;
DrvDoReset(); // Reset machine
return 0;
}
static int DrvInit()
{
int nLen;
// bToaRotateScreen = true;
BurnSetRefreshRate(REFRESHRATE);
nBCU2ROMSize = 0x080000;
nFCU2ROMSize = 0x080000;
// Find out how much memory is needed
AllMem = NULL;
MemIndex();
nLen = MemEnd - (unsigned char *)0;
if ((AllMem = (unsigned char *)malloc(nLen)) == NULL) {
return 1;
}
memset(AllMem, 0, nLen);
MemIndex();
if (BurnLoadRom(Drv68KROM + 0x000001, 0, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x000000, 1, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x040001, 2, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x040000, 3, 2)) return 1;
ToaLoadTiles(BCU2ROM, 4, nBCU2ROMSize);
ToaLoadTiles(FCU2ROM, 8, nFCU2ROMSize);
{
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07FFFF, SM_ROM);
SekMapMemory(Drv68KRAM, 0x0c0000, 0x0c3FFF, SM_RAM);
SekMapMemory(DrvPalRAM, 0x104000, 0x1047FF, SM_RAM);
SekMapMemory(DrvPalRAM2, 0x106000, 0x1067FF, SM_RAM);
SekSetReadWordHandler(0, samesameReadWord);
SekSetReadByteHandler(0, samesameReadByte);
SekSetWriteWordHandler(0, samesameWriteWord);
SekSetWriteByteHandler(0, samesameWriteByte);
SekClose();
}
ToaInitBCU2();
nToaPalLen = nColCount;
ToaPalSrc = DrvPalRAM;
ToaPalSrc2 = DrvPalRAM2;
ToaPalInit();
// BurnYM3812Init(28000000 / 8, &toaplan1FMIRQHandler, &toaplan1SynchroniseStream, 0);
bDrawScreen = true;
DrvDoReset();
return 0;
}
static INT32 DrvInit()
{
INT32 nLen;
// bToaRotateScreen = true;
BurnSetRefreshRate(REFRESHRATE);
nBCU2ROMSize = 0x080000;
nFCU2ROMSize = 0x100000;
// Find out how much memory is needed
AllMem = NULL;
MemIndex();
nLen = MemEnd - (UINT8 *)0;
if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(AllMem, 0, nLen);
MemIndex();
ToaLoadCode(Drv68KROM, 0, 2);
ToaLoadTiles(BCU2ROM, 2, nBCU2ROMSize);
ToaLoadGP9001Tiles(FCU2ROM, 6, 3, nFCU2ROMSize);
{
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x03FFFF, SM_ROM);
SekMapMemory(DrvPalRAM, 0x404000, 0x4047FF, SM_RAM);
SekMapMemory(DrvPalRAM2, 0x406000, 0x4067FF, SM_RAM);
SekMapMemory(Drv68KRAM, 0x480000, 0x487FFF, SM_RAM);
SekSetReadWordHandler(0, vimanaReadWord);
SekSetReadByteHandler(0, vimanaReadByte);
SekSetWriteWordHandler(0, vimanaWriteWord);
SekSetWriteByteHandler(0, vimanaWriteByte);
SekClose();
}
ToaInitBCU2();
nToaPalLen = nColCount;
ToaPalSrc = DrvPalRAM;
ToaPalSrc2 = DrvPalRAM2;
ToaPalInit();
// BurnYM3812Init(28000000 / 8, &toaplan1FMIRQHandler, &toaplan1SynchroniseStream, 0);
bDrawScreen = true;
DrvDoReset();
return 0;
}
static int s1945iiInit()
{
int nRet;
Mem = NULL;
MemIndex();
int nLen = MemEnd - (unsigned char *)0;
if ((Mem = (unsigned char *)malloc(nLen)) == NULL) return 1;
memset(Mem, 0, nLen); // blank all memory
MemIndex();
nRet = BurnLoadRom(RomSH2 + 0x000000, 0, 2); if (nRet != 0) return 1;
nRet = BurnLoadRom(RomSH2 + 0x000001, 1, 2); if (nRet != 0) return 1;
be_to_le( RomSH2, 0x100000 );
#if 0
FILE * f = fopen("d.bin", "wb+");
fwrite(RomSH2, 1, 0x100000, f);
fclose(f);
#endif
{
Sh2Init(1);
Sh2Open(0);
// Map 68000 memory:
Sh2MapMemory(RomSH2, 0x00000000, 0x000fffff, SM_ROM);
Sh2MapMemory(RamSpr, 0x03000000, 0x0300ffff, SM_RAM);
Sh2MapMemory((unsigned char *) RamPal,
0x03040000, 0x03044fff, SM_RAM);
Sh2MapMemory(RamVReg, 0x03050000, 0x0305ffff, SM_WRITE);
Sh2MapMemory(RamSH2, 0x06000000, 0x060fffff, SM_RAM);
Sh2SetReadByteHandler (0, ps3v1ReadByte);
Sh2SetReadWordHandler (0, ps3v1ReadWord);
Sh2SetReadLongHandler (0, ps3v1ReadLong);
Sh2SetWriteByteHandler(0, ps3v1WriteByte);
Sh2SetWriteWordHandler(0, ps3v1WriteWord);
Sh2SetWriteLongHandler(0, ps3v1WriteLong);
}
DrvDoReset();
return 0;
}
bool PoolAllocator::internal_init( uint32_t size_in_bytes )
{
data = new uint8_t[size_in_bytes];
if(!data)
return false;
size = size_in_bytes;
openList.push_back( MemIndex( data, size_in_bytes ) );
return true;
}
void* PoolAllocator::closeMemory( int i, uint size_in_bytes )
{
if( openList[i].size / 2 < size_in_bytes || openList[i].size / 2 < block_size )
{
void* t = openList[i].memory;
insertClosedList( openList[i] );
openList.erase( openList.begin() + i );
return t;
}
else
{
MemIndex t = openList[i];
openList.insert( openList.begin() + i, MemIndex( (char*)t.memory + (t.size / 2), t.size / 2 ) );
openList.insert( openList.begin() + i, MemIndex( t.memory, t.size / 2 ) );
openList.erase( openList.begin() + i + 2 );
return closeMemory( i, size_in_bytes );
}
// cast error: out of memory for supplied size... ?
return nullptr;
}
static int dynablstInit()
{
int nRet;
Mem = NULL;
MemIndex();
int nLen = MemEnd - (unsigned char *)0;
if ((Mem = (unsigned char *)malloc(nLen)) == NULL) return 1;
memset(Mem, 0, nLen); // blank all memory
MemIndex();
nRet = BurnLoadRom(RomV30 + 0x000001, 0, 2); if (nRet != 0) return 1;
nRet = BurnLoadRom(RomV30 + 0x000000, 1, 2); if (nRet != 0) return 1;
memcpy (RomV30+ 0xffff0, RomV30+ 0x3fff0, 0x10 ); /* start vector */
irem_cpu_decrypt(0,bomberman_decryption_table,RomV30,DecrRomV30,0x7ffff );
nRet = BurnLoadRom(RomZ80 + 0x000000, 3, 1); if (nRet != 0) return 1;
unsigned char *sprTmp = (unsigned char *) malloc (0x100000);
if ( sprTmp == 0 )
{
return 1;
}
for (int i = 0; i < 4; i++)
{
nRet = BurnLoadRom(sprTmp + (0x40000*i), 3+i, 1);
if (nRet != 0)
{
return 1;
}
}
GfxDecode(0x2000, 4, 16, 16, SpritePlaneOffsets, SpriteXOffsets, SpriteYOffsets, 0x100, sprTmp, RomSpr);
GfxDecode(0x8000, 4, 8, 8, TilePlaneOffsets, TileXOffsets, TileYOffsets, 0x40, sprTmp, RomTile);
free(sprTmp);
{
unsigned int cpu_types[] = { 8 };
VezInit(1, &cpu_types[0]);
VezOpen(0);
VezMapArea(0x00000, 0x7ffff, 0, RomV30 + 0x00000); // CPU 0 ROM
VezMapArea(0x00000, 0x7ffff, 2, DecrRomV30,RomV30 + 0x00000 );
VezMapArea(0xa0000, 0xa3fff, 0, RamV30);
VezMapArea(0xa0000, 0xa3fff, 1, RamV30);
VezMapArea(0xd0000, 0xdffff, 0, RamVideo); //??
VezMapArea(0xd0000, 0xdffff, 1, RamVideo);
VezMapArea(0xe0000, 0xe03ff, 0, RamPal); // palette
VezMapArea(0xe0000, 0xe03ff, 1, RamPal);
// VezMapArea(0xffff0, 0xfffff, 0, RomV30 + 0x3fff0); // start vector
VezSetReadHandler(m90ReadByte);
VezSetWriteHandler(m90WriteByte);
VezSetReadPort(m90ReadPort);
VezSetWritePort(m90WritePort);
VezClose();
}
DrvDoReset();
return 0;
}
static int DrvInit()
{
int nLen;
BurnSetRefreshRate(CAVE_REFRESHRATE);
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (unsigned char *)0;
if ((Mem = (unsigned char *)malloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
EEPROMInit(1024, 16); // EEPROM has 1024 bits, uses 16-bit words
// Load the roms into memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x200000, 0x207FFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x300000, 0x307FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x400000, 0x403FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x404000, 0x407FFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x500000, 0x50FFFF, SM_RAM);
SekMapMemory(CavePalSrc, 0xA08000, 0xA08FFF, SM_RAM); // Palette RAM
SekSetReadWordHandler(0, donpachiReadWord);
SekSetReadByteHandler(0, donpachiReadByte);
SekSetWriteWordHandler(0, donpachiWriteWord);
SekSetWriteByteHandler(0, donpachiWriteByte);
SekClose();
}
CavePalInit();
CaveTileInit();
CaveSpriteInit(0, 0x0800000);
CaveTileInitLayer(0, 0x200000, 8, 0x4000);
CaveTileInitLayer(1, 0x200000, 8, 0x4000);
CaveTileInitLayer(2, 0x080000, 8, 0x4000);
MSM6295Init(0, 8000, 50.0, 0);
MSM6295Init(1, 16000, 50.0, 0);
MSM6295SampleData[0][0] = MSM6295ROM + 0x100000;
MSM6295SampleInfo[0][0] = MSM6295ROM + 0x100000 + 0x0000;
MSM6295SampleData[0][1] = MSM6295ROM + 0x100000;
MSM6295SampleInfo[0][1] = MSM6295ROM + 0x100000 + 0x0100;
MSM6295SampleData[0][2] = MSM6295ROM + 0x100000;
MSM6295SampleInfo[0][2] = MSM6295ROM + 0x100000 + 0x0200;
MSM6295SampleData[0][3] = MSM6295ROM + 0x100000;
MSM6295SampleInfo[0][3] = MSM6295ROM + 0x100000 + 0x0300;
bDrawScreen = true;
#if defined FBA_DEBUG && defined USE_SPEEDHACKS
bprintf(PRINT_IMPORTANT, _T(" * Using speed-hacks (detecting idle loops).\n"));
#endif
DrvDoReset(); // Reset machine
return 0;
}
static INT32 DrvInit()
{
if (bBurnUseASMCPUEmulation) {
bUseAsm68KCoreOldValue = bBurnUseASMCPUEmulation;
bBurnUseASMCPUEmulation = false;
}
INT32 nLen;
// bToaRotateScreen = true;
BurnSetRefreshRate(REFRESHRATE);
nBCU2ROMSize = 0x080000;
nFCU2ROMSize = 0x080000;
// Find out how much memory is needed
AllMem = NULL;
MemIndex();
nLen = MemEnd - (UINT8 *)0;
if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(AllMem, 0, nLen);
MemIndex();
if (BurnLoadRom(Drv68KROM + 0x000001, 0, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x000000, 1, 2)) return 1;
if (BurnLoadRom(DrvZ80ROM, 2, 1)) return 1;
ToaLoadTiles(BCU2ROM, 5, nBCU2ROMSize);
ToaLoadTiles(FCU2ROM, 9, nFCU2ROMSize);
{
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x03FFFF, SM_ROM);
SekMapMemory(DrvPalRAM, 0x404000, 0x4047FF, SM_RAM);
SekMapMemory(DrvPalRAM2, 0x406000, 0x4067FF, SM_RAM);
SekMapMemory(Drv68KRAM, 0xc00000, 0xc03FFF, SM_RAM);
SekSetReadWordHandler(0, demonwldReadWord);
SekSetReadByteHandler(0, demonwldReadByte);
SekSetWriteWordHandler(0, demonwldWriteWord);
SekSetWriteByteHandler(0, demonwldWriteByte);
SekMapHandler(1, 0x600000, 0x600FFF, SM_RAM);
SekSetReadByteHandler(1, toaplan1ReadByteZ80RAM);
SekSetReadWordHandler(1, toaplan1ReadWordZ80RAM);
SekSetWriteByteHandler(1, toaplan1WriteByteZ80RAM);
SekSetWriteWordHandler(1, toaplan1WriteWordZ80RAM);
SekClose();
ZetInit(0);
ZetOpen(0);
ZetMapArea(0x0000, 0x7fff, 0, DrvZ80ROM);
ZetMapArea(0x0000, 0x7fff, 2, DrvZ80ROM);
ZetMapArea(0x8000, 0xffff, 0, DrvShareRAM);
ZetMapArea(0x8000, 0xffff, 1, DrvShareRAM);
ZetMapArea(0x8000, 0xffff, 2, DrvShareRAM);
ZetSetOutHandler(demonwld_sound_write_port);
ZetSetInHandler(demonwld_sound_read_port);
ZetMemEnd();
ZetClose();
}
ToaInitBCU2();
nToaPalLen = nColCount;
ToaPalSrc = DrvPalRAM;
ToaPalSrc2 = DrvPalRAM2;
ToaPalInit();
ToaOpaquePriority = 2;
BurnYM3812Init(28000000 / 8, &toaplan1FMIRQHandler, &toaplan1SynchroniseStream, 0);
BurnTimerAttachZetYM3812(28000000 / 8);
BurnYM3812SetRoute(BURN_SND_YM3812_ROUTE, 1.00, BURN_SND_ROUTE_BOTH);
bDrawScreen = true;
DrvDoReset();
return 0;
}
static INT32 DrvInit()
{
INT32 nLen;
#ifdef DRIVER_ROTATION
bToaRotateScreen = false;
#endif
nGP9001ROMSize[0] = 0x800000;
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (UINT8 *)0;
if ((Mem = (UINT8 *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
// Load the roms into memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
SekMapMemory(Rom01, 0x000000, 0x07FFFF, MAP_ROM);
SekMapMemory(Ram01, 0x100000, 0x103FFF, MAP_RAM);
SekMapMemory(RamSnd, 0x104000, 0x1040FF, MAP_RAM);
SekMapMemory(RamPal, 0x400000, 0x400FFF, MAP_RAM);
SekSetReadWordHandler(0, kbash2ReadWord);
SekSetReadByteHandler(0, kbash2ReadByte);
SekSetWriteWordHandler(0, kbash2WriteWord);
SekSetWriteByteHandler(0, kbash2WriteByte);
SekClose();
}
MSM6295Init(0, 1000000 / 132, 1);
MSM6295Init(1, 1000000 / 132, 1);
MSM6295SetRoute(0, 1.00, BURN_SND_ROUTE_BOTH);
MSM6295SetRoute(1, 1.00, BURN_SND_ROUTE_BOTH);
nSpriteYOffset = 0x0011;
nLayer0XOffset = -0x01D6;
nLayer1XOffset = -0x01D8;
nLayer2XOffset = -0x01DA;
ToaInitGP9001();
nToaPalLen = nColCount;
ToaPalSrc = RamPal;
ToaPalInit();
bDrawScreen = true;
DrvDoReset(); // Reset machine
return 0;
}
int rastanInit()
{
int nRet=0; int nLen=0;
//--------------Allocate Memory-----------------
Mem=NULL;
MemIndex();
nLen=MemEnd-(unsigned char *)0;
Mem=(unsigned char *)malloc(nLen);
if (Mem==NULL)
return 1;
memset(Mem,0,nLen); // blank all memory
MemIndex(); // Index the allocated memory
//--------------- Load Roms -------------------
nRet=LoadRoms();
if (nRet!=0)
return 1; // Load the roms into memory
taito_pal=rastan_pal;
init_taito_gfx();
// Map in memory:
// ----------------- Cpu 1 ------------------------
SekInit(0, 0x68000); // Allocate 1 68000
SekOpen(0);
SekMapMemory( Rom ,0x000000,0x05ffff,SM_ROM); // 68000 Rom
SekMapMemory(rastan_ram,0x10c000,0x10ffff,SM_RAM); //0x4000
SekMapMemory(rastan_src_pal,0x200000,0x200fff,SM_RAM);
SekMapMemory(rastan_ram+0x4000,0x350008,0x350010,SM_RAM);
SekMapMemory(PC090OJ_spritectrl,0x380000,0x380003,SM_RAM);
SekMapMemory(rastan_ram+0x4012,0x3c0000,0x3c0003,SM_WRITE);
SekMapMemory(PC080SN_word_0,0xc00000,0xc0ffff,SM_RAM);
SekMapMemory(PC080SN_ctrl_word_0,0xc50000,0xc50003,SM_WRITE);
SekMapMemory(PC090OJ_word_0,0xd00000,0xd03fff,SM_RAM);
SekSetReadWordHandler(0, rastanReadWord);
SekSetWriteWordHandler(0, rastanWriteWord);
SekSetReadByteHandler(0, rastanReadByte);
SekSetWriteByteHandler(0, rastanWriteByte);
// ------------------------------------------------
SekClose();
ZetInit(1);
ZetOpen(0);
ZetSetReadHandler(RastanZ80Read);
ZetSetWriteHandler(RastanZ80Write);
ZetMapArea (0x0000,0x3FFF,0,z80_rom);
ZetMapArea (0x0000,0x3FFF,2,z80_rom);
ZetMapArea (0x4000,0x7FFF,0,z80_rom+0x4000);
ZetMapArea (0x4000,0x7FFF,2,z80_rom+0x4000);
ZetMapArea (0x8000,0x8FFF,0,z80_ram);
ZetMapArea (0x8000,0x8FFF,1,z80_ram);
ZetMemEnd();
ZetMemCallback(0x9000, 0xa001, 0); // Read
ZetMemCallback(0x9000, 0xa001, 1); // Write
ZetReset();
ZetClose();
//-------------------------------------------------
BurnYM2151Init(4000000, 50.0);
BurnYM2151SetIrqHandler(&RastanYM2151IRQHandler);
BurnYM2151SetPortHandler(&rastanBankSwitch);
nCurrentBank=0; // bank number 0 or 1
MSM5205Init(0,8000, 60,1);
drvDoReset();
return 0;
}
static INT32 DrvInit()
{
INT32 nLen;
Rallybik = 1;
// bToaRotateScreen = true;
BurnSetRefreshRate(REFRESHRATE);
nBCU2ROMSize = 0x080000;
nFCU2ROMSize = 0x080000;
// Find out how much memory is needed
AllMem = NULL;
MemIndex();
nLen = MemEnd - (UINT8 *)0;
if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(AllMem, 0, nLen);
MemIndex();
if (BurnLoadRom(Drv68KROM + 0x000001, 0, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x000000, 1, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x040001, 2, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x040000, 3, 2)) return 1;
if (BurnLoadRom(DrvZ80ROM, 4, 1)) return 1;
ToaLoadTiles(BCU2ROM, 5, nBCU2ROMSize);
// ToaLoadTiles(FCU2ROM, 9, nFCU2ROMSize);
if (BurnLoadRom(FCU2ROM + 0x000000, 9, 1)) return 1;
if (BurnLoadRom(FCU2ROM + 0x010000, 10, 1)) return 1;
if (BurnLoadRom(FCU2ROM + 0x020000, 11, 1)) return 1;
if (BurnLoadRom(FCU2ROM + 0x030000, 12, 1)) return 1;
DrvSpriteDecode();
{
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x00FFFF, SM_ROM);
SekMapMemory(Drv68KROM + 0x40000, 0x040000, 0x07FFFF, SM_ROM);
SekMapMemory(Drv68KRAM, 0x080000, 0x083FFF, SM_RAM);
SekMapMemory(DrvSprRAM, 0x0c0000, 0x0C0FFF, SM_RAM);
SekMapMemory(DrvPalRAM, 0x144000, 0x1447FF, SM_RAM);
SekMapMemory(DrvPalRAM2, 0x146000, 0x1467FF, SM_RAM);
SekSetReadWordHandler(0, rallybikReadWord);
SekSetReadByteHandler(0, rallybikReadByte);
SekSetWriteWordHandler(0, rallybikWriteWord);
SekSetWriteByteHandler(0, rallybikWriteByte);
SekMapHandler(1, 0x180000, 0x180FFF, SM_RAM);
SekSetReadByteHandler(1, toaplan1ReadByteZ80RAM);
SekSetReadWordHandler(1, toaplan1ReadWordZ80RAM);
SekSetWriteByteHandler(1, toaplan1WriteByteZ80RAM);
SekSetWriteWordHandler(1, toaplan1WriteWordZ80RAM);
SekClose();
ZetInit(0);
ZetOpen(0);
ZetMapArea(0x0000, 0x7fff, 0, DrvZ80ROM);
ZetMapArea(0x0000, 0x7fff, 2, DrvZ80ROM);
ZetMapArea(0x8000, 0xffff, 0, DrvShareRAM);
ZetMapArea(0x8000, 0xffff, 1, DrvShareRAM);
ZetMapArea(0x8000, 0xffff, 2, DrvShareRAM);
ZetSetOutHandler(rallybik_sound_write_port);
ZetSetInHandler(rallybik_sound_read_port);
ZetMemEnd();
ZetClose();
}
nLayer0XOffset = 0x0d + 6;
nLayer1XOffset = 0x0d + 4;
nLayer2XOffset = 0x0d + 2;
nLayer3XOffset = 0x0d + 0;
nLayer0YOffset = nLayer1YOffset = nLayer2YOffset = nLayer3YOffset = 0x111;
ToaInitBCU2();
ToaOpaquePriority = 0;
nToaPalLen = nColCount;
ToaPalSrc = DrvPalRAM;
ToaPalSrc2 = DrvPalRAM2;
ToaPalInit();
BurnYM3812Init(28000000 / 8, &toaplan1FMIRQHandler, &toaplan1SynchroniseStream, 0);
BurnTimerAttachZetYM3812(28000000 / 8);
bDrawScreen = true;
DrvDoReset();
return 0;
}
static INT32 DrvInit()
{
AllMem = NULL;
MemIndex();
INT32 nLen = MemEnd - (UINT8 *)0;
if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
memset(AllMem, 0, nLen);
MemIndex();
{
if (BurnLoadRom(DrvZ80ROM0 + 0x000000, 0, 1)) return 1;
memmove (DrvZ80ROM0 + 0x10000, DrvZ80ROM0 + 0x08000, 0x78000);
if (BurnLoadRom(DrvZ80ROM1 + 0x000000, 1, 1)) return 1;
if (BurnLoadRom(DrvGfxROM0 + 0x000000, 2, 1)) return 1;
memcpy (DrvSndROM + 0x000000, DrvGfxROM0 + 0x000000, 0x020000);
memcpy (DrvSndROM + 0x040000, DrvGfxROM0 + 0x000000, 0x020000);
memcpy (DrvSndROM + 0x080000, DrvGfxROM0 + 0x000000, 0x020000);
memcpy (DrvSndROM + 0x0c0000, DrvGfxROM0 + 0x000000, 0x020000);
memcpy (DrvSndROM + 0x020000, DrvGfxROM0 + 0x000000, 0x020000);
memcpy (DrvSndROM + 0x060000, DrvGfxROM0 + 0x020000, 0x020000);
memcpy (DrvSndROM + 0x0a0000, DrvGfxROM0 + 0x040000, 0x020000);
memcpy (DrvSndROM + 0x0e0000, DrvGfxROM0 + 0x060000, 0x020000);
if (BurnLoadRom(DrvGfxROM0 + 0x000000, 3, 1)) return 1;
if (BurnLoadRom(DrvGfxROM0 + 0x020000, 4, 1)) return 1;
if (BurnLoadRom(DrvGfxROM0 + 0x040000, 5, 1)) return 1;
if (BurnLoadRom(DrvGfxROM0 + 0x060000, 6, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x000000, 7, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x020000, 8, 1)) return 1;
DrvGfxDecode();
}
ZetInit(0);
ZetOpen(0);
ZetMapArea(0x0000, 0x7fff, 0, DrvZ80ROM0);
ZetMapArea(0x0000, 0x7fff, 2, DrvZ80ROM0);
ZetMapArea(0x8000, 0x87ff, 0, DrvPalRAM);
// ZetMapArea(0x8000, 0x87ff, 1, DrvPalRAM);
ZetMapArea(0x8000, 0x87ff, 2, DrvPalRAM);
ZetMapArea(0x8800, 0x8fff, 0, DrvAttrRAM);
ZetMapArea(0x8800, 0x8fff, 1, DrvAttrRAM);
ZetMapArea(0x8800, 0x8fff, 2, DrvAttrRAM);
ZetMapArea(0xa000, 0xbfff, 0, DrvZ80RAM0);
ZetMapArea(0xa000, 0xbfff, 1, DrvZ80RAM0);
ZetMapArea(0xa000, 0xbfff, 2, DrvZ80RAM0);
ZetSetWriteHandler(speedspn_main_write);
ZetSetOutHandler(speedspn_main_write_port);
ZetSetInHandler(speedspn_main_read_port);
ZetClose();
ZetInit(1);
ZetOpen(1);
ZetMapArea(0x0000, 0x7fff, 0, DrvZ80ROM1);
ZetMapArea(0x0000, 0x7fff, 2, DrvZ80ROM1);
ZetMapArea(0x8000, 0x87ff, 0, DrvZ80RAM1);
ZetMapArea(0x8000, 0x87ff, 1, DrvZ80RAM1);
ZetMapArea(0x8000, 0x87ff, 2, DrvZ80RAM1);
ZetSetWriteHandler(speedspn_sound_write);
ZetSetReadHandler(speedspn_sound_read);
ZetClose();
MSM6295Init(0, 1122000 / 132, 0);
MSM6295SetRoute(0, 1.00, BURN_SND_ROUTE_BOTH);
DrvDoReset();
GenericTilesInit();
return 0;
}
static INT32 DrvInit()
{
INT32 nLen;
#ifdef DRIVER_ROTATION
bToaRotateScreen = false;
#endif
nGP9001ROMSize[0] = 0x800000;
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (UINT8 *)0;
if ((Mem = (UINT8 *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
// Load the roms into memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
SekMapMemory(Rom01, 0x000000, 0x07FFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x103FFF, MAP_RAM);
SekMapMemory(RamPal, 0x400000, 0x400FFF, MAP_RAM); // Palette RAM
SekSetReadWordHandler(0, kbashReadWord);
SekSetReadByteHandler(0, kbashReadByte);
SekSetWriteWordHandler(0, kbashWriteWord);
SekSetWriteByteHandler(0, kbashWriteByte);
SekClose();
VezInit(0, V25_TYPE, 16000000 /*before divider*/);
VezOpen(0);
VezMapArea(0x00000, 0x007ff, 0, ShareRAM);
VezMapArea(0x00000, 0x007ff, 1, ShareRAM);
VezMapArea(0x00000, 0x007ff, 2, ShareRAM);
for (INT32 i = 0x80000; i < 0x100000; i += 0x8000) {
VezMapArea(i, i + 0x7fff, 0, Rom02);
VezMapArea(i, i + 0x7fff, 1, Rom02);
VezMapArea(i, i + 0x7fff, 2, Rom02);
}
VezSetReadHandler(kbash_v25_read);
VezSetWriteHandler(kbash_v25_write);
VezSetReadPort(kbash_v25_read_port);
VezSetDecode(nitro_decryption_table);
VezClose();
}
BurnYM2151Init(3375000);
BurnYM2151SetAllRoutes(0.50, BURN_SND_ROUTE_BOTH);
MSM6295Init(0, 1000000 / 132, 1);
MSM6295SetRoute(0, 0.50, BURN_SND_ROUTE_BOTH);
nSpriteYOffset = 0x0011;
nLayer0XOffset = -0x01D6;
nLayer1XOffset = -0x01D8;
nLayer2XOffset = -0x01DA;
ToaInitGP9001();
nToaPalLen = nColCount;
ToaPalSrc = RamPal;
ToaPalInit();
bDrawScreen = true;
DrvDoReset(); // Reset machine
return 0;
}
static int DrvInit()
{
AllMem = NULL;
MemIndex();
int nLen = MemEnd - (unsigned char *)0;
if ((AllMem = (unsigned char *)malloc(nLen)) == NULL) return 1;
memset(AllMem, 0, nLen);
MemIndex();
{
if (BurnLoadRom(DrvM6809ROM + 0x08000, 0, 1)) return 1;
memcpy (DrvM6809ROM + 0x4000, DrvM6809ROM + 0xc000, 0x4000);
if (BurnLoadRom(DrvM6809ROM + 0x0c000, 1, 1)) return 1;
if (BurnLoadRom(DrvZ80ROM + 0x00000, 2, 1)) return 1;
if (BurnLoadRom(DrvGfxROM0 + 0x00000, 3, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x00000, 4, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x08000, 5, 1)) return 1;
if (BurnLoadRom(DrvColPROM + 0x00000, 6, 1)) return 1;
if (BurnLoadRom(DrvColPROM + 0x00100, 7, 1)) return 1;
if (BurnLoadRom(DrvColPROM + 0x00200, 8, 1)) return 1;
if (BurnLoadRom(DrvColPROM + 0x00300, 9, 1)) return 1;
if (BurnLoadRom(DrvColPROM + 0x00400, 10, 1)) return 1;
DrvPaletteInit();
DrvGfxDecode();
}
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvColRAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x0800, 0x0fff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x1000, 0x1fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x04000, 0x4000, 0xffff, M6809_ROM);
M6809SetWriteByteHandler(scotrsht_main_write);
M6809SetReadByteHandler(scotrsht_main_read);
M6809Close();
ZetInit(1);
ZetOpen(0);
ZetMapArea(0x0000, 0x3fff, 0, DrvZ80ROM);
ZetMapArea(0x0000, 0x3fff, 2, DrvZ80ROM);
ZetMapArea(0x4000, 0x43ff, 0, DrvZ80RAM);
ZetMapArea(0x4000, 0x43ff, 1, DrvZ80RAM);
ZetMapArea(0x4000, 0x43ff, 2, DrvZ80RAM);
ZetSetReadHandler(scotrsht_sound_read);
ZetSetOutHandler(scotrsht_sound_out);
ZetSetInHandler(scotrsht_sound_in);
ZetMemEnd();
ZetClose();
BurnYM2203Init(1, 3072000, NULL, DrvSynchroniseStream, DrvGetTime, 0);
BurnTimerAttachZet(3072000);
DrvDoReset();
GenericTilesInit();
return 0;
}
static int DrvInit()
{
int nRet;
Mem = NULL;
MemIndex();
int nLen = MemEnd - (unsigned char *)0;
if ((Mem = (unsigned char *)malloc(nLen)) == NULL) return 1;
memset(Mem, 0, nLen); // blank all memory
MemIndex();
nRet = BurnLoadRom(Rom68K + 0x000000, 0, 2); if (nRet != 0) return 1;
nRet = BurnLoadRom(Rom68K + 0x000001, 1, 2); if (nRet != 0) return 1;
BurnLoadRom(RomSpr + 0, 2, 2);
BurnLoadRom(RomSpr + 1, 3, 2);
// decode sprites
unsigned char * tmp = RomSpr;
for (int i=0; i<(0x400000/4); i++) {
unsigned char c = tmp[2];
tmp[2] = tmp[1];
tmp[1] = c;
tmp += 4;
}
BurnLoadRom(RomBg, 4, 1);
BurnLoadRom(MSM6295ROM + 0x00000, 5, 1);
BurnLoadRom(MSM6295ROM + 0x80000, 6, 1);
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom68K, 0x000000, 0x0FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram68K, 0x100000, 0x10FFFF, SM_RAM); // CPU 0 RAM
SekMapMemory((unsigned char *)RamPal,
0x200000, 0x200FFF, SM_ROM); // palette
SekMapMemory((unsigned char *)RamSpr0,
0x240000, 0x240FFF, SM_RAM); // sprites 0
SekMapMemory((unsigned char *)RamSpr1,
0x280000, 0x280FFF, SM_RAM); // sprites 1
SekMapMemory((unsigned char *)RamBg,
0x2C0000, 0x2C0FFF, SM_RAM); // back ground
SekMapMemory(Ram68K+0x10000,0x8C0000, 0x8CFFFF, SM_RAM); // not used?
SekMapHandler(1, 0x200000, 0x200FFF, SM_WRITE);
SekSetReadWordHandler(0, k1945iiiReadWord);
// SekSetReadByteHandler(0, k1945iiiReadByte);
SekSetWriteWordHandler(0, k1945iiiWriteWord);
SekSetWriteByteHandler(0, k1945iiiWriteByte);
// SekSetWriteByteHandler(1, k1945iiiWriteBytePalette);
SekSetWriteWordHandler(1, k1945iiiWriteWordPalette);
SekClose();
}
MSM6295Init(0, 7500, 80, 1);
MSM6295Init(1, 7500, 80, 1);
DrvDoReset();
return 0;
}
static int drvInit()
{
int nLen;
#ifdef DRIVER_ROTATION
bToaRotateScreen = true;
#endif
nGP9001ROMSize[0] = 0x01000000;
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (unsigned char*)0;
if ((Mem = (unsigned char*)malloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // Zero memory
MemIndex(); // Index the allocated memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x1FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram02, 0x208000, 0x20FFFF, SM_RAM);
Map68KTextROM(true);
SekSetReadWordHandler(0, batriderReadWord);
SekSetReadByteHandler(0, batriderReadByte);
SekSetWriteWordHandler(0, batriderWriteWord);
SekSetWriteByteHandler(0, batriderWriteByte);
SekMapHandler(1, 0x400000, 0x400400, SM_RAM); // GP9001 addresses
SekSetReadWordHandler(1, batriderReadWordGP9001);
SekSetWriteWordHandler(1, batriderWriteWordGP9001);
SekMapHandler(2, 0x300000, 0x37FFFF, SM_ROM); // Z80 ROM
SekSetReadByteHandler(2, batriderReadByteZ80ROM);
SekSetReadWordHandler(2, batriderReadWordZ80ROM);
SekClose();
}
nSpriteYOffset = 0x0001;
nLayer0XOffset = -0x01D6;
nLayer1XOffset = -0x01D8;
nLayer2XOffset = -0x01DA;
ToaInitGP9001();
nExtraTXOffset = 0x2C;
ToaExtraTextInit();
drvZInit(); // Initialize Z80
BurnYM2151Init(32000000 / 8, 50.0);
MSM6295Init(0, 32000000 / 10 / 132, 50.0, 1);
MSM6295Init(1, 32000000 / 10 / 165, 50.0, 1);
nToaPalLen = nColCount;
ToaPalSrc = RamPal;
ToaPalInit();
nTextROMStatus = -1;
bDrawScreen = true;
#if defined FBA_DEBUG && defined USE_SPEEDHACKS
bprintf(PRINT_IMPORTANT, _T(" * Using speed-hacks (detecting idle loops).\n"));
#endif
drvDoReset(); // Reset machine
return 0;
}
int twinhawkInit()
{
int nRet=0; int nLen=0;
//--------------Allocate Memory-----------------
Mem=NULL;
MemIndex();
nLen=MemEnd-(unsigned char *)0;
Mem=(unsigned char *)malloc(nLen);
if (Mem==NULL)
return 1;
memset(Mem,0,nLen); // blank all memory
MemIndex(); // Index the allocated memory
//--------------- Load Roms -------------------
nRet=LoadRoms();
if (nRet!=0)
return 1; // Load the roms into memory
// Map in memory:
// ----------------- Cpu 1 68k ------------------------
SekInit(0, 0x68000); // Allocate 1 68000
SekOpen(0);
SekMapMemory( Rom ,0x000000,0x3ffff,SM_ROM); // 68000 Rom
SekMapMemory(twinhawk_src_pal,0xb00000,0xb00FFF,SM_RAM);
SekMapMemory(sysbvidattr,0xd00000,0xd00fff,SM_RAM);
SekMapMemory(sysbvidram,0xe00000,0xe03fff,SM_RAM);
SekMapMemory(twinhawk_ram,0xf00000,0xf03fff,SM_RAM);
SekSetReadWordHandler(0, twinhawkReadWord);
SekSetWriteWordHandler(0, twinhawkWriteWord);
SekSetReadByteHandler(0, twinhawkReadByte);
SekSetWriteByteHandler(0, twinhawkWriteByte);
SekClose();
// ------------------------------------------------
// ----------------- Cpu 2 Z80 ------------------------
ZetInit(1);
ZetOpen(0);
ZetSetReadHandler(twinhawkZ80Read);
ZetSetWriteHandler(twinhawkZ80Write);
ZetMapArea (0x0000,0x3FFF,0,z80_rom);
ZetMapArea (0x0000,0x3FFF,2,z80_rom);
// ZetMapArea (0x4000,0x7FFF,0,z80_rom+0x4000);
// ZetMapArea (0x4000,0x7FFF,2,z80_rom+0x4000);
ZetMapArea (0xc000,0xdfff,0,z80_ram);
ZetMapArea (0xc000,0xdfff,2,z80_ram);
ZetMapArea (0xc000,0xdfff,1,z80_ram);
ZetMemEnd();
ZetMemCallback(0xe000, 0xFFFF, 0); // Read
ZetMemCallback(0xe000, 0xFFFF, 1); // Write
ZetReset();
ZetClose();
//-------------------------------------------------
//-------- sound stuff ----------------------------
//---------- YM2151 Setup ----------------------
BurnYM2151Init(4000000, 50.0);
BurnYM2151SetIrqHandler(&twinhawkYM2151IRQHandler);
nCurrentBank=-1;
//--------------------------------------------------
// ------- GFX Init -------------------
taito_pal=twinhawk_pal;
SysXInit(0);
drvDoReset();
return 0;
}
static int CyvernInit()
{
int nRet = 0, nLen;
BurnSetRefreshRate(59.5971);
// Allocate and Blank all required memory
Mem = NULL;
MemIndex();
nLen = MemEnd - (unsigned char *)0;
if ((Mem = (unsigned char *)malloc(nLen)) == NULL) return 1;
memset(Mem, 0, nLen);
MemIndex();
DrvTempRom = (unsigned char *)malloc(0x800000);
// Load BIOS Rom
nRet = BurnLoadRom(DrvBiosRom + 0x000000, 0, 1); if (nRet != 0) return 1;
be_to_le(DrvBiosRom, 0x00080000);
// Load Program Rom
nRet = BurnLoadRom(DrvPrgRom + 0x000000, 1, 2); if (nRet != 0) return 1;
nRet = BurnLoadRom(DrvPrgRom + 0x000001, 2, 2); if (nRet != 0) return 1;
be_to_le(DrvPrgRom, 0x00200000);
free(DrvTempRom);
// Setup the 68000 emulation
Sh2Init(1);
Sh2Open(0);
Sh2MapMemory(DrvBiosRom , 0x00000000, 0x0007ffff, SM_ROM);
Sh2MapMemory(DrvSpriteRam , 0x02000000, 0x02003fff, SM_RAM);
Sh2MapMemory(DrvSpriteRegs , 0x02100000, 0x0210003f, SM_RAM);
Sh2MapMemory(DrvTileRegs , 0x02400000, 0x0240007f, SM_RAM);
Sh2MapMemory(DrvTileARam , 0x02500000, 0x02503fff, SM_RAM);
Sh2MapMemory(DrvTileBRam , 0x02504000, 0x02507fff, SM_RAM);
Sh2MapMemory(DrvTileLineRam , 0x02600000, 0x02607fff, SM_RAM);
Sh2MapMemory(DrvPaletteRegs , 0x02a00000, 0x02a0001f, SM_RAM);
Sh2MapMemory(DrvPaletteRam , 0x02a40000, 0x02a5ffff, SM_RAM);
Sh2MapMemory(DrvPrgRom , 0x04000000, 0x041fffff, SM_ROM);
Sh2MapMemory(DrvTileBTilesRam , 0x04800000, 0x0483ffff, SM_RAM);
Sh2MapMemory(DrvPrgRam , 0x06000000, 0x06ffffff, SM_RAM);
// Sh2MapMemory(DrvPrgRam , 0x06000000, 0x06ffffff, SM_WRITE);
Sh2MapMemory(DrvCacheRam , 0xc0000000, 0xc0000fff, SM_RAM);
// Sh2MapHandler(1 , 0x06000028, 0x0600002b, SM_READ);
Sh2SetReadByteHandler (0, CyvernReadByte);
Sh2SetReadWordHandler (0, CyvernReadWord);
Sh2SetReadLongHandler (0, CyvernReadLong);
Sh2SetWriteByteHandler(0, CyvernWriteByte);
Sh2SetWriteWordHandler(0, CyvernWriteWord);
Sh2SetWriteLongHandler(0, CyvernWriteLong);
// Sh2SetReadByteHandler (1, BiosSkipReadByte);
// Sh2SetReadWordHandler (1, BiosSkipReadWord);
// Sh2SetReadLongHandler (1, BiosSkipReadLong);
Sh2Close();
GenericTilesInit();
// Reset the driver
DrvDoReset();
return 0;
}
static int DrvInit()
{
int nLen;
#ifdef DRIVER_ROTATION
bToaRotateScreen = true;
#endif
nGP9001ROMSize[0] = 0x200000;
nGP9001ROMSize[1] = 0x400000;
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (unsigned char *)0;
if ((Mem = (unsigned char *)malloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
// Load the roms into memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x103FFF, SM_RAM);
SekMapMemory(RamPal, 0x400000, 0x400FFF, SM_RAM); // Palette RAM
SekSetReadWordHandler(0, dogyuunReadWord);
SekSetReadByteHandler(0, dogyuunReadByte);
SekSetWriteWordHandler(0, dogyuunWriteWord);
SekSetWriteByteHandler(0, dogyuunWriteByte);
SekClose();
VezInit(0, V25_TYPE, 12500000 /*before divider*/);
VezOpen(0);
for (int i = 0x80000; i < 0x100000; i += 0x8000) {
VezMapArea(i, i + 0x7fff, 0, ShareRAM);
VezMapArea(i, i + 0x7fff, 1, ShareRAM);
VezMapArea(i, i + 0x7fff, 2, ShareRAM);
}
VezSetReadHandler(dogyuun_v25_read);
VezSetWriteHandler(dogyuun_v25_write);
VezSetReadPort(dogyuun_v25_read_port);
VezSetDecode(nitro_decryption_table);
VezClose();
}
BurnYM2151Init(3375000, 50.0);
MSM6295Init(0, 1041667 / 132, 50.0, 1);
nSpriteXOffset = 0x0024;
nSpriteYOffset = 0x0001;
nLayer0XOffset = -0x01D6;
nLayer1XOffset = -0x01D8;
nLayer2XOffset = -0x01DA;
ToaInitGP9001(2);
nToaPalLen = nColCount;
ToaPalSrc = RamPal;
ToaPalInit();
bDrawScreen = true;
DrvDoReset(); // Reset machine
return 0;
}
static INT32 DrvInit()
{
BurnSetRefreshRate(60.00);
AllMem = NULL;
MemIndex();
INT32 nLen = MemEnd - (UINT8 *)0;
if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) return 1;
memset(AllMem, 0, nLen);
MemIndex();
{
if (BurnLoadRom(DrvZ80ROM + 0x00000, 0, 1)) return 1;
if (BurnLoadRom(DrvZ80ROM + 0x10000, 1, 1)) return 1;
if (BurnLoadRom(t5182ROM + 0x00000, 2, 1)) return 1;
if (BurnLoadRom(t5182ROM + 0x08000, 3, 1)) return 1;
if (BurnLoadRom(DrvGfxROM0 + 0x00000, 4, 1)) return 1;
if (BurnLoadRom(DrvGfxROM0 + 0x02000, 5, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x10000, 6, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x00000, 7, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x30000, 8, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x20000, 9, 1)) return 1;
if (BurnLoadRom(DrvGfxROM2 + 0x00000, 10, 1)) return 1;
if (BurnLoadRom(DrvGfxROM2 + 0x10000, 11, 1)) return 1;
if (BurnLoadRom(DrvGfxROM2 + 0x20000, 12, 1)) return 1;
if (BurnLoadRom(DrvGfxROM2 + 0x30000, 13, 1)) return 1;
if (BurnLoadRom(DrvGfxROM3 + 0x00000, 14, 1)) return 1;
if (BurnLoadRom(DrvGfxROM3 + 0x08000, 15, 1)) return 1;
if (BurnLoadRom(DrvGfxROM4 + 0x00000, 16, 1)) return 1;
if (BurnLoadRom(DrvGfxROM4 + 0x04000, 17, 1)) return 1;
if (BurnLoadRom(DrvColPROM + 0x00000, 18, 1)) return 1;
if (BurnLoadRom(DrvColPROM + 0x00100, 19, 1)) return 1;
if (BurnLoadRom(DrvColPROM + 0x00200, 20, 1)) return 1;
if (BurnLoadRom(DrvColPROM + 0x00300, 21, 1)) return 1;
decrypt_prg();
decrypt_gfx();
decrypt_snd();
DrvGfxDecode();
DrvPaletteInit();
}
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80ROMDec, 0x0000, 0x7fff, MAP_FETCHOP);
ZetMapMemory(DrvPalRAM, 0xd000, 0xd3ff, MAP_ROM);
ZetMapMemory(DrvScrollRAM, 0xd400, 0xd4ff, MAP_RAM);
ZetMapMemory(DrvVidRAM, 0xd800, 0xdfff, MAP_RAM);
ZetMapMemory(DrvZ80RAM, 0xe000, 0xefff, MAP_RAM);
ZetMapMemory(DrvSprRAM, 0xf000, 0xffff, MAP_RAM);
ZetSetWriteHandler(darkmist_main_write);
ZetSetReadHandler(darkmist_main_read);
ZetClose();
t5182Init(1, 14318180/4);
GenericTilesInit();
DrvDoReset();
return 0;
}
int SupermanInit()
{
int nRet= 0; int nLen = 0;
//--------------Allocate Memory-----------------
Mem = NULL;
MemIndex();
nLen = MemEnd - (unsigned char *)0;
Mem = (unsigned char *)malloc(nLen);
if (Mem == NULL)
return 1;
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
//--------------- Load Roms -------------------
nRet = LoadRoms();
if (nRet != 0)
return 1; // Load the roms into memory
// Map in memory:
// ----------------- Cpu 1 68k ------------------------
SekInit(0, 0x68000); // Allocate 1 68000
SekOpen(0);
SekMapMemory(Rom , 0x000000, 0x07ffff ,SM_ROM);
SekMapMemory(Superman_src_pal, 0xb00000, 0xb00fff, SM_RAM);
SekMapMemory(sysbvidattr , 0xd00000, 0xd00fff, SM_RAM);
SekMapMemory(sysbvidram , 0xe00000, 0xe03fff, SM_RAM);
SekMapMemory(Superman_ram , 0xf00000, 0xf03fff ,SM_RAM);
SekSetWriteWordHandler(0, SupermanWriteWord);
SekSetReadWordHandler(0, SupermanReadWord);
SekSetReadByteHandler(0, SupermanReadByte);
SekSetWriteByteHandler(0, SupermanWriteByte);
SekClose();
// ----------------- Cpu 2 Z80 ------------------------
ZetInit(1);
ZetSetReadHandler(SupermanZ80Read);
ZetSetWriteHandler(SupermanZ80Write);
ZetMapArea(0x0000, 0x3fff, 0, z80_rom);
ZetMapArea(0x0000, 0x3fff, 2, z80_rom);
ZetMapArea(0xc000, 0xdfff, 0, z80_ram);
ZetMapArea(0xc000, 0xdfff, 2, z80_ram);
ZetMapArea(0xc000, 0xdfff, 1, z80_ram);
ZetMemCallback(0xe000, 0xffff, 0);
ZetMemCallback(0xe000, 0xffff, 1);
ZetMemEnd();
ZetClose();
//-------------------------------------------------
//-------- sound stuff ----------------------------
nCurrentBank = -1;
int SupermanYM2610RomSize = 0x80000;
BurnYM2610Init(8000000, SupermanYM2610Rom, &SupermanYM2610RomSize, SupermanYM2610Rom, &SupermanYM2610RomSize, &SupermanFMIRQHandler, SupermanSynchroniseStream, SupermanGetTime);
BurnTimerAttachZet(4000000);
// ------- GFX Init -------------------
taito_pal=Superman_pal;
SysXInit(1);
SupermanDoReset();
return 0;
}
static INT32 DrvInit()
{
INT32 nLen;
#ifdef DRIVER_ROTATION
bToaRotateScreen = false;
#endif
nGP9001ROMSize[0] = 0x800000;
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (UINT8 *)0;
if ((Mem = (UINT8 *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
// Load the roms into memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x03FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x080000, 0x082FFF, SM_RAM);
SekMapMemory(RamPal, 0x0c0000, 0x0c0FFF, SM_RAM); // Palette RAM
SekSetReadWordHandler(0, tekipakiReadWord);
SekSetReadByteHandler(0, tekipakiReadByte);
SekSetWriteWordHandler(0, tekipakiWriteWord);
SekSetWriteByteHandler(0, tekipakiWriteByte);
SekClose();
}
nSpriteYOffset = 0x0011;
nLayer0XOffset = -0x01D6;
nLayer1XOffset = -0x01D8;
nLayer2XOffset = -0x01DA;
ToaInitGP9001();
nToaPalLen = nColCount;
ToaPalSrc = RamPal;
ToaPalInit();
BurnSampleInit(0);
BurnSampleSetAllRoutesAllSamples(1.00, BURN_SND_ROUTE_BOTH);
bDrawScreen = true;
DrvDoReset(); // Reset machine
return 0;
}
static int DrvInit(int (*LoadCallback)(), int type, int gfx_max, int gfx_min)
{
AllMem = NULL;
MemIndex(gfx_max - gfx_min);
int nLen = MemEnd - (unsigned char *)0;
if ((AllMem = (unsigned char *)malloc(nLen)) == NULL) return 1;
memset(AllMem, 0, nLen);
MemIndex(gfx_max - gfx_min);
{
if (LoadCallback) {
if (LoadCallback()) return 1;
}
BurnSwap32(DrvSh2ROM, 0x100000);
BurnSwapEndian(0x200000);
DrvGfxDecode(gfx_max - gfx_min);
graphics_min_max[0] = gfx_min;
graphics_min_max[1] = gfx_max;
}
if (type == 0)
{
Sh2Init(1);
Sh2Open(0);
Sh2MapMemory(DrvSh2ROM, 0x00000000, 0x000fffff, SM_ROM);
Sh2MapMemory(DrvSh2ROM + 0x100000, 0x02000000, 0x020fffff, SM_ROM);
Sh2MapMemory(DrvSprRAM, 0x03000000, 0x0300ffff, SM_RAM);
Sh2MapMemory(DrvPalRAM, 0x03040000, 0x0304ffff, SM_RAM);
Sh2MapMemory(DrvZoomRAM, 0x03050000, 0x0305ffff, SM_ROM);
Sh2MapMemory(DrvSh2RAM, 0x06000000, 0x060fffff, SM_RAM);
Sh2SetReadByteHandler (0, ps3v1_read_byte);
Sh2SetWriteByteHandler(0, ps3v1_write_byte);
Sh2SetWriteWordHandler(0, ps3v1_write_word);
Sh2SetWriteLongHandler(0, psx_write_long);
} else {
Sh2Init(1);
Sh2Open(0);
Sh2MapMemory(DrvSh2ROM, 0x00000000, 0x000fffff, SM_ROM);
Sh2MapMemory(DrvSprRAM, 0x04000000, 0x0400ffff, SM_RAM);
Sh2MapMemory(DrvPalRAM, 0x04040000, 0x0404ffff, SM_RAM);
Sh2MapMemory(DrvZoomRAM, 0x04050000, 0x0405ffff, SM_ROM);
Sh2MapMemory(DrvSh2ROM + 0x100000, 0x05000000, 0x0507ffff, SM_ROM);
Sh2MapMemory(DrvSh2RAM, 0x06000000, 0x060fffff, SM_RAM);
Sh2SetReadByteHandler (0, ps5_read_byte);
Sh2SetWriteByteHandler(0, ps5_write_byte);
Sh2SetWriteWordHandler(0, ps5_write_word);
Sh2SetWriteLongHandler(0, psx_write_long);
}
Sh2MapHandler(1, 0x06000000 | speedhack_address, 0x0600ffff | speedhack_address, SM_ROM);
Sh2SetReadByteHandler (1, hack_read_byte);
Sh2SetReadWordHandler (1, hack_read_word);
Sh2SetReadLongHandler (1, hack_read_long);
BurnYMF278BInit(0, DrvSndROM, &DrvIRQCallback, DrvSynchroniseStream);
BurnTimerAttachSh2(28636350);
EEPROMInit(&eeprom_interface_93C56);
PsikyoshVideoInit(gfx_max, gfx_min);
DrvDoReset();
return 0;
}
int TmntInit()
{
int nRet=0; int nLen=0;
// Find out how much memory is needed
Mem=NULL;
MemIndex();
nLen=MemEnd-(unsigned char *)0;
Mem=(unsigned char *)malloc(nLen);
if (Mem==NULL)
return 1;
memset(Mem,0,nLen); // blank all memory
MemIndex(); // Index the allocated memory
TmntZ80Rom=(unsigned char *)malloc(0x08000);
if (TmntZ80Rom==NULL) return 1;
memset(TmntZ80Rom,0x11,0x08000);
TmntZ80Ram=(unsigned char *)malloc(0x0800);
if (TmntZ80Ram==NULL) return 1;
memset(TmntZ80Ram,0x00,0x0800);
nRet=LoadRoms();
if (nRet!=0)
return 1; // Load the roms into memory
SekInit(0,0x68000); // Allocate 68000
SekOpen(0);
// Map in memory:
// ----------------- Cpu 1 ------------------------
SekMapMemory(Tmnt68KROM01, 0x000000,0x05FFFF, SM_ROM); // 68000 Rom
SekMapMemory(TmntRam06, 0x060000,0x063FFF, SM_RAM);
SekMapMemory(TmntRam08, 0x080000,0x080FFF, SM_ROM); // Write goes through handler
SekMapMemory(PriRam, 0x0c0000,0x0c00FF, SM_RAM);
SekMapMemory(TmntRam10, 0x100000,0x107FFF, SM_RAM);
SekMapMemory(K051960Ram, 0x140400,0x1407FF, SM_RAM);
SekSetReadWordHandler(0,TmntReadWord);
SekSetWriteWordHandler(0,TmntWriteWord);
SekSetReadByteHandler(0,TmntReadByte);
SekSetWriteByteHandler(0,TmntWriteByte);
// ------------------------------------------------
// SekReset();
SekClose();
// Setup the Z80 emulation
ZetInit(1);
ZetOpen(0);
ZetMapArea(0x0000, 0x7fff, 0, TmntZ80Rom);
ZetMapArea(0x0000, 0x7fff, 2, TmntZ80Rom);
ZetMapArea(0x8000, 0x87FF, 0, TmntZ80Ram);
ZetMapArea(0x8000, 0x87FF,1, TmntZ80Ram);
ZetMapArea(0x8000, 0x87FF, 2, TmntZ80Ram);
ZetMemEnd();
ZetSetInHandler(tmntZ80In);
ZetSetOutHandler(tmntZ80Out);
ZetSetReadHandler(tmntZ80Read);
ZetSetWriteHandler(tmntZ80Write);
// ZetReset();
ZetClose();
// sound stuff
// ym2151
BurnYM2151Init(3579545, 50.0);
BurnYM2151SetIrqHandler(&tmntYM2151IRQHandler);
// BurnYM2151Reset();
UPD7759Init(UPD7759_STANDARD_CLOCK, TmntSampleROM02);
bInt5=0;
GenericTilesInit();
TmntPalInit();
TmntReset();
return 0;
}
static INT32 DrvInit()
{
INT32 nLen;
// bToaRotateScreen = true;
BurnSetRefreshRate(REFRESHRATE);
nBCU2ROMSize = 0x080000;
nFCU2ROMSize = 0x080000;
// Find out how much memory is needed
AllMem = NULL;
MemIndex();
nLen = MemEnd - (UINT8 *)0;
if ((AllMem = (UINT8 *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(AllMem, 0, nLen);
MemIndex();
if (BurnLoadRom(Drv68KROM + 0x000001, 0, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x000000, 1, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x040001, 2, 2)) return 1;
if (BurnLoadRom(Drv68KROM + 0x040000, 3, 2)) return 1;
ToaLoadTiles(BCU2ROM, 4, nBCU2ROMSize);
ToaLoadTiles(FCU2ROM, 8, nFCU2ROMSize);
{
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07FFFF, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x0c0000, 0x0c3FFF, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x104000, 0x1047FF, MAP_RAM);
SekMapMemory(DrvPalRAM2, 0x106000, 0x1067FF, MAP_RAM);
SekSetReadWordHandler(0, samesameReadWord);
SekSetReadByteHandler(0, samesameReadByte);
SekSetWriteWordHandler(0, samesameWriteWord);
SekSetWriteByteHandler(0, samesameWriteByte);
SekClose();
}
ToaInitBCU2();
nToaPalLen = nColCount;
ToaPalSrc = DrvPalRAM;
ToaPalSrc2 = DrvPalRAM2;
ToaPalInit();
// BurnYM3812Init(28000000 / 8, &toaplan1FMIRQHandler, &toaplan1SynchroniseStream, 0);
// BurnYM3812SetRoute(BURN_SND_YM3812_ROUTE, 1.00, BURN_SND_ROUTE_BOTH);
#ifdef TOAPLAN_SOUND_SAMPLES_HACK
BurnUpdateProgress(0.0, _T("Loading samples..."), 0);
BurnSampleInit(0);
BurnSampleSetAllRoutesAllSamples(0.60, BURN_SND_ROUTE_BOTH);
#endif
bDrawScreen = true;
DrvDoReset();
return 0;
}
static INT32 DrvInit()
{
INT32 nLen;
#ifdef DRIVER_ROTATION
bToaRotateScreen = true;
#endif
BurnSetRefreshRate(REFRESHRATE);
nBCU2ROMSize = 0x080000;
nFCU2ROMSize = 0x080000;
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (UINT8 *)0;
if ((Mem = (UINT8 *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
// Load the roms into memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x03FFFF, SM_ROM); // 68K ROM
SekMapMemory(Ram01, 0x080000, 0x083FFF, SM_RAM); // 68K RAM
SekMapMemory(RamPal, 0x144000, 0x1447FF, SM_RAM); // BCU-2 palette RAM
SekMapMemory(RamPal2, 0x146000, 0x1467FF, SM_RAM); // FCU-2 palette RAM
SekSetReadWordHandler(0, truxtonReadWord);
SekSetReadByteHandler(0, truxtonReadByte);
SekSetWriteWordHandler(0, truxtonWriteWord);
SekSetWriteByteHandler(0, truxtonWriteByte);
SekMapHandler(1, 0x180000, 0x180FFF, SM_RAM); // Z80 RAM
SekSetReadByteHandler(1, toaplan1ReadByteZ80RAM);
SekSetReadWordHandler(1, toaplan1ReadWordZ80RAM);
SekSetWriteByteHandler(1, toaplan1WriteByteZ80RAM);
SekSetWriteWordHandler(1, toaplan1WriteWordZ80RAM);
SekClose();
}
ToaInitBCU2();
DrvZ80Init(); // Initialize Z80
nToaPalLen = nColCount;
ToaPalSrc = RamPal;
ToaPalSrc2 = RamPal2;
ToaPalInit();
BurnYM3812Init(28000000 / 8, &toaplan1FMIRQHandler, &toaplan1SynchroniseStream, 0);
BurnTimerAttachZetYM3812(28000000 / 8);
BurnYM3812SetRoute(BURN_SND_YM3812_ROUTE, 1.00, BURN_SND_ROUTE_BOTH);
bDrawScreen = true;
DrvDoReset(); // Reset machine
return 0;
}
static int DrvInit()
{
int nLen;
#ifdef DRIVER_ROTATION
bToaRotateScreen = true;
#endif
nGP9001ROMSize[0] = 0x400000;
nGP9001ROMSize[1] = 0x200000;
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (unsigned char *)0;
if ((Mem = (unsigned char *)malloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
// Load the roms into memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(Ram02, 0x210000, 0x21EFFF, SM_RAM); //
SekMapMemory(Ram03, 0x21FC00, 0x21FFFF, SM_RAM); //
SekMapMemory(RamPal, 0x400000, 0x400FFF, SM_RAM); // Palette RAM
SekSetReadWordHandler(0, batsugunReadWord);
SekSetReadByteHandler(0, batsugunReadByte);
SekSetWriteWordHandler(0, batsugunWriteWord);
SekSetWriteByteHandler(0, batsugunWriteByte);
SekClose();
}
nSpriteYOffset = 0x0001;
nLayer0XOffset = -0x01D6;
nLayer1XOffset = -0x01D8;
nLayer2XOffset = -0x01DA;
ToaInitGP9001(3);
nToaPalLen = nColCount;
ToaPalSrc = RamPal;
ToaPalInit();
bDrawScreen = true;
#if defined FBA_DEBUG && defined USE_SPEEDHACKS
bprintf(PRINT_IMPORTANT, _T(" * Using speed-hacks (detecting idle loops).\n"));
#endif
DrvDoReset(); // Reset machine
return 0;
}
static INT32 drvInit()
{
INT32 nLen;
#ifdef DRIVER_ROTATION
bToaRotateScreen = true;
#endif
nGP9001ROMSize[0] = 0x01000000;
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (UINT8*)0;
if ((Mem = (UINT8*)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // Zero memory
MemIndex(); // Index the allocated memory
if (LoadRoms()) {
return 1;
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x1FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram02, 0x208000, 0x20FFFF, SM_RAM);
Map68KTextROM(true);
SekSetReadWordHandler(0, batriderReadWord);
SekSetReadByteHandler(0, batriderReadByte);
SekSetWriteWordHandler(0, batriderWriteWord);
SekSetWriteByteHandler(0, batriderWriteByte);
SekMapHandler(1, 0x400000, 0x400400, SM_RAM); // GP9001 addresses
SekSetReadWordHandler(1, batriderReadWordGP9001);
SekSetWriteWordHandler(1, batriderWriteWordGP9001);
SekMapHandler(2, 0x300000, 0x37FFFF, SM_ROM); // Z80 ROM
SekSetReadByteHandler(2, batriderReadByteZ80ROM);
SekSetReadWordHandler(2, batriderReadWordZ80ROM);
SekClose();
}
nSpriteYOffset = 0x0001;
nLayer0XOffset = -0x01D6;
nLayer1XOffset = -0x01D8;
nLayer2XOffset = -0x01DA;
ToaInitGP9001();
nExtraTXOffset = 0x2C;
ToaExtraTextInit();
drvZInit(); // Initialize Z80
BurnYM2151Init(32000000 / 8);
BurnYM2151SetAllRoutes(1.00, BURN_SND_ROUTE_BOTH);
MSM6295Init(0, 32000000 / 10 / 132, 1);
MSM6295Init(1, 32000000 / 10 / 165, 1);
MSM6295SetRoute(0, 1.00, BURN_SND_ROUTE_BOTH);
MSM6295SetRoute(1, 1.00, BURN_SND_ROUTE_BOTH);
nToaPalLen = nColCount;
ToaPalSrc = RamPal;
ToaPalInit();
nTextROMStatus = -1;
bDrawScreen = true;
drvDoReset(); // Reset machine
return 0;
}
static INT32 battlegInit()
{
INT32 nLen;
#ifdef DRIVER_ROTATION
bToaRotateScreen = true;
#endif
nGP9001ROMSize[0] = 0x800000;
// Find out how much memory is needed
Mem = NULL;
MemIndex();
nLen = MemEnd - (UINT8 *)0;
if ((Mem = (UINT8 *)BurnMalloc(nLen)) == NULL) {
return 1;
}
memset(Mem, 0, nLen); // blank all memory
MemIndex(); // Index the allocated memory
// Load the roms into memory
if (Bgareggabla) {
if (LoadRomsBla()) {
return 1;
}
} else {
if (Bgareggabl) {
if (LoadRomsBl()) {
return 1;
}
} else {
if (LoadRoms()) {
return 1;
}
}
}
{
SekInit(0, 0x68000); // Allocate 68000
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, MAP_RAM);
SekMapMemory(RamPal, 0x400000, 0x400FFF, MAP_RAM); // Palette RAM
SekMapMemory(Ram02, 0x401000, 0x4017FF, MAP_RAM); // Unused
SekMapMemory(ExtraTRAM, 0x500000, 0x501FFF, MAP_RAM);
SekMapMemory(ExtraTSelect, 0x502000, 0x502FFF, MAP_RAM); // 0x502000 - Scroll; 0x502200 - RAM
SekMapMemory(ExtraTScroll, 0x503000, 0x503FFF, MAP_RAM); // 0x203000 - Offset; 0x503200 - RAM
SekSetReadWordHandler(0, battlegReadWord);
SekSetReadByteHandler(0, battlegReadByte);
SekSetWriteWordHandler(0, battlegWriteWord);
SekSetWriteByteHandler(0, battlegWriteByte);
SekClose();
}
nSpriteXOffset = 0x0024;
nSpriteYOffset = 0x0001;
nLayer0XOffset = -0x01D6;
nLayer1XOffset = -0x01D8;
nLayer2XOffset = -0x01DA;
ToaInitGP9001();
nExtraTXOffset = 0x2C;
ToaExtraTextInit();
if (Bgareggabl) nExtraTXOffset = 0;
DrvZ80Init(); // Initialize Z80
BurnYM2151Init(32000000 / 8);
BurnYM2151SetAllRoutes(1.00, BURN_SND_ROUTE_BOTH);
MSM6295Init(0, 32000000 / 16 / 132, 1);
MSM6295SetRoute(0, 1.00, BURN_SND_ROUTE_BOTH);
nToaPalLen = nColCount;
ToaPalSrc = RamPal;
ToaPalInit();
bDrawScreen = true;
// mar 2 1996 & apr 2 1996 ver: 0x0009AC - 0x0009B8 & 0x001F5E - 0x001F64 & 0x003A1C - 0x003A22
// feb 2 1996 ver: 0x0009AC - 0x0009B8 & 0x001F2E - 0x001F34 & 0x0039EC - 0x0039F2
DrvDoReset(); // Reset machine
return 0;
}
