Rim/iw4x-client
Rim/iw4x-client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity
iw4x-client/src/Components/Modules/Zones.cpp

4136 lines
114 KiB
C++
Raw Blame History

#include <STDInclude.hpp>
#include <zlib.h>
#include "FastFiles.hpp"
#pragma optimize( "", off )
namespace Components
{
int Zones::ZoneVersion;
int Zones::FxEffectIndex;
char* Zones::FxEffectStrings[64];
static std::unordered_map<std::string, std::string> shellshock_replace_list =
{
{ "66","bg_shock_screenType" },
{ "67","bg_shock_screenBlurBlendTime"},
{ "68","bg_shock_screenBlurBlendFadeTime"},
{ "69","bg_shock_screenFlashWhiteFadeTime"},
{ "70","bg_shock_screenFlashShotFadeTime"},
{ "71","bg_shock_viewKickPeriod"},
{ "72","bg_shock_viewKickRadius"},
{ "73","bg_shock_viewKickFadeTime"},
{ "78","bg_shock_sound"},
{ "74","bg_shock_soundLoop"},
{ "75","bg_shock_soundLoopSilent"},
{ "76","bg_shock_soundEnd"},
{ "77","bg_shock_soundEndAbort"},
{ "79","bg_shock_soundFadeInTime"},
{ "80","bg_shock_soundFadeOutTime"},
{ "81","bg_shock_soundLoopFadeTime"},
{ "82","bg_shock_soundLoopEndDelay"},
{ "83","bg_shock_soundRoomType"},
{ "84","bg_shock_soundDryLevel"},
{ "85","bg_shock_soundWetLevel"},
{ "86","bg_shock_soundModEndDelay"},
// guessed, not sure
{ "87","bg_shock_lookControl"},
{ "88","bg_shock_lookControl_maxpitchspeed"},
{ "89","bg_shock_lookControl_maxyawspeed"},
{ "90","bg_shock_lookControl_mousesensitivityscale"},
{ "91","bg_shock_lookControl_fadeTime"},
{ "92","bg_shock_movement"}
};
Game::XAssetType currentAssetType = Game::XAssetType::ASSET_TYPE_INVALID;
Game::XAssetType previousAssetType = Game::XAssetType::ASSET_TYPE_INVALID;
enum FxElemType_461
{
FX_ELEM_TYPE_SPRITE_BILLBOARD,
FX_ELEM_TYPE_SPRITE_ORIENTED,
FX_ELEM_TYPE_TAIL,
FX_ELEM_UNKNOWN_1,
FX_ELEM_UNKNOWN_2,
FX_ELEM_TYPE_TRAIL,
FX_ELEM_TYPE_CLOUD,
FX_ELEM_TYPE_SPARK_CLOUD,
FX_ELEM_TYPE_SPARK_FOUNTAIN,
FX_ELEM_TYPE_MODEL,
FX_ELEM_TYPE_OMNI_LIGHT ,
FX_ELEM_TYPE_SPOT_LIGHT,
FX_ELEM_TYPE_SOUND ,
FX_ELEM_TYPE_DECAL,
FX_ELEM_TYPE_RUNNER,
};
static_assert(FxElemType_461::FX_ELEM_TYPE_TRAIL == 5);
static_assert(FxElemType_461::FX_ELEM_TYPE_SPARK_FOUNTAIN == 8);
static const std::unordered_map<char, char> elemTypeMapCodoToIW4 = {
{ FX_ELEM_TYPE_SPRITE_BILLBOARD, Game::FX_ELEM_TYPE_SPRITE_BILLBOARD },
{ FX_ELEM_TYPE_SPRITE_ORIENTED, Game::FX_ELEM_TYPE_SPRITE_ORIENTED },
{ FX_ELEM_TYPE_TAIL, Game::FX_ELEM_TYPE_TAIL },
// (Legacy rekti guesswork)
{ FX_ELEM_UNKNOWN_1, Game::FX_ELEM_TYPE_TAIL },
{ FX_ELEM_UNKNOWN_2, Game::FX_ELEM_TYPE_CLOUD },
{ FX_ELEM_TYPE_TRAIL, Game::FX_ELEM_TYPE_TRAIL },
{ FX_ELEM_TYPE_CLOUD, Game::FX_ELEM_TYPE_CLOUD },
{ FX_ELEM_TYPE_SPARK_CLOUD, Game::FX_ELEM_TYPE_SPARK_CLOUD },
{ FX_ELEM_TYPE_SPARK_FOUNTAIN, Game::FX_ELEM_TYPE_SPARK_FOUNTAIN },
{ FX_ELEM_TYPE_MODEL, Game::FX_ELEM_TYPE_MODEL },
{ FX_ELEM_TYPE_OMNI_LIGHT, Game::FX_ELEM_TYPE_OMNI_LIGHT },
{ FX_ELEM_TYPE_SPOT_LIGHT, Game::FX_ELEM_TYPE_SPOT_LIGHT },
{ FX_ELEM_TYPE_SOUND, Game::FX_ELEM_TYPE_SOUND },
{ FX_ELEM_TYPE_DECAL, Game::FX_ELEM_TYPE_DECAL },
{ FX_ELEM_TYPE_RUNNER, Game::FX_ELEM_TYPE_RUNNER }
};
struct FxElemDef_461
{
int flags;
Game::FxSpawnDef spawn;
Game::FxFloatRange spawnRange;
Game::FxFloatRange fadeInRange;
Game::FxFloatRange fadeOutRange;
float spawnFrustumCullRadius;
Game::FxIntRange spawnDelayMsec;
Game::FxIntRange lifeSpanMsec;
Game::FxFloatRange spawnOrigin[3];
Game::FxFloatRange spawnOffsetRadius;
Game::FxFloatRange spawnOffsetHeight;
Game::FxFloatRange spawnAngles[3];
Game::FxFloatRange angularVelocity[3];
Game::FxFloatRange initialRotation;
Game::FxFloatRange gravity;
Game::FxFloatRange reflectionFactor;
Game::FxElemAtlas atlas;
char elemType;
char visualCount;
char velIntervalCount;
char visStateIntervalCount;
Game::FxElemVelStateSample* velSamples;
Game::FxElemVisStateSample* visSamples;
void* visuals;
Game::Bounds collBounds;
void* effectOnImpact;
void* effectOnDeath;
void* effectEmitted;
Game::FxFloatRange emitDist;
Game::FxFloatRange emitDistVariance;
Game::FxElemExtendedDefPtr extended;
char sortOrder;
char lightingFrac;
char useItemClip;
char fadeInfo;
char pad[4];
char* unknownString;
};
//bool Zones::LoadFxEffectDef(bool atStreamStart, char* buffer, int size)
//{
// int count = 0;
// if (Zones::Version() >= VERSION_ALPHA2)
// {
// size /= 252;
// count = size;
// size *= 260;
// }
// bool result = Game::Load_Stream(atStreamStart, buffer, size);
// Zones::FxEffectIndex = 0;
// if (Zones::Version() >= VERSION_ALPHA2)
// {
// Utils::Memory::Allocator allocator;
// Game::FxElemDef* elems = allocator.allocateArray<Game::FxElemDef>(count);
// for (int i = 0; i < count; ++i)
// {
// AssetHandler::Relocate(buffer + (260 * i), buffer + (252 * i), 252);
// std::memcpy(&elems[i], buffer + (260 * i), 252);
// Zones::FxEffectStrings[i] = *reinterpret_cast<char**>(buffer + (260 * i) + 256);
// }
// std::memcpy(buffer, elems, sizeof(Game::FxElemDef) * count);
// }
// return result;
//}
//bool Zones::LoadFxElemDefStub(bool atStreamStart, Game::FxElemDef* fxElem, int size)
//{
// if (Zones::Version() >= VERSION_ALPHA2)
// {
// if (fxElem->elemType == 3)
// {
// fxElem->elemType = 2;
// }
// else if (fxElem->elemType >= 5)
// {
// fxElem->elemType -= 2;
// }
// }
// return Game::Load_Stream(atStreamStart, fxElem, size);
//}
//void Zones::LoadFxElemDefArrayStub(bool atStreamStart)
//{
// Game::Load_FxElemDef(atStreamStart);
// if (Zones::Version() >= VERSION_ALPHA2)
// {
// *Game::varXString = &Zones::FxEffectStrings[Zones::FxEffectIndex++];
// Game::Load_XString(false);
// }
//}
bool Zones::LoadXModel(bool atStreamStart, char* xmodel, int size)
{
if (Zones::Version() >= VERSION_ALPHA2)
{
if (Zones::Version() == VERSION_ALPHA2)
{
size = 0x16C;
}
else
{
size = 0x168;
}
}
bool result = Game::Load_Stream(atStreamStart, xmodel, size);
if (Zones::Version() >= VERSION_ALPHA2)
{
Game::XModel model[2]; // Allocate 2 models, as we exceed the buffer
std::memcpy(model, xmodel, 36);
std::memcpy(&model->boneNames, &xmodel[44], 28);
for (int i = 0; i < 4; ++i)
{
AssertOffset(Game::XModelLodInfo, partBits, 12);
std::memcpy(&model->lodInfo[i], &xmodel[72 + (i * 56)], 12);
std::memcpy(&model->lodInfo[i].partBits, &xmodel[72 + (i * 56) + 16], 32);
std::memcpy(reinterpret_cast<char*>(&model) + (size - 4) - (i * 4), &xmodel[72 + (i * 56) + 12], 4);
}
std::memcpy(&model->lodInfo[3].lod, &xmodel[292], (size - 292 - 4)/*68*/);
std::memcpy(&model->physPreset, &xmodel[(size - 8)], 8);
model[1].name = reinterpret_cast<char*>(0xDEADC0DE);
std::memcpy(xmodel, &model, size);
}
return result;
}
void Zones::LoadXModelLodInfo(int i)
{
if (Zones::Version() >= VERSION_ALPHA2)
{
int elSize = (Zones::ZoneVersion == VERSION_ALPHA2) ? 364 : 360;
*Game::varXString = reinterpret_cast<char**>(reinterpret_cast<char*>(*Game::varXModel) + (elSize - 4) - (4 * (4 - i)));
Game::Load_XString(false);
}
}
__declspec(naked) void Zones::LoadXModelLodInfoStub()
{
__asm
{
pushad
push edi
call Zones::LoadXModelLodInfo
add esp, 4h
popad
push 0x4EA703 // Return address
push 0x40D7A0 // Load_XModelSurfsFixup
retn
}
}
bool Zones::LoadXSurfaceArray(bool atStreamStart, char* buffer, int size)
{
int count = 0;
if (Zones::Version() >= VERSION_ALPHA2)
{
size >>= 6;
count = size;
size *= 84;
}
bool result = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::Version() >= VERSION_ALPHA2)
{
Utils::Memory::Allocator allocator;
Game::XSurface* tempSurfaces = allocator.allocateArray<Game::XSurface>(count);
for (int i = 0; i < count; ++i)
{
char* source = &buffer[i * 84];
std::memcpy(&tempSurfaces[i], source, 12);
std::memcpy(&tempSurfaces[i].triIndices, source + 16, 20);
std::memcpy(&tempSurfaces[i].vertListCount, source + 40, 8);
std::memcpy(&tempSurfaces[i].partBits, source + 52, 24);
if (Zones::ZoneVersion >= 332)
{
struct
{
short pad; // +0
char flag; // +2
char zoneHandle; // +3
unsigned short vertCount; // +4
unsigned short triCount; // +6
// [...]
} surface332;
// Copy the data to our new structure
std::memcpy(&surface332, &tempSurfaces[i], sizeof(surface332));
// Check if that special flag is set
if (!(surface332.flag & 0x20))
{
Logger::Error(Game::ERR_FATAL, "We're not able to handle XSurface buffer allocation yet!");
}
// Copy the correct data back to our surface
tempSurfaces[i].zoneHandle = surface332.zoneHandle;
tempSurfaces[i].vertCount = surface332.vertCount;
tempSurfaces[i].triCount = surface332.triCount;
//std::memmove(&tempSurfaces[i].numVertices, &tempSurfaces[i].numPrimitives, 6);
}
}
std::memcpy(buffer, tempSurfaces, sizeof(Game::XSurface) * count);
}
return result;
}
struct codo461_WeaponCompleteDef
{
char* szInternalName; // +0
char* szDisplayName; // +4
char* szInternalName2; // +8
char* unkString3; // +12
Game::XModel* unkModels1[2]; // +16
Game::XModel* unkModels2[2]; // +24
Game::XModel* unkModels_Multiple1[6]; // +32
char unkPadding[4];
int16_t unkScriptStrings[32]; // +60
char** unkXStringArray1; // +124
char unkPadding3[244];
char** unkXStringArray2; // +372
char unkPadding4[244];
char** unkXStringArray3; // +620
char unkPadding5[276]; // + 624
int16_t unkScriptString; // 900
char unkPadding5a[30];
int16_t unkScriptString2; // 932
char unkPadding5b[30];
int16_t unkScriptString3; // 964
char unkPadding5c[30];
int16_t unkScriptString4; // 996
char unkPadding5d[30];
Game::FxEffectDef* effects[16]; // +1028
int16_t* unkScriptString5; // +1092
char unkPadding6[28];
Game::FxEffectDef* effects2[16]; // +1124
Game::FxEffectDef* effects2b[16]; // + 1188
char unkPadding7[64]; // + 1188
Game::FxEffectDef* effects3[16]; // +1316
char unkPadding8[64]; // + 1380
Game::FxEffectDef* viewFlashEffect; // +1444
Game::FxEffectDef* worldFlashEffect; // +1448
Game::FxEffectDef* unkEffect3; // +1452
Game::FxEffectDef* unkEffect4; // +1456
Game::FxEffectDef* unkEffect5; // +1460
char* unkString4; // +1464
int unkPadding9;
char* unkString5; // +1472
Game::snd_alias_list_t* sounds[53]; // +1476
Game::snd_alias_list_t* sounds1b[5]; // +1604
//Game::snd_alias_list_t** soundsList[5]; // 1688
Game::snd_alias_list_t** bounceSounds1; // + 1708
Game::snd_alias_list_t** bounceSounds2; // + 1712
Game::FxEffectDef* viewShellEjectEffect; // 1716
Game::FxEffectDef* worldShellEjectEffect;
Game::FxEffectDef* viewLastShotEjectEffect;
Game::FxEffectDef* worldLastShotEjectEffect;
Game::Material* reticleCenter; // 1732
Game::Material* reticleSide; // 1736
char unkPadding10[212];
Game::Material* materials[6]; // 1952
int unkPadding11;
Game::Material* material3; // 1980
int unkPadding12;
Game::Material* material4; // 1988
char unkPadding13[8];
Game::Material* overlayMaterial; // 2000
Game::Material* overlayMaterialLowRes;
Game::Material* overlayMaterialEMP;
Game::Material* overlayMaterialEMPLowRes;
char unkPadding14[8];
char* unkString6; // 2024
int unkPadding15;
char* unkString7; // 2032
char unkPadding16[12];
char* unkString8; // 2048
char padFloats[278];
Game::Material* unkMaterials2[4]; // 2332
char padFloats2[194];
Game::PhysCollmap* physCollMap; // 2544;
Game::PhysPreset* physPreset; // 2548
char padFloats3[104];
Game::XModel* projectileModel; // 2656
Game::weapProjExposion_t projExplosion; // 2660
Game::FxEffectDef* projExplosionEffect; // 2664
Game::FxEffectDef* projDudEffect; // 2668
Game::snd_alias_list_t* projDudSound; // 2672
Game::snd_alias_list_t* unkSound1; // 2676
char padProj2[272];
Game::FxEffectDef* unkProjEffects1[2]; // 2952
char padFX[24];
Game::FxEffectDef* unkEffect5b;
Game::snd_alias_list_t* unkSound2; // 2988
Game::FxEffectDef* projTrailEffect; // 2992
Game::FxEffectDef* projBeaconEffect; // 2996
Game::FxEffectDef* unkProjEffects2[3]; // 3000
char padProj3[184];
char* accuracyGraphName1; // 3196
char* accuracyGraphName2; // 3200
// OUT OF ORDER!
uint64_t* unknownAsset1; // 3204
uint64_t* unknownAsset2; // 3208
char unkPadding16_b[80];
char* unkString10_b; // 3292
char* unkString11; // 3296
char padStrings[28];
char* unkString12; // 3328
char* unkString13; // 3332
char padStrings2[152];
char* unkStrings[2]; // 3488
Game::TracerDef* tracers[3];
char padStrings3[24];
Game::snd_alias_list_t* unkSound3; // 3532
Game::FxEffectDef* unkEffect6; // 3536
char* unkString14; // 3540
char unkPadding17[12];
Game::snd_alias_list_t* sounds2; // 3556
Game::snd_alias_list_t* turretBarrelSpinUpSnd[4]; // 3560
Game::snd_alias_list_t* turretBarrelSpinDownSnd[4]; // 3576
Game::snd_alias_list_t* sounds3[2]; // 3592
char unkPadding18[64];
Game::snd_alias_list_t* sounds4[6]; // 3664
char unkPadding19[26];
char* unkString15; // 3716
char unkPadding20[12];
char* unkString16; // 3732
char* unkString17; // 3736
char unkPadding21[4];
Game::Material* unkMaterials3[4]; // 3744
char unkPadding22[20];
unsigned short numberOfUnknownAsset1;
unsigned short numberOfUnknownAsset2;
uint64_t* unknownAsset3; // 3784
uint64_t* unknownAsset4; // 3788
char unkPadding23[88];
char* unkString18[3]; // 3880
char unkPadding24[108];
char* unkString19; // 4000
char unkPadding25[12];
char* unkString20; // 4016
char padEnd[104];
};
static_assert(offsetof(codo461_WeaponCompleteDef, unkXStringArray1) == 124);
static_assert(offsetof(codo461_WeaponCompleteDef, unkXStringArray2) == 372);
static_assert(offsetof(codo461_WeaponCompleteDef, unkXStringArray3) == 620);
static_assert(offsetof(codo461_WeaponCompleteDef, effects) == 1028);
static_assert(offsetof(codo461_WeaponCompleteDef, effects2) == 1124);
static_assert(offsetof(codo461_WeaponCompleteDef, effects3) == 1316);
static_assert(offsetof(codo461_WeaponCompleteDef, viewFlashEffect) == 1444);
static_assert(offsetof(codo461_WeaponCompleteDef, unkEffect5) == 1460);
static_assert(offsetof(codo461_WeaponCompleteDef, sounds) == 1476);
static_assert(offsetof(codo461_WeaponCompleteDef, viewShellEjectEffect) == 1716);
static_assert(offsetof(codo461_WeaponCompleteDef, reticleSide) == 1736);
static_assert(offsetof(codo461_WeaponCompleteDef, materials) == 1952);
static_assert(offsetof(codo461_WeaponCompleteDef, material3) == 1980);
static_assert(offsetof(codo461_WeaponCompleteDef, material4) == 1988);
static_assert(offsetof(codo461_WeaponCompleteDef, overlayMaterial) == 2000);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString6) == 2024);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString8) == 2048);
static_assert(offsetof(codo461_WeaponCompleteDef, unkMaterials2) == 2332);
static_assert(offsetof(codo461_WeaponCompleteDef, physCollMap) == 2544);
static_assert(offsetof(codo461_WeaponCompleteDef, projectileModel) == 2656);
static_assert(offsetof(codo461_WeaponCompleteDef, unkSound1) == 2676);
static_assert(offsetof(codo461_WeaponCompleteDef, unkProjEffects1) == 2952);
static_assert(offsetof(codo461_WeaponCompleteDef, unkProjEffects2) == 3000);
static_assert(offsetof(codo461_WeaponCompleteDef, accuracyGraphName1) == 3196);
static_assert(offsetof(codo461_WeaponCompleteDef, unknownAsset1) == 3204);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString10_b) == 3292);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString11) == 3296);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString12) == 3328);
static_assert(offsetof(codo461_WeaponCompleteDef, unkStrings) == 3488);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString14) == 3540);
static_assert(offsetof(codo461_WeaponCompleteDef, sounds2) == 3556);
static_assert(offsetof(codo461_WeaponCompleteDef, turretBarrelSpinUpSnd) == 3560);
static_assert(offsetof(codo461_WeaponCompleteDef, turretBarrelSpinDownSnd) == 3576);
static_assert(offsetof(codo461_WeaponCompleteDef, sounds3) == 3592);
static_assert(offsetof(codo461_WeaponCompleteDef, sounds4) == 3664);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString15) == 3716);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString16) == 3732);
static_assert(offsetof(codo461_WeaponCompleteDef, unkMaterials3) == 3744);
static_assert(offsetof(codo461_WeaponCompleteDef, unknownAsset3) == 3784);
static_assert(offsetof(codo461_WeaponCompleteDef, unknownAsset4) == 3788);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString18) == 3880);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString19) == 4000);
static_assert(offsetof(codo461_WeaponCompleteDef, unkString20) == 4016);
void Zones::LoadWeaponCompleteDef()
{
if (Zones::ZoneVersion < VERSION_ALPHA2)
{
return Utils::Hook::Call<void(bool)>(0x4AE7B0)(true);
}
// setup structures we use
char* varWeaponCompleteDef = *reinterpret_cast<char**>(0x112A9F4);
int size = 3112;
if (Zones::ZoneVersion >= 461) {
LoadWeaponCompleteDef461();
}
else
{
throw std::exception();
}
}
void Zones::LoadWeaponCompleteDef461()
{
#define LOAD_XSTRING(member)\
*Game::varXString = reinterpret_cast<char**>(&member);\
Game::Load_XString(false)
#define LOAD_MATERIAL(member)\
*Game::varMaterialHandle = reinterpret_cast<Game::Material**>(&member);\
Game::Load_MaterialHandle(false)
#define LOAD_XSTRING_ARRAY(member, count)\
*Game::varXString = reinterpret_cast<char**>(&member);\
Game::Load_XStringArray(false, count)
#define LOAD_FX(member)\
*Game::varFxEffectDefHandle = &member;\
Game::Load_FxEffectDefHandle(false);
#define LOAD_SOUND(member)\
{\
*Game::varsnd_alias_list_name = &member;\
Game::Load_SndAliasCustom(*Game::varsnd_alias_list_name);\
}
constexpr auto size = 4124;
static_assert(sizeof(codo461_WeaponCompleteDef) >= size, "Invalid size");
static_assert(sizeof(codo461_WeaponCompleteDef) <= size, "Invalid size");
static_assert(sizeof(codo461_WeaponCompleteDef) == size, "Invalid size");
codo461_WeaponCompleteDef target;
Game::Load_Stream(true, reinterpret_cast<void*>(&target), size);
Game::DB_PushStreamPos(3);
static std::string csvFmt = std::format("weapons.csv", std::chrono::system_clock::now().time_since_epoch().count());
static std::ofstream csv(csvFmt);
static bool hasWritten = false;
int lastPos = *Game::g_streamPos;
#define _LOG_POS()\
csv << (*Game::g_streamPos - lastPos) << ",";\
lastPos = *Game::g_streamPos; \
if (!hasWritten)
{
hasWritten = true;
csv
<< "name" << ","
<< "unkXStringArray" << ","
<< "effects1" << ","
<< "effects2" << ","
<< "effects2b" << ","
<< "effects3" << ","
<< "viewFlash" << ","
<< "worldFlash" << ","
<< "unkEffect3" << ","
<< "unkEffect4" << ","
<< "unkEffect5" << ","
<< "unkString45" << ","
<< "sounds" << ","
<< "sounds1b" << ","
<< "bounceSounds1" << ","
<< "bounceSounds2" << ","
<< "viewShellEjectEffect" << ","
<< "worldShellEjectEffect" << ","
<< "viewLastShotEjectEffect" << ","
<< "worldLastShotEjectEffect" << ","
<< "reticleCenter" << ","
<< "reticleSide" << ","
<< "materials" << ","
<< "material3" << ","
<< "material4" << ","
<< "overlayMaterials" << ","
<< "unkStrings678" << ","
<< "unkMaterials2" << ","
<< "collmap" << ","
<< "physPreset" << ","
<< "projectileData" << ","
<< "unkSound1" << ","
<< "unkProjEffects1" << ","
<< "unkSound2" << ","
<< "trail" << ","
<< "beacon" << ","
<< "unkProjEffects2" << ","
<< "accuracyGraphName1" << ","
<< "mysterious1" << ","
<< "accuracyGraphName2" << ","
<< "mysterious2" << ","
<< "unkString10To13" << ","
<< "unkStrings" << ","
<< "tracers" << ","
<< "unkSound3" << ","
<< "unkEffects6" << ","
<< "unkString14" << ","
<< "sound2" << ","
<< "sound3" << ","
<< "sound4" << ","
<< "unkString15" << ","
<< "unkString16" << ","
<< "unkString17" << ","
<< "unkMaterials3" << ","
<< "mystery34" << ","
<< "unkString18" << ","
<< "unkString19" << ","
<< "unkString20" << ","
<< "finalPosition" << "\n";
}
{
std::string fmt = std::format("weapon{}.bin", std::chrono::system_clock::now().time_since_epoch().count());
std::ofstream out(fmt);
out.write(reinterpret_cast<const char*>(&target), size);
}
if (target.szDisplayName == nullptr)
{
printf("");
}
LOAD_XSTRING(target.szInternalName);
LOAD_XSTRING(target.szDisplayName);
LOAD_XSTRING(target.szInternalName2);
LOAD_XSTRING(target.unkString3);
if (target.szInternalName == "ak47holiday_mp"s)
{
printf("");
}
csv.flush();
csv << target.szInternalName << ",";
for (size_t i = 0; i < ARRAYSIZE(target.unkModels1); i++)
{
*Game::varXModelPtr = &target.unkModels1[i];
Game::Load_XModelPtr(false);
}
for (size_t i = 0; i < ARRAYSIZE(target.unkModels2); i++)
{
*Game::varXModelPtr = &target.unkModels2[i];
Game::Load_XModelPtr(false);
}
for (size_t i = 0; i < ARRAYSIZE(target.unkModels_Multiple1); i++)
{
*Game::varXModelPtr = &target.unkModels_Multiple1[i];
Game::Load_XModelPtr(false);
}
LOAD_XSTRING_ARRAY(target.unkXStringArray1, 62);
LOAD_XSTRING_ARRAY(target.unkXStringArray2, 62);
LOAD_XSTRING_ARRAY(target.unkXStringArray3, 62);
_LOG_POS();
for (size_t i = 0; i < 16; i++)
{
*Game::varFxEffectDefHandle = &target.effects[i];
Game::Load_FxEffectDefHandle(false);
}
_LOG_POS();
for (size_t i = 0; i < 16; i++)
{
*Game::varFxEffectDefHandle = &target.effects2[i];
Game::Load_FxEffectDefHandle(false);
}
_LOG_POS();
for (size_t i = 0; i < 16; i++)
{
*Game::varFxEffectDefHandle = &target.effects2b[i];
Game::Load_FxEffectDefHandle(false);
}
_LOG_POS();
for (size_t i = 0; i < 16; i++)
{
*Game::varFxEffectDefHandle = &target.effects3[i];
Game::Load_FxEffectDefHandle(false);
}
_LOG_POS();
*Game::varFxEffectDefHandle = &target.viewFlashEffect;
Game::Load_FxEffectDefHandle(false);
_LOG_POS();
*Game::varFxEffectDefHandle = &target.worldFlashEffect;
Game::Load_FxEffectDefHandle(false);
_LOG_POS();
*Game::varFxEffectDefHandle = &target.unkEffect3;
Game::Load_FxEffectDefHandle(false);
_LOG_POS();
*Game::varFxEffectDefHandle = &target.unkEffect4;
Game::Load_FxEffectDefHandle(false);
_LOG_POS();
*Game::varFxEffectDefHandle = &target.unkEffect5;
Game::Load_FxEffectDefHandle(false);
_LOG_POS();
LOAD_XSTRING(target.unkString4);
LOAD_XSTRING(target.unkString5);
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.sounds); i++)
{
*Game::varsnd_alias_list_name = &target.sounds[i];
Game::Load_SndAliasCustom(*Game::varsnd_alias_list_name);
}
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.sounds1b); i++)
{
*Game::varsnd_alias_list_ptr = &target.sounds1b[i];
// Load_snd_alias_list_ptr
Utils::Hook::Call<void(bool)>(0x44A870)(false);
}
_LOG_POS();
if (target.bounceSounds1)
{
if (target.bounceSounds1 == reinterpret_cast<void*>(-1))
{
target.bounceSounds1 = reinterpret_cast<Game::snd_alias_list_t**>(Game::DB_AllocStreamPos(3));
//target.bounceSounds1 = reinterpret_cast<Game::snd_alias_list_t**>(Game::DB_AllocStreamPos(3));
*Game::varsnd_alias_list_name = target.bounceSounds1;
Game::Load_snd_alias_list_nameArray(true, 31);
}
else
{
Game::DB_ConvertOffsetToPointer(&target.bounceSounds1);
}
}
_LOG_POS();
if (target.bounceSounds2)
{
target.bounceSounds2 = reinterpret_cast<Game::snd_alias_list_t**>(Game::DB_AllocStreamPos(3));
*Game::varsnd_alias_list_name = target.bounceSounds2;
Game::Load_snd_alias_list_nameArray(true, 31);
}
_LOG_POS();
LOAD_FX(target.viewShellEjectEffect);
_LOG_POS();
LOAD_FX(target.worldShellEjectEffect);
_LOG_POS();
LOAD_FX(target.viewLastShotEjectEffect);
_LOG_POS();
LOAD_FX(target.worldLastShotEjectEffect);
_LOG_POS();
LOAD_MATERIAL(target.reticleCenter);
_LOG_POS();
LOAD_MATERIAL(target.reticleSide);
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.materials); i++)
{
*Game::varMaterialHandle = reinterpret_cast<Game::Material**>(&target.materials[i]);
Game::Load_MaterialHandle(false);
}
_LOG_POS();
LOAD_MATERIAL(target.material3);
_LOG_POS();
LOAD_MATERIAL(target.material4);
_LOG_POS();
LOAD_MATERIAL(target.overlayMaterial);
LOAD_MATERIAL(target.overlayMaterialLowRes);
LOAD_MATERIAL(target.overlayMaterialEMP);
LOAD_MATERIAL(target.overlayMaterialEMPLowRes);
_LOG_POS();
LOAD_XSTRING(target.unkString6);
LOAD_XSTRING(target.unkString7);
LOAD_XSTRING(target.unkString8);
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.unkMaterials2); i++)
{
*Game::varMaterialHandle = reinterpret_cast<Game::Material**>(&target.unkMaterials2[i]);
Game::Load_MaterialHandle(false);
}
_LOG_POS();
*Game::varPhysCollmapPtr = reinterpret_cast<Game::PhysCollmap**>(&target.physCollMap);
Game::Load_PhysCollmapPtr(false);
_LOG_POS();
*Game::varPhysPresetPtr = reinterpret_cast<Game::PhysPreset**>(&target.physPreset);
Game::Load_PhysPresetPtr(false);
_LOG_POS();
*Game::varXModelPtr = &target.projectileModel;
Game::Load_XModelPtr(false);
*Game::varFxEffectDefHandle = &target.projExplosionEffect;
Game::Load_FxEffectDefHandle(false);
*Game::varFxEffectDefHandle = &target.projDudEffect;
Game::Load_FxEffectDefHandle(false);
*Game::varsnd_alias_list_name = &target.projDudSound;
Game::Load_SndAliasCustom(*Game::varsnd_alias_list_name);
_LOG_POS();
LOAD_SOUND(target.unkSound1);
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.unkProjEffects1); i++)
{
*Game::varFxEffectDefHandle = &target.unkProjEffects1[i];
Game::Load_FxEffectDefHandle(false);
}
_LOG_POS();
*Game::varsnd_alias_list_name = &target.unkSound2;
Game::Load_SndAliasCustom(*Game::varsnd_alias_list_name);
_LOG_POS();
*Game::varFxEffectDefHandle = &target.projTrailEffect;
Game::Load_FxEffectDefHandle(false);
_LOG_POS();
*Game::varFxEffectDefHandle = &target.projBeaconEffect;
Game::Load_FxEffectDefHandle(false);
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.unkProjEffects2); i++)
{
*Game::varFxEffectDefHandle = &target.unkProjEffects2[i];
Game::Load_FxEffectDefHandle(false);
}
_LOG_POS();
LOAD_XSTRING(target.accuracyGraphName1);
_LOG_POS();
// Mysterious assets ?
const auto read_mysterious_uint64_asset = [](uint64_t** ptr, unsigned short count)
{
const auto size = count * 8;
if (*ptr == reinterpret_cast<uint64_t*>(-1))
{
*ptr = reinterpret_cast<uint64_t*>(Game::DB_AllocStreamPos(3));
if (size)
{
if (*Game::g_streamPosIndex == 2)
{
*ptr = nullptr;
}
else
{
Game::DB_ReadXFile(*ptr, size);
}
*Game::g_streamPos += size;
}
}
else
{
*ptr = nullptr;
}
};
read_mysterious_uint64_asset(&target.unknownAsset1, target.numberOfUnknownAsset1);
_LOG_POS();
// Out of order
LOAD_XSTRING(target.accuracyGraphName2);
_LOG_POS();
read_mysterious_uint64_asset(&target.unknownAsset2, target.numberOfUnknownAsset2);
_LOG_POS();
LOAD_XSTRING(target.unkString10_b);
LOAD_XSTRING(target.unkString11);
LOAD_XSTRING(target.unkString12);
LOAD_XSTRING(target.unkString13);
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.unkStrings); i++)
{
LOAD_XSTRING(target.unkStrings[i]);
}
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.tracers); i++)
{
*Game::varTracerDefPtr = &target.tracers[i];
Game::Load_TracerDefPtr(false);
}
_LOG_POS();
LOAD_SOUND(target.unkSound3);
_LOG_POS();
LOAD_FX(target.unkEffect6);
_LOG_POS();
LOAD_XSTRING(target.unkString14);
_LOG_POS();
LOAD_SOUND(target.sounds2);
_LOG_POS();
*Game::varsnd_alias_list_ptr = target.turretBarrelSpinUpSnd;
Game::Load_snd_alias_list_nameArray(false, 4);
*Game::varsnd_alias_list_ptr = target.turretBarrelSpinDownSnd;
Game::Load_snd_alias_list_nameArray(false, 4);
for (size_t i = 0; i < ARRAYSIZE(target.sounds3); i++)
{
LOAD_SOUND(target.sounds3[i]);
}
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.sounds4); i++)
{
LOAD_SOUND(target.sounds4[i]);
}
_LOG_POS();
LOAD_XSTRING(target.unkString15);
_LOG_POS();
LOAD_XSTRING(target.unkString16);
_LOG_POS();
LOAD_XSTRING(target.unkString17);
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.unkMaterials3); i++)
{
LOAD_MATERIAL(target.unkMaterials3[i]);
}
_LOG_POS();
read_mysterious_uint64_asset(&target.unknownAsset3, target.numberOfUnknownAsset1);
read_mysterious_uint64_asset(&target.unknownAsset4, target.numberOfUnknownAsset2);
_LOG_POS();
for (size_t i = 0; i < ARRAYSIZE(target.unkString18); i++)
{
LOAD_XSTRING(target.unkString18[i]);
}
_LOG_POS();
LOAD_XSTRING(target.unkString19);
_LOG_POS();
LOAD_XSTRING(target.unkString20);
_LOG_POS();
Components::Logger::Print("===== LOADED WEAPON {} ======\n", target.szInternalName);
csv << (* Game::g_streamPos - lastPos) << "\n";
csv.flush();
if (target.szInternalName == "ak47holiday_mp"s)
{
printf("");
}
auto varWeaponCompleteDef = *reinterpret_cast<Game::WeaponCompleteDef**>(0x112A9F4);
ZeroMemory(varWeaponCompleteDef, sizeof(Game::WeaponCompleteDef));
varWeaponCompleteDef->szInternalName = target.szInternalName;
#undef LOAD_SOUND
#undef LOAD_XSTRING_ARRAY
#undef LOAD_XSTRING
#undef LOAD_MATERIAL
}
// Code-analysis has a bug, the first memcpy makes it believe size of tempVar is 44 instead of 84
#pragma warning(push)
#pragma warning(disable: 6385)
bool Zones::LoadGameWorldSp(bool atStreamStart, char* buffer, int size)
{
if (Zones::Version() >= VERSION_ALPHA2)
{
size = 84;
}
bool result = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::Version() >= VERSION_ALPHA2)
{
char tempVar[84] = { 0 };
std::memcpy(&tempVar[0], &buffer[0], 44);
std::memcpy(&tempVar[56], &buffer[44], 28);
std::memcpy(&tempVar[44], &buffer[72], 12);
std::memcpy(buffer, tempVar, sizeof(tempVar));
}
return result;
}
#pragma warning(pop)
void Zones::LoadPathDataTail()
{
if (Zones::ZoneVersion >= VERSION_ALPHA2)
{
char* varPathData = reinterpret_cast<char*>(*Game::varPathData);
if (*reinterpret_cast<char**>(varPathData + 56))
{
*reinterpret_cast<char**>(varPathData + 56) = Game::DB_AllocStreamPos(0);
Game::Load_Stream(true, *reinterpret_cast<char**>(varPathData + 56), *reinterpret_cast<int*>(varPathData + 52));
}
if (*reinterpret_cast<char**>(varPathData + 64))
{
*reinterpret_cast<char**>(varPathData + 64) = Game::DB_AllocStreamPos(0);
Game::Load_Stream(true, *reinterpret_cast<char**>(varPathData + 64), *reinterpret_cast<int*>(varPathData + 60));
}
if (*reinterpret_cast<char**>(varPathData + 76))
{
*reinterpret_cast<char**>(varPathData + 76) = Game::DB_AllocStreamPos(0);
Game::Load_Stream(true, *reinterpret_cast<char**>(varPathData + 76), *reinterpret_cast<int*>(varPathData + 72));
}
}
}
bool Zones::Loadsnd_alias_tArray(bool atStreamStart, char* buffer, int len)
{
int count = 0;
if (Zones::Version() >= VERSION_ALPHA2)
{
len /= 100;
count = len;
len *= 108;
}
bool result = Game::Load_Stream(atStreamStart, buffer, len);
if (Zones::Version() >= VERSION_ALPHA2)
{
Utils::Memory::Allocator allocator;
Game::snd_alias_t* tempSounds = allocator.allocateArray<Game::snd_alias_t>(count);
for (int i = 0; i < count; ++i)
{
char* src = &buffer[i * 108];
char* dest = reinterpret_cast<char*>(&tempSounds[i]);
std::memcpy(dest + 0, src + 0, 60);
std::memcpy(dest + 60, src + 68, 20);
std::memcpy(dest + 80, src + 88, 20);
AssetHandler::Relocate(src + 0, buffer + (i * 100) + 0, 60);
AssetHandler::Relocate(src + 68, buffer + (i * 100) + 60, 20);
AssetHandler::Relocate(src + 88, buffer + (i * 100) + 80, 20);
}
std::memcpy(buffer, tempSounds, sizeof(Game::snd_alias_t) * count);
}
return result;
}
bool Zones::LoadLoadedSound(bool atStreamStart, char* buffer, int size)
{
if (Zones::Version() >= VERSION_ALPHA2)
{
size = 48;
}
bool result = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::Version() >= VERSION_ALPHA2)
{
std::memmove(buffer + 28, buffer + 32, 16);
AssetHandler::Relocate(buffer + 32, buffer + 28, 16);
}
return result;
}
// Code-analysis has a bug, the first memcpy makes it believe size of tempVar is 400 instead of 788
#pragma warning(push)
#pragma warning(disable: 6385)
bool Zones::LoadVehicleDef(bool atStreamStart, char* buffer, int size)
{
if (Zones::Version() >= VERSION_ALPHA2)
{
size = 788;
}
bool result = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::Version() >= VERSION_ALPHA2)
{
char tempVar[788] = { 0 };
std::memcpy(&tempVar[0], &buffer[0], 400);
std::memcpy(&tempVar[408], &buffer[400], 380);
AssetHandler::Relocate(buffer + 400, buffer + 408, 388);
std::memmove(buffer, tempVar, sizeof(tempVar));
}
return result;
}
#pragma warning(pop)
void Zones::LoadWeaponAttachStuff(DWORD* varWeaponAttachStuff, int count)
{
Game::Load_Stream(true, varWeaponAttachStuff, 12 * count);
for (int i = 0; i < count; ++i)
{
if (varWeaponAttachStuff[1] < 16 || varWeaponAttachStuff[1] == 39)
{
if (varWeaponAttachStuff[2] == -1)
{
varWeaponAttachStuff[2] = reinterpret_cast<DWORD>(Game::DB_AllocStreamPos(0));
*Game::varConstChar = reinterpret_cast<const char*>(varWeaponAttachStuff[2]);
Game::Load_XStringCustom(Game::varConstChar);
}
}
varWeaponAttachStuff += 3;
}
}
bool Zones::LoadmenuDef_t(bool atStreamStart, char* buffer, int size)
{
if (Zones::ZoneVersion != 359 && Zones::ZoneVersion >= VERSION_ALPHA2) size += 4;
bool result = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::ZoneVersion >= VERSION_ALPHA2)
{
if (Zones::ZoneVersion < VERSION_LATEST_CODO)
{
std::memmove(buffer + 168, buffer + 172, (Zones::ZoneVersion != 359 ? 232 : 228));
AssetHandler::Relocate(buffer + 172, buffer + 168, (Zones::ZoneVersion != 359 ? 232 : 228));
}
else
{
std::memmove(buffer + 168, buffer + 176, 236);
AssetHandler::Relocate(buffer + 168, buffer + 176, 236);
}
reinterpret_cast<Game::menuDef_t*>(buffer)->expressionData = nullptr;
}
return result;
}
void Zones::LoadWeaponAttach()
{
if (Zones::ZoneVersion < VERSION_ALPHA2)
{
return Utils::Hook::Call<void(bool)>(0x4F4160)(true);
}
// setup structures we use
char* varWeaponAttach = *reinterpret_cast<char**>(0x112ADE0); // varAddonMapEnts
// and do the stuff
if (currentAssetType == Game::XAssetType::ASSET_TYPE_COUNT && Zones::Version() == VERSION_LATEST_CODO)
{
struct attachment_461
{
char type;
char padAlign[3];
int unk;
char* attachmentName;
};
static_assert(sizeof (attachment_461) == 12);
struct weaponAttach_t_461
{
char* name;
int attachmentCount;
attachment_461* attachments;
};
static_assert(sizeof(weaponAttach_t_461) == 12);
weaponAttach_t_461* varWeaponAttach = reinterpret_cast<weaponAttach_t_461*>(*Game::g_streamPos);
Game::Load_Stream(true, varWeaponAttach, sizeof(weaponAttach_t_461));
assert(*Game::g_streamPosIndex != 2);
Game::DB_PushStreamPos(3);
*Game::varXString = &varWeaponAttach->name;
Game::Load_XString(false);
if (varWeaponAttach->attachmentCount)
{
varWeaponAttach->attachments = reinterpret_cast<attachment_461*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varWeaponAttach->attachments, varWeaponAttach->attachmentCount * sizeof(attachment_461));
for (size_t i = 0; i < varWeaponAttach->attachmentCount; i++)
{
auto attach = &varWeaponAttach->attachments[i];
const auto attachType = attach->type;
if ((attachType < 16 || attachType == 40 || attachType == 43 || attachType == 44 || attachType == 41)
&& attachType != 5
&& attachType != 6
&& attachType != 4
&& attachType != 7
&& attachType != 8
&& attachType != 9)
{
*Game::varXString = &attach->attachmentName;
Game::Load_XString(false);
}
}
}
Game::DB_PopStreamPos();
}
else if (Zones::Version() >= 446)
{
Game::Load_Stream(true, varWeaponAttach, 20);
Game::DB_PushStreamPos(3);
*Game::varXString = reinterpret_cast<char**>(varWeaponAttach);
Game::Load_XString(false);
// load string array
const auto numStringsInArray = *reinterpret_cast<int*>(varWeaponAttach + 12);
std::string checkNop(varWeaponAttach + 12, 3);
if (checkNop == "nop")
{
printf("");
Game::DB_PopStreamPos();
return;
}
auto stringArray = reinterpret_cast<int**>(varWeaponAttach + 16);
if (*stringArray != nullptr)
{
if (*reinterpret_cast<int*>(stringArray) == -1)
{
*reinterpret_cast<void**>(varWeaponAttach + 16) = Game::DB_AllocStreamPos(3);
*Game::varXString = reinterpret_cast<char**>(varWeaponAttach + 16);
Game::Load_XStringArray(true, numStringsInArray);
}
else
{
Game::DB_ConvertOffsetToPointer(reinterpret_cast<int*>(varWeaponAttach + 16));
}
}
Game::DB_PopStreamPos();
}
else
{
Game::Load_Stream(true, varWeaponAttach, 12);
Game::DB_PushStreamPos(3);
*Game::varXString = reinterpret_cast<char**>(varWeaponAttach);
Game::Load_XString(false);
*reinterpret_cast<void**>(varWeaponAttach + 8) = Game::DB_AllocStreamPos(3);
Zones::LoadWeaponAttachStuff(*reinterpret_cast<DWORD**>(varWeaponAttach + 8), *reinterpret_cast<int*>(varWeaponAttach + 4));
Game::DB_PopStreamPos();
}
}
__declspec(naked) void LoadWeaponAttach_Stub()
{
__asm
{
pushad
cmp eax, 43 // type of WeaponAttach. We need to check cause we're in a default case
jne returnSafely
call Zones::LoadWeaponAttach
returnSafely:
popad
// Existing code
mov eax, 0x112AC48
// go back
push 0x418B38
retn
}
}
bool Zones::LoadMaterialShaderArgumentArray(bool atStreamStart, Game::MaterialShaderArgument* argument, int size)
{
// if (Zones::ZoneVersion >= 446 && currentAssetType == Game::XAssetType::ASSET_TYPE_FX) __debugbreak();
bool result = Game::Load_Stream(atStreamStart, argument, size);
Game::MaterialPass* curPass = *Game::varMaterialPass;
int count = curPass->perPrimArgCount + curPass->perObjArgCount + curPass->stableArgCount;
for (int i = 0; i < count && (Zones::ZoneVersion >= VERSION_ALPHA2); ++i)
{
Game::MaterialShaderArgument* arg = &argument[i];
if (arg->type != Game::MaterialShaderArgumentType::MTL_ARG_CODE_VERTEX_CONST && arg->type != Game::MaterialShaderArgumentType::MTL_ARG_CODE_PIXEL_CONST)
{
continue;
}
if (Zones::Version() < 446)
{
// should be min 68 currently
// >= 58 fixes foliage without bad side effects
// >= 53 still has broken shadow mapping
// >= 23 is still broken somehow
if (arg->u.codeConst.index >= 58 && arg->u.codeConst.index <= 135) // >= 34 would be 31 in iw4 terms
{
arg->u.codeConst.index -= 3;
if (Zones::Version() >= 359/* && arg->paramID <= 113*/)
{
arg->u.codeConst.index -= 7;
if (arg->u.codeConst.index <= 53)
{
arg->u.codeConst.index += 1;
}
}
}
// >= 21 works fine for specular, but breaks trees
// >= 4 is too low, breaks specular
else if (arg->u.codeConst.index >= 11 && arg->u.codeConst.index < 58)
{
arg->u.codeConst.index -= 2;
if (Zones::Version() >= 359)
{
if (arg->u.codeConst.index > 15 && arg->u.codeConst.index < 30)
{
arg->u.codeConst.index -= 1;
if (arg->u.codeConst.index == 19)
{
arg->u.codeConst.index = 21;
}
}
else if (arg->u.codeConst.index >= 50)
{
arg->u.codeConst.index += 6;
}
}
}
}
else
{
if (arg->type == 3 || arg->type == 5)
{
// 446 is from a special client version that had lot of
// unrelased/unfinished maps, is just enough for explore,
// trees had issue with it
if (Zones::Version() == 446)
{
static std::unordered_map<std::uint16_t, std::uint16_t> mapped_constants = {
{ 33, 31 },
{ 34, 32 },
{ 36, 34 },
{ 39, 37 },
{ 40, 38 },
{ 42, 40 },
{ 43, 41 },
{ 45, 43 },
{ 62, 52 },
{ 63, 53 },
{ 199, 58 },
{ 259, 86 },
{ 263, 90 },
{ 271, 98 },
{ 279, 106 },
};
const auto itr = mapped_constants.find(arg->u.codeConst.index);
if (itr != mapped_constants.end())
{
arg->u.codeConst.index = itr->second;
}
}
else if (Zones::Version() == 461)
{
static std::unordered_map<std::uint16_t, std::uint16_t> mapped_constants =
{
// mp_raid
{ 33, 31 },
{ 34, 32 },
{ 36, 34 },
{ 39, 37 },
{ 40, 38 },
{ 42, 40 },
{ 43, 41 },
{ 45, 43 },
{ 62, 52 },
{ 63, 53 },
{ 197, 58 },
{ 202, 63 },
{ 203, 64 },
{ 261, 90 },
{ 265, 94 },
{ 269, 98 },
{ 277, 106 },
// mp_dome
{ 38, 36 },
{ 40, 38 },
{ 118, 86 },
};
const auto itr = mapped_constants.find(arg->u.codeConst.index);
if (itr != mapped_constants.end())
{
arg->u.codeConst.index = itr->second;
}
if (arg->u.codeConst.index == 257)
{
auto techsetName = (*reinterpret_cast<Game::MaterialTechniqueSet**>(0x112AE8C))->name;
// dont know if this applies to 460 too, but I dont have 460 files to test
if (!strncmp(techsetName, "wc_unlit_add", 12) ||
!strncmp(techsetName, "wc_unlit_multiply", 17))
{
// fixes glass and water
arg->u.codeConst.index = 116;
}
else
{
// anything else
arg->u.codeConst.index = 86;
}
}
else
{
// copy-paste from 460
if (arg->u.codeConst.index >= 259)
{
arg->u.codeConst.index -= 171;
}
else if (arg->u.codeConst.index >= 197)
{
arg->u.codeConst.index -= 139;
}
}
}
else if (Zones::Version() == 460 /*|| Zones::Version() == 446*/) // 446 is no longer compatible, needs correct mappings
{
static std::unordered_map<std::uint16_t, std::uint16_t> mapped_constants = {
{ 22, 21 },
{ 33, 31 },
{ 34, 32 },
{ 36, 34 },
{ 37, 35 },
{ 38, 36 },
{ 39, 37 },
{ 40, 38 },
{ 41, 39 },
{ 42, 40 },
{ 43, 41 },
{ 44, 42 },
{ 45, 43 },
{ 62, 52 },
{ 63, 53 },
// these might need fixes?
{ 197, 58 },
{ 198, 59 },
{ 202, 63 },
{ 203, 64 },
{ 207, 68 },
{ 252, 81 },
{ 253, 82 },
// these seem fine
{ 261, 90 },
{ 265, 94 },
{ 269, 98 },
{ 272, 101 },
{ 273, 102 },
{ 274, 103 },
{ 277, 106 },
};
const auto itr = mapped_constants.find(arg->u.codeConst.index);
if (itr != mapped_constants.end())
{
arg->u.codeConst.index = itr->second;
}
else
{
if (arg->u.codeConst.index == 257)
{
if (FastFiles::Current() != "mp_conflict" && FastFiles::Current() != "mp_derail_sh" && FastFiles::Current() != "mp_overwatch_sh" &&
FastFiles::Current() != "mp_con_spring" && FastFiles::Current() != "mp_resistance_sh" && FastFiles::Current() != "mp_lookout_sh")
{
const auto varMaterialTechniqueSet = *reinterpret_cast<Game::MaterialTechniqueSet**>(0x112AE8C);
if (varMaterialTechniqueSet->name && !strncmp(varMaterialTechniqueSet->name, "mc_", 3))
{
// fixes trees
arg->u.codeConst.index = 86;
}
else
{
// fixes black spots in the maps
arg->u.codeConst.index = 128;
}
}
//else
/*{
arg->u.codeConst.index = 134;
}*/
}
else if (arg->u.codeConst.index >= 259)
{
arg->u.codeConst.index -= 171;
}
else if (arg->u.codeConst.index >= 197)
{
arg->u.codeConst.index -= 139;
}
}
}
}
}
}
return result;
}
bool Zones::LoadStructuredDataStructPropertyArray(bool atStreamStart, char* data, int size)
{
int count = 0;
if (Zones::ZoneVersion >= VERSION_ALPHA2)
{
size /= 16;
count = size;
size *= 24;
}
bool result = Game::Load_Stream(atStreamStart, data, size);
if (Zones::ZoneVersion >= VERSION_ALPHA2)
{
for (int i = 0; i < count; ++i)
{
std::memmove(data + (i * 16), data + (i * 24), 16);
AssetHandler::Relocate(data + (i * 24), data + (i * 16), 16);
}
}
return result;
}
bool Zones::LoadGfxImage(bool atStreamStart, char* buffer, int size)
{
if (Zones::ZoneVersion >= 332)
{
size = (Zones::ZoneVersion >= 359) ? 52 : 36;
}
bool result = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::ZoneVersion >= 332)
{
AssetHandler::Relocate(buffer + (size - 4), buffer + 28, 4);
if (Zones::Version() >= 359)
{
struct
{
Game::GfxImageLoadDef* texture;
char mapType;
Game::TextureSemantic semantic;
char category;
char flags;
int cardMemory;
char pad[8]; // ?
int dataLen1;
int dataLen2;
char pad2[4]; // ?
short width;
short height;
short depth;
char loaded;
char pad3[5];
Game::GfxImageLoadDef* storedTexture;
char* name;
} image359;
AssertSize(image359, 52);
// Copy to new struct
std::memcpy(&image359, buffer, sizeof(image359));
// Convert to old struct
Game::GfxImage* image = reinterpret_cast<Game::GfxImage*>(buffer);
image->mapType = image359.mapType;
image->semantic = image359.semantic;
image->category = image359.category;
image->useSrgbReads = image359.flags;
//image->cardMemory = image359.cardMemory;
//image->dataLen1 = image359.dataLen1;
//image->dataLen2 = image359.dataLen2;
std::memcpy(image->picmip.platform, &image359.cardMemory, sizeof(int) * 3);
image->height = image359.height;
image->width = image359.width;
image->depth = image359.depth;
image->delayLoadPixels = image359.loaded;
image->name = image359.name;
FixImageCategory(image);
// Used for later stuff
(&image->delayLoadPixels)[1] = image359.pad3[1];
}
else
{
std::memcpy(buffer + 28, buffer + (size - 4), 4);
Game::GfxImage* image = reinterpret_cast<Game::GfxImage*>(buffer);
FixImageCategory(image);
}
}
return result;
}
void Zones::FixImageCategory(Game::GfxImage* image)
{
// CODO makes use of additional enumerator values (9, 10, 11) that don't exist in IW4
// We have to translate them. 9 is for Reflection probes, 11 is for Compass, 10 is for Lightmap
switch (image->category)
{
case 9:
image->category = Game::ImageCategory::IMG_CATEGORY_AUTO_GENERATED;
break;
case 10:
image->category = Game::ImageCategory::IMG_CATEGORY_LIGHTMAP;
break;
case 11:
image->category = Game::ImageCategory::IMG_CATEGORY_LOAD_FROM_FILE;
break;
}
if (image->category > 7 || image->category < 0)
{
#ifdef DEBUG
if (IsDebuggerPresent()) __debugbreak();
#endif
}
}
bool Zones::LoadXAsset(bool atStreamStart, char* buffer, int size)
{
int count = 0;
if (Zones::ZoneVersion >= 334)
{
size /= 8;
count = size;
size *= 16;
}
bool result = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::ZoneVersion >= 334)
{
for (int i = 0; i < count; ++i)
{
std::memmove(buffer + (i * 8), buffer + (i * 16), 4);
std::memmove(buffer + (i * 8) + 4, buffer + (i * 16) + 8, 4);
if (Zones::Version() >= 423)
{
// don't read assets that are unused by codol, for some retarded reason their header is written in the FF anyway
if (*reinterpret_cast<int*>(buffer + (i * 8)) == Game::XAssetType::ASSET_TYPE_CLIPMAP_SP ||
*reinterpret_cast<int*>(buffer + (i * 8)) == Game::XAssetType::ASSET_TYPE_GAMEWORLD_SP ||
*reinterpret_cast<int*>(buffer + (i * 8)) == Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP)
{
*reinterpret_cast<int*>(buffer + (i * 8)) = Game::XAssetType::ASSET_TYPE_UI_MAP;
*reinterpret_cast<int**>(buffer + (i * 8) + 4) = nullptr;
}
}
AssetHandler::Relocate(buffer + (i * 16), buffer + (i * 8) + 0, 4);
AssetHandler::Relocate(buffer + (i * 16) + 8, buffer + (i * 8) + 4, 4);
}
}
Game::XAssetList* list = *reinterpret_cast<Game::XAssetList**>(0x112AC7C);
if (list->assetCount == 8557) {
for (size_t i = 0; i < 8557; i++)
{
Logger::Print("#{}: \t {} ({})\n", i, Game::DB_GetXAssetTypeName(list->assets[i].type), (int)list->assets[i].type);
}
}
return result;
}
bool Zones::LoadMaterialTechnique(bool atStreamStart, char* buffer, int size)
{
// 359 and above adds an extra remapped techset ptr
if (Zones::ZoneVersion >= 359) size += 4;
// 446 amd above adds an additional technique
if (Zones::ZoneVersion >= 446) size += 4;
bool result = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::ZoneVersion >= 359)
{
// This shouldn't make any difference.
// The new entry is an additional remapped techset which is linked at runtime.
// It's used when the 0x100 gameFlag in a material is set.
// As MW2 flags are only 1 byte large, this won't be possible anyways
int shiftTest = 4;
std::memmove(buffer + 8 + shiftTest, buffer + 12 + shiftTest, (Zones::Version() >= 446) ? 200 : 196 - shiftTest);
AssetHandler::Relocate(buffer + 12 + shiftTest, buffer + 8 + shiftTest, (Zones::Version() >= 446) ? 200 : 196 - shiftTest);
}
return result;
}
int Zones::LoadMaterialTechniqueArray(bool atStreamStart, int count)
{
if (Zones::Version() >= 446)
{
count += 1;
}
auto retval = Utils::Hook::Call<int(bool, int)>(0x497020)(atStreamStart, count);
if (Zones::Version() >= 446)
{
auto lastTechnique = **reinterpret_cast<Game::MaterialTechnique***>(0x112AEDC);
auto varMaterialTechniqueSet = **reinterpret_cast<Game::MaterialTechniqueSet***>(0x112B070);
// patch last technique to match iw4
varMaterialTechniqueSet->techniques[47] = lastTechnique;
}
return retval;
}
bool Zones::LoadMaterial(bool atStreamStart, char* buffer, int size)
{
// if (Zones::ZoneVersion >= 446 && currentAssetType == Game::ASSET_TYPE_XMODEL) __debugbreak();
bool result = Game::Load_Stream(atStreamStart, buffer, (Zones::Version() >= 446) ? 104 : size);
if (Zones::Version() >= 446)
{
char codol_material[104];
memcpy(codol_material, buffer, 104);
// move material data
std::memmove(buffer, codol_material + 0x10, 4);
std::memmove(buffer + 0x11, codol_material + 0x14, 6);
std::memmove(buffer + 4, codol_material + 0x1A, 1);
std::memmove(buffer + 5, codol_material + 0x1C, 3);
std::memmove(buffer + 8, codol_material, 16);
std::memmove(buffer + 0x18, codol_material + 0x20, 0x30);
std::memmove(buffer + 0x48, codol_material + 0x51, 5);
std::memmove(buffer + 0x50, codol_material + 0x58, 0x10);
std::memset(buffer + 0x48 + 5, 0, 3);
// relocate pointers
AssetHandler::Relocate(buffer + 10, buffer, 4);
AssetHandler::Relocate(buffer + 0x1B, buffer + 4, 4);
AssetHandler::Relocate(buffer, buffer + 8, 16);
AssetHandler::Relocate(buffer + 0x20, buffer + 0x18, 0x30);
AssetHandler::Relocate(buffer + 0x51, buffer + 0x48, 5);
AssetHandler::Relocate(buffer + 0x58, buffer + 0x50, 0x10);
// fix statebit
reinterpret_cast<Game::Material*>(buffer)->stateBitsEntry[47] = codol_material[0x50];
}
else if (Zones::ZoneVersion >= 359)
{
struct material339_s
{
char drawSurfBegin[8]; // 4
//int surfaceTypeBits;
const char* name;
char drawSurf[6];
union
{
char gameFlags;
short sGameFlags;
};
char sortKey;
char textureAtlasRowCount;
char textureAtlasColumnCount;
} material359;
static_assert(offsetof(material339_s, gameFlags) == 18, "");
static_assert(offsetof(material339_s, sortKey) == 20, "");
static_assert(offsetof(material339_s, textureAtlasColumnCount) == 22, "");
static_assert(offsetof(Game::Material, stateBitsEntry) == 24, "");
Game::Material* material = reinterpret_cast<Game::Material*>(buffer);
memcpy(&material359, material, sizeof(material359));
material->info.name = material359.name;
material->info.sortKey = material359.sortKey;
material->info.textureAtlasRowCount = material359.textureAtlasRowCount;
material->info.textureAtlasColumnCount = material359.textureAtlasColumnCount;
material->info.gameFlags = material359.gameFlags;
// Probably wrong
material->info.surfaceTypeBits = 0;//material359.surfaceTypeBits;
// Pretty sure that's wrong
// Actually, it's not
// yes it was lol
memcpy(&material->info.drawSurf.packed, material359.drawSurfBegin, 8);
memcpy(&material->info.surfaceTypeBits, &material359.drawSurf[0], 6); // copies both surfaceTypeBits and hashIndex
//material->drawSurf[8] = material359.drawSurf[0];
//material->drawSurf[9] = material359.drawSurf[1];
//material->drawSurf[10] = material359.drawSurf[2];
//material->drawSurf[11] = material359.drawSurf[3];
}
return result;
}
int gfxLightMapExtraCount = 0;
int* gfxLightMapExtraPtr1 = nullptr;
int* gfxLightMapExtraPtr2 = nullptr;
bool Zones::LoadGfxWorld(bool atStreamStart, char* buffer, int size)
{
gfxLightMapExtraPtr1 = nullptr;
gfxLightMapExtraPtr2 = nullptr;
if (Zones::Version() >= 460) size += 984;
else if (Zones::Version() >= 423) size += 980;
else if (Zones::Version() >= 359) size += 968;
bool result = Game::Load_Stream(atStreamStart, buffer, size);
// fix 4 byte difference in FF ver 460+ this turns 460+ into 423
if (Zones::Version() >= 460)
{
std::memmove(buffer + 0x34, buffer + 0x38, size - 0x38);
AssetHandler::Relocate(buffer + 0x38, buffer + 0x34, size - 0x38);
}
// fix 12 byte difference in FF ver 423+, this turns 423+ into 359
if (Zones::Version() >= 423)
{
// store extra pointers we just yeeted out of the structure
gfxLightMapExtraCount = *reinterpret_cast<int*>(buffer + 0x50 + 0x10);
gfxLightMapExtraPtr1 = *reinterpret_cast<int**>(buffer + 0x50 + 0x14);
gfxLightMapExtraPtr2 = *reinterpret_cast<int**>(buffer + 0x50 + 0x18);
// move gfxworld into 359 format
std::memmove(buffer + 0x50 + 0x10, buffer + 0x50 + 0x1C, size - 0x6C);
AssetHandler::Relocate(buffer + 0x50 + 0x1C, buffer + 0x50 + 0x10, size - 0x6C);
}
if (Zones::Version() >= 359)
{
int sunDiff = 8; // Stuff that is part of the sunflare we would overwrite
std::memmove(buffer + 348 + sunDiff, buffer + 1316 + sunDiff, 280 - sunDiff);
AssetHandler::Relocate(buffer + 1316, buffer + 348, 280);
Game::GfxWorld* world = reinterpret_cast<Game::GfxWorld*>(buffer);
world->fogTypesAllowed = 3;
}
return result;
}
void Zones::Loadsunflare_t(bool atStreamStart)
{
Game::Load_MaterialHandle(atStreamStart);
if (Zones::ZoneVersion >= 359)
{
char* varsunflare_t = *reinterpret_cast<char**>(0x112A848);
*Game::varMaterialHandle = reinterpret_cast<Game::Material**>(varsunflare_t + 12);
Game::Load_MaterialHandle(atStreamStart);
*Game::varMaterialHandle = reinterpret_cast<Game::Material**>(varsunflare_t + 16);
Game::Load_MaterialHandle(atStreamStart);
std::memmove(varsunflare_t + 12, varsunflare_t + 20, 84);
// Copy the remaining struct data we couldn't copy in LoadGfxWorld
char* varGfxWorld = *reinterpret_cast<char**>(0x112A7F4);
std::memmove(varGfxWorld + 348, varGfxWorld + 1316, 8);
}
}
bool Zones::LoadStatement(bool atStreamStart, char* buffer, int size)
{
if (Zones::Version() >= 359) size -= 4;
bool result = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::Version() >= 359)
{
std::memmove(buffer + 12, buffer + 8, 12);
}
return result;
}
void Zones::LoadWindowImage(bool atStreamStart)
{
int* data = (int*)&atStreamStart;
if (*data > 1)
{
printf("");
}
Game::Load_MaterialHandle(atStreamStart);
if (Zones::Version() >= 360)
{
char** varGfxImagePtr = reinterpret_cast<char**>(0x112B4A0);
char** varwindowDef_t = reinterpret_cast<char**>(0x112AF94);
*varGfxImagePtr = *varwindowDef_t + 164;
Game::Load_GfxImagePtr(atStreamStart);
}
}
void Zones::LoadPhysPreset(bool atStreamStart, char* buffer, int size)
{
if (Zones::Version() >= VERSION_ALPHA2)
{
size = 68;
}
Game::Load_Stream(atStreamStart, buffer, size);
}
void Zones::LoadXModelSurfs(bool atStreamStart, char* buffer, int size)
{
if (Zones::Version() >= VERSION_ALPHA2)
{
size = 48;
}
Game::Load_Stream(atStreamStart, buffer, size);
}
void Zones::LoadImpactFx(bool atStreamStart, char* buffer, int size)
{
if (Zones::Version() >= 460) size = 0xB94;
else if (Zones::Version() >= 446) size = 0xA64;
else if (Zones::Version() >= VERSION_ALPHA2) size = 0x8C0;
Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::Version() >= 460)
{
for (auto i = 0; i < Zones::ImpactFxArrayCount(); i++)
{
std::memmove(buffer + (i * 140), buffer + (i * 156), 140);
AssetHandler::Relocate(buffer + (i * 156), buffer + (i * 140), 140);
}
}
}
int Zones::ImpactFxArrayCount()
{
if (Zones::Version() >= 446)
{
return 19;
}
if (Zones::Version() >= VERSION_ALPHA2)
{
return 16;
}
return 15;
}
__declspec(naked) void Zones::LoadImpactFxArray()
{
__asm
{
push edi
pushad
push edi
call Zones::ImpactFxArrayCount
pop edi
mov[esp + 20h], eax
popad
pop edi
push 4447E0h
retn
}
}
void Zones::LoadPathNodeArray(bool atStreamStart, char* buffer, int size)
{
if (Zones::Version() >= VERSION_ALPHA2)
{
size /= 136;
size *= 148;
}
Game::Load_Stream(atStreamStart, buffer, size);
}
void Zones::LoadPathnodeConstantTail(bool atStreamStart, char* buffer, int size)
{
if (Zones::Version() >= VERSION_ALPHA2)
{
size /= 12;
size *= 16;
}
Game::Load_Stream(atStreamStart, buffer, size);
}
void Zones::LoadExpressionSupportingDataPtr(bool atStreamStart)
{
if (Zones::Version() < 359)
{
Utils::Hook::Call<void(bool)>(0x4AF680)(atStreamStart);
}
}
void Zones::SetVersion(int version)
{
AssetHandler::ClearRelocations();
Zones::ZoneVersion = version;
}
__declspec(noinline) bool Zones::CheckGameMapSp(int type)
{
if (type == Game::XAssetType::ASSET_TYPE_GAMEWORLD_SP)
{
return true;
}
if (Zones::Version() >= VERSION_ALPHA2 && Zones::Version() < 423 && type == Game::XAssetType::ASSET_TYPE_GAMEWORLD_MP)
{
Maps::HandleAsSPMap();
return true;
}
return false;
}
__declspec(naked) void Zones::GameMapSpPatchStub()
{
__asm
{
pushad
push eax
call Zones::CheckGameMapSp
add esp, 4h
test al, al
jnz returnSafe
popad
push 4189AEh
retn
returnSafe :
popad
push 41899Dh
retn
}
}
int Zones::PathDataSize()
{
if (Zones::Version() >= VERSION_ALPHA2)
{
return 148;
}
return 136;
}
__declspec(naked) void Zones::LoadPathDataConstant()
{
__asm
{
push esi
pushad
call Zones::PathDataSize
add[esp + 20h], eax
popad
pop esi
push 4D6A4Dh
retn
}
}
__declspec(naked) void Zones::GetCurrentAssetTypeStub()
{
__asm pushad;
previousAssetType = currentAssetType;
__asm popad;
__asm
{
// get asset type
mov eax, ds:0x112aa54
mov eax, [eax];
// log asset type
// mov previousAssetType, currentAssetType;
mov currentAssetType, eax;
// go back
push 0x418847;
retn;
}
}
int Zones::LoadRandomFxGarbage(bool atStreamStart, char* buffer, int size)
{
int count = 0;
if (Zones::Version() >= 446)
{
size /= 48;
count = size;
size *= 64;
}
const auto retval = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::Version() >= 446)
{
for (auto i = 0; i < count; i++)
{
std::memcpy(buffer + (48 * i) + 0, buffer + (64 * i) + 0, 24);
std::memcpy(buffer + (48 * i) + 24, buffer + (64 * i) + 32, 24);
AssetHandler::Relocate(buffer + (64 * i) + 0, buffer + (48 * i) + 0, 24);
AssetHandler::Relocate(buffer + (64 * i) + 32, buffer + (48 * i) + 24, 24);
}
}
return retval;
}
int currentGfxSurfaceIndex = 0;
std::vector<std::pair<int, int*>> gfxSurfaceExtraData;
int Zones::LoadGfxXSurfaceArray(bool atStreamStart, char* buffer, int size)
{
currentGfxSurfaceIndex = 0;
gfxSurfaceExtraData.clear();
int count = 0;
if (Zones::Version() >= 423)
{
size /= 40;
count = size;
size *= 48;
}
const auto retval = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::Version() >= 423)
{
// fix structure
for (auto i = 0; i < count; i++)
{
auto read_count = *reinterpret_cast<int*>(buffer + (48 * i) + 40);
auto read_ptr = *reinterpret_cast<int**>(buffer + (48 * i) + 44);
// extra data stuff we need to load
gfxSurfaceExtraData.push_back({
read_count,
read_ptr
});
// fix structure
std::memmove(buffer + (40 * i), buffer + (48 * i), 40);
AssetHandler::Relocate(buffer + (48 * i), buffer + (40 * i), 40);
}
}
return retval;
}
int Zones::LoadGfxXSurfaceExtraData(bool atStreamStart)
{
const auto retval = Utils::Hook::Call<int(bool)>(0x4516B0)(atStreamStart);
if (Zones::Version() >= 423)
{
const auto currentData = &gfxSurfaceExtraData[currentGfxSurfaceIndex];
if (currentData->second)
{
currentData->second = reinterpret_cast<int*>(Game::DB_AllocStreamPos(0));
Game::Load_Stream(true, currentData->second, currentData->first);
}
currentGfxSurfaceIndex++;
}
return retval;
}
int Zones::LoadGfxReflectionProbes(bool atStreamStart, char* buffer, int size)
{
int count = 0;
if (Zones::Version() >= 446)
{
size /= 12;
count = size;
size *= 20;
}
auto retval = Game::Load_Stream(atStreamStart, buffer, size);
if (Zones::Version() >= 446)
{
for (int i = 0; i < count; i++)
{
auto garbage = *reinterpret_cast<char**>(buffer + (20 * i) + 12);
auto garbage_count = *reinterpret_cast<int*>(buffer + (20 * i) + 16);
if (garbage != nullptr)
{
garbage = Game::DB_AllocStreamPos(3);
Game::Load_Stream(true, garbage, 8 * garbage_count);
for (int j = 0; j < garbage_count; j++)
{
auto garbage_2 = *reinterpret_cast<char**>(garbage + (8 * j) + 0);
auto garbage_2_count = *reinterpret_cast<int*>(garbage + (8 * j) + 4);
if (garbage_2)
{
garbage_2 = Game::DB_AllocStreamPos(1);
Game::Load_Stream(true, garbage_2, 2 * garbage_2_count);
}
}
}
std::memmove(buffer + (12 * i), buffer + (20 * i), 12);
AssetHandler::Relocate(buffer + (20 * i), buffer + (12 * i), 12);
}
}
return retval;
}
void Zones::LoadGfxLightMapExtraData()
{
Game::DB_PopStreamPos();
if (Zones::Version() >= 423)
{
if (gfxLightMapExtraPtr1)
{
gfxLightMapExtraPtr1 = reinterpret_cast<int*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, gfxLightMapExtraPtr1, 12 * gfxLightMapExtraCount);
}
if (gfxLightMapExtraPtr2)
{
gfxLightMapExtraPtr2 = reinterpret_cast<int*>(Game::DB_AllocStreamPos(0));
Game::Load_Stream(true, gfxLightMapExtraPtr2, gfxLightMapExtraCount);
}
}
}
__declspec(naked) void Zones::LoadXModelColSurfPtr()
{
static auto DB_ConvertOffsetToPointer_Address = 0x4A82B0;
__asm
{
cmp dword ptr[eax], 0;
je dontLoadAssetData;
cmp dword ptr[eax], 0xFFFFFFFF;
je loadAssetData;
// check if FF is below 446, still load data in that case
cmp Zones::ZoneVersion, 446;
jl loadAssetData;
// offset to pointer magic
pushad;
push eax;
call DB_ConvertOffsetToPointer_Address;
add esp, 4;
popad;
dontLoadAssetData:
push 0x4C870E;
retn;
loadAssetData:
push 0x4C86DD;
retn;
}
}
struct ClipInfo
{
int numCPlanes;
Game::cplane_s* cPlanes;
int numMaterials;
Game::ClipMaterial* materials;
int numCBrushSides;
Game::cbrushside_t* cBrushSides;
int numCBrushEdges;
char* cBrushEdges;
int numCLeafBrushNodes;
Game::cLeafBrushNode_s* cLeafBrushNodes; // cmodels use this?
int numLeafBrushes;
short* leafBrushes;
unsigned short numBrushes;
Game::cbrush_t* brushes;
Game::Bounds* brushBounds;
int* brushContents;
};
struct codolCmodel_t
{
Game::Bounds bounds;
float radius;
ClipInfo* infoPtr;
Game::cLeaf_t leaf;
};
struct codolClipMap_t
{
char* name;
bool isInUse;
char pad1[3];
ClipInfo info;
ClipInfo* pInfo;
int numStaticModels;
Game::cStaticModel_s* staticModelList;
int numCNodes;
Game::cNode_t* cNodes;
int numCLeaf;
Game::cLeaf_t* cLeaf;
int numVerts;
float(*verts)[3];
int numTriIndices;
short* triIndices;
char* triEdgeIsWalkable; //Size = ((triCount << 1) + triCount + 0x1F) >> 3 << 2
int numCollisionBorders;
Game::CollisionBorder* collisionBorders;
int numCollisionPartitions;
Game::CollisionPartition* collisionPartitions;
int numCollisionAABBTrees;
Game::CollisionAabbTree* collisionAABBTrees;
int numCModels;
codolCmodel_t* cModels;
Game::MapEnts* mapEnts;
Game::Stage* stages;
unsigned char stageCount;
char pad2[3];
Game::MapTriggers trigger;
short smodelNodeCount;
Game::SModelAabbNode* smodelNodes;
unsigned short dynEntCount[2];
Game::DynEntityDef* dynEntDefList[2];
Game::DynEntityPose* dynEntPoseList[2];
Game::DynEntityClient* dynEntClientList[2];
Game::DynEntityColl* dynEntCollList[2];
char pad3[20];
std::uint32_t isPlutoniumMap;
};
static Game::MapEnts codolMapEnts;
static Game::MapEnts* codolMapEntsPtr;
int Zones::LoadMapEnts(bool atStreamStart, Game::MapEnts* buffer, int size)
{
if (Zones::Version() >= 446)
{
size /= 44;
size *= 36;
memset(&codolMapEnts, 0, sizeof Game::MapEnts);
buffer = &codolMapEnts;
codolMapEntsPtr = &codolMapEnts;
*reinterpret_cast<Game::MapEnts**>(0x112B3E8) = &codolMapEnts; // varMapEnts
*reinterpret_cast<Game::MapEnts***>(0x112B388) = &codolMapEntsPtr; // varMapEntsPtr
AssetHandler::Relocate(&codolMapEnts, buffer, size);
}
return Game::Load_Stream(atStreamStart, buffer, size);
}
ClipInfo* varClipInfoPtr;
void Zones::Load_ClipInfo(bool atStreamStart)
{
AssertSize(ClipInfo, 64);
AssertSize(Game::cplane_s, 20);
AssertSize(Game::Bounds, 24);
Game::Load_Stream(atStreamStart, varClipInfoPtr, sizeof ClipInfo);
if (varClipInfoPtr->cPlanes)
{
if (varClipInfoPtr->cPlanes == reinterpret_cast<Game::cplane_s*>(0xFFFFFFFF))
{
varClipInfoPtr->cPlanes = reinterpret_cast<Game::cplane_s*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipInfoPtr->cPlanes, varClipInfoPtr->numCPlanes * sizeof(Game::cplane_s));
}
else
{
Game::DB_ConvertOffsetToPointer(&varClipInfoPtr->cPlanes);
}
}
if (varClipInfoPtr->materials)
{
if (varClipInfoPtr->materials == reinterpret_cast<Game::ClipMaterial*>(0xFFFFFFFF))
{
varClipInfoPtr->materials = reinterpret_cast<Game::ClipMaterial*>(Game::DB_AllocStreamPos(3));
*reinterpret_cast<Game::ClipMaterial**>(0x112A958) = varClipInfoPtr->materials;
Utils::Hook::Call<void(bool, int)>(0x4895F0)(true, varClipInfoPtr->numMaterials);
}
else
{
Game::DB_ConvertOffsetToPointer(&varClipInfoPtr->materials);
}
}
if (varClipInfoPtr->cBrushSides)
{
if (varClipInfoPtr->cBrushSides == reinterpret_cast<Game::cbrushside_t*>(0xFFFFFFFF))
{
varClipInfoPtr->cBrushSides = reinterpret_cast<Game::cbrushside_t*>(Game::DB_AllocStreamPos(3));
*reinterpret_cast<Game::cbrushside_t**>(0x112B33C) = varClipInfoPtr->cBrushSides;
Utils::Hook::Call<void(bool, int)>(0x420790)(true, varClipInfoPtr->numCBrushSides);
}
else
{
Game::DB_ConvertOffsetToPointer(&varClipInfoPtr->cBrushSides);
}
}
if (varClipInfoPtr->cBrushEdges)
{
if (varClipInfoPtr->cBrushEdges == reinterpret_cast<char*>(0xFFFFFFFF))
{
varClipInfoPtr->cBrushEdges = reinterpret_cast<char*>(Game::DB_AllocStreamPos(0));
Game::Load_Stream(true, varClipInfoPtr->cBrushEdges, varClipInfoPtr->numCBrushEdges);
}
else
{
Game::DB_ConvertOffsetToPointer(&varClipInfoPtr->cBrushEdges);
}
}
if (varClipInfoPtr->cLeafBrushNodes)
{
if (varClipInfoPtr->cLeafBrushNodes == reinterpret_cast<Game::cLeafBrushNode_s*>(0xFFFFFFFF))
{
varClipInfoPtr->cLeafBrushNodes = reinterpret_cast<Game::cLeafBrushNode_s*>(Game::DB_AllocStreamPos(3));
*reinterpret_cast<Game::cLeafBrushNode_s**>(0x112B130) = varClipInfoPtr->cLeafBrushNodes;
Utils::Hook::Call<void(bool, int)>(0x4C29D0)(true, varClipInfoPtr->numCLeafBrushNodes);
}
else
{
Game::DB_ConvertOffsetToPointer(&varClipInfoPtr->cLeafBrushNodes);
}
}
if (varClipInfoPtr->leafBrushes)
{
if (varClipInfoPtr->leafBrushes == reinterpret_cast<short*>(0xFFFFFFFF))
{
varClipInfoPtr->leafBrushes = reinterpret_cast<short*>(Game::DB_AllocStreamPos(1));
Game::Load_Stream(true, varClipInfoPtr->leafBrushes, varClipInfoPtr->numLeafBrushes * sizeof(short));
}
else
{
Game::DB_ConvertOffsetToPointer(&varClipInfoPtr->leafBrushes);
}
}
AssertOffset(ClipInfo, numBrushes, 48);
AssertOffset(ClipInfo, brushes, 52);
AssertSize(Game::cbrush_t, 36);
if (varClipInfoPtr->brushes)
{
if (varClipInfoPtr->brushes == reinterpret_cast<Game::cbrush_t*>(0xFFFFFFFF))
{
varClipInfoPtr->brushes = reinterpret_cast<Game::cbrush_t*>(Game::DB_AllocStreamPos(127));
*reinterpret_cast<Game::cbrush_t**>(0x112B2B8) = varClipInfoPtr->brushes;
Utils::Hook::Call<void(bool, unsigned int)>(0x4B4160)(true, varClipInfoPtr->numBrushes);
}
else
{
Game::DB_ConvertOffsetToPointer(&varClipInfoPtr->brushes);
}
}
AssertOffset(ClipInfo, brushBounds, 56);
if (varClipInfoPtr->brushBounds)
{
if (varClipInfoPtr->brushBounds == reinterpret_cast<Game::Bounds*>(0xFFFFFFFF))
{
varClipInfoPtr->brushBounds = reinterpret_cast<Game::Bounds*>(Game::DB_AllocStreamPos(127));
Game::Load_Stream(true, varClipInfoPtr->brushBounds, varClipInfoPtr->numBrushes * sizeof(Game::Bounds));
}
else
{
Game::DB_ConvertOffsetToPointer(&varClipInfoPtr->brushBounds);
}
}
AssertOffset(ClipInfo, brushContents, 60);
if (varClipInfoPtr->brushContents)
{
if (varClipInfoPtr->brushContents == reinterpret_cast<int*>(0xFFFFFFFF))
{
varClipInfoPtr->brushContents = reinterpret_cast<int*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipInfoPtr->brushContents, 4 * varClipInfoPtr->numBrushes);
}
else
{
Game::DB_ConvertOffsetToPointer(&varClipInfoPtr->brushContents);
}
}
}
int Zones::LoadClipMap(bool atStreamStart)
{
if (Zones::Version() >= 446)
{
AssertOffset(codolClipMap_t, pInfo, 72);
AssertSize(Game::cStaticModel_s, 76);
AssertOffset(codolClipMap_t, numStaticModels, 76);
AssertOffset(codolClipMap_t, staticModelList, 80);
auto varClipMap = *reinterpret_cast<codolClipMap_t**>(0x112A758);
Game::Load_Stream(atStreamStart, varClipMap, 256);
Game::DB_PushStreamPos(3);
*Game::varXString = &varClipMap->name;
Game::Load_XString(false);
varClipInfoPtr = &varClipMap->info;
Load_ClipInfo(false);
Game::DB_PushStreamPos(0);
varClipInfoPtr = varClipMap->pInfo;
ClipInfo** assetPointer = nullptr;
if (varClipMap->pInfo)
{
if (varClipMap->pInfo == reinterpret_cast<ClipInfo*>(0xFFFFFFFF) ||
varClipMap->pInfo == reinterpret_cast<ClipInfo*>(0xFFFFFFFE))
{
const auto needsToAllocPointer = varClipMap->pInfo == reinterpret_cast<ClipInfo*>(0xFFFFFFFE);
varClipMap->pInfo = reinterpret_cast<ClipInfo*>(Game::DB_AllocStreamPos(3));
if (needsToAllocPointer) // 0xFFFFFFFE
{
assetPointer = Game::DB_InsertPointer<ClipInfo>();
}
varClipInfoPtr = varClipMap->pInfo;
Load_ClipInfo(true);
// varClipMap->pInfo = &varClipMap->info;
if (assetPointer)
{
*assetPointer = varClipMap->pInfo;
}
}
}
Game::DB_PopStreamPos();
if (varClipMap->staticModelList)
{
varClipMap->staticModelList = reinterpret_cast<Game::cStaticModel_s*>(Game::DB_AllocStreamPos(3));
*reinterpret_cast<Game::cStaticModel_s**>(0x112B0E4) = varClipMap->staticModelList;
Utils::Hook::Call<void(bool, int)>(0x4B7440)(true, varClipMap->numStaticModels);
}
if (varClipMap->cNodes)
{
varClipMap->cNodes = reinterpret_cast<Game::cNode_t*>(Game::DB_AllocStreamPos(3));
*reinterpret_cast<Game::cNode_t**>(0x112B1D0) = varClipMap->cNodes;
Utils::Hook::Call<void(bool, int)>(0x4E65A0)(true, varClipMap->numCNodes);
}
if (varClipMap->cLeaf)
{
varClipMap->cLeaf = reinterpret_cast<Game::cLeaf_t*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipMap->cLeaf, sizeof(Game::cLeaf_t) * varClipMap->numCLeaf);
}
if (varClipMap->verts)
{
varClipMap->verts = reinterpret_cast<float(*)[3]>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipMap->verts, 12 * varClipMap->numVerts);
}
if (varClipMap->triIndices)
{
varClipMap->triIndices = reinterpret_cast<short*>(Game::DB_AllocStreamPos(1));
Game::Load_Stream(true, varClipMap->triIndices, sizeof(short) * varClipMap->numTriIndices * 3);
}
if (varClipMap->triEdgeIsWalkable)
{
varClipMap->triEdgeIsWalkable = static_cast<char*>(Game::DB_AllocStreamPos(0));
#pragma warning(push)
#pragma warning(disable: 4554)
Game::Load_Stream(true, varClipMap->triEdgeIsWalkable, 0x1F + varClipMap->numTriIndices * 3 >> 3 & 0xFFFFFFFC);
#pragma warning(pop)
}
if (varClipMap->collisionBorders)
{
varClipMap->collisionBorders = reinterpret_cast<Game::CollisionBorder*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipMap->collisionBorders, varClipMap->numCollisionBorders * sizeof(Game::CollisionBorder));
}
if (varClipMap->collisionPartitions)
{
varClipMap->collisionPartitions = reinterpret_cast<Game::CollisionPartition*>(Game::DB_AllocStreamPos(3));
*reinterpret_cast<Game::CollisionPartition**>(0x112AA38) = varClipMap->collisionPartitions;
Utils::Hook::Call<void(bool, int)>(0x444AF0)(true, varClipMap->numCollisionPartitions);
}
AssertSize(Game::CollisionAabbTree, 32);
if (varClipMap->collisionAABBTrees)
{
varClipMap->collisionAABBTrees = reinterpret_cast<Game::CollisionAabbTree*>(Game::DB_AllocStreamPos(15));
Game::Load_Stream(true, varClipMap->collisionAABBTrees, varClipMap->numCollisionAABBTrees * sizeof(Game::CollisionAabbTree));
}
AssertSize(Game::cmodel_t, 68);
AssertSize(codolCmodel_t, 72);
AssertOffset(codolCmodel_t, infoPtr, 28);
if (varClipMap->cModels)
{
varClipMap->cModels = reinterpret_cast<codolCmodel_t*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipMap->cModels, sizeof(codolCmodel_t) * varClipMap->numCModels);
// read garbage iw5 data we don't need in iw4
for (auto i = 0; i < varClipMap->numCModels; i++)
{
Game::DB_PushStreamPos(0);
varClipInfoPtr = varClipMap->cModels[i].infoPtr;
if (varClipInfoPtr)
{
if (varClipInfoPtr == reinterpret_cast<ClipInfo*>(0xFFFFFFFF) ||
varClipInfoPtr == reinterpret_cast<ClipInfo*>(0xFFFFFFFE))
{
const auto needsToAllocPointer = varClipMap->pInfo == reinterpret_cast<ClipInfo*>(0xFFFFFFFE);
ClipInfo** info = nullptr;
varClipInfoPtr = reinterpret_cast<ClipInfo*>(Game::DB_AllocStreamPos(3));
if (needsToAllocPointer) // 0xFFFFFFFE
{
info = Game::DB_InsertPointer<ClipInfo>();
}
Load_ClipInfo(true);
if (info)
{
*info = varClipInfoPtr;
}
}
}
Game::DB_PopStreamPos();
}
// fix cmodels
std::vector<Game::cmodel_t> iw4Models;
iw4Models.resize(varClipMap->numCModels);
for (int i = 0; i < varClipMap->numCModels; i++)
{
std::memcpy(&iw4Models[i], &varClipMap->cModels[i], 28);
std::memcpy(&iw4Models[i].leaf, &varClipMap->cModels[i].leaf, 40);
}
std::memcpy(varClipMap->cModels, iw4Models.data(), iw4Models.size() * sizeof Game::cmodel_t);
}
if (varClipMap->smodelNodes)
{
varClipMap->smodelNodes = reinterpret_cast<Game::SModelAabbNode*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipMap->smodelNodes, varClipMap->smodelNodeCount * sizeof(Game::SModelAabbNode));
}
// load mapents
*reinterpret_cast<Game::MapEnts***>(0x112B388) = &varClipMap->mapEnts;
Utils::Hook::Call<void(bool)>(0x5B9E10)(false);
// load stages
if (varClipMap->stages)
{
varClipMap->stages = (Game::Stage*)Game::DB_AllocStreamPos(3);
*reinterpret_cast<Game::Stage**>(0x112A818) = varClipMap->stages;
Utils::Hook::Call<void(bool, int)>(0x4AC760)(true, varClipMap->stageCount);
// IW4 expects stages in mapents instaed of clipmap
codolMapEnts.stageCount = varClipMap->stageCount;
codolMapEnts.stages = varClipMap->stages;
}
// load map triggers
*reinterpret_cast<Game::MapTriggers**>(0x112AB3C) = &varClipMap->trigger;
Utils::Hook::Call<void(bool)>(0x43CBA0)(false);
AssertOffset(codolClipMap_t, dynEntCount[0], 196);
AssertOffset(codolClipMap_t, dynEntCount[1], 198);
// dynamic entity shit
for (int i = 0; i < 2; i++)
{
if (varClipMap->dynEntDefList[i])
{
varClipMap->dynEntDefList[i] = reinterpret_cast<Game::DynEntityDef*>(Game::DB_AllocStreamPos(3));
*reinterpret_cast<Game::DynEntityDef**>(0x112AF3C) = varClipMap->dynEntDefList[i];
Utils::Hook::Call<void(bool, unsigned int)>(0x47CE10)(true, varClipMap->dynEntCount[i]);
}
}
Game::DB_PushStreamPos(2);
for (int i = 0; i < 2; i++)
{
if (varClipMap->dynEntPoseList[i])
{
varClipMap->dynEntPoseList[i] = reinterpret_cast<Game::DynEntityPose*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipMap->dynEntPoseList[i], varClipMap->dynEntCount[i] * sizeof(Game::DynEntityPose));
}
}
for (int i = 0; i < 2; i++)
{
if (varClipMap->dynEntClientList[i])
{
varClipMap->dynEntClientList[i] = reinterpret_cast<Game::DynEntityClient*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipMap->dynEntClientList[i], varClipMap->dynEntCount[i] * sizeof(Game::DynEntityClient));
}
}
for (int i = 0; i < 2; i++)
{
if (varClipMap->dynEntCollList[i])
{
varClipMap->dynEntCollList[i] = reinterpret_cast<Game::DynEntityColl*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, varClipMap->dynEntCollList[i], varClipMap->dynEntCount[i] * sizeof(Game::DynEntityColl));
}
}
Game::DB_PopStreamPos();
Game::DB_PopStreamPos();
auto codolMap = new codolClipMap_t;
memcpy(codolMap, varClipMap, sizeof codolClipMap_t);
auto cancerMap = reinterpret_cast<codolClipMap_t*>(varClipMap);
auto iw4Map = reinterpret_cast<Game::clipMap_t*>(varClipMap);
memcpy(&iw4Map->planeCount, &codolMap->info.numCPlanes, 8);
memcpy(&iw4Map->numStaticModels, &codolMap->numStaticModels, 8);
memcpy(&iw4Map->numMaterials, &codolMap->info.numMaterials, 24);
memcpy(&iw4Map->numNodes, &codolMap->numCNodes, 16);
memcpy(&iw4Map->leafbrushNodesCount, &codolMap->info.numCLeafBrushNodes, 16);
memcpy(&iw4Map->vertCount, &codolMap->numVerts, 52);
memcpy(&iw4Map->numBrushes, &codolMap->info.numBrushes, 16);
iw4Map->mapEnts = &codolMapEnts;
memcpy(&iw4Map->smodelNodeCount, &codolMap->smodelNodeCount, 48);
// unused on IW4
iw4Map->numLeafSurfaces = 0;
AssetHandler::Relocate(&cancerMap->info.numCPlanes, &iw4Map->planeCount, 8);
AssetHandler::Relocate(&cancerMap->numStaticModels, &iw4Map->numStaticModels, 8);
AssetHandler::Relocate(&cancerMap->info.numMaterials, &iw4Map->numMaterials, 24);
AssetHandler::Relocate(&cancerMap->numCNodes, &iw4Map->numNodes, 16);
AssetHandler::Relocate(&cancerMap->info.numCLeafBrushNodes, &iw4Map->leafbrushNodesCount, 16);
AssetHandler::Relocate(&cancerMap->numVerts, &iw4Map->vertCount, 52);
AssetHandler::Relocate(&cancerMap->info.numBrushes, &iw4Map->numBrushes, 16);
AssetHandler::Relocate(&cancerMap->smodelNodeCount, &iw4Map->smodelNodeCount, 48);
delete codolMap;
return 1;
}
else
{
return Utils::Hook::Call<int(bool)>(0x46C390)(atStreamStart);
}
}
static const unsigned int crcTable[] =
{
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
uint32_t Zones::HashCRC32StringInt(const std::string& string, uint32_t initialCrc)
{
auto curPtr = reinterpret_cast<std::uint8_t*>(const_cast<char*>(string.data()));
auto remaining = string.size();
auto crc = ~initialCrc;
for (; remaining--; ++curPtr)
{
crc = (crc >> 8) ^ crcTable[(crc ^ *curPtr) & 0xFF];
}
return (~crc);
}
std::unordered_map<int, Zones::FileData> Zones::fileDataMap;
std::mutex Zones::fileDataMutex;
__declspec(naked) int Zones::FS_FOpenFileReadForThreadOriginal(const char*, int*, int)
{
__asm
{
sub esp, 0x33C
push 0x643276
ret
}
}
int Zones::FS_FOpenFileReadForThreadHook(const char* file, int* filePointer, int thread)
{
const auto retval = FS_FOpenFileReadForThreadOriginal(file, filePointer, thread);
if (file != nullptr && filePointer != nullptr && strlen(file) >= 4 && retval > 0)
{
std::string fileBuffer;
fileBuffer.resize(retval);
auto readSize = Game::FS_Read(&fileBuffer[0], retval, *filePointer);
// check if file should be skipped
auto skipFile = false;
if (std::strlen(file) > 5 && ((std::strncmp(&file[strlen(file) - 4], ".iwi", 4) != 0)))
{
skipFile = true;
}
else if (readSize >= 3 && (std::memcmp(&fileBuffer[0], "IWi", 3) == 0))
{
skipFile = true;
}
// if the header seems encrypted...
if (fileBuffer.size() > 4 && readSize == retval && !skipFile)
{
auto packedSize = fileBuffer.size() - 4;
auto unpackedSize = *reinterpret_cast<int*>(&fileBuffer[fileBuffer.size() - 4]);
// calc encrypted buffer size
auto encryptedBufferSize = fileBuffer.size();
encryptedBufferSize -= 4;
encryptedBufferSize += 16 - (encryptedBufferSize % 16);
// prepare encryptedData buffer
std::string encryptedData;
encryptedData.resize(encryptedBufferSize);
memcpy(&encryptedData[0], &fileBuffer[0], packedSize);
// prepare decryptedData buffer
std::string decryptedData;
decryptedData.resize(encryptedBufferSize);
register_cipher(&aes_desc);
auto aes = find_cipher("aes");
// attempt to decrypt the IWI
symmetric_CTR ctr_state;
ZeroMemory(&ctr_state, sizeof(symmetric_CTR));
// decryption keys
std::uint8_t aesKey[24] = { 0x15, 0x9a, 0x03, 0x25, 0xe0, 0x75, 0x2e, 0x80, 0xc6, 0xc0, 0x94, 0x2a, 0x50, 0x5c, 0x1c, 0x68, 0x8c, 0x17, 0xef, 0x53, 0x99, 0xf8, 0x68, 0x3c };
std::uint32_t aesIV[4] = { 0x1010101, 0x1010101, 0x1010101, 0x1010101 };
auto strippedFileName = std::filesystem::path(file).filename().string();
auto nonce = HashCRC32StringInt(strippedFileName, strippedFileName.size());
std::uint8_t iv[16];
std::memset(iv, 0, sizeof iv);
std::memcpy(iv, &nonce, 4);
std::memcpy(iv + 4, &unpackedSize, 4);
ctr_start(aes, reinterpret_cast<unsigned char*>(&aesIV[0]), &aesKey[0], sizeof aesKey, 0, CTR_COUNTER_BIG_ENDIAN, &ctr_state);
// decrypt image
auto readDataSize = 0u;
while (readDataSize < packedSize)
{
auto left = (packedSize - readDataSize);
auto blockSize = (left > 0x8000) ? 0x8000 : left;
std::memcpy(iv + 8, &readDataSize, 4);
std::memcpy(iv + 12, &blockSize, 4);
ctr_setiv(iv, sizeof iv, &ctr_state);
ctr_decrypt(reinterpret_cast<uint8_t*>(&encryptedData[readDataSize]), reinterpret_cast<uint8_t*>(&decryptedData[readDataSize]), blockSize, &ctr_state);
readDataSize += blockSize;
}
ctr_done(&ctr_state);
if (static_cast<std::uint8_t>(decryptedData[0]) == 0x78)
{
FileData data = {};
data.readPos = 0;
data.len = unpackedSize;
data.fileContents.resize(unpackedSize);
// decompress the buffer
auto result = uncompress(reinterpret_cast<std::uint8_t*>(&data.fileContents[0]),
reinterpret_cast<unsigned long*>(&data.len), reinterpret_cast<const uint8_t*>(&decryptedData[0]), packedSize);
// insert file data
if (result == Z_OK)
{
std::lock_guard _(fileDataMutex);
fileDataMap[*filePointer] = data;
return unpackedSize;
}
}
}
// un-read data, file is apparently not encrypted
Game::FS_Seek(*filePointer, 0, Game::FS_SEEK_SET);
}
return retval;
}
__declspec(naked) int Zones::FS_ReadOriginal(void*, size_t, int)
{
__asm
{
push ecx
mov eax, [esp + 0x10]
push 0x4A04C5
ret
}
}
int Zones::FS_ReadHook(void* buffer, size_t size, int filePointer)
{
std::lock_guard _(fileDataMutex);
if (auto itr = fileDataMap.find(filePointer); itr != fileDataMap.end())
{
if (!itr->second.fileContents.empty())
{
const auto readSize = std::min(size, itr->second.fileContents.size() - itr->second.readPos);
std::memcpy(buffer, &itr->second.fileContents[itr->second.readPos], readSize);
itr->second.readPos += readSize;
return static_cast<int>(readSize);
}
}
return FS_ReadOriginal(buffer, size, filePointer);
}
__declspec(naked) void Zones::FS_FCloseFileOriginal(int)
{
__asm
{
mov eax, [esp + 4]
push esi
push 0x462005
ret
}
}
void Zones::FS_FCloseFileHook(int filePointer)
{
std::lock_guard _(fileDataMutex);
FS_FCloseFileOriginal(filePointer);
if (const auto itr = fileDataMap.find(filePointer); itr != fileDataMap.end())
{
fileDataMap.erase(itr);
}
}
__declspec(naked) std::uint32_t Zones::FS_SeekOriginal(int, int, int)
{
__asm
{
push esi
mov esi, [esp + 8]
push 0x4A63D5
ret
}
}
std::uint32_t Zones::FS_SeekHook(int fileHandle, int seekPosition, int seekOrigin)
{
std::lock_guard _(fileDataMutex);
if (const auto itr = fileDataMap.find(fileHandle); itr != fileDataMap.end())
{
if (seekOrigin == Game::FS_SEEK_SET)
{
itr->second.readPos = seekPosition;
}
else if (seekOrigin == Game::FS_SEEK_CUR)
{
itr->second.readPos += seekPosition;
}
else if (seekOrigin == Game::FS_SEEK_END)
{
itr->second.readPos = itr->second.fileContents.size() - seekPosition;
}
return itr->second.readPos;
}
return FS_SeekOriginal(fileHandle, seekPosition, seekOrigin);
}
__declspec(naked) void Zones::LoadMapTriggersModelPointer()
{
static auto DB_ConvertOffsetToPointer_Address = 0x4A82B0;
__asm
{
cmp dword ptr[edx + 4], 0;
je dontLoadAssetData;
cmp dword ptr[edx + 4], 0xFFFFFFFF;
je loadAssetData;
// check if FF is below 446, still load data in that case
cmp Zones::ZoneVersion, 446;
jl loadAssetData;
// offset to pointer magic
pushad;
push eax;
call DB_ConvertOffsetToPointer_Address;
add esp, 4;
popad;
dontLoadAssetData:
push 0x43CBF3;
retn;
loadAssetData:
push 0x43CBC1;
retn;
}
}
__declspec(naked) void Zones::LoadMapTriggersHullPointer()
{
static auto DB_ConvertOffsetToPointer_Address = 0x4A82B0;
__asm
{
cmp dword ptr[eax + 0Ch], 0;
je dontLoadAssetData;
cmp dword ptr[eax + 0Ch], 0xFFFFFFFF;
je loadAssetData;
// check if FF is below 446, still load data in that case
cmp Zones::ZoneVersion, 446;
jl loadAssetData;
// offset to pointer magic
pushad;
push eax;
call DB_ConvertOffsetToPointer_Address;
add esp, 4;
popad;
dontLoadAssetData:
push 0x43CC2E;
retn;
loadAssetData:
push 0x43CBFE;
retn;
}
}
__declspec(naked) void Zones::LoadMapTriggersSlabPointer()
{
static auto DB_ConvertOffsetToPointer_Address = 0x4A82B0;
__asm
{
cmp dword ptr[eax + 14h], 0;
je dontLoadAssetData;
cmp dword ptr[eax + 14h], 0xFFFFFFFF;
je loadAssetData;
// check if FF is below 446, still load data in that case
cmp Zones::ZoneVersion, 446;
jl loadAssetData;
// offset to pointer magic
pushad;
push eax;
call DB_ConvertOffsetToPointer_Address;
add esp, 4;
popad;
dontLoadAssetData:
push 0x43CC6D;
retn;
loadAssetData:
push 0x43CC39;
retn;
}
}
void Zones::LoadFxWorldAsset(Game::FxWorld** asset)
{
Utils::Hook::Call<void(Game::FxWorld**)>(0x4857F0)(asset);
if (Zones::Version() >= 423 && asset && *asset)
{
// allocate glass data structures
static Game::GameWorldMp glassMap;
static Game::GameWorldMp* glassMapPtr;
static Game::G_GlassData glassData;
static std::vector<Game::G_GlassPiece> glassPieces;
// clear previous glass data
memset(&glassMap, 0, sizeof Game::GameWorldMp);
memset(&glassData, 0, sizeof Game::G_GlassData);
glassPieces.clear();
// generate glassPieces array
const auto pieceCount = (*asset)->glassSys.initPieceCount;
if (pieceCount > 0)
{
glassPieces.resize(pieceCount);
memset(&glassPieces[0], 0, sizeof(Game::G_GlassPiece) * pieceCount);
// generate glassData array
glassData.glassPieces = glassPieces.data();
glassData.pieceCount = glassPieces.size();
}
else
{
// game seems to do an array lookup on the first index even if there's no glass pieces?
static Game::G_GlassPiece emptyPiece;
glassData.glassPieces = &emptyPiece;
}
// build glass asset
glassMap.g_glassData = &glassData;
glassMap.name = (*asset)->name;
// set glass map ptr
glassMapPtr = &glassMap;
// add glass to DB
Utils::Hook::Call<void(Game::GameWorldMp**)>(0x4A6240)(&glassMapPtr);
}
}
void Zones::LoadXModelAsset(Game::XModel** asset)
{
if (Zones::Version() >= 446)
{
for (int i = 0; i < (*asset)->numLods; i++)
{
if ((*asset)->lodInfo[i].surfs == nullptr && Zones::Version() >= 446)
{
const auto name = (*asset)->name;
const auto fx_model = Game::DB_FindXAssetHeader(Game::XAssetType::ASSET_TYPE_XMODEL, "void").model;
memcpy(*asset, fx_model, sizeof Game::XModel);
(*asset)->name = name;
break;
}
}
}
return Utils::Hook::Call<void(Game::XModel**)>(0x47A690)(asset);
}
// patch max file amount returned by Sys_ListFiles
constexpr auto fileCountMultiplier = 8;
constexpr auto maxFileCount = 8191 * fileCountMultiplier;
Game::HunkUser* Hunk_UserCreate_Stub(int maxSize, const char* name, bool fixed, int type)
{
maxSize *= fileCountMultiplier;
return Utils::Hook::Call<Game::HunkUser* (int, const char*, bool, int)>(0x430E90)(maxSize, name, fixed, type);
}
void Zones::LoadMaterialAsset(Game::Material** asset)
{
if (asset && *asset && Zones::Version() >= 446)
{
static std::vector<std::string> broken_materials = {
"gfx_fxt_debris_wind_ash_z10",
"gfx_fxt_smk_light_z3"
};
// replace broken materials with the default one as restricting them does not seem to work.
const auto itr = std::find(broken_materials.begin(), broken_materials.end(), (*asset)->info.name);
if (itr != broken_materials.end())
{
const auto name = (*asset)->info.name;
const auto default_material = Game::DB_FindXAssetHeader(Game::XAssetType::ASSET_TYPE_MATERIAL, "$default").material;
memcpy(*asset, default_material, sizeof Game::Material);
(*asset)->info.name = name;
}
}
return Utils::Hook::Call<void(Game::Material**)>(0x476750)(asset);
}
void Zones::LoadTracerDef(bool atStreamStart)
{
struct TracerDef_461
{
char* name;
Game::Material* material;
Game::FxEffectDef* fx;
unsigned int drawInterval;
float speed;
float beamLength;
float beamWidth;
float screwRadius;
float screwDist;
float colors[5][4];
};
static_assert(sizeof(TracerDef_461) == 116);
static_assert(offsetof(TracerDef_461, material) == 4);
static_assert(offsetof(TracerDef_461, fx) == 8);
if (Zones::Version() >= 460)
{
const auto size = 116;
TracerDef_461 def{};
Game::Load_Stream(atStreamStart, &def, size);
Game::DB_PushStreamPos(3);
*Game::varXString = &def.name;
Game::Load_XString(0);
*Game::varMaterialHandle = &def.material;
Game::Load_MaterialHandle(0);
*Game::varFxEffectDefHandle = &def.fx;
Game::Load_FxEffectDefHandle(0);
Game::DB_PopStreamPos();
const auto iw4Tracer = **Game::varTracerDefPtr;
iw4Tracer->name = def.name;
iw4Tracer->material = def.material;
iw4Tracer->drawInterval = def.drawInterval;
iw4Tracer->speed = def.speed;
iw4Tracer->beamLength = def.beamLength;
iw4Tracer->beamWidth = def.beamWidth;
iw4Tracer->screwRadius = def.screwRadius;
iw4Tracer->screwDist = def.screwDist;
std::memcpy(iw4Tracer->colors, def.colors, sizeof(float) * 4 * 5);
printf("");
}
else
{
// Call original
Utils::Hook::Call<void(bool)>(0x471460)(atStreamStart);
}
}
char* Zones::ParseShellShock_Stub(const char** data_p)
{
auto token = Game::Com_Parse(data_p);
if (shellshock_replace_list.find(token) != shellshock_replace_list.end())
{
return shellshock_replace_list[token].data();
}
return token;
}
static auto varMenu = reinterpret_cast<Game::menuDef_t**>(0x112B0EC);
// 461 Menu work
void __cdecl Load_windowDef_t(char a1)
{
if (Zones::Version() >= VERSION_LATEST_CODO)
{
printf("");
}
else {
printf("");
}
Utils::Hook::Call<void(char)>(0x4719E0)(a1);
return;
}
void __cdecl Load_MenuPtr(char a1)
{
if (Zones::Version() >= VERSION_LATEST_CODO)
{
printf("");
}
else {
printf("");
}
Utils::Hook::Call<void(char)>(0x463920)(a1);
printf("");
}
void __cdecl Load_itemDef_ptrArray(char a1, int count)
{
if (Zones::Version() >= VERSION_LATEST_CODO)
{
printf("");
}
else {
printf("");
}
Utils::Hook::Call<void(char, int)>(0x406260)(a1, count);
return;
}
void __cdecl Load_itemDef_s(char a1)
{
if (Zones::Version() >= VERSION_LATEST_CODO)
{
printf("");
}
else {
printf("");
}
Utils::Hook::Call<void(char)>(0x491980)(a1);
auto justLoaded = *((Game::itemDef_s***)0x112A74C);
if ((*justLoaded)->window.name && (*justLoaded)->window.name == "playermutelist"s)
{
printf("");
}
return;
}
void __cdecl Load_Stream_itemDef_s(char atStreamStart, Game::itemDef_s* item, size_t size)
{
if (Zones::Version() >= VERSION_LATEST_CODO)
{
// 3x4 new structs?
size += 12;
}
bool result = Game::Load_Stream(atStreamStart, item, size);
auto itemBaseOffset = reinterpret_cast<size_t>(item);
auto varMenu = *((Game::menuDef_t**)0x112B0EC);
if (Zones::Version() >= VERSION_LATEST_CODO)
{
// CODO 461 has one more member with a very early offset
{
constexpr auto newMemberPosition = offsetof(Game::itemDef_s, type);
constexpr auto newMemberSize = sizeof(int);
const auto sizeToMove = size - newMemberPosition - newMemberSize;
const auto destination = reinterpret_cast<void*>(itemBaseOffset + newMemberPosition);
const auto origin = reinterpret_cast<void*>(itemBaseOffset + newMemberPosition + newMemberSize);
std::memcpy(destination, origin, sizeToMove);
AssetHandler::Relocate(destination, origin, sizeToMove);
}
// And two more expressions of 4 bytes each
{
constexpr auto newExpressionsPosition = offsetof(Game::itemDef_s, glowColor);
constexpr auto newExpressionsSize = sizeof(void*) * 2;
const auto sizeToMove = size - newExpressionsPosition - newExpressionsSize;
const auto destination = reinterpret_cast<void*>(itemBaseOffset + newExpressionsPosition);
const auto origin = reinterpret_cast<void*>(itemBaseOffset + newExpressionsPosition + newExpressionsSize);
// Keeping them on the side because we will need to read them if any
void* codoXpressions[2];
memcpy(codoXpressions, destination, sizeof(codoXpressions));
std::memcpy(destination, origin, sizeToMove);
for (size_t i = 0; i < ARRAYSIZE(codoXpressions); i++)
{
if (codoXpressions[i] != 0) {
// Load the extra expression in an empty expression slot so that it gets loaded by the game, no extra sweat
if (!item->materialExp) item->materialExp = reinterpret_cast<Game::Statement_s*>(codoXpressions[i]);
else if (!item->textExp) item->textExp = reinterpret_cast<Game::Statement_s*>(codoXpressions[i]);
else if (!item->disabledExp) item->disabledExp = reinterpret_cast<Game::Statement_s*>(codoXpressions[i]);
else if (!item->visibleExp) item->visibleExp = reinterpret_cast<Game::Statement_s*>(codoXpressions[i]);
else {
printf(""); // This is gonna be a bigger problem than anticipated
}
}
}
AssetHandler::Relocate(destination, origin, sizeToMove);
}
}
return;
}
void Load_UnknownAssetType45()
{
struct codo461_unknownAssetType45
{
char* name;
void* unk1;
int pad1;
void* unk2;
int countOfUnk2;
char padEnd[0x30EC - 20];
};
static_assert(offsetof(codo461_unknownAssetType45, countOfUnk2) == 16);
static_assert(sizeof(codo461_unknownAssetType45) == 0x30EC);
static_assert(sizeof(codo461_unknownAssetType45) <= 0x30EC);
static_assert(sizeof(codo461_unknownAssetType45) >= 0x30EC);
#define LOAD_XSTRING(member)\
*Game::varXString = reinterpret_cast<char**>(&member);\
Game::Load_XString(false)
codo461_unknownAssetType45 target{};
const auto streamPosIndex = *Game::g_streamPosIndex;
Game::DB_ReadXFile(reinterpret_cast<void*>(&target), 0x30EC);
*Game::g_streamPos += 0x30EC;
Game::DB_PushStreamPos(3);
if (target.name)
{
LOAD_XSTRING(target.name);
}
#undef LOAD_XSTRING
printf("");
}
void Load_UnknownAssetType45Ptr(char** varAssetType43Ptr)
{
Game::DB_PushStreamPos(0);
char* varAssetType43 = *varAssetType43Ptr;
if (varAssetType43)
{
if (
*varAssetType43 == -1 ||
*varAssetType43 == -2
)
{
int newStreamPos = (*Game::g_streamPos + 3) & 0xFFFFFFFC;
*varAssetType43Ptr = reinterpret_cast<char*>(newStreamPos);
*Game::g_streamPos = newStreamPos;
varAssetType43 = reinterpret_cast<char*>(*Game::g_streamPos);
if (varAssetType43 == reinterpret_cast<void*>(-2))
{
Game::DB_PushStreamPos(3);
newStreamPos = ((*Game::g_streamPos + 3) & 0xFFFFFFFC);
*Game::g_streamPos = (newStreamPos + 1);
Game::DB_PopStreamPos();
}
Load_UnknownAssetType45();
//sub_49C4E0();
}
else
{
// We don't care
}
}
Game::DB_PopStreamPos();
}
void CheckAssetType_Hook(Game::XAssetType type)
{
if (Zones::Version() >= VERSION_LATEST_CODO)
{
Logger::Print("LOADING INLINE ASSET TYPE {}\n", static_cast<int>(type));
currentAssetType = type;
if (type == 0x2B)
{
printf("");
}
//switch (type)
//{
// case 0x2C:
// // Unknown CODO type
// {
// int32_t purge;
// Game::Load_Stream(false, &purge, 4);
// Game::DB_PushStreamPos(0);
// Game::DB_PopStreamPos()
// }
// break;
//}
}
}
__declspec(naked) void CheckAssetType_Stub()
{
__asm
{
pushad
push eax
call CheckAssetType_Hook
pop eax
popad
// original code
cmp eax, 1
jz isPhysColMap
// return
push 0x418870
ret
isPhysColMap:
// return
push 0x418861
ret
}
}
// Identical (except for elemtype) to MW2 Version
// But on MW2 v159, it's inlined, so we can reimplement it.
void Load_FxElemExtendedPtr_461(Game::FxElemExtendedDefPtr* extended, FxElemDef_461* elem)
{
if (elem->elemType == FxElemType_461::FX_ELEM_TYPE_TRAIL)
{
if (extended)
{
extended->trailDef = reinterpret_cast<Game::FxTrailDef*>(Game::DB_AllocStreamPos(3));
static_assert(sizeof(Game::FxTrailDef) == 0x24);
static_assert(sizeof(Game::FxTrailVertex) == 20);
Game::Load_Stream(1, extended->trailDef, sizeof(Game::FxTrailDef));
if (extended->trailDef->verts)
{
extended->trailDef->verts = reinterpret_cast<Game::FxTrailVertex*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, extended->trailDef->verts, sizeof(Game::FxTrailVertex) * extended->trailDef->vertCount);
}
if (extended->trailDef->inds)
{
extended->trailDef->inds = reinterpret_cast<uint16_t*>(Game::DB_AllocStreamPos(1));
Game::Load_Stream(true, extended->trailDef->inds, sizeof(uint16_t) * extended->trailDef->indCount);
}
}
}
else if (elem->elemType == FxElemType_461::FX_ELEM_TYPE_SPARK_FOUNTAIN)
{
static_assert(sizeof(Game::FxSparkFountainDef) == 0x34);
if (extended)
{
extended->sparkFountainDef = reinterpret_cast<Game::FxSparkFountainDef*>(Game::DB_AllocStreamPos(3));
Game::Load_Stream(true, extended->sparkFountainDef, sizeof(Game::FxSparkFountainDef));
}
}
else
{
if (extended)
{
extended->unknownDef = Game::DB_AllocStreamPos(0);
Game::Load_Stream(true, extended->unknownDef, 1);
}
}
}
void Load_FxElemDef_461(FxElemDef_461* def)
{
static auto varFxElemDef = reinterpret_cast<Game::FxElemDef**>(0x0112B018);
Game::Load_Stream(false, def, sizeof(FxElemDef_461));
static_assert(sizeof(Game::FxElemDef) < sizeof(FxElemDef_461));
std::memcpy(*varFxElemDef, def, sizeof(Game::FxElemDef));
auto iw4_def = *varFxElemDef;
// Fix type
iw4_def->elemType = elemTypeMapCodoToIW4.at(def->elemType);
if (iw4_def->velSamples)
{
static_assert(sizeof(Game::FxElemVelStateSample) == 96);
iw4_def->velSamples = reinterpret_cast<Game::FxElemVelStateSample*>(Game::DB_AllocStreamPos(3));
auto varFxElemVelStateSample = iw4_def->velSamples;
Game::Load_Stream(true, varFxElemVelStateSample, sizeof(Game::FxElemVelStateSample) * (iw4_def->velIntervalCount + 1));
}
if (iw4_def->visSamples)
{
static_assert(sizeof(Game::FxElemVisStateSample) == 48);
iw4_def->visSamples = reinterpret_cast<Game::FxElemVisStateSample*>(Game::DB_AllocStreamPos(3));
auto varFxElemVisStateSample = iw4_def->visSamples;
Game::Load_Stream(true, varFxElemVisStateSample, sizeof(Game::FxElemVisStateSample) * (iw4_def->visStateIntervalCount + 1));
}
static Game::FxElemDefVisuals** varFxElemDefVisuals = reinterpret_cast<Game::FxElemDefVisuals**>(0x112A7B8);
*varFxElemDefVisuals = &iw4_def->visuals;
// Load_FxElemDefVisuals
Utils::Hook::Call<void(int)>(0x417F90)(0);
static auto varFxEffectDefRef = reinterpret_cast<Game::FxEffectDefRef**>(0x112ABA8);
*varFxEffectDefRef = &iw4_def->effectOnImpact;
*Game::varXString = &iw4_def->effectOnImpact.name;
Game::Load_XString(false);
*varFxEffectDefRef = &iw4_def->effectOnDeath;
*Game::varXString = &iw4_def->effectOnDeath.name;
Game::Load_XString(false);
*varFxEffectDefRef = &iw4_def->effectEmitted;
*Game::varXString = &iw4_def->effectEmitted.name;
Game::Load_XString(false);
static auto varFxElemExtendedDefPtr = reinterpret_cast<Game::FxElemExtendedDefPtr**>(0x45AEDE);
*varFxElemExtendedDefPtr = &iw4_def->extended;
Load_FxElemExtendedPtr_461(&def->extended, def);
iw4_def->extended = def->extended;
// Additional unknown string
*Game::varXString = &def->unknownString;
Game::Load_XString(false);
printf("");
}
void Load_FxElemDefArray(bool atStreamStart, int count)
{
if (Zones::Version() < VERSION_ALPHA2)
{
Utils::Hook::Call<void(bool, int)>(0x495900)(atStreamStart, count);
return;
}
static_assert(sizeof(FxElemDef_461) == 260);
if (count > 15)
{
throw std::exception("HORRIBLE!");
}
static FxElemDef_461 elems[16]{};
Game::Load_Stream(atStreamStart, elems, sizeof(FxElemDef_461) * count);
for (int i = 0; i < count; i++)
{
const auto ptr = static_cast<int>(reinterpret_cast<intptr_t>(elems));
AssetHandler::Relocate(reinterpret_cast<void*>(ptr + (260 * i)), reinterpret_cast<void*>(ptr + (252 * i)), 252);
Load_FxElemDef_461(&elems[i]);
}
}
Zones::Zones()
{
Zones::ZoneVersion = 0;
// 461 Menu work
Utils::Hook(0x41A5B8, Load_windowDef_t, HOOK_CALL).install()->quick();
Utils::Hook(0x4A3BF8, Load_MenuPtr, HOOK_CALL).install()->quick();
Utils::Hook(0x41A85E, Load_itemDef_ptrArray, HOOK_CALL).install()->quick();
Utils::Hook(0x4062CB, Load_itemDef_s, HOOK_CALL).install()->quick();
Utils::Hook(0x491990, Load_Stream_itemDef_s, HOOK_CALL).install()->quick();
Utils::Hook(0x4AF2B4, Load_FxElemDefArray, HOOK_CALL).install()->quick();
if (ZoneBuilder::IsEnabled())
{
Command::Add("decryptImages", []()
{
auto images = FileSystem::GetSysFileList("iw4x/images", "iwi");
Logger::Print("decrypting {} images...\n", images.size());
for (auto& image : images)
{
char* buffer = nullptr;
auto fileLength = Game::FS_ReadFile(Utils::String::Format("images/{}", image), &buffer);
if (fileLength && buffer)
{
if (!std::filesystem::exists("raw/images"))
{
std::filesystem::create_directories("raw/images");
}
if (!std::filesystem::exists(Utils::String::Format("raw/images/{}", image)))
{
const auto fp = fopen(Utils::String::Format("raw/images/{}", image), "wb");
if (fp)
{
fwrite(buffer, fileLength, 1, fp);
fclose(fp);
}
}
Game::FS_FreeFile(buffer);
}
}
Logger::Print("decrypted {} images!\n", images.size());
});
Command::Add("decryptSounds", []()
{
auto sounds = FileSystem::GetSysFileList("iw4x/sound", "iwi");
Logger::Print("decrypting {} sounds...\n", sounds.size());
for (auto& sound : sounds)
{
char* buffer = nullptr;
auto len = Game::FS_ReadFile(Utils::String::Format("sound/{}", sound), &buffer);
if (len && buffer)
{
auto path = std::filesystem::path(sound.data());
std::filesystem::create_directories("raw/sound" / path.parent_path());
if (!std::filesystem::exists(std::format("raw/sound/{}", sound)))
{
FILE* fp;
if (!fopen_s(&fp, Utils::String::Format("raw/sound/{}", sound), "wb") && fp)
{
fwrite(buffer, len, 1, fp);
fclose(fp);
}
}
Game::FS_FreeFile(buffer);
}
}
Logger::Print("decrypted {} sounds!\n", sounds.size());
});
}
// patch max filecount Sys_ListFiles can return
Utils::Hook::Set<std::uint32_t>(0x45A66B, (maxFileCount + fileCountMultiplier) * 4);
Utils::Hook::Set<std::uint32_t>(0x64AF78, maxFileCount);
Utils::Hook::Set<std::uint32_t>(0x64B04F, maxFileCount);
Utils::Hook::Set<std::uint32_t>(0x45A8CE, maxFileCount);
Utils::Hook(0x45A806, Hunk_UserCreate_Stub, HOOK_CALL).install()->quick();
Utils::Hook(0x45A6A0, Hunk_UserCreate_Stub, HOOK_CALL).install()->quick();
#ifndef DEBUG
// Ignore missing soundaliases for now
// TODO: Include them in the dependency zone!
Utils::Hook::Nop(0x644207, 5);
#endif
// Block Mark_pathnode_constant_t
Utils::Hook::Set<BYTE>(0x4F74B0, 0xC3);
// addon_map_ents asset type (we reuse it for weaponattach)
// We treat the case "asset type 43" as a default case (any type higher or equal than 43 will hit)
Utils::Hook::Set<BYTE>(0x418B31, 0x72);
// encrypted images hooks
if (ZoneBuilder::IsEnabled())
{
Utils::Hook(0x462000, Zones::FS_FCloseFileHook, HOOK_JUMP).install()->quick();
Utils::Hook(0x4A04C0, Zones::FS_ReadHook, HOOK_JUMP).install()->quick();
Utils::Hook(0x643270, Zones::FS_FOpenFileReadForThreadHook, HOOK_JUMP).install()->quick();
Utils::Hook(0x4A63D0, Zones::FS_SeekHook, HOOK_JUMP).install()->quick();
}
// asset hooks
Utils::Hook(0x493102, Zones::LoadTracerDef, HOOK_CALL).install()->quick();
Utils::Hook(0x4039DE, Zones::LoadMaterialAsset, HOOK_CALL).install()->quick();
Utils::Hook(0x4FCAEE, Zones::LoadXModelAsset, HOOK_CALL).install()->quick();
Utils::Hook(0x5BA01E, Zones::LoadFxWorldAsset, HOOK_CALL).install()->quick();
Utils::Hook(0x43CBBB, Zones::LoadMapTriggersModelPointer, HOOK_JUMP).install()->quick();
Utils::Hook(0x43CBF8, Zones::LoadMapTriggersHullPointer, HOOK_JUMP).install()->quick();
Utils::Hook(0x43CC33, Zones::LoadMapTriggersSlabPointer, HOOK_JUMP).install()->quick();
Utils::Hook(0x47E1DD, Zones::LoadMapEnts, HOOK_CALL).install()->quick();
Utils::Hook(0x4BF992, Zones::LoadClipMap, HOOK_CALL).install()->quick();
Utils::Hook(0x4C86D8, Zones::LoadXModelColSurfPtr, HOOK_JUMP).install()->quick();
Utils::Hook(0x44EB21, Zones::LoadGfxLightMapExtraData, HOOK_CALL).install()->quick();
Utils::Hook(0x44EAD3, Zones::LoadGfxReflectionProbes, HOOK_CALL).install()->quick();
Utils::Hook(0x4C08F8, Zones::LoadGfxXSurfaceExtraData, HOOK_CALL).install()->quick();
Utils::Hook(0x4C08DC, Zones::LoadGfxXSurfaceArray, HOOK_CALL).install()->quick();
Utils::Hook(0x45AE3D, Zones::LoadRandomFxGarbage, HOOK_CALL).install()->quick();
//Utils::Hook(0x495938, Zones::LoadFxElemDefArrayStub, HOOK_CALL).install()->quick();
//Utils::Hook(0x45ADA0, Zones::LoadFxElemDefStub, HOOK_CALL).install()->quick();
Utils::Hook(0x4EA6FE, Zones::LoadXModelLodInfoStub, HOOK_JUMP).install()->quick();
Utils::Hook(0x410D90, Zones::LoadXModel, HOOK_CALL).install()->quick();
Utils::Hook(0x4925C8, Zones::LoadXSurfaceArray, HOOK_CALL).install()->quick();
Utils::Hook(0x4F4D0D, Zones::LoadGameWorldSp, HOOK_CALL).install()->quick();
Utils::Hook(0x47CCD2, Zones::LoadWeaponCompleteDef, HOOK_CALL).install()->quick();
Utils::Hook(0x483DA0, Zones::LoadVehicleDef, HOOK_CALL).install()->quick();
Utils::Hook(0x4F0AC8, Zones::Loadsnd_alias_tArray, HOOK_CALL).install()->quick();
Utils::Hook(0x403A5D, Zones::LoadLoadedSound, HOOK_CALL).install()->quick();
Utils::Hook(0x463022, Zones::LoadWeaponAttach, HOOK_CALL).install()->quick();
Utils::Hook(0x41A570, Zones::LoadmenuDef_t, HOOK_CALL).install()->quick();
//Utils::Hook(0x49591B, Zones::LoadFxEffectDef, HOOK_CALL).install()->quick();
Utils::Hook(0x428F0A, Zones::LoadMaterialShaderArgumentArray, HOOK_CALL).install()->quick();
Utils::Hook(0x4B1EB8, Zones::LoadStructuredDataStructPropertyArray, HOOK_CALL).install()->quick();
Utils::Hook(0x49CE0D, Zones::LoadPhysPreset, HOOK_CALL).install()->quick();
Utils::Hook(0x48E84D, Zones::LoadXModelSurfs, HOOK_CALL).install()->quick();
Utils::Hook(0x4447C2, Zones::LoadImpactFx, HOOK_CALL).install()->quick();
Utils::Hook(0x4447D0, Zones::LoadImpactFxArray, HOOK_JUMP).install()->quick();
Utils::Hook(0x4D6A0B, Zones::LoadPathNodeArray, HOOK_CALL).install()->quick();
Utils::Hook(0x4D6A47, Zones::LoadPathDataConstant, HOOK_JUMP).install()->quick();
Utils::Hook(0x463D6E, Zones::LoadPathnodeConstantTail, HOOK_CALL).install()->quick();
Utils::Hook(0x4471AD, Zones::LoadGfxImage, HOOK_CALL).install()->quick();
Utils::Hook(0x41A590, Zones::LoadExpressionSupportingDataPtr, HOOK_CALL).install()->quick();
Utils::Hook(0x459833, Zones::LoadExpressionSupportingDataPtr, HOOK_JUMP).install()->quick();
Utils::Hook(0x5B9AA5, Zones::LoadXAsset, HOOK_CALL).install()->quick();
Utils::Hook(0x461740, Zones::LoadMaterialTechniqueArray, HOOK_CALL).install()->quick();
Utils::Hook(0x461710, Zones::LoadMaterialTechnique, HOOK_CALL).install()->quick();
Utils::Hook(0x40330D, Zones::LoadMaterial, HOOK_CALL).install()->quick();
Utils::Hook(0x4B8DC0, Zones::LoadGfxWorld, HOOK_CALL).install()->quick();
Utils::Hook(0x4B8FF5, Zones::Loadsunflare_t, HOOK_CALL).install()->quick();
Utils::Hook(0x418998, Zones::GameMapSpPatchStub, HOOK_JUMP).install()->quick();
Utils::Hook(0x427A1B, Zones::LoadPathDataTail, HOOK_JUMP).install()->quick();
Utils::Hook(0x41885C, CheckAssetType_Stub, HOOK_JUMP).install()->quick();
Utils::Hook(0x4B4EA1, Zones::ParseShellShock_Stub, HOOK_CALL).install()->quick();
Utils::Hook(0x4B4F0C, Zones::ParseShellShock_Stub, HOOK_CALL).install()->quick();
Utils::Hook(0x4F4D3B, []
{
if (Zones::ZoneVersion >= VERSION_ALPHA3)
{
ZeroMemory(*Game::varPathData, sizeof(Game::PathData));
}
else
{
// Load_PathData
Utils::Hook::Call<void(int)>(0x4278A0)(false);
}
}, HOOK_CALL).install()->quick();
// Change stream for images
Utils::Hook(0x4D3225, []()
{
Game::DB_PushStreamPos((Zones::ZoneVersion >= 332) ? 3 : 0);
}, HOOK_CALL).install()->quick();
Utils::Hook(0x4597DD, Zones::LoadStatement, HOOK_CALL).install()->quick();
Utils::Hook(0x471A39, Zones::LoadWindowImage, HOOK_JUMP).install()->quick();
}
}
#pragma optimize( "", on )
Reference in New Issue View Git Blame Copy Permalink