Valve SDK FIX#2

MiniBase/ValveSDK/archtypes.h

@@ -0,0 +1,21 @@
+//
+// Word size dependent definitions
+// DAL 1/03
+//
+#ifndef ARCHTYPES_H
+#define ARCHTYPES_H
+
+#include "steamtypes.h"
+
+#ifndef _WIN32
+#define MAX_PATH PATH_MAX
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <limits.h>
+#include <stddef.h>
+#define _S_IREAD S_IREAD
+#define _S_IWRITE S_IWRITE
+typedef long unsigned int ulong;
+#endif
+
+#endif // ARCHTYPES_H

MiniBase/ValveSDK/beamdef.h

@@ -0,0 +1,62 @@
+/***
+*
+*	Copyright (c) 1999, 2000, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined ( BEAMDEFH )
+#define BEAMDEFH
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define FBEAM_STARTENTITY		0x00000001
+#define FBEAM_ENDENTITY			0x00000002
+#define FBEAM_FADEIN			0x00000004
+#define FBEAM_FADEOUT			0x00000008
+#define FBEAM_SINENOISE			0x00000010
+#define FBEAM_SOLID				0x00000020
+#define FBEAM_SHADEIN			0x00000040
+#define FBEAM_SHADEOUT			0x00000080
+#define FBEAM_STARTVISIBLE		0x10000000		// Has this client actually seen this beam's start entity yet?
+#define FBEAM_ENDVISIBLE		0x20000000		// Has this client actually seen this beam's end entity yet?
+#define FBEAM_ISACTIVE			0x40000000
+#define FBEAM_FOREVER			0x80000000
+
+typedef struct beam_s BEAM;
+struct beam_s
+{
+	BEAM		*next;
+	int			type;
+	int			flags;
+	vec3_t		source;
+	vec3_t		target;
+	vec3_t		delta;
+	float		t;		// 0 .. 1 over lifetime of beam
+	float		freq;
+	float		die;
+	float		width;
+	float		amplitude;
+	float		r, g, b;
+	float		brightness;
+	float		speed;
+	float		frameRate;
+	float		frame;
+	int			segments;
+	int			startEntity;
+	int			endEntity;
+	int			modelIndex;
+	int			frameCount;
+	struct model_s		*pFollowModel;
+	struct particle_s	*particles;
+};
+
+#endif

MiniBase/ValveSDK/cdll_dll.h

@@ -0,0 +1,46 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  cdll_dll.h
+
+// this file is included by both the game-dll and the client-dll,
+
+#ifndef CDLL_DLL_H
+#define CDLL_DLL_H
+
+#define MAX_WEAPONS		32		// ???
+
+#define MAX_WEAPON_SLOTS		5	// hud item selection slots
+#define MAX_ITEM_TYPES			6	// hud item selection slots
+
+#define MAX_ITEMS				5	// hard coded item types
+
+#define	HIDEHUD_WEAPONS		( 1<<0 )
+#define	HIDEHUD_FLASHLIGHT	( 1<<1 )
+#define	HIDEHUD_ALL			( 1<<2 )
+#define 	HIDEHUD_HEALTH		( 1<<3 )
+
+#define	MAX_AMMO_TYPES	32		// ???
+#define MAX_AMMO_SLOTS  32		// not really slots
+
+#define HUD_PRINTNOTIFY		1
+#define HUD_PRINTCONSOLE	2
+#define HUD_PRINTTALK		3
+#define HUD_PRINTCENTER		4
+
+
+#define WEAPON_SUIT			31
+
+#endif

MiniBase/ValveSDK/cdll_int.h

@@ -0,0 +1,375 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  cdll_int.h
+//
+// 4-23-98  
+// JOHN:  client dll interface declarations
+//
+
+#ifndef CDLL_INT_H
+#define CDLL_INT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "const.h"
+
+
+// this file is included by both the engine and the client-dll,
+// so make sure engine declarations aren't done twice
+
+typedef int SptiteHandle_t; // handle to a graphic
+
+#define SCRINFO_SCREENFLASH 1
+#define SCRINFO_STRETCHED	2
+
+typedef struct SCREENINFO_s
+{
+	int		iSize;
+	int		iWidth;
+	int		iHeight;
+	int		iFlags;
+	int		iCharHeight;
+	short	charWidths[256];
+} SCREENINFO;
+
+
+typedef struct client_data_s
+{
+	// fields that cannot be modified  (ie. have no effect if changed)
+	vec3_t origin;
+
+	// fields that can be changed by the cldll
+	vec3_t viewangles;
+	int		iWeaponBits;
+	float	fov;	// field of view
+} client_data_t;
+
+typedef struct client_sprite_s
+{
+	char szName[64];
+	char szSprite[64];
+	int hspr;
+	int iRes;
+	wrect_t rc;
+} client_sprite_t;
+
+typedef struct client_textmessage_s
+{
+	int		effect;
+	byte	r1, g1, b1, a1;		// 2 colors for effects
+	byte	r2, g2, b2, a2;
+	float	x;
+	float	y;
+	float	fadein;
+	float	fadeout;
+	float	holdtime;
+	float	fxtime;
+	const char *pName;
+	const char *pMessage;
+} client_textmessage_t;
+
+typedef struct hud_player_info_s
+{
+	char *name;
+	short ping;
+	byte thisplayer;  // TRUE if this is the calling player
+
+  // stuff that's unused at the moment,  but should be done
+	byte spectator;
+	byte packetloss;
+
+	char *model;
+	short topcolor;
+	short bottomcolor;
+
+} hud_player_info_t;
+
+
+typedef struct cl_enginefuncs_s
+{
+	// sprite handlers
+	HSPRITE						( *pfnSPR_Load )			( const char *szPicName );
+	int							( *pfnSPR_Frames )			( HSPRITE hPic );
+	int							( *pfnSPR_Height )			( HSPRITE hPic, int frame );
+	int							( *pfnSPR_Width )			( HSPRITE hPic, int frame );
+	void						( *pfnSPR_Set )				( HSPRITE hPic, int r, int g, int b );
+	void						( *pfnSPR_Draw )			( int frame, int x, int y, const wrect_t *prc );
+	void						( *pfnSPR_DrawHoles )		( int frame, int x, int y, const wrect_t *prc );
+	void						( *pfnSPR_DrawAdditive )	( int frame, int x, int y, const wrect_t *prc );
+	void						( *pfnSPR_EnableScissor )	( int x, int y, int width, int height );
+	void						( *pfnSPR_DisableScissor )	( void );
+	client_sprite_t				*( *pfnSPR_GetList )			( char *psz, int *piCount );
+
+	// screen handlers
+	void						( *pfnFillRGBA )			( int x, int y, int width, int height, int r, int g, int b, int a );
+	int							( *pfnGetScreenInfo ) 		( SCREENINFO *pscrinfo );
+	void						( *pfnSetCrosshair )		( HSPRITE hspr, wrect_t rc, int r, int g, int b );
+
+	// cvar handlers
+	struct cvar_s				*( *pfnRegisterVariable )	( char *szName, char *szValue, int flags );
+	float						( *pfnGetCvarFloat )		( char *szName );
+	char*						( *pfnGetCvarString )		( char *szName );
+
+	// command handlers
+	int							( *pfnAddCommand )			( char *cmd_name, void (*function)(void) );
+	int							( *pfnHookUserMsg )			( char *szMsgName, pfnUserMsgHook pfn );
+	int							( *pfnServerCmd )			( char *szCmdString );
+	int							( *pfnClientCmd )			( char *szCmdString );
+
+	void						( *pfnGetPlayerInfo )		( int ent_num, hud_player_info_t *pinfo );
+
+	// sound handlers
+	void						( *pfnPlaySoundByName )		( char *szSound, float volume );
+	void						( *pfnPlaySoundByIndex )	( int iSound, float volume );
+
+	// vector helpers
+	void						( *pfnAngleVectors )		( const float * vecAngles, float * forward, float * right, float * up );
+
+	// text message system
+	client_textmessage_t		*( *pfnTextMessageGet )		( const char *pName );
+	int							( *pfnDrawCharacter )		( int x, int y, int number, int r, int g, int b );
+	int							( *pfnDrawConsoleString )	( int x, int y, char *string );
+	void						( *pfnDrawSetTextColor )	( float r, float g, float b );
+	void						( *pfnDrawConsoleStringLen )(  const char *string, int *length, int *height );
+
+	void						( *pfnConsolePrint )		( const char *string );
+	void						( *pfnCenterPrint )			( const char *string );
+
+
+// Added for user input processing
+	int							( *GetWindowCenterX )		( void );
+	int							( *GetWindowCenterY )		( void );
+	void						( *GetViewAngles )			( float * );
+	void						( *SetViewAngles )			( float * );
+	int							( *GetMaxClients )			( void );
+	void						( *Cvar_SetValue )			( char *cvar, float value );
+
+	int       					(*Cmd_Argc)					(void);	
+	char						*( *Cmd_Argv )				( int arg );
+	void						( *Con_Printf )				( char *fmt, ... );
+	void						( *Con_DPrintf )			( char *fmt, ... );
+	void						( *Con_NPrintf )			( int pos, char *fmt, ... );
+	void						( *Con_NXPrintf )			( struct con_nprint_s *info, char *fmt, ... );
+
+	const char					*( *PhysInfo_ValueForKey )	( const char *key );
+	const char					*( *ServerInfo_ValueForKey )( const char *key );
+	float						( *GetClientMaxspeed )		( void );
+	int							( *CheckParm )				( char *parm, char **ppnext );
+	void						( *Key_Event )				( int key, int down );
+	void						( *GetMousePosition )		( int *mx, int *my );
+	int							( *IsNoClipping )			( void );
+
+	struct cl_entity_s			*( *GetLocalPlayer )		( void );
+	struct cl_entity_s			*( *GetViewModel )			( void );
+	struct cl_entity_s			*( *GetEntityByIndex )		( int idx );
+
+	float						( *GetClientTime )			( void );
+	void						( *V_CalcShake )			( void );
+	void						( *V_ApplyShake )			( float *origin, float *angles, float factor );
+
+	int							( *PM_PointContents )		( float *point, int *truecontents );
+	int							( *PM_WaterEntity )			( float *p );
+	struct pmtrace_s			*( *PM_TraceLine )			( float *start, float *end, int flags, int usehull, int ignore_pe );
+
+	struct model_s				*( *CL_LoadModel )			( const char *modelname, int *index );
+	int							( *CL_CreateVisibleEntity )	( int type, struct cl_entity_s *ent );
+
+	const struct model_s *		( *GetSpritePointer )		( HSPRITE hSprite );
+	void						( *pfnPlaySoundByNameAtLocation )	( char *szSound, float volume, float *origin );
+
+	unsigned short				( *pfnPrecacheEvent )		( int type, const char* psz );
+	void						( *pfnPlaybackEvent )		( int flags, const struct edict_s *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
+	void						( *pfnWeaponAnim )			( int iAnim, int body );
+	float						( *pfnRandomFloat )			( float flLow, float flHigh );
+	long						( *pfnRandomLong )			( long lLow, long lHigh );
+	void						( *pfnHookEvent )			( char *name, void ( *pfnEvent )( struct event_args_s *args ) );
+	int							(*Con_IsVisible)			();
+	const char					*( *pfnGetGameDirectory )	( void );
+	struct cvar_s				*( *pfnGetCvarPointer )		( const char *szName );
+	const char					*( *Key_LookupBinding )		( const char *pBinding );
+	const char					*( *pfnGetLevelName )		( void );
+	void						( *pfnGetScreenFade )		( struct screenfade_s *fade );
+	void						( *pfnSetScreenFade )		( struct screenfade_s *fade );
+	void                        *( *VGui_GetPanel )         ( );
+	void                         ( *VGui_ViewportPaintBackground ) (int extents[4]);
+
+	byte*						(*COM_LoadFile)				( char *path, int usehunk, int *pLength );
+	char*						(*COM_ParseFile)			( char *data, char *token );
+	void						(*COM_FreeFile)				( void *buffer );
+		
+	struct triangleapi_s		*pTriAPI;
+	struct efx_api_s			*pEfxAPI;
+	struct event_api_s			*pEventAPI;
+	struct demo_api_s			*pDemoAPI;
+	struct net_api_s			*pNetAPI;
+	struct IVoiceTweak_s		*pVoiceTweak;
+
+	// returns 1 if the client is a spectator only (connected to a proxy), 0 otherwise or 2 if in dev_overview mode
+	int							( *IsSpectateOnly ) ( void );
+	struct model_s				*( *LoadMapSprite )			( const char *filename );
+
+	// file search functions
+	void						( *COM_AddAppDirectoryToSearchPath ) ( const char *pszBaseDir, const char *appName );
+	int							( *COM_ExpandFilename)				 ( const char *fileName, char *nameOutBuffer, int nameOutBufferSize );
+
+	// User info
+	// playerNum is in the range (1, MaxClients)
+	// returns NULL if player doesn't exit
+	// returns "" if no value is set
+	const char					*( *PlayerInfo_ValueForKey )( int playerNum, const char *key );
+	void						( *PlayerInfo_SetValueForKey )( const char *key, const char *value );
+
+	// Gets a unique ID for the specified player. This is the same even if you see the player on a different server.
+	// iPlayer is an entity index, so client 0 would use iPlayer=1.
+	// Returns false if there is no player on the server in the specified slot.
+	qboolean					(*GetPlayerUniqueID)(int iPlayer, char playerID[16]);
+
+	// TrackerID access
+	int							(*GetTrackerIDForPlayer)(int playerSlot);
+	int							(*GetPlayerForTrackerID)(int trackerID);
+
+	// Same as pfnServerCmd, but the message goes in the unreliable stream so it can't clog the net stream
+	// (but it might not get there).
+	int							( *pfnServerCmdUnreliable )( char *szCmdString );
+
+	void						( *pfnGetMousePos )( struct tagPOINT *ppt );
+	void						( *pfnSetMousePos )( int x, int y );
+	void						( *pfnSetMouseEnable )( qboolean fEnable );
+	struct cvar_s*	( *pfnGetCvarList )( void );
+	struct cmd_s* ( *pfnGetCmdList )( void );
+
+	char* ( *pfnGetCvarName )( struct cvar_s* cvar );
+	char* ( *pfnGetCmdName )( struct cmd_s* cmd );
+
+	float ( *pfnGetServerTime )( void );
+	float ( *pfnGetGravity )( void );
+	const struct model_s* ( *pfnPrecacheSprite )( HSPRITE spr );
+	void ( *OverrideLightmap )( int override );
+	void ( *SetLightmapColor )( float r, float g, float b );
+	void ( *SetLightmapDarkness )( float dark );
+
+	//this will always fail with the current engine
+	int ( *pfnGetSequenceByName )( int flags, const char* seq );
+
+	void ( *pfnSPR_DrawGeneric )( int frame, int x, int y, const wrect_t *prc, int blendsrc, int blenddst, int unknown1, int unknown2 );
+
+	//this will always fail with engine, don't call
+	//it actually has paramenters but i dunno what they do
+	void ( *pfnLoadSentence )( void );
+
+	//localizes hud string, uses Legacy font from skin def
+	// also supports unicode strings
+	int ( *pfnDrawLocalizedHudString )( int x, int y, const char* str, int r, int g, int b );
+
+	//i can't get this to work for some reason, don't use this
+	int ( *pfnDrawLocalizedConsoleString )( int x, int y, const char* str );
+
+	//gets keyvalue for local player, useful for querying vgui menus or autohelp
+	const char	*(*LocalPlayerInfo_ValueForKey)( const char* key );
+
+	//another vgui2 text drawing function, i dunno how it works
+	//it doesn't localize though
+	void ( *pfnDrawText_0 )( int x, int y, const char* text, unsigned long font );
+
+	int ( *pfnDrawUnicodeCharacter )( int x, int y, short number, int r, int g, int b, unsigned long hfont );
+
+	//checks sound header of a sound file, determines if its a supported type
+	int ( *pfnCheckSoundFile )( const char* path );
+
+	//for condition zero, returns interface from GameUI
+	void* ( *GetCareerGameInterface )( void );
+
+	void ( *pfnCvar_Set )( const char* cvar, const char* value );
+
+	//this actually checks for if the CareerGameInterface is found
+	//and if a server is being run
+	int ( *IsSinglePlayer )( void );
+
+	void ( *pfnPlaySound )( const char* sound, float vol, float pitch );
+
+	void ( *pfnPlayMp3 )( const char* mp3, int flags );
+
+	//get the systems current time as a float
+	float ( *Sys_FloatTime )( void );
+
+	void ( *pfnSetArray )( int* array, int size );
+	void ( *pfnSetClearArray )( int* array, int size );
+	void ( *pfnClearArray )( void );
+
+	void ( *pfnPlaySound2 )( const char* sound, float vol, float pitch );
+
+	void	( *pfnTintRGBA )			( int x, int y, int width, int height, int r, int g, int b, int a );
+} cl_enginefunc_t;
+
+#ifndef IN_BUTTONS_H
+#include "in_buttons.h"
+#endif
+
+#define CLDLL_INTERFACE_VERSION		7
+
+extern void ClientDLL_Init( void ); // from cdll_int.c
+extern void ClientDLL_Shutdown( void );
+extern void ClientDLL_HudInit( void );
+extern void ClientDLL_HudVidInit( void );
+extern void	ClientDLL_UpdateClientData( void );
+extern void ClientDLL_Frame( double time );
+extern void ClientDLL_HudRedraw( int intermission );
+extern void ClientDLL_MoveClient( struct playermove_s *ppmove );
+extern void ClientDLL_ClientMoveInit( struct playermove_s *ppmove );
+extern char ClientDLL_ClientTextureType( char *name );
+
+extern void ClientDLL_CreateMove( float frametime, struct usercmd_s *cmd, int active );
+extern void ClientDLL_ActivateMouse( void );
+extern void ClientDLL_DeactivateMouse( void );
+extern void ClientDLL_MouseEvent( int mstate );
+extern void ClientDLL_ClearStates( void );
+extern int ClientDLL_IsThirdPerson( void );
+extern void ClientDLL_GetCameraOffsets( float *ofs );
+extern int ClientDLL_GraphKeyDown( void );
+extern struct kbutton_s *ClientDLL_FindKey( const char *name );
+extern void ClientDLL_CAM_Think( void );
+extern void ClientDLL_IN_Accumulate( void );
+extern void ClientDLL_CalcRefdef( struct ref_params_s *pparams );
+extern int ClientDLL_AddEntity( int type, struct cl_entity_s *ent );
+extern void ClientDLL_CreateEntities( void );
+
+extern void ClientDLL_DrawNormalTriangles( void );
+extern void ClientDLL_DrawTransparentTriangles( void );
+extern void ClientDLL_StudioEvent( const struct mstudioevent_s *event, const struct cl_entity_s *entity );
+extern void ClientDLL_PostRunCmd( struct local_state_s *from, struct local_state_s *to, struct usercmd_s *cmd, int runfuncs, double time, unsigned int random_seed );
+extern void ClientDLL_TxferLocalOverrides( struct entity_state_s *state, const struct clientdata_s *client );
+extern void ClientDLL_ProcessPlayerState( struct entity_state_s *dst, const struct entity_state_s *src );
+extern void ClientDLL_TxferPredictionData ( struct entity_state_s *ps, const struct entity_state_s *pps, struct clientdata_s *pcd, const struct clientdata_s *ppcd, struct weapon_data_s *wd, const struct weapon_data_s *pwd );
+extern void ClientDLL_ReadDemoBuffer( int size, unsigned char *buffer );
+extern int ClientDLL_ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size );
+extern int ClientDLL_GetHullBounds( int hullnumber, float *mins, float *maxs );
+
+extern void ClientDLL_VGui_ConsolePrint(const char* text);
+
+extern int ClientDLL_Key_Event( int down, int keynum, const char *pszCurrentBinding );
+extern void ClientDLL_TempEntUpdate( double ft, double ct, double grav, struct tempent_s **ppFreeTE, struct tempent_s **ppActiveTE, int ( *addTEntity )( struct cl_entity_s *pEntity ), void ( *playTESound )( struct tempent_s *pTemp, float damp ) );
+extern struct cl_entity_s *ClientDLL_GetUserEntity( int index );
+extern void ClientDLL_VoiceStatus(int entindex, qboolean bTalking);
+extern void ClientDLL_DirectorMessage( int iSize, void *pbuf );
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // CDLL_INT_H

MiniBase/ValveSDK/cl_dll.h

@@ -0,0 +1,37 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  cl_dll.h
+//
+
+// 4-23-98  JOHN
+
+//
+//  This DLL is linked by the client when they first initialize.
+// This DLL is responsible for the following tasks:
+//		- Loading the HUD graphics upon initialization
+//		- Drawing the HUD graphics every frame
+//		- Handling the custum HUD-update packets
+//
+typedef unsigned char byte;
+typedef unsigned short word;
+typedef float vec_t;
+typedef int (*pfnUserMsgHook)(const char *pszName, int iSize, void *pbuf);
+
+#include "util_vector.h"
+#define EXPORT	_declspec( dllexport )
+
+#include "cdll_int.h"
+#include "cdll_dll.h"

MiniBase/ValveSDK/cl_entity.h

@@ -0,0 +1,115 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// cl_entity.h
+#if !defined( CL_ENTITYH )
+#define CL_ENTITYH
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef struct efrag_s
+{
+	struct mleaf_s		*leaf;
+	struct efrag_s		*leafnext;
+	struct cl_entity_s	*entity;
+	struct efrag_s		*entnext;
+} efrag_t;
+
+typedef struct
+{
+	byte					mouthopen;		// 0 = mouth closed, 255 = mouth agape
+	byte					sndcount;		// counter for running average
+	int						sndavg;			// running average
+} mouth_t;
+
+typedef struct
+{
+	float					prevanimtime;  
+	float					sequencetime;
+	byte					prevseqblending[2];
+	vec3_t					prevorigin;
+	vec3_t					prevangles;
+
+	int						prevsequence;
+	float					prevframe;
+
+	byte					prevcontroller[4];
+	byte					prevblending[2];
+} latchedvars_t;
+
+typedef struct
+{
+	// Time stamp for this movement
+	float					animtime;
+
+	vec3_t					origin;
+	vec3_t					angles;
+} position_history_t;
+
+typedef struct cl_entity_s cl_entity_t;
+
+#define HISTORY_MAX		64  // Must be power of 2
+#define HISTORY_MASK	( HISTORY_MAX - 1 )
+
+
+#if !defined( ENTITY_STATEH )
+#include "entity_state.h"
+#endif
+
+#if !defined( PROGS_H )
+#include "progs.h"
+#endif
+
+struct cl_entity_s
+{
+	int						index;      // Index into cl_entities ( should match actual slot, but not necessarily )
+
+	qboolean				player;     // True if this entity is a "player"
+	
+	entity_state_t			baseline;   // The original state from which to delta during an uncompressed message
+	entity_state_t			prevstate;  // The state information from the penultimate message received from the server
+	entity_state_t			curstate;   // The state information from the last message received from server
+
+	int						current_position;  // Last received history update index
+	position_history_t		ph[ HISTORY_MAX ];   // History of position and angle updates for this player
+
+	mouth_t					mouth;			// For synchronizing mouth movements.
+
+	latchedvars_t			latched;		// Variables used by studio model rendering routines
+
+	// Information based on interplocation, extrapolation, prediction, or just copied from last msg received.
+	//
+	float					lastmove;
+
+	// Actual render position and angles
+	vec3_t					origin;
+	vec3_t					angles;
+
+	// Attachment points
+	vec3_t					attachment[4];
+
+	// Other entity local information
+	int						trivial_accept;
+
+	struct model_s			*model;			// cl.model_precache[ curstate.modelindes ];  all visible entities have a model
+	struct efrag_s			*efrag;			// linked list of efrags
+	struct mnode_s			*topnode;		// for bmodels, first world node that splits bmodel, or NULL if not split
+
+	float					syncbase;		// for client-side animations -- used by obsolete alias animation system, remove?
+	int						visframe;		// last frame this entity was found in an active leaf
+	colorVec				cvFloorColor;
+};
+
+#endif // !CL_ENTITYH

MiniBase/ValveSDK/com_model.h

@@ -0,0 +1,351 @@
+//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+// com_model.h
+#if !defined( COM_MODEL_H )
+#define COM_MODEL_H
+#if defined( _WIN32 )
+#pragma once
+#endif
+
+#define STUDIO_RENDER 1
+#define STUDIO_EVENTS 2
+
+#define MAX_CLIENTS			32
+#define	MAX_EDICTS			900
+
+#define MAX_MODEL_NAME		64
+#define MAX_MAP_HULLS		4
+#define	MIPLEVELS			4
+#define	NUM_AMBIENTS		4		// automatic ambient sounds
+#define	MAXLIGHTMAPS		4
+#define	PLANE_ANYZ			5
+
+#define ALIAS_Z_CLIP_PLANE	5
+
+// flags in finalvert_t.flags
+#define ALIAS_LEFT_CLIP				0x0001
+#define ALIAS_TOP_CLIP				0x0002
+#define ALIAS_RIGHT_CLIP			0x0004
+#define ALIAS_BOTTOM_CLIP			0x0008
+#define ALIAS_Z_CLIP				0x0010
+#define ALIAS_ONSEAM				0x0020
+#define ALIAS_XY_CLIP_MASK			0x000F
+
+#define	ZISCALE	((float)0x8000)
+
+#define CACHE_SIZE	32		// used to align key data structures
+
+typedef enum
+{
+	mod_brush, 
+	mod_sprite, 
+	mod_alias, 
+	mod_studio
+} modtype_t;
+
+// must match definition in modelgen.h
+#ifndef SYNCTYPE_T
+#define SYNCTYPE_T
+
+typedef enum
+{
+	ST_SYNC=0,
+	ST_RAND
+} synctype_t;
+
+#endif
+
+typedef struct
+{
+	float		mins[3], maxs[3];
+	float		origin[3];
+	int			headnode[MAX_MAP_HULLS];
+	int			visleafs;		// not including the solid leaf 0
+	int			firstface, numfaces;
+} dmodel_t;
+
+// plane_t structure
+typedef struct mplane_s
+{
+	vec3_t	normal;			// surface normal
+	float	dist;			// closest appoach to origin
+	byte	type;			// for texture axis selection and fast side tests
+	byte	signbits;		// signx + signy<<1 + signz<<1
+	byte	pad[2];
+} mplane_t;
+
+typedef struct
+{
+	vec3_t		position;
+} mvertex_t;
+
+typedef struct
+{
+	unsigned short	v[2];
+	unsigned int	cachededgeoffset;
+} medge_t;
+
+typedef struct texture_s
+{
+	char		name[16];
+	unsigned	width, height;
+	int			anim_total;				// total tenths in sequence ( 0 = no)
+	int			anim_min, anim_max;		// time for this frame min <=time< max
+	struct texture_s *anim_next;		// in the animation sequence
+	struct texture_s *alternate_anims;	// bmodels in frame 1 use these
+	unsigned	offsets[MIPLEVELS];		// four mip maps stored
+	unsigned	paloffset;
+} texture_t;
+
+typedef struct
+{
+	float		vecs[2][4];		// [s/t] unit vectors in world space. 
+								// [i][3] is the s/t offset relative to the origin.
+								// s or t = dot(3Dpoint,vecs[i])+vecs[i][3]
+	float		mipadjust;		// ?? mipmap limits for very small surfaces
+	texture_t	*texture;
+	int			flags;			// sky or slime, no lightmap or 256 subdivision
+} mtexinfo_t;
+
+typedef struct mnode_s
+{
+// common with leaf
+	int			contents;		// 0, to differentiate from leafs
+	int			visframe;		// node needs to be traversed if current
+	
+	short		minmaxs[6];		// for bounding box culling
+
+	struct mnode_s	*parent;
+
+// node specific
+	mplane_t	*plane;
+	struct mnode_s	*children[2];	
+
+	unsigned short		firstsurface;
+	unsigned short		numsurfaces;
+} mnode_t;
+
+typedef struct msurface_s	msurface_t;
+typedef struct decal_s		decal_t;
+
+// JAY: Compress this as much as possible
+struct decal_s
+{
+	decal_t		*pnext;			// linked list for each surface
+	msurface_t	*psurface;		// Surface id for persistence / unlinking
+	short		dx;				// Offsets into surface texture (in texture coordinates, so we don't need floats)
+	short		dy;
+	short		texture;		// Decal texture
+	byte		scale;			// Pixel scale
+	byte		flags;			// Decal flags
+
+	short		entityIndex;	// Entity this is attached to
+};
+
+typedef struct mleaf_s
+{
+// common with node
+	int			contents;		// wil be a negative contents number
+	int			visframe;		// node needs to be traversed if current
+
+	short		minmaxs[6];		// for bounding box culling
+
+	struct mnode_s	*parent;
+
+// leaf specific
+	byte		*compressed_vis;
+	struct efrag_s	*efrags;
+
+	msurface_t	**firstmarksurface;
+	int			nummarksurfaces;
+	int			key;			// BSP sequence number for leaf's contents
+	byte		ambient_sound_level[NUM_AMBIENTS];
+} mleaf_t;
+
+struct msurface_s
+{
+	int			visframe;		// should be drawn when node is crossed
+
+	int			dlightframe;	// last frame the surface was checked by an animated light
+	int			dlightbits;		// dynamically generated. Indicates if the surface illumination 
+								// is modified by an animated light.
+
+	mplane_t	*plane;			// pointer to shared plane			
+	int			flags;			// see SURF_ #defines
+
+	int			firstedge;	// look up in model->surfedges[], negative numbers
+	int			numedges;	// are backwards edges
+	
+// surface generation data
+	struct surfcache_s	*cachespots[MIPLEVELS];
+
+	short		texturemins[2]; // smallest s/t position on the surface.
+	short		extents[2];		// ?? s/t texture size, 1..256 for all non-sky surfaces
+
+	mtexinfo_t	*texinfo;		
+	
+// lighting info
+	byte		styles[MAXLIGHTMAPS]; // index into d_lightstylevalue[] for animated lights 
+									  // no one surface can be effected by more than 4 
+									  // animated lights.
+	color24		*samples;
+	
+	decal_t		*pdecals;
+};
+
+typedef struct
+{
+	int			planenum;
+	short		children[2];	// negative numbers are contents
+} dclipnode_t;
+
+typedef struct hull_s
+{
+	dclipnode_t	*clipnodes;
+	mplane_t	*planes;
+	int			firstclipnode;
+	int			lastclipnode;
+	vec3_t		clip_mins;
+	vec3_t		clip_maxs;
+} hull_t;
+
+#if !defined( CACHE_USER ) && !defined( QUAKEDEF_H )
+#define CACHE_USER
+typedef struct cache_user_s
+{
+	void	*data;
+} cache_user_t;
+#endif
+
+typedef struct model_s
+{
+	char		name[ MAX_MODEL_NAME ];
+	qboolean	needload;		// bmodels and sprites don't cache normally
+
+	modtype_t	type;
+	int			numframes;
+	synctype_t	synctype;
+	
+	int			flags;
+
+//
+// volume occupied by the model
+//		
+	vec3_t		mins, maxs;
+	float		radius;
+
+//
+// brush model
+//
+	int			firstmodelsurface, nummodelsurfaces;
+
+	int			numsubmodels;
+	dmodel_t	*submodels;
+
+	int			numplanes;
+	mplane_t	*planes;
+
+	int			numleafs;		// number of visible leafs, not counting 0
+	struct mleaf_s		*leafs;
+
+	int			numvertexes;
+	mvertex_t	*vertexes;
+
+	int			numedges;
+	medge_t		*edges;
+
+	int			numnodes;
+	mnode_t		*nodes;
+
+	int			numtexinfo;
+	mtexinfo_t	*texinfo;
+
+	int			numsurfaces;
+	msurface_t	*surfaces;
+
+	int			numsurfedges;
+	int			*surfedges;
+
+	int			numclipnodes;
+	dclipnode_t	*clipnodes;
+
+	int			nummarksurfaces;
+	msurface_t	**marksurfaces;
+
+	hull_t		hulls[MAX_MAP_HULLS];
+
+	int			numtextures;
+	texture_t	**textures;
+
+	byte		*visdata;
+
+	color24		*lightdata;
+
+	char		*entities;
+
+//
+// additional model data
+//
+	cache_user_t	cache;		// only access through Mod_Extradata
+
+} model_t;
+
+typedef vec_t vec4_t[4];
+
+typedef struct alight_s
+{
+	int			ambientlight;	// clip at 128
+	int			shadelight;		// clip at 192 - ambientlight
+	vec3_t		color;
+	float		*plightvec;
+} alight_t;
+
+typedef struct auxvert_s
+{
+	float	fv[3];		// viewspace x, y
+} auxvert_t;
+
+#include "custom.h"
+
+#define	MAX_INFO_STRING			256
+#define	MAX_SCOREBOARDNAME		32
+typedef struct player_info_s
+{
+	// User id on server
+	int		userid;
+
+	// User info string
+	char	userinfo[ MAX_INFO_STRING ];
+
+	// Name
+	char	name[ MAX_SCOREBOARDNAME ];
+
+	// Spectator or not, unused
+	int		spectator;
+
+	int		ping;
+	int		packet_loss;
+
+	// skin information
+	char	model[MAX_QPATH];
+	int		topcolor;
+	int		bottomcolor;
+
+	// last frame rendered
+	int		renderframe;	
+
+	// Gait frame estimation
+	int		gaitsequence;
+	float	gaitframe;
+	float	gaityaw;
+	vec3_t	prevgaitorigin;
+
+	customization_t customdata;
+} player_info_t;
+
+#endif // #define COM_MODEL_H

MiniBase/ValveSDK/const.h

@@ -0,0 +1,783 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef CONST_H
+#define CONST_H
+//
+// Constants shared by the engine and dlls
+// This header file included by engine files and DLL files.
+// Most came from server.h
+
+// edict->flags
+#define	FL_FLY					(1<<0)	// Changes the SV_Movestep() behavior to not need to be on ground
+#define	FL_SWIM					(1<<1)	// Changes the SV_Movestep() behavior to not need to be on ground (but stay in water)
+#define	FL_CONVEYOR				(1<<2)
+#define	FL_CLIENT				(1<<3)
+#define	FL_INWATER				(1<<4)
+#define	FL_MONSTER				(1<<5)
+#define	FL_GODMODE				(1<<6)
+#define	FL_NOTARGET				(1<<7)
+#define	FL_SKIPLOCALHOST		(1<<8)	// Don't send entity to local host, it's predicting this entity itself
+#define	FL_ONGROUND				(1<<9)	// At rest / on the ground
+#define	FL_PARTIALGROUND		(1<<10)	// not all corners are valid
+#define	FL_WATERJUMP			(1<<11)	// player jumping out of water
+#define FL_FROZEN				(1<<12) // Player is frozen for 3rd person camera
+#define FL_FAKECLIENT			(1<<13)	// JAC: fake client, simulated server side; don't send network messages to them
+#define FL_DUCKING				(1<<14)	// Player flag -- Player is fully crouched
+#define FL_FLOAT				(1<<15)	// Apply floating force to this entity when in water
+#define FL_GRAPHED				(1<<16) // worldgraph has this ent listed as something that blocks a connection
+
+// UNDONE: Do we need these?
+#define FL_IMMUNE_WATER			(1<<17)
+#define	FL_IMMUNE_SLIME			(1<<18)
+#define FL_IMMUNE_LAVA			(1<<19)
+
+#define FL_PROXY				(1<<20)	// This is a spectator proxy
+#define FL_ALWAYSTHINK			(1<<21)	// Brush model flag -- call think every frame regardless of nextthink - ltime (for constantly changing velocity/path)
+#define FL_BASEVELOCITY			(1<<22)	// Base velocity has been applied this frame (used to convert base velocity into momentum)
+#define FL_MONSTERCLIP			(1<<23)	// Only collide in with monsters who have FL_MONSTERCLIP set
+#define FL_ONTRAIN				(1<<24) // Player is _controlling_ a train, so movement commands should be ignored on client during prediction.
+#define FL_WORLDBRUSH			(1<<25)	// Not moveable/removeable brush entity (really part of the world, but represented as an entity for transparency or something)
+#define FL_SPECTATOR            (1<<26) // This client is a spectator, don't run touch functions, etc.
+#define FL_CUSTOMENTITY			(1<<29)	// This is a custom entity
+#define FL_KILLME				(1<<30)	// This entity is marked for death -- This allows the engine to kill ents at the appropriate time
+#define FL_DORMANT				(1<<31)	// Entity is dormant, no updates to client
+
+
+// Goes into globalvars_t.trace_flags
+#define FTRACE_SIMPLEBOX		(1<<0)	// Traceline with a simple box
+
+
+// walkmove modes
+#define	WALKMOVE_NORMAL		0 // normal walkmove
+#define WALKMOVE_WORLDONLY	1 // doesn't hit ANY entities, no matter what the solid type
+#define WALKMOVE_CHECKONLY	2 // move, but don't touch triggers
+
+// edict->movetype values
+#define	MOVETYPE_NONE			0		// never moves
+//#define	MOVETYPE_ANGLENOCLIP	1
+//#define	MOVETYPE_ANGLECLIP		2
+#define	MOVETYPE_WALK			3		// Player only - moving on the ground
+#define	MOVETYPE_STEP			4		// gravity, special edge handling -- monsters use this
+#define	MOVETYPE_FLY			5		// No gravity, but still collides with stuff
+#define	MOVETYPE_TOSS			6		// gravity/collisions
+#define	MOVETYPE_PUSH			7		// no clip to world, push and crush
+#define	MOVETYPE_NOCLIP			8		// No gravity, no collisions, still do velocity/avelocity
+#define	MOVETYPE_FLYMISSILE		9		// extra size to monsters
+#define	MOVETYPE_BOUNCE			10		// Just like Toss, but reflect velocity when contacting surfaces
+#define MOVETYPE_BOUNCEMISSILE	11		// bounce w/o gravity
+#define MOVETYPE_FOLLOW			12		// track movement of aiment
+#define	MOVETYPE_PUSHSTEP		13		// BSP model that needs physics/world collisions (uses nearest hull for world collision)
+
+// edict->solid values
+// NOTE: Some movetypes will cause collisions independent of SOLID_NOT/SOLID_TRIGGER when the entity moves
+// SOLID only effects OTHER entities colliding with this one when they move - UGH!
+#define	SOLID_NOT				0		// no interaction with other objects
+#define	SOLID_TRIGGER			1		// touch on edge, but not blocking
+#define	SOLID_BBOX				2		// touch on edge, block
+#define	SOLID_SLIDEBOX			3		// touch on edge, but not an onground
+#define	SOLID_BSP				4		// bsp clip, touch on edge, block
+
+// edict->deadflag values
+#define	DEAD_NO					0 // alive
+#define	DEAD_DYING				1 // playing death animation or still falling off of a ledge waiting to hit ground
+#define	DEAD_DEAD				2 // dead. lying still.
+#define DEAD_RESPAWNABLE		3
+#define DEAD_DISCARDBODY		4
+
+#define	DAMAGE_NO				0
+#define	DAMAGE_YES				1
+#define	DAMAGE_AIM				2
+
+// entity effects
+#define	EF_BRIGHTFIELD			1	// swirling cloud of particles
+#define	EF_MUZZLEFLASH 			2	// single frame ELIGHT on entity attachment 0
+#define	EF_BRIGHTLIGHT 			4	// DLIGHT centered at entity origin
+#define	EF_DIMLIGHT 			8	// player flashlight
+#define EF_INVLIGHT				16	// get lighting from ceiling
+#define EF_NOINTERP				32	// don't interpolate the next frame
+#define EF_LIGHT				64	// rocket flare glow sprite
+#define EF_NODRAW				128	// don't draw entity
+#define EF_NIGHTVISION			256 // player nightvision
+#define EF_SNIPERLASER			512 // sniper laser effect
+#define EF_FIBERCAMERA			1024// fiber camera
+
+
+// entity flags
+#define EFLAG_SLERP				1	// do studio interpolation of this entity
+		
+//
+// temp entity events
+//
+#define	TE_BEAMPOINTS		0		// beam effect between two points
+// coord coord coord (start position) 
+// coord coord coord (end position) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define	TE_BEAMENTPOINT		1		// beam effect between point and entity
+// short (start entity) 
+// coord coord coord (end position) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define	TE_GUNSHOT			2		// particle effect plus ricochet sound
+// coord coord coord (position) 
+
+#define	TE_EXPLOSION		3		// additive sprite, 2 dynamic lights, flickering particles, explosion sound, move vertically 8 pps
+// coord coord coord (position) 
+// short (sprite index)
+// byte (scale in 0.1's)
+// byte (framerate)
+// byte (flags)
+//
+// The Explosion effect has some flags to control performance/aesthetic features:
+#define TE_EXPLFLAG_NONE		0	// all flags clear makes default Half-Life explosion
+#define TE_EXPLFLAG_NOADDITIVE	1	// sprite will be drawn opaque (ensure that the sprite you send is a non-additive sprite)
+#define TE_EXPLFLAG_NODLIGHTS	2	// do not render dynamic lights
+#define TE_EXPLFLAG_NOSOUND		4	// do not play client explosion sound
+#define TE_EXPLFLAG_NOPARTICLES	8	// do not draw particles
+
+
+#define	TE_TAREXPLOSION		4		// Quake1 "tarbaby" explosion with sound
+// coord coord coord (position) 
+
+#define	TE_SMOKE			5		// alphablend sprite, move vertically 30 pps
+// coord coord coord (position) 
+// short (sprite index)
+// byte (scale in 0.1's)
+// byte (framerate)
+
+#define	TE_TRACER			6		// tracer effect from point to point
+// coord, coord, coord (start) 
+// coord, coord, coord (end)
+
+#define	TE_LIGHTNING		7		// TE_BEAMPOINTS with simplified parameters
+// coord, coord, coord (start) 
+// coord, coord, coord (end) 
+// byte (life in 0.1's) 
+// byte (width in 0.1's) 
+// byte (amplitude in 0.01's)
+// short (sprite model index)
+
+#define	TE_BEAMENTS			8		
+// short (start entity) 
+// short (end entity) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define	TE_SPARKS			9		// 8 random tracers with gravity, ricochet sprite
+// coord coord coord (position) 
+
+#define	TE_LAVASPLASH		10		// Quake1 lava splash
+// coord coord coord (position) 
+
+#define	TE_TELEPORT			11		// Quake1 teleport splash
+// coord coord coord (position) 
+
+#define TE_EXPLOSION2		12		// Quake1 colormaped (base palette) particle explosion with sound
+// coord coord coord (position) 
+// byte (starting color)
+// byte (num colors)
+
+#define TE_BSPDECAL			13		// Decal from the .BSP file 
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// short (texture index of precached decal texture name)
+// short (entity index)
+// [optional - only included if previous short is non-zero (not the world)] short (index of model of above entity)
+
+#define TE_IMPLOSION		14		// tracers moving toward a point
+// coord, coord, coord (position)
+// byte (radius)
+// byte (count)
+// byte (life in 0.1's) 
+
+#define TE_SPRITETRAIL		15		// line of moving glow sprites with gravity, fadeout, and collisions
+// coord, coord, coord (start) 
+// coord, coord, coord (end) 
+// short (sprite index)
+// byte (count)
+// byte (life in 0.1's) 
+// byte (scale in 0.1's) 
+// byte (velocity along vector in 10's)
+// byte (randomness of velocity in 10's)
+
+#define TE_BEAM				16		// obsolete
+
+#define TE_SPRITE			17		// additive sprite, plays 1 cycle
+// coord, coord, coord (position) 
+// short (sprite index) 
+// byte (scale in 0.1's) 
+// byte (brightness)
+
+#define TE_BEAMSPRITE		18		// A beam with a sprite at the end
+// coord, coord, coord (start position) 
+// coord, coord, coord (end position) 
+// short (beam sprite index) 
+// short (end sprite index) 
+
+#define TE_BEAMTORUS		19		// screen aligned beam ring, expands to max radius over lifetime
+// coord coord coord (center position) 
+// coord coord coord (axis and radius) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define TE_BEAMDISK			20		// disk that expands to max radius over lifetime
+// coord coord coord (center position) 
+// coord coord coord (axis and radius) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define TE_BEAMCYLINDER		21		// cylinder that expands to max radius over lifetime
+// coord coord coord (center position) 
+// coord coord coord (axis and radius) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define TE_BEAMFOLLOW		22		// create a line of decaying beam segments until entity stops moving
+// short (entity:attachment to follow)
+// short (sprite index)
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte,byte,byte (color)
+// byte (brightness)
+
+#define TE_GLOWSPRITE		23		
+// coord, coord, coord (pos) short (model index) byte (scale / 10)
+
+#define TE_BEAMRING			24		// connect a beam ring to two entities
+// short (start entity) 
+// short (end entity) 
+// short (sprite index) 
+// byte (starting frame) 
+// byte (frame rate in 0.1's) 
+// byte (life in 0.1's) 
+// byte (line width in 0.1's) 
+// byte (noise amplitude in 0.01's) 
+// byte,byte,byte (color)
+// byte (brightness)
+// byte (scroll speed in 0.1's)
+
+#define TE_STREAK_SPLASH	25		// oriented shower of tracers
+// coord coord coord (start position) 
+// coord coord coord (direction vector) 
+// byte (color)
+// short (count)
+// short (base speed)
+// short (ramdon velocity)
+
+#define TE_BEAMHOSE			26		// obsolete
+
+#define TE_DLIGHT			27		// dynamic light, effect world, minor entity effect
+// coord, coord, coord (pos) 
+// byte (radius in 10's) 
+// byte byte byte (color)
+// byte (brightness)
+// byte (life in 10's)
+// byte (decay rate in 10's)
+
+#define TE_ELIGHT			28		// point entity light, no world effect
+// short (entity:attachment to follow)
+// coord coord coord (initial position) 
+// coord (radius)
+// byte byte byte (color)
+// byte (life in 0.1's)
+// coord (decay rate)
+
+#define TE_TEXTMESSAGE		29
+// short 1.2.13 x (-1 = center)
+// short 1.2.13 y (-1 = center)
+// byte Effect 0 = fade in/fade out
+			// 1 is flickery credits
+			// 2 is write out (training room)
+
+// 4 bytes r,g,b,a color1	(text color)
+// 4 bytes r,g,b,a color2	(effect color)
+// ushort 8.8 fadein time
+// ushort 8.8  fadeout time
+// ushort 8.8 hold time
+// optional ushort 8.8 fxtime	(time the highlight lags behing the leading text in effect 2)
+// string text message		(512 chars max sz string)
+#define TE_LINE				30
+// coord, coord, coord		startpos
+// coord, coord, coord		endpos
+// short life in 0.1 s
+// 3 bytes r, g, b
+
+#define TE_BOX				31
+// coord, coord, coord		boxmins
+// coord, coord, coord		boxmaxs
+// short life in 0.1 s
+// 3 bytes r, g, b
+
+#define TE_KILLBEAM			99		// kill all beams attached to entity
+// short (entity)
+
+#define TE_LARGEFUNNEL		100
+// coord coord coord (funnel position)
+// short (sprite index) 
+// short (flags) 
+
+#define	TE_BLOODSTREAM		101		// particle spray
+// coord coord coord (start position)
+// coord coord coord (spray vector)
+// byte (color)
+// byte (speed)
+
+#define	TE_SHOWLINE			102		// line of particles every 5 units, dies in 30 seconds
+// coord coord coord (start position)
+// coord coord coord (end position)
+
+#define TE_BLOOD			103		// particle spray
+// coord coord coord (start position)
+// coord coord coord (spray vector)
+// byte (color)
+// byte (speed)
+
+#define TE_DECAL			104		// Decal applied to a brush entity (not the world)
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// byte (texture index of precached decal texture name)
+// short (entity index)
+
+#define TE_FIZZ				105		// create alpha sprites inside of entity, float upwards
+// short (entity)
+// short (sprite index)
+// byte (density)
+
+#define TE_MODEL			106		// create a moving model that bounces and makes a sound when it hits
+// coord, coord, coord (position) 
+// coord, coord, coord (velocity)
+// angle (initial yaw)
+// short (model index)
+// byte (bounce sound type)
+// byte (life in 0.1's)
+
+#define TE_EXPLODEMODEL		107		// spherical shower of models, picks from set
+// coord, coord, coord (origin)
+// coord (velocity)
+// short (model index)
+// short (count)
+// byte (life in 0.1's)
+
+#define TE_BREAKMODEL		108		// box of models or sprites
+// coord, coord, coord (position)
+// coord, coord, coord (size)
+// coord, coord, coord (velocity)
+// byte (random velocity in 10's)
+// short (sprite or model index)
+// byte (count)
+// byte (life in 0.1 secs)
+// byte (flags)
+
+#define TE_GUNSHOTDECAL		109		// decal and ricochet sound
+// coord, coord, coord (position)
+// short (entity index???)
+// byte (decal???)
+
+#define TE_SPRITE_SPRAY		110		// spay of alpha sprites
+// coord, coord, coord (position)
+// coord, coord, coord (velocity)
+// short (sprite index)
+// byte (count)
+// byte (speed)
+// byte (noise)
+
+#define TE_ARMOR_RICOCHET	111		// quick spark sprite, client ricochet sound. 
+// coord, coord, coord (position)
+// byte (scale in 0.1's)
+
+#define TE_PLAYERDECAL		112		// ???
+// byte (playerindex)
+// coord, coord, coord (position)
+// short (entity???)
+// byte (decal number???)
+// [optional] short (model index???)
+
+#define TE_BUBBLES			113		// create alpha sprites inside of box, float upwards
+// coord, coord, coord (min start position)
+// coord, coord, coord (max start position)
+// coord (float height)
+// short (model index)
+// byte (count)
+// coord (speed)
+
+#define TE_BUBBLETRAIL		114		// create alpha sprites along a line, float upwards
+// coord, coord, coord (min start position)
+// coord, coord, coord (max start position)
+// coord (float height)
+// short (model index)
+// byte (count)
+// coord (speed)
+
+#define TE_BLOODSPRITE		115		// spray of opaque sprite1's that fall, single sprite2 for 1..2 secs (this is a high-priority tent)
+// coord, coord, coord (position)
+// short (sprite1 index)
+// short (sprite2 index)
+// byte (color)
+// byte (scale)
+
+#define TE_WORLDDECAL		116		// Decal applied to the world brush
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// byte (texture index of precached decal texture name)
+
+#define TE_WORLDDECALHIGH	117		// Decal (with texture index > 256) applied to world brush
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// byte (texture index of precached decal texture name - 256)
+
+#define TE_DECALHIGH		118		// Same as TE_DECAL, but the texture index was greater than 256
+// coord, coord, coord (x,y,z), decal position (center of texture in world)
+// byte (texture index of precached decal texture name - 256)
+// short (entity index)
+
+#define TE_PROJECTILE		119		// Makes a projectile (like a nail) (this is a high-priority tent)
+// coord, coord, coord (position)
+// coord, coord, coord (velocity)
+// short (modelindex)
+// byte (life)
+// byte (owner)  projectile won't collide with owner (if owner == 0, projectile will hit any client).
+
+#define TE_SPRAY			120		// Throws a shower of sprites or models
+// coord, coord, coord (position)
+// coord, coord, coord (direction)
+// short (modelindex)
+// byte (count)
+// byte (speed)
+// byte (noise)
+// byte (rendermode)
+
+#define TE_PLAYERSPRITES	121		// sprites emit from a player's bounding box (ONLY use for players!)
+// byte (playernum)
+// short (sprite modelindex)
+// byte (count)
+// byte (variance) (0 = no variance in size) (10 = 10% variance in size)
+
+#define TE_PARTICLEBURST	122		// very similar to lavasplash.
+// coord (origin)
+// short (radius)
+// byte (particle color)
+// byte (duration * 10) (will be randomized a bit)
+
+#define TE_FIREFIELD			123		// makes a field of fire.
+// coord (origin)
+// short (radius) (fire is made in a square around origin. -radius, -radius to radius, radius)
+// short (modelindex)
+// byte (count)
+// byte (flags)
+// byte (duration (in seconds) * 10) (will be randomized a bit)
+//
+// to keep network traffic low, this message has associated flags that fit into a byte:
+#define TEFIRE_FLAG_ALLFLOAT	1 // all sprites will drift upwards as they animate
+#define TEFIRE_FLAG_SOMEFLOAT	2 // some of the sprites will drift upwards. (50% chance)
+#define TEFIRE_FLAG_LOOP		4 // if set, sprite plays at 15 fps, otherwise plays at whatever rate stretches the animation over the sprite's duration.
+#define TEFIRE_FLAG_ALPHA		8 // if set, sprite is rendered alpha blended at 50% else, opaque
+#define TEFIRE_FLAG_PLANAR		16 // if set, all fire sprites have same initial Z instead of randomly filling a cube. 
+#define TEFIRE_FLAG_ADDITIVE	32 // if set, sprite is rendered non-opaque with additive
+
+#define TE_PLAYERATTACHMENT			124 // attaches a TENT to a player (this is a high-priority tent)
+// byte (entity index of player)
+// coord (vertical offset) ( attachment origin.z = player origin.z + vertical offset )
+// short (model index)
+// short (life * 10 );
+
+#define TE_KILLPLAYERATTACHMENTS	125 // will expire all TENTS attached to a player.
+// byte (entity index of player)
+
+#define TE_MULTIGUNSHOT				126 // much more compact shotgun message
+// This message is used to make a client approximate a 'spray' of gunfire.
+// Any weapon that fires more than one bullet per frame and fires in a bit of a spread is
+// a good candidate for MULTIGUNSHOT use. (shotguns)
+//
+// NOTE: This effect makes the client do traces for each bullet, these client traces ignore
+//		 entities that have studio models.Traces are 4096 long.
+//
+// coord (origin)
+// coord (origin)
+// coord (origin)
+// coord (direction)
+// coord (direction)
+// coord (direction)
+// coord (x noise * 100)
+// coord (y noise * 100)
+// byte (count)
+// byte (bullethole decal texture index)
+
+#define TE_USERTRACER				127 // larger message than the standard tracer, but allows some customization.
+// coord (origin)
+// coord (origin)
+// coord (origin)
+// coord (velocity)
+// coord (velocity)
+// coord (velocity)
+// byte ( life * 10 )
+// byte ( color ) this is an index into an array of color vectors in the engine. (0 - )
+// byte ( length * 10 )
+
+
+
+#define	MSG_BROADCAST		0		// unreliable to all
+#define	MSG_ONE				1		// reliable to one (msg_entity)
+#define	MSG_ALL				2		// reliable to all
+#define	MSG_INIT			3		// write to the init string
+#define MSG_PVS				4		// Ents in PVS of org
+#define MSG_PAS				5		// Ents in PAS of org
+#define MSG_PVS_R			6		// Reliable to PVS
+#define MSG_PAS_R			7		// Reliable to PAS
+#define MSG_ONE_UNRELIABLE	8		// Send to one client, but don't put in reliable stream, put in unreliable datagram ( could be dropped )
+#define	MSG_SPEC			9		// Sends to all spectator proxies
+
+// contents of a spot in the world
+#define	CONTENTS_EMPTY		-1
+#define	CONTENTS_SOLID		-2
+#define	CONTENTS_WATER		-3
+#define	CONTENTS_SLIME		-4
+#define	CONTENTS_LAVA		-5
+#define	CONTENTS_SKY		-6
+/* These additional contents constants are defined in bspfile.h
+#define	CONTENTS_ORIGIN		-7		// removed at csg time
+#define	CONTENTS_CLIP		-8		// changed to contents_solid
+#define	CONTENTS_CURRENT_0		-9
+#define	CONTENTS_CURRENT_90		-10
+#define	CONTENTS_CURRENT_180	-11
+#define	CONTENTS_CURRENT_270	-12
+#define	CONTENTS_CURRENT_UP		-13
+#define	CONTENTS_CURRENT_DOWN	-14
+
+#define CONTENTS_TRANSLUCENT	-15
+*/
+#define	CONTENTS_LADDER				-16
+
+#define	CONTENT_FLYFIELD			-17
+#define	CONTENT_GRAVITY_FLYFIELD	-18
+#define	CONTENT_FOG					-19
+
+#define CONTENT_EMPTY	-1
+#define CONTENT_SOLID	-2
+#define	CONTENT_WATER	-3
+#define CONTENT_SLIME	-4
+#define CONTENT_LAVA	-5
+#define CONTENT_SKY		-6
+
+// channels
+#define CHAN_AUTO			0
+#define CHAN_WEAPON			1
+#define	CHAN_VOICE			2
+#define CHAN_ITEM			3
+#define	CHAN_BODY			4
+#define CHAN_STREAM			5			// allocate stream channel from the static or dynamic area
+#define CHAN_STATIC			6			// allocate channel from the static area 
+#define CHAN_NETWORKVOICE_BASE	7		// voice data coming across the network
+#define CHAN_NETWORKVOICE_END	500		// network voice data reserves slots (CHAN_NETWORKVOICE_BASE through CHAN_NETWORKVOICE_END).
+#define CHAN_BOT			501			// channel used for bot chatter.
+
+// attenuation values
+#define ATTN_NONE		0
+#define	ATTN_NORM		(float)0.8
+#define ATTN_IDLE		(float)2
+#define ATTN_STATIC		(float)1.25 
+
+// pitch values
+#define	PITCH_NORM		100			// non-pitch shifted
+#define PITCH_LOW		95			// other values are possible - 0-255, where 255 is very high
+#define PITCH_HIGH		120
+
+// volume values
+#define VOL_NORM		1.0
+
+// plats
+#define	PLAT_LOW_TRIGGER	1
+
+// Trains
+#define	SF_TRAIN_WAIT_RETRIGGER	1
+#define SF_TRAIN_START_ON		4		// Train is initially moving
+#define SF_TRAIN_PASSABLE		8		// Train is not solid -- used to make water trains
+
+// buttons
+#ifndef IN_BUTTONS_H
+#include "in_buttons.h"
+#endif
+
+// Break Model Defines
+
+#define BREAK_TYPEMASK	0x4F
+#define BREAK_GLASS		0x01
+#define BREAK_METAL		0x02
+#define BREAK_FLESH		0x04
+#define BREAK_WOOD		0x08
+
+#define BREAK_SMOKE		0x10
+#define BREAK_TRANS		0x20
+#define BREAK_CONCRETE	0x40
+#define BREAK_2			0x80
+
+// Colliding temp entity sounds
+
+#define BOUNCE_GLASS	BREAK_GLASS
+#define	BOUNCE_METAL	BREAK_METAL
+#define BOUNCE_FLESH	BREAK_FLESH
+#define BOUNCE_WOOD		BREAK_WOOD
+#define BOUNCE_SHRAP	0x10
+#define BOUNCE_SHELL	0x20
+#define	BOUNCE_CONCRETE BREAK_CONCRETE
+#define BOUNCE_SHOTSHELL 0x80
+
+// Temp entity bounce sound types
+#define TE_BOUNCE_NULL		0
+#define TE_BOUNCE_SHELL		1
+#define TE_BOUNCE_SHOTSHELL	2
+
+// Rendering constants
+enum 
+{	
+	kRenderNormal,			// src
+	kRenderTransColor,		// c*a+dest*(1-a)
+	kRenderTransTexture,	// src*a+dest*(1-a)
+	kRenderGlow,			// src*a+dest -- No Z buffer checks
+	kRenderTransAlpha,		// src*srca+dest*(1-srca)
+	kRenderTransAdd,		// src*a+dest
+};
+
+enum 
+{	
+	kRenderFxNone = 0, 
+	kRenderFxPulseSlow, 
+	kRenderFxPulseFast, 
+	kRenderFxPulseSlowWide, 
+	kRenderFxPulseFastWide, 
+	kRenderFxFadeSlow, 
+	kRenderFxFadeFast, 
+	kRenderFxSolidSlow, 
+	kRenderFxSolidFast, 	   
+	kRenderFxStrobeSlow, 
+	kRenderFxStrobeFast, 
+	kRenderFxStrobeFaster, 
+	kRenderFxFlickerSlow, 
+	kRenderFxFlickerFast,
+	kRenderFxNoDissipation,
+	kRenderFxDistort,			// Distort/scale/translate flicker
+	kRenderFxHologram,			// kRenderFxDistort + distance fade
+	kRenderFxDeadPlayer,		// kRenderAmt is the player index
+	kRenderFxExplode,			// Scale up really big!
+	kRenderFxGlowShell,			// Glowing Shell
+	kRenderFxClampMinScale,		// Keep this sprite from getting very small (SPRITES only!)
+	kRenderFxLightMultiplier,   //CTM !!!CZERO added to tell the studiorender that the value in iuser2 is a lightmultiplier
+};
+
+
+typedef int	func_t;
+typedef int	string_t;
+
+typedef unsigned char 		byte;
+typedef unsigned short 		word;
+#define _DEF_BYTE_
+
+#undef true
+#undef false
+
+#ifndef __cplusplus
+typedef enum {false, true}	qboolean;
+#else 
+typedef int qboolean;
+#endif
+
+typedef struct
+{
+	byte r, g, b;
+} color24;
+
+typedef struct
+{
+	unsigned r, g, b, a;
+} colorVec;
+
+#ifdef _WIN32
+#pragma pack(push,2)
+#endif
+
+typedef struct
+{
+	unsigned short r, g, b, a;
+} PackedColorVec;
+
+#ifdef _WIN32
+#pragma pack(pop)
+#endif
+typedef struct link_s
+{
+	struct link_s	*prev, *next;
+} link_t;
+
+typedef struct edict_s edict_t;
+
+typedef struct
+{
+	vec3_t	normal;
+	float	dist;
+} plane_t;
+
+typedef struct
+{
+	qboolean	allsolid;	// if true, plane is not valid
+	qboolean	startsolid;	// if true, the initial point was in a solid area
+	qboolean	inopen, inwater;
+	float	fraction;		// time completed, 1.0 = didn't hit anything
+	vec3_t	endpos;			// final position
+	plane_t	plane;			// surface normal at impact
+	edict_t	*ent;			// entity the surface is on
+	int		hitgroup;		// 0 == generic, non zero is specific body part
+} trace_t;
+
+#endif
+

MiniBase/ValveSDK/crc.h

@@ -0,0 +1,65 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/* crc.h */
+#ifndef CRC_H
+#define CRC_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "archtypes.h"     // DAL
+
+// MD5 Hash
+typedef struct
+{
+	unsigned int buf[4];
+    unsigned int bits[2];
+    unsigned char in[64];
+} MD5Context_t;
+
+
+#ifdef _WIN32
+typedef uint32 CRC32_t;
+#else
+typedef uint32 CRC32_t;
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+void CRC32_Init(CRC32_t *pulCRC);
+CRC32_t CRC32_Final(CRC32_t pulCRC);
+void CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len);
+void CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch);
+int CRC_File(CRC32_t *crcvalue, char *pszFileName);
+#ifdef __cplusplus
+}
+#endif
+unsigned char COM_BlockSequenceCRCByte (unsigned char *base, int length, int sequence);
+
+void MD5Init(MD5Context_t *context);
+void MD5Update(MD5Context_t *context, unsigned char const *buf,
+               unsigned int len);
+void MD5Final(unsigned char digest[16], MD5Context_t *context);
+void Transform(unsigned int buf[4], unsigned int const in[16]);
+
+int MD5_Hash_File(unsigned char digest[16], char *pszFileName, int bUsefopen, int bSeed, unsigned int seed[4]);
+char *MD5_Print(unsigned char hash[16]);
+int MD5_Hash_CachedFile(unsigned char digest[16], unsigned char *pCache, int nFileSize, int bSeed, unsigned int seed[4]);
+
+int CRC_MapFile(CRC32_t *crcvalue, char *pszFileName);
+
+#endif

MiniBase/ValveSDK/custom.h

@@ -0,0 +1,103 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// Customization.h
+
+#ifndef CUSTOM_H
+#define CUSTOM_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "const.h"
+
+#define MAX_QPATH 64    // Must match value in quakedefs.h
+
+/////////////////
+// Customization
+// passed to pfnPlayerCustomization
+// For automatic downloading.
+typedef enum
+{
+	t_sound = 0,
+	t_skin,
+	t_model,
+	t_decal,
+	t_generic,
+	t_eventscript,
+	t_world,		// Fake type for world, is really t_model
+} resourcetype_t;
+
+
+typedef struct
+{
+	int				size;
+} _resourceinfo_t;
+
+typedef struct resourceinfo_s
+{
+	_resourceinfo_t info[ 8 ];
+} resourceinfo_t;
+
+#define RES_FATALIFMISSING (1<<0)   // Disconnect if we can't get this file.
+#define RES_WASMISSING     (1<<1)   // Do we have the file locally, did we get it ok?
+#define RES_CUSTOM         (1<<2)   // Is this resource one that corresponds to another player's customization
+								    // or is it a server startup resource.
+#define RES_REQUESTED	   (1<<3)	// Already requested a download of this one
+#define RES_PRECACHED	   (1<<4)	// Already precached
+#define RES_ALWAYS		   (1<<5)	// download always even if available on client	
+#define RES_CHECKFILE	   (1<<7)	// check file on client
+
+#include "crc.h"
+
+typedef struct resource_s
+{
+	char              szFileName[MAX_QPATH]; // File name to download/precache.
+	resourcetype_t    type;                // t_sound, t_skin, t_model, t_decal.
+	int               nIndex;              // For t_decals
+	int               nDownloadSize;       // Size in Bytes if this must be downloaded.
+	unsigned char     ucFlags;
+
+// For handling client to client resource propagation
+	unsigned char     rgucMD5_hash[16];    // To determine if we already have it.
+	unsigned char     playernum;           // Which player index this resource is associated with, if it's a custom resource.
+
+	unsigned char	  rguc_reserved[ 32 ]; // For future expansion
+	struct resource_s *pNext;              // Next in chain.
+	struct resource_s *pPrev;
+} resource_t;
+
+typedef struct customization_s
+{
+	qboolean bInUse;     // Is this customization in use;
+	resource_t resource; // The resource_t for this customization
+	qboolean bTranslated; // Has the raw data been translated into a useable format?  
+						   //  (e.g., raw decal .wad make into texture_t *)
+	int        nUserData1; // Customization specific data
+	int        nUserData2; // Customization specific data
+	void *pInfo;          // Buffer that holds the data structure that references the data (e.g., the cachewad_t)
+	void *pBuffer;       // Buffer that holds the data for the customization (the raw .wad data)
+	struct customization_s *pNext; // Next in chain
+} customization_t;
+
+#define FCUST_FROMHPAK		( 1<<0 )
+#define FCUST_WIPEDATA		( 1<<1 )
+#define FCUST_IGNOREINIT	( 1<<2 )
+
+void		COM_ClearCustomizationList( struct customization_s *pHead, qboolean bCleanDecals);
+qboolean	COM_CreateCustomization( struct customization_s *pListHead, struct resource_s *pResource, int playernumber, int flags, 
+				struct customization_s **pCustomization, int *nLumps ); 
+int			COM_SizeofResourceList ( struct resource_s *pList, struct resourceinfo_s *ri );
+
+#endif // CUSTOM_H

MiniBase/ValveSDK/cvardef.h

@@ -0,0 +1,36 @@
+/***
+*
+*	Copyright (c) 1999, 2000, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef CVARDEF_H
+#define CVARDEF_H
+
+#define	FCVAR_ARCHIVE		(1<<0)	// set to cause it to be saved to vars.rc
+#define	FCVAR_USERINFO		(1<<1)	// changes the client's info string
+#define	FCVAR_SERVER		(1<<2)	// notifies players when changed
+#define FCVAR_EXTDLL		(1<<3)	// defined by external DLL
+#define FCVAR_CLIENTDLL     (1<<4)  // defined by the client dll
+#define FCVAR_PROTECTED     (1<<5)  // It's a server cvar, but we don't send the data since it's a password, etc.  Sends 1 if it's not bland/zero, 0 otherwise as value
+#define FCVAR_SPONLY        (1<<6)  // This cvar cannot be changed by clients connected to a multiplayer server.
+#define FCVAR_PRINTABLEONLY (1<<7)  // This cvar's string cannot contain unprintable characters ( e.g., used for player name etc ).
+#define FCVAR_UNLOGGED		(1<<8)  // If this is a FCVAR_SERVER, don't log changes to the log file / console if we are creating a log
+
+typedef struct cvar_s
+{
+	char	*name;
+	char	*string;
+	int		flags;
+	float	value;
+	struct cvar_s *next;
+} cvar_t;
+#endif

MiniBase/ValveSDK/dlight.h

@@ -0,0 +1,33 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined ( DLIGHTH )
+#define DLIGHTH
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef struct dlight_s
+{
+	vec3_t	origin;
+	float	radius;
+	color24	color;
+	float	die;				// stop lighting after this time
+	float	decay;				// drop this each second
+	float	minlight;			// don't add when contributing less
+	int		key;
+	qboolean	dark;			// subtracts light instead of adding
+} dlight_t;
+
+#endif

MiniBase/ValveSDK/edict.h

@@ -0,0 +1,36 @@
+//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#if !defined EDICT_H
+#define EDICT_H
+#ifdef _WIN32
+#pragma once
+#endif
+#define	MAX_ENT_LEAFS	48
+
+#include "progdefs.h"
+
+struct edict_s
+{
+	qboolean	free;
+	int			serialnumber;
+	link_t		area;				// linked to a division node or leaf
+	
+	int			headnode;			// -1 to use normal leaf check
+	int			num_leafs;
+	short		leafnums[MAX_ENT_LEAFS];
+
+	float		freetime;			// sv.time when the object was freed
+
+	void*		pvPrivateData;		// Alloced and freed by engine, used by DLLs
+
+	entvars_t	v;					// C exported fields from progs
+
+	// other fields from progs come immediately after
+};
+
+#endif

MiniBase/ValveSDK/engine_launcher_api.h

@@ -0,0 +1,104 @@
+// engine/launcher interface
+#if !defined( ENGINE_LAUNCHER_APIH )
+#define ENGINE_LAUNCHER_APIH
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef void ( *xcommand_t ) ( void );
+
+#define RENDERTYPE_UNDEFINED	0
+#define RENDERTYPE_SOFTWARE		1
+#define RENDERTYPE_HARDWARE		2
+#define RENDERTYPE_D3D			3
+
+#define ENGINE_LAUNCHER_API_VERSION 1
+
+typedef struct engine_api_s
+{
+	int		version;
+	int		rendertype;
+	int		size;
+
+	// Functions
+	int		( *GetEngineState )				( void );
+	void	( *Cbuf_AddText )				( char *text ); // append cmd at end of buf
+	void	( *Cbuf_InsertText )			( char *text ); // insert cmd at start of buf
+	void	( *Cmd_AddCommand )				( char *cmd_name, void ( *funcname )( void ) );
+	int		( *Cmd_Argc )					( void );
+	char	*( *Cmd_Args )					( void );
+	char	*( *Cmd_Argv )					( int arg );
+	void	( *Con_Printf )					( char *, ... );
+	void	( *Con_SafePrintf )				( char *, ... );
+	void	( *Cvar_Set )					( char *var_name, char *value );
+	void	( *Cvar_SetValue )				( char *var_name, float value );
+	int		( *Cvar_VariableInt )			( char *var_name );
+	char	*( *Cvar_VariableString )		( char *var_name );
+	float	( *Cvar_VariableValue )			( char *var_name );
+	void	( *ForceReloadProfile )			( void );
+	int		( *GetGameInfo )				( struct GameInfo_s *pGI, char *pszChannel );
+	void	( *GameSetBackground )			( int bBack );
+	void	( *GameSetState )				( int iState );
+	void	( *GameSetSubState )			( int iState );
+	int		( *GetPauseState )				( void );
+	int		( *Host_Frame )					( float time, int iState, int *stateInfo );
+	void	( *Host_GetHostInfo )			( float *fps, int *nActive, int *nSpectators, int *nMaxPlayers, char *pszMap );
+	void	( *Host_Shutdown )				( void );
+	int		( *Game_Init )					( char *lpCmdLine, unsigned char *pMem, int iSize, struct exefuncs_s *pef, void *, int );
+	void	( *IN_ActivateMouse )			( void );
+	void	( *IN_ClearStates )				( void );
+	void	( *IN_DeactivateMouse )			( void );
+	void	( *IN_MouseEvent )				( int mstate );
+	void	( *Keyboard_ReturnToGame )		( void );
+	void	( *Key_ClearStates )			( void );
+	void	( *Key_Event )					( int key, int down );
+	int		( *LoadGame )					( const char *pszSlot );
+	void	( *S_BlockSound )				( void );
+	void	( *S_ClearBuffer )				( void );
+	void	( *S_GetDSPointer )				( struct IDirectSound **lpDS, struct IDirectSoundBuffer **lpDSBuf );
+	void 	*( *S_GetWAVPointer )			( void );
+	void	( *S_UnblockSound )				( void );
+	int		( *SaveGame )					( const char *pszSlot, const char *pszComment );
+	void	( *SetAuth )					( void *pobj );
+	void	( *SetMessagePumpDisableMode )	( int bMode );
+	void	( *SetPauseState )				( int bPause );
+	void	( *SetStartupMode )				( int bMode );
+	void	( *SNDDMA_Shutdown )			( void );
+	void	( *Snd_AcquireBuffer )			( void );
+	void	( *Snd_ReleaseBuffer )			( void );
+	void	( *StoreProfile )				( void );
+	double	( *Sys_FloatTime )				( void );
+	void	( *VID_UpdateWindowVars )		( void *prc, int x, int y );
+	void	( *VID_UpdateVID )				( struct viddef_s *pvid );
+
+	// VGUI interfaces
+	void	( *VGui_CallEngineSurfaceProc )	( void* hwnd, unsigned int msg, unsigned int wparam, long lparam );
+
+	// notifications that the launcher is taking/giving focus to the engine
+	void    ( *EngineTakingFocus )			( void );
+	void    ( *LauncherTakingFocus )		( void );
+
+#ifdef _WIN32
+	// Only filled in by rendertype RENDERTYPE_HARDWARE
+	void	( *GL_Init )					( void );
+	int		( *GL_SetMode )					( HWND hwndGame, HDC *pmaindc, HGLRC *pbaseRC, int fD3D, const char *p, const char *pszCmdLine );
+	void	( *GL_Shutdown )				( HWND hwnd, HDC hdc, HGLRC hglrc );
+
+	void	( *QGL_D3DShared )				( struct tagD3DGlobals *d3dGShared );
+
+	int		( WINAPI *glSwapBuffers )		( HDC dc );
+	void	( *DirectorProc ) ( unsigned int cmd, void * params );
+#else
+	// NOT USED IN LINUX!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	void	( *GL_Init )					( void );
+	void	( *GL_SetMode )					( void );
+	void	( *GL_Shutdown )				( void );
+	void	( *QGL_D3DShared )				( void );
+	void	( *glSwapBuffers )				( void );
+	void	( *DirectorProc )				( void );
+	// LINUX
+#endif
+
+} engine_api_t;
+
+#endif // ENGINE_LAUNCHER_APIH

MiniBase/ValveSDK/entity_state.h

@@ -0,0 +1,193 @@
+/***
+*
+*	Copyright (c) 1999, 2000, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( ENTITY_STATEH )
+#define ENTITY_STATEH
+#ifdef _WIN32
+#pragma once
+#endif
+
+// For entityType below
+#define ENTITY_NORMAL		(1<<0)
+#define ENTITY_BEAM			(1<<1)
+
+// Entity state is used for the baseline and for delta compression of a packet of 
+//  entities that is sent to a client.
+typedef struct entity_state_s entity_state_t;
+
+struct entity_state_s
+{
+// Fields which are filled in by routines outside of delta compression
+	int			entityType;
+	// Index into cl_entities array for this entity.
+	int			number;      
+	float		msg_time;
+
+	// Message number last time the player/entity state was updated.
+	int			messagenum;		
+
+	// Fields which can be transitted and reconstructed over the network stream
+	vec3_t		origin;
+	vec3_t		angles;
+
+	int			modelindex;
+	int			sequence;
+	float		frame;
+	int			colormap;
+	short		skin;
+	short		solid;
+	int			effects;
+	float		scale;
+
+	byte		eflags;
+	
+	// Render information
+	int			rendermode;
+	int			renderamt;
+	color24		rendercolor;
+	int			renderfx;
+
+	int			movetype;
+	float		animtime;
+	float		framerate;
+	int			body;
+	byte		controller[4];
+	byte		blending[4];
+	vec3_t		velocity;
+
+	// Send bbox down to client for use during prediction.
+	vec3_t		mins;    
+	vec3_t		maxs;
+
+	int			aiment;
+	// If owned by a player, the index of that player ( for projectiles ).
+	int			owner; 
+
+	// Friction, for prediction.
+	float		friction;       
+	// Gravity multiplier
+	float		gravity;		
+
+// PLAYER SPECIFIC
+	int			team;
+	int			playerclass;
+	int			health;
+	qboolean	spectator;  
+	int         weaponmodel;
+	int			gaitsequence;
+	// If standing on conveyor, e.g.
+	vec3_t		basevelocity;   
+	// Use the crouched hull, or the regular player hull.
+	int			usehull;		
+	// Latched buttons last time state updated.
+	int			oldbuttons;     
+	// -1 = in air, else pmove entity number
+	int			onground;		
+	int			iStepLeft;
+	// How fast we are falling
+	float		flFallVelocity;  
+
+	float		fov;
+	int			weaponanim;
+
+	// Parametric movement overrides
+	vec3_t				startpos;
+	vec3_t				endpos;
+	float				impacttime;
+	float				starttime;
+
+	// For mods
+	int			iuser1;
+	int			iuser2;
+	int			iuser3;
+	int			iuser4;
+	float		fuser1;
+	float		fuser2;
+	float		fuser3;
+	float		fuser4;
+	vec3_t		vuser1;
+	vec3_t		vuser2;
+	vec3_t		vuser3;
+	vec3_t		vuser4;
+};
+
+#include "pm_info.h"
+
+typedef struct clientdata_s
+{
+	vec3_t				origin;
+	vec3_t				velocity;
+
+	int					viewmodel;
+	vec3_t				punchangle;
+	int					flags;
+	int					waterlevel;
+	int					watertype;
+	vec3_t				view_ofs;
+	float				health;
+
+	int					bInDuck;
+
+	int					weapons; // remove?
+	
+	int					flTimeStepSound;
+	int					flDuckTime;
+	int					flSwimTime;
+	int					waterjumptime;
+
+	float				maxspeed;
+
+	float				fov;
+	int					weaponanim;
+
+	int					m_iId;
+	int					ammo_shells;
+	int					ammo_nails;
+	int					ammo_cells;
+	int					ammo_rockets;
+	float				m_flNextAttack;
+	
+	int					tfstate;
+
+	int					pushmsec;
+
+	int					deadflag;
+
+	char				physinfo[ MAX_PHYSINFO_STRING ];
+
+	// For mods
+	int					iuser1;
+	int					iuser2;
+	int					iuser3;
+	int					iuser4;
+	float				fuser1;
+	float				fuser2;
+	float				fuser3;
+	float				fuser4;
+	vec3_t				vuser1;
+	vec3_t				vuser2;
+	vec3_t				vuser3;
+	vec3_t				vuser4;
+} clientdata_t;
+
+#include "weaponinfo.h"
+
+typedef struct local_state_s
+{
+	entity_state_t playerstate;
+	clientdata_t   client;
+	weapon_data_t  weapondata[ 32 ];
+} local_state_t;
+
+#endif // !ENTITY_STATEH

MiniBase/ValveSDK/entity_types.h

@@ -0,0 +1,26 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// entity_types.h
+#if !defined( ENTITY_TYPESH )
+#define ENTITY_TYPESH
+
+#define ET_NORMAL		0
+#define ET_PLAYER		1
+#define ET_TEMPENTITY	2
+#define ET_BEAM			3
+// BMODEL or SPRITE that was split across BSP nodes
+#define ET_FRAGMENTED	4
+
+#endif // !ENTITY_TYPESH

MiniBase/ValveSDK/event_api.h

@@ -0,0 +1,51 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined ( EVENT_APIH )
+#define EVENT_APIH
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define EVENT_API_VERSION 1
+
+typedef struct event_api_s
+{
+	int		version;
+	void	( *EV_PlaySound ) ( int ent, float *origin, int channel, const char *sample, float volume, float attenuation, int fFlags, int pitch );
+	void	( *EV_StopSound ) ( int ent, int channel, const char *sample );
+	int		( *EV_FindModelIndex )( const char *pmodel );
+	int		( *EV_IsLocal ) ( int playernum );
+	int		( *EV_LocalPlayerDucking ) ( void );
+	void	( *EV_LocalPlayerViewheight ) ( float * );
+	void	( *EV_LocalPlayerBounds ) ( int hull, float *mins, float *maxs );
+	int		( *EV_IndexFromTrace) ( struct pmtrace_s *pTrace );
+	struct physent_s *( *EV_GetPhysent ) ( int idx );
+	void	( *EV_SetUpPlayerPrediction ) ( int dopred, int bIncludeLocalClient );
+	void	( *EV_PushPMStates ) ( void );
+	void	( *EV_PopPMStates ) ( void );
+	void	( *EV_SetSolidPlayers ) (int playernum);
+	void	( *EV_SetTraceHull ) ( int hull );
+	void	( *EV_PlayerTrace ) ( float *start, float *end, int traceFlags, int ignore_pe, struct pmtrace_s *tr );
+	void	( *EV_WeaponAnimation ) ( int sequence, int body );
+	unsigned short ( *EV_PrecacheEvent ) ( int type, const char* psz );
+	void	( *EV_PlaybackEvent ) ( int flags, const struct edict_s *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
+	const char *( *EV_TraceTexture ) ( int ground, float *vstart, float *vend );
+	void	( *EV_StopAllSounds ) ( int entnum, int entchannel );
+	void    ( *EV_KillEvents ) ( int entnum, const char *eventname );
+} event_api_t;
+
+extern event_api_t eventapi;
+
+#endif

MiniBase/ValveSDK/event_args.h

@@ -0,0 +1,50 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( EVENT_ARGSH )
+#define EVENT_ARGSH
+#ifdef _WIN32
+#pragma once
+#endif
+
+// Event was invoked with stated origin
+#define FEVENT_ORIGIN	( 1<<0 )
+
+// Event was invoked with stated angles
+#define FEVENT_ANGLES	( 1<<1 )
+
+typedef struct event_args_s
+{
+	int		flags;
+
+	// Transmitted
+	int		entindex;
+
+	float	origin[3];
+	float	angles[3];
+	float	velocity[3];
+
+	int		ducking;
+
+	float	fparam1;
+	float	fparam2;
+
+	int		iparam1;
+	int		iparam2;
+
+	int		bparam1;
+	int		bparam2;
+} event_args_t;
+
+#endif

MiniBase/ValveSDK/event_flags.h

@@ -0,0 +1,47 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( EVENT_FLAGSH )
+#define EVENT_FLAGSH
+#ifdef _WIN32
+#pragma once
+#endif
+
+// Skip local host for event send.
+#define FEV_NOTHOST		(1<<0)    
+
+// Send the event reliably.  You must specify the origin and angles and use
+// PLAYBACK_EVENT_FULL for this to work correctly on the server for anything
+// that depends on the event origin/angles.  I.e., the origin/angles are not
+// taken from the invoking edict for reliable events.
+#define FEV_RELIABLE	(1<<1)	 
+
+// Don't restrict to PAS/PVS, send this event to _everybody_ on the server ( useful for stopping CHAN_STATIC
+//  sounds started by client event when client is not in PVS anymore ( hwguy in TFC e.g. ).
+#define FEV_GLOBAL		(1<<2)
+
+// If this client already has one of these events in its queue, just update the event instead of sending it as a duplicate
+//
+#define FEV_UPDATE		(1<<3)
+
+// Only send to entity specified as the invoker
+#define	FEV_HOSTONLY	(1<<4)
+
+// Only send if the event was created on the server.
+#define FEV_SERVER		(1<<5)
+
+// Only issue event client side ( from shared code )
+#define FEV_CLIENT		(1<<6)
+
+#endif

MiniBase/ValveSDK/in_buttons.h

@@ -0,0 +1,38 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef IN_BUTTONS_H
+#define IN_BUTTONS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define IN_ATTACK	(1 << 0)
+#define IN_JUMP		(1 << 1)
+#define IN_DUCK		(1 << 2)
+#define IN_FORWARD	(1 << 3)
+#define IN_BACK		(1 << 4)
+#define IN_USE		(1 << 5)
+#define IN_CANCEL	(1 << 6)
+#define IN_LEFT		(1 << 7)
+#define IN_RIGHT	(1 << 8)
+#define IN_MOVELEFT	(1 << 9)
+#define IN_MOVERIGHT (1 << 10)
+#define IN_ATTACK2	(1 << 11)
+#define IN_RUN      (1 << 12)
+#define IN_RELOAD	(1 << 13)
+#define IN_ALT1		(1 << 14)
+#define IN_SCORE	(1 << 15)   // Used by client.dll for when scoreboard is held down
+
+#endif // IN_BUTTONS_H

MiniBase/ValveSDK/keydefs.h

@@ -0,0 +1,124 @@
+// keydefs.h
+#ifndef KEYDEFS_H
+#define KEYDEFS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+//
+// these are the key numbers that should be passed to Key_Event
+//
+#define	K_TAB			9
+#define	K_ENTER			13
+#define	K_ESCAPE		27
+#define	K_SPACE			32
+
+// normal keys should be passed as lowercased ascii
+
+#define	K_BACKSPACE		127
+#define	K_UPARROW		128
+#define	K_DOWNARROW		129
+#define	K_LEFTARROW		130
+#define	K_RIGHTARROW	131
+
+#define	K_ALT			132
+#define	K_CTRL			133
+#define	K_SHIFT			134
+#define	K_F1			135
+#define	K_F2			136
+#define	K_F3			137
+#define	K_F4			138
+#define	K_F5			139
+#define	K_F6			140
+#define	K_F7			141
+#define	K_F8			142
+#define	K_F9			143
+#define	K_F10			144
+#define	K_F11			145
+#define	K_F12			146
+#define	K_INS			147
+#define	K_DEL			148
+#define	K_PGDN			149
+#define	K_PGUP			150
+#define	K_HOME			151
+#define	K_END			152
+
+#define K_KP_HOME		160
+#define K_KP_UPARROW	161
+#define K_KP_PGUP		162
+#define	K_KP_LEFTARROW	163
+#define K_KP_5			164
+#define K_KP_RIGHTARROW	165
+#define K_KP_END		166
+#define K_KP_DOWNARROW	167
+#define K_KP_PGDN		168
+#define	K_KP_ENTER		169
+#define K_KP_INS   		170
+#define	K_KP_DEL		171
+#define K_KP_SLASH		172
+#define K_KP_MINUS		173
+#define K_KP_PLUS		174
+#define K_CAPSLOCK		175
+#define K_KP_MUL		176
+#define K_WIN			177
+
+
+//
+// joystick buttons
+//
+#define	K_JOY1			203
+#define	K_JOY2			204
+#define	K_JOY3			205
+#define	K_JOY4			206
+
+//
+// aux keys are for multi-buttoned joysticks to generate so they can use
+// the normal binding process
+//
+#define	K_AUX1			207
+#define	K_AUX2			208
+#define	K_AUX3			209
+#define	K_AUX4			210
+#define	K_AUX5			211
+#define	K_AUX6			212
+#define	K_AUX7			213
+#define	K_AUX8			214
+#define	K_AUX9			215
+#define	K_AUX10			216
+#define	K_AUX11			217
+#define	K_AUX12			218
+#define	K_AUX13			219
+#define	K_AUX14			220
+#define	K_AUX15			221
+#define	K_AUX16			222
+#define	K_AUX17			223
+#define	K_AUX18			224
+#define	K_AUX19			225
+#define	K_AUX20			226
+#define	K_AUX21			227
+#define	K_AUX22			228
+#define	K_AUX23			229
+#define	K_AUX24			230
+#define	K_AUX25			231
+#define	K_AUX26			232
+#define	K_AUX27			233
+#define	K_AUX28			234
+#define	K_AUX29			235
+#define	K_AUX30			236
+#define	K_AUX31			237
+#define	K_AUX32			238
+#define K_MWHEELDOWN	239
+#define K_MWHEELUP		240
+
+#define K_PAUSE			255
+
+//
+// mouse buttons generate virtual keys
+//
+#define	K_MOUSE1		241
+#define	K_MOUSE2		242
+#define	K_MOUSE3		243
+#define K_MOUSE4		244
+#define K_MOUSE5		245
+
+#endif // KEYDEFS_H

MiniBase/ValveSDK/net_api.h

@@ -0,0 +1,99 @@
+//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#if !defined( NET_APIH )
+#define NET_APIH
+#ifdef _WIN32
+#pragma once
+#endif
+
+#if !defined ( NETADRH )
+#include "netadr.h"
+#endif
+
+#define NETAPI_REQUEST_SERVERLIST	( 0 )  // Doesn't need a remote address
+#define NETAPI_REQUEST_PING			( 1 )
+#define NETAPI_REQUEST_RULES		( 2 )
+#define NETAPI_REQUEST_PLAYERS		( 3 )
+#define NETAPI_REQUEST_DETAILS		( 4 )
+
+// Set this flag for things like broadcast requests, etc. where the engine should not
+//  kill the request hook after receiving the first response
+#define FNETAPI_MULTIPLE_RESPONSE ( 1<<0 )
+
+typedef void ( *net_api_response_func_t ) ( struct net_response_s *response );
+
+#define NET_SUCCESS						( 0 )
+#define NET_ERROR_TIMEOUT				( 1<<0 )
+#define NET_ERROR_PROTO_UNSUPPORTED		( 1<<1 )
+#define NET_ERROR_UNDEFINED				( 1<<2 )
+
+typedef struct net_adrlist_s
+{
+	struct net_adrlist_s	*next;
+	netadr_t				remote_address;
+} net_adrlist_t;
+
+typedef struct net_response_s
+{
+	// NET_SUCCESS or an error code
+	int			error;
+
+	// Context ID
+	int			context;
+	// Type
+	int			type;
+
+	// Server that is responding to the request
+	netadr_t	remote_address;
+
+	// Response RTT ping time
+	double		ping;
+	// Key/Value pair string ( separated by backlash \ characters )
+	// WARNING:  You must copy this buffer in the callback function, because it is freed
+	//  by the engine right after the call!!!!
+	// ALSO:  For NETAPI_REQUEST_SERVERLIST requests, this will be a pointer to a linked list of net_adrlist_t's
+	void		*response;
+} net_response_t;
+
+typedef struct net_status_s
+{
+		// Connected to remote server?  1 == yes, 0 otherwise
+	int			connected; 
+	// Client's IP address
+	netadr_t	local_address;
+	// Address of remote server
+	netadr_t	remote_address;
+	// Packet Loss ( as a percentage )
+	int			packet_loss;
+	// Latency, in seconds ( multiply by 1000.0 to get milliseconds )
+	double		latency;
+	// Connection time, in seconds
+	double		connection_time;
+	// Rate setting ( for incoming data )
+	double		rate;
+} net_status_t;
+
+typedef struct net_api_s
+{
+	// APIs
+	void		( *InitNetworking )( void );
+	void		( *Status ) ( struct net_status_s *status );
+	void		( *SendRequest) ( int context, int request, int flags, double timeout, struct netadr_s *remote_address, net_api_response_func_t response );
+	void		( *CancelRequest ) ( int context );
+	void		( *CancelAllRequests ) ( void );
+	char		*( *AdrToString ) ( struct netadr_s *a );
+	int			( *CompareAdr ) ( struct netadr_s *a, struct netadr_s *b );
+	int			( *StringToAdr ) ( char *s, struct netadr_s *a );
+	const char *( *ValueForKey ) ( const char *s, const char *key );
+	void		( *RemoveKey ) ( char *s, const char *key );
+	void		( *SetValueForKey ) (char *s, const char *key, const char *value, int maxsize );
+} net_api_t;
+
+extern net_api_t netapi;
+
+#endif // NET_APIH

MiniBase/ValveSDK/netadr.h

@@ -0,0 +1,40 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// netadr.h
+#ifndef NETADR_H
+#define NETADR_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef enum
+{
+	NA_UNUSED,
+	NA_LOOPBACK,
+	NA_BROADCAST,
+	NA_IP,
+	NA_IPX,
+	NA_BROADCAST_IPX,
+} netadrtype_t;
+
+typedef struct netadr_s
+{
+	netadrtype_t	type;
+	unsigned char	ip[4];
+	unsigned char	ipx[10];
+	unsigned short	port;
+} netadr_t;
+
+#endif // NETADR_H

MiniBase/ValveSDK/parsemsg.cpp

@@ -0,0 +1,166 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  parsemsg.cpp
+//
+typedef unsigned char byte;
+#define true 1
+
+static byte *gpBuf;
+static int giSize;
+static int giRead;
+static int giBadRead;
+
+void BEGIN_READ( void *buf, int size )
+{
+	giRead = 0;
+	giBadRead = 0;
+	giSize = size;
+	gpBuf = (byte*)buf;
+}
+
+
+int READ_CHAR( void )
+{
+	int     c;
+	
+	if (giRead + 1 > giSize)
+	{
+		giBadRead = true;
+		return -1;
+	}
+		
+	c = (signed char)gpBuf[giRead];
+	giRead++;
+	
+	return c;
+}
+
+int READ_BYTE( void )
+{
+	int     c;
+	
+	if (giRead+1 > giSize)
+	{
+		giBadRead = true;
+		return -1;
+	}
+		
+	c = (unsigned char)gpBuf[giRead];
+	giRead++;
+	
+	return c;
+}
+
+int READ_SHORT( void )
+{
+	int     c;
+	
+	if (giRead+2 > giSize)
+	{
+		giBadRead = true;
+		return -1;
+	}
+		
+	c = (short)( gpBuf[giRead] + ( gpBuf[giRead+1] << 8 ) );
+	
+	giRead += 2;
+	
+	return c;
+}
+
+int READ_WORD( void )
+{
+	return READ_SHORT();
+}
+
+
+int READ_LONG( void )
+{
+	int     c;
+	
+	if (giRead+4 > giSize)
+	{
+		giBadRead = true;
+		return -1;
+	}
+		
+ 	c = gpBuf[giRead] + (gpBuf[giRead + 1] << 8) + (gpBuf[giRead + 2] << 16) + (gpBuf[giRead + 3] << 24);
+	
+	giRead += 4;
+	
+	return c;
+}
+
+float READ_FLOAT( void )
+{
+	union
+	{
+		byte    b[4];
+		float   f;
+		int     l;
+	} dat;
+	
+	dat.b[0] = gpBuf[giRead];
+	dat.b[1] = gpBuf[giRead+1];
+	dat.b[2] = gpBuf[giRead+2];
+	dat.b[3] = gpBuf[giRead+3];
+	giRead += 4;
+	
+//	dat.l = LittleLong (dat.l);
+
+	return dat.f;   
+}
+
+char* READ_STRING( void )
+{
+	static char     string[2048];
+	int             l,c;
+
+	string[0] = 0;
+
+	l = 0;
+	do
+	{
+		if ( giRead+1 > giSize )
+			break; // no more characters
+
+		c = READ_CHAR();
+		if (c == -1 || c == 0)
+			break;
+		string[l] = c;
+		l++;
+	} while (l < sizeof(string)-1);
+	
+	string[l] = 0;
+	
+	return string;
+}
+
+float READ_COORD( void )
+{
+	return (float)(READ_SHORT() * (1.0/8));
+}
+
+float READ_ANGLE( void )
+{
+	return (float)(READ_CHAR() * (360.0/256));
+}
+
+float READ_HIRESANGLE( void )
+{
+	return (float)(READ_SHORT() * (360.0/65536));
+}
+

MiniBase/ValveSDK/parsemsg.h

@@ -0,0 +1,40 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//
+//  parsemsg.h
+//
+
+#define ASSERT( x )
+
+void BEGIN_READ( void *buf, int size );
+int READ_CHAR( void );
+int READ_BYTE( void );
+int READ_SHORT( void );
+int READ_WORD( void );
+int READ_LONG( void );
+float READ_FLOAT( void );
+char* READ_STRING( void );
+float READ_COORD( void );
+float READ_ANGLE( void );
+float READ_HIRESANGLE( void );
+
+
+
+
+
+
+
+
+

MiniBase/ValveSDK/particledef.h

@@ -0,0 +1,57 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( PARTICLEDEFH )
+#define PARTICLEDEFH
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef enum {
+	pt_static, 
+	pt_grav,
+	pt_slowgrav,
+	pt_fire,
+	pt_explode,
+	pt_explode2,
+	pt_blob,
+	pt_blob2,
+	pt_vox_slowgrav,
+	pt_vox_grav,
+	pt_clientcustom   // Must have callback function specified
+} ptype_t;
+
+// !!! if this is changed, it must be changed in d_ifacea.h too !!!
+typedef struct particle_s
+{
+// driver-usable fields
+	vec3_t		org;
+	short		color;
+	short		packedColor;
+// drivers never touch the following fields
+	struct particle_s	*next;
+	vec3_t		vel;
+	float		ramp;
+	float		die;
+	ptype_t		type;
+	void		(*deathfunc)( struct particle_s *particle );
+
+	// for pt_clientcusttom, we'll call this function each frame
+	void		(*callback)( struct particle_s *particle, float frametime );
+	
+	// For deathfunc, etc.
+	unsigned char context;
+} particle_t;
+
+#endif

MiniBase/ValveSDK/pm_defs.h

@@ -0,0 +1,223 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// pm_defs.h
+#if !defined( PM_DEFSH )
+#define PM_DEFSH
+#pragma once
+
+#include "archtypes.h"     // DAL
+#define	MAX_PHYSENTS 600 		  // Must have room for all entities in the world.
+#define MAX_MOVEENTS 64
+#define	MAX_CLIP_PLANES	5
+
+#define PM_NORMAL			0x00000000
+#define PM_STUDIO_IGNORE	0x00000001		// Skip studio models
+#define PM_STUDIO_BOX		0x00000002		// Use boxes for non-complex studio models (even in traceline)
+#define PM_GLASS_IGNORE		0x00000004		// Ignore entities with non-normal rendermode
+#define PM_WORLD_ONLY		0x00000008		// Only trace against the world
+
+// Values for flags parameter of PM_TraceLine
+#define PM_TRACELINE_PHYSENTSONLY	0
+#define PM_TRACELINE_ANYVISIBLE		1
+
+
+#include "pm_info.h"
+
+// PM_PlayerTrace results.
+#include "pmtrace.h"
+
+#if !defined ( USERCMD_H )
+#include "usercmd.h"
+#endif
+
+// physent_t
+typedef struct physent_s
+{
+	char			name[32];             // Name of model, or "player" or "world".
+	int				player;
+	vec3_t			origin;               // Model's origin in world coordinates.
+	struct model_s	*model;		          // only for bsp models
+	struct model_s	*studiomodel;         // SOLID_BBOX, but studio clip intersections.
+	vec3_t			mins, maxs;	          // only for non-bsp models
+	int				info;		          // For client or server to use to identify (index into edicts or cl_entities)
+	vec3_t			angles;               // rotated entities need this info for hull testing to work.
+
+	int				solid;				  // Triggers and func_door type WATER brushes are SOLID_NOT
+	int				skin;                 // BSP Contents for such things like fun_door water brushes.
+	int				rendermode;			  // So we can ignore glass
+	
+	// Complex collision detection.
+	float			frame;
+	int				sequence;
+	byte			controller[4];
+	byte			blending[2];
+
+	int				movetype;
+	int				takedamage;
+	int				blooddecal;
+	int				team;
+	int				classnumber;
+
+	// For mods
+	int				iuser1;
+	int				iuser2;
+	int				iuser3;
+	int				iuser4;
+	float			fuser1;
+	float			fuser2;
+	float			fuser3;
+	float			fuser4;
+	vec3_t			vuser1;
+	vec3_t			vuser2;
+	vec3_t			vuser3;
+	vec3_t			vuser4;
+} physent_t;
+
+
+typedef struct playermove_s
+{
+	int				player_index;  // So we don't try to run the PM_CheckStuck nudging too quickly.
+	qboolean		server;        // For debugging, are we running physics code on server side?
+
+	qboolean		multiplayer;   // 1 == multiplayer server
+	float			time;          // realtime on host, for reckoning duck timing
+	float			frametime;	   // Duration of this frame
+
+	vec3_t			forward, right, up; // Vectors for angles
+	// player state
+	vec3_t			origin;        // Movement origin.
+	vec3_t			angles;        // Movement view angles.
+	vec3_t			oldangles;     // Angles before movement view angles were looked at.
+	vec3_t			velocity;      // Current movement direction.
+	vec3_t			movedir;       // For waterjumping, a forced forward velocity so we can fly over lip of ledge.
+	vec3_t			basevelocity;  // Velocity of the conveyor we are standing, e.g.
+	
+	// For ducking/dead
+	vec3_t			view_ofs;      // Our eye position.
+	float			flDuckTime;    // Time we started duck
+	qboolean		bInDuck;       // In process of ducking or ducked already?
+	
+	// For walking/falling
+	int				flTimeStepSound;  // Next time we can play a step sound
+	int				iStepLeft;
+
+	float			flFallVelocity;
+	vec3_t			punchangle;
+
+	float			flSwimTime;
+
+	float			flNextPrimaryAttack;
+
+	int				effects;		// MUZZLE FLASH, e.g.
+
+	int				flags;         // FL_ONGROUND, FL_DUCKING, etc.
+	int				usehull;       // 0 = regular player hull, 1 = ducked player hull, 2 = point hull
+	float			gravity;       // Our current gravity and friction.
+	float			friction;
+	int				oldbuttons;    // Buttons last usercmd
+	float			waterjumptime; // Amount of time left in jumping out of water cycle.
+	qboolean		dead;          // Are we a dead player?
+	int				deadflag;
+	int				spectator;     // Should we use spectator physics model?
+	int				movetype;      // Our movement type, NOCLIP, WALK, FLY
+
+	int				onground;
+	int				waterlevel;
+	int				watertype;
+	int				oldwaterlevel;
+
+	char			sztexturename[256];
+	char			chtexturetype;
+
+	float			maxspeed;
+	float			clientmaxspeed; // Player specific maxspeed
+
+	// For mods
+	int				iuser1;
+	int				iuser2;
+	int				iuser3;
+	int				iuser4;
+	float			fuser1;
+	float			fuser2;
+	float			fuser3;
+	float			fuser4;
+	vec3_t			vuser1;
+	vec3_t			vuser2;
+	vec3_t			vuser3;
+	vec3_t			vuser4;
+	// world state
+	// Number of entities to clip against.
+	int				numphysent;    
+	physent_t		physents[MAX_PHYSENTS];
+	// Number of momvement entities (ladders)
+	int				nummoveent;
+	// just a list of ladders
+	physent_t		moveents[MAX_MOVEENTS];	
+
+	// All things being rendered, for tracing against things you don't actually collide with
+	int				numvisent;
+	physent_t		visents[ MAX_PHYSENTS ];
+
+	// input to run through physics.
+	usercmd_t		cmd;
+
+	// Trace results for objects we collided with.
+	int				numtouch;
+	pmtrace_t		touchindex[MAX_PHYSENTS];
+
+	char			physinfo[ MAX_PHYSINFO_STRING ]; // Physics info string
+
+	struct movevars_s *movevars;
+	vec3_t player_mins[ 4 ];
+	vec3_t player_maxs[ 4 ];
+	
+	// Common functions
+	const char		*(*PM_Info_ValueForKey) ( const char *s, const char *key );
+	void			(*PM_Particle)( float *origin, int color, float life, int zpos, int zvel);
+	int				(*PM_TestPlayerPosition) (float *pos, pmtrace_t *ptrace );
+	void			(*Con_NPrintf)( int idx, char *fmt, ... );
+	void			(*Con_DPrintf)( char *fmt, ... );
+	void			(*Con_Printf)( char *fmt, ... );
+	double			(*Sys_FloatTime)( void );
+	void			(*PM_StuckTouch)( int hitent, pmtrace_t *ptraceresult );
+	int				(*PM_PointContents) (float *p, int *truecontents /*filled in if this is non-null*/ );
+	int				(*PM_TruePointContents) (float *p);
+	int				(*PM_HullPointContents) ( struct hull_s *hull, int num, float *p);   
+	pmtrace_t		(*PM_PlayerTrace) (float *start, float *end, int traceFlags, int ignore_pe );
+	struct pmtrace_s *(*PM_TraceLine)( float *start, float *end, int flags, int usehulll, int ignore_pe );
+	int32			(*RandomLong)( int32 lLow, int32 lHigh );
+	float			(*RandomFloat)( float flLow, float flHigh );
+	int				(*PM_GetModelType)( struct model_s *mod );
+	void			(*PM_GetModelBounds)( struct model_s *mod, float *mins, float *maxs );
+	void			*(*PM_HullForBsp)( physent_t *pe, float *offset );
+	float			(*PM_TraceModel)( physent_t *pEnt, float *start, float *end, trace_t *trace );
+	int				(*COM_FileSize)(char *filename);
+	byte			*(*COM_LoadFile) (char *path, int usehunk, int *pLength);
+	void			(*COM_FreeFile) ( void *buffer );
+	char			*(*memfgets)( byte *pMemFile, int fileSize, int *pFilePos, char *pBuffer, int bufferSize );
+
+	// Functions
+	// Run functions for this frame?
+	qboolean		runfuncs;      
+	void			(*PM_PlaySound) ( int channel, const char *sample, float volume, float attenuation, int fFlags, int pitch );
+	const char		*(*PM_TraceTexture) ( int ground, float *vstart, float *vend );
+	void			(*PM_PlaybackEventFull) ( int flags, int clientindex, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 );
+	
+	pmtrace_t		(*PM_PlayerTraceEx) (float *start, float *end, int traceFlags, int (*pfnIgnore)( physent_t *pe ) );
+	int				(*PM_TestPlayerPositionEx) (float *pos, pmtrace_t *ptrace, int (*pfnIgnore)( physent_t *pe ) );
+	struct pmtrace_s *(*PM_TraceLineEx)( float *start, float *end, int flags, int usehulll, int (*pfnIgnore)( physent_t *pe ) );
+} playermove_t;
+
+#endif

MiniBase/ValveSDK/pm_info.h

@@ -0,0 +1,22 @@
+/***
+*
+*	Copyright (c) 1999, 2000, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+// Physics info string definition
+#if !defined( PM_INFOH )
+#define PM_INFOH
+#pragma once
+
+#define MAX_PHYSINFO_STRING 256
+
+#endif // PM_INFOH

MiniBase/ValveSDK/pmtrace.h

@@ -0,0 +1,43 @@
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( PMTRACEH )
+#define PMTRACEH
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef struct
+{
+	vec3_t	normal;
+	float	dist;
+} pmplane_t;
+
+typedef struct pmtrace_s pmtrace_t;
+
+struct pmtrace_s
+{
+	qboolean	allsolid;	      // if true, plane is not valid
+	qboolean	startsolid;	      // if true, the initial point was in a solid area
+	qboolean	inopen, inwater;  // End point is in empty space or in water
+	float		fraction;		  // time completed, 1.0 = didn't hit anything
+	vec3_t		endpos;			  // final position
+	pmplane_t	plane;		      // surface normal at impact
+	int			ent;			  // entity at impact
+	vec3_t      deltavelocity;    // Change in player's velocity caused by impact.  
+								  // Only run on server.
+	int         hitgroup;
+};
+
+#endif

MiniBase/ValveSDK/progdefs.h

@@ -0,0 +1,224 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef PROGDEFS_H
+#define PROGDEFS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef struct
+{	
+	float		time;
+	float		frametime;
+	float		force_retouch;
+	string_t	mapname;
+	string_t	startspot;
+	float		deathmatch;
+	float		coop;
+	float		teamplay;
+	float		serverflags;
+	float		found_secrets;
+	vec3_t		v_forward;
+	vec3_t		v_up;
+	vec3_t		v_right;
+	float		trace_allsolid;
+	float		trace_startsolid;
+	float		trace_fraction;
+	vec3_t		trace_endpos;
+	vec3_t		trace_plane_normal;
+	float		trace_plane_dist;
+	edict_t		*trace_ent;
+	float		trace_inopen;
+	float		trace_inwater;
+	int			trace_hitgroup;
+	int			trace_flags;
+	int			msg_entity;
+	int			cdAudioTrack;
+	int			maxClients;
+	int			maxEntities;
+	const char	*pStringBase;
+
+	void		*pSaveData;
+	vec3_t		vecLandmarkOffset;
+} globalvars_t;
+
+
+typedef struct entvars_s
+{
+	string_t	classname;
+	string_t	globalname;
+
+	vec3_t		origin;
+	vec3_t		oldorigin;
+	vec3_t		velocity;
+	vec3_t		basevelocity;
+	vec3_t      clbasevelocity;  // Base velocity that was passed in to server physics so 
+							     //  client can predict conveyors correctly.  Server zeroes it, so we need to store here, too.
+	vec3_t		movedir;
+
+	vec3_t		angles;			// Model angles
+	vec3_t		avelocity;		// angle velocity (degrees per second)
+	vec3_t		punchangle;		// auto-decaying view angle adjustment
+	vec3_t		v_angle;		// Viewing angle (player only)
+
+	// For parametric entities
+	vec3_t		endpos;
+	vec3_t		startpos;
+	float		impacttime;
+	float		starttime;
+
+	int			fixangle;		// 0:nothing, 1:force view angles, 2:add avelocity
+	float		idealpitch;
+	float		pitch_speed;
+	float		ideal_yaw;
+	float		yaw_speed;
+
+	int			modelindex;
+	string_t	model;
+
+	int			viewmodel;		// player's viewmodel
+	int			weaponmodel;	// what other players see
+	
+	vec3_t		absmin;		// BB max translated to world coord
+	vec3_t		absmax;		// BB max translated to world coord
+	vec3_t		mins;		// local BB min
+	vec3_t		maxs;		// local BB max
+	vec3_t		size;		// maxs - mins
+
+	float		ltime;
+	float		nextthink;
+
+	int			movetype;
+	int			solid;
+
+	int			skin;			
+	int			body;			// sub-model selection for studiomodels
+	int 		effects;
+	
+	float		gravity;		// % of "normal" gravity
+	float		friction;		// inverse elasticity of MOVETYPE_BOUNCE
+	
+	int			light_level;
+
+	int			sequence;		// animation sequence
+	int			gaitsequence;	// movement animation sequence for player (0 for none)
+	float		frame;			// % playback position in animation sequences (0..255)
+	float		animtime;		// world time when frame was set
+	float		framerate;		// animation playback rate (-8x to 8x)
+	byte		controller[4];	// bone controller setting (0..255)
+	byte		blending[2];	// blending amount between sub-sequences (0..255)
+
+	float		scale;			// sprite rendering scale (0..255)
+
+	int			rendermode;
+	float		renderamt;
+	vec3_t		rendercolor;
+	int			renderfx;
+
+	float		health;
+	float		frags;
+	int			weapons;  // bit mask for available weapons
+	float		takedamage;
+
+	int			deadflag;
+	vec3_t		view_ofs;	// eye position
+
+	int			button;
+	int			impulse;
+
+	edict_t		*chain;			// Entity pointer when linked into a linked list
+	edict_t		*dmg_inflictor;
+	edict_t		*enemy;
+	edict_t		*aiment;		// entity pointer when MOVETYPE_FOLLOW
+	edict_t		*owner;
+	edict_t		*groundentity;
+
+	int			spawnflags;
+	int			flags;
+	
+	int			colormap;		// lowbyte topcolor, highbyte bottomcolor
+	int			team;
+
+	float		max_health;
+	float		teleport_time;
+	float		armortype;
+	float		armorvalue;
+	int			waterlevel;
+	int			watertype;
+	
+	string_t	target;
+	string_t	targetname;
+	string_t	netname;
+	string_t	message;
+
+	float		dmg_take;
+	float		dmg_save;
+	float		dmg;
+	float		dmgtime;
+	
+	string_t	noise;
+	string_t	noise1;
+	string_t	noise2;
+	string_t	noise3;
+	
+	float		speed;
+	float		air_finished;
+	float		pain_finished;
+	float		radsuit_finished;
+	
+	edict_t		*pContainingEntity;
+
+	int			playerclass;
+	float		maxspeed;
+
+	float		fov;
+	int			weaponanim;
+
+	int			pushmsec;
+
+	int			bInDuck;
+	int			flTimeStepSound;
+	int			flSwimTime;
+	int			flDuckTime;
+	int			iStepLeft;
+	float		flFallVelocity;
+
+	int			gamestate;
+
+	int			oldbuttons;
+
+	int			groupinfo;
+
+	// For mods
+	int			iuser1;
+	int			iuser2;
+	int			iuser3;
+	int			iuser4;
+	float		fuser1;
+	float		fuser2;
+	float		fuser3;
+	float		fuser4;
+	vec3_t		vuser1;
+	vec3_t		vuser2;
+	vec3_t		vuser3;
+	vec3_t		vuser4;
+	edict_t		*euser1;
+	edict_t		*euser2;
+	edict_t		*euser3;
+	edict_t		*euser4;
+} entvars_t;
+
+
+#endif // PROGDEFS_H

MiniBase/ValveSDK/progs.h

@@ -0,0 +1,82 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef PROGS_H
+#define PROGS_H
+
+#include "progdefs.h"
+
+// 16 simultaneous events, max
+#define MAX_EVENT_QUEUE 64
+
+#define DEFAULT_EVENT_RESENDS 1
+
+#include "event_flags.h"
+
+typedef struct event_info_s event_info_t;
+
+#include "event_args.h"
+
+struct event_info_s
+{
+	unsigned short index;			  // 0 implies not in use
+
+	short packet_index;      // Use data from state info for entity in delta_packet .  -1 implies separate info based on event
+	                         // parameter signature
+	short entity_index;      // The edict this event is associated with
+
+	float fire_time;        // if non-zero, the time when the event should be fired ( fixed up on the client )
+	
+	event_args_t args;
+
+// CLIENT ONLY	
+	int	  flags;			// Reliable or not, etc.
+
+};
+
+typedef struct event_state_s event_state_t;
+
+struct event_state_s
+{
+	struct event_info_s ei[ MAX_EVENT_QUEUE ];
+};
+
+#if !defined( ENTITY_STATEH )
+#include "entity_state.h"
+#endif
+
+#if !defined( EDICT_H )
+#include "edict.h"
+#endif
+
+#define	STRUCT_FROM_LINK(l,t,m) ((t *)((byte *)l - (int)&(((t *)0)->m)))
+#define	EDICT_FROM_AREA(l) STRUCT_FROM_LINK(l,edict_t,area)
+
+//============================================================================
+
+extern	char			*pr_strings;
+extern	globalvars_t	gGlobalVariables;
+
+//============================================================================
+
+edict_t		*ED_Alloc (void);
+void		ED_Free (edict_t *ed);
+void		ED_LoadFromFile (char *data);
+
+edict_t		*EDICT_NUM(int n);
+int			NUM_FOR_EDICT(const edict_t *e);
+
+#define PROG_TO_EDICT(e) ((edict_t *)((byte *)sv.edicts + e))
+
+#endif // PROGS_H

MiniBase/ValveSDK/r_efx.h

@@ -0,0 +1,197 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined ( R_EFXH )
+#define R_EFXH
+#ifdef _WIN32
+#pragma once
+#endif
+
+// particle_t
+#if !defined( PARTICLEDEFH )  
+#include "particledef.h"
+#endif
+
+// BEAM
+#if !defined( BEAMDEFH )
+#include "beamdef.h"
+#endif
+
+// dlight_t
+#if !defined ( DLIGHTH )
+#include "dlight.h"
+#endif
+
+// cl_entity_t
+#if !defined( CL_ENTITYH )
+#include "cl_entity.h"
+#endif
+
+/*
+// FOR REFERENCE, These are the built-in tracer colors.  Note, color 4 is the one
+//  that uses the tracerred/tracergreen/tracerblue and traceralpha cvar settings
+color24 gTracerColors[] =
+{
+	{ 255, 255, 255 },		// White
+	{ 255, 0, 0 },			// Red
+	{ 0, 255, 0 },			// Green
+	{ 0, 0, 255 },			// Blue
+	{ 0, 0, 0 },			// Tracer default, filled in from cvars, etc.
+	{ 255, 167, 17 },		// Yellow-orange sparks
+	{ 255, 130, 90 },		// Yellowish streaks (garg)
+	{ 55, 60, 144 },		// Blue egon streak
+	{ 255, 130, 90 },		// More Yellowish streaks (garg)
+	{ 255, 140, 90 },		// More Yellowish streaks (garg)
+	{ 200, 130, 90 },		// More red streaks (garg)
+	{ 255, 120, 70 },		// Darker red streaks (garg)
+};
+*/
+
+// Temporary entity array
+#define TENTPRIORITY_LOW	0
+#define TENTPRIORITY_HIGH	1
+
+// TEMPENTITY flags
+#define	FTENT_NONE				0x00000000
+#define	FTENT_SINEWAVE			0x00000001
+#define	FTENT_GRAVITY			0x00000002
+#define FTENT_ROTATE			0x00000004
+#define	FTENT_SLOWGRAVITY		0x00000008
+#define FTENT_SMOKETRAIL		0x00000010
+#define FTENT_COLLIDEWORLD		0x00000020
+#define FTENT_FLICKER			0x00000040
+#define FTENT_FADEOUT			0x00000080
+#define FTENT_SPRANIMATE		0x00000100
+#define FTENT_HITSOUND			0x00000200
+#define FTENT_SPIRAL			0x00000400
+#define FTENT_SPRCYCLE			0x00000800
+#define FTENT_COLLIDEALL		0x00001000 // will collide with world and slideboxes
+#define FTENT_PERSIST			0x00002000 // tent is not removed when unable to draw 
+#define FTENT_COLLIDEKILL		0x00004000 // tent is removed upon collision with anything
+#define FTENT_PLYRATTACHMENT	0x00008000 // tent is attached to a player (owner)
+#define FTENT_SPRANIMATELOOP	0x00010000 // animating sprite doesn't die when last frame is displayed
+#define FTENT_SPARKSHOWER		0x00020000
+#define FTENT_NOMODEL			0x00040000 // Doesn't have a model, never try to draw ( it just triggers other things )
+#define FTENT_CLIENTCUSTOM		0x00080000 // Must specify callback.  Callback function is responsible for killing tempent and updating fields ( unless other flags specify how to do things )
+
+typedef struct tempent_s
+{
+	int			flags;
+	float		die;
+	float		frameMax;
+	float		x;
+	float		y;
+	float		z;
+	float		fadeSpeed;
+	float		bounceFactor;
+	int			hitSound;
+	void		( *hitcallback )	( struct tempent_s *ent, struct pmtrace_s *ptr );
+	void		( *callback )		( struct tempent_s *ent, float frametime, float currenttime );
+	struct tempent_s	*next;
+	int			priority;
+	short		clientIndex;	// if attached, this is the index of the client to stick to
+								// if COLLIDEALL, this is the index of the client to ignore
+								// TENTS with FTENT_PLYRATTACHMENT MUST set the clientindex! 
+
+	vec3_t		tentOffset;		// if attached, client origin + tentOffset = tent origin.
+	cl_entity_t	entity;
+
+	// baseline.origin		- velocity
+	// baseline.renderamt	- starting fadeout intensity
+	// baseline.angles		- angle velocity
+} TEMPENTITY;
+
+typedef struct efx_api_s efx_api_t;
+
+struct efx_api_s
+{
+	particle_t  *( *R_AllocParticle )			( void ( *callback ) ( struct particle_s *particle, float frametime ) );
+	void		( *R_BlobExplosion )			( float * org );
+	void		( *R_Blood )					( float * org, float * dir, int pcolor, int speed );
+	void		( *R_BloodSprite )				( float * org, int colorindex, int modelIndex, int modelIndex2, float size );
+	void		( *R_BloodStream )				( float * org, float * dir, int pcolor, int speed );
+	void		( *R_BreakModel )				( float *pos, float *size, float *dir, float random, float life, int count, int modelIndex, char flags );
+	void		( *R_Bubbles )					( float * mins, float * maxs, float height, int modelIndex, int count, float speed );
+	void		( *R_BubbleTrail )				( float * start, float * end, float height, int modelIndex, int count, float speed );
+	void		( *R_BulletImpactParticles )	( float * pos );
+	void		( *R_EntityParticles )			( struct cl_entity_s *ent );
+	void		( *R_Explosion )				( float *pos, int model, float scale, float framerate, int flags );
+	void		( *R_FizzEffect )				( struct cl_entity_s *pent, int modelIndex, int density );
+	void		( *R_FireField ) 				( float * org, int radius, int modelIndex, int count, int flags, float life );
+	void		( *R_FlickerParticles )			( float * org );
+	void		( *R_FunnelSprite )				( float *org, int modelIndex, int reverse );
+	void		( *R_Implosion )				( float * end, float radius, int count, float life );
+	void		( *R_LargeFunnel )				( float * org, int reverse );
+	void		( *R_LavaSplash )				( float * org );
+	void		( *R_MultiGunshot )				( float * org, float * dir, float * noise, int count, int decalCount, int *decalIndices );
+	void		( *R_MuzzleFlash )				( float *pos1, int type );
+	void		( *R_ParticleBox )				( float *mins, float *maxs, unsigned char r, unsigned char g, unsigned char b, float life );
+	void		( *R_ParticleBurst )			( float * pos, int size, int color, float life );
+	void		( *R_ParticleExplosion )		( float * org );
+	void		( *R_ParticleExplosion2 )		( float * org, int colorStart, int colorLength );
+	void		( *R_ParticleLine )				( float * start, float *end, unsigned char r, unsigned char g, unsigned char b, float life );
+	void		( *R_PlayerSprites )			( int client, int modelIndex, int count, int size );
+	void		( *R_Projectile )				( float * origin, float * velocity, int modelIndex, int life, int owner, void (*hitcallback)( struct tempent_s *ent, struct pmtrace_s *ptr ) );
+	void		( *R_RicochetSound )			( float * pos );
+	void		( *R_RicochetSprite )			( float *pos, struct model_s *pmodel, float duration, float scale );
+	void		( *R_RocketFlare )				( float *pos );
+	void		( *R_RocketTrail )				( float * start, float * end, int type );
+	void		( *R_RunParticleEffect )		( float * org, float * dir, int color, int count );
+	void		( *R_ShowLine )					( float * start, float * end );
+	void		( *R_SparkEffect )				( float *pos, int count, int velocityMin, int velocityMax );
+	void		( *R_SparkShower )				( float *pos );
+	void		( *R_SparkStreaks )				( float * pos, int count, int velocityMin, int velocityMax );
+	void		( *R_Spray )					( float * pos, float * dir, int modelIndex, int count, int speed, int spread, int rendermode );
+	void		( *R_Sprite_Explode )			( TEMPENTITY *pTemp, float scale, int flags );
+	void		( *R_Sprite_Smoke )				( TEMPENTITY *pTemp, float scale );
+	void		( *R_Sprite_Spray )				( float * pos, float * dir, int modelIndex, int count, int speed, int iRand );
+	void		( *R_Sprite_Trail )				( int type, float * start, float * end, int modelIndex, int count, float life, float size, float amplitude, int renderamt, float speed );
+	void		( *R_Sprite_WallPuff )			( TEMPENTITY *pTemp, float scale );
+	void		( *R_StreakSplash )				( float * pos, float * dir, int color, int count, float speed, int velocityMin, int velocityMax );
+	void		( *R_TracerEffect )				( float * start, float * end );
+	void		( *R_UserTracerParticle )		( float * org, float * vel, float life, int colorIndex, float length, unsigned char deathcontext, void ( *deathfunc)( struct particle_s *particle ) );
+	particle_t *( *R_TracerParticles )			( float * org, float * vel, float life );
+	void		( *R_TeleportSplash )			( float * org );
+	void		( *R_TempSphereModel )			( float *pos, float speed, float life, int count, int modelIndex );
+	TEMPENTITY	*( *R_TempModel )				( float *pos, float *dir, float *angles, float life, int modelIndex, int soundtype );
+	TEMPENTITY	*( *R_DefaultSprite )			( float *pos, int spriteIndex, float framerate );
+	TEMPENTITY	*( *R_TempSprite )				( float *pos, float *dir, float scale, int modelIndex, int rendermode, int renderfx, float a, float life, int flags );
+	int			( *Draw_DecalIndex )			( int id );
+	int			( *Draw_DecalIndexFromName )	( char *name );
+	void		( *R_DecalShoot )				( int textureIndex, int entity, int modelIndex, float * position, int flags );
+	void		( *R_AttachTentToPlayer )		( int client, int modelIndex, float zoffset, float life );
+	void		( *R_KillAttachedTents )		( int client );
+	BEAM		*( *R_BeamCirclePoints )		( int type, float * start, float * end, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	BEAM		*( *R_BeamEntPoint )			( int startEnt, float * end, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	BEAM		*( *R_BeamEnts )				( int startEnt, int endEnt, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	BEAM		*( *R_BeamFollow )				( int startEnt, int modelIndex, float life, float width, float r, float g, float b, float brightness );
+	void		( *R_BeamKill )					( int deadEntity );
+	BEAM		*( *R_BeamLightning )			( float * start, float * end, int modelIndex, float life, float width, float amplitude, float brightness, float speed );
+	BEAM		*( *R_BeamPoints )				( float * start, float * end, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	BEAM		*( *R_BeamRing )				( int startEnt, int endEnt, int modelIndex, float life, float width, float amplitude, float brightness, float speed, int startFrame, float framerate, float r, float g, float b );
+	dlight_t	*( *CL_AllocDlight )			( int key );
+	dlight_t	*( *CL_AllocElight )			( int key );
+	TEMPENTITY	*( *CL_TempEntAlloc )			( float * org, struct model_s *model );
+	TEMPENTITY	*( *CL_TempEntAllocNoModel )	( float * org );
+	TEMPENTITY	*( *CL_TempEntAllocHigh )		( float * org, struct model_s *model );
+	TEMPENTITY	*( *CL_TentEntAllocCustom )		( float *origin, struct model_s *model, int high, void ( *callback ) ( struct tempent_s *ent, float frametime, float currenttime ) );
+	void		( *R_GetPackedColor )			( short *packed, short color );
+	short		( *R_LookupColor )				( unsigned char r, unsigned char g, unsigned char b );
+	void		( *R_DecalRemoveAll )			( int textureIndex ); //textureIndex points to the decal index in the array, not the actual texture index.
+	void		( *R_FireCustomDecal )			( int textureIndex, int entity, int modelIndex, float * position, int flags, float scale );
+};
+
+extern efx_api_t efx;
+
+#endif

MiniBase/ValveSDK/r_studioint.h

@@ -0,0 +1,144 @@
+#if !defined( R_STUDIOINT_H )
+#define R_STUDIOINT_H
+#if defined( _WIN32 )
+#pragma once
+#endif
+
+#define STUDIO_INTERFACE_VERSION 1
+
+typedef struct engine_studio_api_s
+{
+	// Allocate number*size bytes and zero it
+	void			*( *Mem_Calloc )				( int number, size_t size );
+	// Check to see if pointer is in the cache
+	void			*( *Cache_Check )				( struct cache_user_s *c );
+	// Load file into cache ( can be swapped out on demand )
+	void			( *LoadCacheFile )				( char *path, struct cache_user_s *cu );
+	// Retrieve model pointer for the named model
+	struct model_s	*( *Mod_ForName )				( const char *name, int crash_if_missing );
+	// Retrieve pointer to studio model data block from a model
+	void			*( *Mod_Extradata )				( struct model_s *mod );
+	// Retrieve indexed model from client side model precache list
+	struct model_s	*( *GetModelByIndex )			( int index );
+	// Get entity that is set for rendering
+	struct cl_entity_s * ( *GetCurrentEntity )		( void );
+	// Get referenced player_info_t
+	struct player_info_s *( *PlayerInfo )			( int index );
+	// Get most recently received player state data from network system
+	struct entity_state_s *( *GetPlayerState )		( int index );
+	// Get viewentity
+	struct cl_entity_s * ( *GetViewEntity )			( void );
+	// Get current frame count, and last two timestampes on client
+	void			( *GetTimes )					( int *framecount, double *current, double *old );
+	// Get a pointer to a cvar by name
+	struct cvar_s	*( *GetCvar )					( const char *name );
+	// Get current render origin and view vectors ( up, right and vpn )
+	void			( *GetViewInfo )				( float *origin, float *upv, float *rightv, float *vpnv );
+	// Get sprite model used for applying chrome effect
+	struct model_s	*( *GetChromeSprite )			( void );
+	// Get model counters so we can incement instrumentation
+	void			( *GetModelCounters )			( int **s, int **a );
+	// Get software scaling coefficients
+	void			( *GetAliasScale )				( float *x, float *y );
+
+	// Get bone, light, alias, and rotation matrices
+	float			****( *StudioGetBoneTransform ) ( void );
+	float			****( *StudioGetLightTransform )( void );
+	float			***( *StudioGetAliasTransform ) ( void );
+	float			***( *StudioGetRotationMatrix ) ( void );
+
+	// Set up body part, and get submodel pointers
+	void			( *StudioSetupModel )			( int bodypart, void **ppbodypart, void **ppsubmodel );
+	// Check if entity's bbox is in the view frustum
+	int				( *StudioCheckBBox )			( void );
+	// Apply lighting effects to model
+	void			( *StudioDynamicLight )			( struct cl_entity_s *ent, struct alight_s *plight );
+	void			( *StudioEntityLight )			( struct alight_s *plight );
+	void			( *StudioSetupLighting )		( struct alight_s *plighting );
+
+	// Draw mesh vertices
+	void			( *StudioDrawPoints )			( void );
+
+	// Draw hulls around bones
+	void			( *StudioDrawHulls )			( void );
+	// Draw bbox around studio models
+	void			( *StudioDrawAbsBBox )			( void );
+	// Draws bones
+	void			( *StudioDrawBones )			( void );
+	// Loads in appropriate texture for model
+	void			( *StudioSetupSkin )			( void *ptexturehdr, int index );
+	// Sets up for remapped colors
+	void			( *StudioSetRemapColors )		( int top, int bottom );
+	// Set's player model and returns model pointer
+	struct model_s	*( *SetupPlayerModel )			( int index );
+	// Fires any events embedded in animation
+	void			( *StudioClientEvents )			( void );
+	// Retrieve/set forced render effects flags
+	int				( *GetForceFaceFlags )			( void );
+	void			( *SetForceFaceFlags )			( int flags );
+	// Tell engine the value of the studio model header
+	void			( *StudioSetHeader )			( void *header );
+	// Tell engine which model_t * is being renderered
+	void			( *SetRenderModel )				( struct model_s *model );
+
+	// Final state setup and restore for rendering
+	void			( *SetupRenderer )				( int rendermode );
+	void			( *RestoreRenderer )			( void );
+
+	// Set render origin for applying chrome effect
+	void			( *SetChromeOrigin )			( void );
+
+	// True if using D3D/OpenGL
+	int				( *IsHardware )					( void );
+	
+	// Only called by hardware interface
+	void			( *GL_StudioDrawShadow )		( void );
+	void			( *GL_SetRenderMode )			( int mode );
+
+	void			( *StudioSetRenderamt )			(int iRenderamt); 	//!!!CZERO added for rendering glass on viewmodels
+	void			( *StudioSetCullState )			( int iCull	   );
+	void			( *StudioRenderShadow )			( int iSprite, float *p1, float *p2, float *p3, float *p4 );
+} engine_studio_api_t;
+
+typedef struct server_studio_api_s
+{
+	// Allocate number*size bytes and zero it
+	void			*( *Mem_Calloc )				( int number, size_t size );
+	// Check to see if pointer is in the cache
+	void			*( *Cache_Check )				( struct cache_user_s *c );
+	// Load file into cache ( can be swapped out on demand )
+	void			( *LoadCacheFile )				( char *path, struct cache_user_s *cu );
+	// Retrieve pointer to studio model data block from a model
+	void			*( *Mod_Extradata )				( struct model_s *mod );
+} server_studio_api_t;
+
+
+// client blending
+typedef struct r_studio_interface_s
+{
+	int				version;
+	int				( *StudioDrawModel	)			( int flags );
+	int				( *StudioDrawPlayer	)			( int flags, struct entity_state_s *pplayer );
+} r_studio_interface_t;
+
+extern r_studio_interface_t *pStudioAPI;
+
+// server blending
+#define SV_BLENDING_INTERFACE_VERSION 1
+
+typedef struct sv_blending_interface_s
+{
+	int				version;
+
+	void			( *SV_StudioSetupBones )		( struct model_s	*pModel, 
+													  float				frame, 
+													  int				sequence, 
+													  const vec3_t		angles, 
+													  const	vec3_t		origin, 
+													  const	byte		*pcontroller,
+													  const	byte		*pblending, 
+													  int				iBone,
+													  const edict_t		*pEdict );
+} sv_blending_interface_t;
+
+#endif // R_STUDIOINT_H

MiniBase/ValveSDK/ref_params.h

@@ -0,0 +1,75 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( REF_PARAMSH )
+#define REF_PARAMSH
+
+typedef struct ref_params_s
+{
+	// Output
+	float	vieworg[3];
+	float	viewangles[3];
+
+	float	forward[3];
+	float	right[3];
+	float   up[3];
+
+	// Client frametime;
+	float	frametime;
+	// Client time
+	float	time;
+
+	// Misc
+	int		intermission;
+	int		paused;
+	int		spectator;
+	int		onground;
+	int		waterlevel;
+
+	float	simvel[3];
+	float	simorg[3];
+
+	float	viewheight[3];
+	float	idealpitch;
+
+	float	cl_viewangles[3];
+
+	int		health;
+	float	crosshairangle[3];
+	float	viewsize;
+
+	float	punchangle[3];
+	int		maxclients;
+	int		viewentity;
+	int		playernum;
+	int		max_entities;
+	int		demoplayback;
+	int		hardware;
+
+	int		smoothing;
+
+	// Last issued usercmd
+	struct usercmd_s *cmd;
+
+	// Movevars
+	struct movevars_s *movevars;
+
+	int		viewport[4];		// the viewport coordinates x ,y , width, height
+
+	int		nextView;			// the renderer calls ClientDLL_CalcRefdef() and Renderview
+								// so long in cycles until this value is 0 (multiple views)
+	int		onlyClientDraw;		// if !=0 nothing is drawn by the engine except clientDraw functions
+} ref_params_t;
+
+#endif // !REF_PARAMSH

MiniBase/ValveSDK/screenfade.h

@@ -0,0 +1,24 @@
+//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#if !defined( SCREENFADEH )
+#define SCREENFADEH
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef struct screenfade_s
+{
+	float		fadeSpeed;		// How fast to fade (tics / second) (+ fade in, - fade out)
+	float		fadeEnd;		// When the fading hits maximum
+	float		fadeTotalEnd;	// Total End Time of the fade (used for FFADE_OUT)
+	float		fadeReset;		// When to reset to not fading (for fadeout and hold)
+	byte		fader, fadeg, fadeb, fadealpha;	// Fade color
+	int			fadeFlags;		// Fading flags
+} screenfade_t;
+
+#endif // !SCREENFADEH

MiniBase/ValveSDK/steamtypes.h

@@ -0,0 +1,177 @@
+//========= Copyright <EFBFBD> 1996-2008, Valve LLC, All rights reserved. ============
+//
+// Purpose:
+//
+//=============================================================================
+
+#ifndef STEAMTYPES_H
+#define STEAMTYPES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+// Steam-specific types. Defined here so this header file can be included in other code bases.
+#if defined( __GNUC__ ) && !defined(POSIX)
+	#if __GNUC__ < 4
+		#error "Steamworks requires GCC 4.X (4.2 or 4.4 have been tested)"
+	#endif
+	#define POSIX 1
+#endif
+
+#if defined(__x86_64__) || defined(_WIN64)
+#define X64BITS
+#endif
+
+// Make sure VALVE_BIG_ENDIAN gets set on PS3, may already be set previously in Valve internal code.
+#if !defined(VALVE_BIG_ENDIAN) && defined(_PS3)
+#define VALVE_BIG_ENDIAN
+#endif
+
+typedef unsigned char uint8;
+typedef signed char int8;
+
+#if defined( _WIN32 )
+
+typedef __int16 int16;
+typedef unsigned __int16 uint16;
+typedef __int32 int32;
+typedef unsigned __int32 uint32;
+typedef __int64 int64;
+typedef unsigned __int64 uint64;
+
+#ifdef X64BITS
+typedef __int64 intp;				// intp is an integer that can accomodate a pointer
+typedef unsigned __int64 uintp;		// (ie, sizeof(intp) >= sizeof(int) && sizeof(intp) >= sizeof(void *)
+#else
+typedef __int32 intp;
+typedef unsigned __int32 uintp;
+#endif
+
+#else // _WIN32
+
+typedef short int16;
+typedef unsigned short uint16;
+typedef int int32;
+typedef unsigned int uint32;
+typedef long long int64;
+typedef unsigned long long uint64;
+#ifdef X64BITS
+typedef long long intp;
+typedef unsigned long long uintp;
+#else
+typedef int intp;
+typedef unsigned int uintp;
+#endif
+
+#endif // else _WIN32
+
+#ifdef __cplusplus
+const int k_cubSaltSize   = 8;
+#else
+#define k_cubSaltSize 8
+#endif
+
+typedef	uint8 Salt_t[ k_cubSaltSize ];
+
+//-----------------------------------------------------------------------------
+// GID (GlobalID) stuff
+// This is a globally unique identifier.  It's guaranteed to be unique across all
+// racks and servers for as long as a given universe persists.
+//-----------------------------------------------------------------------------
+// NOTE: for GID parsing/rendering and other utils, see gid.h
+typedef uint64 GID_t;
+
+#ifdef __cplusplus
+const GID_t k_GIDNil = 0xfffffffffffffffful;
+#else
+#define k_GIDNil 0xffffffffffffffffull;
+#endif
+
+// For convenience, we define a number of types that are just new names for GIDs
+typedef GID_t JobID_t;			// Each Job has a unique ID
+typedef GID_t TxnID_t;			// Each financial transaction has a unique ID
+
+#ifdef __cplusplus
+const GID_t k_TxnIDNil = k_GIDNil;
+const GID_t k_TxnIDUnknown = 0;
+#else
+#define k_TxnIDNil k_GIDNil;
+#define  k_TxnIDUnknown 0;
+#endif
+
+// this is baked into client messages and interfaces as an int, 
+// make sure we never break this.
+typedef uint32 PackageId_t;
+#ifdef __cplusplus
+const PackageId_t k_uPackageIdFreeSub = 0x0;
+const PackageId_t k_uPackageIdInvalid = 0xFFFFFFFF;
+#else
+#define k_uPackageIdFreeSub 0x0;
+#define k_uPackageIdInvalid 0xFFFFFFFF;
+#endif
+
+// this is baked into client messages and interfaces as an int, 
+// make sure we never break this.
+typedef uint32 AppId_t;
+#ifdef __cplusplus
+const AppId_t k_uAppIdInvalid = 0x0;
+#else
+#define k_uAppIdInvalid 0x0;
+#endif
+
+typedef uint64 AssetClassId_t;
+#ifdef __cplusplus
+const AssetClassId_t k_ulAssetClassIdInvalid = 0x0;
+#else
+#define k_ulAssetClassIdInvalid 0x0;
+#endif
+
+typedef uint32 PhysicalItemId_t;
+#ifdef __cplusplus
+const PhysicalItemId_t k_uPhysicalItemIdInvalid = 0x0;
+#else
+#define k_uPhysicalItemIdInvalid 0x0;
+#endif
+
+
+// this is baked into client messages and interfaces as an int, 
+// make sure we never break this.  AppIds and DepotIDs also presently
+// share the same namespace, but since we'd like to change that in the future
+// I've defined it seperately here.
+typedef uint32 DepotId_t;
+#ifdef __cplusplus
+const DepotId_t k_uDepotIdInvalid = 0x0;
+#else
+#define k_uDepotIdInvalid 0x0;
+#endif
+
+// RTime32
+// We use this 32 bit time representing real world time.
+// It offers 1 second resolution beginning on January 1, 1970 (Unix time)
+typedef uint32 RTime32;
+
+typedef uint32 CellID_t;
+#ifdef __cplusplus
+const CellID_t k_uCellIDInvalid = 0xFFFFFFFF;
+#else
+#define k_uCellIDInvalid 0x0;
+#endif
+
+// handle to a Steam API call
+typedef uint64 SteamAPICall_t;
+#ifdef __cplusplus
+const SteamAPICall_t k_uAPICallInvalid = 0x0;
+#else
+#define k_uAPICallInvalid 0x0;
+#endif
+
+typedef uint32 AccountID_t;
+
+typedef uint32 PartnerId_t;
+#ifdef __cplusplus
+const PartnerId_t k_uPartnerIdInvalid = 0;
+#else
+#define k_uPartnerIdInvalid 0x0;
+#endif
+
+#endif // STEAMTYPES_H

MiniBase/ValveSDK/studio.h

@@ -0,0 +1,368 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+
+
+
+
+#ifndef _STUDIO_H_
+#define _STUDIO_H_
+
+/*
+==============================================================================
+
+STUDIO MODELS
+
+Studio models are position independent, so the cache manager can move them.
+==============================================================================
+*/
+ 
+
+#define MAXSTUDIOTRIANGLES	20000	// TODO: tune this
+#define MAXSTUDIOVERTS		2048	// TODO: tune this
+#define MAXSTUDIOSEQUENCES	2048	// total animation sequences -- KSH incremented
+#define MAXSTUDIOSKINS		100		// total textures
+#define MAXSTUDIOSRCBONES	512		// bones allowed at source movement
+#define MAXSTUDIOBONES		128		// total bones actually used
+#define MAXSTUDIOMODELS		32		// sub-models per model
+#define MAXSTUDIOBODYPARTS	32
+#define MAXSTUDIOGROUPS		16
+#define MAXSTUDIOANIMATIONS	2048		
+#define MAXSTUDIOMESHES		256
+#define MAXSTUDIOEVENTS		1024
+#define MAXSTUDIOPIVOTS		256
+#define MAXSTUDIOCONTROLLERS 8
+
+typedef struct 
+{
+	int					id;
+	int					version;
+
+	char				name[64];
+	int					length;
+
+	vec3_t				eyeposition;	// ideal eye position
+	vec3_t				min;			// ideal movement hull size
+	vec3_t				max;			
+
+	vec3_t				bbmin;			// clipping bounding box
+	vec3_t				bbmax;		
+
+	int					flags;
+
+	int					numbones;			// bones
+	int					boneindex;
+
+	int					numbonecontrollers;		// bone controllers
+	int					bonecontrollerindex;
+
+	int					numhitboxes;			// complex bounding boxes
+	int					hitboxindex;			
+	
+	int					numseq;				// animation sequences
+	int					seqindex;
+
+	int					numseqgroups;		// demand loaded sequences
+	int					seqgroupindex;
+
+	int					numtextures;		// raw textures
+	int					textureindex;
+	int					texturedataindex;
+
+	int					numskinref;			// replaceable textures
+	int					numskinfamilies;
+	int					skinindex;
+
+	int					numbodyparts;		
+	int					bodypartindex;
+
+	int					numattachments;		// queryable attachable points
+	int					attachmentindex;
+
+	int					soundtable;
+	int					soundindex;
+	int					soundgroups;
+	int					soundgroupindex;
+
+	int					numtransitions;		// animation node to animation node transition graph
+	int					transitionindex;
+} studiohdr_t;
+
+// header for demand loaded sequence group data
+typedef struct 
+{
+	int					id;
+	int					version;
+
+	char				name[64];
+	int					length;
+} studioseqhdr_t;
+
+// bones
+typedef struct 
+{
+	char				name[32];	// bone name for symbolic links
+	int		 			parent;		// parent bone
+	int					flags;		// ??
+	int					bonecontroller[6];	// bone controller index, -1 == none
+	float				value[6];	// default DoF values
+	float				scale[6];   // scale for delta DoF values
+} mstudiobone_t;
+
+
+// bone controllers
+typedef struct 
+{
+	int					bone;	// -1 == 0
+	int					type;	// X, Y, Z, XR, YR, ZR, M
+	float				start;
+	float				end;
+	int					rest;	// byte index value at rest
+	int					index;	// 0-3 user set controller, 4 mouth
+} mstudiobonecontroller_t;
+
+// intersection boxes
+typedef struct
+{
+	int					bone;
+	int					group;			// intersection group
+	vec3_t				bbmin;		// bounding box
+	vec3_t				bbmax;		
+} mstudiobbox_t;
+
+#if !defined( CACHE_USER ) && !defined( QUAKEDEF_H )
+#define CACHE_USER
+typedef struct cache_user_s
+{
+	void *data;
+} cache_user_t;
+#endif
+
+//
+// demand loaded sequence groups
+//
+typedef struct
+{
+	char				label[32];	// textual name
+	char				name[64];	// file name
+    int32				unused1;    // was "cache"  - index pointer
+	int					unused2;    // was "data" -  hack for group 0
+} mstudioseqgroup_t;
+
+// sequence descriptions
+typedef struct
+{
+	char				label[32];	// sequence label
+
+	float				fps;		// frames per second	
+	int					flags;		// looping/non-looping flags
+
+	int					activity;
+	int					actweight;
+
+	int					numevents;
+	int					eventindex;
+
+	int					numframes;	// number of frames per sequence
+
+	int					numpivots;	// number of foot pivots
+	int					pivotindex;
+
+	int					motiontype;	
+	int					motionbone;
+	vec3_t				linearmovement;
+	int					automoveposindex;
+	int					automoveangleindex;
+
+	vec3_t				bbmin;		// per sequence bounding box
+	vec3_t				bbmax;		
+
+	int					numblends;
+	int					animindex;		// mstudioanim_t pointer relative to start of sequence group data
+										// [blend][bone][X, Y, Z, XR, YR, ZR]
+
+	int					blendtype[2];	// X, Y, Z, XR, YR, ZR
+	float				blendstart[2];	// starting value
+	float				blendend[2];	// ending value
+	int					blendparent;
+
+	int					seqgroup;		// sequence group for demand loading
+
+	int					entrynode;		// transition node at entry
+	int					exitnode;		// transition node at exit
+	int					nodeflags;		// transition rules
+	
+	int					nextseq;		// auto advancing sequences
+} mstudioseqdesc_t;
+
+// events
+#include "studio_event.h"
+/*
+typedef struct 
+{
+	int 				frame;
+	int					event;
+	int					type;
+	char				options[64];
+} mstudioevent_t;
+*/
+
+// pivots
+typedef struct 
+{
+	vec3_t				org;	// pivot point
+	int					start;
+	int					end;
+} mstudiopivot_t;
+
+// attachment
+typedef struct 
+{
+	char				name[32];
+	int					type;
+	int					bone;
+	vec3_t				org;	// attachment point
+	vec3_t				vectors[3];
+} mstudioattachment_t;
+
+typedef struct
+{
+	unsigned short	offset[6];
+} mstudioanim_t;
+
+// animation frames
+typedef union 
+{
+	struct {
+		byte	valid;
+		byte	total;
+	} num;
+	short		value;
+} mstudioanimvalue_t;
+
+
+
+// body part index
+typedef struct
+{
+	char				name[64];
+	int					nummodels;
+	int					base;
+	int					modelindex; // index into models array
+} mstudiobodyparts_t;
+
+
+
+// skin info
+typedef struct
+{
+	char					name[64];
+	int						flags;
+	int						width;
+	int						height;
+	int						index;
+} mstudiotexture_t;
+
+
+// skin families
+// short	index[skinfamilies][skinref]
+
+// studio models
+typedef struct
+{
+	char				name[64];
+
+	int					type;
+
+	float				boundingradius;
+
+	int					nummesh;
+	int					meshindex;
+
+	int					numverts;		// number of unique vertices
+	int					vertinfoindex;	// vertex bone info
+	int					vertindex;		// vertex vec3_t
+	int					numnorms;		// number of unique surface normals
+	int					norminfoindex;	// normal bone info
+	int					normindex;		// normal vec3_t
+
+	int					numgroups;		// deformation groups
+	int					groupindex;
+} mstudiomodel_t;
+
+
+// vec3_t	boundingbox[model][bone][2];	// complex intersection info
+
+
+// meshes
+typedef struct 
+{
+	int					numtris;
+	int					triindex;
+	int					skinref;
+	int					numnorms;		// per mesh normals
+	int					normindex;		// normal vec3_t
+} mstudiomesh_t;
+
+// triangles
+#if 0
+typedef struct 
+{
+	short				vertindex;		// index into vertex array
+	short				normindex;		// index into normal array
+	short				s,t;			// s,t position on skin
+} mstudiotrivert_t;
+#endif
+
+// lighting options
+#define STUDIO_NF_FLATSHADE		0x0001
+#define STUDIO_NF_CHROME		0x0002
+#define STUDIO_NF_FULLBRIGHT	0x0004
+#define STUDIO_NF_NOMIPS        0x0008
+#define STUDIO_NF_ALPHA         0x0010
+#define STUDIO_NF_ADDITIVE      0x0020
+#define STUDIO_NF_MASKED        0x0040
+
+// motion flags
+#define STUDIO_X		0x0001
+#define STUDIO_Y		0x0002	
+#define STUDIO_Z		0x0004
+#define STUDIO_XR		0x0008
+#define STUDIO_YR		0x0010
+#define STUDIO_ZR		0x0020
+#define STUDIO_LX		0x0040
+#define STUDIO_LY		0x0080
+#define STUDIO_LZ		0x0100
+#define STUDIO_AX		0x0200
+#define STUDIO_AY		0x0400
+#define STUDIO_AZ		0x0800
+#define STUDIO_AXR		0x1000
+#define STUDIO_AYR		0x2000
+#define STUDIO_AZR		0x4000
+#define STUDIO_TYPES	0x7FFF
+#define STUDIO_RLOOP	0x8000	// controller that wraps shortest distance
+
+// sequence flags
+#define STUDIO_LOOPING	0x0001
+
+// bone flags
+#define STUDIO_HAS_NORMALS	0x0001
+#define STUDIO_HAS_VERTICES 0x0002
+#define STUDIO_HAS_BBOX		0x0004
+#define STUDIO_HAS_CHROME	0x0008	// if any of the textures have chrome on them
+
+#define RAD_TO_STUDIO		(32768.0/M_PI)
+#define STUDIO_TO_RAD		(M_PI/32768.0)
+
+#endif

MiniBase/ValveSDK/studio_event.h

@@ -0,0 +1,29 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( STUDIO_EVENTH )
+#define STUDIO_EVENTH
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef struct mstudioevent_s
+{
+	int 				frame;
+	int					event;
+	int					type;
+	char				options[64];
+} mstudioevent_t;
+
+#endif // STUDIO_EVENTH

MiniBase/ValveSDK/triangleapi.h

@@ -0,0 +1,54 @@
+/***
+*
+*	Copyright (c) 1999, 2000, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined( TRIANGLEAPIH )
+#define TRIANGLEAPIH
+#pragma once
+
+typedef enum 
+{
+	TRI_FRONT = 0,
+	TRI_NONE = 1,
+} TRICULLSTYLE;
+
+#define TRI_API_VERSION		1
+
+#define TRI_TRIANGLES		0
+#define TRI_TRIANGLE_FAN	1
+#define TRI_QUADS			2
+#define TRI_POLYGON			3
+#define TRI_LINES			4	
+#define TRI_TRIANGLE_STRIP	5
+#define TRI_QUAD_STRIP		6
+
+typedef struct triangleapi_s
+{
+	int			version;
+
+	void		( *RenderMode )( int mode );
+	void		( *Begin )( int primitiveCode );
+	void		( *End ) ( void );
+
+	void		( *Color4f ) ( float r, float g, float b, float a );
+	void		( *Color4ub ) ( unsigned char r, unsigned char g, unsigned char b, unsigned char a );
+	void		( *TexCoord2f ) ( float u, float v );
+	void		( *Vertex3fv ) ( float *worldPnt );
+	void		( *Vertex3f ) ( float x, float y, float z );
+	void		( *Brightness ) ( float brightness );
+	void		( *CullFace ) ( TRICULLSTYLE style );
+	int			( *SpriteTexture ) ( struct model_s *pSpriteModel, int frame );
+	int			( *WorldToScreen ) ( float *world, float *screen );  // Returns 1 if it's z clipped
+} triangleapi_t;
+
+#endif // !TRIANGLEAPIH

MiniBase/ValveSDK/usercmd.h

@@ -0,0 +1,41 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#ifndef USERCMD_H
+#define USERCMD_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+typedef struct usercmd_s
+{
+	short	lerp_msec;      // Interpolation time on client
+	byte	msec;           // Duration in ms of command
+	vec3_t	viewangles;     // Command view angles.
+
+// intended velocities
+	float	forwardmove;    // Forward velocity.
+	float	sidemove;       // Sideways velocity.
+	float	upmove;         // Upward velocity.
+	byte	lightlevel;     // Light level at spot where we are standing.
+	unsigned short  buttons;  // Attack buttons
+	byte    impulse;          // Impulse command issued.
+	byte	weaponselect;	// Current weapon id
+
+// Experimental player impact stuff.
+	int		impact_index;
+	vec3_t	impact_position;
+} usercmd_t;
+
+#endif // USERCMD_H

MiniBase/ValveSDK/util_vector.h

@@ -0,0 +1,131 @@
+/***
+*
+*	Copyright (c) 1999, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+//  Vector.h
+// A subset of the extdll.h in the project HL Entity DLL
+//
+
+#if !defined FILE_UTIL_VECTOR_H
+#define FILE_UTIL_VECTOR_H
+
+// Misc C-runtime library headers
+#include "STDIO.H"
+#include "STDLIB.H"
+#include "MATH.H"
+
+// Header file containing definition of globalvars_t and entvars_t
+typedef int	func_t;					//
+typedef int	string_t;				// from engine's pr_comp.h;
+typedef float vec_t;				// needed before including progdefs.h
+
+//=========================================================
+// 2DVector - used for many pathfinding and many other 
+// operations that are treated as planar rather than 3d.
+//=========================================================
+class Vector2D
+{
+public:
+	inline Vector2D(void)									{ }
+	inline Vector2D(float X, float Y)						{ x = X; y = Y; }
+	inline Vector2D operator+(const Vector2D& v)	const	{ return Vector2D(x+v.x, y+v.y);	}
+	inline Vector2D operator-(const Vector2D& v)	const	{ return Vector2D(x-v.x, y-v.y);	}
+	inline Vector2D operator*(float fl)				const	{ return Vector2D(x*fl, y*fl);	}
+	inline Vector2D operator/(float fl)				const	{ return Vector2D(x/fl, y/fl);	}
+	
+	inline float Length(void)						const	{ return (float)sqrt(x*x + y*y );		}
+
+	inline Vector2D Normalize ( void ) const
+	{
+		Vector2D vec2;
+
+		float flLen = Length();
+		if ( flLen == 0 )
+		{
+			return Vector2D( (float)0, (float)0 );
+		}
+		else
+		{
+			flLen = 1 / flLen;
+			return Vector2D( x * flLen, y * flLen );
+		}
+	}
+
+	vec_t	x, y;
+};
+
+inline float DotProduct(const Vector2D& a, const Vector2D& b) { return( a.x*b.x + a.y*b.y ); }
+inline Vector2D operator*(float fl, const Vector2D& v)	{ return v * fl; }
+
+//=========================================================
+// 3D Vector
+//=========================================================
+class Vector						// same data-layout as engine's vec3_t,
+{								//		which is a vec_t[3]
+public:
+	// Construction/destruction
+	inline Vector(void)								{ }
+	inline Vector(float X, float Y, float Z)		{ x = X; y = Y; z = Z;						}
+	inline Vector(double X, double Y, double Z)		{ x = (float)X; y = (float)Y; z = (float)Z;	}
+	inline Vector(int X, int Y, int Z)				{ x = (float)X; y = (float)Y; z = (float)Z;	}
+	inline Vector(const Vector& v)					{ x = v.x; y = v.y; z = v.z;				} 
+	inline Vector(float rgfl[3])					{ x = rgfl[0]; y = rgfl[1]; z = rgfl[2];	}
+
+	// Operators
+	inline Vector operator-(void) const				{ return Vector(-x,-y,-z);				}
+	inline int operator==(const Vector& v) const	{ return x==v.x && y==v.y && z==v.z;	}
+	inline int operator!=(const Vector& v) const	{ return !(*this==v);					}
+	inline Vector operator+(const Vector& v) const	{ return Vector(x+v.x, y+v.y, z+v.z);	}
+	inline Vector operator-(const Vector& v) const	{ return Vector(x-v.x, y-v.y, z-v.z);	}
+	inline Vector operator*(float fl) const			{ return Vector(x*fl, y*fl, z*fl);		}
+	inline Vector operator/(float fl) const			{ return Vector(x/fl, y/fl, z/fl);		}
+	
+	// Methods
+	inline void CopyToArray(float* rgfl) const		{ rgfl[0] = x, rgfl[1] = y, rgfl[2] = z; }
+	inline float Length(void) const					{ return (float)sqrt(x*x + y*y + z*z); }
+	operator float *()								{ return &x; } // Vectors will now automatically convert to float * when needed
+	operator const float *() const					{ return &x; } // Vectors will now automatically convert to float * when needed
+	inline Vector Normalize(void) const
+	{
+		float flLen = Length();
+		if (flLen == 0) return Vector(0,0,1); // ????
+		flLen = 1 / flLen;
+		return Vector(x * flLen, y * flLen, z * flLen);
+	}
+
+	inline Vector2D Make2D ( void ) const
+	{
+		Vector2D	Vec2;
+
+		Vec2.x = x;
+		Vec2.y = y;
+
+		return Vec2;
+	}
+	inline float Length2D(void) const					{ return (float)sqrt(x*x + y*y); }
+
+	// Members
+	vec_t x, y, z;
+};
+inline Vector operator*(float fl, const Vector& v)	{ return v * fl; }
+inline float DotProduct(const Vector& a, const Vector& b) { return(a.x*b.x+a.y*b.y+a.z*b.z); }
+inline Vector CrossProduct(const Vector& a, const Vector& b) { return Vector( a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x ); }
+
+#define vec3_t Vector
+
+
+#define VectorAdd(a,b,c) {(c)[0]=(a)[0]+(b)[0];(c)[1]=(a)[1]+(b)[1];(c)[2]=(a)[2]+(b)[2];}
+#define VectorCopy(a,b) {(b)[0]=(a)[0];(b)[1]=(a)[1];(b)[2]=(a)[2];}
+#define VectorClear(a) { a[0]=0.0;a[1]=0.0;a[2]=0.0;}
+
+#endif

MiniBase/ValveSDK/weaponinfo.h

@@ -0,0 +1,52 @@
+/***
+*
+*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+#if !defined ( WEAPONINFOH )
+#define WEAPONINFOH
+#ifdef _WIN32
+#pragma once
+#endif
+
+// Info about weapons player might have in his/her possession
+typedef struct weapon_data_s
+{
+	int			m_iId;
+	int			m_iClip;
+
+	float		m_flNextPrimaryAttack;
+	float		m_flNextSecondaryAttack;
+	float		m_flTimeWeaponIdle;
+
+	int			m_fInReload;
+	int			m_fInSpecialReload;
+	float		m_flNextReload;
+	float		m_flPumpTime;
+	float		m_fReloadTime;
+
+	float		m_fAimedDamage;
+	float		m_fNextAimBonus;
+	int			m_fInZoom;
+	int			m_iWeaponState;
+
+	int			iuser1;
+	int			iuser2;
+	int			iuser3;
+	int			iuser4;
+	float		fuser1;
+	float		fuser2;
+	float		fuser3;
+	float		fuser4;
+} weapon_data_t;
+
+#endif

MiniBase/ValveSDK/wrect.h

@@ -0,0 +1,9 @@
+#if !defined( WRECTH )
+#define WRECTH
+
+typedef struct rect_s
+{
+	int				left, right, top, bottom;
+} wrect_t;
+
+#endif