matteobin
/
PharaohResizer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
PharaohResizer/PharaohResizer.c

569 lines
16 KiB
C
Raw Permalink Blame History

#include <stdlib.h>
#include <stdio.h>
#include <lz4.h>
#define EXE_SIZE 2142208
#define MIN_WIDTH 1024
#define MAX_WIDTH 7680
#define MIN_HEIGHT 720
#define MAX_HEIGHT 4320
unsigned long int widthOffsets[] =
{
0xcfa0a,
0xcfda3
};
unsigned long int heightOffsets[] =
{
0xcfa0f,
0xcfdad
};
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
unsigned char exeFile[EXE_SIZE];
/* Patch a single byte. */
void PatchByte(unsigned long int offset, unsigned char value)
{
exeFile[offset] = value;
}
/* Patch an array of bytes in */
void PatchBytes(unsigned long int offset, int count, unsigned char *bytes)
{
int i;
for (i = 0; i < count; ++i)
{
exeFile[offset+i] = bytes[i];
}
}
/* Patch a little-endian 32bit value in. */
void PatchU32(unsigned long int offset, unsigned long int value)
{
exeFile[offset] = value & 0xFF;
exeFile[offset+1] = (value >> 8) & 0xFF;
exeFile[offset+2] = (value >> 16) & 0xFF;
exeFile[offset+3] = (value >> 24) & 0xFF;
}
/* Helper function for Nopping out a region of code. */
void NopBytes(unsigned long int offset, int count)
{
int i;
for (i = 0; i < count; ++i)
{
exeFile[offset+i] = 0x90;
}
}
/* Sometimes we pad regions with non-nop bytes. int 3 (0xCC) is popular. */
void PadBytes(unsigned long int offset, int count, unsigned char byte)
{
int i;
for (i = 0; i < count; ++i)
{
exeFile[offset+i] = byte;
}
}
/* Apply all of the patches from the PharaohResizer
* version to a raw Cleopatra exe (assuming DRM, etc,
* skipped).
*/
void DoCrudeliosPatches()
{
unsigned char jmp_loc_56E331[] = {0xE9, 0x0B, 0xBB, 0x12, 0x00};
unsigned char jmp_loc_56E37B[] = {0xE9, 0x84, 0x04, 0x09, 0x00, 0x90};
unsigned char jmp_loc_56E35E[] = {0xE9, 0x11, 0x04, 0x09, 0x00, 0x90};
unsigned char jmp_loc_56E491[] = {0xE9, 0xEE, 0x5B, 0x07, 0x00};
unsigned char new_loc_51E96D[] = {
0x7C, 0x1B, /* jl short locret_51E98F */
0x52, 0x50, /* push edx | push eax */
0xE8, 0x21, 0xFA, 0x04, 0x00, /* call sub_56E39C */
0x58, 0x29, 0xD0, /* pop eax | sub eax, edx */
0x83, 0xE8, 0x2A, /* sub eax, 42 */
0xA3, 0x60, 0x3F, 0xF5, 0x00, /* mov dword_F53F60, eax */
0x83, 0xE8, 0x78, /* sub eax, 120 */
0xA3, 0x64, 0x3F, 0xF5, 0x00, /* mov dword_F53F64, eax */
0x5A, 0xC3 /* pop edx | ret */
};
unsigned char sub_51E990_patch[] = {
0x8B, 0x0D, 0xAC, 0x8D, 0xE3, 0x00, /* mov ecx, dword_E38DAC */
0x6A, 0x09, /* push 9 */
0x50, 0x51 /* push eax | push ecx */
};
unsigned char sub_51E990_patch2[] = { 0xE8, 0xA6, 0xFA, 0x04, 0x00, 0xC3 };
unsigned char sub_51E990_patch3[] = { 0xE8, 0x6B, 0xFA, 0x04, 0x00, 0x0C3 };
unsigned char jmp_loc_56E3C7[] = {0xE9, 0xAB, 0xE5, 0x04, 0x00};
unsigned char jmp_loc_56E3DF[] = {0xE9, 0xF2, 0xEA, 0x03, 0x00, 0x90};
unsigned char sub_56E24F[] = {
0x53,
0x56, 0xE8, 0x46, 0x01, 0x00, 0x00, 0x85, 0xD2,
0x74, 0x74, 0x52, 0x51, 0x31, 0xD2, 0xA1, 0xAC,
0x8D, 0xE3, 0x00, 0xBB, 0xA0, 0x02, 0x00, 0x00,
0xF7, 0xFB, 0xF7, 0xEB, 0x05, 0x50, 0x01, 0x00,
0x00, 0x8B, 0x1D, 0xE4, 0x67, 0xF5, 0x00, 0x59,
0x01, 0xCB, 0x5A, 0x31, 0xF6, 0x8B, 0x0D, 0xB0,
0x8D, 0xE3, 0x00, 0x83, 0xFA, 0x28, 0x7E, 0x11,
0x83, 0xFA, 0x32, 0x7E, 0x07, 0xBE, 0x14, 0x00,
0x00, 0x00, 0xEB, 0x05, 0xBE, 0x0A, 0x00, 0x00,
0x00, 0x29, 0xD1, 0x01, 0xF1, 0x2D, 0x50, 0x01,
0x00, 0x00, 0x3D, 0x50, 0x01, 0x00, 0x00, 0x7D,
0x02, 0x31, 0xC0, 0x50, 0x51, 0x52, 0x50, 0x51,
0x53, 0xB9, 0xB0, 0x5B, 0xF5, 0x00, 0xE8, 0xD5,
0x02, 0xFD, 0xFF, 0x5A, 0x59, 0x58, 0x85, 0xF6,
0x74, 0x08, 0x83, 0xEE, 0x0A, 0x83, 0xE9, 0x0A,
0xEB, 0xE1, 0x85, 0xC0, 0x75, 0xAD, 0x5E, 0x5B,
0xC3
};
unsigned char loc_56E2D3[] = {
0xE8, 0xB8, 0x02, 0xFD, 0xFF,
0x53, 0xA1, 0xB0, 0x8D, 0xE3, 0x00, 0xBB, 0x48,
0x03, 0x00, 0x00, 0x29, 0xD8, 0x8B, 0x0D, 0xE4,
0x67, 0xF5, 0x00, 0x83, 0xC1, 0x08, 0x50, 0x51,
0x6A, 0x00, 0x53, 0x51, 0xB9, 0xB0, 0x5B, 0xF5,
0x00, 0xE8, 0x92, 0x02, 0xFD, 0xFF, 0x59, 0x58,
0x81, 0xC3, 0x48, 0x03, 0x00, 0x00, 0x39, 0xC3,
0x7C, 0xE4, 0x51, 0xE8, 0x8C, 0x00, 0x00, 0x00,
0x59, 0x8B, 0x1D, 0xB0, 0x8D, 0xE3, 0x00, 0x81,
0xEB, 0xE8, 0x03, 0x00, 0x00, 0x29, 0xD3, 0x6A,
0x00, 0x53, 0x51, 0xB9, 0xB0, 0x5B, 0xF5, 0x00,
0xE8, 0x63, 0x02, 0xFD, 0xFF, 0x5B, 0xC3
};
unsigned char loc_56E331[] = {
0x52, 0xA1, 0xB0, 0x8D, 0xE3, 0x00, 0x8B,
0x15, 0x10, 0x2A, 0x5D, 0x00, 0x83, 0xE8, 0x20,
0x39, 0xC2, 0x7E, 0x02, 0x89, 0xD0, 0x5A, 0xE9,
0xDA, 0x44, 0xED, 0xFF
};
unsigned char loc_56E35E[] = {
0x31, 0xD2,
0xA1, 0xAC, 0x8D, 0xE3, 0x00, 0xB9, 0x0F, 0x00,
0x00, 0x00, 0x29, 0xC8, 0xF7, 0xF1, 0x50, 0xE8,
0x28, 0x00, 0x00, 0x00, 0x50, 0xE9, 0xDC, 0xFB,
0xF6, 0xFF
};
unsigned char loc_56E37B[] = {
0x31, 0xD2, 0xA1, 0xAC, 0x8D,
0xE3, 0x00, 0xB9, 0x0F, 0x00, 0x00, 0x00, 0x29,
0xC8, 0xF7, 0xF1, 0x50, 0xE8, 0x0B, 0x00, 0x00,
0x00, 0x83, 0xC0, 0x02, 0x50, 0xE9, 0x62, 0xFB,
0xF6, 0xFF,
};
unsigned char sub_56E39C[] = {
0x31, 0xD2, 0xA1, 0xB0,
0x8D, 0xE3, 0x00, 0x2D, 0xA0, 0x00, 0x00, 0x00,
0xB9, 0x3C, 0x00, 0x00, 0x00, 0xF7, 0xF1, 0x83,
0xFA, 0x18, 0x7F, 0x06, 0xB9, 0x02, 0x00, 0x00,
0x00, 0xC3, 0xB9, 0x03, 0x00, 0x00, 0x00, 0xC3
};
unsigned char loc_56E3C7[] = {
0x50,
0xE8, 0xCF, 0xFF, 0xFF, 0xFF, 0x58, 0x89, 0xC1,
0x29, 0xD1, 0x89, 0x0D, 0x58, 0xB5, 0xD3, 0x00,
0xE9, 0x57, 0x1A, 0xFB, 0xFF
};
unsigned char loc_56E3DF[] = {
0xA1,
0xB0, 0x8D, 0xE3, 0x00, 0x8B, 0x15, 0x10, 0x2A,
0x5D, 0x00, 0x83, 0xE8, 0x20, 0x39, 0xC2, 0x7F,
0x02, 0x89, 0xC2, 0xE9, 0xF6, 0x14, 0xFC, 0xFF
};
unsigned char loc_56E491[] = {
0x8B, 0x15, 0x30, 0x8E, 0xE3, 0x00, 0x83,
0xFA, 0x26, 0x7D, 0x05, 0xBA, 0x26, 0x00, 0x00,
0x00, 0xC1, 0xE0, 0x04, 0x52, 0x83, 0xC2, 0x08,
0x01, 0xC2, 0x3B, 0x15, 0xAC, 0x8D, 0xE3, 0x00,
0x5A, 0x7F, 0x05, 0x83, 0xC2, 0x00, 0xEB, 0x05,
0x83, 0xEA, 0x00, 0x29, 0xC2, 0x89, 0x15, 0x8C,
0xDD, 0xEA, 0x00, 0xE8, 0xD4, 0xFE, 0xFF, 0xFF,
0x8B, 0x0D, 0xB0, 0x8D, 0xE3, 0x00, 0x29, 0xD1,
0x31, 0xD2, 0x3B, 0x15, 0x78, 0x3F, 0xF5, 0x00,
0x75, 0x08, 0x81, 0xE9, 0xA2, 0x00, 0x00, 0x00,
0xEB, 0x03, 0x83, 0xE9, 0x2A, 0x8B, 0x15, 0x34,
0x8E, 0xE3, 0x00, 0x52, 0x83, 0xC2, 0x08, 0xA1,
0x88, 0xDD, 0xEA, 0x00, 0xC1, 0xE0, 0x04, 0x01,
0xC2, 0x39, 0xCA, 0x5A, 0x7F, 0x05, 0x83, 0xC2,
0x00, 0xEB, 0x07, 0x89, 0xCA, 0x83, 0xEA, 0x08,
0x29, 0xC2, 0x89, 0x15, 0x90, 0xDD, 0xEA, 0x00,
0xE9, 0xC7, 0xA3, 0xF8, 0xFF
};
unsigned char sub_56E532[] = {
0x53, 0x8B, 0x5C, 0x24, 0x10, 0x53,
0x53, 0xFF, 0x74, 0x24, 0x14, 0xFF, 0x74, 0x24,
0x14, 0xB9, 0xB0, 0x5B, 0xF5, 0x00, 0xE8, 0x45,
0x00, 0xFD, 0xFF, 0x6A, 0x01, 0xE8, 0x4E, 0x0B,
0xFB, 0xFF, 0x6A, 0x01, 0xE8, 0x27, 0x11, 0xFB,
0xFF, 0x83, 0xC4, 0x08, 0x5B, 0x81, 0xC3, 0x1D,
0x01, 0x00, 0x00, 0x3B, 0x1D, 0xAC, 0x8D, 0xE3,
0x00, 0x7C, 0xCC, 0x5B, 0xC2, 0x0C, 0x00
};
unsigned char sub_56E5A6[] = {
0xA1, 0xAC,
0x8D, 0xE3, 0x00, 0x2D, 0x00, 0x03, 0x00, 0x00,
0xD1, 0xF8, 0x50, 0xA1, 0xB0, 0x8D, 0xE3, 0x00,
0x2D, 0x00, 0x04, 0x00, 0x00, 0xD1, 0xF8, 0x50,
0xFF, 0x74, 0x24, 0x0C, 0xE8, 0xC7, 0xFF, 0xFC,
0xFF, 0xC2, 0x0C, 0x00
};
/* Patch a function call? */
PatchU32(0x1A236, 0x15436C);
PatchU32(0x1A8C7, 0x153CDB);
PatchU32(0x1A8F3, 0x153CAF);
PatchU32(0x1A964, 0x153C3E);
PatchU32(0x1A9AA, 0x153BF8);
PatchU32(0x1A9D1, 0x153BD1);
PatchU32(0x1AB2F, 0x153A73);
/* Patch a comparison out */
PatchByte(0x1E657, 0xEB); /*jmp*/
/* Patch a massive jump? */
PatchBytes(0x42821, 5, jmp_loc_56E331);
/* Patch a jnz -> jl */
PatchByte(0xDDEF0, 0x7C);
/* ...and a jump in */
PatchBytes(0xDDEF2, 6, jmp_loc_56E37B);
/* Patch a jnz -> jl */
PatchByte(0xDDF42, 0x7C);
/* ...and a jump in */
PatchBytes(0xDDF48, 6, jmp_loc_56E35E);
/* Patch a jnz -> jl */
PatchByte(0xF889C, 0x7C);
/* ...and a jump in */
PatchBytes(0xF889E, 5, jmp_loc_56E491);
/* ...and nop out a bunch. */
NopBytes(0xF88A3, 57);
/* Rewrite another functon. */
PatchBytes(0x11E972, ARRAY_SIZE(new_loc_51E96D), new_loc_51E96D);
/* sub_51E990 changes: */
/* jnz -> jl */
PatchByte(0x11E99A, 0x7C);
/* call target -> sub_56E24F */
PatchU32(0x11E99D, 0x4F8AE);
/* jnz -> jl */
PatchByte(0x11E9BB, 0x7C);
/* Modify setup for call to sub_4CD9D0 */
PatchBytes(0x11E9BD, ARRAY_SIZE(sub_51E990_patch), sub_51E990_patch);
NopBytes(0x11E9C7, 6);
/* add eax, _0_ instead of 250 */
PatchByte(0x11E9D9, 0);
/* jnz -> jl */
PatchByte(0x11EA67, 0x7C);
/* call sub_56E532 and return */
PatchBytes(0x11EA87, ARRAY_SIZE(sub_51E990_patch2), sub_51E990_patch2);
NopBytes(0x11EA8D, 22);
/* and again, call sub_56E532 and return */
PatchBytes(0x11EAC2, ARRAY_SIZE(sub_51E990_patch3), sub_51E990_patch3);
NopBytes(0x11EAC8, 22);
/* Another jnz -> jl */
PatchByte(0x11EBB0, 0x7C);
/* Another one, but this time a longer encoding */
PatchByte(0x11F4AD, 0x8C);
/* Another jnz -> jl */
PatchByte(0x11FE15, 0x7C);
/* Then a jmp loc_56E3C7 */
PatchBytes(0x11FE17, 5, jmp_loc_56E3C7);
NopBytes(0x11FE1C, 7);
/* sub_51FD60 patches: */
/* A jnz -> jl */
PatchByte(0x11FF3E, 0x7C);
/* Patch call target -> sub_56E532 */
PatchU32(0x11FF5C, 0x4E5D2);
/* Another call target -> sub_56E532 */
PatchU32(0x11FFBD, 0x4E571);
/* Another call target to sub_56E5A6 */
PatchU32(0x120F95, 0x4D60D);
/* A massive jump to loc_56E3DF */
PatchBytes(0x12F8E8, 6, jmp_loc_56E3DF);
/* jnz -> jl */
PatchByte(0x136689, 0x8C);
/* A big jump to loc_56E2D3 */
PatchByte(0x1366F5, 0xE9);
PatchU32(0x1366F6, 0x37BD9);
/* Patch 1003 -> 1900 in a push statement */
PatchU32(0x13712B, 1900);
/* Now patch in a bunch of custom functions and/or
function fragments in the free space at the end
of the .exe */
PadBytes(0x16E24D, 2, 0xCC);
PatchBytes(0x16E24F, ARRAY_SIZE(sub_56E24F), sub_56E24F);
PadBytes(0x16E2D1, 2, 0xCC);
/* FUNCTION CHUNK FOR sub_536670 */
PatchBytes(0x16E2D3, ARRAY_SIZE(loc_56E2D3), loc_56E2D3);
PadBytes(0x16E32F, 2, 0xCC);
/* FUNCTION CHUNK FOR sub_442800 */
PatchBytes(0x16E331, ARRAY_SIZE(loc_56E331), loc_56E331);
/* FUNCTION CHUNK FOR sub_4DDF20 */
PatchBytes(0x16E35E, ARRAY_SIZE(loc_56E35E), loc_56E35E);
PadBytes(0x16E37A, 1, 0xCC);
/* FUNCTION CHUNK FOR sub_4DDEC0 */
PatchBytes(0x16E37B, ARRAY_SIZE(loc_56E37B), loc_56E37B);
PadBytes(0x16E39A, 2, 0xCC);
/* sub_56E39C */
PatchBytes(0x16E39C, ARRAY_SIZE(sub_56E39C), sub_56E39C);
PadBytes(0x16E3C0, 7, 0xCC);
/* FUNCTION CHUNK FOR sub_51FD60 */
PatchBytes(0x16E3C7, ARRAY_SIZE(loc_56E3C7), loc_56E3C7);
PadBytes(0x16E3DD, 2, 0xCC);
/* FUNCTION CHUNK FOR sub_52F8B0 */
PatchBytes(0x16E3DF, ARRAY_SIZE(loc_56E3DF), loc_56E3DF);
/* FUNCTION CHUNK FOR sub_4F7E50 */
PatchBytes(0x16E491, ARRAY_SIZE(loc_56E491), loc_56E491);
/* sub_56E532 */
PatchBytes(0x16E532, ARRAY_SIZE(sub_56E532), sub_56E532);
/* sub_56E5A6 */
PatchBytes(0x16E5A6, ARRAY_SIZE(sub_56E5A6), sub_56E5A6);
}
void PatchResolution(int width, int height)
{
int i;
for (i = 0; i < ARRAY_SIZE(widthOffsets); ++i)
{
PatchU32(widthOffsets[i], width);
}
for (i = 0; i < ARRAY_SIZE(heightOffsets); ++i)
{
PatchU32(heightOffsets[i], height);
}
}
/* Patch in some code to auto-detect the resolution */
void PatchAutoResolution()
{
unsigned char call_SetScreenSize[] = {
0xE8, 0x57, 0x03, 0x00, 0x00, /* call SetScreenSize */
0xEB, 0x20 /* jmp loc_4CFA2B */
};
unsigned char new_SetScreenSize[] = {
0x8B, 0x2D, 0xA0, 0xF1, 0x56, 0x00, /* mov ebp, ds:GetSystemMetrics */
0x6A, 0x00, /* push SM_CXSCREEN (0) */
0xFF, 0xD5, /* call ebp (GetSystemMetrics) */
0xA3, 0xB0, 0x8D, 0xE3, 0x00, /* mov ScreenWidth, eax */
0x6A, 0x01, /* push SM_CYSCREEN (1) */
0xFF, 0xD5, /* call ebp (GetSystemMetrics) */
0xA3, 0xAC, 0x8D, 0xE3, 0x00, /* mov ScreenHeight, eax */
0xC3 /* ret */
};
/* Don't default to 800x600: jnz -> jmp */
PatchByte(0xCF9F0, 0xEB);
PatchBytes(0xCFA04, ARRAY_SIZE(call_SetScreenSize), call_SetScreenSize);
NopBytes(0xCFA0B, 32);
PatchBytes(0xCFD60, ARRAY_SIZE(new_SetScreenSize), new_SetScreenSize);
}
int ValidateResolution(int width, int height)
{
int valid = 1;
if (width & 3)
{
fprintf(stderr, "The width %d is not a multiple of 4.\n", width);
fprintf(stderr, "Pharaoh requires the resolution's width to be divisible by 4.\n");
valid = 0;
}
if (width < MIN_WIDTH)
{
fprintf(stderr, "The width %d is less than %d.\n", width, MIN_WIDTH);
fprintf(stderr, "The selected width must be at least %d pixels.\n", MIN_WIDTH);
valid = 0;
}
if (width > MAX_WIDTH)
{
fprintf(stderr, "The width %d is greater than %d.\n", width, MAX_WIDTH);
fprintf(stderr, "The selected width must be no greater than %d pixels.\n", MAX_WIDTH);
valid = 0;
}
if (height & 3)
{
fprintf(stderr, "The height %d is not a multiple of 4.\n", height);
fprintf(stderr, "Pharaoh requres the resolution's height to be divisible by 4.\n");
valid = 0;
}
if (height < MIN_HEIGHT)
{
fprintf(stderr, "The height %d is less than %d.\n", height, MIN_HEIGHT);
fprintf(stderr, "The selected height must be at least %d pixels.\n", MIN_HEIGHT);
valid = 0;
}
if (height > MAX_HEIGHT)
{
fprintf(stderr, "The height %d is greater than %d.\n", height, MAX_HEIGHT);
fprintf(stderr, "The selected height must be no greater than %d pixels.\n", MAX_HEIGHT);
valid = 0;
}
return valid;
}
int main(int argc, char **argv)
{
const char *inName;
const char *outName;
int width;
int height;
FILE *inFile;
FILE *outFile;
size_t compSize;
int retVal;
if (argc < 2)
{
printf("%s: Run Pharaoh+Cleopatra at different resolutions\n", argv[0]);
printf("\n");
printf("Usage:\n");
printf("\t%s input [output] [width] [height]\n", argv[0]);
printf("\tinput: the Cleopatra 2.1 .exe file, or extracted EXE_RESOURCE from PharaohResizer\n");
printf("\t[output]: The .exe file to write, defaults to PharaohNew.exe\n");
printf("\t[width]: The width of the resolution to use, otherwise autodetected\n");
printf("\t[height]: The height of the resolution to use, otherwise autodetected\n");
return 1;
}
inName = argv[1];
outName = (argc >= 3)?argv[2]:"PharaohNew.exe";
width = (argc >= 4)?atoi(argv[3]):0;
height = (argc >= 5)?atoi(argv[4]):0;
/* Validate the resolution before we do anything further. */
if ((width || height) && !ValidateResolution(width, height))
{
/* ValidateResolution prints its own errors. */
return 7;
}
inFile = fopen(inName, "rb");
if (!inFile)
{
fprintf(stderr, "Couldn't open input file \"%s\"\n", inName);
return 2;
}
outFile = fopen(outName, "wb");
if (!outFile)
{
fprintf(stderr, "Couldn't open output file \"%s\"\n", outName);
fprintf(stderr, "Check that the path is correct and is writable.\n");
fclose(inFile);
return 3;
}
fseek(inFile, 0, SEEK_END);
compSize = ftell(inFile);
fseek(inFile, 0, SEEK_SET);
if (compSize == EXE_SIZE)
{
/* We are patching an original Cleopatra 2.1 .exe */
if (fread(exeFile, EXE_SIZE, 1, inFile) != 1)
{
fprintf(stderr, "Couldn't read input file \"%s\"\n", inName);
fclose(inFile);
fclose(outFile);
return 5;
}
fclose(inFile);
/* As we're using an original .exe, we need to patch it. */
DoCrudeliosPatches();
}
else
{
unsigned char *compData = malloc(compSize);
if (!compData)
{
fprintf(stderr, "Not enough memory to load compressed file \"%s\"\n", inName);
fprintf(stderr, "Is it mysteriously enormous? It appears to be %lu MiB.\n", compSize / (1024 * 1024));
fclose(inFile);
fclose(outFile);
return 4;
}
if (fread(compData, compSize, 1, inFile) != 1)
{
fprintf(stderr, "Couldn't read input file \"%s\"\n", inName);
fclose(inFile);
fclose(outFile);
return 5;
}
fclose(inFile);
retVal = LZ4_decompress_safe((char *) compData, (char *) exeFile, compSize, EXE_SIZE);
if (retVal < 1)
{
fprintf(stderr, "Couldn't decompress input file \"%s\"\n", inName);
fprintf(stderr, "Check that it's the correct resource extracted from PharaohResizer.exe\n");
fprintf(stderr, "You can extract it from PharaohResizer.exe with:\n");
fprintf(stderr, "\twrestool PharaohResizer.exe -x --type='EXECUTABLE' --name=101\n");
fprintf(stderr, "Alternatively, make sure you're providing a Cleopatra 2.1 English .exe file\n");
return 6;
}
}
if (width && height)
{
/* Patch the user's width and height in. */
PatchResolution(width, height);
}
else
{
/* Write some code to autodetect the resolution. */
PatchAutoResolution();
}
if (fwrite(exeFile, EXE_SIZE, 1, outFile) != 1)
{
fprintf(stderr, "Couldn't write output executable \"%s\"\n", outName);
fprintf(stderr, "Have you run out of disk space or something?\n");
fclose(outFile);
return 8;
}
fclose(outFile);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink