14 files changed, 1775 insertions, 0 deletions

diff --git a/include/hge.h b/include/hge.h
new file mode 100644
index 0000000..836a2b9
--- /dev/null
+++ b/include/hge.h
@@ -0,0 +1,568 @@
+/*
+** Haaf's Game Engine 1.8
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** System layer API
+*/
+
+
+#ifndef HGE_H
+#define HGE_H
+
+#include "unix_compat.h"
+
+#ifdef _WINDOWS
+#include <windows.h>
+#endif
+
+#define HGE_VERSION 0x181
+
+#ifndef EXPORT
+#  ifdef HGEDLL
+#    ifdef _WINDOWS
+#      define EXPORT __declspec(dllexport)
+#    elif (__GNUC__ >= 3)
+#      define EXPORT __attribute__((visibility("default")))
+#    else
+#      define EXPORT
+#    endif
+#  else
+#    define EXPORT
+#  endif
+#endif
+
+#ifdef _WINDOWS
+#define CALL  __stdcall
+#else
+#define CALL
+#endif
+
+#ifdef __BORLANDC__
+ #define floorf (float)floor
+ #define sqrtf (float)sqrt
+ #define acosf (float)acos
+ #define atan2f (float)atan2
+ #define cosf (float)cos
+ #define sinf (float)sin
+ #define powf (float)pow
+ #define fabsf (float)fabs
+
+ #define min(x,y) ((x) < (y)) ? (x) : (y)
+ #define max(x,y) ((x) > (y)) ? (x) : (y)
+#endif
+
+
+/*
+** Common data types
+*/
+#ifdef _WINDOWS
+#ifndef DWORD
+typedef unsigned long       DWORD;
+typedef unsigned short      WORD;
+typedef unsigned char       BYTE;
+#endif
+#endif
+
+/*
+** Common math constants
+*/
+#ifndef M_PI
+#define M_PI	3.14159265358979323846f
+#endif
+#ifndef M_PI_2
+#define M_PI_2	1.57079632679489661923f
+#endif
+#ifndef M_PI_4
+#define M_PI_4	0.785398163397448309616f
+#endif
+#ifndef M_1_PI
+#define M_1_PI	0.318309886183790671538f
+#endif
+#ifndef M_2_PI
+#define M_2_PI	0.636619772367581343076f
+#endif
+
+
+/*
+** HGE Handle types
+*/
+typedef size_t HTEXTURE;
+typedef size_t HTARGET;
+typedef size_t HEFFECT;
+typedef size_t HMUSIC;
+typedef size_t HSTREAM;
+typedef size_t HCHANNEL;
+
+
+/*
+** Hardware color macros
+*/
+#define ARGB(a,r,g,b)	((DWORD(a)<<24) + (DWORD(r)<<16) + (DWORD(g)<<8) + DWORD(b))
+#define GETA(col)		((col)>>24)
+#define GETR(col)		(((col)>>16) & 0xFF)
+#define GETG(col)		(((col)>>8) & 0xFF)
+#define GETB(col)		((col) & 0xFF)
+#define SETA(col,a)		(((col) & 0x00FFFFFF) + (DWORD(a)<<24))
+#define SETR(col,r)		(((col) & 0xFF00FFFF) + (DWORD(r)<<16))
+#define SETG(col,g)		(((col) & 0xFFFF00FF) + (DWORD(g)<<8))
+#define SETB(col,b)		(((col) & 0xFFFFFF00) + DWORD(b))
+
+
+/*
+** HGE Blending constants
+*/
+#define	BLEND_COLORADD		1
+#define	BLEND_COLORMUL		0
+#define	BLEND_ALPHABLEND	2
+#define	BLEND_ALPHAADD		0
+#define	BLEND_ZWRITE		4
+#define	BLEND_NOZWRITE		0
+
+#define BLEND_DEFAULT		(BLEND_COLORMUL | BLEND_ALPHABLEND | BLEND_NOZWRITE)
+#define BLEND_DEFAULT_Z		(BLEND_COLORMUL | BLEND_ALPHABLEND | BLEND_ZWRITE)
+
+
+/*
+** HGE System state constants
+*/
+enum hgeBoolState
+{
+	HGE_WINDOWED		= 1,    // bool		run in window?		(default: false)
+	HGE_ZBUFFER			= 2,    // bool		use z-buffer?		(default: false)
+	HGE_TEXTUREFILTER	= 3,    // bool		texture filtering?	(default: true)
+
+	HGE_USESOUND		= 4,    // bool		use BASS for sound?	(default: true)
+
+	HGE_DONTSUSPEND		= 5,	// bool		focus lost:suspend?	(default: false)
+	HGE_HIDEMOUSE		= 6,	// bool		hide system cursor?	(default: true)
+
+	HGE_SHOWSPLASH		= 7,	// bool		hide system cursor?	(default: true)
+
+	HGEBOOLSTATE_FORCE_DWORD = 0x7FFFFFFF
+};
+
+enum hgeFuncState
+{
+	HGE_FRAMEFUNC		= 8,    // bool*()	frame function		(default: NULL) (you MUST set this)
+	HGE_RENDERFUNC		= 9,    // bool*()	render function		(default: NULL)
+	HGE_FOCUSLOSTFUNC	= 10,   // bool*()	focus lost function	(default: NULL)
+	HGE_FOCUSGAINFUNC	= 11,   // bool*()	focus gain function	(default: NULL)
+	HGE_GFXRESTOREFUNC	= 12,   // bool*()	exit function		(default: NULL)
+	HGE_EXITFUNC		= 13,   // bool*()	exit function		(default: NULL)
+
+	HGEFUNCSTATE_FORCE_DWORD = 0x7FFFFFFF
+};
+
+enum hgeHwndState
+{
+	HGE_HWND			= 15,	// int		window handle: read only
+	HGE_HWNDPARENT		= 16,	// int		parent win handle	(default: 0)
+
+	HGEHWNDSTATE_FORCE_DWORD = 0x7FFFFFFF
+};
+
+enum hgeIntState
+{
+	HGE_SCREENWIDTH		= 17,   // int		screen width		(default: 800)
+	HGE_SCREENHEIGHT	= 18,   // int		screen height		(default: 600)
+	HGE_SCREENBPP		= 19,   // int		screen bitdepth		(default: 32) (desktop bpp in windowed mode)
+
+	HGE_SAMPLERATE		= 20,   // int		sample rate			(default: 44100)
+	HGE_FXVOLUME		= 21,   // int		global fx volume	(default: 100)
+	HGE_MUSVOLUME		= 22,   // int		global music volume	(default: 100)
+	HGE_STREAMVOLUME	= 23,   // int		global music volume	(default: 100)
+
+	HGE_FPS				= 24,	// int		fixed fps			(default: HGEFPS_UNLIMITED)
+
+	HGE_POWERSTATUS		= 25,   // int		battery life percent + status
+
+	HGE_ORIGSCREENWIDTH		= 30,   // int		original screen width		(default: 800 ... not valid until hge->System_Initiate()!)
+	HGE_ORIGSCREENHEIGHT	= 31,   // int		original screen height		(default: 600 ... not valid until hge->System_Initiate()!))
+
+	HGEINTSTATE_FORCE_DWORD = 0x7FFFFFF
+};
+
+enum hgeStringState
+{
+	HGE_ICON			= 26,   // char*	icon resource		(default: NULL)
+	HGE_TITLE			= 27,   // char*	window title		(default: "HGE")
+
+	HGE_INIFILE			= 28,   // char*	ini file			(default: NULL) (meaning no file)
+	HGE_LOGFILE			= 29,   // char*	log file			(default: NULL) (meaning no file)
+
+	HGESTRINGSTATE_FORCE_DWORD = 0x7FFFFFFF
+};
+
+/*
+** Callback protoype used by HGE
+*/
+typedef bool (*hgeCallback)();
+
+
+/*
+** HGE_FPS system state special constants
+*/
+#define HGEFPS_UNLIMITED	0
+#define HGEFPS_VSYNC		-1
+
+
+/*
+** HGE_POWERSTATUS system state special constants
+*/
+#define HGEPWR_AC			-1
+#define HGEPWR_UNSUPPORTED	-2
+
+
+/*
+** HGE Primitive type constants
+*/
+#define HGEPRIM_LINES		2
+#define HGEPRIM_TRIPLES		3
+#define HGEPRIM_QUADS		4
+
+
+/*
+** HGE Vertex structure
+*/
+struct hgeVertex
+{
+	float			x, y;		// screen position
+	float			z;			// Z-buffer depth 0..1
+	DWORD			col;		// color
+	float			tx, ty;		// texture coordinates
+};
+
+
+/*
+** HGE Triple structure
+*/
+struct hgeTriple
+{
+	hgeVertex		v[3];
+	HTEXTURE		tex;
+	int				blend;
+};
+
+
+/*
+** HGE Quad structure
+*/
+struct hgeQuad
+{
+	hgeVertex		v[4];
+	HTEXTURE		tex;
+	int				blend;
+};
+
+
+/*
+** HGE Input Event structure
+*/
+struct hgeInputEvent
+{
+	int		type;			// event type
+	int		key;			// key code
+	int		flags;			// event flags
+	int		chr;			// character code
+	int		wheel;			// wheel shift
+	float	x;				// mouse cursor x-coordinate
+	float	y;				// mouse cursor y-coordinate
+};
+
+
+/*
+** HGE Input Event type constants
+*/
+#define INPUT_KEYDOWN		1
+#define INPUT_KEYUP			2
+#define INPUT_MBUTTONDOWN	3
+#define INPUT_MBUTTONUP		4
+#define INPUT_MOUSEMOVE		5
+#define INPUT_MOUSEWHEEL	6
+
+
+/*
+** HGE Input Event flags
+*/
+#define HGEINP_SHIFT		1
+#define HGEINP_CTRL			2
+#define HGEINP_ALT			4
+#define HGEINP_CAPSLOCK		8
+#define HGEINP_SCROLLLOCK	16
+#define HGEINP_NUMLOCK		32
+#define HGEINP_REPEAT		64
+
+
+/*
+** HGE Interface class
+*/
+class HGE
+{
+public:
+	HGE() {}
+	virtual ~HGE() {};
+
+	virtual	void		CALL	Release() = 0;
+
+	virtual bool		CALL	System_Initiate() = 0;
+	virtual void		CALL	System_Shutdown() = 0;
+	virtual bool		CALL	System_Start() = 0;
+	virtual const char*	CALL	System_GetErrorMessage() = 0;
+	virtual	void		CALL	System_Log(const char *format, ...) = 0;
+	virtual bool		CALL	System_Launch(const char *url) = 0;
+	virtual void		CALL	System_Snapshot(const char *filename=0) = 0;
+
+private:
+	virtual void		CALL	System_SetStateBool  (hgeBoolState   state, bool        value) = 0;
+	virtual void		CALL	System_SetStateFunc  (hgeFuncState   state, hgeCallback value) = 0;
+	virtual void		CALL	System_SetStateHwnd  (hgeHwndState   state, HWND        value) = 0;
+	virtual void		CALL	System_SetStateInt   (hgeIntState    state, int         value) = 0;
+	virtual void		CALL	System_SetStateString(hgeStringState state, const char *value) = 0;
+	virtual bool		CALL	System_GetStateBool  (hgeBoolState   state) = 0;
+	virtual hgeCallback	CALL	System_GetStateFunc  (hgeFuncState   state) = 0;
+	virtual HWND		CALL	System_GetStateHwnd  (hgeHwndState   state) = 0;
+	virtual int			CALL	System_GetStateInt   (hgeIntState    state) = 0;
+	virtual const char*	CALL	System_GetStateString(hgeStringState state) = 0;
+
+public:
+	inline void					System_SetState(hgeBoolState   state, bool        value) { System_SetStateBool  (state, value); }
+	inline void					System_SetState(hgeFuncState   state, hgeCallback value) { System_SetStateFunc  (state, value); }
+	inline void					System_SetState(hgeHwndState   state, HWND        value) { System_SetStateHwnd  (state, value); }
+	inline void					System_SetState(hgeIntState    state, int         value) { System_SetStateInt   (state, value); }
+	inline void					System_SetState(hgeStringState state, const char *value) { System_SetStateString(state, value); }
+	inline bool					System_GetState(hgeBoolState   state) { return System_GetStateBool  (state); }
+	inline hgeCallback			System_GetState(hgeFuncState   state) { return System_GetStateFunc  (state); }
+	inline HWND					System_GetState(hgeHwndState   state) { return System_GetStateHwnd  (state); }
+	inline int					System_GetState(hgeIntState    state) { return System_GetStateInt   (state); }
+	inline const char*			System_GetState(hgeStringState state) { return System_GetStateString(state); }
+
+	virtual void*		CALL	Resource_Load(const char *filename, DWORD *size=0) = 0;
+	virtual void		CALL	Resource_Free(void *res) = 0;
+	virtual bool		CALL	Resource_AttachPack(const char *filename, const char *password=0) = 0;
+	virtual void		CALL	Resource_RemovePack(const char *filename) = 0;
+	virtual void		CALL	Resource_RemoveAllPacks() = 0;
+	virtual char*		CALL	Resource_MakePath(const char *filename=0) = 0;
+	virtual char*		CALL	Resource_EnumFiles(const char *wildcard=0) = 0;
+	virtual char*		CALL	Resource_EnumFolders(const char *wildcard=0) = 0;
+
+	virtual	void		CALL	Ini_SetInt(const char *section, const char *name, int value) = 0;
+	virtual	int			CALL	Ini_GetInt(const char *section, const char *name, int def_val) = 0;
+	virtual	void		CALL	Ini_SetFloat(const char *section, const char *name, float value) = 0;
+	virtual	float		CALL	Ini_GetFloat(const char *section, const char *name, float def_val) = 0;
+	virtual	void		CALL	Ini_SetString(const char *section, const char *name, const char *value) = 0;
+	virtual	char*		CALL	Ini_GetString(const char *section, const char *name, const char *def_val) = 0;
+
+	virtual void		CALL	Random_Seed(int seed=0) = 0;
+	virtual int			CALL	Random_Int(int min, int max) = 0;
+	virtual float		CALL	Random_Float(float min, float max) = 0;
+
+	virtual float		CALL	Timer_GetTime() = 0;
+	virtual float		CALL	Timer_GetDelta() = 0;
+	virtual int			CALL	Timer_GetFPS() = 0;
+
+	virtual HEFFECT		CALL	Effect_Load(const char *filename, DWORD size=0) = 0;
+	virtual void		CALL	Effect_Free(HEFFECT eff) = 0;
+	virtual HCHANNEL	CALL 	Effect_Play(HEFFECT eff) = 0;
+	virtual HCHANNEL	CALL	Effect_PlayEx(HEFFECT eff, int volume=100, int pan=0, float pitch=1.0f, bool loop=false) = 0;
+
+	virtual HMUSIC		CALL	Music_Load(const char *filename, DWORD size=0) = 0;
+	virtual void		CALL	Music_Free(HMUSIC mus) = 0;
+	virtual HCHANNEL	CALL	Music_Play(HMUSIC mus, bool loop, int volume = 100, int order = -1, int row = -1) = 0;
+	virtual void		CALL	Music_SetAmplification(HMUSIC music, int ampl) = 0;
+	virtual int			CALL	Music_GetAmplification(HMUSIC music) = 0;
+	virtual int			CALL	Music_GetLength(HMUSIC music) = 0;
+	virtual void		CALL	Music_SetPos(HMUSIC music, int order, int row) = 0;
+	virtual bool		CALL	Music_GetPos(HMUSIC music, int *order, int *row) = 0;
+	virtual void		CALL	Music_SetInstrVolume(HMUSIC music, int instr, int volume) = 0;
+	virtual int			CALL	Music_GetInstrVolume(HMUSIC music, int instr) = 0;
+	virtual void		CALL	Music_SetChannelVolume(HMUSIC music, int channel, int volume) = 0;
+	virtual int			CALL	Music_GetChannelVolume(HMUSIC music, int channel) = 0;
+
+	virtual HSTREAM		CALL	Stream_Load(const char *filename, DWORD size=0) = 0;
+	virtual void		CALL	Stream_Free(HSTREAM stream) = 0;
+	virtual HCHANNEL	CALL	Stream_Play(HSTREAM stream, bool loop, int volume = 100) = 0;
+
+	virtual void		CALL	Channel_SetPanning(HCHANNEL chn, int pan) = 0;
+	virtual void		CALL 	Channel_SetVolume(HCHANNEL chn, int volume) = 0;
+	virtual void		CALL 	Channel_SetPitch(HCHANNEL chn, float pitch) = 0;
+	virtual void		CALL 	Channel_Pause(HCHANNEL chn) = 0;
+	virtual void		CALL 	Channel_Resume(HCHANNEL chn) = 0;
+	virtual void		CALL 	Channel_Stop(HCHANNEL chn) = 0;
+	virtual void		CALL 	Channel_PauseAll() = 0;
+	virtual void		CALL 	Channel_ResumeAll() = 0;
+	virtual void		CALL 	Channel_StopAll() = 0;
+	virtual bool		CALL	Channel_IsPlaying(HCHANNEL chn) = 0;
+	virtual float		CALL	Channel_GetLength(HCHANNEL chn) = 0;
+	virtual float		CALL	Channel_GetPos(HCHANNEL chn) = 0;
+	virtual void		CALL	Channel_SetPos(HCHANNEL chn, float fSeconds) = 0;
+	virtual int			CALL	Channel_GetPos_BySample(HCHANNEL chn) = 0;
+	virtual void		CALL	Channel_SetPos_BySample(HCHANNEL chn, int iSample) = 0;
+	virtual void		CALL	Channel_SlideTo(HCHANNEL channel, float time, int volume, int pan = -101, float pitch = -1) = 0;
+	virtual bool		CALL	Channel_IsSliding(HCHANNEL channel) = 0;
+
+	virtual void		CALL	Input_GetMousePos(float *x, float *y) = 0;
+	virtual void		CALL	Input_SetMousePos(float x, float y) = 0;
+	virtual int			CALL	Input_GetMouseWheel() = 0;
+	virtual bool		CALL	Input_IsMouseOver() = 0;
+	virtual bool		CALL	Input_KeyDown(int key) = 0;
+	virtual bool		CALL	Input_KeyUp(int key) = 0;
+	virtual bool		CALL	Input_GetKeyState(int key) = 0;
+	virtual int			CALL	Input_GetKeyStateEx(int key) = 0;
+	virtual const char*		CALL	Input_GetKeyName(int key) = 0;
+	virtual int			CALL	Input_GetKey() = 0;
+	virtual int			CALL	Input_GetChar() = 0;
+	virtual bool		CALL	Input_GetEvent(hgeInputEvent *event) = 0;
+
+	virtual bool		CALL	Gfx_BeginScene(HTARGET target=0) = 0;
+	virtual void		CALL	Gfx_EndScene() = 0;
+	virtual void		CALL	Gfx_Clear(DWORD color) = 0;
+	virtual void		CALL	Gfx_RenderLine(float x1, float y1, float x2, float y2, DWORD color=0xFFFFFFFF, float z=0.5f) = 0;
+	virtual void		CALL	Gfx_RenderTriple(const hgeTriple *triple) = 0;
+	virtual void		CALL	Gfx_RenderQuad(const hgeQuad *quad) = 0;
+	virtual hgeVertex*	CALL	Gfx_StartBatch(int prim_type, HTEXTURE tex, int blend, int *max_prim) = 0;
+	virtual void		CALL	Gfx_FinishBatch(int nprim) = 0;
+	virtual void		CALL	Gfx_SetClipping(int x=0, int y=0, int w=0, int h=0) = 0;
+	virtual void		CALL	Gfx_SetTransform(float x=0, float y=0, float dx=0, float dy=0, float rot=0, float hscale=0, float vscale=0) = 0;
+
+	virtual HTARGET		CALL	Target_Create(int width, int height, bool zbuffer) = 0;
+	virtual void		CALL	Target_Free(HTARGET target) = 0;
+	virtual HTEXTURE	CALL	Target_GetTexture(HTARGET target) = 0;
+
+	virtual HTEXTURE	CALL	Texture_Create(int width, int height) = 0;
+	virtual HTEXTURE	CALL	Texture_Load(const char *filename, DWORD size=0, bool bMipmap=false) = 0;
+	virtual void		CALL	Texture_Free(HTEXTURE tex) = 0;
+	virtual int			CALL	Texture_GetWidth(HTEXTURE tex, bool bOriginal=false) = 0;
+	virtual int			CALL	Texture_GetHeight(HTEXTURE tex, bool bOriginal=false) = 0;
+	virtual DWORD*		CALL	Texture_Lock(HTEXTURE tex, bool bReadOnly=true, int left=0, int top=0, int width=0, int height=0) = 0;
+	virtual void		CALL	Texture_Unlock(HTEXTURE tex) = 0;
+};
+
+extern "C" { EXPORT HGE * CALL hgeCreate(int ver); }
+
+
+/*
+** HGE Virtual-key codes
+*/
+#define HGEK_LBUTTON	0x01
+#define HGEK_RBUTTON	0x02
+#define HGEK_MBUTTON	0x04
+
+#define HGEK_ESCAPE		0x1B
+#define HGEK_BACKSPACE	0x08
+#define HGEK_TAB		0x09
+#define HGEK_ENTER		0x0D
+#define HGEK_SPACE		0x20
+
+#define HGEK_SHIFT		0x10
+#define HGEK_CTRL		0x11
+#define HGEK_ALT		0x12
+
+#define HGEK_LWIN		0x5B
+#define HGEK_RWIN		0x5C
+#define HGEK_APPS		0x5D
+
+#define HGEK_PAUSE		0x13
+#define HGEK_CAPSLOCK	0x14
+#define HGEK_NUMLOCK	0x90
+#define HGEK_SCROLLLOCK	0x91
+
+#define HGEK_PGUP		0x21
+#define HGEK_PGDN		0x22
+#define HGEK_HOME		0x24
+#define HGEK_END		0x23
+#define HGEK_INSERT		0x2D
+#define HGEK_DELETE		0x2E
+
+#define HGEK_LEFT		0x25
+#define HGEK_UP			0x26
+#define HGEK_RIGHT		0x27
+#define HGEK_DOWN		0x28
+
+#define HGEK_0			0x30
+#define HGEK_1			0x31
+#define HGEK_2			0x32
+#define HGEK_3			0x33
+#define HGEK_4			0x34
+#define HGEK_5			0x35
+#define HGEK_6			0x36
+#define HGEK_7			0x37
+#define HGEK_8			0x38
+#define HGEK_9			0x39
+
+#define HGEK_A			0x41
+#define HGEK_B			0x42
+#define HGEK_C			0x43
+#define HGEK_D			0x44
+#define HGEK_E			0x45
+#define HGEK_F			0x46
+#define HGEK_G			0x47
+#define HGEK_H			0x48
+#define HGEK_I			0x49
+#define HGEK_J			0x4A
+#define HGEK_K			0x4B
+#define HGEK_L			0x4C
+#define HGEK_M			0x4D
+#define HGEK_N			0x4E
+#define HGEK_O			0x4F
+#define HGEK_P			0x50
+#define HGEK_Q			0x51
+#define HGEK_R			0x52
+#define HGEK_S			0x53
+#define HGEK_T			0x54
+#define HGEK_U			0x55
+#define HGEK_V			0x56
+#define HGEK_W			0x57
+#define HGEK_X			0x58
+#define HGEK_Y			0x59
+#define HGEK_Z			0x5A
+
+#define HGEK_GRAVE		0xC0
+#define HGEK_MINUS		0xBD
+#define HGEK_EQUALS		0xBB
+#define HGEK_BACKSLASH	0xDC
+#define HGEK_LBRACKET	0xDB
+#define HGEK_RBRACKET	0xDD
+#define HGEK_SEMICOLON	0xBA
+#define HGEK_APOSTROPHE	0xDE
+#define HGEK_COMMA		0xBC
+#define HGEK_PERIOD		0xBE
+#define HGEK_SLASH		0xBF
+
+#define HGEK_NUMPAD0	0x60
+#define HGEK_NUMPAD1	0x61
+#define HGEK_NUMPAD2	0x62
+#define HGEK_NUMPAD3	0x63
+#define HGEK_NUMPAD4	0x64
+#define HGEK_NUMPAD5	0x65
+#define HGEK_NUMPAD6	0x66
+#define HGEK_NUMPAD7	0x67
+#define HGEK_NUMPAD8	0x68
+#define HGEK_NUMPAD9	0x69
+
+#define HGEK_MULTIPLY	0x6A
+#define HGEK_DIVIDE		0x6F
+#define HGEK_ADD		0x6B
+#define HGEK_SUBTRACT	0x6D
+#define HGEK_DECIMAL	0x6E
+
+#define HGEK_F1			0x70
+#define HGEK_F2			0x71
+#define HGEK_F3			0x72
+#define HGEK_F4			0x73
+#define HGEK_F5			0x74
+#define HGEK_F6			0x75
+#define HGEK_F7			0x76
+#define HGEK_F8			0x77
+#define HGEK_F9			0x78
+#define HGEK_F10		0x79
+#define HGEK_F11		0x7A
+#define HGEK_F12		0x7B
+
+#define HGEKST_NONE		0
+#define HGEKST_HIT		1
+#define HGEKST_KEEP		2
+#define HGEKST_RELEASE	3
+
+#endif
+
diff --git a/include/hgeanim.h b/include/hgeanim.h
new file mode 100644
index 0000000..7c5f237
--- /dev/null
+++ b/include/hgeanim.h
@@ -0,0 +1,69 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeAnimation helper class header
+*/
+
+
+#ifndef HGEANIM_H
+#define HGEANIM_H
+
+
+#include "hgesprite.h"
+
+
+#define HGEANIM_FWD			0
+#define HGEANIM_REV			1
+#define HGEANIM_PINGPONG	2
+#define HGEANIM_NOPINGPONG	0
+#define HGEANIM_LOOP		4
+#define HGEANIM_NOLOOP		0
+
+
+/*
+** HGE Animation class
+*/
+class hgeAnimation : public hgeSprite
+{
+public:
+	hgeAnimation(HTEXTURE tex, int nframes, float FPS, float x, float y, float w, float h);
+	hgeAnimation(const hgeAnimation &anim);
+	
+	void		Play();
+	void		Stop() { bPlaying=false; }
+	void		Resume() { bPlaying=true; }
+	void		Update(float fDeltaTime);
+	bool		IsPlaying() const { return bPlaying; }
+
+	void		SetTexture(HTEXTURE tex) { hgeSprite::SetTexture(tex); orig_width = hge->Texture_GetWidth(tex, true); }
+	void		SetTextureRect(float x1, float y1, float x2, float y2) { hgeSprite::SetTextureRect(x1,y1,x2,y2); SetFrame(nCurFrame); }
+	void		SetMode(int mode);
+	void		SetSpeed(float FPS) { fSpeed=1.0f/FPS; }
+	void		SetFrame(int n);
+	void		SetFrames(int n) { nFrames=n; }
+
+	int			GetMode() const { return Mode; }
+	float		GetSpeed() const { return 1.0f/fSpeed; }
+	int			GetFrame() const { return nCurFrame; }
+	int			GetFrames() const { return nFrames; }
+
+private:
+	hgeAnimation();
+
+	int			orig_width;
+
+	bool		bPlaying;
+
+	float		fSpeed;
+	float		fSinceLastFrame;
+
+	int			Mode;
+	int			nDelta;
+	int			nFrames;
+	int			nCurFrame;
+};
+
+
+#endif
diff --git a/include/hgecolor.h b/include/hgecolor.h
new file mode 100644
index 0000000..7cd4d82
--- /dev/null
+++ b/include/hgecolor.h
@@ -0,0 +1,80 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeColor*** helper classes
+*/
+
+
+#ifndef HGECOLOR_H
+#define HGECOLOR_H
+
+
+#include "hge.h"
+
+
+#define hgeColor hgeColorRGB
+
+inline void ColorClamp(float &x) { if(x<0.0f) x=0.0f; if(x>1.0f) x=1.0f; }
+
+
+class hgeColorRGB
+{
+public:
+	float		r,g,b,a;
+
+	hgeColorRGB(float _r, float _g, float _b, float _a) { r=_r; g=_g; b=_b; a=_a; }
+	hgeColorRGB(DWORD col) { SetHWColor(col); }
+	hgeColorRGB() { r=g=b=a=0; }
+
+	hgeColorRGB		operator-  (const hgeColorRGB &c) const { return hgeColorRGB(r-c.r, g-c.g, b-c.b, a-c.a); }
+	hgeColorRGB		operator+  (const hgeColorRGB &c) const { return hgeColorRGB(r+c.r, g+c.g, b+c.b, a+c.a); }
+	hgeColorRGB		operator*  (const hgeColorRGB &c) const { return hgeColorRGB(r*c.r, g*c.g, b*c.b, a*c.a); }
+	hgeColorRGB&	operator-= (const hgeColorRGB &c)		{ r-=c.r; g-=c.g; b-=c.b; a-=c.a; return *this;   }
+	hgeColorRGB&	operator+= (const hgeColorRGB &c)		{ r+=c.r; g+=c.g; b+=c.b; a+=c.a; return *this;   }
+	bool			operator== (const hgeColorRGB &c) const { return (r==c.r && g==c.g && b==c.b && a==c.a);  }
+	bool			operator!= (const hgeColorRGB &c) const { return (r!=c.r || g!=c.g || b!=c.b || a!=c.a);  }
+
+	hgeColorRGB		operator/  (const float scalar) const { return hgeColorRGB(r/scalar, g/scalar, b/scalar, a/scalar); }
+	hgeColorRGB		operator*  (const float scalar) const { return hgeColorRGB(r*scalar, g*scalar, b*scalar, a*scalar); }
+	hgeColorRGB&	operator*= (const float scalar)		  { r*=scalar; g*=scalar; b*=scalar; a*=scalar; return *this;   }
+
+	void			Clamp() { ColorClamp(r); ColorClamp(g); ColorClamp(b); ColorClamp(a); }
+	void			SetHWColor(DWORD col) {	a = (col>>24)/255.0f; r = ((col>>16) & 0xFF)/255.0f; g = ((col>>8) & 0xFF)/255.0f; b = (col & 0xFF)/255.0f;	}
+	DWORD			GetHWColor() const { return (DWORD(a*255.0f)<<24) + (DWORD(r*255.0f)<<16) + (DWORD(g*255.0f)<<8) + DWORD(b*255.0f);	}
+};
+
+inline hgeColorRGB operator* (const float sc, const hgeColorRGB &c) { return c*sc; }
+
+
+class hgeColorHSV
+{
+public:
+	float		h,s,v,a;
+
+	hgeColorHSV(float _h, float _s, float _v, float _a) { h=_h; s=_s; v=_v; a=_a; }
+	hgeColorHSV(DWORD col) { SetHWColor(col); }
+	hgeColorHSV() { h=s=v=a=0; }
+
+	hgeColorHSV		operator-  (const hgeColorHSV &c) const { return hgeColorHSV(h-c.h, s-c.s, v-c.v, a-c.a); }
+	hgeColorHSV		operator+  (const hgeColorHSV &c) const { return hgeColorHSV(h+c.h, s+c.s, v+c.v, a+c.a); }
+	hgeColorHSV		operator*  (const hgeColorHSV &c) const { return hgeColorHSV(h*c.h, s*c.s, v*c.v, a*c.a); }
+	hgeColorHSV&	operator-= (const hgeColorHSV &c)		{ h-=c.h; s-=c.s; v-=c.v; a-=c.a; return *this;   }
+	hgeColorHSV&	operator+= (const hgeColorHSV &c)		{ h+=c.h; s+=c.s; v+=c.v; a+=c.a; return *this;   }
+	bool			operator== (const hgeColorHSV &c) const { return (h==c.h && s==c.s && v==c.v && a==c.a);  }
+	bool			operator!= (const hgeColorHSV &c) const { return (h!=c.h || s!=c.s || v!=c.v || a!=c.a);  }
+
+	hgeColorHSV		operator/  (const float scalar) const { return hgeColorHSV(h/scalar, s/scalar, v/scalar, a/scalar); }
+	hgeColorHSV		operator*  (const float scalar) const { return hgeColorHSV(h*scalar, s*scalar, v*scalar, a*scalar); }
+	hgeColorHSV&	operator*= (const float scalar)		  { h*=scalar; s*=scalar; v*=scalar; a*=scalar; return *this;   }
+
+	void			Clamp() { ColorClamp(h); ColorClamp(s); ColorClamp(v); ColorClamp(a); }
+	void			SetHWColor(DWORD col);
+	DWORD			GetHWColor() const;
+};
+
+inline hgeColorHSV operator* (const float sc, const hgeColorHSV &c) { return c*sc; }
+
+
+#endif
diff --git a/include/hgedistort.h b/include/hgedistort.h
new file mode 100644
index 0000000..3c8f449
--- /dev/null
+++ b/include/hgedistort.h
@@ -0,0 +1,66 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeDistortionMesh helper class header
+*/
+
+
+#ifndef HGEDISTORT_H
+#define HGEDISTORT_H
+
+
+#include "hge.h"
+
+
+#define HGEDISP_NODE		0
+#define HGEDISP_TOPLEFT		1
+#define HGEDISP_CENTER		2
+
+/*
+** HGE Distortion mesh class
+*/
+class hgeDistortionMesh
+{
+public:
+     hgeDistortionMesh(int cols, int rows);
+     hgeDistortionMesh(const hgeDistortionMesh &dm);
+     ~hgeDistortionMesh();
+
+	 hgeDistortionMesh&	operator= (const hgeDistortionMesh &dm);
+
+     void		Render(float x, float y);
+     void		Clear(DWORD col=0xFFFFFFFF, float z=0.5f);
+
+     void		SetTexture(HTEXTURE tex);
+     void		SetTextureRect(float x, float y, float w, float h);
+     void		SetBlendMode(int blend);
+     void		SetZ(int col, int row, float z);
+     void		SetColor(int col, int row, DWORD color);
+     void		SetDisplacement(int col, int row, float dx, float dy, int ref);
+
+     HTEXTURE	GetTexture() const {return quad.tex;}
+     void		GetTextureRect(float *x, float *y, float *w, float *h) const { *x=tx; *y=ty; *w=width; *h=height; }
+     int		GetBlendMode() const { return quad.blend; }
+     float		GetZ(int col, int row) const;
+     DWORD		GetColor(int col, int row) const;
+     void		GetDisplacement(int col, int row, float *dx, float *dy, int ref) const;
+
+	 int		GetRows() { return nRows; }
+	 int		GetCols() { return nCols; }
+
+private:
+	hgeDistortionMesh();
+
+	static HGE	*hge;
+
+	hgeVertex	*disp_array;
+	int			nRows, nCols;
+	float		cellw,cellh;
+	float		tx,ty,width,height;
+	hgeQuad		quad;
+};
+
+
+#endif
diff --git a/include/hgefont.h b/include/hgefont.h
new file mode 100644
index 0000000..403d307
--- /dev/null
+++ b/include/hgefont.h
@@ -0,0 +1,94 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeFont helper class header
+*/
+
+
+#ifndef HGEFONT_H
+#define HGEFONT_H
+
+
+#include "hge.h"
+#include "hgesprite.h"
+
+
+#define HGETEXT_LEFT		0
+#define HGETEXT_RIGHT		1
+#define HGETEXT_CENTER		2
+#define HGETEXT_HORZMASK	0x03
+
+#define HGETEXT_TOP			0
+#define HGETEXT_BOTTOM		4
+#define HGETEXT_MIDDLE		8
+#define HGETEXT_VERTMASK	0x0C
+
+/*
+** HGE Font class
+*/
+class hgeFont
+{
+public:
+	hgeFont(const char *filename, bool bMipmap=false);
+	~hgeFont();
+
+	void		Render(float x, float y, int align, const char *string);
+	void		printf(float x, float y, int align, const char *format, ...);
+	void		printfb(float x, float y, float w, float h, int align, const char *format, ...);
+
+	void		SetColor(DWORD col);
+	void		SetZ(float z);
+	void		SetBlendMode(int blend);
+	void		SetScale(float scale) {fScale=scale;}
+	void		SetProportion(float prop) { fProportion=prop; }
+	void		SetRotation(float rot) {fRot=rot;}
+	void		SetTracking(float tracking) {fTracking=tracking;}
+	void		SetSpacing(float spacing) {fSpacing=spacing;}
+
+	DWORD		GetColor() const {return dwCol;}
+	float		GetZ() const {return fZ;}
+	int			GetBlendMode() const {return nBlend;}
+	float		GetScale() const {return fScale;}
+	float		GetProportion() const { return fProportion; }
+	float		GetRotation() const {return fRot;}
+	float		GetTracking() const {return fTracking;}
+	float		GetSpacing() const {return fSpacing;}
+
+	hgeSprite*	GetSprite(char chr) const { return letters[(unsigned char)chr]; }
+	float		GetPreWidth(char chr) const { return pre[(unsigned char)chr]; }
+	float		GetPostWidth(char chr) const { return post[(unsigned char)chr]; }
+	float		GetHeight() const { return fHeight; }
+	float		GetStringWidth(const char *string, bool bMultiline=true) const;
+	
+	HTEXTURE	GetTexture(){return hTexture;}
+private:
+	hgeFont();
+	hgeFont(const hgeFont &fnt);
+	hgeFont&	operator= (const hgeFont &fnt);
+
+	char*		_get_line(char *file, char *line);
+
+	static HGE	*hge;
+
+	static char	buffer[1024];
+
+	HTEXTURE	hTexture;
+	hgeSprite*	letters[256];
+	float		pre[256];
+	float		post[256];
+	float		fHeight;
+	float		fScale;
+	float		fProportion;
+	float		fRot;
+	float		fTracking;
+	float		fSpacing;
+
+	DWORD		dwCol;
+	float		fZ;
+	int			nBlend;
+};
+
+
+#endif
diff --git a/include/hgegui.h b/include/hgegui.h
new file mode 100644
index 0000000..7e2144b
--- /dev/null
+++ b/include/hgegui.h
@@ -0,0 +1,126 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeGUI helper classes header
+*/
+
+
+#ifndef HGEGUI_H
+#define HGEGUI_H
+
+
+#include "hge.h"
+#include "hgesprite.h"
+#include "hgerect.h"
+
+
+#define HGEGUI_NONAVKEYS		0
+#define HGEGUI_LEFTRIGHT		1
+#define HGEGUI_UPDOWN			2
+#define HGEGUI_CYCLED			4
+
+class hgeGUI;
+
+/*
+** hgeGUIObject
+*/
+class hgeGUIObject
+{
+public:
+	hgeGUIObject()	{ hge=hgeCreate(HGE_VERSION); color=0xFFFFFFFF; }
+	virtual			~hgeGUIObject() { hge->Release(); }
+
+	virtual void	Render() = 0;
+	virtual void	Update(float dt) {}
+
+	virtual void	Enter() {}
+	virtual void	Leave() {}
+	virtual void	Reset() {}
+	virtual bool	IsDone() { return true; }
+	virtual void	Focus(bool bFocused) {}
+	virtual void	MouseOver(bool bOver) {}
+
+	virtual bool	MouseMove(float x, float y) { return false; }
+	virtual bool	MouseLButton(bool bDown) { return false; }
+	virtual bool	MouseRButton(bool bDown) { return false; }
+	virtual bool	MouseWheel(int nNotches) { return false; }
+	virtual bool	KeyClick(int key, int chr) { return false; }
+
+	virtual void	SetColor(DWORD _color) { color=_color; }
+	
+	int				id;
+	bool			bStatic;
+	bool			bVisible;
+	bool			bEnabled;
+	hgeRect			rect;
+	DWORD			color;
+
+	hgeGUI			*gui;
+	hgeGUIObject	*next;
+	hgeGUIObject	*prev;
+
+protected:
+	hgeGUIObject(const hgeGUIObject &go);
+	hgeGUIObject&	operator= (const hgeGUIObject &go);
+
+	static HGE		*hge;
+};
+
+
+/*
+** hgeGUI
+*/
+class hgeGUI
+{
+public:
+	hgeGUI();
+	~hgeGUI();
+
+	void			AddCtrl(hgeGUIObject *ctrl);
+	void			DelCtrl(int id);
+	hgeGUIObject*	GetCtrl(int id) const;
+
+	void			MoveCtrl(int id, float x, float y);
+	void			ShowCtrl(int id, bool bVisible);
+	void			EnableCtrl(int id, bool bEnabled);
+
+	void			SetNavMode(int mode);
+	void			SetCursor(hgeSprite *spr);
+	void			SetColor(DWORD color);
+	void			SetFocus(int id);
+	int				GetFocus() const;
+	
+	void			Enter();
+	void			Leave();
+	void			Reset();
+	void			Move(float dx, float dy);
+
+	int				Update(float dt);
+	void			Render();
+
+private:
+	hgeGUI(const hgeGUI &);
+	hgeGUI&			operator= (const hgeGUI&);
+	bool			ProcessCtrl(hgeGUIObject *ctrl);
+
+	static HGE		*hge;
+
+	hgeGUIObject	*ctrls;
+	hgeGUIObject	*ctrlLock;
+	hgeGUIObject	*ctrlFocus;
+	hgeGUIObject	*ctrlOver;
+
+	int				navmode;
+	int				nEnterLeave;
+	hgeSprite		*sprCursor;
+
+	float			mx,my;
+	int				nWheel;
+	bool			bLPressed, bLReleased;
+	bool			bRPressed, bRReleased;
+};
+
+
+#endif
diff --git a/include/hgeguictrls.h b/include/hgeguictrls.h
new file mode 100644
index 0000000..8a1addd
--- /dev/null
+++ b/include/hgeguictrls.h
@@ -0,0 +1,150 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeGUI default controls header
+*/
+
+
+#ifndef HGEGUICTRLS_H
+#define HGEGUICTRLS_H
+
+
+#include "hge.h"
+#include "hgesprite.h"
+#include "hgefont.h"
+#include "hgerect.h"
+#include "hgegui.h"
+
+
+#define hgeButtonGetState(gui,id)		((hgeGUIButton*)gui->GetCtrl(id))->GetState()
+#define hgeButtonSetState(gui,id,b)		((hgeGUIButton*)gui->GetCtrl(id))->SetState(b)
+#define hgeSliderGetValue(gui,id)		((hgeGUISlider*)gui->GetCtrl(id))->GetValue()
+#define hgeSliderSetValue(gui,id,f)		((hgeGUISlider*)gui->GetCtrl(id))->SetValue(f)
+#define hgeGetTextCtrl(gui,id)			((hgeGUIText*)gui->GetCtrl(id))
+#define hgeGetListboxCtrl(gui,id)		((hgeGUIListbox*)gui->GetCtrl(id))
+
+
+/*
+** hgeGUIText
+*/
+class hgeGUIText : public hgeGUIObject
+{
+public:
+	hgeGUIText(int id, float x, float y, float w, float h, hgeFont *fnt);
+
+	void			SetMode(int _align);
+	void			SetText(const char *_text);
+	void			printf(const char *format, ...);
+
+	virtual void	Render();
+
+private:
+	hgeFont*		font;
+	float			tx, ty;
+	int				align;
+	char			text[256];
+};
+
+
+/*
+** hgeGUIButton
+*/
+class hgeGUIButton : public hgeGUIObject
+{
+public:
+	hgeGUIButton(int id, float x, float y, float w, float h, HTEXTURE tex, float tx, float ty);
+	virtual			~hgeGUIButton();
+
+	void			SetMode(bool _bTrigger) { bTrigger=_bTrigger; }
+	void			SetState(bool _bPressed) { bPressed=_bPressed; }
+	bool			GetState() const { return bPressed; }
+
+	virtual void	Render();
+	virtual bool	MouseLButton(bool bDown);
+
+private:
+	bool			bTrigger;
+	bool			bPressed;
+	bool			bOldState;
+	hgeSprite		*sprUp, *sprDown;
+};
+
+
+/*
+** hgeGUISlider
+*/
+#define HGESLIDER_BAR			0
+#define HGESLIDER_BARRELATIVE	1
+#define HGESLIDER_SLIDER		2
+
+class hgeGUISlider : public hgeGUIObject
+{
+public:
+	hgeGUISlider(int id, float x, float y, float w, float h, HTEXTURE tex, float tx, float ty, float sw, float sh, bool vertical=false);
+	virtual			~hgeGUISlider();
+
+	void			SetMode(float _fMin, float _fMax, int _mode) { fMin=_fMin; fMax=_fMax; mode=_mode; }
+	void			SetValue(float _fVal);
+	float			GetValue() const { return fVal; }
+
+	virtual void	Render();
+	virtual bool	MouseMove(float x, float y);
+	virtual bool	MouseLButton(bool bDown);
+
+private:
+	bool			bPressed;
+	bool			bVertical;
+	int				mode;
+	float			fMin, fMax, fVal;
+	float			sl_w, sl_h;
+	hgeSprite		*sprSlider;
+};
+
+
+/*
+** hgeGUIListbox
+*/
+struct hgeGUIListboxItem
+{
+	char				text[64];
+	hgeGUIListboxItem	*next;
+};
+
+class hgeGUIListbox : public hgeGUIObject
+{
+public:
+	hgeGUIListbox(int id, float x, float y, float w, float h, hgeFont *fnt, DWORD tColor, DWORD thColor, DWORD hColor);
+	virtual			~hgeGUIListbox();
+
+	int				AddItem(char *item);
+	void			DeleteItem(int n);
+	int				GetSelectedItem() { return nSelectedItem; }
+	void			SetSelectedItem(int n) { if(n>=0 && n<GetNumItems()) nSelectedItem=n; }
+	int				GetTopItem() { return nTopItem; }
+	void			SetTopItem(int n) { if(n>=0 && n<=GetNumItems()-GetNumRows()) nTopItem=n; }
+
+	char			*GetItemText(int n);
+	int				GetNumItems() { return nItems; }
+	int				GetNumRows() { return int((rect.y2-rect.y1)/font->GetHeight()); }
+	void			Clear();
+
+	virtual void	Render();
+	virtual bool	MouseMove(float x, float y) { mx=x; my=y; return false; }
+	virtual bool	MouseLButton(bool bDown);
+	virtual bool	MouseWheel(int nNotches);
+	virtual bool	KeyClick(int key, int chr);
+
+private:
+	hgeSprite		*sprHighlight;
+	hgeFont			*font;
+	DWORD			textColor, texthilColor;
+
+	int					nItems, nSelectedItem, nTopItem;
+	float				mx, my;
+	hgeGUIListboxItem	*pItems;
+};
+
+
+#endif
diff --git a/include/hgeparticle.h b/include/hgeparticle.h
new file mode 100644
index 0000000..fd1e622
--- /dev/null
+++ b/include/hgeparticle.h
@@ -0,0 +1,168 @@
+// PLEASE NOTE that this is not the 1.81 version of hgeparticle.h ...
+//  the game I'm working on used an older HGE that breaks with the 1.81
+//  particle system. If you want 1.81, add the "bRelative" stuff to it.  --ryan.
+
+/*
+** Haaf's Game Engine 1.61
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeParticleSystem helper class header
+*/
+
+
+#ifndef HGEPARTICLE_H
+#define HGEPARTICLE_H
+
+
+#include "hge.h"
+#include "hgesprite.h"
+#include "hgevector.h"
+#include "hgecolor.h"
+#include "hgerect.h"
+
+
+#define MAX_PARTICLES	500
+#define MAX_PSYSTEMS	100
+
+struct hgeParticle
+{
+	hgeVector	vecLocation;
+	hgeVector	vecVelocity;
+
+	float		fGravity;
+	float		fRadialAccel;
+	float		fTangentialAccel;
+
+	float		fSpin;
+	float		fSpinDelta;
+
+	float		fSize;
+	float		fSizeDelta;
+
+	hgeColor	colColor;		// + alpha
+	hgeColor	colColorDelta;
+
+	float		fAge;
+	float		fTerminalAge;
+};
+
+struct hgeParticleSystemInfo
+{
+	hgeSprite*	sprite;    // texture + blend mode
+	int			nEmission; // particles per sec
+	float		fLifetime;
+
+	float		fParticleLifeMin;
+	float		fParticleLifeMax;
+
+	float		fDirection;
+	float		fSpread;
+	BYTE		bRelative;  // was "bool", but that's 4 bytes on PowerPC instead of 1, and it broke loading from disk...
+
+	float		fSpeedMin;
+	float		fSpeedMax;
+
+	float		fGravityMin;
+	float		fGravityMax;
+
+	float		fRadialAccelMin;
+	float		fRadialAccelMax;
+
+	float		fTangentialAccelMin;
+	float		fTangentialAccelMax;
+
+	float		fSizeStart;
+	float		fSizeEnd;
+	float		fSizeVar;
+
+	float		fSpinStart;
+	float		fSpinEnd;
+	float		fSpinVar;
+
+	hgeColor	colColorStart; // + alpha
+	hgeColor	colColorEnd;
+	float		fColorVar;
+	float		fAlphaVar;
+};
+
+class hgeParticleSystem
+{
+public:
+	hgeParticleSystemInfo info;
+	
+	hgeParticleSystem(const char *filename, hgeSprite *sprite, float fps=0.0f);
+	hgeParticleSystem(hgeParticleSystemInfo *psi, float fps=0.0f);
+	hgeParticleSystem(const hgeParticleSystem &ps);
+	~hgeParticleSystem() { hge->Release(); }
+
+	hgeParticleSystem&	operator= (const hgeParticleSystem &ps);
+
+
+	void				Render();
+	void				FireAt(float x, float y);
+	void				Fire();
+	void				Stop(bool bKillParticles=false);
+	void				Update(float fDeltaTime);
+	void				MoveTo(float x, float y, bool bMoveParticles=false);
+	void				Transpose(float x, float y) { fTx=x; fTy=y; }
+	void				TrackBoundingBox(bool bTrack) { bUpdateBoundingBox=bTrack; }
+
+	int					GetParticlesAlive() const { return nParticlesAlive; }
+	float				GetAge() const { return fAge; }
+	void				GetPosition(float *x, float *y) const { *x=vecLocation.x; *y=vecLocation.y; }
+	void				GetTransposition(float *x, float *y) const { *x=fTx; *y=fTy; }
+	hgeRect*			GetBoundingBox(hgeRect *rect) const { memcpy(rect, &rectBoundingBox, sizeof(hgeRect)); return rect; }
+
+private:
+	hgeParticleSystem();
+	void				_update(float fDeltaTime);
+
+	static HGE			*hge;
+
+	float				fUpdSpeed;
+	float				fResidue;
+
+	float				fAge;
+	float				fEmissionResidue;
+
+	hgeVector			vecPrevLocation;
+	hgeVector			vecLocation;
+	float				fTx, fTy;
+
+	int					nParticlesAlive;
+	hgeRect				rectBoundingBox;
+	bool				bUpdateBoundingBox;
+
+	hgeParticle			particles[MAX_PARTICLES];
+};
+
+class hgeParticleManager
+{
+public:
+	hgeParticleManager(float fps=0.0f);
+	~hgeParticleManager();
+
+	void				Update(float dt);
+	void				Render();
+
+	hgeParticleSystem*	SpawnPS(hgeParticleSystemInfo *psi, float x, float y);
+	bool				IsPSAlive(hgeParticleSystem *ps) const;
+	void				Transpose(float x, float y);
+	void				GetTransposition(float *dx, float *dy) const {*dx=tX; *dy=tY;}
+	void				KillPS(hgeParticleSystem *ps);
+	void				KillAll();
+
+private:
+	hgeParticleManager(const hgeParticleManager &);
+	hgeParticleManager&	operator= (const hgeParticleManager &);
+
+	float				fFPS;
+	int					nPS;
+	float				tX;
+	float				tY;
+	hgeParticleSystem*	psList[MAX_PSYSTEMS];
+};
+
+
+#endif
diff --git a/include/hgerect.h b/include/hgerect.h
new file mode 100644
index 0000000..9e26907
--- /dev/null
+++ b/include/hgerect.h
@@ -0,0 +1,35 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeRect helper class
+*/
+
+
+#ifndef HGERECT_H
+#define HGERECT_H
+
+
+class hgeRect
+{
+public:
+	float	x1, y1, x2, y2;
+
+	hgeRect(float _x1, float _y1, float _x2, float _y2) {x1=_x1; y1=_y1; x2=_x2; y2=_y2; bClean=false; }
+	hgeRect() {bClean=true;}
+
+	void    Clear() {bClean=true;}
+	bool    IsClean() const {return bClean;}
+	void	Set(float _x1, float _y1, float _x2, float _y2) { x1=_x1; x2=_x2; y1=_y1; y2=_y2; bClean=false; }
+	void	SetRadius(float x, float y, float r) { x1=x-r; x2=x+r; y1=y-r; y2=y+r; bClean=false; }
+	void	Encapsulate(float x, float y);
+	bool	TestPoint(float x, float y) const;
+	bool	Intersect(const hgeRect *rect) const;
+
+private:
+	bool	bClean;
+};
+
+
+#endif
diff --git a/include/hgeresource.h b/include/hgeresource.h
new file mode 100644
index 0000000..ace8f21
--- /dev/null
+++ b/include/hgeresource.h
@@ -0,0 +1,85 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeResourceManager helper class header
+*/
+
+
+#ifndef HGERESOURCE_H
+#define HGERESOURCE_H
+
+
+#include "hge.h"
+#include "hgesprite.h"
+#include "hgeanim.h"
+#include "hgefont.h"
+#include "hgeparticle.h"
+#include "hgedistort.h"
+#include "hgestrings.h"
+
+
+#define RESTYPES 13
+#define MAXRESCHARS 128
+
+
+class hgeResourceManager;
+
+struct ResDesc
+{
+	char		name[MAXRESCHARS];
+	int			resgroup;
+	size_t		handle;
+	ResDesc*	next;
+
+	ResDesc()	{ hge=hgeCreate(HGE_VERSION); }
+	~ResDesc()	{ hge->Release(); }
+
+	virtual DWORD Get(hgeResourceManager *rm) = 0;
+	virtual void  Free() = 0;
+
+protected:
+	static HGE	*hge;
+};
+
+/*
+** HGE Resource manager class
+*/
+class hgeResourceManager
+{
+public:
+	hgeResourceManager(const char *scriptname=0);
+	~hgeResourceManager();
+
+	void				ChangeScript(const char *scriptname=0);
+	bool				Precache(int groupid=0);
+	void				Purge(int groupid=0);
+
+	void*				GetResource(const char *name, int resgroup=0);
+	HTEXTURE			GetTexture(const char *name, int resgroup=0);
+	HEFFECT				GetEffect(const char *name, int resgroup=0);
+	HMUSIC				GetMusic(const char *name, int resgroup=0);
+	HSTREAM				GetStream(const char *name, int resgroup=0);
+	HTARGET				GetTarget(const char *name);
+
+	hgeSprite*			GetSprite(const char *name);
+	hgeAnimation*		GetAnimation(const char *name);
+	hgeFont*			GetFont(const char *name);
+	hgeParticleSystem*	GetParticleSystem(const char *name);
+	hgeDistortionMesh*	GetDistortionMesh(const char *name);
+	hgeStringTable*		GetStringTable(const char *name, int resgroup=0);
+
+	ResDesc*			res[RESTYPES];
+
+private:
+	hgeResourceManager(const hgeResourceManager &);
+	hgeResourceManager&	operator= (const hgeResourceManager&);
+	void				_remove_all();
+	void				_parse_script(const char *scriptname=0);
+
+	static HGE			*hge;
+};
+
+
+#endif
diff --git a/include/hgesprite.h b/include/hgesprite.h
new file mode 100644
index 0000000..e414c02
--- /dev/null
+++ b/include/hgesprite.h
@@ -0,0 +1,67 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeSprite helper class header
+*/
+
+
+#ifndef HGESPRITE_H
+#define HGESPRITE_H
+
+
+#include "hge.h"
+#include "hgerect.h"
+
+
+/*
+** HGE Sprite class
+*/
+class hgeSprite
+{
+public:
+	hgeSprite(HTEXTURE tex, float x, float y, float w, float h);
+	hgeSprite(const hgeSprite &spr);
+	~hgeSprite() { hge->Release(); }
+	
+	
+	void		Render(float x, float y);
+	void		RenderEx(float x, float y, float rot, float hscale=1.0f, float vscale=0.0f);
+	void		RenderStretch(float x1, float y1, float x2, float y2);
+	void		Render4V(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3);
+
+	void		SetTexture(HTEXTURE tex);
+	void		SetTextureRect(float x, float y, float w, float h, bool adjSize = true);
+	void		SetColor(DWORD col, int i=-1);
+	void		SetZ(float z, int i=-1);
+	void		SetBlendMode(int blend) { quad.blend=blend; }
+	void		SetHotSpot(float x, float y) { hotX=x; hotY=y; }
+	void		SetFlip(bool bX, bool bY, bool bHotSpot = false);
+
+	HTEXTURE	GetTexture() const { return quad.tex; }
+	void		GetTextureRect(float *x, float *y, float *w, float *h) const { *x=tx; *y=ty; *w=width; *h=height; }
+	DWORD		GetColor(int i=0) const { return quad.v[i].col; }
+	float		GetZ(int i=0) const { return quad.v[i].z; }
+	int			GetBlendMode() const { return quad.blend; }
+	void		GetHotSpot(float *x, float *y) const { *x=hotX; *y=hotY; }
+	void		GetFlip(bool *bX, bool *bY) const { *bX=bXFlip; *bY=bYFlip; }
+
+	float		GetWidth() const { return width; }
+	float		GetHeight() const { return height; }
+	hgeRect*	GetBoundingBox(float x, float y, hgeRect *rect) const { rect->Set(x-hotX, y-hotY, x-hotX+width, y-hotY+height); return rect; }
+	hgeRect*	GetBoundingBoxEx(float x, float y, float rot, float hscale, float vscale,  hgeRect *rect) const;
+
+protected:
+	hgeSprite();
+	static HGE	*hge;
+
+	hgeQuad		quad;
+	float		tx, ty, width, height;
+	float		tex_width, tex_height;
+	float		hotX, hotY;
+	bool		bXFlip, bYFlip, bHSFlip;
+};
+
+
+#endif
diff --git a/include/hgestrings.h b/include/hgestrings.h
new file mode 100644
index 0000000..e02cbe9
--- /dev/null
+++ b/include/hgestrings.h
@@ -0,0 +1,48 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeStringTable helper class header
+*/
+
+
+#ifndef HGESTRINGS_H
+#define HGESTRINGS_H
+
+
+#include "hge.h"
+
+
+#define MAXSTRNAMELENGTH 64
+
+
+struct NamedString
+{
+	char			name[MAXSTRNAMELENGTH];
+	char			*string;
+	NamedString		*next;
+};
+
+/*
+** HGE String table class
+*/
+class hgeStringTable
+{
+public:
+	hgeStringTable(const char *filename);
+	~hgeStringTable();
+
+	char			*GetString(const char *name);
+
+private:
+	hgeStringTable(const hgeStringTable &);
+	hgeStringTable&	operator= (const hgeStringTable &);
+
+	NamedString		*strings;
+
+	static HGE		*hge;
+};
+
+
+#endif
diff --git a/include/hgevector.h b/include/hgevector.h
new file mode 100644
index 0000000..b86bd01
--- /dev/null
+++ b/include/hgevector.h
@@ -0,0 +1,54 @@
+/*
+** Haaf's Game Engine 1.7
+** Copyright (C) 2003-2007, Relish Games
+** hge.relishgames.com
+**
+** hgeVector helper class
+*/
+
+
+#ifndef HGEVECTOR_H
+#define HGEVECTOR_H
+
+#include <math.h>
+
+/*
+** Fast 1.0/sqrtf(float) routine
+*/
+float InvSqrt(float x);
+
+class hgeVector
+{
+public:
+	float	x,y;
+
+	hgeVector(float _x, float _y)	{ x=_x; y=_y; }
+	hgeVector()						{ x=0; y=0; }
+
+	hgeVector	operator-  ()					const { return hgeVector(-x, -y);		}
+	hgeVector	operator-  (const hgeVector &v) const { return hgeVector(x-v.x, y-v.y); }
+	hgeVector	operator+  (const hgeVector &v) const { return hgeVector(x+v.x, y+v.y); }
+	hgeVector&	operator-= (const hgeVector &v)		  { x-=v.x; y-=v.y; return *this;	}
+	hgeVector&	operator+= (const hgeVector &v)		  { x+=v.x; y+=v.y; return *this;	}
+	bool		operator== (const hgeVector &v)	const { return (x==v.x && y==v.y);		}
+	bool		operator!= (const hgeVector &v)	const { return (x!=v.x || y!=v.y);		}
+
+	hgeVector	operator/  (const float scalar)	const { return hgeVector(x/scalar, y/scalar); }
+	hgeVector	operator*  (const float scalar) const { return hgeVector(x*scalar, y*scalar); }
+	hgeVector&	operator*= (const float scalar)		  { x*=scalar; y*=scalar; return *this;   }
+
+	float		Dot(const hgeVector *v) const { return x*v->x + y*v->y; }
+	float		Length() const { return sqrtf(Dot(this)); }
+	float		Angle(const hgeVector *v = 0) const;
+	
+	void		Clamp(const float max) { if(Length() > max)	{ Normalize(); x *= max; y *= max; } }
+	hgeVector*	Normalize() { float rc=InvSqrt(Dot(this)); x*=rc; y*=rc; return this; }
+	hgeVector*	Rotate(float a);
+};
+
+inline hgeVector operator* (const float s, const hgeVector &v)		{ return v*s; }
+inline float	 operator^ (const hgeVector &v, const hgeVector &u) { return v.Angle(&u); }
+inline float	 operator% (const hgeVector &v, const hgeVector &u) { return v.Dot(&u); }
+
+
+#endif
diff --git a/include/unix_compat.h b/include/unix_compat.h
new file mode 100644
index 0000000..56ec4b3
--- /dev/null
+++ b/include/unix_compat.h
@@ -0,0 +1,165 @@
+#ifndef _INCL_UNIX_COMPAT_H_
+#define _INCL_UNIX_COMPAT_H_
+
+#if (defined(__APPLE__) && defined(__MACH__))
+#define PLATFORM_MACOSX 1
+#endif
+
+#if ( defined(unix) || PLATFORM_MACOSX )
+#define PLATFORM_UNIX 1
+#endif
+
+// Useful to sprinkle around the codebase without a bunch of #ifdefs...
+#ifdef _WINDOWS
+#define BYTESWAP(x)
+#define STUBBED(x)
+#endif
+
+// don't want rest of this header on Windows, etc.
+#if (PLATFORM_UNIX)
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <time.h>
+
+#include "/usr/include/SDL/SDL.h"
+
+#define _MAX_PATH PATH_MAX
+#define MAX_PATH PATH_MAX
+
+typedef int64_t __int64;
+typedef uint32_t DWORD;
+typedef uint64_t UINT64;
+typedef uint8_t BYTE;
+typedef void *HANDLE;
+typedef HANDLE HWND;
+typedef int32_t BOOL;
+
+static inline DWORD timeGetTime(void)
+{
+    return SDL_GetTicks();
+} // timeGetTime
+
+
+// macro so I know what is still on the TODO list...
+#if 1
+#define STUBBED(x)
+#else
+void CalledSTUBBED(void);  // you can set a breakpoint on this.
+#define STUBBED(x) \
+do { \
+    static bool seen_this = false; \
+    if (!seen_this) { \
+        seen_this = true; \
+        fprintf(stderr, "STUBBED: %s at %s (%s:%d)\n", x, __FUNCTION__, __FILE__, __LINE__); \
+        fflush(stderr); \
+        CalledSTUBBED(); \
+    } \
+} while (false)
+#endif
+
+static inline char *itoa(const int i, char *s, const int radix)
+{
+    assert(radix == 10);
+    sprintf(s, "%d", i);
+    return s;
+}
+
+static inline char *_i64toa(const __int64 i, char *s, const int radix)
+{
+    assert(radix == 10);
+    assert(sizeof (long long) == sizeof (__int64));
+    sprintf(s, "%lld", (long long) i);
+    return s;
+}
+
+static inline __int64 _atoi64(const char *str)
+{
+    return (__int64) strtoll(str, NULL, 10);
+}
+
+static inline void Sleep(const int ms)
+{
+    usleep(ms * 1000);
+}
+
+static inline char *_gcvt(const double value, const int digits, char *buffer)
+{
+    char fmt[32];
+    snprintf(fmt, sizeof (fmt), "%%.%dg", digits);
+    sprintf(buffer, fmt, value);
+    return buffer;
+}
+
+#define ZeroMemory(a,b) memset(a, '\0', b)
+
+#ifdef __cplusplus
+#ifdef max
+#undef max
+#endif
+template <class T> inline const T &max(const T &a, const T &b) { return (a > b) ? a : b; }
+#ifdef min
+#undef min
+#endif
+template <class T> inline const T &min(const T &a, const T &b) { return (a < b) ? a : b; }
+#endif
+
+// Byteswap magic...
+
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+#define PLATFORM_BIGENDIAN 1
+#define PLATFORM_LITTLEENDIAN 0
+#else
+#define PLATFORM_BIGENDIAN 0
+#define PLATFORM_LITTLEENDIAN 1
+#endif
+
+#if PLATFORM_BIGENDIAN
+    #define SWAPPER64(t) \
+        inline void BYTESWAP(t &x) { \
+            union { t orig; Uint64 ui; } swapper; \
+            swapper.orig = x; \
+            swapper.ui = SDL_SwapLE64(swapper.ui); \
+            x = swapper.orig; \
+        }
+    #define SWAPPER32(t) \
+        inline void BYTESWAP(t &x) { \
+            union { t orig; Uint32 ui; } swapper; \
+            swapper.orig = x; \
+            swapper.ui = SDL_SwapLE32(swapper.ui); \
+            x = swapper.orig; \
+        }
+    #define SWAPPER16(t) \
+        inline void BYTESWAP(t &x) { \
+            union { t orig; Uint16 ui; } swapper; \
+            swapper.orig = x; \
+            swapper.ui = SDL_SwapLE16(swapper.ui); \
+            x = swapper.orig; \
+        }
+    #define SWAPPER8(t) inline void BYTESWAP(t &_x) {}
+    SWAPPER64(double)
+    SWAPPER32(size_t)   // !!! FIXME: this will fail on gnuc/amd64.
+    SWAPPER32(int)
+    SWAPPER32(float)
+    SWAPPER32(DWORD)
+    SWAPPER16(WORD)
+    SWAPPER16(short)
+    SWAPPER8(BYTE)
+    #undef SWAPPER32
+    #undef SWAPPER16
+    #undef SWAPPER8
+#else
+    #define BYTESWAP(x)
+#endif
+
+#endif  // PLATFORM_UNIX
+
+#endif  // include-once blocker.