Written by Fiel in the C/C++ programming languages. So what is NXPatcher? It’s a program I developed in early June 2009. At the time I was extremely frustrated with Nexon’s patching system, so I decided to write my own Maplestory pre-patcher and made it open source and free to redistribute. NXPatcher does more than just create pre-patchers, it can also read patch files directly, determine the version of maplestory you’re using, split apart pre-patchers, and a lot more! I’ve spent more than 10 months writing this product and have examined every line of code. If you want a fast way to make Maplestory pre-patchers or if you’re looking for freedom from the dreaded Nexon pre-patchers, you’ve come to the right place! Since I wrote this program I have not used a Nexon Pre-patcher once, patched hundreds of times, and saved myself countless headaches. This is the program I trust and use for all of my patching needs.

Which version to choose? Lite or Advanced?

NXPatcher Lite Version

If you consider yourself not very computer savvy or just want to make pre-patchers in a very simple way, I recommend that you pick NXPatcher Lite. The Lite version only creates Nexon pre-patchers and does not contain any other features. Choosing NXPatcher Lite is also a good idea if you’re interested in making pre-patchers for others. Please view the “Lite – Create Your Own Pre-patcher” spoiler below.

NXPatcher Advanced Version

If you are more technical minded, want fine-grained control over the patching process, or want to get away from Nexon pre-patchers, I recommend you pick NXPatcher Advanced. All of the documentation needed to run the Advanced version can be found in the spoilers marked “Advanced” below. Please view the “Advanced – Patch it yourself” spoiler below

Licensing:

Credit to “Fiel” for the source code isn’t required, but appreciated. You may use the source code and any binaries in this topic for any use that you require. You may also redistribute this code and all binaries.

Disclaimer

This program is not affiliated with or endorsed by the Nexon Corporation or any of its subsidiaries in any way.
This program comes as is and with all faults. I, Fiel, disclaim any warranty of merchantability or fitness for a particular purpose. Use this program at your own risk.

Lite – Create your own Pre-patcher

Tutorial: How to make a Maplestory pre-patcher.
Time to completion: 2-3 minutes
Required files: NXPatcher.exe

PLEASE NOTE!: NXPatcherLite has recently updated to version 2.1. This version behaves differently from other versions.

How to do it:
1. Place NXPatcher.exe in your Maplestory directory.
2. Download the patch file from Nexon’s FTP:

Here’s what the patch file URL is for 0.72:
http://download2.nexon.net/Game/MapleStory/patch/patchdir/00072/00071to00072.patch

for 0.73:
http://download2.nexon.net/Game/MapleStory/patch/patchdir/00073/00072to00073.patch

Just look at the links to figure out how to get your patch files. It’s really hard to describe, but very easy to comprehend.

When you download the patch file, download it to your maplestory directory.

3. After the patch file is fully downloaded, simply drag & drop the file onto NXPatcher.exe. The program creates the pre-patcher for you.
4. After the prepatcher is created, NXPatcher will ask you if you want to run the prepatcher.

Alternate Method 1:
3. After downloading the patch file, simply double click on NXPatcher.exe to run it.
4. A dialog window appears asking you to select the patch file. Select the patch file.
5. NXPatcher will create the patcher then ask you if you want to run it.

Alternate Method 2:
3. After the patch file is fully downloaded, right click on it, click on "Open With", then click on "Choose Default Program".
4. In the window that appears, select "Browse", and search for NXPatcher.exe. Once you’ve found NXPatcher.exe, double click on it.
5. Click on "OK" to make NXPatcher.exe the default program for patch files.
6. Now every time you want to create a pre-patcher, simply double-click on the patch file and NXPatcher will create a pre-patcher for you.

Enjoy!

Lite – Troubleshooting

Q: I created a pre-patcher with NXPatcher Lite, but it’s stuck on Base.wz.
A: I did not write Nexon’s horrible pre-patcher, only my own NXPatcher. I can’t help you with this problem as I did not write their code.

Q: I created a pre-patcher with NXPatcher Lite, but it’s stuck on "Checking the Files".
A: This likely means that your patch file that you downloaded from Nexon is corrupt. Redownload the file. Please consider trying a download manager.

Q: The program won’t work and I can’t find a solution in this troubleshooting section.
A: Post your problem in this thread. I’m around most days.

Lite – Errors

ERROR 1001 – BAD FILE NAME

• Error: This error is thrown if the patch file you selected does not exactly conform to the following naming scheme: \d\d\d\d\dto\d\d\d\d\d.patch (where "\d" means any number 0-9).
• Solution: Please make sure that you are selecting the correct patch file. If you are sure of it, please rename the file to conform to the above naming scheme.

ERROR 1002 – BAD FILE NAME

• Error: This error is thrown if the patch file you selected does not exactly conform to the following naming scheme: \d\d\d\d\dto\d\d\d\d\d.patch (where "\d" means any number 0-9).
• Solution: Please make sure that you are selecting the correct patch file. If you are sure of it, please rename the file to conform to the above naming scheme.

ERROR 1003 – BAD CRC

• Error: This error occurs because the patch file you provided has an incorrect CRC (Cyclic Redundancy Check). An incorrect CRC means that your patch file, even if created, will not run properly with the Nexon patcher. Because of this, NXPatcher will refuse to make the patch file.
• Solution: Try downloading the patch file again at a later time and hopefully Nexon will have resolved the bad CRC.

ERROR 1004 – BAD HEADER

• Error: This error occurs because the file you provided to NXPatcher does not contain the correct file header. Because of this, NXPatcher cannot process the file to create a new prepatcher for you.
• Solution: Please select a different file to use with NXPatcher.

Advanced – Patch it yourself

Tutorial: How to patch your game.
Time to completion: 5-10 minutes.
Required files: Windows 32-bit pre-compiled – NXPatcher.zip

If you’re looking to compile NXPatcher yourself, you can download the source here. Note that the source code will only compile under a Windows environment. The source code is written in C, so you will need a C or C++ compiler. The only <windows.h> dependencies are creating directories, moving files, and showing error messages. I don’t see any reason why it would not run under WINE, but I have not tested it myself.

How to do it:
1. Unpack the zip file to your Maplestory directory.
2. Download the desired patch file to your Maplestory directory.
Here’s what the patch file URL is for 0.72:

http://download2.nexon.net/Game/MapleStory/patch/patchdir/00072/00071to00072.patch

for 0.73:

http://download2.nexon.net/Game/MapleStory/patch/patchdir/00073/00072to00073.patch

Just look at the links to figure out how to get your patch files. It’s really hard to describe, but very easy to comprehend.

When you download the patch file, download it to your maplestory directory.

3. Edit the batch file so the third argument has the same name as the patch file you downloaded. Make sure the second argument is "read"
4. Run the batch file. All of the new files created by NXPatcher will be placed in the "Patcher" directory.
5. Copy the files from your "Patcher" directory to your Maplestory directory. You are now fully patched.

Advanced – Features & Documentation

Introduction:
There are five commands that NXPatcher accepts – read, write, hijack, version, and split. By using these five commands you can have full power over how you patch your Maplestory game.

Read:
The read command allows you to apply a patch file to your current directory. Use the following command:

NXPatcher read [Name of patch file]
ex. NXPatcher read 00075to00079.patch

NXPatcher will then create a directory called "Patcher" and place all of the newly updated files in that directory. Once NXPatcher is done reading the files, simply copy all of the new files from the Patcher directory to your maplestory directory. Your game is now fully patched and ready to go when the Nexon servers come back up. Just run Maplestory from the website, as you always would, to start the game again.

Write:
The write command allows you to create pre-patchers – possibly to use yourself or to share with your friends. Use the following command:

NXPatcher write [Name of patch file]
ex. NXPatcher write 00080to00085.patch

For example, if we were executing the example command above, NXPatcher will create a new file – 00080to00085.exe – which is the pre-patcher. Simply share that file with your friends.

WZ File Version Checking:
If you try to apply a patch file and it freezes on Base.wz (or if you use the "Patch it yourself" method above and it tells you that a checksum is bad), maybe you should try checking which version of wz file you’re using as you may have downloaded the wrong patch file by mistake. Simply use this command:

NXPatcher.exe version Base.wz

And it will tell you what version of WZ file it is. The output looks something like this:

WZ File version is 79

This will work with any WZ file, so the following examples will work too:

NXPatcher.exe version Character.wz
NXPatcher.exe version Mob.wz

If you get the following error: "Version could not be determined", it’s likely that your wz file is corrupt and you should reinstall the game from scratch.

If you get the error, "This is not a properly formatted WZ file", please make sure that you gave the name of a true WZ file (List.wz is not a true wz file in the strictest sense).

Splitting Patch EXE files:
If you have a pre-patcher EXE file, with NXPatcher you can break down the pre-patcher into its three parts: the base file, the patch file, and the notice file. Simply use the following command:

NXPatcher.exe split MyPrePatcher.exe

Pre-patcher EXE hijacking
Let’s say you have a pre-patcher from Nexon. You don’t want to use their pre-patcher, but you’d rather use the algorithms already in place with this NXPatcher. This is now easily possible. Simply use the following command:

NXPatcher.exe hijack MyPrePatcher.exe

The following will happen:
1. NXPatcher rips the patch file from the pre-patcher
2. NXPatcher then executes the patch file for itself

Menu:
Of course, you don’t have to remember everything above to use NXPatcher correctly. Just type "NXPatcher.exe" to see a listing of everything this program can do for you.

Also, just as a reminder, NXPatcher never, ever removes any of your files! If your computer has to suddenly restart for anything or should there be an error with the patching program, none of your data is at risk.

Advanced – INI File Documentation

The INI file is split up into six different sections – one section for each of the five commands and a file associations section. There are a few basic guidelines that the NXPatcher INI file follows:

1. All variables which begin with the word if (ifbackupdir, ifusefastpatch, ifoutputbase) are boolean variables – the value of it must be 0 or 1, 0 for off and 1 for on.
2. All other variables are strings.

[fileassociations]
patch = write
exe = split
wz = version

C:\Nexon\Maplestory> NXPatcher 00080to00081.patch

struct PatchFormat
{
  char WzPatch[9]; //WzPatch\x1A - plus null terminator
  int version; //Always 0x02 - This is some sort of patch file version
  unsigned int checksum;
  unsigned char* zlibBlock;
}

//Official PKZIP CRC32 table generation
/*
    Width: 32
	Poly: 0x04C11DB7
	Reflect-in: False
	XOR-in: 0x00000000
	Reflect-out: False
	XOR-out: 0x00000000
*/

void Generatesbox(int* sbox)
{
	int remain;
	int dividend;
	int bit;

	for(dividend = 0; dividend < 256; dividend++)
	{
		remain = dividend << 24;
		for(bit = 0; bit < 8; bit++)
		{
			if(remain & 0x80000000)
			{
				remain = (remain << 1) ^ 0x04C11DB7;
			}
			else
			{
				remain = (remain << 1);
			}
		}
		sbox[dividend] = remain;
	}
}

//This is the standard CRC32 implementation
//"rollingChecksum" is used so the caller can maintain the current checksum between function calls
unsigned int CalculateChecksum(unsigned char* eachBlock, int* sbox, long lengthOfBlock, unsigned int rollingChecksum)
{
	int IndexLookup;
	int blockPos;

	for(blockPos = 0; blockPos < lengthOfBlock; blockPos++)
	{
		IndexLookup = (rollingChecksum >> 0x18) ^ eachBlock[blockPos];
		rollingChecksum = (rollingChecksum << 0x08) ^ sbox[IndexLookup];
	}
	return rollingChecksum;
}

int sbox[256] = {
  0,          0x4c11db7,  0x9823b6e,  0xd4326d9,  0x130476dc, 0x17c56b6b,
  0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
  0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7,
  0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
  0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3,
  0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
  0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef,
  0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
  0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb,
  0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
  0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
  0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
  0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x18aeb13,  0x54bf6a4,
  0x808d07d,  0xcc9cdca,  0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
  0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08,
  0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
  0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc,
  0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
  0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050,
  0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
  0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
  0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
  0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1,
  0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
  0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5,
  0x3f9b762c, 0x3b5a6b9b,  0x315d626, 0x7d4cb91,  0xa97ed48,  0xe56f0ff,
  0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9,
  0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
  0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd,
  0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
  0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
  0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
  0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2,
  0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
  0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e,
  0x18197087, 0x1cd86d30, 0x29f3d35,  0x65e2082,  0xb1d065b,  0xfdc1bec,
  0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a,
  0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
  0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676,
  0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
  0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
  0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
  0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
};

//unsigned char* zlibBlock = A pointer to the current place in the unpacked zlib stream
//unsigned char* zlibBlockPtr = A pointer to the beginning of the unpacked zlib stream
//int unpackedLengthZlib = The length of the decompressed zlib stream
//char checkByte = The current byte being read from the zlib stream
//char fileName[260] = The file name that we are working on now

do {
  checkByte = GetByte(&zlibBlock);
  switch(checkByte)  
  {
      case 0x00:
          //Create file OR folder
          break;
      case 0x01:
          //Rebuild the file
          break;
      case 0x02:
          //Delete the file OR folder
          break;
      default:
          //Add checkByte to the end of fileName
  }

}while((zlibBlock - zlibBlockPtr) < unpackedLenZlibBlock); //Basically, continue parsing file blocks until the final offset is reached.

struct NewFile
{
    int length;
    unsigned int checksum;
    unsigned char* bytes;
};

struct RebuildBlock
{
    unsigned int oldFileChecksum;
    unsigned int newFileChecksum;
};

for(Command = GetInt(&zlibBlock); Command != 0x00000000; Command = GetInt(&zlibBlock))
{
    if((Command & 0xC0000000) == 0xC0000000)
    {
          //This is a repeat block. It's essentially run length encoding.
          repeatedByte = Command & 0x000000FF
          lengthOfBlock = (Command & 0x3FFFFF00) >> 8;
          //use memset in C to write to a buffer containing the repeatedByte for lengthOfBlock number of bytes, then write it to the file.
    }
    else if((Command & 0x80000000) == 0x80000000)
    {
          // This is a direct write block. The bytes to be written are contained directly in the zlib stream. Simply write these bytes out to the file.
          lengthOfBlock = Command & 0x7FFFFFFF;
    }

    else
    {
          //This means we take from the old file and write to the new file.
          lengthOfBlock = Command
          oldFileOffset = GetInt(&zlibBlock);
          //So open the old file, seek to the oldFileOffset, read lengthOfBlock number of bytes, then write those bytes to the new file.
    }
}

Want quick and easy notification of just patches & updates? Follow PatchWatcher on twitter, or visit http://www.PatchWatcher.net/ and monitor just the patches you’re interested in.