Welcome!

Final Burn Neo => FBN Development => Topic started by: iq_132 on January 17, 2005, 04:06:40 PM

Title: kof2002b infos
Post by: iq_132 on January 17, 2005, 04:06:40 PM

Here's a few things I noticed about kof2002b:

The p2 rom is scrambled the same as the original p2, but there's a few bytes different.
The C roms are scrambled in a (I think) similar way to cthd2003 & svcboot
- The Cs use the same scrambling every 32kb
- In every 32kb chunk, every 64 bytes is moved to a seemingly random position in the 32kb chunk.
- I'm thinking of using a table of 512 offsets to re-order the data.  It's not the best solution, but it will work.

Title: kof2002b driver
Post by: iq_132 on January 24, 2005, 03:34:07 AM

Here's a fully working driver for kof2002b :) Enjoy.

Code: [Select]

// The King Of Fighters 2002 (bootleg)

static struct BurnRomInfo kof2002bRomDesc[] = {
{ "265-p1.bin",  0x100000, 0x9EDE7323, 1 | BRF_ESS | BRF_PRG },  //  0 68K code
{ "2k2-p2b.bin", 0x400000, 0x6DBEE4DF, 1 | BRF_ESS | BRF_PRG },  //  1

{ "2k2-s1b.bin", 0x020000, 0x2255F5BF, 2 | BRF_GRA }, //  2 Text data

{ "2k2-c1b.bin", 0x800000, 0xF25D3D66, 3 | BRF_GRA }, //  3 Sprite data
{ "2k2-c2b.bin", 0x800000, 0xE3E66F1D, 3 | BRF_GRA }, //  4
{ "2k2-c3b.bin", 0x800000, 0x8732FA30, 3 | BRF_GRA }, //  5
{ "2k2-c4b.bin", 0x800000, 0x0989FD40, 3 | BRF_GRA }, //  6
{ "2k2-c5b.bin", 0x800000, 0x60635CD2, 3 | BRF_GRA }, //  7
{ "2k2-c6b.bin", 0x800000, 0xBD736824, 3 | BRF_GRA }, //  8
{ "2k2-c7b.bin", 0x800000, 0x2DA8D8CF, 3 | BRF_GRA }, //  9
{ "2k2-c8b.bin", 0x800000, 0x2048404A, 3 | BRF_GRA }, //  10

{ "265-m1d.bin", 0x020000, 0x1c661a4b, 4 | BRF_ESS | BRF_PRG },  //  11 Z80 code

{ "265-v1.bin",  0x800000, 0x15E8F3F5, 5 | BRF_SND }, //  12 Samples
{ "265-v2.bin",  0x800000, 0xDA41D6F9, 5 | BRF_SND }, //  13
};

STDROMPICKEXT(kof2002b, kof2002b, neogeo);
STD_ROM_FN(kof2002b);

// Driver by IQ_132 -- http;//neosource.1emu.net/
// A big thanks to Bubbawmu2 for helping me sort the table
static void kof2002b_gfx_decrypt(unsigned char* src, int size)
{
unsigned short kof2002b_sec[512] = {
0x001, 0x101, 0x002, 0x102, 0x003, 0x103, 0x004, 0x104, 0x009, 0x089, 0x109, 0x189, 0x00A, 0x08A, 0x10A, 0x18A,
0x011, 0x051, 0x091, 0x0D1, 0x111, 0x151, 0x191, 0x1D1, 0x019, 0x01D, 0x059, 0x05D, 0x099, 0x09D, 0x0D9, 0x0DD,
0x021, 0x023, 0x025, 0x027, 0x061, 0x063, 0x065, 0x067, 0x029, 0x129, 0x0A9, 0x1A9, 0x069, 0x169, 0x0E9, 0x1E9,
0x031, 0x071, 0x0B1, 0x0F1, 0x131, 0x171, 0x1B1, 0x1F1, 0x039, 0x0B9, 0x03A, 0x0BA, 0x03B, 0x0BB, 0x03C, 0x0BC,
0x005, 0x105, 0x006, 0x106, 0x007, 0x107, 0x008, 0x108, 0x00B, 0x08B, 0x10B, 0x18B, 0x00C, 0x08C, 0x10C, 0x18C,
0x012, 0x052, 0x092, 0x0D2, 0x112, 0x152, 0x192, 0x1D2, 0x119, 0x11D, 0x159, 0x15D, 0x199, 0x19D, 0x1D9, 0x1DD,
0x0A1, 0x0A3, 0x0A5, 0x0A7, 0x0E1, 0x0E3, 0x0E5, 0x0E7, 0x02D, 0x12D, 0x0AD, 0x1AD, 0x06D, 0x16D, 0x0ED, 0x1ED,
0x035, 0x075, 0x0B5, 0x0F5, 0x135, 0x175, 0x1B5, 0x1F5, 0x03D, 0x0BD, 0x03E, 0x0BE, 0x03F, 0x0BF, 0x040, 0x0C0,
0x041, 0x141, 0x042, 0x142, 0x043, 0x143, 0x044, 0x144, 0x00D, 0x08D, 0x10D, 0x18D, 0x00E, 0x08E, 0x10E, 0x18E,
0x013, 0x053, 0x093, 0x0D3, 0x113, 0x153, 0x193, 0x1D3, 0x01A, 0x01E, 0x05A, 0x05E, 0x09A, 0x09E, 0x0DA, 0x0DE,
0x121, 0x123, 0x125, 0x127, 0x161, 0x163, 0x165, 0x167, 0x02B, 0x12B, 0x0AB, 0x1AB, 0x06B, 0x16B, 0x0EB, 0x1EB,
0x033, 0x073, 0x0B3, 0x0F3, 0x133, 0x173, 0x1B3, 0x1F3, 0x079, 0x0F9, 0x07A, 0x0FA, 0x07B, 0x0FB, 0x07C, 0x0FC,
0x045, 0x145, 0x046, 0x146, 0x047, 0x147, 0x048, 0x148, 0x00F, 0x08F, 0x10F, 0x18F, 0x010, 0x090, 0x110, 0x190,
0x014, 0x054, 0x094, 0x0D4, 0x114, 0x154, 0x194, 0x1D4, 0x11A, 0x11E, 0x15A, 0x15E, 0x19A, 0x19E, 0x1DA, 0x1DE,
0x1A1, 0x1A3, 0x1A5, 0x1A7, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x02F, 0x12F, 0x0AF, 0x1AF, 0x06F, 0x16F, 0x0EF, 0x1EF,
0x037, 0x077, 0x0B7, 0x0F7, 0x137, 0x177, 0x1B7, 0x1F7, 0x07D, 0x0FD, 0x07E, 0x0FE, 0x07F, 0x0FF, 0x080, 0x100,
0x081, 0x181, 0x082, 0x182, 0x083, 0x183, 0x084, 0x184, 0x049, 0x0C9, 0x149, 0x1C9, 0x04A, 0x0CA, 0x14A, 0x1CA,
0x015, 0x055, 0x095, 0x0D5, 0x115, 0x155, 0x195, 0x1D5, 0x01B, 0x01F, 0x05B, 0x05F, 0x09B, 0x09F, 0x0DB, 0x0DF,
0x022, 0x024, 0x026, 0x028, 0x062, 0x064, 0x066, 0x068, 0x02A, 0x12A, 0x0AA, 0x1AA, 0x06A, 0x16A, 0x0EA, 0x1EA,
0x032, 0x072, 0x0B2, 0x0F2, 0x132, 0x172, 0x1B2, 0x1F2, 0x139, 0x1B9, 0x13A, 0x1BA, 0x13B, 0x1BB, 0x13C, 0x1BC,
0x085, 0x185, 0x086, 0x186, 0x087, 0x187, 0x088, 0x188, 0x04B, 0x0CB, 0x14B, 0x1CB, 0x04C, 0x0CC, 0x14C, 0x1CC,
0x016, 0x056, 0x096, 0x0D6, 0x116, 0x156, 0x196, 0x1D6, 0x11B, 0x11F, 0x15B, 0x15F, 0x19B, 0x19F, 0x1DB, 0x1DF,
0x0A2, 0x0A4, 0x0A6, 0x0A8, 0x0E2, 0x0E4, 0x0E6, 0x0E8, 0x02E, 0x12E, 0x0AE, 0x1AE, 0x06E, 0x16E, 0x0EE, 0x1EE,
0x036, 0x076, 0x0B6, 0x0F6, 0x136, 0x176, 0x1B6, 0x1F6, 0x13D, 0x1BD, 0x13E, 0x1BE, 0x13F, 0x1BF, 0x140, 0x1C0,
0x0C1, 0x1C1, 0x0C2, 0x1C2, 0x0C3, 0x1C3, 0x0C4, 0x1C4, 0x04D, 0x0CD, 0x14D, 0x1CD, 0x04E, 0x0CE, 0x14E, 0x1CE,
0x017, 0x057, 0x097, 0x0D7, 0x117, 0x157, 0x197, 0x1D7, 0x01C, 0x020, 0x05C, 0x060, 0x09C, 0x0A0, 0x0DC, 0x0E0,
0x122, 0x124, 0x126, 0x128, 0x162, 0x164, 0x166, 0x168, 0x02C, 0x12C, 0x0AC, 0x1AC, 0x06C, 0x16C, 0x0EC, 0x1EC,
0x034, 0x074, 0x0B4, 0x0F4, 0x134, 0x174, 0x1B4, 0x1F4, 0x179, 0x1F9, 0x17A, 0x1FA, 0x17B, 0x1FB, 0x17C, 0x1FC,
0x0C5, 0x1C5, 0x0C6, 0x1C6, 0x0C7, 0x1C7, 0x0C8, 0x1C8, 0x04F, 0x0CF, 0x14F, 0x1CF, 0x050, 0x0D0, 0x150, 0x1D0,
0x018, 0x058, 0x098, 0x0D8, 0x118, 0x158, 0x198, 0x1D8, 0x11C, 0x120, 0x15C, 0x160, 0x19C, 0x1A0, 0x1DC, 0x1E0,
0x1A2, 0x1A4, 0x1A6, 0x1A8, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x030, 0x130, 0x0B0, 0x1B0, 0x070, 0x170, 0x0F0, 0x1F0,
0x038, 0x078, 0x0B8, 0x0F8, 0x138, 0x178, 0x1B8, 0x1F8, 0x17D, 0x1FD, 0x17E, 0x1FE, 0x17F, 0x1FF, 0x180, 0x200,
};

int i, j;
unsigned char* dst = (unsigned char*)malloc(0x10000);

for (i = 0; i < size; i+=0x10000)
{
memcpy(dst, src+i,0x10000);

for (j = 0; j < 512; ++j)
{
memcpy(src+i+(kof2002b_sec[j]-1)*128, dst+j*128, 128);
}
}
free(dst);
}

static void kof2002b_decrypt()
{
PCM2DecryptP(); // Program is scrambled the same as original
kof2002b_gfx_decrypt(NeoSpriteROM,     0x4000000); // Sprite and Text are scrambled/encrypted
kof2002b_gfx_decrypt(NeoTextROM+0x20000, 0x20000); // in the same way every 64kb
}

static int kof2002bInit()
{
int nRet;

pNeoInitCallback = kof2002b_decrypt;

nRet = NeoInit();

if (nRet == 0) {
PCM2DecryptVInfo Info = { 0x0A5000, 0x000000, { 0xF9, 0xE0, 0x5D, 0xF3, 0xEA, 0x92, 0xBE, 0xEF } };

PCM2DecryptV(&Info);
}

return nRet;
}

struct BurnDriver BurnDrvkof2002b = {
"kof2002b", "kof2002", "neogeo", "2002",
"The King of Fighters 2002 - challenge to ultimate battle\0", "Bootleg", "Eolith / Playmore Corporation", "Neo Geo",
NULL, NULL, NULL, NULL,
BDF_GAME_WORKING | BDF_CLONE | BDF_BOOTLEG, 2, HARDWARE_SNK_NEOGEO,
NULL, kof2002bRomInfo, kof2002bRomName, neogeoInputInfo, neogeoDIPInfo,
kof2002bInit, NeoExit, NeoFrame, NeoRender, NeoScan, &NeoRecalcPalette,
nNeoScreenWidth, 224, 4, 3
};

Title: kof2002b driver
Post by: bms888 on January 24, 2005, 05:49:44 AM

Quote from: iq_132

Here's a fully working driver for kof2002b :) Enjoy.

Code: [Select]

// The King Of Fighters 2002 (bootleg)

static struct BurnRomInfo kof2002bRomDesc[] = {
{ "265-p1.bin",  0x100000, 0x9EDE7323, 1 | BRF_ESS | BRF_PRG },  //  0 68K code
{ "2k2-p2b.bin", 0x400000, 0x6DBEE4DF, 1 | BRF_ESS | BRF_PRG },  //  1

{ "2k2-s1b.bin", 0x020000, 0x2255F5BF, 2 | BRF_GRA }, //  2 Text data

{ "2k2-c1b.bin", 0x800000, 0xF25D3D66, 3 | BRF_GRA }, //  3 Sprite data
{ "2k2-c2b.bin", 0x800000, 0xE3E66F1D, 3 | BRF_GRA }, //  4
{ "2k2-c3b.bin", 0x800000, 0x8732FA30, 3 | BRF_GRA }, //  5
{ "2k2-c4b.bin", 0x800000, 0x0989FD40, 3 | BRF_GRA }, //  6
{ "2k2-c5b.bin", 0x800000, 0x60635CD2, 3 | BRF_GRA }, //  7
{ "2k2-c6b.bin", 0x800000, 0xBD736824, 3 | BRF_GRA }, //  8
{ "2k2-c7b.bin", 0x800000, 0x2DA8D8CF, 3 | BRF_GRA }, //  9
{ "2k2-c8b.bin", 0x800000, 0x2048404A, 3 | BRF_GRA }, //  10

{ "265-m1d.bin", 0x020000, 0x1c661a4b, 4 | BRF_ESS | BRF_PRG },  //  11 Z80 code

{ "265-v1.bin",  0x800000, 0x15E8F3F5, 5 | BRF_SND }, //  12 Samples
{ "265-v2.bin",  0x800000, 0xDA41D6F9, 5 | BRF_SND }, //  13
};

STDROMPICKEXT(kof2002b, kof2002b, neogeo);
STD_ROM_FN(kof2002b);

// Driver by IQ_132 -- http;//neosource.1emu.net/
// A big thanks to Bubbawmu2 for helping me sort the table
static void kof2002b_gfx_decrypt(unsigned char* src, int size)
{
unsigned short kof2002b_sec[512] = {
0x001, 0x101, 0x002, 0x102, 0x003, 0x103, 0x004, 0x104, 0x009, 0x089, 0x109, 0x189, 0x00A, 0x08A, 0x10A, 0x18A,
0x011, 0x051, 0x091, 0x0D1, 0x111, 0x151, 0x191, 0x1D1, 0x019, 0x01D, 0x059, 0x05D, 0x099, 0x09D, 0x0D9, 0x0DD,
0x021, 0x023, 0x025, 0x027, 0x061, 0x063, 0x065, 0x067, 0x029, 0x129, 0x0A9, 0x1A9, 0x069, 0x169, 0x0E9, 0x1E9,
0x031, 0x071, 0x0B1, 0x0F1, 0x131, 0x171, 0x1B1, 0x1F1, 0x039, 0x0B9, 0x03A, 0x0BA, 0x03B, 0x0BB, 0x03C, 0x0BC,
0x005, 0x105, 0x006, 0x106, 0x007, 0x107, 0x008, 0x108, 0x00B, 0x08B, 0x10B, 0x18B, 0x00C, 0x08C, 0x10C, 0x18C,
0x012, 0x052, 0x092, 0x0D2, 0x112, 0x152, 0x192, 0x1D2, 0x119, 0x11D, 0x159, 0x15D, 0x199, 0x19D, 0x1D9, 0x1DD,
0x0A1, 0x0A3, 0x0A5, 0x0A7, 0x0E1, 0x0E3, 0x0E5, 0x0E7, 0x02D, 0x12D, 0x0AD, 0x1AD, 0x06D, 0x16D, 0x0ED, 0x1ED,
0x035, 0x075, 0x0B5, 0x0F5, 0x135, 0x175, 0x1B5, 0x1F5, 0x03D, 0x0BD, 0x03E, 0x0BE, 0x03F, 0x0BF, 0x040, 0x0C0,
0x041, 0x141, 0x042, 0x142, 0x043, 0x143, 0x044, 0x144, 0x00D, 0x08D, 0x10D, 0x18D, 0x00E, 0x08E, 0x10E, 0x18E,
0x013, 0x053, 0x093, 0x0D3, 0x113, 0x153, 0x193, 0x1D3, 0x01A, 0x01E, 0x05A, 0x05E, 0x09A, 0x09E, 0x0DA, 0x0DE,
0x121, 0x123, 0x125, 0x127, 0x161, 0x163, 0x165, 0x167, 0x02B, 0x12B, 0x0AB, 0x1AB, 0x06B, 0x16B, 0x0EB, 0x1EB,
0x033, 0x073, 0x0B3, 0x0F3, 0x133, 0x173, 0x1B3, 0x1F3, 0x079, 0x0F9, 0x07A, 0x0FA, 0x07B, 0x0FB, 0x07C, 0x0FC,
0x045, 0x145, 0x046, 0x146, 0x047, 0x147, 0x048, 0x148, 0x00F, 0x08F, 0x10F, 0x18F, 0x010, 0x090, 0x110, 0x190,
0x014, 0x054, 0x094, 0x0D4, 0x114, 0x154, 0x194, 0x1D4, 0x11A, 0x11E, 0x15A, 0x15E, 0x19A, 0x19E, 0x1DA, 0x1DE,
0x1A1, 0x1A3, 0x1A5, 0x1A7, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x02F, 0x12F, 0x0AF, 0x1AF, 0x06F, 0x16F, 0x0EF, 0x1EF,
0x037, 0x077, 0x0B7, 0x0F7, 0x137, 0x177, 0x1B7, 0x1F7, 0x07D, 0x0FD, 0x07E, 0x0FE, 0x07F, 0x0FF, 0x080, 0x100,
0x081, 0x181, 0x082, 0x182, 0x083, 0x183, 0x084, 0x184, 0x049, 0x0C9, 0x149, 0x1C9, 0x04A, 0x0CA, 0x14A, 0x1CA,
0x015, 0x055, 0x095, 0x0D5, 0x115, 0x155, 0x195, 0x1D5, 0x01B, 0x01F, 0x05B, 0x05F, 0x09B, 0x09F, 0x0DB, 0x0DF,
0x022, 0x024, 0x026, 0x028, 0x062, 0x064, 0x066, 0x068, 0x02A, 0x12A, 0x0AA, 0x1AA, 0x06A, 0x16A, 0x0EA, 0x1EA,
0x032, 0x072, 0x0B2, 0x0F2, 0x132, 0x172, 0x1B2, 0x1F2, 0x139, 0x1B9, 0x13A, 0x1BA, 0x13B, 0x1BB, 0x13C, 0x1BC,
0x085, 0x185, 0x086, 0x186, 0x087, 0x187, 0x088, 0x188, 0x04B, 0x0CB, 0x14B, 0x1CB, 0x04C, 0x0CC, 0x14C, 0x1CC,
0x016, 0x056, 0x096, 0x0D6, 0x116, 0x156, 0x196, 0x1D6, 0x11B, 0x11F, 0x15B, 0x15F, 0x19B, 0x19F, 0x1DB, 0x1DF,
0x0A2, 0x0A4, 0x0A6, 0x0A8, 0x0E2, 0x0E4, 0x0E6, 0x0E8, 0x02E, 0x12E, 0x0AE, 0x1AE, 0x06E, 0x16E, 0x0EE, 0x1EE,
0x036, 0x076, 0x0B6, 0x0F6, 0x136, 0x176, 0x1B6, 0x1F6, 0x13D, 0x1BD, 0x13E, 0x1BE, 0x13F, 0x1BF, 0x140, 0x1C0,
0x0C1, 0x1C1, 0x0C2, 0x1C2, 0x0C3, 0x1C3, 0x0C4, 0x1C4, 0x04D, 0x0CD, 0x14D, 0x1CD, 0x04E, 0x0CE, 0x14E, 0x1CE,
0x017, 0x057, 0x097, 0x0D7, 0x117, 0x157, 0x197, 0x1D7, 0x01C, 0x020, 0x05C, 0x060, 0x09C, 0x0A0, 0x0DC, 0x0E0,
0x122, 0x124, 0x126, 0x128, 0x162, 0x164, 0x166, 0x168, 0x02C, 0x12C, 0x0AC, 0x1AC, 0x06C, 0x16C, 0x0EC, 0x1EC,
0x034, 0x074, 0x0B4, 0x0F4, 0x134, 0x174, 0x1B4, 0x1F4, 0x179, 0x1F9, 0x17A, 0x1FA, 0x17B, 0x1FB, 0x17C, 0x1FC,
0x0C5, 0x1C5, 0x0C6, 0x1C6, 0x0C7, 0x1C7, 0x0C8, 0x1C8, 0x04F, 0x0CF, 0x14F, 0x1CF, 0x050, 0x0D0, 0x150, 0x1D0,
0x018, 0x058, 0x098, 0x0D8, 0x118, 0x158, 0x198, 0x1D8, 0x11C, 0x120, 0x15C, 0x160, 0x19C, 0x1A0, 0x1DC, 0x1E0,
0x1A2, 0x1A4, 0x1A6, 0x1A8, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x030, 0x130, 0x0B0, 0x1B0, 0x070, 0x170, 0x0F0, 0x1F0,
0x038, 0x078, 0x0B8, 0x0F8, 0x138, 0x178, 0x1B8, 0x1F8, 0x17D, 0x1FD, 0x17E, 0x1FE, 0x17F, 0x1FF, 0x180, 0x200,
};

int i, j;
unsigned char* dst = (unsigned char*)malloc(0x10000);

for (i = 0; i < size; i+=0x10000)
{
memcpy(dst, src+i,0x10000);

for (j = 0; j < 512; ++j)
{
memcpy(src+i+(kof2002b_sec[j]-1)*128, dst+j*128, 128);
}
}
free(dst);
}

static void kof2002b_decrypt()
{
PCM2DecryptP(); // Program is scrambled the same as original
kof2002b_gfx_decrypt(NeoSpriteROM,     0x4000000); // Sprite and Text are scrambled/encrypted
kof2002b_gfx_decrypt(NeoTextROM+0x20000, 0x20000); // in the same way every 64kb
}

static int kof2002bInit()
{
int nRet;

pNeoInitCallback = kof2002b_decrypt;

nRet = NeoInit();

if (nRet == 0) {
PCM2DecryptVInfo Info = { 0x0A5000, 0x000000, { 0xF9, 0xE0, 0x5D, 0xF3, 0xEA, 0x92, 0xBE, 0xEF } };

PCM2DecryptV(&Info);
}

return nRet;
}

struct BurnDriver BurnDrvkof2002b = {
"kof2002b", "kof2002", "neogeo", "2002",
"The King of Fighters 2002 - challenge to ultimate battle\0", "Bootleg", "Eolith / Playmore Corporation", "Neo Geo",
NULL, NULL, NULL, NULL,
BDF_GAME_WORKING | BDF_CLONE | BDF_BOOTLEG, 2, HARDWARE_SNK_NEOGEO,
NULL, kof2002bRomInfo, kof2002bRomName, neogeoInputInfo, neogeoDIPInfo,
kof2002bInit, NeoExit, NeoFrame, NeoRender, NeoScan, &NeoRecalcPalette,
nNeoScreenWidth, 224, 4, 3
};

Well done,IQ! ^_^

Title: kof2002b driver
Post by: neo04 on January 24, 2005, 07:28:35 AM

iq is the man! :) anyway, can anyone please convert to mame?

Title: kof2002b driver
Post by: tcwlee on January 24, 2005, 07:55:48 AM

Code: [Select]

// King of Fighters '02 (bootleg)

static struct BurnRomInfo kof2002blRomDesc[] = {
{"265-p1.bin",  0x100000, 0x9EDE7323, 0x10}, //  0 68K code
{"265-p2b.bin", 0x400000, 0x6dbee4df, 0x10}, //  1

        {"265-s1b.bin", 0x020000, 0x2255f5bf,    1}, //  2 Text layer tiles

        {"kof2k2_c1b.rom", 0x800000, 0xf25d3d66,    1}, //  3 Sprite data
{"kof2k2_c2b.rom", 0x800000, 0xe3e66f1d,    1}, //  4
{"kof2k2_c3b.rom", 0x800000, 0x8732fa30,    1}, //  5
{"kof2k2_c4b.rom", 0x800000, 0x989fd40,    1}, //  6
{"kof2k2_c5b.rom", 0x800000, 0x60635cd2,    1}, //  7
{"kof2k2_c6b.rom", 0x800000, 0xbd736824,    1}, //  8
{"kof2k2_c7b.rom", 0x800000, 0x2da8d8cf,    1}, //  9
{"kof2k2_c8b.rom", 0x800000, 0x2048404a,    1}, // 10

{"kof2k2_m1.rom", 0x020000, 0x1c661a4b, 0x10}, // 11 Z80 code

{"2k2_v1.rom", 0x400000, 0x13d98607,    2}, // 12 Sound data
{"2k2_v2.rom", 0x400000, 0x9cf74677,    2}, // 13
{"2k2_v3.rom", 0x400000, 0x8e9448b5,    2}, // 14
{"2k2_v4.rom", 0x400000, 0x67271b5,    2}, // 15
};

STDROMPICKEXT(kof2002bl, kof2002bl, neogeo);
STD_ROM_FN(kof2002bl);

// Driver by IQ_132 -- http;//neosource.1emu.net/
// A big thanks to Bubbawmu2 for helping me sort the table
static void kof2002b_gfx_decrypt(unsigned char* src, int size)
{
unsigned short kof2002b_sec[512] = {
0x001, 0x101, 0x002, 0x102, 0x003, 0x103, 0x004, 0x104, 0x009, 0x089, 0x109, 0x189, 0x00A, 0x08A, 0x10A, 0x18A,
0x011, 0x051, 0x091, 0x0D1, 0x111, 0x151, 0x191, 0x1D1, 0x019, 0x01D, 0x059, 0x05D, 0x099, 0x09D, 0x0D9, 0x0DD,
0x021, 0x023, 0x025, 0x027, 0x061, 0x063, 0x065, 0x067, 0x029, 0x129, 0x0A9, 0x1A9, 0x069, 0x169, 0x0E9, 0x1E9,
0x031, 0x071, 0x0B1, 0x0F1, 0x131, 0x171, 0x1B1, 0x1F1, 0x039, 0x0B9, 0x03A, 0x0BA, 0x03B, 0x0BB, 0x03C, 0x0BC,
0x005, 0x105, 0x006, 0x106, 0x007, 0x107, 0x008, 0x108, 0x00B, 0x08B, 0x10B, 0x18B, 0x00C, 0x08C, 0x10C, 0x18C,
0x012, 0x052, 0x092, 0x0D2, 0x112, 0x152, 0x192, 0x1D2, 0x119, 0x11D, 0x159, 0x15D, 0x199, 0x19D, 0x1D9, 0x1DD,
0x0A1, 0x0A3, 0x0A5, 0x0A7, 0x0E1, 0x0E3, 0x0E5, 0x0E7, 0x02D, 0x12D, 0x0AD, 0x1AD, 0x06D, 0x16D, 0x0ED, 0x1ED,
0x035, 0x075, 0x0B5, 0x0F5, 0x135, 0x175, 0x1B5, 0x1F5, 0x03D, 0x0BD, 0x03E, 0x0BE, 0x03F, 0x0BF, 0x040, 0x0C0,
0x041, 0x141, 0x042, 0x142, 0x043, 0x143, 0x044, 0x144, 0x00D, 0x08D, 0x10D, 0x18D, 0x00E, 0x08E, 0x10E, 0x18E,
0x013, 0x053, 0x093, 0x0D3, 0x113, 0x153, 0x193, 0x1D3, 0x01A, 0x01E, 0x05A, 0x05E, 0x09A, 0x09E, 0x0DA, 0x0DE,
0x121, 0x123, 0x125, 0x127, 0x161, 0x163, 0x165, 0x167, 0x02B, 0x12B, 0x0AB, 0x1AB, 0x06B, 0x16B, 0x0EB, 0x1EB,
0x033, 0x073, 0x0B3, 0x0F3, 0x133, 0x173, 0x1B3, 0x1F3, 0x079, 0x0F9, 0x07A, 0x0FA, 0x07B, 0x0FB, 0x07C, 0x0FC,
0x045, 0x145, 0x046, 0x146, 0x047, 0x147, 0x048, 0x148, 0x00F, 0x08F, 0x10F, 0x18F, 0x010, 0x090, 0x110, 0x190,
0x014, 0x054, 0x094, 0x0D4, 0x114, 0x154, 0x194, 0x1D4, 0x11A, 0x11E, 0x15A, 0x15E, 0x19A, 0x19E, 0x1DA, 0x1DE,
0x1A1, 0x1A3, 0x1A5, 0x1A7, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x02F, 0x12F, 0x0AF, 0x1AF, 0x06F, 0x16F, 0x0EF, 0x1EF,
0x037, 0x077, 0x0B7, 0x0F7, 0x137, 0x177, 0x1B7, 0x1F7, 0x07D, 0x0FD, 0x07E, 0x0FE, 0x07F, 0x0FF, 0x080, 0x100,
0x081, 0x181, 0x082, 0x182, 0x083, 0x183, 0x084, 0x184, 0x049, 0x0C9, 0x149, 0x1C9, 0x04A, 0x0CA, 0x14A, 0x1CA,
0x015, 0x055, 0x095, 0x0D5, 0x115, 0x155, 0x195, 0x1D5, 0x01B, 0x01F, 0x05B, 0x05F, 0x09B, 0x09F, 0x0DB, 0x0DF,
0x022, 0x024, 0x026, 0x028, 0x062, 0x064, 0x066, 0x068, 0x02A, 0x12A, 0x0AA, 0x1AA, 0x06A, 0x16A, 0x0EA, 0x1EA,
0x032, 0x072, 0x0B2, 0x0F2, 0x132, 0x172, 0x1B2, 0x1F2, 0x139, 0x1B9, 0x13A, 0x1BA, 0x13B, 0x1BB, 0x13C, 0x1BC,
0x085, 0x185, 0x086, 0x186, 0x087, 0x187, 0x088, 0x188, 0x04B, 0x0CB, 0x14B, 0x1CB, 0x04C, 0x0CC, 0x14C, 0x1CC,
0x016, 0x056, 0x096, 0x0D6, 0x116, 0x156, 0x196, 0x1D6, 0x11B, 0x11F, 0x15B, 0x15F, 0x19B, 0x19F, 0x1DB, 0x1DF,
0x0A2, 0x0A4, 0x0A6, 0x0A8, 0x0E2, 0x0E4, 0x0E6, 0x0E8, 0x02E, 0x12E, 0x0AE, 0x1AE, 0x06E, 0x16E, 0x0EE, 0x1EE,
0x036, 0x076, 0x0B6, 0x0F6, 0x136, 0x176, 0x1B6, 0x1F6, 0x13D, 0x1BD, 0x13E, 0x1BE, 0x13F, 0x1BF, 0x140, 0x1C0,
0x0C1, 0x1C1, 0x0C2, 0x1C2, 0x0C3, 0x1C3, 0x0C4, 0x1C4, 0x04D, 0x0CD, 0x14D, 0x1CD, 0x04E, 0x0CE, 0x14E, 0x1CE,
0x017, 0x057, 0x097, 0x0D7, 0x117, 0x157, 0x197, 0x1D7, 0x01C, 0x020, 0x05C, 0x060, 0x09C, 0x0A0, 0x0DC, 0x0E0,
0x122, 0x124, 0x126, 0x128, 0x162, 0x164, 0x166, 0x168, 0x02C, 0x12C, 0x0AC, 0x1AC, 0x06C, 0x16C, 0x0EC, 0x1EC,
0x034, 0x074, 0x0B4, 0x0F4, 0x134, 0x174, 0x1B4, 0x1F4, 0x179, 0x1F9, 0x17A, 0x1FA, 0x17B, 0x1FB, 0x17C, 0x1FC,
0x0C5, 0x1C5, 0x0C6, 0x1C6, 0x0C7, 0x1C7, 0x0C8, 0x1C8, 0x04F, 0x0CF, 0x14F, 0x1CF, 0x050, 0x0D0, 0x150, 0x1D0,
0x018, 0x058, 0x098, 0x0D8, 0x118, 0x158, 0x198, 0x1D8, 0x11C, 0x120, 0x15C, 0x160, 0x19C, 0x1A0, 0x1DC, 0x1E0,
0x1A2, 0x1A4, 0x1A6, 0x1A8, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x030, 0x130, 0x0B0, 0x1B0, 0x070, 0x170, 0x0F0, 0x1F0,
0x038, 0x078, 0x0B8, 0x0F8, 0x138, 0x178, 0x1B8, 0x1F8, 0x17D, 0x1FD, 0x17E, 0x1FE, 0x17F, 0x1FF, 0x180, 0x200,
};

int i, j;
unsigned char* dst = (unsigned char*)malloc(0x10000);

for (i = 0; i < size; i+=0x10000)
{
memcpy(dst, src+i,0x10000);

for (j = 0; j < 512; ++j)
{
memcpy(src+i+(kof2002b_sec[j]-1)*128, dst+j*128, 128);
}
}
free(dst);
}

static void kof2002b_decrypt()
{
kof2002b_gfx_decrypt(NeoSpriteROM,     0x4000000); // Sprite and Text are scrambled/encrypted
kof2002b_gfx_decrypt(NeoTextROM+0x20000, 0x20000); // in the same way every 64kb
}

static int kof2002blInit()
{
int nRet;

pNeoInitCallback = kof2002b_decrypt;

nRet = NeoInit();

if (nRet == 0) {

}

return nRet;
}

struct BurnDriver BurnDrvkof2002bl = {
{"kof2002bl", "King of Fighters '02 (bootleg)", "Alternate version", "SNK", "Neo Geo", "2002", "kof2002", "neogeo"},
BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_SNK_NEOGEO,
NULL, kof2002blRomInfo, kof2002blRomName, neogeoInputInfo, neogeoDIPInfo,
kof2002blInit, NeoExit, NeoFrame, NeoRender, NeoScan, &NeoRecalcPalette,
nNeoScreenWidth, 224, 4, 3
};

WHY DONT PLAY? I USED FBA2.94

Title: kof2002b driver
Post by: JiMMy_PaGe on January 24, 2005, 08:03:44 AM

Thanks iq ! as i always said ur codes rocks xDDD
@tcwlee
U are missing p2b descrambling code, if u dont use it wont work...

Code: [Select]

//descramble code by bms888
static void kof2002b_px_decrypt()
{      
       
int sec[] = { 0x02, 0x05, 0x06, 0x03, 0x00, 0x07, 0x04, 0x01 };

int i, rom_size = 0x400000;
UINT8 *src = Neo68KROM01+0x100000;
UINT8 *dst = (UINT8 *)malloc( rom_size );
 
memcpy( dst, src, rom_size);
for( i=0; i<8; i++){
memcpy( src+i*0x80000, dst+sec[i]*0x80000, 0x80000);
}
free( dst );            
}
Call it again on kof2002b_decrypt:

Code: [Select]

static void kof2002b_decrypt()
{
kof2002b_px_decrypt();
kof2002b_gfx_decrypt(NeoSpriteROM, 0x4000000); // Sprite and Text are scrambled/encrypted
kof2002b_gfx_decrypt(NeoTextROM+0x20000, 0x20000); // in the same way every 64kb
}
See ya
EDIT: I forgot u are using 0.2.94.98

Title: kof2002b driver
Post by: tcwlee on January 24, 2005, 08:20:57 AM

Quote from: Jimmy_Page

Thanks iq ! as i always said ur codes rocks xDDD
@tcwlee
U are missing p2b descrambling code, if u dont use it wont work...

Code: [Select]

//descramble code by bms888
static void kof2002b_px_decrypt()
{      
       
int sec[] = { 0x02, 0x05, 0x06, 0x03, 0x00, 0x07, 0x04, 0x01 };

int i, rom_size = 0x400000;
UINT8 *src = Neo68KROM+0x100000;
UINT8 *dst = (UINT8 *)malloc( rom_size );
 
memcpy( dst, src, rom_size);
for( i=0; i<8; i++){
memcpy( src+i*0x80000, dst+sec[i]*0x80000, 0x80000);
}
free( dst );            
}
Call it again on kof2002b_decrypt:

Code: [Select]

static void kof2002b_decrypt()
{
kof2002b_px_decrypt();
kof2002b_gfx_decrypt(NeoSpriteROM, 0x4000000); // Sprite and Text are scrambled/encrypted
kof2002b_gfx_decrypt(NeoTextROM+0x20000, 0x20000); // in the same way every 64kb
}
See ya
EDIT: I forgot u are using 0.2.94.98

thx^_^

Title: kof2002b driver
Post by: bms888 on January 26, 2005, 09:49:55 AM

Quote from: neo04

iq is the man! :) anyway, can anyone please convert to mame?

ok,mame code is here,^_^!

Code: [Select]


/******************************************************************************/

// Neo-PCM2 PLAYMORE(c) 2002 Sound Chip Emulation
// Original code by Fataku & the vconv (from 2ch)
static void Neo_PCM2_PLAYMORE_2002(int value)
{
// kof2002,matrimelee,samsho5,mslug5 & svcchaos & kof2003 (pcb and mvs),samsh5sp (mvs and aes)
// offset,xor address data
unsigned int addrs[7][2] = {
{0x000000,0xA5000}, //kof2002
{0xFFCE20,0x01000}, //matrimelee
{0xFE2CF6,0x4E001}, //mslug5
{0xFEB2C0,0x0A000}, //samsho5
{0xFFAC28,0xC2000}, //svcchaos
{0xFF14EA,0xA7001}, //kof2003
{0xFFB440,0x02000}, //samsh5sp
};

unsigned int xordata[7][8] = {
{0xF9,0xE0,0x5D,0xF3,0xEA,0x92,0xBE,0xEF}, //kof2002
  {0xC4,0x83,0xA8,0x5F,0x21,0x27,0x64,0xAF}, //matrimelee
{0xC3,0xFD,0x81,0xAC,0x6D,0xE7,0xBF,0x9E}, //mslug5
{0xCB,0x29,0x7D,0x43,0xD2,0x3A,0xC2,0xB4}, //samsho5
{0xC3,0xFD,0x81,0xAC,0x6D,0xE7,0xBF,0x9E}, //svcchaos
{0x4B,0xA4,0x63,0x46,0xF0,0x91,0xEA,0x62}, //kof2003
{0x4B,0xA4,0x63,0x46,0xF0,0x91,0xEA,0x62}, //samsh5sp
};

int i, ofst, rom_size = memory_region_length(REGION_SOUND1);
UINT8 *rom = memory_region(REGION_SOUND1);
UINT8 *buf = malloc( rom_size );

memcpy( buf, rom, rom_size );
for( i=0; i ofst = (i & 0xfefffe) | ((i & 0x010000) >> 16) | ((i & 0x000001) << 16);
ofst ^= addrs[value][1];
rom[ofst] = (buf[((i + addrs[value][0]) & 0xffffff)] ^ xordata[value][(ofst & 0x07)]);
}
free( buf );
}

/******************************************************************************/

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

int i, rom_size = 0x400000;
UINT8 *src = memory_region(REGION_CPU1)+0x100000;
UINT8 *dst = malloc( rom_size );

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

// Code by IQ_132 -- http;//neosource.1emu.net/
// Thanks to Bubbawmu2 for helping me sort the table
static void kof2002b_gfx_decrypt(unsigned char* src, int size)
{
unsigned short kof2002b_sec[512] = {
0x001, 0x101, 0x002, 0x102, 0x003, 0x103, 0x004, 0x104, 0x009, 0x089, 0x109, 0x189, 0x00A, 0x08A, 0x10A, 0x18A,
0x011, 0x051, 0x091, 0x0D1, 0x111, 0x151, 0x191, 0x1D1, 0x019, 0x01D, 0x059, 0x05D, 0x099, 0x09D, 0x0D9, 0x0DD,
0x021, 0x023, 0x025, 0x027, 0x061, 0x063, 0x065, 0x067, 0x029, 0x129, 0x0A9, 0x1A9, 0x069, 0x169, 0x0E9, 0x1E9,
0x031, 0x071, 0x0B1, 0x0F1, 0x131, 0x171, 0x1B1, 0x1F1, 0x039, 0x0B9, 0x03A, 0x0BA, 0x03B, 0x0BB, 0x03C, 0x0BC,
0x005, 0x105, 0x006, 0x106, 0x007, 0x107, 0x008, 0x108, 0x00B, 0x08B, 0x10B, 0x18B, 0x00C, 0x08C, 0x10C, 0x18C,
0x012, 0x052, 0x092, 0x0D2, 0x112, 0x152, 0x192, 0x1D2, 0x119, 0x11D, 0x159, 0x15D, 0x199, 0x19D, 0x1D9, 0x1DD,
0x0A1, 0x0A3, 0x0A5, 0x0A7, 0x0E1, 0x0E3, 0x0E5, 0x0E7, 0x02D, 0x12D, 0x0AD, 0x1AD, 0x06D, 0x16D, 0x0ED, 0x1ED,
0x035, 0x075, 0x0B5, 0x0F5, 0x135, 0x175, 0x1B5, 0x1F5, 0x03D, 0x0BD, 0x03E, 0x0BE, 0x03F, 0x0BF, 0x040, 0x0C0,
0x041, 0x141, 0x042, 0x142, 0x043, 0x143, 0x044, 0x144, 0x00D, 0x08D, 0x10D, 0x18D, 0x00E, 0x08E, 0x10E, 0x18E,
0x013, 0x053, 0x093, 0x0D3, 0x113, 0x153, 0x193, 0x1D3, 0x01A, 0x01E, 0x05A, 0x05E, 0x09A, 0x09E, 0x0DA, 0x0DE,
0x121, 0x123, 0x125, 0x127, 0x161, 0x163, 0x165, 0x167, 0x02B, 0x12B, 0x0AB, 0x1AB, 0x06B, 0x16B, 0x0EB, 0x1EB,
0x033, 0x073, 0x0B3, 0x0F3, 0x133, 0x173, 0x1B3, 0x1F3, 0x079, 0x0F9, 0x07A, 0x0FA, 0x07B, 0x0FB, 0x07C, 0x0FC,
0x045, 0x145, 0x046, 0x146, 0x047, 0x147, 0x048, 0x148, 0x00F, 0x08F, 0x10F, 0x18F, 0x010, 0x090, 0x110, 0x190,
0x014, 0x054, 0x094, 0x0D4, 0x114, 0x154, 0x194, 0x1D4, 0x11A, 0x11E, 0x15A, 0x15E, 0x19A, 0x19E, 0x1DA, 0x1DE,
0x1A1, 0x1A3, 0x1A5, 0x1A7, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x02F, 0x12F, 0x0AF, 0x1AF, 0x06F, 0x16F, 0x0EF, 0x1EF,
0x037, 0x077, 0x0B7, 0x0F7, 0x137, 0x177, 0x1B7, 0x1F7, 0x07D, 0x0FD, 0x07E, 0x0FE, 0x07F, 0x0FF, 0x080, 0x100,
0x081, 0x181, 0x082, 0x182, 0x083, 0x183, 0x084, 0x184, 0x049, 0x0C9, 0x149, 0x1C9, 0x04A, 0x0CA, 0x14A, 0x1CA,
0x015, 0x055, 0x095, 0x0D5, 0x115, 0x155, 0x195, 0x1D5, 0x01B, 0x01F, 0x05B, 0x05F, 0x09B, 0x09F, 0x0DB, 0x0DF,
0x022, 0x024, 0x026, 0x028, 0x062, 0x064, 0x066, 0x068, 0x02A, 0x12A, 0x0AA, 0x1AA, 0x06A, 0x16A, 0x0EA, 0x1EA,
0x032, 0x072, 0x0B2, 0x0F2, 0x132, 0x172, 0x1B2, 0x1F2, 0x139, 0x1B9, 0x13A, 0x1BA, 0x13B, 0x1BB, 0x13C, 0x1BC,
0x085, 0x185, 0x086, 0x186, 0x087, 0x187, 0x088, 0x188, 0x04B, 0x0CB, 0x14B, 0x1CB, 0x04C, 0x0CC, 0x14C, 0x1CC,
0x016, 0x056, 0x096, 0x0D6, 0x116, 0x156, 0x196, 0x1D6, 0x11B, 0x11F, 0x15B, 0x15F, 0x19B, 0x19F, 0x1DB, 0x1DF,
0x0A2, 0x0A4, 0x0A6, 0x0A8, 0x0E2, 0x0E4, 0x0E6, 0x0E8, 0x02E, 0x12E, 0x0AE, 0x1AE, 0x06E, 0x16E, 0x0EE, 0x1EE,
0x036, 0x076, 0x0B6, 0x0F6, 0x136, 0x176, 0x1B6, 0x1F6, 0x13D, 0x1BD, 0x13E, 0x1BE, 0x13F, 0x1BF, 0x140, 0x1C0,
0x0C1, 0x1C1, 0x0C2, 0x1C2, 0x0C3, 0x1C3, 0x0C4, 0x1C4, 0x04D, 0x0CD, 0x14D, 0x1CD, 0x04E, 0x0CE, 0x14E, 0x1CE,
0x017, 0x057, 0x097, 0x0D7, 0x117, 0x157, 0x197, 0x1D7, 0x01C, 0x020, 0x05C, 0x060, 0x09C, 0x0A0, 0x0DC, 0x0E0,
0x122, 0x124, 0x126, 0x128, 0x162, 0x164, 0x166, 0x168, 0x02C, 0x12C, 0x0AC, 0x1AC, 0x06C, 0x16C, 0x0EC, 0x1EC,
0x034, 0x074, 0x0B4, 0x0F4, 0x134, 0x174, 0x1B4, 0x1F4, 0x179, 0x1F9, 0x17A, 0x1FA, 0x17B, 0x1FB, 0x17C, 0x1FC,
0x0C5, 0x1C5, 0x0C6, 0x1C6, 0x0C7, 0x1C7, 0x0C8, 0x1C8, 0x04F, 0x0CF, 0x14F, 0x1CF, 0x050, 0x0D0, 0x150, 0x1D0,
0x018, 0x058, 0x098, 0x0D8, 0x118, 0x158, 0x198, 0x1D8, 0x11C, 0x120, 0x15C, 0x160, 0x19C, 0x1A0, 0x1DC, 0x1E0,
0x1A2, 0x1A4, 0x1A6, 0x1A8, 0x1E2, 0x1E4, 0x1E6, 0x1E8, 0x030, 0x130, 0x0B0, 0x1B0, 0x070, 0x170, 0x0F0, 0x1F0,
0x038, 0x078, 0x0B8, 0x0F8, 0x138, 0x178, 0x1B8, 0x1F8, 0x17D, 0x1FD, 0x17E, 0x1FE, 0x17F, 0x1FF, 0x180, 0x200,
};

int i, j;
unsigned char* dst = (unsigned char*)malloc(0x10000);

for (i = 0; i < size; i+=0x10000){
memcpy(dst, src+i,0x10000);

for (j = 0; j < 512; ++j){
memcpy(src+i+(kof2002b_sec[j]-1)*128, dst+j*128, 128);
}
}
free(dst);
}

DRIVER_INIT( kof2002b )
{
kof2002_px_decrypt(); // Program is scrambled the same as original
Neo_PCM2_PLAYMORE_2002(0);
kof2002b_gfx_decrypt((memory_region( REGION_GFX3 )), 0x4000000); // Sprite and Text are scrambled/encrypted
kof2002b_gfx_decrypt((memory_region( REGION_GFX1 )), 0x20000); // in the same way every 64kb

init_neogeo();
}


Title: kof2002b driver
Post by: babytek on January 26, 2005, 01:54:13 PM

thanks bms ;)

Title: kof2002b driver
Post by: neo04 on January 27, 2005, 06:19:04 AM

thx bms! :)

Title: kof2002b driver
Post by: FerchogtX on January 27, 2005, 12:52:31 PM

Thanks for this IQ :D and bms
See ya!!!!! :D :D

Title: kof2002b driver
Post by: iq_132 on January 30, 2005, 02:56:51 PM

Here's an updated version of the decryption code.  All of these values are correct and were generated by a program I wrote, which is attached (source included).

Code: [Select]

// Decryption code by IQ_132 -- http://neosource.1emu.net/
static void kof2002b_gfx_decrypt(unsigned char* src, int size)
{
unsigned short kof2002b_sec[512] = {
0x000, 0x100, 0x001, 0x101, 0x002, 0x102, 0x003, 0x103, 0x008, 0x088, 0x108, 0x188, 0x009, 0x089, 0x109, 0x189,
0x010, 0x050, 0x090, 0x0D0, 0x110, 0x150, 0x190, 0x1D0, 0x018, 0x01C, 0x058, 0x05C, 0x098, 0x09C, 0x0D8, 0x0DC,
0x020, 0x022, 0x024, 0x026, 0x060, 0x062, 0x064, 0x066, 0x028, 0x128, 0x0A8, 0x1A8, 0x068, 0x168, 0x0E8, 0x1E8,
0x030, 0x070, 0x0B0, 0x0F0, 0x130, 0x170, 0x1B0, 0x1F0, 0x038, 0x0B8, 0x039, 0x0B9, 0x03A, 0x0BA, 0x03B, 0x0BB,
0x004, 0x104, 0x005, 0x105, 0x006, 0x106, 0x007, 0x107, 0x00A, 0x08A, 0x10A, 0x18A, 0x00B, 0x08B, 0x10B, 0x18B,
0x011, 0x051, 0x091, 0x0D1, 0x111, 0x151, 0x191, 0x1D1, 0x118, 0x11C, 0x158, 0x15C, 0x198, 0x19C, 0x1D8, 0x1DC,
0x0A0, 0x0A2, 0x0A4, 0x0A6, 0x0E0, 0x0E2, 0x0E4, 0x0E6, 0x02C, 0x12C, 0x0AC, 0x1AC, 0x06C, 0x16C, 0x0EC, 0x1EC,
0x034, 0x074, 0x0B4, 0x0F4, 0x134, 0x174, 0x1B4, 0x1F4, 0x03C, 0x0BC, 0x03D, 0x0BD, 0x03E, 0x0BE, 0x03F, 0x0BF,
0x040, 0x140, 0x041, 0x141, 0x042, 0x142, 0x043, 0x143, 0x00C, 0x08C, 0x10C, 0x18C, 0x00D, 0x08D, 0x10D, 0x18D,
0x012, 0x052, 0x092, 0x0D2, 0x112, 0x152, 0x192, 0x1D2, 0x019, 0x01D, 0x059, 0x05D, 0x099, 0x09D, 0x0D9, 0x0DD,
0x120, 0x122, 0x124, 0x126, 0x160, 0x162, 0x164, 0x166, 0x02A, 0x12A, 0x0AA, 0x1AA, 0x06A, 0x16A, 0x0EA, 0x1EA,
0x032, 0x072, 0x0B2, 0x0F2, 0x132, 0x172, 0x1B2, 0x1F2, 0x078, 0x0F8, 0x079, 0x0F9, 0x07A, 0x0FA, 0x07B, 0x0FB,
0x044, 0x144, 0x045, 0x145, 0x046, 0x146, 0x047, 0x147, 0x00E, 0x08E, 0x10E, 0x18E, 0x00F, 0x08F, 0x10F, 0x18F,
0x013, 0x053, 0x093, 0x0D3, 0x113, 0x153, 0x193, 0x1D3, 0x119, 0x11D, 0x159, 0x15D, 0x199, 0x19D, 0x1D9, 0x1DD,
0x1A0, 0x1A2, 0x1A4, 0x1A6, 0x1E0, 0x1E2, 0x1E4, 0x1E6, 0x02E, 0x12E, 0x0AE, 0x1AE, 0x06E, 0x16E, 0x0EE, 0x1EE,
0x036, 0x076, 0x0B6, 0x0F6, 0x136, 0x176, 0x1B6, 0x1F6, 0x07C, 0x0FC, 0x07D, 0x0FD, 0x07E, 0x0FE, 0x07F, 0x0FF,
0x080, 0x180, 0x081, 0x181, 0x082, 0x182, 0x083, 0x183, 0x048, 0x0C8, 0x148, 0x1C8, 0x049, 0x0C9, 0x149, 0x1C9,
0x014, 0x054, 0x094, 0x0D4, 0x114, 0x154, 0x194, 0x1D4, 0x01A, 0x01E, 0x05A, 0x05E, 0x09A, 0x09E, 0x0DA, 0x0DE,
0x021, 0x023, 0x025, 0x027, 0x061, 0x063, 0x065, 0x067, 0x029, 0x129, 0x0A9, 0x1A9, 0x069, 0x169, 0x0E9, 0x1E9,
0x031, 0x071, 0x0B1, 0x0F1, 0x131, 0x171, 0x1B1, 0x1F1, 0x138, 0x1B8, 0x139, 0x1B9, 0x13A, 0x1BA, 0x13B, 0x1BB,
0x084, 0x184, 0x085, 0x185, 0x086, 0x186, 0x087, 0x187, 0x04A, 0x0CA, 0x14A, 0x1CA, 0x04B, 0x0CB, 0x14B, 0x1CB,
0x015, 0x055, 0x095, 0x0D5, 0x115, 0x155, 0x195, 0x1D5, 0x11A, 0x11E, 0x15A, 0x15E, 0x19A, 0x19E, 0x1DA, 0x1DE,
0x0A1, 0x0A3, 0x0A5, 0x0A7, 0x0E1, 0x0E3, 0x0E5, 0x0E7, 0x02D, 0x12D, 0x0AD, 0x1AD, 0x06D, 0x16D, 0x0ED, 0x1ED,
0x035, 0x075, 0x0B5, 0x0F5, 0x135, 0x175, 0x1B5, 0x1F5, 0x13C, 0x1BC, 0x13D, 0x1BD, 0x13E, 0x1BE, 0x13F, 0x1BF,
0x0C0, 0x1C0, 0x0C1, 0x1C1, 0x0C2, 0x1C2, 0x0C3, 0x1C3, 0x04C, 0x0CC, 0x14C, 0x1CC, 0x04D, 0x0CD, 0x14D, 0x1CD,
0x016, 0x056, 0x096, 0x0D6, 0x116, 0x156, 0x196, 0x1D6, 0x01B, 0x01F, 0x05B, 0x05F, 0x09B, 0x09F, 0x0DB, 0x0DF,
0x121, 0x123, 0x125, 0x127, 0x161, 0x163, 0x165, 0x167, 0x02B, 0x12B, 0x0AB, 0x1AB, 0x06B, 0x16B, 0x0EB, 0x1EB,
0x033, 0x073, 0x0B3, 0x0F3, 0x133, 0x173, 0x1B3, 0x1F3, 0x178, 0x1F8, 0x179, 0x1F9, 0x17A, 0x1FA, 0x17B, 0x1FB,
0x0C4, 0x1C4, 0x0C5, 0x1C5, 0x0C6, 0x1C6, 0x0C7, 0x1C7, 0x04E, 0x0CE, 0x14E, 0x1CE, 0x04F, 0x0CF, 0x14F, 0x1CF,
0x017, 0x057, 0x097, 0x0D7, 0x117, 0x157, 0x197, 0x1D7, 0x11B, 0x11F, 0x15B, 0x15F, 0x19B, 0x19F, 0x1DB, 0x1DF,
0x1A1, 0x1A3, 0x1A5, 0x1A7, 0x1E1, 0x1E3, 0x1E5, 0x1E7, 0x02F, 0x12F, 0x0AF, 0x1AF, 0x06F, 0x16F, 0x0EF, 0x1EF,
0x037, 0x077, 0x0B7, 0x0F7, 0x137, 0x177, 0x1B7, 0x1F7, 0x17C, 0x1FC, 0x17D, 0x1FD, 0x17E, 0x1FE, 0x17F, 0x1FF,
};

int i, j;
unsigned char* dst = (unsigned char*)malloc(0x10000);

for (i = 0; i < size; i+=0x10000)
{
memcpy(dst, src+i,0x10000);

for (j = 0; j < 512; ++j)
{
memcpy(src+i+kof2002b_sec[j]*128, dst+j*128, 128);
}
}
free(dst);
}

Code: [Select]

static void kof2002b_decrypt()
{
PCM2DecryptP(); // Program is scrambled the same as original
kof2002b_gfx_decrypt(NeoSpriteROM,     0x4000000); // Sprite and Text are scrambled/encrypted
kof2002b_gfx_decrypt(NeoTextROM+0x20000, 0x20000); // in the same way every 64kb
}

Title: kof2002b driver
Post by: iq_132 on February 14, 2005, 04:52:03 AM

Here's some updated encryption code.

Code: [Select]

// Decryption code by IQ_132 -- http;//neosource.1emu.net/
static void kof2002b_gfx_decrypt(unsigned char* src, int size)
{
unsigned short decrypt[8][8] = {
{0x000, 0x100, 0x001, 0x101, 0x002, 0x102, 0x003, 0x103},
{0x000, 0x080, 0x100, 0x180, 0x001, 0x081, 0x101, 0x181},
{0x000, 0x040, 0x080, 0x0C0, 0x100, 0x140, 0x180, 0x1C0},
{0x000, 0x004, 0x040, 0x044, 0x080, 0x084, 0x0C0, 0x0C4},
{0x000, 0x002, 0x004, 0x006, 0x040, 0x042, 0x044, 0x046},
{0x000, 0x100, 0x080, 0x180, 0x040, 0x140, 0x0C0, 0x1C0},
{0x000, 0x040, 0x080, 0x0C0, 0x100, 0x140, 0x180, 0x1C0},
{0x000, 0x080, 0x001, 0x081, 0x002, 0x082, 0x003, 0x083},
};

unsigned short offset[8][8] = {
{0x000, 0x008, 0x010, 0x018, 0x020, 0x028, 0x030, 0x038},
{0x004, 0x00A, 0x011, 0x118, 0x0A0, 0x02C, 0x034, 0x03C},
{0x040, 0x00C, 0x012, 0x019, 0x120, 0x02A, 0x032, 0x078},
{0x044, 0x00E, 0x013, 0x119, 0x1A0, 0x02E, 0x036, 0x07C},
{0x080, 0x048, 0x014, 0x01A, 0x021, 0x029, 0x031, 0x138},
{0x084, 0x04A, 0x015, 0x11A, 0x0A1, 0x02D, 0x035, 0x13C},
{0x0C0, 0x04C, 0x016, 0x01B, 0x121, 0x02B, 0x033, 0x178},
{0x0C4, 0x04E, 0x017, 0x11B, 0x1A1, 0x02F, 0x037, 0x17C},
};

int i, j, k, m, ofst;
unsigned char* dst = (unsigned char*)malloc(0x10000);
for (i = 0; i < size; i+=0x10000)
{
memcpy(dst, src+i, 0x10000);

for (j = 0; j < 8; j++)
{
for (k = 0; k < 8; k++)
{
for (m = 0; m < 8; m++)
{
ofst = offset[j][k]+decrypt[k][m];
memcpy(src+i+ofst*128, dst+j*0x2000+k*0x400+m*128, 128);
}
}
}
}
free(dst);
}

Code: [Select]

static void kof2002b_decrypt()
{
PCM2DecryptP();
kof2002b_gfx_decrypt(NeoSpriteROM, 0x4000000);
kof2002b_gfx_decrypt(NeoTextROM+0x20000, 0x20000);
}

Title: Re: kof2002b infos
Post by: iq_132 on August 02, 2005, 03:53:20 PM

Went back and took a look at how this works again :)

I think this is really a much better solution, and it actually deals with the addresses instead of kludging it.
Again, this is a low ram version.

Code: [Select]

void kof2002b_gfx_decrypt(unsigned char* src, int size)
{
int t[8][6] =
{
{ 0, 8, 7, 6, 2, 1 },
{ 1, 0, 8, 7, 6, 2 },
{ 2, 1, 0, 8, 7, 6 },
{ 6, 2, 1, 0, 8, 7 },
{ 7, 6, 2, 1, 0, 8 },
{ 0, 1, 2, 6, 7, 8 },
{ 2, 1, 0, 6, 7, 8 },
{ 8, 0, 7, 6, 2, 1 },
};

unsigned char* dst = (unsigned char*)malloc(0x10000);

for (int i = 0; i < size; i+=0x10000)
{
memcpy(dst, src+i,0x10000);

for (int j = 0; j < 0x200; j++)
{
int n = ((j>>3)&7);
int ofst = BITSWAP16(j, 15, 14, 13, 12, 11, 10, 9, t[n][0], t[n][1], t[n][2], 5, 4, 3, t[n][3], t[n][4], t[n][5]);
memcpy(src+i+ofst*128, dst+j*128, 128);
}
}
free(dst);
}

Title: Re: kof2002b infos
Post by: FerchogtX on August 02, 2005, 08:35:01 PM

Thanks for this man!!!!
See ya!!!! :biggrin:

Title: Re: kof2002b infos
Post by: James33 on August 08, 2005, 05:12:46 AM

Great stuff :)

Now to try and do a Mame conversion .

Title: Re: kof2002b infos
Post by: iq_132 on August 09, 2005, 01:57:01 AM

How about this James ;)

Code: [Select]

// Decryption code by IQ_132 -- http;//neosource.1emu.net
void kof2002b_gfx_decrypt(UINT8 *src, int size)
{
int i, j;
int t[8][10] =
{
{ 0, 8, 7, 5, 4, 3, 6, 2, 1 },
{ 1, 0, 8, 5, 4, 3, 7, 6, 2 },
{ 2, 1, 0, 5, 4, 3, 8, 7, 6 },
{ 6, 2, 1, 5, 4, 3, 0, 8, 7 },
{ 7, 6, 2, 5, 4, 3, 1, 0, 8 },
{ 0, 1, 2, 5, 4, 3, 6, 7, 8 },
{ 2, 1, 0, 5, 4, 3, 6, 7, 8 },
{ 8, 0, 7, 5, 4, 3, 6, 2, 1 },
};

UINT8 *dst = malloc(0x10000);

for (i = 0; i < size; i+=0x10000)
{
memcpy(dst, src+i,0x10000);

for (j = 0; j < 0x200; j++)
{
int n = ((j % 0x40) / 8);
int ofst = BITSWAP16(j, 15, 14, 13, 12, 11, 10, 9, t[n][0], t[n][1], t[n][2],
        5, 4, 3, t[n][6], t[n][7], t[n][8]);
memcpy(src+i+ofst*128, dst+j*128, 128);
}
}
free(dst);
}

DRIVER_INIT( kof2002b )
{

kof2002b_gfx_decrypt(memory_region(REGION_GFX3), 0x4000000);
kof2002b_gfx_decrypt(memory_region(REGION_GFX1), 0x0020000);

Title: Re: kof2002b infos
Post by: James33 on August 09, 2005, 02:36:59 AM

I will give it a test . Thanks IQ :)


EDIT
Yep it seems to work :)


This is how I added it to Mame .

Code: [Select]

// Decryption code by IQ_132 -- http;//neosource.1emu.net
void kof2002b_gfx_decrypt(UINT8 *src, int size)
{
int i, j;
int t[8][10] =
{
{ 0, 8, 7, 3, 4, 5, 6, 2, 1 },
{ 1, 0, 8, 4, 5, 3, 7, 6, 2 },
{ 2, 1, 0, 3, 4, 5, 8, 7, 6 },
{ 6, 2, 1, 5, 3, 4, 0, 8, 7 },
{ 7, 6, 2, 5, 3, 4, 1, 0, 8 },
{ 0, 1, 2, 3, 4, 5, 6, 7, 8 },
{ 2, 1, 0, 4, 5, 3, 6, 7, 8 },
{ 8, 0, 7, 3, 4, 5, 6, 2, 1 },
};

UINT8 *dst = malloc(0x10000);

for (i = 0; i < size; i+=0x10000)
{
memcpy(dst, src+i,0x10000);

for (j = 0; j < 0x200; j++)
{
int n = ((j % 0x40) / 8);
int ofst = BITSWAP16(j, 15, 14, 13, 12, 11, 10, 9, t[n][0], t[n][1], t[n][2],
        t[n][3], t[n][4], t[n][5], t[n][6], t[n][7], t[n][8]);
memcpy(src+i+ofst*128, dst+j*128, 128);
}
}
free(dst);
}

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

int i, rom_size = 0x400000;
UINT8 *src = memory_region(REGION_CPU1)+0x100000;
UINT8 *dst = malloc( rom_size );
 
memcpy( dst, src, rom_size);
for( i=0; i<8; i++){
memcpy( src+i*0x80000, dst+sec[i]*0x80000, 0x80000);
}
free( dst );

kof2002b_gfx_decrypt(memory_region(REGION_GFX3), 0x4000000);
kof2002b_gfx_decrypt(memory_region(REGION_GFX1), 0x0020000);

neo_pcm2_playmore_2002(0); // kof2002
neogeo_fix_bank_type = 0;
init_neogeo();
}

Title: Re: kof2002b infos
Post by: FerchogtX on August 15, 2005, 10:59:48 PM

Hem... I have a problem here I hope that you can help me IQ (i tried to see you on Mesenger but you were away)
I have this for patching the m1 rom in kof2k2 plus as you know (or some of you know) kof2002b misses sounds (in the real cart), but in the plus versions the use a "fix" for that, so the Orochi team BGM and other stuff is fixed.
Can you help me making this code "shorter"?... this can geive a headache to the best lector XD
Thanks in advance
See ya!!!!! :biggrin:

Title: Re: kof2002b infos
Post by: CaptainCPS on August 16, 2005, 11:51:09 AM

Ok i edited the code Wheuu!! xDDD lot of code there...xDD wow 2758 lines of
patching? right? or that's not patching xD...

well now is more readable i think, and i added something missing ...that was the '' ; '' sign after
every line of code...that hurts xDD

I know IQ can do more for the code ...than i did. So i hope IQ get some time for this ^^

SeeYaa!!!
:-D

Title: Re: kof2002b infos
Post by: FerchogtX on August 16, 2005, 08:59:59 PM

Hem... i had another thing in mind XD... maybe a table with values or somethig like that (more or less like the svcchaos patch that was released some time ago before the real bankswitch)
Thanks anyway... but that stills big XD
See ya!!!! :biggrin:

Title: Re: kof2002b infos
Post by: iq_132 on August 17, 2005, 01:51:15 AM

Tell me what crc source and changed m1, and I'll make that for you no problem ;)

Title: Re: kof2002b infos
Post by: FerchogtX on August 18, 2005, 12:26:00 PM

From CRC32 AB9D360E to CRC32 (fix) F6FAB859
The last is a fix for kof2002 some time ago... but is used in the plus bootlegs so, for avoiding to use another m1 i prefer to make a table to patch it XD
Thanks in advance
See ya!!!! :biggrin:

Title: Re: kof2002b infos
Post by: iq_132 on August 20, 2005, 10:12:09 PM

Here ya go.  it's only 300 lines long instead of 5000 lol :p

Title: Re: kof2002b infos
Post by: Shoometsu on August 21, 2005, 01:57:56 PM

did you guys tested this code with the system configured as normal bios, mvs system and asia/euro region ? the game don't start nly in this config here... my code:

Code: [Select]

// The King of Fighters 2002 (bootleg)

static struct BurnRomInfo kof2002bRomDesc[] = {
 {"265-p1.bin", 0x100000, 0x9ede7323, 1 | BRF_ESS | BRF_PRG },
 {"265b-p2.bin", 0x400000, 0x6dbee4df, 1 | BRF_ESS | BRF_PRG },

 {"265b-s1.bin", 0x020000, 0x2255f5bf, 2 | BRF_GRA },

 {"265b-c1.bin", 0x800000, 0xf25d3d66, 3 | BRF_GRA },
 {"265b-c2.bin", 0x800000, 0xe3e66f1d, 3 | BRF_GRA },
 {"265b-c3.bin", 0x800000, 0x8732fa30, 3 | BRF_GRA },
 {"265b-c4.bin", 0x800000, 0x0989fd40, 3 | BRF_GRA },
 {"265b-c5.bin", 0x800000, 0x60635cd2, 3 | BRF_GRA },
 {"265b-c6.bin", 0x800000, 0xbd736824, 3 | BRF_GRA },
 {"265b-c7.bin", 0x800000, 0x2da8d8cf, 3 | BRF_GRA },
 {"265b-c8.bin", 0x800000, 0x2048404a, 3 | BRF_GRA },

 { "265-m1d.bin", 0x020000, 0x1C661A4B, 4 | BRF_ESS | BRF_PRG },

 {"265b-v1d.bin", 0x400000, 0x13D98607, 5 | BRF_SND },
 {"265b-v2d.bin", 0x400000, 0x9CF74677, 5 | BRF_SND },
 {"265b-v3d.bin", 0x400000, 0x8E9448B5, 5 | BRF_SND },
 {"265b-v4d.bin", 0x400000, 0x067271B5, 5 | BRF_SND },
};

STDROMPICKEXT(kof2002b, kof2002b, neogeo);
STD_ROM_FN(kof2002b);

// Code by IQ_132

void kof2002b_gfx_decrypt(unsigned char *src, int size)
{
int i, j;
int t[8][10] =
{
{ 0, 8, 7, 3, 4, 5, 6, 2, 1 },
{ 1, 0, 8, 4, 5, 3, 7, 6, 2 },
{ 2, 1, 0, 3, 4, 5, 8, 7, 6 },
{ 6, 2, 1, 5, 3, 4, 0, 8, 7 },
{ 7, 6, 2, 5, 3, 4, 1, 0, 8 },
{ 0, 1, 2, 3, 4, 5, 6, 7, 8 },
{ 2, 1, 0, 4, 5, 3, 6, 7, 8 },
{ 8, 0, 7, 3, 4, 5, 6, 2, 1 },
};

unsigned char *dst = (unsigned char*)malloc(0x10000);

for (i = 0; i < size; i+=0x10000)
{
memcpy(dst, src+i,0x10000);

for (j = 0; j < 0x200; j++)
{
int n = ((j % 0x40) / 8);
int ofst = BITSWAP16(j, 15, 14, 13, 12, 11, 10, 9, t[n][0], t[n][1], t[n][2],t[n][3], t[n][4], t[n][5], t[n][6], t[n][7], t[n][8]);
memcpy(src+i+ofst*128, dst+j*128, 128);
}
}

free(dst);
}

// Descramble code by bms888
static void kof2002b_px_decrypt()
{       
       
int sec[] = { 0x02, 0x05, 0x06, 0x03, 0x00, 0x07, 0x04, 0x01 };

int i, rom_size = 0x400000;
UINT8 *src = Neo68KROM+0x100000;
UINT8 *dst = (UINT8 *)malloc( rom_size );

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

static void kof2002b_decrypt()
{
kof2002b_px_decrypt();
kof2002b_gfx_decrypt(NeoSpriteROM,     0x4000000);// Sprite and Text are scrambled/encrypted
kof2002b_gfx_decrypt(NeoTextROM+0x20000, 0x20000);// in the same way every 64kb
}

//

static int kof2002bInit()
{
int nRet;

pNeoInitCallback = kof2002b_decrypt;

nRet = NeoInit();

return nRet;
}

struct BurnDriver BurnDrvkof2002b = {
"kof2002b", "kof2002", "neogeo", "2002",
"The King of Fighters 2002 (bootleg)\0", NULL, "SNK", "Neo Geo",
NULL, NULL, NULL, NULL,
BDF_GAME_WORKING | BDF_CLONE | BDF_BOOTLEG, 2, HARDWARE_SNK_NEOGEO,
NULL, kof2002bRomInfo, kof2002bRomName, neogeoInputInfo, neogeoDIPInfo,
kof2002bInit, NeoExit, NeoFrame, NeoRender, NeoScan, &NeoRecalcPalette,
nNeoScreenWidth, 224, 4, 3
};

Title: Re: kof2002b infos
Post by: iq_132 on August 21, 2005, 04:01:55 PM

I don't see anything wrong with your driver, and I just tested mine, and it works fine with every bios tested...  :confused:
Maybe something else in your build is messed up?

Title: Re: kof2002b infos
Post by: FerchogtX on August 21, 2005, 04:56:26 PM

Quote from: iq_132 on August 20, 2005, 10:12:09 PM

Here ya go.  it's only 300 lines long instead of 5000 lol :p

Thanks a lot man!!! I'll test inmedia
See ya!!!! :biggrin:

Title: Re: kof2002b infos
Post by: Shoometsu on August 22, 2005, 09:54:28 PM

if it's working with you, must be another issue from my build (I'm expect anything afther that tmnt gfx bug :P )

edit 28.08.o5

wow, the same code is working now, I don't know what happened... I'm thinking about to add "cursed" to my build's name :P