Fixing array sizes in thps3

d3d8to9.cpp

#define pRANDOM_SIZE 0x32000

static BYTE pRandom[pRANDOM_SIZE] = { 0 };
#define HASH_SIZE 0x2FFD0
#define OLD_HASH_SIZE 0xBFF4
BYTE hashTable[HASH_SIZE] = { 0 };//the node hash names, each item is 12 bytes
#define OTHER_SIZE 0x140000
#define OLD_OTHER_SIZE 0x14000
//BYTE otherTable[0x50000];//unknown table, each item is 20 bytes

static DWORD pOld = 0x008A8B48;
static DWORD pNew = (DWORD)&hashTable;

#pragma pack(1)
struct TriggerScript
{
	DWORD qbKey;
	DWORD unk1;
	DWORD test;//should be 2
	//BYTE padding[3];
	void* script;
	BYTE* link;
};
#pragma pop(pack)
#define MAX_TRIGGERS OTHER_SIZE / 0x14
#define OLD_MAX_TRIGGERS OLD_OTHER_SIZE / 0x14
TriggerScript triggers[MAX_TRIGGERS]{ 0 };
static DWORD pOld2 = 0x0087D8F8;
static DWORD pNew2 = (DWORD)&triggers;
TriggerScript* oldTriggers = (TriggerScript*)pOld2;





DWORD old;
	VirtualProtect((void*)0x0042B247, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042B250, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042B2C1, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042B1A4, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042B1CF, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x008A8B4D, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042B183, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);

	VirtualProtect((void*)0x0042B2B8, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042B23E, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);



	VirtualProtect((void*)0x00426123, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	VirtualProtect((void*)0x0042635A, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	VirtualProtect((void*)0x0042B91C, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	VirtualProtect((void*)0x0042C231, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	VirtualProtect((void*)0x00426353, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	VirtualProtect((void*)0x0042B923, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	VirtualProtect((void*)0x0042C0F2, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	VirtualProtect((void*)0x0042C10D, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	VirtualProtect((void*)0x0042C24D, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	/*VirtualProtect((void*)0x004282B1, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable
	VirtualProtect((void*)0x004282BD, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);//othertable*/

	VirtualProtect((void*)0x0042611A, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042634A, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042B913, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);

	//something about nodearray
	VirtualProtect((void*)0x0042B9C8, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042B9E9, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042BB31, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);



	//previus exe stuff
	VirtualProtect((void*)0x41211F, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x412134, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x41217F, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x4121D1, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);

	VirtualProtect((void*)0x412245, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42B93F, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42b98A, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);

	VirtualProtect((void*)0x42B9C9, sizeof(WORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42B9EA, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42BA1E, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42BAC2, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42BB32, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);

	VirtualProtect((void*)0x42BB73, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42BB98, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42BBA0, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);

	VirtualProtect((void*)0x42C09F, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42C0C6, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42C0CE, sizeof(BYTE), PAGE_EXECUTE_READWRITE, &old);

	VirtualProtect((void*)0x42C18D, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42C1C7, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42C1D5, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42C1E1, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x42C1EC, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);

	//pRandom, something about drawing original max was only 1024 now it's 10 times bigger
	VirtualProtect((void*)0x004F41ED, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x004F48A9, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x004F4975, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x004F4B49, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x004F4B50, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x005C94C8, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);
	VirtualProtect((void*)0x0042B171, sizeof(DWORD), PAGE_EXECUTE_READWRITE, &old);


	//Actually old data should be 0 at this point, but copy to be sure
	for (DWORD i = 0; i < OLD_HASH_SIZE; i += 4)
	{

		*(DWORD*)(pNew + i) = *(DWORD*)(pOld + i);

	}
	//Actually old data should be 0 at this point, but copy to be sure
	for (DWORD i = 0; i < OLD_OTHER_SIZE; i += 4)//Triggers
	{
		*(DWORD*)(pNew2 + i) = *(DWORD*)(pOld2 + i);
	}



	
	*(DWORD*)0x0042B247 = (DWORD)&hashTable;
	*(DWORD*)0x0042B250 = (DWORD)&hashTable;
	*(DWORD*)0x0042B2C1 = (DWORD)&hashTable;
	*(DWORD*)0x0042B1A4 = (DWORD)&hashTable + 8;
	*(DWORD*)0x0042B1CF = (DWORD)&hashTable + HASH_SIZE + 8;
	
	*(DWORD*)0x008A8B4D = (DWORD)&hashTable + 4;
	*(DWORD*)0x0042B171 = (DWORD)&hashTable + 4;
	*(DWORD*)0x0042B183 = (DWORD)&hashTable + HASH_SIZE + 4;
	//Dunno why it crashes when changing these, maybe should try 0xFF?
	//*(BYTE*)0x0042B2B8 = 0x3F;
	//*(BYTE*)0x0042B23E = 0x3F;


	*(DWORD*)0x00426123 = (DWORD)&triggers;
	*(DWORD*)0x0042635A = (DWORD)&triggers;
	*(DWORD*)0x0042B91C = (DWORD)&triggers;
	*(DWORD*)0x0042C231 = (DWORD)&triggers;
	*(DWORD*)0x0042612A = (DWORD)&triggers + 8;
	*(DWORD*)0x00426353 = (DWORD)&triggers + 8;
	*(DWORD*)0x0042B923 = (DWORD)&triggers + 8;
	*(DWORD*)0x0042C0F2 = (DWORD)&triggers + 16;
	*(DWORD*)0x0042C10D = (DWORD)&triggers + OTHER_SIZE + 0x10;

	*(DWORD*)0x0042C24D = (DWORD)&triggers + OTHER_SIZE;
	/**(DWORD*)0x004282B1 = (DWORD)&otherTable + OTHER_SIZE;
	*(DWORD*)0x004282BD = (DWORD)&otherTable + OTHER_SIZE;*/

	//008918F8 maybe this one needs to get increased aswelll?
	//Dunno why it crash when try to change this, maybe should try 0xFF?
	/**(BYTE*)0x0042611A = 0x3F;
	*(BYTE*)0x0042634A = 0x3F;
	*(BYTE*)0x0042B913 = 0x3F;*/


	//pRandom, something about drawing original max was only 1024 now it's 10 times
	//if it randomly crashes when looking around in a huge map maybe this need to be increased again
	*(DWORD*)0x004F41ED = (DWORD)&pRandom;
	*(DWORD*)0x004F48A9 = (DWORD)&pRandom;
	*(DWORD*)0x004F4975 = (DWORD)&pRandom;
	*(DWORD*)0x004F4B49 = (DWORD)&pRandom;
	*(DWORD*)0x004F4B50 = (DWORD)&pRandom;
	*(DWORD*)0x005C94C8 = pRANDOM_SIZE / 0x14;



	*(DWORD*)0x0042B9C8 = 0xC0000;
	*(DWORD*)0x0042B9E9 = 0x10000;
	*(DWORD*)0x0042BB31 = 0x10000;



	//The stuff previusly made in exe
	

	//this is the SuperSectors list size
	//if change the 0xFF here need to also change it in LevelMod, else it can't find the SuperSectors
	*(DWORD*)0x41211F = 0xC0000;
	*(DWORD*)0x412134 = 0x10000;
	*(BYTE*)0x41217F = 0xFF;
	*(DWORD*)0x4121D1 = 0x10000;
	*(BYTE*)0x412245 = 0xFF;

	*(BYTE*)0x42B93F = 0xFF;
	*(BYTE*)0x42b98A = 0xFF;

	*(WORD*)0x42B9C9 = 0x3000;
	*(BYTE*)0x42B9EA = 0x40;
	//*(BYTE*)0x42BA1E = 0x3F;
	//*(BYTE*)0x42BAC2 = 0x3F;
	*(BYTE*)0x42BB32 = 0x40;

	*(BYTE*)0x42BB73 = 0x10;
	*(BYTE*)0x42BB98 = 0x10;
	*(BYTE*)0x42BBA0 = 0x10;

	*(BYTE*)0x42C09F = 0x02;
	*(BYTE*)0x42C0C6 = 0x02;
	*(BYTE*)0x42C0CE = 0x02;

	//this is the NodeArray size maybe need to increase this...
	//each item in list is 0x10 bytes so the total size need to be able to be divided by that
	*(DWORD*)0x42C18D = 0x10AA00;
	*(DWORD*)0x42C1C7 = *(DWORD*)0x42C18D - 0x10;//last item
	*(DWORD*)0x42C1D5 = *(DWORD*)0x42C18D - 0x10;//last item
	*(DWORD*)0x42C1E1 = *(DWORD*)0x42C18D - 0x10 + 8;//last item+8
	*(DWORD*)0x42C1EC = *(DWORD*)0x42C18D - 0x10 + 0xC;//last item+0xC


	//this is old code, keep it here just in case
/*for (DWORD i = 0; i < OLD_MAX_TRIGGERS; i++)
{

	if (oldTriggers[i].test)
	{
	/**(TriggerScript*)((BYTE*)&triggers[i] + 0x3000) = oldTriggers[i];
	(*(TriggerScript*)(((BYTE*)&triggers[i] + 0x3000))).link -= (DWORD)oldTriggers;
	(*(TriggerScript*)(((BYTE*)&triggers[i] + 0x3000))).link += (DWORD)triggers + 0x3000;*/
	/*triggers[i] = oldTriggers[i];
	if (triggers[i].link)
	{
		triggers[i].link -= (DWORD)oldTriggers;
		triggers[i].link += (DWORD)triggers;
		printf("oldLink %p new link %p triggers %p\n", oldTriggers[i].link, triggers[i].link, triggers);
	}*/
	//}
	/*DWORD q = oldTriggers[i].qbKey;
	q &= 0x0000FFFF;
	q = q * 4 + q;

	TriggerScript* t = (TriggerScript*)(q*4 + pNew2);
	if((BYTE)t->test!=2)
	{
		t->qbKey = oldTriggers[i].qbKey;
		t->unk1 = oldTriggers[i].unk1;
		t->test = oldTriggers[i].test;
		//t->padding = oldTriggers[i].padding;
		t->script = oldTriggers[i].script;
		t->link = oldTriggers[i].link;

	}
	else
	{
		while (t->qbKey)
		{
			t++;
		}
		t->qbKey = oldTriggers[i].qbKey;
		t->unk1 = oldTriggers[i].unk1;
		t->test = oldTriggers[i].test;
		//t->padding = oldTriggers[i].padding;
		t->script = oldTriggers[i].script;
		t->link = oldTriggers[i].link;
	}
}*/