Halo Classes for making hacks

[supercarz1991]

i have these layin around from my halo hack, figured i'd share

BSP class

#ifndef BSP_H
#define BSP_H

//#include "map.h"

struct BSPInfoPrimary
{
	unsigned long	BspMapOffset;
	unsigned long	BspSize;
	void*			BSPInfoSec;
	unsigned long	Unknown;
	TagReference	BSPRef;
};

struct BSPInfoSecondary
{
	void*			BSPHeader;
	long			Unknown[4];
	unsigned long	Name;	//'psbs'
};

struct BSPHeader
{
  TagReference		LightmapsTag;
  unsigned long		Unknown[37];
  TagBlock			Shaders;
  TagBlock			CollBspHeader;
  TagBlock			Nodes;
  unsigned long		Unknown1[6];
  TagBlock			Leaves;
  TagBlock			LeafSurfaces;
  TagBlock			SubmeshTriIndices;
  TagBlock			SubmeshHeader;
  TagBlock			Chunk10;
  TagBlock			Chunk11;
  TagBlock			Chunk12;
  TagBlock			Clusters;
  unsigned long		ClusterDataSize;
  unsigned long		Unknown2;
  TagBlock			Chunk14;
  TagBlock			ClusterPortals;
  TagBlock			Chunk16a;
  TagBlock			BreakableSurfaces;
  TagBlock			FogPlanes;
  TagBlock			FogRegions;
  TagBlock			FogOrWeatherPallette;
  TagBlock			Chunk16f;
  TagBlock			Chunk16g;
  TagBlock			Weather;
  TagBlock			WeatherPolyhedra;
  TagBlock			Chunk19;
  TagBlock			Chunk20;
  TagBlock			PathfindingSurface;
  TagBlock			Chunk24;
  TagBlock			BackgroundSound;
  TagBlock			SoundEnvironment;
  unsigned long		SoundPASDataSize;
  unsigned long		Unknown3;
  TagBlock			Chunk25;
  TagBlock			Chunk26;
  TagBlock			Chunk27;
  TagBlock			Markers;
  TagBlock			DetailObjects;
  TagBlock			RuntimeDecals;
  unsigned long		Unknown4[9];
}; // Size = 0x0288 ( 648 )

// **** BSP COLLISION LUMPS START ****

struct CollisionHeader
{
	TagBlock		Nodes;      //12 bytes
	TagBlock		Planes;     //16 bytes
	TagBlock		Leaves;     //8 bytes
	TagBlock		Bsp2dRef;   //8 bytes
	TagBlock		Bsp2dNodes;	//20 bytes
	TagBlock		Surfaces;   //12 bytes
	TagBlock		Edges;      //24 bytes
	TagBlock		Vertices;   //16 bytes
};

struct CollisionNode
{
	unsigned long	PlaneIndex;
	unsigned long	Back;
	unsigned long	Front;
};

struct CollisionPlane
{
	float			x;
	float			y;
	float			z;
	float			d;
};

struct CollisionLeaf
{
	unsigned long	Unknown[2];
};

struct CollisionBSP2dRef
{
	unsigned long	Unknown[2];
};

struct CollisionBSP2dNodes
{
	float			Unknown[3];
	unsigned long	Unknown2;
	unsigned long	LeafIndex;
};

struct CollisionSurfaces
{
	unsigned long	Unknown[2];
	short			Unknown1;
	short			Unknown2;
};

struct CollisionEdges
{
	unsigned long	Unknown[6];
};

struct CollisionVertex
{
	float			Unknown[4];
};

// **** BSP COLLISION LUMPS END ****

// **** BSP LUMPS START ****

struct Shader
{
	TagReference	ShaderRef;
	unsigned short	Unknown[2];
};

struct Nodes
{
  short				Unknown[3];
};

struct Leaves
{
  unsigned long		Unknown[4];
};

struct LeafSurface
{
  unsigned long		Unknown[2];
};

struct SubmeshTriIndices
{
  unsigned short	TriIndices[3];
};

struct SubmeshHeader
{
	short			LightmapIndex;
	short			Unknown;
	unsigned long	Unknown1[4];
	TagBlock		Material;
};

struct Cluster
{
	short			SkyIndex;
	short			FogIndex;
	short			BackgroundSoundIndex;
	short			SoundEnvIndex;
	short			WeatherIndex;
	short			TransitionBsp;
	unsigned long	Unknown1[10];
	TagBlock		SubCluster;
	unsigned long	Unknown2[7];
	TagBlock		Portals;
};

struct Weather
{
	char			Name[32];
	char			TagGroup[4];
	unsigned long	NamePtr;
	unsigned long	Zero;
	unsigned long	TagId;
	unsigned long	Reserved[20];
	char			TagGroup2[4];
	unsigned long	NamePtr2;
	unsigned long	Zero2;
	unsigned long	Signature2;
	unsigned long	Unknown[24];
};

struct MaterialSubmeshHeader
{
  TagReference		ShaderTag;
  unsigned long		UnkZero2;
  unsigned long		VertIndexOffset;
  unsigned long		VertIndexCount;
  float				Centroid[3];
  float				AmbientColor[3];
  unsigned long		DistLightCount;
  float				DistLight1[6];
  float				DistLight2[6];
  float				unkFloat2[3];
  float				ReflectTint[4];
  float				ShadowVector[3];
  float				ShadowColor[3];
  float				Plane[4];
  unsigned long		UnkFlag2;
  unsigned long		UnkCount1;
  unsigned long		VertexCount1;
  unsigned long		UnkZero4;
  unsigned long		VertexOffset;
  unsigned long		Vert_Reflexive;
  unsigned long		UnkAlways3;
  unsigned long		VertexCount2;
  unsigned long		UnkZero9;
  unsigned long		UnkLightmapOffset;
  unsigned long		CompVert_Reflexive;
  unsigned long		UnkZero5[2];
  unsigned long		SomeOffset1;
  unsigned long		PcVertexDataOffset;
  unsigned long		UnkZero6;
  unsigned long		CompVertBufferSize;
  unsigned long		UnkZero7;
  unsigned long		SomeOffset2;
  unsigned long		VertexDataOffset;
  unsigned long		UnkZero8;
};

// **** BSP LUMPS END ****

#endif /* BSP_H */

Maps Class

#ifndef MAP_H
#define MAP_H

#include <windows.h>
//#include "tags.h"
//#include "scenario.h"
//#include "bsp.h"

// 2 Map Headers are loaded into static memory. 2 differences - 
// few bytes before and after the header ( Index Header pointer and bps pointer? )
// Either of these should work though
#define MAP_HEADER_ADDRESS 0x006A807C
#define MapHeaderAltAddy	0x006AAB80

struct MapHeader
{
	unsigned long	HeadSignature;		// 'deah' translates as head
	unsigned long	Version;			// 5 = Xbox, 6 = Trial, 7 = PC, 609 = CE
	unsigned long	DecompressedLength;	// Actual len of decompressed data. Halo sticks garbage on the end so that the file is one of several fixed sizes (35, etc).
	unsigned long	Unknown;
	unsigned long	TagIndexOffset;
	unsigned long	TagIndexMetaLength;
	unsigned long	Zeros[2];			// both always 0x0
	char			MapName[32];
	char			BuildDate[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
	unsigned long	MapType;			// 0 = singleplayer, 1 = multiplayer, 2 = ui - this also determines the size of the cache file. UI = 35MB, multiplayer = 47MB, and singleplayer = 270MB
	unsigned long	Unknown1;
	unsigned long	Padding[485];
	unsigned long	FootSignature;		// 'toof' translates to foot
};

#endif /* MAP_H */

Scenario Class

#ifndef SCENARIO_H
#define SCENARIO_H

//#include "map.h"
//#include "bsp.h"

struct ScenarioHeader
{
	char			Unknown1[16];			// 0x0000
	char			Unknown2[16];			// 0x0010
	char			Unknown3[16];			// 0x0020
	TagBlock		SkyBox;					// 0x0030
	unsigned long	Unknown4;				// 0x003C
	TagBlock		ChildScenarios;			// 0x0040
	unsigned long	UnNeeded1[46];			// 0x004C
	unsigned long	EditorScenarioSize;		// 0x0104
	unsigned long	Unknown5;				// 0x0108
	unsigned long	Unknown6;				// 0x010C
	void*			PointerToIndex;			// 0x0110
	unsigned long	UnNeeded2[2];			// 0x0114
	void*			PointerToEndOfIndex;	// 0x011C
	unsigned long	Zeros[57];				// 0x0120
	TagBlock		ObjectNames;			// 0x0204
	TagBlock		Scenery;				// 0x0210
	TagBlock		SceneryRef;				// 0x021C
	TagBlock		Biped;					// 0x0228
	TagBlock		BipedRef;				// 0x0234
	TagBlock		Vehicle;				// 0x0240
	TagBlock		VehicleRef;				// 0x024C
	TagBlock		Equip;					// 0x0258
	TagBlock		EquipRef;				// 0x0264
	TagBlock		Weap;					// 0x0270
	TagBlock		WeapRef;				// 0x027C
	TagBlock		DeviceGroups;			// 0x0288
	TagBlock		Machine;				// 0x0294
	TagBlock		MachineRef;				// 0x02A0
	TagBlock		Control;				// 0x02AC
	TagBlock		ControlRef;				// 0x02B8
	TagBlock		LightFixture;			// 0x02C4
	TagBlock		LightFixtureRef;		// 0x02D0
	TagBlock		SoundScenery;			// 0x02DC
	TagBlock		SoundSceneryRef;		// 0x02E8
	TagBlock		Unknown7[7];			// 0x02F4
	TagBlock		PlayerStartingProfile;	// 0x0348
	TagBlock		PlayerSpawn;			// 0x0354
	TagBlock		TriggerVolumes;			// 0x0360
	TagBlock		Animations;				// 0x036C
	TagBlock		MultiplayerFlags;		// 0x0378
	TagBlock		MpEquip;				// 0x0384
	TagBlock		StartingEquip;			// 0x0390
	TagBlock		BspSwitchTrigger;		// 0x039C
	TagBlock		Decals;					// 0x03A8
	TagBlock		DecalsRef;				// 0x03B4
	TagBlock		DetailObjCollRef;		// 0x03C0
	TagBlock		Unknown8[7];			// 0x03CC
	TagBlock		ActorVariantRef;		// 0x0420
	TagBlock		Encounters;				// 0x042C
	TagBlock		CommandLists;			// 0x0438
	TagBlock		Unknown9;				// 0x0444
	TagBlock		StartingLocations;		// 0x0450
	TagBlock		Platoons;				// 0x045C
	TagBlock		AiConversations;		// 0x0468
	unsigned long	ScriptSyntaxDataSize;	// 0x0474
	unsigned long	Unknown10;				// 0x0478
	TagBlock		ScriptCrap;				// 0x047C
	TagBlock		Commands;				// 0x0488
	TagBlock		Points;					// 0x0494
	TagBlock		AiAnimationRefs;		// 0x04A0
	TagBlock		GlobalsVerified;		// 0x04AC
	TagBlock		AiRecordingRefs;		// 0x04B8
	TagBlock		Unknown11;				// 0x04C4
	TagBlock		Participants;			// 0x04D0
	TagBlock		Lines;					// 0x04DC
	TagBlock		ScriptTriggers;			// 0x04E8
	TagBlock		VerifyCutscenes;		// 0x04F4
	TagBlock		VerifyCutsceneTitle;	// 0x0500
	TagBlock		SourceFiles;			// 0x050C
	TagBlock		CutsceneFlags;			// 0x0518
	TagBlock		CutsceneCameraPoi;		// 0x0524
	TagBlock		CutsceneTitles;			// 0x0530
	TagBlock		Unknown12[8];			// 0x053C
	unsigned long	Unknown13[2];			// 0x059C
	TagBlock		StructBsp;				// 0x05A4
	// Binary Space Partitioning (BSP Tree) - The actual map layout ( excluding objects! )
};	/* ScenarioHeader Size = 0x05B0 ( 1456 bytes ) */

struct SkyBox
{
	TagReference	SkyBoxRef;
};

struct ScenerySpawn
{
	short			NumID;
	short			Flag;
	unsigned long	Unknown;
	vect3			World;
	vect3			Rotation;
	long			Unknown1[10];
};

struct SceneryRef
{
	TagReference	SceneryRef;
	unsigned long	Zero[8];
};

struct VehicleSpawn
{
	short			NumID;
	short			Flag;
	unsigned long	Unknown;
	vect3			World;
	vect3			Rotation;
	unsigned long	Unknown1[22];
};

struct VehicleRef
{
	TagReference	VehicleRef;
	unsigned long	Zero[8];
};

struct PlayerSpawn
{
	vect3			World;
	float			Yaw;
	long			Team;
	unsigned long	Unknown[8];
};

struct MpEquip
{
	unsigned long	Unknown[16];
	vect3			World;
	float			Yaw;
	TagReference	MpEquipRef;
	unsigned long	Unknown1[12];
};

#endif /* SCENARIO_H */

Objects class

#ifndef OBJECTS_H
#define OBJECTS_H

#include <windows.h>
#include "types.h"

#define OBJECT_ADDRESS 0x400506B4

struct AObjectHeader;
struct AObjectData;
struct AObject;
struct ABiped;
struct AWeapon;
struct ASniperRifle;
struct APistol;
struct AAssaultRifle;
struct AShotgun;
struct ARocketLauncher;
struct AFlameThrower;
struct APlasmaRifle;
struct APlasmaPistol;
struct ANeedler;
struct APlasmaCannon;

struct AObjectHeader
{
	short			ID;
	unsigned char	Flags;
	unsigned char	Type;
	short			CluserIndex;	// portal rendering (sector)
	short			Size;			// Structure size
	union
	{
		void*				Address;
		AObject*			Object;
		ABiped*				Biped;
		AWeapon*			Weapon;
		ASniperRifle*		SniperRifle;
		APistol*			Pistol;
		AAssaultRifle*		AssaultRifle;
		AShotgun*			Shotgun;
		ARocketLauncher*	RocketLauncher;
		AFlameThrower*		FlameThrower;
		APlasmaRifle*		PlasmaRifle;
		APlasmaPistol*		PlasmaPistol;
		ANeedler*			Needler;
		APlasmaCannon*		PlasmaCannon;
	};
};

struct AObjectData
{
	DataHeader		ObjectsHeader;
	AObjectHeader	ObjectHeader[2048];
};

struct AObject
{
	ident	ModelTag;		// 0x0000
	long	Zero;			// 0x0004
	char	Flags[4];		// 0x0008
	long	Timer;			// 0x000C
	char	Flags2[4];		// 0x0010
	long	Timer2;			// 0x0014
	long	Zero2[17];		// 0x0018
	vect3	World;			// 0x005C
	vect3	Velocity;		// 0x0068
	vect3	LowerRot;		// 0x0074
	vect3	Scale;			// 0x0080
	vect3	UnknownVect1;	// 0x008C
	long	LocationID;		// 0x0098
	long	Unknown1;		// 0x009C
	vect3	UnknownVect2;	// 0x00A0
	float	Unknown2[2];	// 0x00AC		
	long	Unknown3[3];	// 0x00B4
	ident	Player;			// 0x00C0
	long	Unknown4[2];	// 0x00C4
	ident	AntrMeta;		// 0x00CC
	long	Unknown5[4];	// 0x00D0
	float	Health;			// 0x00E0
	float	Shield1;		// 0x00E4
	long	Unknown6[11];	// 0x00E8
	ident	VehicleWeapon;	// 0x0114
	ident	Weapon;			// 0x0118
	ident	Vehicle;		// 0x011C
	short	SeatType;		// 0x0120
	short	Unknown7;		// 0x0122
	long	Unknown8;		// 0x0124
	float	Shield2;		// 0x0128
	float	Flashlight1;	// 0x012C
	float	Unknown9;		// 0x0130
	float	Flashlight2;	// 0x0134
	long	Unknown10[5];	// 0x0138
	ident	UnknownIdent1;	// 0x014C
	ident	UnknownIdent2;	// 0x0150
	long	Zero3[6];		// 0x0154
	ident	UnknownIdent3;	// 0x016C
	ident	UnknownIdent4;	// 0x0170
	D3DXMATRIX UnknownMatrix;	// 0x0174
	D3DXMATRIX UnknownMatrix1;	// 0x01B4
};

struct ABiped
{
	AObject	Object;				// 0x0000
	long	Unknown[4];			// 0x01F4
	long	IsInvisible;		// 0x0204	normal = 0x41 invis = 0x51 (bitfield?)
	char	IsCrouching :	1;	// 0x0208
	char	IsJumping	:	1;
	char	UnknownBit	:	2;
	char	Flashligh	:	1;
	char	UnknownBit2	:	3;
	char	Unknown1[3];		// 0x0209
	char	Unknown2[236];		// 0x020C
	ident	PrimaryWeapon;
	ident	SecondaryWeapon;

	char	Zoom;				// 0x0320
	char	Zoom1;				// 0x0321
	char	Unknown3[610];		// 0x0322
	bone	LeftThigh;			// 0x0584
	bone	RightThigh;			// 0x05B8
	bone	Pelvis;				// 0x05EC
	bone	LeftCalf;			// 0x0620
	bone	RightCalf;			// 0x0654
	bone	Spine;				// 0x0688
	bone	LeftClavicle;		// 0x06BC
	bone	LeftFoot;			// 0x06F0
	bone	Neck;				// 0x0724
	bone	RightClavicle;		// 0x0758
	bone	RightFoot;			// 0x078C
	bone	Head;				// 0x07C0
	bone	LeftUpperArm;		// 0x07F4
	bone	RightUpperArm;		// 0x0828
	bone	LeftLowerArm;		// 0x085C
	bone	RightLowerArm;		// 0x0890
	bone	LeftHand;			// 0x08C4
	bone	RightHand;			// 0x08F8
	char	Unknown4[1216];		// 0x092C
}; // Size - 3564(0x0DEC) bytes

////////////////////
// Generic Weapon //
////////////////////
struct AWeapon
{
	AObject			Object;
	char			Unknown[24];
	ident			UnknownIdent;
	unsigned long	NetworkTime;
	char			Unknown1[36];
	unsigned long	UnknownFlags	:	32;
	unsigned long	UnknownBit		:	1;
	unsigned long	Fire			:	1;
	unsigned long	Grenade			:	1;
	unsigned long	Reload			:	1;
	unsigned long	Melee			:	1;
	unsigned long	UnknownBit1		:	1;
	unsigned long	Zoom			:	1;
	unsigned long	UnknownBit2		:	1;
	unsigned long	UnusedBits		:	24;
	float			Unknown2;
	bool			IsFiring;
	char			Unknown3;
	unsigned short	WeaponReadyWaitTime;
	char			Unknown4[36];
	unsigned long	SomeCounter;
	unsigned long	IsNotFiring;
	unsigned long	Unknown5[2];
	float			Unknown6;
	unsigned long	Unknown7;
	float			Unknown8[2];
	ident			UnknownIdent1;
	unsigned long	AutoReloadCounter;
	unsigned char	Unknown9[40];
	unsigned short	ReloadFlags; // 0=NotReloading,1=Reloading, 2=???, 3=???
	unsigned short	ReloadCountdown;
	unsigned short	Unknown10;
	unsigned short	BulletCountInRemainingClips;
	unsigned short	BulletCountInCurrentClip;
	char			Unknown11[18];
	ident			UnknownIdent2;
	unsigned long	LastBulletFiredTime;
	char			Unknown12[16];
	vect3			Unknown13[2];
	char			Unknown14[12];
	unsigned long	BulletCountInRemainingClips1;
	char			Unknown15[52];
}; // Size - 1644(0x066C)

///////////////////
// Human Weapons //
///////////////////
struct ASniperRifle
{
	AWeapon		Weapon;
	bone		UnknownBone[4];
	float		FloatTable[32];
	char		Unknown[128];
};

struct APistol
{
	AWeapon		Weapon;
	bone		UnknownBone[7];
	float		FloatTable[56];
	char		Unknown[224];
};

struct AAssaultRifle
{
	AWeapon		Weapon;
	bone		UnknownBone[3];
	float		FloatTable[24];
	char		Unknown[96];
};

struct AShotgun
{
	AWeapon		Weapon;
	bone		UnknownBone[2];
	float		FloatTable[16];
	char		Unknown[64];
};

struct ARocketLauncher
{
	AWeapon		Weapon;
	bone		UnknownBone[5];
	float		FloatTable[40];
	char		Unknown[160];
};

struct AFlameThrower
{
	AWeapon		Weapon;
	bone		UnknownBone;
	float		FloatTable[8];
	char		Unknown[32];
};

//////////////////////
// Covenant Weapons //
//////////////////////
struct APlasmaRifle
{
	AWeapon		Weapon;
	bone		UnknownBone[5];
	float		FloatTable[40];
	char		Unknown[160];
};

struct APlasmaPistol
{
	AWeapon		Weapon;
	bone		UnknownBone[4];
	float		FloatTable[32];
	char		Unknown[128];
};

struct ANeedler
{
	AWeapon		Weapon;
	bone		UnknownBone;
	float		FloatTable[8];
	char		Unknown[32];
};

struct APlasmaCannon
{
	AWeapon		Weapon;
	bone		UnknownBone;
	float		FloatTable[8];
	char		Unknown[32];
};

// Main header to the entire array of object classes
struct LoopObjectsHeader
{
	char	Name[32]; // 'loop objects'
	long	Zero;
	void*	Start;
	short	Unknown[4];
	void*	First;
	void*	Last;
};

// Each object class has one of these before it
struct LoopObjectsSubHeader
{
	char			HeadSignature[4];	// 'daeh'
	unsigned long	Size;				// of entire object class, including this header
	void*			Address;			// pointer to the CObjectArray->Offset
	void*			Next;				// pointer to the next subheader
	long			Unknown;
	char			FootSignature[4];	// 'toof'
};

class CObjects
{
private:
	AObjectData*	ObjectData;
public:
	CObjects();
	~CObjects();

	void PrintObjectInfo();
	ident GetObjectIdent(unsigned char object_index);
};
#endif /* OBJECTS_H */

i'll post more later