Ohai

Moderator: Altimit01


User avatar
Altimit01
Eschaton Dev
Eschaton Dev
Posts: 2108
Joined: Sun Apr 15, 2007 7:43 pm

Re: Ohai

Post by Altimit01 » Tue Sep 22, 2009 7:00 am

I have that bookmarked or saved somewhere. Probably a good idea to have it posted just in case.
Halo: Combat Evolved Data Structures
By: SilentK
Version: Halo Trial
Last Updated: 09/02/2008
--------------------------
I've been doing quite a bit of reversing of Halo structures and thought I would share it. As far as know, I've seen no documentation on this. I'm writing this for developers, but anyone can learn from it. I started reversing these structures while looking for a new way to make an aimbot and was fortunately successful. Bitterbanana and Odie5533 ( who used the same method ) wrote a code cave and jmp'd to it from the function that updates players' world coordinates. The code cave then created an array of pointers to player data structures from the function. The reason for this was because the player data structures are dynamic. I found a new way to go about this without code caving or even touching any halo functions. No, this isn't a guide on how to make an aimbot, but this lead me to a lot of great information you are about to read and could be useful in MANY different applications.

I did a bit of reversing on the Unreal Engine a few months ago. There is an array in the UE called GObjObjects. GObjObjects array has a pointer to an object table along with the number of objects and the size of the table. This table has pointers to every object structure in the entire game! Pretty cool huh? Well, I quit working on Unreal Engine since it was such a pain in the arse! I came back to Halo a few weeks after and decided to see if there was a similar table. Low and behold, I discovered it! All I did was grab the base pointer of my dynamic player structure ( searched for my world coordinates for this ), and did a pointer search. From the results, I was brought to this array table. Now, Halo's object table is very small compared to UE's so I was pretty excited. UE's object table contained over 200,000 objects compared to 100+ in Halo!!

Every data section begins with a header and sometimes a footer. The header contains some good info about the table / structures below it including the number of objects / size / max / pointer to first / etc. The object table contains every object in the game. This includes all scenery, vehicles, players, weapons, equipment, gametype flags ( flags, oddballs), and decals ( and possibly more ). There is a 12 byte array for each object in the table, which includes a pointer to that objects data structure, the size of the structure, and the object ID. I'm not sure what the other 2 shorts are, but I think it has to do with the object type or something.

The following structures and addresses in this doc are from Halo Trial. Halo PC and CE could have some changes, but for the most part they are identical besides the addresses.

Code:

Code: Select all

class CObjectHeader
{
public:
	BYTE m_bName[32];        // 'object'
	WORD m_wMaxObjects;      // Maximum number of objects - 0x800(2048 objects)
	WORD m_wSize;            // Size of each object array - 0x0C(12 bytes)
	DWORD m_dwUnknown;       // always 1?
	BYTE m_bData[4];         // '@t@d' - translates to 'data'?
	WORD m_wMax;             // Max number of objects the game has reached (slots maybe?)
	WORD m_wNum;             // Number of objects in the current game
	WORD m_wNextObjectIndex; // Index number of the next object to spawn
	WORD m_wNextObjectID;    // ID number of the next object to spawn
	DWORD m_dwFirstObject;   // Pointer to the first object in the table  
}; // 0x4BB206B4
Code:

Code: Select all

class CObjectArray
{
public:
	WORD m_wObjectID; // Matches up to Object ID in static player table ( for players )
	WORD m_wUnknown;
	WORD m_wSector;   // portal rendering ( index #? )
	WORD m_wSize;     // Structure size
	DWORD m_dwOffset; // Pointer to the object data structure
};
You can do a simple loop through the object table to search for certain objects, to grab them all, or whatever else. Example:

Code:

Code: Select all

// Declare pointers to our structures
CObjectHeader *pObjectHeader;
CObjectArray *pObjectArray[2048];

// Assign the static address to the header
pObjectHeader = (CObjectHeader*) 0x4BB206B4;

// Loop through the table and add each array as a new element
for( unsigned short i = 0; i < pObjectHeader->MaxObjects; i++ )
	pObjectArray[i] = (CObjectArray*)(pObjectHeader->FirstObject + ( i * pObjectHeader->Size));

You could do them one at a time instead of creating a huge array of structures. Then you can do what you need to and get out. All depends on what you are developing! =]

I think that about covers the object table! I haven't reversed each object type's structures. I only reversed some of the player data structure. I didn't go too deep because I really didn't need all the extra info. There is a TON of stuff in the structures though including matrices. Just as an example, here's some of the player structure I have reversed, although this is just a small chunk of it:

Code:

Code: Select all

class CMasterChief
{
public:
	WORD m_wBipdMetaIndex;   // [Biped]characters\cyborg_mp\cyborg_mp
	WORD m_wBipdMetaID;      // [Biped]characters\cyborg_mp\cyborg_mp
	BYTE m_bZeros_00[4];
	BYTE m_bBitFlags_00[4];
	DWORD m_dwTimer_00;
	BYTE m_bBitFlags_01[4];
	DWORD m_dwTimer_01;
	BYTE m_bZeros_01[68];
	float m_fWorld[3];
	float m_fVelocity[3];
	float m_fLowerRot[3];
	float m_fScale[3];
	BYTE m_bZeros_02[12];
	DWORD m_dwLocationID;
	DWORD m_dwPointer_00;
	float m_fxUnknown;
	float m_fyUnknown;
	float m_fzUnknown;
	BYTE m_bZeros_03[20];
	WORD m_wPlayerIndex;
	WORD m_wPlayerID;
	DWORD m_dwUnknown00;
	BYTE m_bZeros_04[4];
	WORD m_wAntrMetaIndex; // [Animation Trigger]characters\cyborg\cyborg
	WORD m_wAntrMetaID;    // [Animation Trigger]characters\cyborg\cyborg
	BYTE m_bBitFlags_02[8];
	BYTE m_bUnknown01[8];
	float m_fHealth;
	float m_fShield_00;
	DWORD m_dwZeros_05;
	float m_fUnknown02;
	DWORD m_dwUnknown03;
	float m_fUnknown04;
	float m_fUnknown05;
	BYTE m_bUnknown06[24];
	WORD m_wVehicleWeaponIndex;
	WORD m_wVehicleWeaponID;
	WORD m_wWeaponIndex;
	WORD m_wWeaponID;
	WORD m_wVehicleIndex; // Ex: Turret on Warthog
	WORD m_wVehicleID;
	WORD m_wSeatType;
	BYTE m_bBitFlags_03[2];
	DWORD m_dwZeros_06;
	float m_fShield_01;
	float m_fFlashlight_00;
	float m_fZeros_07;
	float m_fFlashlight_01;
	BYTE m_bZeros_08[20];
	DWORD m_dwUnknown07;
	BYTE m_bZeros_09[28];
	BYTE m_bUnknown08[8];
	BYTE m_bUnknown10[144];
	DWORD m_dwIsInvisible;    // normal = 0x41 invis = 0x51 (bitfield?)
	BYTE m_bIsCrouching;      // crouch = 1, jump = 2
	BYTE m_bUnknown11[3];
	BYTE m_bUnknown09[276];
	char m_cZoom00;
	char m_cZoom01;
	BYTE m_bUnknown12[610];
	float m_fLeftThigh[13];
	float m_fRightThigh[13];
	float m_fPelvis[13];
	float m_fLeftCalf[13];
	float m_fRightCalf[13];
	float m_fSpine[13];
	float m_fLeftClavicle[13];
	float m_fLeftFoot[13];
	float m_fNeck[13];
	float m_fRightClavicle[13];
	float m_fRightFoot[13];
	float m_fHead[13];
	float m_fLeftUpperArm[13];
	float m_fRightUpperArm[13];
	float m_fLeftLowerArm[13];
	float m_fRightLowerArm[13];
	float m_fLeftHand[13];
	float m_fRightHand[13];
};
Here's some useful info - the object indexes aren't referenced in the object table. But, this is a very useful number! Instead of looping through the object table again, you can just use the index number as the array element index. Let's assume the WeaponIndex is 8. ObjectTableArray[8] would be the array for the current players' weapon! Pretty nifty huh?

The meta index / id is a reference to the meta index which is in the map file structure. These object structures are actually for the mod2 (models). If you follow the reference, you will find the objects name, tag class heirarchy, spawn location, object type, etc.

Now onto the static player table! In addition to dynamic structures, there are static ones. Ones that are always at the same address in memory, no matter what. The static player structures have less important info and are more of a player index than anything. There is some good information though. Just like the object table, the player table has a header. I won't go into details since I commented it pretty heavily.

Code:

Code: Select all

class CPlayerHeader
{
public:
	BYTE m_bName[32];        // "players"
	WORD m_wMaxSlots;        // Max number of players possible
	WORD m_wSlotSize;        // Size of each CPlayer class instance
	DWORD m_dwUnknown;       // always 1?
	BYTE w_bData[4];         // "@t@d" - translated as "data"?
	WORD m_wIsInMainMenu;    // 0 = in game 1 = in main menu / not in game
	WORD m_wSlotsTaken;      // or # of players
	WORD m_wNextPlayerIndex; // Index # of the next player to join
	WORD m_wNextPlayerID;    // ID # of the next player to join
	DWORD m_dwFirstPlayer;   // Pointer to the first CPlayer class instance
}; //0x4BD7AF94
Code:

Code: Select all

class CPlayer
{
public:
	WORD m_wPlayerID;            // Stats at 70EC
	WORD m_wPlayerID2;           // ???
	wchar_t m_wcPlayerName0[12]; // Unicode / Max - 11 Chars + EOS (12 total)
	DWORD Unknown0;              // Always -1 / 0xFFFFFFFF
	DWORD m_dwTeam;              // 0 = Red / 1 = Blue
	DWORD m_dwSwapID;            // is an ObjectID
	WORD m_wSwapType;            // 8 = Vehicle / 6 = Weapon
	WORD m_wSwapSeat;            // Warthog - Driver = 0 / Passenger = 1 / Gunner = 2 / Weapon = -1
	DWORD m_dwRespawnTimer;      // ?????? Counts down when dead, Alive = 0
	DWORD m_wUnknown1;           // Always 0
	WORD m_wObjectIndex;
	WORD m_wObjectID;            // Matches against object table
	DWORD m_dwUnknown3;          // Some sort of ID
	DWORD m_dwSector;            // This is very, very interesting. BG is split into 25 location ID's. 1 -19
	DWORD m_dwUnknown4;          // Always -1 / 0xFFFFFFFF
	DWORD m_dwBulletCount;       // Something to do with bullets increases - weird.
	wchar_t m_wcPlayerName1[12]; // Unicode / Max - 11 Chars + EOS (12 total)
	DWORD m_dwUnknown5;          // 02 00 FF FF
	DWORD m_dwPlayerIndex;
	DWORD m_dwUnknown6;
	float m_fSpeedModifier;
	BYTE m_bUnknown7[108];
	WORD m_wPing;
};
I reversed some of the stats array table. It's not complete unfortunatly. Each array is 48 bytes. Here's what I got:

Code:

Code: Select all

struct Stats_Header
{
	unsigned long RecordedAnimations; // Pointer to Recorded Animations data table
	unsigned char Unknown0[4];           // Zero's
	float LastDecalLocation0[12];                 // World coordinates of the last bullet/nade hit anywhere on map x,y, applies to BSP only, not objects
	unsigned char Unknown1[48];        // Zero's
	float LastDecalLocation1[12];                 // Same as other one.
	float Unknown2[2];                       // Some floats. idk.
	unsigned char Unknown3[40];         // Zero's
	unsigned long DecalIDArray;            // Pointer to an array of Decal ID's (correlates with LastDecalLocation)
	unsigned long Unknown3;                // Pointer
	unsigned char Unknown4[20];
	unsigned long LocationID0;
	unsigned long LocationID1;
	unsigned long Unknown5;
	unsigned char Unknown6[130];         // Zero's
	unsigned long Unknown7;                 // Pointer
	unsigned long Unknown8;                 // Pointer
}; // 0x006A7DB8

Code:

Code: Select all

struct Stats_Array
{
	unsigned char IsInGame;
	unsigned char Unknown0[5];
	unsigned short PlayerID;
	unsigned short Kills;
	unsigned char Unknown1[6];
	unsigned short Assists;
	unsigned char Unknown2[6];
	unsigned short Betrayed; // Suicides count!
	unsigned short TotalDeaths; // Everytime you die, no matter what..
	unsigned short Suicides;
	unsigned short FlagSteals;
	unsigned short FlagReturns;
	unsigned short FlagScores;
	unsigned char Unknown3[12];
}; //size - 48 bytes 0x30 starts at 0x006A7F30
Code:

Code: Select all

struct Stats_Footer
{
	unsigned long RedFlag; // Pointer to scenario meta data
	unsigned long BlueFlag; // Pointer to scenario meta data
	unsigned short RedFlagIndex; // Object Index #
	unsigned short RedFlagID;     // Object ID
	unsigned short BlueFlagIndex; // Object Index #
	unsigned short BlueFlagID;     // Object ID
	unsigned long BlueFlagScores; // # of flags captured
	unsigned long RedFlagScores; // # of flags captured
	unsigned long FlagCaptureLimit; // Num of flags to capture to win
	bool RedFlagStolen; // 0 - At base 1 - Flag is stolen
	bool BlueFlagStoled; // 0 - At base 1 - Flag is stolen
	unsigned short Unknown; // Zero's?
	unsigned long RedFlagTimer; // Respawn time?
	unsigned long BlueFlagTimer; // Respawn time?
}; // 0x006A8230
Now for some map file reversing! =] I am currently working on an in-game level editor. It's pretty much like Spark Edit, but live, during game. I'm using all these structures and the map file structures to accomplish this + some 3d world -> 2d screen space math.

The map header sets up the whole map file. The TagIndexOffset is a pointer to the meta index. The meta index is just like the object table, but a different format. The meta index has all of the elements of the game including objects, sounds, bitmaps, shaders, collision, hud interface, fonts, etc. Pretty much everything you would see in HMT. The meta array's in the index contain the tag class hierarchy, a pointer to the metas name, a pointer to the meta structure and most important our meta ID. Remember the object structures? The first thing in an object structure is the meta ID which we can match up here.

The first thing in the meta index is the header. This is also a VERY important piece of the puzzle, because it sets up more parts of the map. I won't go into details. The first tag in the index is the scnr also know as the 'Scenario'. This contains a utopia of reflexives. A reflexive is just a type of array. It points to a structure with extra information. Our meta data structures all have reflexives too. It is just extra info about that tag. The scenario has all our spawns and triggers. It holds all the spawn points of every object, player, and gametype flags (flags, oddballs, koth, race, etc).

The whole entire map file is loaded into memory, but it is split into sections throughout memory. Fortunately they are static. So without boring you any longer with all this information, here are some map structures( I didn't reverse all these ):

Code:

Code: Select all

class CMapHeader
{
public:
	WORD m_wUnknown1;
	WORD m_wVersion; // 5 = Xbox, 6 = Trial, 7 = PC, 609 = CE
	BYTE m_bUnknown2[700];
	BYTE m_bHeader[4]; // 'head''Ehed'
	DWORD m_dwTagIndexMetaLength;
	BYTE m_bBuildDate[32]; // Year.Month.Day.Build - I guess they use this to make sure that a certain build will only open that build's map files, because this string is in the app too
	BYTE m_bUnknown3[672];
	DWORD m_dwMapType; // 0 = singleplayer, 1 = multiplayer, 2 = ui - this also determines the size of the cache file. UI = 35MB, multiplayer = 47MB, and singleplayer = 270MB
	BYTE m_bMapName[32];
	BYTE m_bUnknown4[60];
	DWORD m_dwDecompLen; // Actual len of decompressed data. Halo sticks garbage on the end so that the file is one of several fixed sizes (35, etc).
	DWORD m_dwTagIndexOffset;
	BYTE m_bFooter[4]; // 'foot' 'Gfot'
}; // 0x006A2000 - Trial Bloodgulch Base
Code:

Code: Select all

class CIndexHeader
{ 
public:
	DWORD m_dwIndexMagic; 
	DWORD m_dwBaseIdent; 
	DWORD m_dwUnknown; 
	DWORD m_dwNumOfTags; 
	DWORD m_dwVertexObjectCount; 
	DWORD m_dwModelRawDataOffset; 
	DWORD m_dwIndicesObjectCount; 
	DWORD m_dwIndicesOffset; 
	DWORD m_dwModelRawDataSize; 
}; // 0x4BF10000 - Trial Bloodgulch Base
Code:

Code: Select all

class CTagIndex
{
public:
	BYTE m_bTagClass[3][4];
	DWORD m_dwTagID; 
	TagName * TName; 
	DWORD m_dwOffset; 
	DWORD m_dwZeros[2]; 
}; // Starts at 0x4BF10028 - Trial Bloogulch Base
Code:

Code: Select all

class CTagName
{
public:
	BYTE m_bName[1];
}; // Starts at 0x4BF22D68 - Trial Bloodgulch Base
Code:

Code: Select all

class CScnrHeader
{
public:
	BYTE m_bUnknown1[16];
	BYTE m_bUnknown2[16];
	BYTE m_bUnknown3[16];
	CReflexive m_RSkyBox;
	DWORD m_dwUnknown4;
	CReflexive m_RChildScenarios;

	DWORD m_dwUnNeeded1[46];
	DWORD m_dwEditorScenarioSize;
	DWORD m_dwUnknown5;
	DWORD m_dwUnknown6;
	DWORD m_dwPointerToIndex;
	DWORD m_dwUnNeeded2[2];
	DWORD m_dwPointerToEndOfIndex;
	DWORD m_dwZeros[57];

	CReflexive m_RObjectNames;
	CReflexive m_RScenery;
	CReflexive m_RSceneryRef;
	CReflexive m_RBiped;
	CReflexive m_RBipedRef;
	CReflexive m_RVehicle;
	CReflexive m_RVehicleRef;
	CReflexive m_REquip;
	CReflexive m_REquipRef;
	CReflexive m_RWeap;
	CReflexive m_RWeapRef;
	CReflexive m_RDeviceGroups;
	CReflexive m_RMachine;
	CReflexive m_RMachineRef;
	CReflexive m_RControl;
	CReflexive m_RControlRef;
	CReflexive m_RLightFixture;
	CReflexive m_RLightFixtureRef;
	CReflexive m_RSoundScenery;
	CReflexive m_RSoundSceneryRef;
	CReflexive m_RUnknown7[7];
	CReflexive m_RPlayerStartingProfile;
	CReflexive m_RPlayerSpawn;
	CReflexive m_RTriggerVolumes;
	CReflexive m_RAnimations;
	CReflexive m_RMultiplayerFlags;
	CReflexive m_RMpEquip;
	CReflexive m_RStartingEquip;
	CReflexive m_RBspSwitchTrigger;
	CReflexive m_RDecals;
	CReflexive m_RDecalsRef;
	CReflexive m_RDetailObjCollRef;
	CReflexive m_RUnknown8[7];
	CReflexive m_RActorVariantRef;
	CReflexive m_REncounters;
	//below this, structs still not confirmed
	CReflexive m_RCommandLists;
	CReflexive m_RUnknown9;
	CReflexive m_RStartingLocations;
	CReflexive m_RPlatoons;
	CReflexive m_RAiConversations;
	DWORD m_dwScriptSyntaxDataSize;
	DWORD m_dwUnknown10;
	CReflexive m_RScriptCrap;      
	CReflexive m_RCommands;
	CReflexive m_RPoints;
	CReflexive m_RAiAnimationRefs;
	CReflexive m_RGlobalsVerified;
	CReflexive m_RAiRecordingRefs;
	CReflexive m_RUnknown11;
	CReflexive m_RParticipants;
	CReflexive m_RLines;
	CReflexive m_RScriptTriggers;
	CReflexive m_RVerifyCutscenes;
	CReflexive m_RVerifyCutsceneTitle;
	CReflexive m_RSourceFiles;
	CReflexive m_RCutsceneFlags;
	CReflexive m_RCutsceneCameraPoi;
	CReflexive m_RCutsceneTitles;
	CReflexive m_RUnknown12[8];
	DWORD m_dwUnknown13[2];
	CReflexive m_RStructBsp;
}; // 0x4BF3EDA0 - Trial Bloodgulch Base
Code:

Code: Select all

class CReflexive
{
public:
	DWORD m_dwCount;
	DWORD m_dwOffset;
	DWORD m_dwZeros;
};
Code:

Code: Select all

class CPlayerSpawn
{
public:
	float m_fX;
	float m_fY;
	float m_fZ;
	float m_fYaw;
	DWORD m_dwTeam;
	DWORD m_dwUnknown[8];
};
I think I have gone over enough material for now. I will be updating. Hope you learned something from this! =]



Title: Re: Halo: Combat Evolved Structures
Post by: °•°•°•ŞįĿəŋţ¬ĸ°•°•°• on March 06, 2009, 02:53:36 PM
I went over limit, so I have to continue in another post.

Blam file structure, which is also loaded directly into memory like copy and paste.
Code:

Code: Select all

class CBlam
{
public:
	WORD m_wGameTypeName[24];	// Unicode
	DWORD m_dwGameType;			// 1 CTF, 2 Slayer, 3 Oddball, 4 KOTH, 5 Race
	DWORD m_dwTeamPlay;			// 0 Off, 1 On

	BITFIELD m_bBallIndicator		:	1;
	BITFIELD m_bFriendsOnRadar		:	1;
	BITFIELD m_bStartEquipment		:	1;	// 0 Generic, 1 Custom
	BITFIELD m_bInvisible			:	1;
	BITFIELD m_bShields				:	1;  
	BITFIELD m_bInfiniteGrenades	:	1;
	BITFIELD m_bFriendIndicators	:	1;
	BITFIELD m_bPlayersOnRadar		:	1;

	DWORD m_dwIndicator;            // 0 Motion tracker, 1 Navpoints, 2 None
	DWORD m_dwOddManOut;            // 0 No, 1 Yes
	DWORD m_dwRespawnTimeGrowth;	// 0 Off, 30 units per second eg: 150(0x96) = 30*5 secs
	DWORD m_dwRespawnTime;
	DWORD m_dwSuicidePenalty;
	DWORD m_dwNumOfLives;			// 0 Unlimited, 1 1 life, 3 3 lives, 5 5 lives
	float m_fUnknown;               // 1.0f
	DWORD m_dwScoreLimit;           // Captures for CTF, laps for RACE, kills for Slayer, minutes for King, etc
	DWORD m_dwWeaponSet;            // 0 Normal, 1 Pistols, 2 Rifles, 3 Plasma, 4 Sniper, 5 No sniping, 6 Rockets, 
									// 7 Shotguns, 8 Shortrange, 9 Human, 10 Convenant, 11 Classic, 12 Heavy

	/* Red Team Vehicle Settings */
	BITFIELD m_bRedCustom			:	4;
	BITFIELD m_bRedWarthog			:	3;
	BITFIELD m_bRedGhost			:	3;
	BITFIELD m_bRedScorpion			:	3;
	BITFIELD m_bRedRocketWarthog	:	3;
	BITFIELD m_bRedBanshee			:	3;
	BITFIELD m_bRedTurret			:	3;
	BITFIELD m_bRedZero				:	2;
	BITFIELD m_bRedUnused			:	8;

	/* Blue Team Vehicle Settings */
	BITFIELD m_bBlueCustom			:	4;
	BITFIELD m_bBlueWarthog			:	3;
	BITFIELD m_bBlueGhost			:	3;
	BITFIELD m_bBlueScorpion		:	3;
	BITFIELD m_bBlueRocketWarthog	:	3;
	BITFIELD m_bBlueBanshee			:	3;
	BITFIELD m_bBlueTurret			:	3;
	BITFIELD m_bBlueZero			:	2;
	BITFIELD m_bBlueUnused			:	8;

	DWORD m_dwVehicleRespawnTime;

	DWORD m_dwFriendlyFire;			// 0 Off, 1 On
	DWORD m_dwTKPenalty;
	DWORD m_dwAutoTeamBalance;		// 0 Off, 1 On
	DWORD m_dwGameTimeLimit;
	DWORD m_dwTypeFlags;			// Moving hill 0 Off; 1 On (KOTH)
									// Racetype 0 Normal; 1 Any order; 2 Rally (Race)
									// Random start 0 No; 1 Yes (Oddball)
	BYTE m_bTeamScoring;			// Team scoring 0 Minimum; 1 Maximum; 2 Sum (Race)
									// Ballspeed 0 Slow; 1 Normal; 2 Fast (Oddball)
	BYTE m_bAssaultTimeLimit;		// 0 Two flags
	WORD m_wUnused1;
	DWORD m_dwTraitWithBall;		// 0 None, 1 Invisible, 2 Extra damage, 3 Damage Resistent 
	DWORD m_dwTraitWithoutBall;		// 0 None, 1 Invisible, 2 Extra damage, 3 Damage Resistent
	DWORD m_dwBallType;             // 0 Normal, 1 Reverse Tag, 2 Juggernaut 
	DWORD m_dwBallCountSpawn;
	BYTE m_bOne;                    // Always 1 ( 0 if custom )
	BYTE m_bGameTypeNum;            // # of the game in the game list ( 0000 - for a custom game type )
	WORD m_wUnused2;
	DWORD m_dwChecksum;
};
The halo camera!
Code:

Code: Select all

class CCamera
{
public:
	WORD m_wUnknown1;
	WORD wPerspective; // First Person( 0 ), Third Person( 1 ), Dead( 3 )
	DWORD m_dwUnknown2; 

	float m_fWorld1[3]; // x,y,z ( game units )
	float m_fShift1[3]; // x,y,z ( forward/back,side,vertical )( game units )
	float m_fDepth1;
	float m_fFov1;      // in radians ( default = 70 degrees )
	float m_fForward1[3];
	float m_fUp1[3];
	float m_fVelocity1[3];

	DWORD m_dwUnknown3[26];

	float m_fWorld2[3];
	float m_fShift2[3]; // x,y,z ( forward/back,side,vertical )( game units )
	float m_fDepth2;
	float m_fFov2;      // in radians ( default = 70 degrees )
	float m_fForward2[3];
	float m_fUp2[3];
	float m_fVelocity2[3];

	DWORD m_dwUnknown4[9];
	float m_fWorld3[3];
	DWORD m_dwUnknown5[5];
	float m_fForward3[3];
	float m_fUp3[3];
	float m_fFov3;

	float m_fWorld4[3];
	DWORD m_dwUnknown6[4];
	float m_fFov4;
	float m_fForward4[3];
	float m_fUp4[3];


};
Disclaimer: I am no longer active. Any posts, PMs or other communication I use has no guarantee of accuracy or follow up.
Download Eschaton: Mediafire

nil
Halo Moderator
Halo Moderator
Posts: 1083
Joined: Sat Jul 05, 2008 8:38 am
Location: null zone

Re: Ohai

Post by nil » Wed Jan 20, 2010 9:15 pm

These are Conure's notes that modfox sent me (he asked conure, so they're really straight from him). I'm pretty sure neither of them will care if I post it here, or hopefully.

Code: Select all

////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
//////////////////////////By////////////////////////////
////////////////////////Conure//////////////////////////
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
///////////////////////////////////
////////////Static Headers/////////
///////////////////////////////////
////cached object render states////
///////////////widget//////////////
////////////////flag///////////////
//////////////antenna//////////////
////////////////glow///////////////
///////////glow particles//////////
////////////light volumes//////////
//////////////lightnings///////////
/////////////device groups/////////
////////////////lights/////////////
///////cluster light reference/////
///////light cluster reference/////
////////////////object/////////////
//cluster collideable object refe//
//collideable object cluster refe//
//cluster noncollideable object r//
//noncollideable object cluster r//
///////////////decals//////////////
/////////decal vertex cache////////
//////////////players//////////////
///////////////teams///////////////
/////////////contrail//////////////
//////////contrail point///////////
/////////////particle//////////////
//////////////effect///////////////
//////////effect location//////////
/////////particle systems//////////
/////particle system particles/////
///////object looping sounds///////
//////////////actor////////////////
//////////////swarm////////////////
/////////swarm component///////////
//////////////prop/////////////////
///////////encounter///////////////
///////////ai pursuit//////////////
////////ai conversation////////////
//////object list header///////////
/////list object reference/////////
///////////hs thread///////////////
//////////hs globals///////////////
////////recorded animations////////
///////////////////////////////////
///////////////////////////////////
///////////////////////////////////
/////////Dynamic Headers///////////
///////////////////////////////////
///////////pc texture//////////////
////////pc texture cache///////////
////////////pc sound///////////////
/////////pc sound cache////////////
//////////////sounds///////////////
/////////looping sounds////////////
/////////terminal output///////////
////////weather particles//////////
//////update server queues/////////
//////update client queues/////////
//////////script node//////////////
///////////////////////////////////
///////////////////////////////////



////////
//notes:1. The difference between the static headers in trial and full is 0xbad0000 (adds 0xbad0000 to the static offsets to get trial offsets)
////////2. There is no difference between ce and pc static memory offsets




////Cached object render states////
//Info: Last seen object render state? Not sure.

struct cached_object_render_states_header
{
 unsigned char TName[32];          // 'cached object render states'
 unsigned short MaxObjects;        // Maximum number of objects - 0x100(256 states)
 unsigned short Size;                  // Size of each object array - 0x100(256 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                  // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40002DE0

struct cached_object_render_states_item
{
 unsigned short ObjectID;      // ID number of the current item
};



////Widget////
//Info: Widget tag class is basis of the pause menu, and ui. Basicaily it is the interactable UI features found in game.

struct widget_header
{
 unsigned char TName[32];          // 'widget'
 unsigned short MaxObjects;        // Maximum number of objects - 0x40(64 widgets)
 unsigned short Size;                  // Size of each object array - 0xC(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                  // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40012E18

struct widget_item
{
 unsigned short ObjectID;      // ID number of the current item
unsigned short Unknown0;	//not always 0
unsigned short Unknown1;	//not always 0
unsigned short unknown2;	//combined with unknown1 this may produce a Tag "ident", look into
long unknown3;			//-1
};



////flag////
//Info: Flag tag class is what makes up the flag part of the flags, this has the ability to "sway" in the wind.
//Not sure purpose of this memory section, maybe is what enable the sway.

struct flag_header
{
 unsigned char TName[32];          // 'flag'
 unsigned short MaxObjects;        // Maximum number of objects - 0x2 (2 flags)
 unsigned short Size;                  // Size of each object array - 0x16bc(5820 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                  // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40013150

struct flag_item
{
 unsigned short ObjectID;      // ID number of the current item
};



////antenna////
//Info: antenna tag class seems to have no purpose outside of aperrance, maybe this affects the antennas apperance
//as such when it ways when a warthog is hit

struct antenna_header
{
 unsigned char TName[32];          // 'antenna'
 unsigned short MaxObjects;        // Maximum number of objects - 0xC (12 antenna)
 unsigned short Size;                  // Size of each object array - 0x02bc(700 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                  // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40015F00

struct antenna_item
{
 unsigned short ObjectID;      // ID number of the current item
};



////glow////
//Info: glow is just wat it says, GLOW. Seen on glowing objects.

struct glow_header
{
 unsigned char TName[32];          // 'glow'
 unsigned short MaxObjects;        // Maximum number of objects - 0x8 (8 glow)
 unsigned short Size;                  // Size of each object array - 0x025c(604 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                  // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40018008

struct glow_item
{
 unsigned short ObjectID;      // ID number of the current item
};



////glow particles////
//Info: glow particles... Maybe the small bits of aura that surrond a "glow"?

struct glow_particles_header
{
 unsigned char TName[32];          // 'glow particles'
 unsigned short MaxObjects;        // Maximum number of objects - 0x200 (512)
 unsigned short Size;                  // Size of each object array - 0x064(100 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40019320

struct glow_particles_item
{
 unsigned short ObjectID;      // ID number of the current item
};



////light_volumes////
//Info: light volumes create "3d" dynamic lights in game, this can be seen on 343.

struct light_volumes_header
{
 unsigned char TName[32];          // 'light volumes'
 unsigned short MaxObjects;        // Maximum number of objects - 0x100 (256)
 unsigned short Size;                  // Size of each object array - 0x8(8 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40025B58

struct light_volumes_item
{
 unsigned short ObjectID;      // ID number of the current item
unsigned short unknown0;      // 0
unsigned short unknown1;      // 1
unsigned short unknown2;      // 1
unsigned short unknown3;      // Looks like a ID number to a different table, possibly object table
};



////lightnings////
//Info: The tag that creates lightning

struct lightnings_header
{
 unsigned char TName[32];          // 'lightnings'
 unsigned short MaxObjects;        // Maximum number of objects - 0x100 (256)
 unsigned short Size;                  // Size of each object array - 0x8(8 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40026390

struct lightnings_item
{
 unsigned short ObjectID;      // ID number of the current item
unsigned short unknown0;      // 0
unsigned short unknown1;      // 1
unsigned short unknown2;      // 1
unsigned short unknown3;      // Looks like a ID number to a different table, possibly object table
}; //this struct has not been tested due to lack of lightning tags avlibable at time of info compilation



////device groups////
//Info: The tag that controls a device group which is a link between two devices, such is seen in doors and controls.

struct device_groups_header
{
 unsigned char TName[32];          // 'device groups'
 unsigned short MaxObjects;        // Maximum number of objects - 0x400 (1024)
 unsigned short Size;                  // Size of each object array - 0x8(8 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40026BD0

struct device_groups_item
{
 unsigned short ObjectID;      // ID number of the current item
}; //this struct has not been tested due to lack of lightning tags avlibable at time of info compilation



////lights////
//Info: The tag that creates "lights", such as blinking blue/red lights seen in some MP maps.

struct lights_header
{
 unsigned char TName[32];          // 'lights'
 unsigned short MaxObjects;        // Maximum number of objects - 0x380 (896)
 unsigned short Size;                  // Size of each object array - 0x7c(124 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40028C08

struct lights_item
{
 unsigned short ObjectID;      // ID number of the current item
unsigned short unknown0;      // 
unsigned short unknown1;      // 
unsigned short unknown2;      // 
unsigned short unknown3;      // Looks like a ID number to a different table, possibly object table
};



////cluster light reference ////
//Info: ???

struct cluster_light_reference_header
{
 unsigned char TName[32];          // 'cluster light reference'
 unsigned short MaxObjects;        // Maximum number of objects - 0x800 (2048)
 unsigned short Size;                  // Size of each object array - 0xc(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40044644

struct cluster_light_reference_item
{
//not even going try to understand this one yet
};



////light cluster reference ////
//Info: ???

struct light_cluster_reference_header
{
 unsigned char TName[32];          // 'light cluster reference'
 unsigned short MaxObjects;        // Maximum number of objects - 0x800 (2048)
 unsigned short Size;                  // Size of each object array - 0xc(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - pointer? or just 'data' ?
 unsigned short Unknown1;         // Something to do with number of objects, number currently in index?
 unsigned short MaxNum;                // Number of objects in the current game, maximum game has hit?
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x4004A67C

struct light_cluster_reference_item
{
//will be same as cluster_light_reference_item in all probability
};



////object////
//Info: probably contains info about every "object" type tag in the map that is placed. (object tag include - but are not limited to -
//weapons, bipeds, scenery, and vehicles

struct object_header
{
 unsigned char TName[32];          // 'object'
 unsigned short MaxObjects;        // Maximum number of objects - 0x800(2048 objects)
 unsigned short Size;                  // Size of each object array - 0x0C(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x400506B4

struct object_item
{
 unsigned short ObjectID;           // unique ID of object
 unsigned short Unknown0;
 unsigned short Unknown1;
 unsigned short Size;                 // Structure size
 unsigned long Offset;                // Pointer to the object data structure
};



////cluster collideable object refe////
//Info: Collidable object reference? Collision models?

struct cluster_collideable_object_refe_header
{
 unsigned char TName[32];          // 'cluster collideable object refe'
 unsigned short MaxObjects;        // Maximum number of objects - 0x800(2048)
 unsigned short Size;                  // Size of each object array - 0x0C(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402577BC

struct cluster_collideable_object_refe_item
{
 unsigned short ObjectID;           // unique ID of object
 unsigned short Unknown0;
 unsigned short Unknown1;
 unsigned short OtherId;                 // Id to another table? possibly object
 unsigned long unknown2;                
};



////collideable object cluster refe////
//Info: Collidable object reference? Collision models?

struct collideable_object_cluster_refe_header
{
 unsigned char TName[32];          // 'collideable object cluster refe'
 unsigned short MaxObjects;        // Maximum number of objects - 0x800(2048)
 unsigned short Size;                  // Size of each object array - 0x0C(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x4025D7F4

struct collideable_object_cluster_refe_item
{
 unsigned short ObjectID;           // unique ID of object
 unsigned short Unknown0;
 unsigned short Unknown1;
 unsigned short OtherId;                 // Id to another table? possibly object
 unsigned long unknown2;                
};


////cluster noncollideable object r////
//Info: objects that you can conlide with? Weapons, ect?

struct cluster_noncollideable_object_r_header
{
 unsigned char TName[32];          // 'cluster noncollideable object r'
 unsigned short MaxObjects;        // Maximum number of objects - 0x800(2048)
 unsigned short Size;                  // Size of each object array - 0x0C(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x4026402C

struct cluster_noncollideable_object_r_item
{
 unsigned short ObjectID;           // unique ID of object
 unsigned short Unknown0;
 unsigned short Unknown1;
 unsigned short OtherId;                 // Id to another table? possibly object
 unsigned long unknown2;                
};



////noncollideable object cluster r////
//Info: objects that you can conlide with? Weapons, ect?

struct noncollideable_object_cluster_r_header
{
 unsigned char TName[32];          // 'noncollideable object cluster r'
 unsigned short MaxObjects;        // Maximum number of objects - 0x800(2048)
 unsigned short Size;                  // Size of each object array - 0x0C(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x4026A064

struct noncollideable_object_cluster_r_item
{
 unsigned short ObjectID;           // unique ID of object
 unsigned short Unknown0;
 unsigned short Unknown1;
 unsigned short OtherId;                 // Id to another table? possibly object
 unsigned long unknown2;                
};



////decals////
//Info: decals, textures draw over other map textures that are created in response to a event such as a bullet impact

struct decals_header
{
 unsigned char TName[32];          // 'decals'
 unsigned short MaxObjects;        // Maximum number of objects - 0x800(2048)
 unsigned short Size;                  // Size of each object array - 0x38(56 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x4027E6D4

struct decals_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////decal vertex cache////
//Info: The name implies it stores the cords of the decal vertexs, maybe "decals" references this
//and uses it to store decal locations.

struct decal_vertex_cache_header
{
 unsigned char TName[32];          // 'decal vertex cache'
 unsigned short MaxObjects;        // Maximum number of objects - 0x800(2048)
 unsigned short Size;                  // Size of each object array - 0x1c(28 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x4029CF5C

struct decal_vertex_cache_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////player////
//Info: Contians information about the player such as score, and name

struct player_header
{
 unsigned char TName[32];          // 'player'
 unsigned short MaxObjects;        // Maximum number of objects - 0x10(16)
 unsigned short Size;                  // Size of each object array - 0x200(512 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402AAF94

struct player_item
{
 unsigned short ObjectID;            // Stats at 0x70EC
 unsigned short PlayerID2;            // ???
 wchar_t PlayerName0[12];           // Unicode / Max - 11 Chars + EOS (12 total)
 long Unknown0;                     // Always -1 / 0xFFFFFFFF
 unsigned long Team;                // 0 = Red / 1 = Blue
 unsigned long SwapID;              // ObjectID
 unsigned short SwapType;           // 8 = Vehicle / 6 = Weapon
 short SwapSeat;                    // Warthog - Driver = 0 / Passenger = 1 / Gunner = 2 / Weapon = -1
 unsigned long RespawnTimer;        // ?????? Counts down when dead, Alive = 0
 unsigned long Unknown1;            // Always 0
 unsigned short ObjectIndexNum;
 unsigned short ObjectID;           // Matches against object table
 unsigned long Unknown3;            // Some sort of ID
 unsigned long LocationID;          // This is very, very interesting. BG is split into 25 location ID's. 1 -19
 long Unknown4;                     // Always -1 / 0xFFFFFFFF
 unsigned long BulletCount;         // Something to do with bullets increases - weird.
 wchar_t PlayerName1[12];           // Unicode / Max - 11 Chars + EOS (12 total)
 unsigned long Unknown5;      // 02 00 FF FF
 unsigned long PlayerIndex;
 char Unknown6[52];           // unexplored
 short Kills;		//amount of kills player has, this can be modifed
 char Unknown7[6];			//unexplored
 short assists;		//number of assists player has
 char unknown8[6];			//unexplored
 short betrayed;	//betrays
 short Deaths;	//death count
 short Sucides;   //sucides
};



////teams////
//Info: Contians information about teams (i assume), weitherthis is sp/mp (or both) is unknown at the moment.
//update: due to the fact maximum number is "16" i assume it is a sp thing and might contian info about alliences and such.

struct teams_header
{
 unsigned char TName[32];          // 'teams'
 unsigned short MaxObjects;        // Maximum number of objects - 0x10(16)
 unsigned short Size;                  // Size of each object array - 0x40(64 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402ACFCC

struct teams_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////contrail////
//Info: contrail, as in the thing that follows the gun

struct contrail_header
{
 unsigned char TName[32];          // 'contrail'
 unsigned short MaxObjects;        // Maximum number of objects - 0x100(256)
 unsigned short Size;                  // Size of each object array - 0x44(68 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402AD4EC

struct contrail_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////contrail point////
//Info: points that the contrial is still visible in?

struct contrail_point_header
{
 unsigned char TName[32];          // 'contrail point'
 unsigned short MaxObjects;        // Maximum number of objects - 0x400(1024)
 unsigned short Size;                  // Size of each object array - 0x38(56 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402B1924

struct contrail_point_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////particle////
//Info: particle, small floating peices of bitmap

struct particle_header
{
 unsigned char TName[32];          // 'particle'
 unsigned short MaxObjects;        // Maximum number of objects - 0x400(1024)
 unsigned short Size;                  // Size of each object array - 0x70(11 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402BF95C

struct particle_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////effect////
//Info: an effect, example is a explosion

struct effect_header
{
 unsigned char TName[32];          // 'effect'
 unsigned short MaxObjects;        // Maximum number of objects - 0x100(256)
 unsigned short Size;                  // Size of each object array - 0xfc(252 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402DB994

struct effect_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////effect location////
//Info: location a effect happens at (?)

struct effect_location_header
{
 unsigned char TName[32];          // 'effect location'
 unsigned short MaxObjects;        // Maximum number of objects - 0x200(512)
 unsigned short Size;                  // Size of each object array - 0x3c(60 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402EB5CC

struct effect_location_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////particle systems////
//Info: system of particles, seen in explosions and such 

struct particle_systems_header
{
 unsigned char TName[32];          // 'particle systems'
 unsigned short MaxObjects;        // Maximum number of objects - 0x40(64)
 unsigned short Size;                  // Size of each object array - 0x158(344 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402F2E04

struct particle_systems_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////particle system particles////
//Info: particles to the particle system?

struct particle_system_particles_header
{
 unsigned char TName[32];          // 'particle system particles'
 unsigned short MaxObjects;        // Maximum number of objects - 0x200(512)
 unsigned short Size;                  // Size of each object array - 0x80(128 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x402F843C

struct particle_system_particles_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////object looping sounds////
//Info: ------

struct object_looping_sounds_header
{
 unsigned char TName[32];          // 'object looping sounds'
 unsigned short MaxObjects;        // Maximum number of objects - 0x400(1024)
 unsigned short Size;                  // Size of each object array - 0x34(52 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403086D8

struct object_looping_sounds_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////actor////
//Info: AI actor? The actualy ai location ect? Or just the basis of its "intelligence" (i.e. outer factors being processed)

struct actor_header
{
 unsigned char TName[32];          // 'actor'
 unsigned short MaxObjects;        // Maximum number of objects - 0x100(256)
 unsigned short Size;                  // Size of each object array - 0x724(1828 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40316120

struct actor_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////swarm////
//Info: swarm, a ai thing

struct swarm_header
{
 unsigned char TName[32];          // 'swarm'
 unsigned short MaxObjects;        // Maximum number of objects - 0x20(32)
 unsigned short Size;                  // Size of each object array - 0x98(152 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40388558

struct swarm_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////swarm component////
//Info: swarm component, something to do with swarm

struct swarm_component_header
{
 unsigned char TName[32];          // 'swarm component'
 unsigned short MaxObjects;        // Maximum number of objects - 0x100(256)
 unsigned short Size;                  // Size of each object array - 0x40(64 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x40389890

struct swarm_component_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////prop////
//Info: prop...erty? ...isition? -NO IDEA-

struct prop_header
{
 unsigned char TName[32];          // 'prop'
 unsigned short MaxObjects;        // Maximum number of objects - 0x300(768)
 unsigned short Size;                  // Size of each object array - 0x138(312 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x4038D8C8

struct prop_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////encounter////
//Info: a AI encounter, this contians AI squads and AI spawns, and possibly the locations of ai bipeds.

struct encounter_header
{
 unsigned char TName[32];          // 'encounter'
 unsigned short MaxObjects;        // Maximum number of objects - 0x80(128)
 unsigned short Size;                  // Size of each object array - 0x6c(108 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403C8100

struct encounter_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////ai pursuit////
//Info: ai pursuit, what the ai is pursuing?

struct ai_pursuit_header
{
 unsigned char TName[32];          // 'ai pursuit'
 unsigned short MaxObjects;        // Maximum number of objects - 0x100(256)
 unsigned short Size;                  // Size of each object array - 0x28(40 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403D4738

struct ai_pursuit_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////ai conversation////
//Info: ai conversation, talky talky talky

struct ai_conversation_header
{
 unsigned char TName[32];          // 'ai conversation'
 unsigned short MaxObjects;        // Maximum number of objects - 0x8(8)
 unsigned short Size;                  // Size of each object array - 0x64(100 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403D78C0

struct ai_conversation_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////object list header////
//Info: object list header, a object list is a list of objects accessed by a index number (example: players)

struct object_list_header_header
{
 unsigned char TName[32];          // 'object list header'
 unsigned short MaxObjects;        // Maximum number of objects - 0x30(48)
 unsigned short Size;                  // Size of each object array - 0xc(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403D7C18

struct object_list_header_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////list object reference////
//Info: list object reference, ??????

struct list_object_eference_header
{
 unsigned char TName[32];          // 'list object reference'
 unsigned short MaxObjects;        // Maximum number of objects - 0x80(128)
 unsigned short Size;                  // Size of each object array - 0xc(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403D7E90

struct list_object_reference_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////list object reference////
//Info: list object reference, ??????

struct list_object_eference_header
{
 unsigned char TName[32];          // 'list object reference'
 unsigned short MaxObjects;        // Maximum number of objects - 0x80(128)
 unsigned short Size;                  // Size of each object array - 0xc(12 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403D7E90

struct list_object_reference_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////hs thread////
//Info: hs (halo script?) thread - this probably has something to do with the "continuous" scripts or "sleep until" commands in halo scripting

struct hs_thread_header
{
 unsigned char TName[32];          // 'hs thread'
 unsigned short MaxObjects;        // Maximum number of objects - 0x100(256)
 unsigned short Size;                  // Size of each object array - 0x218(536 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403D84C8

struct hs_thread_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};



////hs globals////
//Info: hs (halo script?) globals, this contains information about current map globals
//note: There are 493 in CE with out new globals compiled, and 491 in PC with out new globals compiled

struct hs_globals_header
{
 unsigned char TName[32];          // 'hs globals'
 unsigned short MaxObjects;        // Maximum number of objects - 0x400(1024)
 unsigned short Size;                  // Size of each object array - 0x8(8 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403F9D00

struct hs_globals_item
{
 unsigned short unknown1; //0xACED
 unsigned short unknown2; //0?
 unsigned long  value; //value of global, may be a pointer or a straight up value depending on type
};



////recorded animations////
//Info: recorded animations

struct recorded_animations_header
{
 unsigned char TName[32];          // 'recorded animations'
 unsigned short MaxObjects;        // Maximum number of objects - 0x40(64)
 unsigned short Size;                  // Size of each object array - 0x64(100 bytes)
 unsigned long Unknown0;           // always 1?
 unsigned char Data[4];              // '@t@d' - translates to 'data'?
 unsigned short Unknown1;         // Something to do with number of objects
 unsigned short Max;                  // Max number of objects the game has reached (slots maybe?)
 unsigned short NextObjectIndex; // Index number of the next object to spawn
 unsigned short NextObjectID;      // ID number of the next object to spawn
 unsigned long FirstObject;          // Pointer to the first object in the table 
}; // 0x403FBD38

struct recorded_animations_item
{
 unsigned short ObjectID;           // unique ID of object
//unexplored for most part
};
I am no longer active to Halo or MGM, and don't guarantee a response on the forums or through email. I will however linger around the discord room for general chatting. It's been fun!

User avatar
Dirk Gently
Commando
Posts: 2047
Joined: Sun Oct 21, 2007 2:34 pm
Location: 3C0E9056
Contact:

Re: Ohai

Post by Dirk Gently » Wed Jan 20, 2010 9:22 pm

lulz, those are actually the notes conure gave me just before QAR was done on the forum.

Post Reply

Who is online

Users browsing this forum: No registered users and 1 guest