Topic: kof2002b infos

[iq_132]

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.

[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
};

[bms888]

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! ^_^

[neo04]

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

[tcwlee]

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

[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 = 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

[tcwlee]

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^_^

[bms888]

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();
}


[babytek]

thanks bms

[neo04]

thx bms!

[FerchogtX]

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

[iq_132]

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
}

[iq_132]

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);
}

[iq_132]

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);
}

[FerchogtX]

Thanks for this man!!!!
See ya!!!!