Adding games

**Robert** · October 30, 2005

Now that I've gotten the hang of compiling, I'd like to add some games.

Is it just a matter of adding a line to drivers.c and adding that other stuff to neogeo.c ?

I'm going to give it a go anyways and see what happens.

**Robert** · October 30, 2005

Lucky I wasn't waiting for an answer...

I've added 23 games that I was able to google the code for.

The compile has just kicked off, I'll see how many errors I get.

**James** · October 30, 2005

And were you adding Encrypted or Decrypted sets ?.

And what games did you add ?. and did you know I already posted drivers here ? http://www.1emulation.com/forums/index.php?showtopic=10562

If they were only decrypted sets then you have lot more to do :lol:

I have added code to drivers.c drivers\neogeo.c machine\neogeo.c machine\neocrypt.c and thats just the neogeo games.

**Weirdy** · October 30, 2005

decrypted sets are easier to add than encrypted sets IMO

**Robert** · October 30, 2005

I've added these sets:

bangbedp, digerman, neopong,

mslug5, mslug5a, mslug5nd,

matrimbl, pnyaa, samsho5, samsh5bl,

svcboot, svcsplus, svcplus,

svcplusa, svcchaos, svchaosa,

kof2003, kof2003a, kof2003b,

kof2k4ex, kf2k4spe, kof2k4se,

kof2k3up, kof10th

As to what is encrypted or not, I have no idea.

I just followed the instructions.

Modifications were done to driver.c, drivers\neogeo.c, common.h

bangbedp is already in mame, just had to be commented back in and added to driver.c

I found 2 mslug5 drivers that were completely different,

so one has been renamed to mslug5a until I know which one is the right one.

I only discovered your thread after I'd already gotten your stuff from a@h, I figured they are probably the same.

**James** · October 30, 2005

decrypted sets are easier to add than encrypted sets IMO
<{POST_SNAPBACK}>

Yes true for some :ph34r: . But I rather encrypted sets

I've added these sets:
bangbedp, digerman, neopong,
mslug5, mslug5a, mslug5nd,
matrimbl, pnyaa, samsho5, samsh5bl,
svcboot, svcsplus, svcplus,
svcplusa, svcchaos, svchaosa,
kof2003, kof2003a, kof2003b,
kof2k4ex, kf2k4spe, kof2k4se,
kof2k3up, kof10th

As to what is encrypted or not, I have no idea.
I just followed the instructions.

Modifications were done to driver.c, drivers\neogeo.c, common.h

bangbedp is already in mame, just had to be commented back in and added to driver.c
I found 2 mslug5 drivers that were completely different,
so one has been renamed to mslug5a until I know which one is the right one.

I only discovered your thread after I'd already gotten your stuff from a@h, I figured they are probably the same.
<{POST_SNAPBACK}>

You no longer need to add code to common.h since that code is now offically supported.

**Robert** · October 30, 2005

Oh well, I got several screenloads of errors,

so I'll continue this tomorrow

**James** · October 30, 2005

Please post the errors here if you can :ph34r:

**Robert** · October 31, 2005

I decided I was being a bit ambitious, so I removed everything, applied the 101u4 patch, and added back in only

bangbedp, pnyaa, mslug5, mslug5a, mslug5nd

and compiled again. The errors I got this time were:

src/drivers/neogeo.c: In function `mv0_bankswitch_w':

src/drivers/neogeo.c:6894: warning: ISO C90 forbids mixed declarations and code

src/drivers/neogeo.c: In function `ms5plus_bankswitch_w':

src/drivers/neogeo.c:6902: warning: ISO C90 forbids mixed declarations and code

src/drivers/neogeo.c: In function `mslug5_vx_decrypt':

src/drivers/neogeo.c:6979: error: 'for' loop initial declaration used outside C99 mode

Then I got rid of the mslug5 routines and replaced them with your ones. Now I'm compiling again.

**Weirdy** · October 31, 2005

the new ones should work

**James** · October 31, 2005

Some of the code was changed I will post all the init here and you can pick the ones you need

/* Clone Mame Extra Games Code  */
DRIVER_INIT( kof2002 )
{
int i;
unsigned int sec[]={0x100000,0x280000,0x300000,0x180000,0x000000,0x380000,0x200000,0x080000};
UINT8 *src = memory_region(REGION_CPU1)+0x100000;
UINT8 *dst = malloc(0x400000);
if (dst)
{
  memcpy( dst, src, 0x400000 );
  for( i=0; i<8; ++i )
  {
   memcpy( src+i*0x80000, dst+sec[i], 0x80000 );
  }
free(dst);
}

neo_pcm2_playmore_2002(0); // kof2002

neogeo_fix_bank_type = 0;
kof2000_neogeo_gfx_decrypt(0xec);

init_neogeo();
}

DRIVER_INIT( samsho5 )
{
/* Descrambling P ROMs */
UINT8 *src = memory_region(REGION_CPU1);
UINT8 *dst = malloc(0x800000);
int i;
unsigned int sec[]={0x000000, 0x080000, 0x700000, 0x680000, 0x500000, 0x180000, 0x200000, 0x480000, 0x300000, 0x780000, 0x600000, 0x280000, 0x100000, 0x580000, 0x400000, 0x380000};
if (dst)
{
  memcpy(dst,src,0x800000);

  for(i=0;i<16;++i)
  {
   memcpy(src+i*0x80000,dst+sec[i],0x80000);
  }
  free(dst);
}
neogeo_fix_bank_type = 1;
kof2000_neogeo_gfx_decrypt(0x0f);
neo_pcm2_playmore_2002(3); // samsho5
init_neogeo();
}

DRIVER_INIT( samsh5nd )
{
/* Descrambling P ROMs */
UINT8 *src = memory_region(REGION_CPU1);
UINT8 *dst = malloc(0x800000);
int i;
unsigned int sec[]={0x000000, 0x080000, 0x700000, 0x680000, 0x500000, 0x180000, 0x200000, 0x480000, 0x300000, 0x780000, 0x600000, 0x280000, 0x100000, 0x580000, 0x400000, 0x380000};
if (dst)
{
  memcpy(dst,src,0x800000);

  for(i=0;i<16;++i)
  {
   memcpy(src+i*0x80000,dst+sec[i],0x80000);
  }
  free(dst);
}
init_neogeo();
}

DRIVER_INIT( samsh5sp )
{
/* Descrambling Px by Vorador from speksnk Converted to Mame code by James */
UINT8 *src = memory_region(REGION_CPU1);
UINT8 *dst = malloc(0x800000);
int i;
unsigned int sec[]={0x0,0x1,0xA,0x9,0xC,0xB,0xE,0x5,0x2,0xD,0x8,0xF,0x4,0x7,0x6,0x3};
if (dst)
{
  memcpy(dst,src,0x800000);

  for(i=0;i<0x10;i++)
  {
   memcpy(src+i*0x80000,dst+sec[i]*0x80000,0x80000);
  }
  free(dst);
}
neogeo_fix_bank_type = 1;
kof2000_neogeo_gfx_decrypt(0x0d);
neo_pcm2_playmore_2002(6); // samsh5sp
init_neogeo();
}

static void kof2003_sx_decrypt( void )
{
int i;
int tx_size = memory_region_length( REGION_GFX1 );
int rom_size = memory_region_length( REGION_GFX3 );
UINT8 *src;
UINT8 *dst;

src = memory_region( REGION_GFX3 ) + rom_size - 0x1000000 - 0x80000;
dst = memory_region( REGION_GFX1 );

for( i = 0; i < tx_size / 2; i++ ){
  dst[ i ] = src[ (i & ~0x1f) + ((i & 7) << 2) + ((~i & 8) >> 2) + ((i & 0x10) >> 4) ];
}

src = memory_region( REGION_GFX3 ) + rom_size - 0x80000;
dst = memory_region( REGION_GFX1 ) + 0x80000;

for( i = 0; i < tx_size / 2; i++ ){
  dst[ i ] = src[ (i & ~0x1f) + ((i & 7) << 2) + ((~i & 8) >> 2) + ((i & 0x10) >> 4) ];
}

dst = memory_region( REGION_GFX1 );
for( i = 0; i < tx_size; i++ ){
  dst[ i ] = BITSWAP8( dst[ i ] ^ 0xd2, 4, 0, 7, 2, 5, 1, 6, 3 );
}
}

DRIVER_INIT( kof2003 )
{
const unsigned char xor2[ 0x20 ] = {
  0xb4, 0x0f, 0x40, 0x6c, 0x38, 0x07, 0xd0, 0x3f, 0x53, 0x08, 0x80, 0xaa, 0xbe, 0x07, 0xc0, 0xfa,
  0xd0, 0x08, 0x10, 0xd2, 0xf1, 0x03, 0x70, 0x7e, 0x87, 0x0B, 0x40, 0xf6, 0x2a, 0x0a, 0xe0, 0xf9
};

int i;
int ofst;
UINT8 *rom, *buf;

rom = memory_region( REGION_CPU1 );

for( i = 0x100000; i < 0x800000; i++ ){
  rom[ i ] ^= xor2[ (i % 0x20) ];
}

for( i = 0x100000; i < 0x800000; i += 4 ){
  UINT16 *rom16 = (UINT16*)&rom[ i + 1 ];
  *rom16 = BITSWAP16( *rom16, 15, 14, 13, 12, 4, 5, 6, 7, 8, 9, 10, 11, 3, 2, 1, 0 );
}

buf = malloc( 0x800000 );
memcpy( buf, rom, 0x800000 );

for( i = 0; i < 0x0100000 / 0x10000; i++ ){
  ofst = (i & 0xf0) + BITSWAP8( (i & 0x0f), 7, 6, 5, 4, 1, 0, 3, 2 );
  memcpy( &rom[ i * 0x10000 ], &buf[ ofst * 0x10000 ], 0x10000 );
}

for( i = 0x100000; i < 0x800000; i += 0x100 ){
  ofst = (i & 0xf000ff) + 
      ((i & 0x000f00) ^ 0x00300) +
      (BITSWAP8( ((i & 0x0ff000) >> 12), 4, 5, 6, 7, 1, 0, 3, 2 ) << 12);

  memcpy( &rom[ i ], &buf[ ofst ], 0x100 );
}

free( buf );

buf = malloc(0x900000);
memcpy( buf, rom, 0x900000 );

memcpy( &rom[0x100000], &buf[0x800000], 0x100000 );
memcpy( &rom[0x200000], &buf[0x100000], 0x700000 );

free(buf);
kof2003_sx_decrypt();

neogeo_fix_bank_type = 2;
neo_pcm2_playmore_2002(5); // Kof2003
init_neogeo();
}

DRIVER_INIT( kof2003a )
{
kof2003_sx_decrypt();
neogeo_fix_bank_type = 2;
init_neogeo();
}

DRIVER_INIT( kof2003p )
{
neogeo_fix_bank_type = 2;
init_neogeo();
}

DRIVER_INIT( pnyaa )
{
neogeo_fix_bank_type = 1;
kof2000_neogeo_gfx_decrypt(0x2e);
neo_pcm2_snk_1999(4);
init_neogeo();
}

DRIVER_INIT( matrim )
{
UINT8 *src = memory_region(REGION_CPU1)+0x100000;
UINT8 *dst = malloc(0x400000);
int i;
unsigned int sec[]={0x100000,0x280000,0x300000,0x180000,0x000000,0x380000,0x200000,0x080000};

if (dst)
{
  memcpy(dst,src,0x400000);

  for(i=0;i<8;++i)
  {
   memcpy(src+i*0x80000,dst+sec[i],0x80000);
  }
  free(dst);
}

neogeo_fix_bank_type = 2;
kof2000_neogeo_gfx_decrypt(0x6a);
neo_pcm2_playmore_2002(1); // Matrim
init_neogeo();
}

DRIVER_INIT( matrimnd )
{
UINT8 *src = memory_region(REGION_CPU1)+0x100000;
UINT8 *dst = malloc(0x400000);
int i;
unsigned int sec[]={0x100000,0x280000,0x300000,0x180000,0x000000,0x380000,0x200000,0x080000};

if (dst)
{
  memcpy(dst,src,0x400000);

  for(i=0;i<8;++i)
  {
   memcpy(src+i*0x80000,dst+sec[i],0x80000);
  }
  free(dst);
}

neogeo_fix_bank_type = 2;

/* the S data comes from the end of the C data */
{
  
  int i;
  int tx_size = memory_region_length(REGION_GFX1);
  int rom_size = memory_region_length(REGION_GFX3);
  UINT8 *src = memory_region(REGION_GFX3)+rom_size-tx_size;
  UINT8 *dst = memory_region(REGION_GFX1);

  for (i = 0;i < tx_size;i++)
  dst[i] = src[(i & ~0x1f) + ((i & 7) << 2) + ((~i & 8) >> 2) + ((i & 0x10) >> 4)];
}
neo_pcm2_playmore_2002(1); // Matrim
init_neogeo();
}

/* descrambling information from razoola */
static void matrimbl_neogeo_gfx_address_fix_do(int start, int end, int bit3shift, int bit2shift, int bit1shift, int bit0shift)
{
int i,j;
int tilesize=128;

UINT8* rom = (UINT8*)malloc(16*tilesize);	// 16 tiles buffer
UINT8* realrom = memory_region(REGION_GFX3) + start*tilesize;

for (i = 0; i < (end-start)/16; i++) {
  for (j = 0; j < 16; j++) {
   int offset = (((j&1)>>0)<<bit0shift)
            +(((j&2)>>1)<<bit1shift)
            +(((j&4)>>2)<<bit2shift)
      +(((j&8)>>3)<<bit3shift);

   memcpy(rom+j*tilesize, realrom+offset*tilesize, tilesize);
  }
  memcpy(realrom,rom,tilesize*16);
  realrom+=16*tilesize;
}
free(rom);
}

static void matrimbl_neogeo_gfx_address_fix(int start, int end)
{
matrimbl_neogeo_gfx_address_fix_do(start+512*0, end+512*0, 0,3,2,1);
matrimbl_neogeo_gfx_address_fix_do(start+512*1, end+512*1, 1,0,3,2);
matrimbl_neogeo_gfx_address_fix_do(start+512*2, end+512*2, 2,1,0,3);
// skip 3 & 4
matrimbl_neogeo_gfx_address_fix_do(start+512*5, end+512*5, 0,1,2,3);
matrimbl_neogeo_gfx_address_fix_do(start+512*6, end+512*6, 0,1,2,3);
matrimbl_neogeo_gfx_address_fix_do(start+512*7, end+512*7, 0,2,3,1);
}

static void matrimbl_c(int pow)
{
int i;

for (i=0; i<=192; i+=8)
  matrimbl_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=200; i<=392; i+=8)
  matrimbl_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=400; i<=592; i+=8)
  matrimbl_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=600; i<=792; i+=8)
  matrimbl_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=800; i<=992; i+=8)
  matrimbl_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=1000; i<=1016; i+=8)
  matrimbl_neogeo_gfx_address_fix(i*512,i*512+512);
}

#define MATRIMBLFIX(i) (i^(BITSWAP8(i&0x3,4,3,1,2,0,7,6,5)<<8))

DRIVER_INIT( matrimbl )
{
UINT8 *src = memory_region(REGION_CPU1)+0x100000;
UINT8 *dst = malloc(0x400000);
        int i; int j=0;
        int tx_size = memory_region_length(REGION_GFX1);
        int rom_size = memory_region_length(REGION_GFX3);

unsigned int sec[]={0x100000,0x280000,0x300000,0x180000,0x000000,0x380000,0x200000,0x080000};

if (dst){
  memcpy(dst,src,0x400000);
  for(i=0;i<8;++i){
   memcpy(src+i*0x80000,dst+sec[i],0x80000);
  }
  free(dst);
}
        matrimbl_c(0);
src = memory_region(REGION_GFX3)+rom_size-tx_size;
        dst = memory_region(REGION_GFX1);
        for (i = 0;i < tx_size;i++)
            dst [ i ] = src[(i & ~0x1f) + ((i & 7) << 2) + ((~i & 8) >> 2) + ((i & 0x10) >> 4)];

        neogeo_fix_bank_type = 2;
        src = memory_region(REGION_CPU2)+0x10000;
        dst = (UINT8*)malloc(0x20000);
        memcpy(dst,src,0x20000);
        for(i=0x00000;i<0x20000;i++){
           if (i&0x10000){
                 if (i&0x800){
                   j=MATRIMBLFIX(i);
                   j=j^0x10000;
                 }else{
                   j=MATRIMBLFIX((i^0x01));
                 }
           }else{
                 if (i&0x800){
                   j=MATRIMBLFIX((i^0x01));
                   j=j^0x10000;
                 }else{
                   j=MATRIMBLFIX(i);
                 }
           }
          src[j]=dst[i];
        }
  free(dst);
memcpy(src-0x10000,src,0x10000);

init_neogeo();
}


static void svcchaos_px_decrypt( void )
{
const unsigned char xor1[ 0x20 ] = {
  0x3b, 0x6a, 0xf7, 0xb7, 0xe8, 0xa9, 0x20, 0x99, 0x9f, 0x39, 0x34, 0x0c, 0xc3, 0x9a, 0xa5, 0xc8,
  0xb8, 0x18, 0xce, 0x56, 0x94, 0x44, 0xe3, 0x7a, 0xf7, 0xdd, 0x42, 0xf0, 0x18, 0x60, 0x92, 0x9f,
};

const unsigned char xor2[ 0x20 ] = {
  0x69, 0x0b, 0x60, 0xd6, 0x4f, 0x01, 0x40, 0x1a, 0x9f, 0x0b, 0xf0, 0x75, 0x58, 0x0e, 0x60, 0xb4,
  0x14, 0x04, 0x20, 0xe4, 0xb9, 0x0d, 0x10, 0x89, 0xeb, 0x07, 0x30, 0x90, 0x50, 0x0e, 0x20, 0x26,
};

int i;
int ofst;
UINT8 *rom, *buf;

rom = memory_region( REGION_CPU1 );

for( i = 0; i < 0x100000; i++ ){
  rom[ i ] ^= xor1[ (i % 0x20) ];
}

for( i = 0x100000; i < 0x800000; i++ ){
  rom[ i ] ^= xor2[ (i % 0x20) ];
}

for( i = 0x100000; i < 0x800000; i += 4 ){
  UINT16 *rom16 = (UINT16*)&rom[ i + 1 ];
  *rom16 = BITSWAP16( *rom16, 15, 14, 13, 12, 10, 11, 8, 9, 6, 7, 4, 5, 3, 2, 1, 0 );
}

buf = malloc( 0x800000 );
memcpy( buf, rom, 0x800000 );

for( i = 0; i < 0x0100000 / 0x10000; i++ ){
  ofst = (i & 0xf0) + BITSWAP8( (i & 0x0f), 7, 6, 5, 4, 2, 3, 0, 1 );
  memcpy( &rom[ i * 0x10000 ], &buf[ ofst * 0x10000 ], 0x10000 );
}

for( i = 0x100000; i < 0x800000; i += 0x100 ){
  ofst = (i & 0xf000ff) + 
      ((i & 0x000f00) ^ 0x00a00) +
      (BITSWAP8( ((i & 0x0ff000) >> 12), 4, 5, 6, 7, 1, 0, 3, 2 ) << 12);

  memcpy( &rom[ i ], &buf[ ofst ], 0x100 );
}

free( buf );

buf = malloc( 0x800000 );
memcpy( buf, rom, 0x800000 );
memcpy( &rom[ 0x100000 ], &buf[ 0x700000 ], 0x100000 );
memcpy( &rom[ 0x200000 ], &buf[ 0x100000 ], 0x600000 );
free( buf );
}

static void svcchaos_gfx_decrypt( void )
{
   const unsigned char xor1[ 4 ] = {
      0x34, 0x21, 0xc4, 0xe9,
   };

   int i;
   int ofst;
   UINT8 *src = memory_region( REGION_GFX3 );
   int len = memory_region_length( REGION_GFX3 );
   UINT8 *dst = malloc( len );
   UINT8 *s1 = memory_region( REGION_GFX1 );
   size_t s1_size = memory_region_length( REGION_GFX1 );

   for( i = 0; i < len; i++ ){
      src[ i ] ^= xor1[ (i % 4) ];
   }

   for( i = 0; i < len; i += 4 ){
      UINT32 *src32 = (UINT32*)&src[ i ];
      *src32 = BITSWAP32( *src32, 0x09, 0x0d, 0x13, 0x00, 0x17, 0x0f, 0x03, 0x05,
                           0x04, 0x0c, 0x11, 0x1e, 0x12, 0x15, 0x0b, 0x06,
                           0x1b, 0x0a, 0x1a, 0x1c, 0x14, 0x02, 0x0e, 0x1d,
                           0x18, 0x08, 0x01, 0x10, 0x19, 0x1f, 0x07, 0x16 );
   }

   memcpy( dst, src, len );

   for( i = 0; i < len / 4; i++ ){
      ofst =  BITSWAP24( (i & 0x1fffff), 0x17, 0x16, 0x15, 0x04, 0x0b, 0x0e, 0x08, 0x0c,
                                 0x10, 0x00, 0x0a, 0x13, 0x03, 0x06, 0x02, 0x07,
                                 0x0d, 0x01, 0x11, 0x09, 0x14, 0x0f, 0x12, 0x05 );
      ofst ^= 0x0c8923;
      ofst += (i & 0xffe00000);

      memcpy( &src[ i * 4 ], &dst[ ofst * 4 ], 0x04 );
   }

   free( dst );

   kof2000_neogeo_gfx_decrypt(0x57);
   
   for( i = 0; i < s1_size; i++ ){
      s1[ i ] = BITSWAP8( s1[ i ] ^ 0xd2, 4, 0, 7, 2, 5, 1, 6, 3 );

   }
}

DRIVER_INIT( svcchaos )
{
neogeo_fix_bank_type = 2;
svcchaos_px_decrypt();
svcchaos_gfx_decrypt();
neo_pcm2_playmore_2002(4); // Svcchaos, Svchaosa
init_neogeo();
}

DRIVER_INIT( svchaosa )
{
svcchaos_px_decrypt();
neo_pcm2_playmore_2002(4); // Svcchaos, Svchaosa
neogeo_fix_bank_type = 2;
kof2000_neogeo_gfx_decrypt(0x57);
init_neogeo();
}

static void svcboot_px_decrypt( void )
{
const unsigned char sec[] = {
  0x06, 0x07, 0x01, 0x02, 0x03, 0x04, 0x05, 0x00
};

int i;
int size = memory_region_length( REGION_CPU1 );
UINT8 *src = memory_region( REGION_CPU1 );
UINT8 *dst = malloc( size );
int ofst;

for( i = 0; i < size / 0x100000; i++ ){
  memcpy( &dst[ i * 0x100000 ], &src[ sec[ i ] * 0x100000 ], 0x100000 );
}

for( i = 0; i < size / 2; i++ ){
  ofst = BITSWAP8( (i & 0x0000ff), 7, 6, 1, 0, 3, 2, 5, 4 );
  ofst += (i & 0xffff00);

  memcpy( &src[ i * 2 ], &dst[ ofst * 2 ], 0x02 );
}

free( dst );
}

static void svcboot_cx_decrypt( void )
{
const unsigned char idx_tbl[ 0x10 ] = {
  0, 1, 0, 1, 2, 3, 2, 3, 3, 4, 3, 4, 4, 5, 4, 5,
};

const unsigned char bitswap4_tbl[ 6 ][ 4 ] = {
  { 3, 0, 1, 2 },
  { 2, 3, 0, 1 },
  { 1, 2, 3, 0 },
  { 0, 1, 2, 3 },
  { 3, 2, 1, 0 },
  { 3, 0, 2, 1 },
};

int i;
int size = memory_region_length( REGION_GFX3 );
UINT8 *src = memory_region( REGION_GFX3 );
UINT8 *dst = malloc( size );
int ofst;

memcpy( dst, src, size );

for( i = 0; i < size / 0x80; i++ ){
  int idx = idx_tbl[ (i & 0xf00) >> 8 ];

  int bit0 = bitswap4_tbl[ idx ][ 0 ];
  int bit1 = bitswap4_tbl[ idx ][ 1 ];
  int bit2 = bitswap4_tbl[ idx ][ 2 ];
  int bit3 = bitswap4_tbl[ idx ][ 3 ];

  ofst = BITSWAP8( (i & 0x0000ff), 7, 6, 5, 4, bit3, bit2, bit1, bit0 );
  ofst += (i & 0xfffff00);

  memcpy( &src[ i * 0x80 ], &dst[ ofst * 0x80 ], 0x80 );
}

free( dst );
}

static void svcplus_px_decrypt( void )
{
int sec[] = {
  0x00, 0x03, 0x02, 0x05, 0x04, 0x01
};

int size = memory_region_length( REGION_CPU1 );
UINT8 *src = memory_region( REGION_CPU1 );
UINT8 *dst = malloc( size );
int i;
int ofst;

memcpy( dst, src, size );

for( i = 0; i < size / 2; i++ ){
  ofst = BITSWAP24( (i & 0xfffff), 0x17, 0x16, 0x15, 0x14, 0x13, 0x00, 0x01, 0x02,
           0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08,
           0x07, 0x06, 0x05, 0x04, 0x03, 0x10, 0x11, 0x12 );

  ofst ^= 0x0f0007;
  ofst += (i & 0xff00000);

  memcpy( &src[ i * 0x02 ], &dst[ ofst * 0x02 ], 0x02 );
}

memcpy( dst, src, size );

for( i = 0; i < 6; i++ ){
  memcpy( &src[ i * 0x100000 ], &dst[ sec[ i ] * 0x100000 ], 0x100000 );
}

free( dst );
}


static void svcplus_sx_decrypt( void )
{
int i; // move this outside of the "for" loop
int rom_size = memory_region_length( REGION_GFX1 );
UINT8 *rom = memory_region( REGION_GFX1 );
UINT8 *buf = malloc( rom_size );

memcpy( buf, rom, rom_size );

for( i = 0; i < rom_size; i += 0x10 ){ // notice removal of "int i =0"
  memcpy( &rom[ i        ], &buf[ i + 0x08 ], 0x08 );
  memcpy( &rom[ i + 0x08 ], &buf[ i        ], 0x08 );
}

free( buf );
}

static void svcplusa_px_decrypt( void )
{
int sec[] = {
  0x01, 0x02, 0x03, 0x04, 0x05, 0x00
};

int i; // move this outside of the "for" loop
int rom_size = memory_region_length( REGION_CPU1 );
UINT8 *rom = memory_region( REGION_CPU1 );
UINT8 *buf = malloc( rom_size );

memcpy( buf, rom, rom_size );

for( i = 0; i < 6; i++ ){ // notice removal of "int i = 0"
  memcpy( &rom[ i * 0x100000 ], &buf[ sec[ i ] * 0x100000 ], 0x100000 );
}

free( buf );
}

static void svcsplus_px_decrypt( void )
{
int sec[] = {
  0x06, 0x07, 0x01, 0x02, 0x03, 0x04, 0x05, 0x00
};

int size = memory_region_length( REGION_CPU1 );
UINT8 *src = memory_region( REGION_CPU1 );
UINT8 *dst = malloc( size );
int i;
int ofst;

memcpy( dst, src, size );

for (i = 0; i < size / 2; i++ ){
  ofst = BITSWAP16( (i & 0x007fff), 0x0f, 0x00, 0x08, 0x09, 0x0b, 0x0a, 0x0c, 0x0d,
            0x04, 0x03, 0x01, 0x07, 0x06, 0x02, 0x05, 0x0e );

  ofst += (i & 0x078000);
  ofst += sec[ (i & 0xf80000) >> 19 ] << 19;

  memcpy( &src[ i * 2 ], &dst[ ofst * 2 ], 0x02 );
}

free( dst );

}


static void svcsplus_sx_decrypt( void )
{
int i; // move this outside of the "for" loop
UINT8 *rom = memory_region( REGION_GFX1 );
int rom_size = memory_region_length( REGION_GFX1 );

for( i = 0; i < rom_size; i++ ){// notice removal of "int i = 0"
  rom[ i ] = BITSWAP8( rom[ i ], 7, 6, 0, 4, 3, 2, 1, 5 );
}
}

static void svcsplus_px_patch( void )
{	
  UINT16 *prom = (UINT16*)memory_region(REGION_CPU1);
  prom[0x9e90/2] = 0x000f;
  prom[0x9e92/2] = 0xc9c0;
  prom[0xa10c/2] = 0x4eb9;
  prom[0xa10e/2] = 0x000e;
  prom[0xa110/2] = 0x9750;



}

DRIVER_INIT( svcboot )
{
svcboot_px_decrypt();
svcboot_cx_decrypt();

init_neogeo();
}

DRIVER_INIT( svcplus )
{
svcplus_px_decrypt();
svcboot_cx_decrypt();
svcplus_sx_decrypt();

init_neogeo();
}

DRIVER_INIT( svcplusa )
{
svcplusa_px_decrypt();
svcboot_cx_decrypt();

init_neogeo();
}

DRIVER_INIT( svcsplus )
{
svcsplus_px_decrypt();
svcsplus_sx_decrypt();
svcboot_cx_decrypt();
svcsplus_px_patch();

init_neogeo();
}

DRIVER_INIT( svcrmu )
{
neogeo_fix_bank_type = 2;
init_neogeo();
}


static void mslug5_px_decrypt( void )
{
const unsigned char xor1[ 0x20 ] = {
  0xc2, 0x4b, 0x74, 0xfd, 0x0b, 0x34, 0xeb, 0xd7, 0x10, 0x6d, 0xf9, 0xce, 0x5d, 0xd5, 0x61, 0x29,
  0xf5, 0xbe, 0x0d, 0x82, 0x72, 0x45, 0x0f, 0x24, 0xb3, 0x34, 0x1b, 0x99, 0xea, 0x09, 0xf3, 0x03,
};

const unsigned char xor2[ 0x20 ] = {
  0x36, 0x09, 0xb0, 0x64, 0x95, 0x0f, 0x90, 0x42, 0x6e, 0x0f, 0x30, 0xf6, 0xe5, 0x08, 0x30, 0x64,
  0x08, 0x04, 0x00, 0x2f, 0x72, 0x09, 0xa0, 0x13, 0xc9, 0x0b, 0xa0, 0x3e, 0xc2, 0x00, 0x40, 0x2b,
};

int i;
UINT8 *rom, *buf;
int ofst;

rom = memory_region( REGION_CPU1 );

for( i = 0; i < 0x100000; i++ ){
  rom[ i ] ^= xor1[ (i % 0x20) ];
}

for( i = 0x100000; i < 0x800000; i++ ){
  rom[ i ] ^= xor2[ (i % 0x20) ];
}

for( i = 0x100000; i < 0x0800000; i += 4 ){
  UINT16 *rom16 = (UINT16*)&rom[ i + 1 ];
  *rom16 = BITSWAP16( *rom16, 15, 14, 13, 12, 10, 11, 8, 9, 6, 7, 4, 5, 3, 2, 1, 0 );
}

buf = malloc( 0x800000 );
memcpy( buf, rom, 0x800000 );

for( i = 0; i < 0x0100000 / 0x10000; i++ ){
  ofst = (i & 0xf0) + BITSWAP8( (i & 0x0f), 7, 6, 5, 4, 1, 0, 3, 2 );
  memcpy( &rom[ i * 0x10000 ], &buf[ ofst * 0x10000 ], 0x10000 );
}

for( i = 0x100000; i < 0x800000; i += 0x100 ){
  ofst = (i & 0xf000ff) + 
      ((i & 0x000f00) ^ 0x00700) +
      (BITSWAP8( ((i & 0x0ff000) >> 12), 5, 4, 7, 6, 1, 0, 3, 2 ) << 12);

  memcpy( &rom[ i ], &buf[ ofst ], 0x100 );
}

free( buf );

buf = malloc( 0x800000 );
memcpy( buf, rom, 0x800000 );
memcpy( &rom[ 0x100000 ], &buf[ 0x700000 ], 0x100000 );
memcpy( &rom[ 0x200000 ], &buf[ 0x100000 ], 0x600000 );
free( buf );
}

DRIVER_INIT( mslug5 )
{
mslug5_px_decrypt();
neo_pcm2_playmore_2002(2); // Mslug5
neogeo_fix_bank_type = 1;
kof2000_neogeo_gfx_decrypt(0x19);
init_neogeo();
}

DRIVER_INIT( mslug5nd )
{
        /* the S data comes from the end of the C data */
        {
                int i;
                int tx_size = memory_region_length(REGION_GFX1);
                int rom_size = memory_region_length(REGION_GFX3);

                UINT8 *src = memory_region(REGION_GFX3)+rom_size-tx_size;
                UINT8 *dst = memory_region(REGION_GFX1);

                for (i = 0;i < tx_size;i++)
                dst[i] = src[(i & ~0x1f) + ((i & 7) << 2) + ((~i & 8) >> 2) + ((i & 0x10) >> 4)];
         }

mslug5_px_decrypt();
        init_neogeo();
}

DRIVER_INIT( ms5plus )
{
UINT8 *dst = malloc(0x20000);
UINT8 *roms1 = (memory_region(REGION_GFX1));
int j;

if ( dst )
{
  memcpy(dst,roms1,0x20000);
  for (j=0;j<0x20000; j+=0x000010)
  {
   memcpy( roms1+j, dst+j+0x000008,8);
   memcpy( roms1+j+0x000008, dst+j,8);
                      
  }
}
free( dst );
        
neogeo_fix_bank_type = 1;
        kof2000_neogeo_gfx_decrypt(0x19);
        init_neogeo();
}

DRIVER_INIT( kf2k4spe )
{
int i;
UINT8 *src = memory_region(REGION_CPU1)+0x100000;
UINT8 *dst = malloc(0x400000);
unsigned int sec[] = {0x300000,0x200000,0x100000,0x000000};
if (dst)
{
  memcpy(dst,src,0x400000);

for (i = 0; i < 4; ++i)
  {
   memcpy(src+i*0x100000,dst+sec[i],0x100000);
  }
  free(dst);
}
init_neogeo();
}

/* kof10th Bankswitch */
static UINT16 neogeo_sram16_2[0x2000];

READ16_HANDLER( neogeo_sram16_2_r )
{
return neogeo_sram16_2[offset];
}

WRITE16_HANDLER( neogeo_sram16_2_w )
{
COMBINE_DATA(&neogeo_sram16_2[offset]);
}

DRIVER_INIT( kof10th )
{
int i,j;
UINT16 *prom = (UINT16*)memory_region(REGION_CPU1);
UINT16 *buf  = (UINT16*)malloc(0x800000);
UINT16 *srom = (UINT16*)memory_region(REGION_GFX1);

if (buf){
  memcpy(buf,prom,0x800000);
  for(i=0;i<0x800000/2;i++){
   j=BITSWAP24(i,23,22,21,20,19,18,17,16,15,14,13,12,11,10,1,8,7,6,0,4,3,2,9,5);
   prom[j]=buf[i];
  }
  free(buf);
}

  // get 8x8 tiles from P rom
  // bank 1, game does this on the fly!
  for (i=0;i<0x10000/2;i++){
   srom[i+0x00000/2]=BITSWAP16(prom[i+0x600000/2]^0xf3f3,7,6,0,4,3,2,1,5,15,14,8,12,11,10,9,13);
   srom[i+0x10000/2]=BITSWAP16(prom[i+0x6d0000/2]^0xf3f3,7,6,0,4,3,2,1,5,15,14,8,12,11,10,9,13);
   }
  for (i=0;i<0x4000/2;i++){
  srom[i+0x02000/2]=BITSWAP16(prom[i+0x6c2000/2]^0xf3f3,7,6,0,4,3,2,1,5,15,14,8,12,11,10,9,13);
  srom[i+0x12000/2]=BITSWAP16(prom[i+0x612000/2]^0xf3f3,7,6,0,4,3,2,1,5,15,14,8,12,11,10,9,13);
  }
// bank 2, game does this on the fly!
for (i=0;i<0x20000/2;i++){
  srom[i+0x40000/2]=BITSWAP16(prom[i+0x600000/2]^0xf3f3,7,6,0,4,3,2,1,5,15,14,8,12,11,10,9,13);
  srom[i+0x60000/2]=srom[i+0x20000/2]; // copy bios again
  }

// Altera protection chip patches these over P ROM

prom[0x00124/2] = 0x000d;	// Run code that gives XOR for RAM moves and forces SoftDIPs
prom[0x00126/2] = 0xf7a8;	// (how to play off and always teamplay). Also forces USA region. 

prom[0x08bf4/2] = 0x4ef9;	// Run code to change 8x8 tiles (needed for neogeo logo tiles)
prom[0x08bf6/2] = 0x000d;
prom[0x08bf8/2] = 0xf980;

// remove protection (game has ram mapped to 0xe0000 and 0xf0000 and moves code into it)

for(i=0;i<0x40;i++){
  prom[0xe0000/2+i]=((prom[0x531680/2+i]^(0xc11d-0xc0c8))^prom[0x531600/2+i]);
}
for(i=0;i<0x270;i++){
  prom[0xe1000/2+i]=((prom[0x531970/2+i]^(0xc11d-0xc0d9))^prom[0x531700/2+i]);
}

prom[0xe1154/2] = 0x125c;	// fix a jmp offset (was in 0xe0000 range)
prom[0xdf986/2] = 0x168C;	// fix a bsr offset (was in 0xe0000 range)
prom[0xdf998/2] = 0x1668;	// fix a bsr offset (was in 0xe0000 range)

prom[0xdd880/2] = 0x4e75;	// fix level drawing   (from 0xf0000 range)
prom[0xdd89e/2] = 0x4e75;	// fix level anim      (from 0xf0000 range)
prom[0xdd8bc/2] = 0x4e75;	// fix continue screen (from 0xf0000 range)

neogeo_fix_bank_type = 0;

/* kof10th Bankswitch handler */
memory_install_read16_handler(0, ADDRESS_SPACE_PROGRAM, 0x2fe000,0x2fffff, 0, 0, neogeo_sram16_2_r);
memory_install_write16_handler(0, ADDRESS_SPACE_PROGRAM, 0x2fe000,0x2fffff, 0, 0, neogeo_sram16_2_w);
memory_install_write16_handler(0, ADDRESS_SPACE_PROGRAM, 0x2ffff0,0x2fffff, 0, 0, neo_bankswitch_w);

init_neogeo();
}

/* descrambling information from razoola */
/* descrambling S rom for cthd2003 Super Plus */
static void ct2k3sp_sx_decrypt( void )
{
int rom_size = memory_region_length( REGION_GFX1 );
UINT8 *rom = memory_region( REGION_GFX1 );
UINT8 *buf = malloc( rom_size );
int i;
int ofst;

memcpy( buf, rom, rom_size );

for( i = 0; i < rom_size; i++ ){
  ofst = BITSWAP24( (i & 0x1ffff), 23, 22, 21, 20, 19, 18, 17,  3,
            0,  1,  4,  2, 13, 14, 16, 15,
            5,  6, 11, 10,  9,  8,  7, 12 );

  ofst += (i >> 17) << 17;

  rom[ i ] = buf[ ofst ];
}

memcpy( buf, rom, rom_size );

memcpy( &rom[ 0x08000 ], &buf[ 0x10000 ], 0x8000 );
memcpy( &rom[ 0x10000 ], &buf[ 0x08000 ], 0x8000 );
memcpy( &rom[ 0x28000 ], &buf[ 0x30000 ], 0x8000 );
memcpy( &rom[ 0x30000 ], &buf[ 0x28000 ], 0x8000 );

free( buf );
}

static void cthd2003_neogeo_gfx_address_fix_do(int start, int end, int bit3shift, int bit2shift, int bit1shift, int bit0shift)
{
int i,j;
int tilesize=128;

UINT8* rom = (UINT8*)malloc(16*tilesize);	// 16 tiles buffer
UINT8* realrom = memory_region(REGION_GFX3) + start*tilesize;

for (i = 0; i < (end-start)/16; i++) {
  for (j = 0; j < 16; j++) {
   int offset = (((j&1)>>0)<<bit0shift)
            +(((j&2)>>1)<<bit1shift)
            +(((j&4)>>2)<<bit2shift)
      +(((j&8)>>3)<<bit3shift);

   memcpy(rom+j*tilesize, realrom+offset*tilesize, tilesize);
  }
  memcpy(realrom,rom,tilesize*16);
  realrom+=16*tilesize;
}
free(rom);
}

static void cthd2003_neogeo_gfx_address_fix(int start, int end)
{
cthd2003_neogeo_gfx_address_fix_do(start+512*0, end+512*0, 0,3,2,1);
cthd2003_neogeo_gfx_address_fix_do(start+512*1, end+512*1, 1,0,3,2);
cthd2003_neogeo_gfx_address_fix_do(start+512*2, end+512*2, 2,1,0,3);
// skip 3 & 4
cthd2003_neogeo_gfx_address_fix_do(start+512*5, end+512*5, 0,1,2,3);
cthd2003_neogeo_gfx_address_fix_do(start+512*6, end+512*6, 0,1,2,3);
cthd2003_neogeo_gfx_address_fix_do(start+512*7, end+512*7, 0,2,3,1);
}

static void cthd2003_c(int pow)
{
int i;

for (i=0; i<=192; i+=8)
  cthd2003_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=200; i<=392; i+=8)
  cthd2003_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=400; i<=592; i+=8)
  cthd2003_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=600; i<=792; i+=8)
  cthd2003_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=800; i<=992; i+=8)
  cthd2003_neogeo_gfx_address_fix(i*512,i*512+512);

for (i=1000; i<=1016; i+=8)
  cthd2003_neogeo_gfx_address_fix(i*512,i*512+512);
}

DRIVER_INIT (cthd2003)
{
UINT8 *romdata = memory_region(REGION_GFX1);
UINT8*tmp = (UINT8*)malloc(8*128*128);

memcpy(tmp+8*0*128, romdata+8*0*128, 8*32*128);
memcpy(tmp+8*32*128, romdata+8*64*128, 8*32*128);
memcpy(tmp+8*64*128, romdata+8*32*128, 8*32*128);
memcpy(tmp+8*96*128, romdata+8*96*128, 8*32*128);
memcpy(romdata, tmp, 8*128*128);

romdata = memory_region(REGION_CPU2)+0x10000;
  memcpy(tmp+8*0*128, romdata+8*0*128, 8*32*128);
memcpy(tmp+8*32*128, romdata+8*64*128, 8*32*128);
  memcpy(tmp+8*64*128, romdata+8*32*128, 8*32*128);
memcpy(tmp+8*96*128, romdata+8*96*128, 8*32*128);
memcpy(romdata, tmp, 8*128*128);

  free(tmp);

memcpy(romdata-0x10000,romdata,0x10000);

cthd2003_c(0);
  init_neogeo();
}

DRIVER_INIT (ct2k3sp)
{

UINT8 *romdata = memory_region(REGION_CPU2)+0x10000;
UINT8*tmp = (UINT8*)malloc(8*128*128);
  memcpy(tmp+8*0*128, romdata+8*0*128, 8*32*128);
memcpy(tmp+8*32*128, romdata+8*64*128, 8*32*128);
  memcpy(tmp+8*64*128, romdata+8*32*128, 8*32*128);
memcpy(tmp+8*96*128, romdata+8*96*128, 8*32*128);
memcpy(romdata, tmp, 8*128*128);

  free(tmp);
memcpy(romdata-0x10000,romdata,0x10000);
ct2k3sp_sx_decrypt();
cthd2003_c(0);
  init_neogeo();
}

Sign In

Adding games

Recommended Posts

Link to comment

Share on other sites

Top Posters In This Topic

Popular Days

Top Posters In This Topic

Popular Days

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites

Link to comment

Share on other sites