From 9c8904d5618195727cad5e67bedfca61a1329a13 Mon Sep 17 00:00:00 2001 From: momo5502 Date: Mon, 13 Jun 2016 18:09:02 +0200 Subject: [PATCH] Nothing special --- deps/mongoose | 2 +- src/Components/Modules/Maps.cpp | 35 +- src/Components/Modules/Maps.hpp | 5 +- src/Game/Functions.cpp | 13 +- src/Game/Functions.hpp | 16 +- src/Game/Structs.hpp | 554 ++++++++++++++++++++++++++++++++ 6 files changed, 608 insertions(+), 17 deletions(-) diff --git a/deps/mongoose b/deps/mongoose index 17184909..a67323fc 160000 --- a/deps/mongoose +++ b/deps/mongoose @@ -1 +1 @@ -Subproject commit 17184909820c448d51212599006ab65476a398df +Subproject commit a67323fc1216d955b68c4d87a91fee355adbf6bb diff --git a/src/Components/Modules/Maps.cpp b/src/Components/Modules/Maps.cpp index 2d34c81f..38ccdf26 100644 --- a/src/Components/Modules/Maps.cpp +++ b/src/Components/Modules/Maps.cpp @@ -2,9 +2,6 @@ namespace Components { - void* Maps::WorldMP = 0; - void* Maps::WorldSP = 0; - std::map Maps::DependencyList; std::vector Maps::CurrentDependencies; @@ -50,6 +47,26 @@ namespace Components return FastFiles::LoadLocalizeZones(data.data(), data.size(), sync); } + void Maps::OverrideMapEnts(Game::MapEnts* ents) + { + auto callback = [] (Game::XAssetHeader header, void* ents) + { + Game::MapEnts* mapEnts = reinterpret_cast(ents); + Game::clipMap_t* clipMap = header.clipMap; + + if (clipMap && mapEnts && !_stricmp(mapEnts->name, clipMap->name)) + { + clipMap->mapEnts = mapEnts; + //*Game::marMapEntsPtr = mapEnts; + //Game::G_SpawnEntitiesFromString(); + } + }; + + // Internal doesn't lock the thread, as locking is impossible, due to executing this in the thread that holds the current lock + Game::DB_EnumXAssets_Internal(Game::XAssetType::ASSET_TYPE_COL_MAP_MP, callback, ents, true); + Game::DB_EnumXAssets_Internal(Game::XAssetType::ASSET_TYPE_COL_MAP_SP, callback, ents, true); + } + void Maps::LoadAssetRestrict(Game::XAssetType type, Game::XAssetHeader asset, std::string name, bool* restrict) { if (std::find(Maps::CurrentDependencies.begin(), Maps::CurrentDependencies.end(), FastFiles::Current()) != Maps::CurrentDependencies.end()) @@ -77,6 +94,10 @@ namespace Components asset.mapEnts->entityString = const_cast(mapEntities.data()); asset.mapEnts->numEntityChars = mapEntities.size() + 1; } + + // Apply new mapEnts + // This doesn't work, entities are spawned before the patch file is loaded + //Maps::OverrideMapEnts(asset.mapEnts); } } @@ -87,12 +108,12 @@ namespace Components format = "maps/%s.d3dbsp"; // Adjust pointer to GameMap_Data - Utils::Hook::Set(0x4D90B7, Maps::WorldSP); + Utils::Hook::Set(0x4D90B7, &(Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAME_MAP_SP].gameMapSP[0].data)); } else { // Adjust pointer to GameMap_Data - Utils::Hook::Set(0x4D90B7, Maps::WorldMP); + Utils::Hook::Set(0x4D90B7, &(Game::DB_XAssetPool[Game::XAssetType::ASSET_TYPE_GAME_MAP_MP].gameMapMP[0].data)); } AntiCheat::EmptyHash(); @@ -170,9 +191,7 @@ namespace Components // Intercept map zone loading Utils::Hook(0x42C2AF, Maps::LoadMapZones, HOOK_CALL).Install()->Quick(); - Maps::WorldSP = static_cast(Game::ReallocateAssetPool(Game::XAssetType::ASSET_TYPE_GAME_MAP_SP, 1)) + 52; // Skip name and other padding to reach world data - Maps::WorldMP = Utils::Hook::Get(0x4D90B7); - + Game::ReallocateAssetPool(Game::XAssetType::ASSET_TYPE_GAME_MAP_SP, 1); Game::ReallocateAssetPool(Game::XAssetType::ASSET_TYPE_IMAGE, 7168); Game::ReallocateAssetPool(Game::XAssetType::ASSET_TYPE_LOADED_SOUND, 2700); Game::ReallocateAssetPool(Game::XAssetType::ASSET_TYPE_FX, 1200); diff --git a/src/Components/Modules/Maps.hpp b/src/Components/Modules/Maps.hpp index bb6873eb..3d61e7a6 100644 --- a/src/Components/Modules/Maps.hpp +++ b/src/Components/Modules/Maps.hpp @@ -10,9 +10,6 @@ namespace Components static void AddDependency(std::string expression, std::string zone); private: - static void* WorldMP; - static void* WorldSP; - static std::vector EntryPool; static std::map DependencyList; @@ -22,6 +19,8 @@ namespace Components static void LoadAssetRestrict(Game::XAssetType type, Game::XAssetHeader asset, std::string name, bool* restrict); static void LoadMapZones(Game::XZoneInfo *zoneInfo, unsigned int zoneCount, int sync); + static void OverrideMapEnts(Game::MapEnts* ents); + void ReallocateEntryPool(); }; } diff --git a/src/Game/Functions.cpp b/src/Game/Functions.cpp index 9a53d92f..3dbac08f 100644 --- a/src/Game/Functions.cpp +++ b/src/Game/Functions.cpp @@ -28,10 +28,12 @@ namespace Game Con_DrawSolidConsole_t Con_DrawSolidConsole = (Con_DrawSolidConsole_t)0x5A5040; DB_EnumXAssets_t DB_EnumXAssets = (DB_EnumXAssets_t)0x4B76D0; + DB_EnumXAssets_Internal_t DB_EnumXAssets_Internal = (DB_EnumXAssets_Internal_t)0x5BB0A0; DB_FindXAssetHeader_t DB_FindXAssetHeader = (DB_FindXAssetHeader_t)0x407930; DB_GetXAssetNameHandler_t* DB_GetXAssetNameHandlers = (DB_GetXAssetNameHandler_t*)0x799328; DB_GetXAssetSizeHandler_t* DB_GetXAssetSizeHandlers = (DB_GetXAssetSizeHandler_t*)0x799488; DB_GetXAssetTypeName_t DB_GetXAssetTypeName = (DB_GetXAssetTypeName_t)0x4CFCF0; + DB_IsXAssetDefault_t DB_IsXAssetDefault = (DB_IsXAssetDefault_t)0x48E6A0; DB_LoadXAssets_t DB_LoadXAssets = (DB_LoadXAssets_t)0x4E5930; Dvar_RegisterBool_t Dvar_RegisterBool = (Dvar_RegisterBool_t)0x4CE1A0; @@ -72,6 +74,8 @@ namespace Game FS_Restart_t FS_Restart = (FS_Restart_t)0x461A50; FS_BuildPathToFile_t FS_BuildPathToFile = (FS_BuildPathToFile_t)0x4702C0; + G_SpawnEntitiesFromString_t G_SpawnEntitiesFromString = (G_SpawnEntitiesFromString_t)0x4D8840; + GScr_LoadGameTypeScript_t GScr_LoadGameTypeScript = (GScr_LoadGameTypeScript_t)0x4ED9A0; Image_LoadFromFileWithReader_t Image_LoadFromFileWithReader = (Image_LoadFromFileWithReader_t)0x53ABF0; @@ -174,7 +178,7 @@ namespace Game Win_GetLanguage_t Win_GetLanguage = (Win_GetLanguage_t)0x45CBA0; - void** DB_XAssetPool = (void**)0x7998A8; + XAssetHeader* DB_XAssetPool = (XAssetHeader*)0x7998A8; unsigned int* g_poolSize = (unsigned int*)0x7995E8; DWORD* cmd_id = (DWORD*)0x1AAC5D0; @@ -221,10 +225,13 @@ namespace Game SafeArea* safeArea = (SafeArea*)0xA15F48; - void* ReallocateAssetPool(XAssetType type, unsigned int newSize) + SpawnVar* spawnVars = (SpawnVar*)0x1A83DE8; + MapEnts** marMapEntsPtr = (MapEnts**)0x112AD34; + + XAssetHeader ReallocateAssetPool(XAssetType type, unsigned int newSize) { int elSize = DB_GetXAssetSizeHandlers[type](); - void* poolEntry = Utils::Memory::Allocate(newSize * elSize); + XAssetHeader poolEntry = { Utils::Memory::Allocate(newSize * elSize) }; DB_XAssetPool[type] = poolEntry; g_poolSize[type] = newSize; return poolEntry; diff --git a/src/Game/Functions.hpp b/src/Game/Functions.hpp index fb5b73f6..c7bf9431 100644 --- a/src/Game/Functions.hpp +++ b/src/Game/Functions.hpp @@ -57,6 +57,9 @@ namespace Game typedef void(__cdecl * DB_EnumXAssets_t)(XAssetType type, void(*)(XAssetHeader, void *), void* userdata, bool overrides); extern DB_EnumXAssets_t DB_EnumXAssets; + typedef void(__cdecl * DB_EnumXAssets_Internal_t)(XAssetType type, void(*)(XAssetHeader, void *), void* userdata, bool overrides); + extern DB_EnumXAssets_Internal_t DB_EnumXAssets_Internal; + typedef XAssetHeader (__cdecl * DB_FindXAssetHeader_t)(XAssetType type, const char* name); extern DB_FindXAssetHeader_t DB_FindXAssetHeader; @@ -69,6 +72,9 @@ namespace Game typedef const char *(__cdecl * DB_GetXAssetTypeName_t)(XAssetType type); extern DB_GetXAssetTypeName_t DB_GetXAssetTypeName; + typedef const char *(__cdecl * DB_IsXAssetDefault_t)(XAssetType type, const char* name); + extern DB_IsXAssetDefault_t DB_IsXAssetDefault; + typedef void(*DB_LoadXAssets_t)(XZoneInfo *zoneInfo, unsigned int zoneCount, int sync); extern DB_LoadXAssets_t DB_LoadXAssets; @@ -169,6 +175,9 @@ namespace Game typedef int(__cdecl * FS_BuildPathToFile_t)(const char*, const char*, const char*, char**); extern FS_BuildPathToFile_t FS_BuildPathToFile; + typedef void(__cdecl* G_SpawnEntitiesFromString_t)(); + extern G_SpawnEntitiesFromString_t G_SpawnEntitiesFromString; + typedef void(__cdecl * GScr_LoadGameTypeScript_t)(); extern GScr_LoadGameTypeScript_t GScr_LoadGameTypeScript; @@ -395,7 +404,7 @@ namespace Game typedef const char * (__cdecl * Win_GetLanguage_t)(); extern Win_GetLanguage_t Win_GetLanguage; - extern void** DB_XAssetPool; + extern XAssetHeader* DB_XAssetPool; extern unsigned int* g_poolSize; extern DWORD* cmd_id; @@ -441,7 +450,10 @@ namespace Game extern SafeArea* safeArea; - void* ReallocateAssetPool(XAssetType type, unsigned int newSize); + extern SpawnVar* spawnVars; + extern MapEnts** marMapEntsPtr; + + XAssetHeader ReallocateAssetPool(XAssetType type, unsigned int newSize); void Menu_FreeItemMemory(Game::itemDef_t* item); const char* TableLookup(StringTable* stringtable, int row, int column); const char* UI_LocalizeMapName(const char* mapName); diff --git a/src/Game/Structs.hpp b/src/Game/Structs.hpp index 3c340d1e..3c16982e 100644 --- a/src/Game/Structs.hpp +++ b/src/Game/Structs.hpp @@ -1683,6 +1683,545 @@ namespace Game // 88 - 0x58 }; + + /* FxEffectDef::flags */ +#define FX_ELEM_LOOPING 0x1 +#define FX_ELEM_USE_RAND_COLOR 0x2 +#define FX_ELEM_USE_RAND_ALPHA 0x4 +#define FX_ELEM_USE_RAND_SIZE0 0x8 +#define FX_ELEM_USE_RAND_SIZE1 0x10 +#define FX_ELEM_USE_RAND_SCALE 0x20 +#define FX_ELEM_USE_RAND_ROT_DELTA 0x40 +#define FX_ELEM_MOD_COLOR_BY_ALPHA 0x80 +#define FX_ELEM_USE_RAND_VEL0 0x100 +#define FX_ELEM_USE_RAND_VEL1 0x200 +#define FX_ELEM_USE_BACK_COMPAT_VEL 0x400 +#define FX_ELEM_ABS_VEL0 0x800 +#define FX_ELEM_ABS_VEL1 0x1000 +#define FX_ELEM_PLAY_ON_TOUCH 0x2000 +#define FX_ELEM_PLAY_ON_DEATH 0x4000 +#define FX_ELEM_PLAY_ON_RUN 0x8000 +#define FX_ELEM_BOUNDING_SPHERE 0x10000 +#define FX_ELEM_USE_ITEM_CLIP 0x20000 +#define FX_ELEM_DISABLED 0x80000000 +#define FX_ELEM_DECAL_FADE_IN 0x40000 + + /* FxElemDef::flags */ +#define FX_ELEM_SPAWN_RELATIVE_TO_EFFECT 0x2 +#define FX_ELEM_SPAWN_FRUSTUM_CULL 0x4 +#define FX_ELEM_RUNNER_USES_RAND_ROT 0x8 +#define FX_ELEM_SPAWN_OFFSET_NONE 0x0 +#define FX_ELEM_SPAWN_OFFSET_SPHERE 0x10 +#define FX_ELEM_SPAWN_OFFSET_CYLINDER 0x20 +#define FX_ELEM_SPAWN_OFFSET_MASK 0x30 +#define FX_ELEM_RUN_RELATIVE_TO_WORLD 0x0 +#define FX_ELEM_RUN_RELATIVE_TO_SPAWN 0x40 +#define FX_ELEM_RUN_RELATIVE_TO_EFFECT 0x80 +#define FX_ELEM_RUN_RELATIVE_TO_OFFSET 0xC0 +#define FX_ELEM_RUN_MASK 0xC0 +#define FX_ELEM_USE_COLLISION 0x100 +#define FX_ELEM_DIE_ON_TOUCH 0x200 +#define FX_ELEM_DRAW_PAST_FOG 0x400 +#define FX_ELEM_DRAW_WITH_VIEWMODEL 0x800 +#define FX_ELEM_BLOCK_SIGHT 0x1000 +#define FX_ELEM_HAS_VELOCITY_GRAPH_LOCAL 0x1000000 +#define FX_ELEM_HAS_VELOCITY_GRAPH_WORLD 0x2000000 +#define FX_ELEM_HAS_GRAVITY 0x4000000 +#define FX_ELEM_USE_MODEL_PHYSICS 0x8000000 +#define FX_ELEM_NONUNIFORM_SCALE 0x10000000 +#define FX_ELEM_CLOUD_SHAPE_CUBE 0x0 +#define FX_ELEM_CLOUD_SHAPE_SPHERE_LARGE 0x20000000 +#define FX_ELEM_CLOUD_SHAPE_SPHERE_MEDIUM 0x40000000 +#define FX_ELEM_CLOUD_SHAPE_SPHERE_SMALL 0x60000000 +#define FX_ELEM_CLOUD_MASK 0x60000000 +#define FX_ELEM_DISABLE_FOUNTAIN_COLLISION 0x80000000 +#define FX_ELEM_DRAW_IN_THERMAL_ONLY 0x2000 +#define FX_ELEM_TRAIL_ORIENT_BY_VELOCITY 0x4000 +#define FX_ELEM_EMIT_ORIENT_BY_ELEM 0x8000 + + /* FxElemAtlas::behavior */ +#define FX_ATLAS_START_MASK 0x3 +#define FX_ATLAS_START_FIXED 0x0 +#define FX_ATLAS_START_RANDOM 0x1 +#define FX_ATLAS_START_INDEXED 0x2 +#define FX_ATLAS_PLAY_OVER_LIFE 0x4 +#define FX_ATLAS_LOOP_ONLY_N_TIMES 0x8 + + enum FxElemType : char + { + FX_ELEM_TYPE_SPRITE_BILLBOARD = 0x0, + FX_ELEM_TYPE_SPRITE_ORIENTED = 0x1, + FX_ELEM_TYPE_TAIL = 0x2, + FX_ELEM_TYPE_TRAIL = 0x3, + FX_ELEM_TYPE_CLOUD = 0x4, + FX_ELEM_TYPE_SPARKCLOUD = 0x5, + FX_ELEM_TYPE_SPARKFOUNTAIN = 0x6, + FX_ELEM_TYPE_MODEL = 0x7, + FX_ELEM_TYPE_OMNI_LIGHT = 0x8, + FX_ELEM_TYPE_SPOT_LIGHT = 0x9, + FX_ELEM_TYPE_SOUND = 0xA, + FX_ELEM_TYPE_DECAL = 0xB, + FX_ELEM_TYPE_RUNNER = 0xC, + FX_ELEM_TYPE_COUNT = 0xD, + FX_ELEM_TYPE_LAST_SPRITE = 0x3, + FX_ELEM_TYPE_LAST_DRAWN = 0x9, + }; + + struct FxElemVec3Range + { + float base[3]; + float amplitude[3]; + }; + + struct FxIntRange + { + int base; + int amplitude; + }; + + struct FxFloatRange + { + float base; + float amplitude; + }; + + struct FxSpawnDefLooping + { + int intervalMsec; + int count; + }; + + struct FxSpawnDefOneShot + { + FxIntRange count; + }; + + union FxSpawnDef + { + FxSpawnDefLooping looping; + FxSpawnDefOneShot oneShot; + }; + + struct FxEffectDef; + + union FxEffectDefRef + { + FxEffectDef *handle; + const char *name; + }; + + union FxElemVisuals + { + const void *anonymous; + Material *material; + XModel *xmodel; + FxEffectDefRef *effectDef; + const char *soundName; + }; + + struct FxElemMarkVisuals + { + Material* data[2]; + }; + + union FxElemDefVisuals + { + FxElemVisuals instance; + //If parent FxElemDef::elemType == 0x7, use xmodel + //If parent FxElemDef::elemType == 0xC, use effectDef + //If parent FxElemDef::elemType == 0xA, use soundName + //If parent FxElemDef::elemType != 0x9 || 0x8, use material + + FxElemVisuals *array; //Total count = parent FxElemDef::visualCount + FxElemMarkVisuals *markArray; //Total count = parent FxElemDef::visualCount + }; + + struct FxTrailVertex + { + float pos[2]; + float normal[2]; + float texCoord[2]; + }; + + struct FxTrailDef + { + int scrollTimeMsec; + int repeatDist; + float splitArcDist; + int splitDist; + int splitTime; + int vertCount; + FxTrailVertex *verts; + int indCount; + unsigned __int16 *inds; + }; + + struct FxSparkFountain + { + float sparkFountainGravity; + float sparkFountainBounceFrac; + float sparkFountainBounceRand; + float sparkFountainSparkSpacing; + float sparkFountainSparkLength; + int sparkFountainSparkCount; + float sparkFountainLoopTime; + float sparkFountainVelMin; + float sparkFountainVelMax; + float sparkFountainVelConeAngle; + float sparkFountainRestSpeed; + float sparkFountainBoostTime; + float sparkFountainBoostFactor; + }; + + union unknownFxUnion + { + char *unknownBytes; + FxSparkFountain *sparkFountain; + FxTrailDef *trailDef; + }; + + struct FxElemAtlas + { + char behavior; + char index; + char fps; + char loopCount; + char colIndexBits; + char rowIndexBits; + __int16 entryCount; + }; + + struct FxElemVelStateInFrame + { + FxElemVec3Range velocity; + FxElemVec3Range totalDelta; + }; + + struct FxElemVelStateSample + { + FxElemVelStateInFrame local; + FxElemVelStateInFrame world; + }; + + struct FxElemVisualState + { + char color[4]; + float rotationDelta; + float rotationTotal; + float size[2]; + float scale; + }; + + struct FxElemVisStateSample + { + FxElemVisualState base; + FxElemVisualState amplitude; + }; + + struct FxElemDef // 0xFC + { + int flags; + FxSpawnDef spawn; + FxFloatRange spawnRange; + FxFloatRange fadeInRange; + FxFloatRange fadeOutRange; + float spawnFrustumCullRadius; + FxIntRange spawnDelayMsec; + FxIntRange lifeSpanMsec; + FxFloatRange spawnOrigin[3]; + FxFloatRange spawnOffsetRadius; + FxFloatRange spawnOffsetHeight; + FxFloatRange spawnAngles[3]; + FxFloatRange angularVelocity[3]; + FxFloatRange initialRotation; + FxFloatRange gravity; + FxFloatRange reflectionFactor; + FxElemAtlas atlas; + char elemType; + char visualCount; + char velIntervalCount; + char visStateIntervalCount; + FxElemVelStateSample *velSamples; // count = velIntervalCount + FxElemVisStateSample *visSamples; // count = visStateIntervalCount + FxElemDefVisuals visuals; + //If elemType is 0xB, then use markVisuals + //If elemType is not 0xB and visualCount == 1, then use visual + //If elemType is not 0xB and visualCount != 1, then use visualsArray + vec3_t collMins; + vec3_t collMaxs; + FxEffectDefRef *effectOnImpact; + FxEffectDefRef *effectOnDeath; + FxEffectDefRef *effectEmitted; + FxFloatRange emitDist; + FxFloatRange emitDistVariance; + unknownFxUnion *trailDef; + //If elemType == 3, then use trailDef + //If elemType == 6, then use sparkFountain + //If elemType != 3 && elemType != 6 use unknownBytes (size = 1) + char sortOrder; + char lightingFrac; + char unused[2]; + }; + + struct FxEffectDef + { + const char *name; + int flags; + int totalSize; + int msecLoopingLife; + int elemDefCountLooping; + int elemDefCountOneShot; + int elemDefCountEmission; + FxElemDef *elemDefs; //Count = elemDefCountOneShot + elemDefCountEmission + elemDefCountLooping + }; + + struct cPlane + { + vec3_t a; + float dist; + int type; + }; + + struct cStaticModel + { + XModel *xmodel; + float origin[3]; + float invScaledAxis[3][3]; + float absmin[3]; + float absmax[3]; + }; + + struct dMaterial + { + char* name; + int unk; + int unk2; + }; + + struct cNode + { + cPlane* plane; + short children[2]; + }; + + struct cBrushSide + { + cPlane* side; + short texInfo, dispInfo; + }; + + struct cBrush + { + int count; + cBrushSide * brushSide; + char * brushEdge; + char pad[24]; + }; + + struct cLeaf + { + unsigned __int16 firstCollAabbIndex; + unsigned __int16 collAabbCount; + int brushContents; + int terrainContents; + float mins[3]; + float maxs[3]; + int leafBrushNode; + }; + + struct cLeafBrushNodeLeaf + { + unsigned __int16 *brushes; + }; + + struct cLeafBrushNodeChildren + { + float dist; + float range; + unsigned __int16 childOffset[6]; + }; + + union cLeafBrushNodeData + { + cLeafBrushNodeLeaf leaf; + cLeafBrushNodeChildren children; + }; + + struct cLeafBrushNode + { + char axis; + __int16 leafBrushCount; + int contents; + cLeafBrushNodeData data; + }; + + struct cModel + { + float mins[3]; + float maxs[3]; + float radius; + cLeaf leaf; + }; + + enum DynEntityType + { + DYNENT_TYPE_INVALID = 0x0, + DYNENT_TYPE_CLUTTER = 0x1, + DYNENT_TYPE_DESTRUCT = 0x2, + DYNENT_TYPE_COUNT = 0x3, + }; + + struct GfxPlacement + { + float quat[4]; + float origin[3]; + }; + + struct DynEntityDef + { + DynEntityType type; + GfxPlacement pose; + XModel *xModel; + unsigned __int16 brushModel; + unsigned __int16 physicsBrushModel; + FxEffectDef *destroyFx; + PhysPreset *physPreset; + int health; + PhysMass mass; + int contents; + }; + + struct DynEntityPose + { + GfxPlacement pose; + float radius; + }; + + struct DynEntityClient + { + int physObjId; + unsigned __int16 flags; + unsigned __int16 lightingHandle; + int health; + }; + + struct DynEntityColl + { + unsigned __int16 sector; + unsigned __int16 nextEntInSector; + float linkMins[2]; + float linkMaxs[2]; + }; + + struct CollisionBorder + { + float distEq[3]; + float zBase; + float zSlope; + float start; + float length; + }; + + struct CollisionPartition + { + char triCount; + char borderCount; + int firstTri; + CollisionBorder *borders; + }; + + union CollisionAabbTreeIndex + { + int firstChildIndex; + int partitionIndex; + }; + + struct CollisionAabbTree + { + float origin[3]; + float halfSize[3]; + unsigned __int16 materialIndex; + unsigned __int16 childCount; + CollisionAabbTreeIndex u; + }; + + struct clipMap_t + { + const char* name; + int unknown1; // +8 + int numCPlanes; // +8 + cPlane* cPlanes; // sizeof 20, +12 + int numStaticModels; // +16 + cStaticModel* staticModelList; // sizeof 76, +20 + int numMaterials; // +24 + dMaterial* materials; // sizeof 12 with a string (possibly name?), +28 + int numCBrushSides; // +32 + cBrushSide* cBrushSides; // sizeof 8, +36 + int numCBrushEdges; // +40 + char* cBrushEdges; // +44 + int numCNodes; // +48 + cNode * cNodes; // sizeof 8, +52 + int numCLeaf; // +56 + cLeaf* cLeaf; // +60 + int numCLeafBrushNodes; // +64 + cLeafBrushNode* cLeafBrushNodes; // +68 + int numLeafBrushes; // +72 + short* leafBrushes; // +76 + int numLeafSurfaces; // +80 + int* leafSurfaces; // +84 + int numVerts; // +88 + vec3_t* verts; // +92 + int numTriIndices; // +96 + short* triIndices; // +100 + bool* triEdgeIsWalkable; // +104 + int numCollisionBorders; // +108 + CollisionBorder* collisionBorders;// sizeof 28, +112 + int numCollisionPartitions; // +116 + CollisionPartition* collisionPartitions; // sizeof 12, +120 + int numCollisionAABBTrees; // +124 + CollisionAabbTree* collisionAABBTrees;// sizeof 32, +128 + int numCModels; // +132 + cModel* cModels; // sizeof 68, +136 + short numCBrushes; // +140 + short pad2; // +142 + cBrush * cBrushes; // sizeof 36, +144 + void* unknown2; // same count as cBrushes, +148 + int * unknown3; // same count as cBrushes, +152 + MapEnts * mapEnts; // +156 + int unkCount4; // +160 + void* unknown4; // +164 + unsigned __int16 dynEntCount[2]; + DynEntityDef *dynEntDefList[2]; + DynEntityPose *dynEntPoseList[2]; + DynEntityClient *dynEntClientList[2]; + DynEntityColl *dynEntCollList[2]; + unsigned int checksum; + char unknown5[0x30]; + }; // +256 + + struct GameMap_Data + { + void* unk1; + int unkCount1; + int unkCount2; + void* unk2; + char pad[112]; + }; + + struct GameMap_SP + { + const char* name; + char pad[48]; + GameMap_Data* data; + }; + + + struct GameMap_MP + { + const char* name; + GameMap_Data* data; + }; + union XAssetHeader { void *data; @@ -1706,6 +2245,10 @@ namespace Game PhysCollmap* physCollmap; XModelSurfs* surfaces; XAnimParts* xanim; + clipMap_t* clipMap; + FxEffectDef* fx; + GameMap_MP* gameMapMP; + GameMap_SP* gameMapSP; }; struct XAsset @@ -1863,6 +2406,17 @@ namespace Game float right; float bottom; }; + +#pragma pack(push, 4) + struct SpawnVar + { + bool spawnVarsValid; + int numSpawnVars; + char *spawnVars[64][2]; + int numSpawnVarChars; + char spawnVarChars[2048]; + }; +#pragma pack(pop) #ifdef __cplusplus }