Reworked native rg_find_item_bpack_by_name -> rg_find_weapon_bpack_by_name

Added native rg_has_item_by_name
Added safety checks into natives
Update CSSDK

reapi/build.gradle

@@ -55,10 +55,10 @@ void setupToolchain(NativeBinarySpec b) {
 		)
 		cfg.compilerOptions.languageStandard = 'c++0x'
 		cfg.defines([
-				'_stricmp': 'strcasecmp',
+			'_stricmp': 'strcasecmp',
-				'_strnicmp': 'strncasecmp',
+			'_strnicmp': 'strncasecmp',
-				'_vsnprintf': 'vsnprintf',
+			'_vsnprintf': 'vsnprintf',
-				'_snprintf': 'snprintf'
+			'_snprintf': 'snprintf'
 		])
 
 		cfg.compilerOptions.args '-Qoption,cpp,--treat_func_as_string_literal_cpp', '-msse2', '-fomit-frame-pointer', '-inline-forceinline', '-fvisibility=default', '-fvisibility-inlines-hidden', '-fno-rtti', '-g0', '-s'
@@ -112,7 +112,7 @@ model {
 						include "**/*.cpp"
 
 						exclude "precompiled.cpp"
-						exclude "engine_api.cpp"
+						exclude "engine_api.cpp", "tier0/dbg.cpp"
 					}
 
 					exportedHeaders {

reapi/extra/amxmodx/scripting/include/cssdk_const.inc

@@ -1133,7 +1133,5 @@ enum ItemID
 	ITEM_SODACAN,
 	ITEM_HEALTHKIT,
 	ITEM_ANTIDOTE,
-	ITEM_SECURITY,
+	ITEM_BATTERY
-	ITEM_BATTERY,
-	ITEM_SUIT
 };

reapi/extra/amxmodx/scripting/include/reapi_engine.inc

@@ -78,7 +78,7 @@ native rh_reset_mapname();
 * @return		1 if successfully sounds are emitted, 0 otherwise
 *
 */
-native rh_emit_sound2(const entity, const recipient, const channel, const sample[], Float:vol = VOL_NORM, Float:attn = ATTN_NORM, const flags = 0, const pitch = PITCH_NORM, emitFlags = 0, const Float:origin[3] = {0.0,0.0,0.0});
+native bool:rh_emit_sound2(const entity, const recipient, const channel, const sample[], Float:vol = VOL_NORM, Float:attn = ATTN_NORM, const flags = 0, const pitch = PITCH_NORM, emitFlags = 0, const Float:origin[3] = {0.0,0.0,0.0});
 
 /*
 * Forces an userinfo update

reapi/extra/amxmodx/scripting/include/reapi_engine_const.inc

@@ -5,7 +5,11 @@
 #define _reapi_engine_const_included
 
 // for natives rh_get_mapname
-enum MapNameType { MNT_TRUE, MNT_SET };
+enum MapNameType
+{
+	MNT_TRUE,	// return true the name of the current map independently of the set via rh_set_mapname
+	MNT_SET		// return the name of the current map
+};
 
 // rh_emit_sound2 flags
 #define SND_EMIT2_NOPAS		(1<<0)	// never to do check PAS

reapi/extra/amxmodx/scripting/include/reapi_gamedll.inc

@@ -289,15 +289,26 @@ native rg_find_ent_by_class(start_index, const classname[]);
 native rg_find_ent_by_owner(&start_index, const classname[], owner);
 
 /*
-* Find the item by name in the player's inventory.
+* Find the weapon by name in the player's inventory.
+*
+* @param index			Client index
+* @param weapon			Weapon name
+*
+* @return			Entity-index of weapon, 0 otherwise
+*
+*/
+native rg_find_weapon_bpack_by_name(const index, const weapon[]);
+
+/*
+* Check if the player already have this item.
 *
 * @param index			Client index
 * @param item			Item name
 *
-* @return			Entity-index of item, 0 otherwise
+* @return			1 if successfully, 0 otherwise
 *
 */
-native rg_find_item_bpack_by_name(const index, const item[]);
+native bool:rg_has_item_by_name(const index, const item[]);
 
 /*
 * Returns some information about a weapon.

reapi/extra/amxmodx/scripting/include/reapi_gamedll_const.inc

@@ -6,7 +6,7 @@
 
 // Returns 1, if round ended by expired time
 // NOTE: Use this for hookchain RG_RoundEnd with the parameter ScenarioEventEndRound:event
-#define HadRoundExpired(event)	(1<<event) & (1<<ROUND_TARGET_SAVED) | (1<<ROUND_HOSTAGE_NOT_RESCUED) | (1<<ROUND_TERRORISTS_NOT_ESCAPED) | (1<<ROUND_VIP_NOT_ESCAPED)
+#define HadRoundExpired(event)	(1<<any:event) & (1<<any:ROUND_TARGET_SAVED) | (1<<any:ROUND_HOSTAGE_NOT_RESCUED) | (1<<any:ROUND_TERRORISTS_NOT_ESCAPED) | (1<<any:ROUND_VIP_NOT_ESCAPED)
 
 // bypass warning: 200 on amxmodx 1.8.2
 #if AMXX_VERSION_NUM < 183
@@ -27,7 +27,11 @@
 	#define RG_CBasePlayer_SetClientUserInfoName RG_CBasePlayer_SetUserInfoName
 #endif
 
-enum AccountSet { AS_SET, AS_ADD };
+enum AccountSet
+{
+	AS_SET,	// sets the value of the account
+	AS_ADD	// adds a value to the account
+};
 
 // Weapon info types for use with rg_get_weapon_info()
 enum WpnInfo
@@ -3596,208 +3600,208 @@ enum MoveVars
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_gravity = BEGIN_MEMBER_REGION(movevars),
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_stopspeed,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_maxspeed,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_spectatormaxspeed,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_accelerate,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_airaccelerate,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_wateraccelerate,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_friction,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_edgefriction,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_waterfriction,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_entgravity,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_bounce,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_stepsize,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_maxvelocity,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_zmax,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_waveHeight,
 
 	/*
 	* Description:		-
 	* Member type:		BOOL
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_footsteps,
 
 	/*
 	* Description:		-
 	* Member type:		char [32]
-	* Get params:		Float:get_mvar(const MoveVars:var, dest[], const lenght);
+	* Get params:		Float:get_movevar(const MoveVars:var, dest[], const lenght);
-	* Set params:		set_mvar(const MoveVars:var, const source[]);
+	* Set params:		set_movevar(const MoveVars:var, const source[]);
 	*/
 	mv_skyName,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_rollangle,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_rollspeed,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_skycolor_r,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_skycolor_g,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_skycolor_b,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_skyvec_x,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_skyvec_y,
 
 	/*
 	* Description:		-
 	* Member type:		float
-	* Get params:		Float:get_mvar(const MoveVars:var);
+	* Get params:		Float:get_movevar(const MoveVars:var);
-	* Set params:		set_mvar(const MoveVars:var, Float:value);
+	* Set params:		set_movevar(const MoveVars:var, Float:value);
 	*/
 	mv_skyvec_z
 };

reapi/include/cssdk/common/mathlib.h

@@ -1,37 +1,51 @@
-/***
+/*
 *
-*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
+*   This program is free software; you can redistribute it and/or modify it
-*	
+*   under the terms of the GNU General Public License as published by the
-*	This product contains software technology licensed from Id 
+*   Free Software Foundation; either version 2 of the License, or (at
-*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*   your option) any later version.
-*	All Rights Reserved.
 *
-*   Use, distribution, and modification of this source code and/or resulting
+*   This program is distributed in the hope that it will be useful, but
-*   object code is restricted to non-commercial enhancements to products from
+*   WITHOUT ANY WARRANTY; without even the implied warranty of
-*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-*   without written permission from Valve LLC.
+*   General Public License for more details.
 *
-****/
+*   You should have received a copy of the GNU General Public License
+*   along with this program; if not, write to the Free Software Foundation,
+*   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*
+*   In addition, as a special exception, the author gives permission to
+*   link the code of this program with the Half-Life Game Engine ("HL
+*   Engine") and Modified Game Libraries ("MODs") developed by Valve,
+*   L.L.C ("Valve").  You must obey the GNU General Public License in all
+*   respects for all of the code used other than the HL Engine and MODs
+*   from Valve.  If you modify this file, you may extend this exception
+*   to your version of the file, but you are not obligated to do so.  If
+*   you do not wish to do so, delete this exception statement from your
+*   version.
+*
+*/
 
-#ifndef MATHLIB_H
+#pragma once
-#define MATHLIB_H
+
+#ifdef PLAY_GAMEDLL
+
+// probably gamedll compiled with flag /fpmath:fasted,
+// so we need to use type double, otherwise will be the test failed
+
+typedef double float_precision;
+
+#else
+
+typedef float float_precision;
+
+#endif // PLAY_GAMEDLL
 
-/* <42b7f> ../common/mathlib.h:3 */
 typedef float vec_t;
-
-/* <42b91> ../common/mathlib.h:6 */
-#if !defined DID_VEC3_T_DEFINE && !defined vec3_t
-#define DID_VEC3_T_DEFINE
 typedef vec_t vec3_t[3];
-#endif
-
-/* <80013> ../common/mathlib.h:8 */
 typedef vec_t vec4_t[4];
+typedef int fixed16_t;
 
-/* <42bac> ../common/mathlib.h:18 */
-typedef int fixed16_t; /* size: 4 */
-
-/* <42bb7> ../common/mathlib.h:60 */
 typedef union DLONG_u
 {
 	int i[2];
@@ -55,36 +69,16 @@ typedef union DLONG_u
 #endif
 
 template <typename T>
-inline T min(T a, T b) {
+T min(T a, T b) { return (a < b) ? a : b; }
-	return (a < b) ? a : b;
-}
 
 template <typename T>
-inline T max(T a, T b) {
+T max(T a, T b) { return (a > b) ? a : b; }
-	return (a < b) ? b : a;
-}
 
 template <typename T>
-inline T clamp(T a, T min, T max) {
+T clamp(T a, T min, T max) { return (a > max) ? max : (a < min) ? min : a; }
-	return (a > max) ? max : (a < min) ? min : a;
-}
 
-template <typename T>
-inline T bswap(T s) {
-	switch (sizeof(T)) {
-#ifdef _WIN32
-	case 2: {auto res = _byteswap_ushort(*(uint16 *)&s); return *(T *)&res;}
-	case 4:	{auto res = _byteswap_ulong(*(uint32 *)(&s)); return *(T *)&res;}
-	case 8: {auto res = _byteswap_uint64(*(uint64 *)&s); return *(T *)&res;}
-#else
-	case 2: {auto res = _bswap16(*(uint16 *)&s); return *(T *)&res;}
-	case 4: {auto res = _bswap(*(uint32 *)&s); return *(T *)&res;}
-	case 8: {auto res = _bswap64(*(uint64 *)&s); return *(T *)&res;}
-#endif
-	default: return s;
-	}
-}
 #else // __cplusplus
+
 #ifndef max
 #define max(a,b) (((a) > (b)) ? (a) : (b))
 #endif
@@ -96,4 +90,38 @@ inline T bswap(T s) {
 #define clamp(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
 #endif // __cplusplus
 
-#endif // MATHLIB_H
+// bitwise operators templates
+template<class T, class type=typename std::underlying_type<T>::type>
+inline T operator~ (T a) { return (T)~(type)a; }
+template<class T, class type=typename std::underlying_type<T>::type>
+inline T operator| (T a, T b) { return (T)((type)a | (type)b); }
+template<class T, class type=typename std::underlying_type<T>::type>
+inline T operator& (T a, T b) { return (T)((type)a & (type)b); }
+template<class T, class type=typename std::underlying_type<T>::type>
+inline T operator^ (T a, T b) { return (T)((type)a ^ (type)b); }
+template<class T, class type=typename std::underlying_type<T>::type>
+inline T& operator|= (T& a, T b) { return (T&)((type&)a |= (type)b); }
+template<class T, class type=typename std::underlying_type<T>::type>
+inline T& operator&= (T& a, T b) { return (T&)((type&)a &= (type)b); }
+template<class T, class type=typename std::underlying_type<T>::type>
+inline T& operator^= (T& a, T b) { return (T&)((type&)a ^= (type)b); }
+
+inline double M_sqrt(int value) {
+	return sqrt(value);
+}
+
+inline float M_sqrt(float value) {
+	return _mm_cvtss_f32(_mm_sqrt_ss(_mm_load_ss(&value)));
+}
+
+inline double M_sqrt(double value) {
+	double ret;
+	auto v = _mm_load_sd(&value);
+	_mm_store_sd(&ret, _mm_sqrt_sd(v, v));
+	return ret;
+}
+
+#define VectorSubtract(a,b,c) {(c)[0]=(a)[0]-(b)[0];(c)[1]=(a)[1]-(b)[1];(c)[2]=(a)[2]-(b)[2];}
+#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;}

reapi/include/cssdk/dlls/bot/cs_bot.h

@@ -281,7 +281,7 @@ private:
 // The Counter-strike Bot
 class CCSBot: public CBot {
 public:
-	virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType) = 0;		// invoked when injured by something (EXTEND) - returns the amount of damage inflicted
+	virtual BOOL TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType) = 0;		// invoked when injured by something (EXTEND) - returns the amount of damage inflicted
 	virtual void Killed(entvars_t *pevAttacker, int iGib) = 0;									// invoked when killed (EXTEND)
 	virtual void RoundRespawn() = 0;
 	virtual void Blind(float duration, float holdTime, float fadeTime, int alpha = 255) = 0;					// player blinded by a flashbang

reapi/include/cssdk/dlls/cbase.h

@@ -136,7 +136,7 @@ public:
 	EOFFSET eoffset() { return OFFSET(pev); }
 	int entindex() { return ENTINDEX(edict()); }
 public:
-	CCSEntity *m_pEntity;
+	CCSEntity *m_pEntity;						// NOTE: it was replaced on member "int *current_ammo" because it is useless.
 
 	// We use this variables to store each ammo count.
 	float currentammo;

reapi/include/cssdk/dlls/extdef.h

@@ -29,6 +29,28 @@
 
 #include "regamedll_const.h"
 
+#ifdef _WIN32
+	// Attributes to specify an "exported" function, visible from outside the
+	// DLL.
+	#undef DLLEXPORT
+	#define DLLEXPORT	__declspec(dllexport)
+	// WINAPI should be provided in the windows compiler headers.
+	// It's usually defined to something like "__stdcall".
+#else
+	#undef DLLEXPORT
+	#define DLLEXPORT	__attribute__((visibility("default")))
+	#define WINAPI		/* */
+#endif // _WIN32
+
+// Simplified macro for declaring/defining exported DLL functions.  They
+// need to be 'extern "C"' so that the C++ compiler enforces parameter
+// type-matching, rather than considering routines with mis-matched
+// arguments/types to be overloaded functions...
+//
+// AFAIK, this is os-independent, but it's included here in osdep.h where
+// DLLEXPORT is defined, for convenience.
+#define C_DLLEXPORT extern "C" DLLEXPORT
+
 enum hash_types_e { CLASSNAME };
 
 // Things that toggle (buttons/triggers/doors) need this

reapi/include/cssdk/dlls/extdll.h

@@ -25,6 +25,7 @@
 *   version.
 *
 */
+
 #pragma once
 
 #pragma warning(disable:4244)		// int or float down-conversion
@@ -35,9 +36,9 @@
 
 #include "archtypes.h"
 #include "maintypes.h"
+#include "regamedll_common.h"
 
 #ifdef _WIN32
-
 	#define WIN32_LEAN_AND_MEAN
 	#define NOWINRES
 	#define NOSERVICE
@@ -48,11 +49,9 @@
 	#include "winsani_out.h"
 	#undef PlaySound
 #else
-
 	#include <limits.h>
 	#include <stdarg.h>
 	#include <string.h>
-
 #endif // _WIN32
 
 // Misc C-runtime library headers

reapi/include/cssdk/dlls/gamerules.h

@@ -665,15 +665,6 @@ typedef struct mapcycle_s
 
 } mapcycle_t;
 
-class CMapInfo: public CPointEntity {
-public:
-	virtual void Spawn() = 0;
-	virtual void KeyValue(KeyValueData *pkvd) = 0;
-public:
-	int m_iBuyingStatus;
-	float m_flBombRadius;
-};
-
 class CCStrikeGameMgrHelper: public IVoiceGameMgrHelper {
 public:
 	virtual bool CanPlayerHearPlayer(CBasePlayer *pListener, CBasePlayer *pSender) = 0;

reapi/include/cssdk/dlls/hostage/hostage.h

@@ -85,7 +85,7 @@ public:
 	virtual void Precache() = 0;
 	virtual int ObjectCaps() = 0;		// make hostage "useable"
 	virtual int Classify() = 0;
-	virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType) = 0;
+	virtual BOOL TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType) = 0;
 	virtual int BloodColor() = 0;
 	virtual void Touch(CBaseEntity *pOther) = 0;
 	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value) = 0;

reapi/include/cssdk/dlls/items.h

@@ -35,6 +35,9 @@ enum ItemRestType
 };
 
 // constant items
+#define ITEM_ID_ANTIDOTE	2
+#define ITEM_ID_SECURITY	3
+
 enum ItemID
 {
 	ITEM_NONE = -1,
@@ -77,9 +80,7 @@ enum ItemID
 	ITEM_SODACAN,
 	ITEM_HEALTHKIT,
 	ITEM_ANTIDOTE,
-	ITEM_SECURITY,
+	ITEM_BATTERY
-	ITEM_BATTERY,
-	ITEM_SUIT
 };
 
 class CItem: public CBaseEntity {
@@ -94,7 +95,7 @@ public:
 	virtual void Spawn() = 0;
 	virtual void KeyValue(KeyValueData *pkvd) = 0;
 public:
-	ItemID m_iType;
+	int m_iType;
 };
 
 class CItemSuit: public CItem {

reapi/include/cssdk/dlls/mapinfo.h

@@ -0,0 +1,40 @@
+/*
+*
+*   This program is free software; you can redistribute it and/or modify it
+*   under the terms of the GNU General Public License as published by the
+*   Free Software Foundation; either version 2 of the License, or (at
+*   your option) any later version.
+*
+*   This program is distributed in the hope that it will be useful, but
+*   WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+*   General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with this program; if not, write to the Free Software Foundation,
+*   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*
+*   In addition, as a special exception, the author gives permission to
+*   link the code of this program with the Half-Life Game Engine ("HL
+*   Engine") and Modified Game Libraries ("MODs") developed by Valve,
+*   L.L.C ("Valve").  You must obey the GNU General Public License in all
+*   respects for all of the code used other than the HL Engine and MODs
+*   from Valve.  If you modify this file, you may extend this exception
+*   to your version of the file, but you are not obligated to do so.  If
+*   you do not wish to do so, delete this exception statement from your
+*   version.
+*
+*/
+
+#pragma once
+
+class CMapInfo: public CPointEntity
+{
+public:
+	virtual void Spawn() = 0;
+	virtual void KeyValue(KeyValueData *pkvd) = 0;
+
+public:
+	InfoMapBuyParam m_iBuyingStatus;
+	float m_flBombRadius;
+};

reapi/include/cssdk/dlls/player.h

@@ -274,19 +274,21 @@ public:
 	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value) = 0;
 };
 
+// Multiplayer intermission spots.
 class CInfoIntermission: public CPointEntity {
 public:
 	virtual void Spawn() = 0;
 	virtual void Think() = 0;
 };
 
+// Dead HEV suit prop
 class CDeadHEV: public CBaseMonster {
 public:
 	virtual void Spawn() = 0;
 	virtual void KeyValue(KeyValueData *pkvd) = 0;
 	virtual int Classify() = 0;
 public:
-	int m_iPose;
+	int m_iPose;				// which sequence to display -- temporary, don't need to save
 	static char *m_szPoses[4];
 };
 

reapi/include/cssdk/dlls/regamedll_common.h

@@ -0,0 +1,95 @@
+/*
+*
+*    This program is free software; you can redistribute it and/or modify it
+*    under the terms of the GNU General Public License as published by the
+*    Free Software Foundation; either version 2 of the License, or (at
+*    your option) any later version.
+*
+*    This program is distributed in the hope that it will be useful, but
+*    WITHOUT ANY WARRANTY; without even the implied warranty of
+*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+*    General Public License for more details.
+*
+*    You should have received a copy of the GNU General Public License
+*    along with this program; if not, write to the Free Software Foundation,
+*    Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*
+*    In addition, as a special exception, the author gives permission to
+*    link the code of this program with the Half-Life Game Engine ("HL
+*    Engine") and Modified Game Libraries ("MODs") developed by Valve,
+*    L.L.C ("Valve").  You must obey the GNU General Public License in all
+*    respects for all of the code used other than the HL Engine and MODs
+*    from Valve.  If you modify this file, you may extend this exception
+*    to your version of the file, but you are not obligated to do so.  If
+*    you do not wish to do so, delete this exception statement from your
+*    version.
+*
+*/
+
+#pragma once
+
+#ifndef _WIN32
+#define _strlwr(p) for (int i = 0; p[i] != 0; i++) p[i] = tolower(p[i]);
+#endif
+
+#define Q_isspace isspace
+#define Q_isalnum isalnum
+#define Q_isalpha isalpha
+
+#define Q_malloc malloc
+#define Q_calloc calloc
+#define Q_alloca alloca
+#define Q_free free
+
+#define Q_min min
+#define Q_max max
+#define Q_clamp clamp
+#define Q_access _access
+#define Q_close _close
+#define Q_write _write
+#define Q_memset memset
+#define Q_memcpy memcpy
+#define Q_strlen strlen
+#define Q_memcmp memcmp
+#define Q_strcpy strcpy
+#define Q_strncpy strncpy
+#define Q_strrchr strrchr
+#define Q_strcat strcat
+#define Q_strncat strncat
+#define Q_strcmp strcmp
+#define Q_strncmp strncmp
+#define Q_sscanf sscanf
+#define Q_strdup _strdup
+#define Q_stricmp _stricmp
+#define Q_strnicmp _strnicmp
+#define Q_strstr strstr
+#define Q_strchr strchr
+#define Q_strrchr strrchr
+#define Q_strlwr _strlwr
+#define Q_sprintf sprintf
+#define Q_snprintf _snprintf
+#define Q_atoi atoi
+#define Q_atof atof
+#define Q_toupper toupper
+#define Q_memmove memmove
+#define Q_vsnprintf _vsnprintf
+#define Q_vsnwprintf _vsnwprintf
+#define Q_abs abs
+#define Q_fabs fabs
+#define Q_tan tan
+#define Q_atan atan
+#define Q_atan2 atan2
+#define Q_acos acos
+#define Q_cos cos
+#define Q_sin sin
+#define Q_pow pow
+#define Q_fmod fmod
+#define Q_fopen fopen
+#define Q_fprintf fprintf
+#define Q_fclose fclose
+
+#ifdef REGAMEDLL_FIXES
+#define Q_sqrt M_sqrt
+#else
+#define Q_sqrt sqrt
+#endif

reapi/include/cssdk/dlls/regamedll_interfaces.h

@@ -86,6 +86,10 @@ public:
 	virtual bool JoinTeam(TeamName team);
 	virtual void StartObserver(Vector& vecPosition, Vector& vecViewAngle);
 	virtual void TeamChangeUpdate();
+	virtual void DropSecondary();
+	virtual void DropPrimary();
+	virtual bool HasPlayerItem(CBasePlayerItem *pCheckItem);
+	virtual bool HasNamedPlayerItem(const char *pszItemName);
 
 	CBasePlayer *BasePlayer() const;
 public:

reapi/include/cssdk/engine/cmd_rehlds.h

@@ -29,10 +29,8 @@
 
 #include "archtypes.h"
 
-/* <8f1> ../engine/cmd.h:65 */
 typedef void(*xcommand_t)(void);
 
-/* <904> ../engine/cmd.h:71 */
 typedef struct cmd_function_s
 {
 	struct cmd_function_s *next;
@@ -41,7 +39,6 @@ typedef struct cmd_function_s
 	int flags;
 } cmd_function_t;
 
-/* <95a> ../engine/cmd.h:80 */
 typedef enum cmd_source_s
 {
 	src_client = 0,		// came in over a net connection as a clc_stringcmd. host_client will be valid during this state.

reapi/include/cssdk/engine/common_rehlds.h

@@ -25,29 +25,23 @@
 *    version.
 *
 */
+
 #pragma once
 
 #include "const.h"
 #include "qlimits.h"
 
-#ifdef REHLDS_FIXES
-#define COM_TOKEN_LEN	2048
-#else
-#define COM_TOKEN_LEN	1024
-#endif
-
 // Don't allow overflow
-#define SIZEBUF_CHECK_OVERFLOW	0
+#define SIZEBUF_CHECK_OVERFLOW		0
-#define SIZEBUF_ALLOW_OVERFLOW	BIT(0)
+#define SIZEBUF_ALLOW_OVERFLOW		BIT(0)
 #define SIZEBUF_OVERFLOWED		BIT(1)
 
-#define MAX_NUM_ARGVS	50
+#define MAX_NUM_ARGVS			50
-#define NUM_SAFE_ARGVS	7
+#define NUM_SAFE_ARGVS			7
 
-#define COM_COPY_CHUNK_SIZE 1024
+#define COM_COPY_CHUNK_SIZE		1024
-#define COM_MAX_CMD_LINE 256
+#define COM_MAX_CMD_LINE		256
 
-/* <6ae> ../common/common.h:82 */
 typedef struct sizebuf_s
 {
 	const char *buffername;
@@ -57,7 +51,6 @@ typedef struct sizebuf_s
 	int cursize;
 } sizebuf_t;
 
-/* <270aa> ../common/common.h:297 */
 typedef struct downloadtime_s
 {
 	qboolean bUsed;
@@ -65,7 +58,6 @@ typedef struct downloadtime_s
 	int nBytesRemaining;
 } downloadtime_t;
 
-/* <19fa2> ../common/common.h:303 */
 typedef struct incomingtransfer_s
 {
 	qboolean doneregistering;

reapi/include/cssdk/engine/hookchains_rehlds.h

@@ -1,69 +0,0 @@
-/*
-*
-*    This program is free software; you can redistribute it and/or modify it
-*    under the terms of the GNU General Public License as published by the
-*    Free Software Foundation; either version 2 of the License, or (at
-*    your option) any later version.
-*
-*    This program is distributed in the hope that it will be useful, but
-*    WITHOUT ANY WARRANTY; without even the implied warranty of
-*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-*    General Public License for more details.
-*
-*    You should have received a copy of the GNU General Public License
-*    along with this program; if not, write to the Free Software Foundation,
-*    Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*
-*    In addition, as a special exception, the author gives permission to
-*    link the code of this program with the Half-Life Game Engine ("HL
-*    Engine") and Modified Game Libraries ("MODs") developed by Valve,
-*    L.L.C ("Valve").  You must obey the GNU General Public License in all
-*    respects for all of the code used other than the HL Engine and MODs
-*    from Valve.  If you modify this file, you may extend this exception
-*    to your version of the file, but you are not obligated to do so.  If
-*    you do not wish to do so, delete this exception statement from your
-*    version.
-*
-*/
-#pragma once
-
-template<typename t_ret, typename ...t_args>
-class IHookChain {
-protected:
-	virtual ~IHookChain() {}
-
-public:
-	virtual t_ret callNext(t_args... args) = 0;
-	virtual t_ret callOriginal(t_args... args) = 0;
-};
-
-template<typename ...t_args>
-class IVoidHookChain
-{
-protected:
-	virtual ~IVoidHookChain() {}
-
-public:
-	virtual void callNext(t_args... args) = 0;
-	virtual void callOriginal(t_args... args) = 0;
-};
-
-// Hook chain registry(for hooks [un]registration)
-template<typename t_ret, typename ...t_args>
-class IHookChainRegistry {
-public:
-	typedef t_ret(*hookfunc_t)(IHookChain<t_ret, t_args...>*, t_args...);
-
-	virtual void registerHook(hookfunc_t hook) = 0;
-	virtual void unregisterHook(hookfunc_t hook) = 0;
-};
-
-// Hook chain registry(for hooks [un]registration)
-template<typename ...t_args>
-class IVoidHookChainRegistry {
-public:
-	typedef void(*hookfunc_t)(IVoidHookChain<t_args...>*, t_args...);
-
-	virtual void registerHook(hookfunc_t hook) = 0;
-	virtual void unregisterHook(hookfunc_t hook) = 0;
-};

reapi/include/cssdk/engine/osconfig.h

@@ -25,25 +25,14 @@
 *    version.
 *
 */
-#pragma once
+
+#ifndef _OSCONFIG_H
+#define _OSCONFIG_H
 
 #ifdef _WIN32 // WINDOWS
 	#pragma warning(disable : 4005)
 #endif // _WIN32
 
-// disable must return a value
-#pragma warning(disable : 4716)
-
-#ifndef _WIN32
-
-// disable missing return statement at end of non-void function
-#pragma warning(disable : 1011)
-
-// disable offsetof applied to non-POD (Plain Old Data) types is nonstandard
-#pragma warning(disable : 1875)
-
-#endif // _WIN32
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
@@ -51,22 +40,26 @@
 #include <string.h>
 #include <time.h>
 #include <math.h>
-//#include <setjmp.h>
+#include <setjmp.h>
 #include <assert.h>
 
+#include <algorithm>
+#include <deque>
+#include <functional>
+
 #ifdef _WIN32 // WINDOWS
 	#include <windows.h>
-	//#include <winsock.h>
+	#include <winsock.h>
-	//#include <wsipx.h> // for support IPX
+	#include <wsipx.h> // for support IPX
 	#define PSAPI_VERSION 1
 	#include <psapi.h>
 	#include <nmmintrin.h>
 	#include <fcntl.h>
-	//#include <sys/types.h>
+	#include <sys/types.h>
 	#include <sys/stat.h>
 	#include <io.h>
 #else // _WIN32
-	//#include <arpa/inet.h>
+	#include <arpa/inet.h>
 	#include <ctype.h>
 	//#include <dirent.h>
 	#include <dlfcn.h>
@@ -80,10 +73,11 @@
 	#include <pthread.h>
 	#include <sys/ioctl.h>
 	#include <sys/mman.h>
+	#include <sys/socket.h>
 	#include <sys/stat.h>
 	#include <sys/time.h>
-	//#include <sys/types.h>
+	#include <sys/types.h>
-	//#include <sys/sysinfo.h>
+	#include <sys/sysinfo.h>
 	#include <unistd.h>
 
 	// Deail with stupid macro in kernel.h
@@ -91,43 +85,12 @@
 #endif // _WIN32
 
 #include <string>
-//#include <sstream>
+#include <sstream>
-//#include <fstream>
+#include <fstream>
 #include <iomanip>
 
-#ifdef _WIN32 // WINDOWS
+#include <smmintrin.h>
-#ifndef _STDINT
+#include <xmmintrin.h>
-	typedef unsigned __int64 uint64_t;
-	typedef unsigned __int32 uint32_t;
-	typedef unsigned __int16 uint16_t;
-	typedef unsigned __int8 uint8_t;
-
-	typedef __int64 int64_t;
-	typedef __int32 int32_t;
-	typedef __int16 int16_t;
-	typedef __int8 int8_t;
-
-	typedef wchar_t uchar16;
-	typedef unsigned int uchar32;
-#endif
-#else // _WIN32
-	typedef unsigned long long uint64_t;
-	typedef unsigned int uint32_t;
-	typedef unsigned short uint16_t;
-	typedef unsigned char uint8_t;
-
-	#ifndef __int8_t_defined
-		typedef long long int64_t;
-		typedef int int32_t;
-		typedef short int16_t;
-		typedef char int8_t;
-	#endif
-
-	typedef unsigned char byte;
-	typedef unsigned char BYTE;
-	typedef unsigned short uchar16;
-	typedef wchar_t uchar32;
-#endif // _WIN32
 
 #ifdef _WIN32 // WINDOWS
 	#define _CRT_SECURE_NO_WARNINGS
@@ -136,20 +99,29 @@
 	#ifndef CDECL
 		#define CDECL __cdecl
 	#endif
-
 	#define STDCALL __stdcall
 	#define HIDDEN
 	#define NOINLINE __declspec(noinline)
 	#define ALIGN16 __declspec(align(16))
 	#define FORCE_STACK_ALIGN
 
-	// Attributes to specify an "exported" function, visible from outside the
+	//inline bool SOCKET_FIONBIO(SOCKET s, int m) { return (ioctlsocket(s, FIONBIO, (u_long*)&m) == 0); }
-	// DLL.
+	//inline int SOCKET_MSGLEN(SOCKET s, u_long& r) { return ioctlsocket(s, FIONREAD, (u_long*)&r); }
-	#undef DLLEXPORT
+	typedef int socklen_t;
-	#define DLLEXPORT	__declspec(dllexport)
+	#define SOCKET_FIONBIO(s, m) ioctlsocket(s, FIONBIO, (u_long*)&m)
-	// WINAPI should be provided in the windows compiler headers.
+	#define SOCKET_MSGLEN(s, r) ioctlsocket(s, FIONREAD, (u_long*)&r)
-	// It's usually defined to something like "__stdcall".
+	#define SIN_GET_ADDR(saddr, r) r = (saddr)->S_un.S_addr
+	#define SIN_SET_ADDR(saddr, r) (saddr)->S_un.S_addr = (r)
+	#define SOCKET_CLOSE(s) closesocket(s)
+	#define SOCKET_AGAIN() (WSAGetLastError() == WSAEWOULDBLOCK)
 
+	inline void* sys_allocmem(unsigned int size) {
+		return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
+	}
+
+	inline void sys_freemem(void* ptr, unsigned int size) {
+		VirtualFree(ptr, 0, MEM_RELEASE);
+	}
 #else // _WIN32
 	#ifdef __FUNCTION__
 		#undef __FUNCTION__
@@ -178,9 +150,26 @@
 	#define ALIGN16 __attribute__((aligned(16)))
 	#define FORCE_STACK_ALIGN __attribute__((force_align_arg_pointer))
 
-	#undef DLLEXPORT
+	//inline bool SOCKET_FIONBIO(SOCKET s, int m) { return (ioctl(s, FIONBIO, (int*)&m) == 0); }
-	#define DLLEXPORT	__attribute__((visibility("default")))
+	//inline int SOCKET_MSGLEN(SOCKET s, u_long& r) { return ioctl(s, FIONREAD, (int*)&r); }
-	#define WINAPI		/* */
+	typedef int SOCKET;
+	#define INVALID_SOCKET (SOCKET)(~0)
+	#define SOCKET_FIONBIO(s, m) ioctl(s, FIONBIO, (char*)&m)
+	#define SOCKET_MSGLEN(s, r) ioctl(s, FIONREAD, (char*)&r)
+	#define SIN_GET_ADDR(saddr, r) r = (saddr)->s_addr
+	#define SIN_SET_ADDR(saddr, r) (saddr)->s_addr = (r)
+	#define SOCKET_CLOSE(s) close(s)
+	#define SOCKET_AGAIN() (errno == EAGAIN)
+	#define SOCKET_ERROR -1
+
+	inline void* sys_allocmem(unsigned int size) {
+		return mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+	}
+	inline void sys_freemem(void* ptr, unsigned int size) {
+		munmap(ptr, size);
+	}
+
+	#define WSAENOPROTOOPT ENOPROTOOPT
 
 	#ifndef FALSE
 	#define FALSE	0
@@ -190,13 +179,16 @@
 	#endif
 #endif // _WIN32
 
-// Simplified macro for declaring/defining exported DLL functions.  They
+#ifdef _WIN32
-// need to be 'extern "C"' so that the C++ compiler enforces parameter
+	static const bool __isWindows = true;
-// type-matching, rather than considering routines with mis-matched
+	static const bool __isLinux = false;
-// arguments/types to be overloaded functions...
+#else
-//
+	static const bool __isWindows = false;
-// AFAIK, this is os-independent, but it's included here in osdep.h where
+	static const bool __isLinux = true;
-// DLLEXPORT is defined, for convenience.
+#endif
-#define C_DLLEXPORT extern "C" DLLEXPORT
 
 #define EXT_FUNC FORCE_STACK_ALIGN
+
+extern void __declspec(noreturn) rehlds_syserror(const char* fmt, ...);
+
+#endif // _OSCONFIG_H

reapi/include/cssdk/game_shared/bot/bot.h

@@ -35,7 +35,7 @@ public:
 	virtual void Spawn() = 0;
 
 	// invoked when injured by something
-	virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType) = 0;
+	virtual BOOL TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType) = 0;
 
 	// invoked when killed
 	virtual void Killed(entvars_t *pevAttacker, int iGib) = 0;

reapi/include/cssdk/public/asmlib.h

@@ -0,0 +1,123 @@
+/*************************** asmlib.h ***************************************
+* Author:        Agner Fog
+* Date created:  2003-12-12
+* Last modified: 2013-10-04
+* Project:       asmlib.zip
+* Source URL:    www.agner.org/optimize
+*
+* Description:
+* Header file for the asmlib function library.
+* This library is available in many versions for different platforms.
+* See asmlib-instructions.pdf for details.
+*
+* (c) Copyright 2003 - 2013 by Agner Fog. 
+* GNU General Public License http://www.gnu.org/licenses/gpl.html
+*****************************************************************************/
+
+
+#ifndef ASMLIB_H
+#define ASMLIB_H
+
+
+/***********************************************************************
+Define compiler-specific types and directives
+***********************************************************************/
+
+// Define type size_t
+#ifndef _SIZE_T_DEFINED
+#include "stddef.h"
+#endif
+
+// Define integer types with known size: int32_t, uint32_t, int64_t, uint64_t.
+// If this doesn't work then insert compiler-specific definitions here:
+#if defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1600)
+  // Compilers supporting C99 or C++0x have stdint.h defining these integer types
+  #include <stdint.h>
+  #define INT64_SUPPORTED // Remove this if the compiler doesn't support 64-bit integers
+#elif defined(_MSC_VER)
+  // Older Microsoft compilers have their own definition
+  typedef signed   __int16  int16_t;
+  typedef unsigned __int16 uint16_t;
+  typedef signed   __int32  int32_t;
+  typedef unsigned __int32 uint32_t;
+  typedef signed   __int64  int64_t;
+  typedef unsigned __int64 uint64_t;
+  #define INT64_SUPPORTED // Remove this if the compiler doesn't support 64-bit integers
+#else
+  // This works with most compilers
+  typedef signed   short int  int16_t;
+  typedef unsigned short int uint16_t;
+  typedef signed   int        int32_t;
+  typedef unsigned int       uint32_t;
+  typedef long long           int64_t;
+  typedef unsigned long long uint64_t;
+  #define INT64_SUPPORTED // Remove this if the compiler doesn't support 64-bit integers
+#endif
+
+
+// Turn off name mangling
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/***********************************************************************
+Function prototypes, memory and string functions
+***********************************************************************/
+void * A_memcpy (void * dest, const void * src, size_t count); // Copy count bytes from src to dest
+void * A_memmove(void * dest, const void * src, size_t count); // Same as memcpy, allows overlap between src and dest
+void * A_memset (void * dest, int c, size_t count);            // Set count bytes in dest to (char)c
+int    A_memcmp (const void * buf1, const void * buf2, size_t num); // Compares two blocks of memory
+size_t GetMemcpyCacheLimit(void);                              // Data blocks bigger than this will be copied uncached by memcpy and memmove
+void   SetMemcpyCacheLimit(size_t);                            // Change limit in GetMemcpyCacheLimit
+size_t GetMemsetCacheLimit(void);                              // Data blocks bigger than this will be stored uncached by memset
+void   SetMemsetCacheLimit(size_t);                            // Change limit in GetMemsetCacheLimit
+char * A_strcat (char * dest, const char * src);               // Concatenate strings dest and src. Store result in dest
+char * A_strcpy (char * dest, const char * src);               // Copy string src to dest
+size_t A_strlen (const char * str);                            // Get length of zero-terminated string
+int    A_strcmp (const char * a, const char * b);              // Compare strings. Case sensitive
+int    A_stricmp (const char *string1, const char *string2);   // Compare strings. Case insensitive for A-Z only
+char * A_strstr (char * haystack, const char * needle);        // Search for substring in string
+void   A_strtolower(char * string);                            // Convert string to lower case for A-Z only
+void   A_strtoupper(char * string);                            // Convert string to upper case for a-z only
+size_t A_substring(char * dest, const char * source, size_t pos, size_t len); // Copy a substring for source into dest
+size_t A_strspn (const char * str, const char * set);          // Find span of characters that belong to set
+size_t A_strcspn(const char * str, const char * set);          // Find span of characters that don't belong to set
+size_t strCountInSet(const char * str, const char * set);      // Count characters that belong to set
+size_t strcount_UTF8(const char * str);                        // Counts the number of characters in a UTF-8 encoded string
+
+
+/***********************************************************************
+Function prototypes, miscellaneous functions
+***********************************************************************/
+uint32_t A_popcount(uint32_t x);                               // Count 1-bits in 32-bit integer
+int    RoundD (double x);                                      // Round to nearest or even
+int    RoundF (float  x);                                      // Round to nearest or even
+int    InstructionSet(void);                                   // Tell which instruction set is supported
+char * ProcessorName(void);                                    // ASCIIZ text describing microprocessor
+void   CpuType(int * vendor, int * family, int * model);       // Get CPU vendor, family and model
+size_t DataCacheSize(int level);                               // Get size of data cache
+void   A_DebugBreak(void);                                     // Makes a debug breakpoint
+#ifdef INT64_SUPPORTED
+   uint64_t ReadTSC(void);                                     // Read microprocessor internal clock (64 bits)
+#else
+   uint32_t ReadTSC(void);                                     // Read microprocessor internal clock (only 32 bits supported by compiler)
+#endif
+void cpuid_ex (int abcd[4], int eax, int ecx);                 // call CPUID instruction
+static inline void cpuid_abcd (int abcd[4], int eax) {
+   cpuid_ex(abcd, eax, 0);}
+
+#ifdef __cplusplus
+}  // end of extern "C"
+
+// Define overloaded versions if compiling as C++
+
+static inline int Round (double x) {   // Overload name Round
+   return RoundD(x);}
+static inline int Round (float  x) {   // Overload name Round
+   return RoundF(x);}
+static inline const char * A_strstr(const char * haystack, const char * needle) {
+   return A_strstr((char*)haystack, needle);} // Overload A_strstr with const char * version
+
+#endif // __cplusplus
+
+#endif // ASMLIB_H

reapi/include/cssdk/public/basetypes.h

@@ -0,0 +1,300 @@
+//========= Copyright  1996-2001, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef BASETYPES_H
+#define BASETYPES_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "osconfig.h"
+#include "protected_things.h"
+#include "commonmacros.h"
+
+
+// For backward compatibilty only...
+//#include "tier0/platform.h"
+
+// stdio.h
+#ifndef NULL
+#define NULL 0
+#endif
+
+
+#define ExecuteNTimes( nTimes, x )	\
+				{								\
+		static int __executeCount=0;\
+		if ( __executeCount < nTimes )\
+						{							\
+			x;						\
+			++__executeCount;		\
+						}							\
+				}
+
+
+#define ExecuteOnce( x )			ExecuteNTimes( 1, x )
+
+
+// Pad a number so it lies on an N byte boundary.
+// So PAD_NUMBER(0,4) is 0 and PAD_NUMBER(1,4) is 4
+#define PAD_NUMBER(number, boundary) \
+	( ((number) + ((boundary)-1)) / (boundary) ) * (boundary)
+
+// In case this ever changes
+#define M_PI			3.14159265358979323846
+
+// #ifndef min
+// #define min(a,b)  (((a) < (b)) ? (a) : (b))
+// #endif
+
+// #ifndef max
+// #define max(a,b)  (((a) > (b)) ? (a) : (b))
+// #endif
+
+#ifdef __cplusplus
+template<typename T>
+inline T clamp2(T const &val, T const &minVal, T const &maxVal) //renamed to clamp2 to avoid conflicts with clamp defined in mathlib
+{
+	if (val < minVal)
+		return minVal;
+	else if (val > maxVal)
+		return maxVal;
+	else
+		return val;
+}
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#define TRUE (!FALSE)
+#endif
+
+
+typedef int BOOL;
+typedef int qboolean;
+typedef unsigned long ULONG;
+typedef unsigned char BYTE;
+typedef unsigned char byte;
+typedef unsigned short word;
+
+//#include "string_t.h"
+
+typedef float vec_t;
+
+
+// FIXME: this should move 
+#ifndef __cplusplus
+#define true TRUE
+#define false FALSE
+#endif
+
+//-----------------------------------------------------------------------------
+// look for NANs, infinities, and underflows. 
+// This assumes the ANSI/IEEE 754-1985 standard
+//-----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+
+inline unsigned long& FloatBits(vec_t& f)
+{
+	return *reinterpret_cast<unsigned long*>(&f);
+}
+
+inline unsigned long const& FloatBits(vec_t const& f)
+{
+	return *reinterpret_cast<unsigned long const*>(&f);
+}
+
+inline vec_t BitsToFloat(unsigned long i)
+{
+	return *reinterpret_cast<vec_t*>(&i);
+}
+
+inline bool IsFinite(vec_t f)
+{
+	return ((FloatBits(f) & 0x7F800000) != 0x7F800000);
+}
+
+inline unsigned long FloatAbsBits(vec_t f)
+{
+	return FloatBits(f) & 0x7FFFFFFF;
+}
+
+inline float FloatMakeNegative(vec_t f)
+{
+	return BitsToFloat(FloatBits(f) | 0x80000000);
+}
+
+#if defined( WIN32 )
+
+//#include <math.h>
+// Just use prototype from math.h
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+	double __cdecl fabs(double);
+#ifdef __cplusplus
+}
+#endif
+
+// In win32 try to use the intrinsic fabs so the optimizer can do it's thing inline in the code
+#pragma intrinsic( fabs )
+// Also, alias float make positive to use fabs, too
+// NOTE:  Is there a perf issue with double<->float conversion?
+inline float FloatMakePositive(vec_t f)
+{
+	return fabs(f);
+}
+#else
+inline float FloatMakePositive(vec_t f)
+{
+	return BitsToFloat(FloatBits(f) & 0x7FFFFFFF);
+}
+#endif
+
+inline float FloatNegate(vec_t f)
+{
+	return BitsToFloat(FloatBits(f) ^ 0x80000000);
+}
+
+
+#define FLOAT32_NAN_BITS     (unsigned long)0x7FC00000	// not a number!
+#define FLOAT32_NAN          BitsToFloat( FLOAT32_NAN_BITS )
+
+#define VEC_T_NAN FLOAT32_NAN
+
+#endif
+
+// FIXME: why are these here?  Hardly anyone actually needs them.
+struct valve_color24
+{
+	byte r, g, b;
+};
+
+typedef struct valve_color32_s
+{
+	bool operator!=(const struct valve_color32_s &other) const;
+
+	byte r, g, b, a;
+} valve_color32;
+
+inline bool valve_color32::operator!=(const valve_color32 &other) const
+{
+	return r != other.r || g != other.g || b != other.b || a != other.a;
+}
+
+struct valve_colorRGBExp32
+{
+	byte r, g, b;
+	signed char exponent;
+};
+
+struct valve_colorVec
+{
+	unsigned r, g, b, a;
+};
+
+
+#ifndef UNUSED
+#define UNUSED(x)	(x = x)	// for pesky compiler / lint warnings
+#endif
+
+#ifdef __cplusplus
+
+struct vrect_t
+{
+	int				x, y, width, height;
+	vrect_t			*pnext;
+};
+
+#endif
+
+
+//-----------------------------------------------------------------------------
+// MaterialRect_t struct - used for DrawDebugText
+//-----------------------------------------------------------------------------
+struct Rect_t
+{
+	int x, y;
+	int width, height;
+};
+
+
+//-----------------------------------------------------------------------------
+// Declares a type-safe handle type; you can't assign one handle to the next
+//-----------------------------------------------------------------------------
+
+// 32-bit pointer handles.
+
+// Typesafe 8-bit and 16-bit handles.
+template< class HandleType >
+class CBaseIntHandle
+{
+public:
+
+	inline bool			operator==(const CBaseIntHandle &other)	{ return m_Handle == other.m_Handle; }
+	inline bool			operator!=(const CBaseIntHandle &other)	{ return m_Handle != other.m_Handle; }
+
+	// Only the code that doles out these handles should use these functions.
+	// Everyone else should treat them as a transparent type.
+	inline HandleType	GetHandleValue()					{ return m_Handle; }
+	inline void			SetHandleValue(HandleType val)	{ m_Handle = val; }
+
+	typedef HandleType	HANDLE_TYPE;
+
+protected:
+
+	HandleType	m_Handle;
+};
+
+template< class DummyType >
+class CIntHandle16 : public CBaseIntHandle < unsigned short >
+{
+public:
+	inline			CIntHandle16() {}
+
+	static inline	CIntHandle16<DummyType> MakeHandle(HANDLE_TYPE val)
+	{
+		return CIntHandle16<DummyType>(val);
+	}
+
+protected:
+	inline			CIntHandle16(HANDLE_TYPE val)
+	{
+		m_Handle = val;
+	}
+};
+
+
+template< class DummyType >
+class CIntHandle32 : public CBaseIntHandle < unsigned long >
+{
+public:
+	inline			CIntHandle32() {}
+
+	static inline	CIntHandle32<DummyType> MakeHandle(HANDLE_TYPE val)
+	{
+		return CIntHandle32<DummyType>(val);
+	}
+
+protected:
+	inline			CIntHandle32(HANDLE_TYPE val)
+	{
+		m_Handle = val;
+	}
+};
+
+
+// NOTE: This macro is the same as windows uses; so don't change the guts of it
+#define DECLARE_HANDLE_16BIT(name)	typedef CIntHandle16< struct name##__handle * > name;
+#define DECLARE_HANDLE_32BIT(name)	typedef CIntHandle32< struct name##__handle * > name;
+
+#define DECLARE_POINTER_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name
+#define FORWARD_DECLARE_HANDLE(name) typedef struct name##__ *name
+
+#endif // BASETYPES_H

reapi/include/cssdk/public/commonmacros.h

@@ -0,0 +1,30 @@
+#ifndef COMMONMACROS_H
+#define COMMONMACROS_H
+#pragma once
+
+
+// -------------------------------------------------------
+//
+// commonmacros.h
+//
+// This should contain ONLY general purpose macros that are 
+// appropriate for use in engine/launcher/all tools
+//
+// -------------------------------------------------------
+
+#include "osconfig.h"
+// Makes a 4-byte "packed ID" int out of 4 characters
+#define MAKEID(d,c,b,a)					( ((int)(a) << 24) | ((int)(b) << 16) | ((int)(c) << 8) | ((int)(d)) )
+
+// Compares a string with a 4-byte packed ID constant
+#define STRING_MATCHES_ID( p, id )		( (*((int *)(p)) == (id) ) ? true : false )
+#define ID_TO_STRING( id, p )			( (p)[3] = (((id)>>24) & 0xFF), (p)[2] = (((id)>>16) & 0xFF), (p)[1] = (((id)>>8) & 0xFF), (p)[0] = (((id)>>0) & 0xFF) )
+
+#define ARRAYSIZE(p)		(sizeof(p)/sizeof(p[0]))
+
+// Keeps clutter down a bit, when using a float as a bit-vector
+#define SETBITS(flBitVector, bits)		((flBitVector) = (int)(flBitVector) | (bits))
+#define CLEARBITS(flBitVector, bits)	((flBitVector) = (int)(flBitVector) & ~(bits))
+#define FBitSet(flBitVector, bit)		((flBitVector) & (bit))
+
+#endif		// COMMONMACROS_H

reapi/include/cssdk/public/protected_things.h

@@ -0,0 +1,187 @@
+//========= Copyright © 1996-2002, Valve LLC, All rights reserved. ============
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef PROTECTED_THINGS_H
+#define PROTECTED_THINGS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+// This header tries to prevent people from using potentially dangerous functions
+// (like the notorious non-null-terminating strncpy) and functions that will break
+// VCR mode (like time, input, registry, etc).
+//
+// This header should be included by ALL of our source code.
+
+// Eventually, ALL of these should be protected, but one man can only accomplish so much in
+// one day AND work on features too!
+#if defined( PROTECT_STRING_FUNCTIONS )
+#if defined( strncpy )
+#undef strncpy
+#endif
+#define strncpy				strncpy__HEY_YOU__USE_VSTDLIB
+
+
+#if defined( _snprintf )
+#undef _snprintf
+#endif
+#define _snprintf			snprintf__HEY_YOU__USE_VSTDLIB
+
+
+#if defined( sprintf )
+#undef sprintf
+#endif
+#define sprintf				sprintf__HEY_YOU__USE_VSTDLIB
+
+
+#if defined( _vsnprintf )
+#undef _vsnprintf
+#endif
+#define _vsnprintf			vsnprintf__HEY_YOU__USE_VSTDLIB
+
+
+#if defined( strcat )
+#undef strcat
+#endif
+#define strcat				strcat__HEY_YOU__USE_VSTDLIB
+#endif
+
+
+#if defined( PROTECT_FILEIO_FUNCTIONS )
+#if defined( fopen )
+#undef fopen
+#endif
+#define fopen				fopen_USE_FILESYSTEM_INSTEAD
+#endif	
+
+
+#if defined( PROTECTED_THINGS_ENABLE )
+
+#if defined( GetTickCount )
+#undef GetTickCount
+#endif
+#define GetTickCount		GetTickCount__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( timeGetTime )
+#undef timeGetTime
+#endif
+#define timeGetTime			timeGetTime__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( clock )
+#undef clock
+#endif
+#define time				time__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( recvfrom )
+#undef recvfrom
+#endif
+#define recvfrom			recvfrom__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( GetCursorPos )
+#undef GetCursorPos
+#endif
+#define GetCursorPos		GetCursorPos__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( ScreenToClient )
+#undef ScreenToClient
+#endif
+#define ScreenToClient		ScreenToClient__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( GetCommandLine )
+#undef GetCommandLine
+#endif
+#define GetCommandLine		GetCommandLine__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( RegOpenKeyEx )
+#undef RegOpenKeyEx
+#endif
+#define RegOpenKeyEx		RegOpenKeyEx__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( RegOpenKey )
+#undef RegOpenKey
+#endif
+#define RegOpenKey			RegOpenKey__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( RegSetValueEx )
+#undef RegSetValueEx
+#endif
+#define RegSetValueEx		RegSetValueEx__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( RegSetValue )
+#undef RegSetValue
+#endif
+#define RegSetValue			RegSetValue__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( RegQueryValueEx )
+#undef RegQueryValueEx
+#endif		
+#define RegQueryValueEx		RegQueryValueEx__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( RegQueryValue )
+#undef RegQueryValue
+#endif		
+#define RegQueryValue		RegQueryValue__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( RegCreateKeyEx )
+#undef RegCreateKeyEx
+#endif
+#define RegCreateKeyEx		RegCreateKeyEx__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( RegCreateKey )
+#undef RegCreateKey
+#endif
+#define RegCreateKey		RegCreateKey__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( RegCloseKey )
+#undef RegCloseKey
+#endif
+#define RegCloseKey			RegCloseKey__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( GetNumberOfConsoleInputEvents )
+#undef GetNumberOfConsoleInputEvents
+#endif
+#define GetNumberOfConsoleInputEvents	GetNumberOfConsoleInputEvents__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( ReadConsoleInput )
+#undef ReadConsoleInput
+#endif
+#define ReadConsoleInput	ReadConsoleInput__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( GetAsyncKeyState )
+#undef GetAsyncKeyState
+#endif
+#define GetAsyncKeyState	GetAsyncKeyState__HEY_YOU__USE_PLATFORM_LIB
+
+
+#if defined( GetKeyState )
+#undef GetKeyState
+#endif
+#define GetKeyState			GetKeyState__HEY_YOU__USE_PLATFORM_LIB
+
+#endif
+
+
+#endif // PROTECTED_THINGS_H

reapi/include/cssdk/public/tier0/dbg.cpp

@@ -0,0 +1,444 @@
+//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// $Header: $
+// $NoKeywords: $
+//
+// The main debug library implementation
+//=============================================================================
+
+#include "precompiled.h"
+#include <assert.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include "tier0/dbg.h"
+#include <math.h>
+
+
+
+//-----------------------------------------------------------------------------
+// internal structures
+//-----------------------------------------------------------------------------
+
+#define MAX_GROUP_NAME_LENGTH 48
+//enum
+//{
+//	MAX_GROUP_NAME_LENGTH = 48
+//};
+
+struct SpewGroup_t
+{
+	char	m_GroupName[MAX_GROUP_NAME_LENGTH];
+	int		m_Level;
+};
+
+
+//-----------------------------------------------------------------------------
+// Templates to assist in validating pointers:
+
+void _AssertValidReadPtr(void* ptr, int count/* = 1*/)
+{
+#ifdef _WIN32
+	Assert(!IsBadReadPtr(ptr, count));
+#else
+	Assert(ptr);
+#endif
+
+}
+
+void _AssertValidWritePtr(void* ptr, int count/* = 1*/)
+{
+#ifdef _WIN32
+	Assert(!IsBadWritePtr(ptr, count));
+#else
+	Assert(ptr);
+#endif
+}
+
+void _AssertValidReadWritePtr(void* ptr, int count/* = 1*/)
+{
+#ifdef _WIN32
+	Assert(!(IsBadWritePtr(ptr, count) || IsBadReadPtr(ptr, count)));
+#else
+	Assert(ptr);
+#endif
+}
+
+void AssertValidStringPtr(const char* ptr, int maxchar/* = 0xFFFFFF */)
+{
+#ifdef _WIN32
+	Assert(!IsBadStringPtr(ptr, maxchar));
+#else
+	Assert(ptr);
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// globals
+//-----------------------------------------------------------------------------
+
+SpewRetval_t DefaultSpewFunc(SpewType_t type, char const *pMsg)
+{
+	printf("%s", pMsg);
+	if (type == SPEW_ASSERT)
+		return SPEW_DEBUGGER;
+	else if (type == SPEW_ERROR)
+		return SPEW_ABORT;
+	else
+		return SPEW_CONTINUE;
+}
+
+static SpewOutputFunc_t   s_SpewOutputFunc = DefaultSpewFunc;
+
+static char const*	s_pFileName;
+static int			s_Line;
+static SpewType_t	s_SpewType;
+
+static SpewGroup_t* s_pSpewGroups = 0;
+static int			s_GroupCount = 0;
+static int			s_DefaultLevel = 0;
+
+
+
+//-----------------------------------------------------------------------------
+// Spew output management.
+//-----------------------------------------------------------------------------
+
+void  SpewOutputFunc(SpewOutputFunc_t func)
+{
+	s_SpewOutputFunc = func ? func : DefaultSpewFunc;
+}
+
+SpewOutputFunc_t GetSpewOutputFunc(void)
+{
+	if (s_SpewOutputFunc)
+	{
+		return s_SpewOutputFunc;
+	}
+	else
+	{
+		return DefaultSpewFunc;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Spew functions
+//-----------------------------------------------------------------------------
+
+void  _SpewInfo(SpewType_t type, char const* pFile, int line)
+{
+	// Only grab the file name. Ignore the path.
+	char const* pSlash = strrchr(pFile, '\\');
+	char const* pSlash2 = strrchr(pFile, '/');
+	if (pSlash < pSlash2) pSlash = pSlash2;
+
+	s_pFileName = pSlash ? pSlash + 1 : pFile;
+	s_Line = line;
+	s_SpewType = type;
+}
+
+SpewRetval_t  _SpewMessage(SpewType_t spewType, char const* pMsgFormat, va_list args)
+{
+	char pTempBuffer[1024];
+
+	/* Printf the file and line for warning + assert only... */
+	int len = 0;
+	if ((spewType == SPEW_ASSERT))
+	{
+		len = sprintf(pTempBuffer, "%s (%d) : ", s_pFileName, s_Line);
+	}
+
+	/* Create the message.... */
+	len += vsprintf(&pTempBuffer[len], pMsgFormat, args);
+
+	// Add \n for warning and assert
+	if ((spewType == SPEW_ASSERT))
+	{
+		len += sprintf(&pTempBuffer[len], "\n");
+	}
+
+	assert(len < 1024); /* use normal assert here; to avoid recursion. */
+	assert(s_SpewOutputFunc);
+
+	/* direct it to the appropriate target(s) */
+	SpewRetval_t ret = s_SpewOutputFunc(spewType, pTempBuffer);
+	switch (ret)
+	{
+		// Put the break into the macro so it would occur in the right place
+		//	case SPEW_DEBUGGER:
+		//		DebuggerBreak();
+		//		break;
+
+	case SPEW_ABORT:
+		//		MessageBox(NULL,"Error in _SpewMessage","Error",MB_OK);
+		exit(0);
+	}
+
+	return ret;
+}
+
+SpewRetval_t  _SpewMessage(char const* pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	SpewRetval_t ret = _SpewMessage(s_SpewType, pMsgFormat, args);
+	va_end(args);
+	return ret;
+}
+
+SpewRetval_t _DSpewMessage(char const *pGroupName, int level, char const* pMsgFormat, ...)
+{
+	if (!IsSpewActive(pGroupName, level))
+		return SPEW_CONTINUE;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	SpewRetval_t ret = _SpewMessage(s_SpewType, pMsgFormat, args);
+	va_end(args);
+	return ret;
+}
+
+void Msg(char const* pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_MESSAGE, pMsgFormat, args);
+	va_end(args);
+}
+
+void DMsg(char const *pGroupName, int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive(pGroupName, level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_MESSAGE, pMsgFormat, args);
+	va_end(args);
+}
+
+void Warning(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_WARNING, pMsgFormat, args);
+	va_end(args);
+}
+
+void DWarning(char const *pGroupName, int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive(pGroupName, level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_WARNING, pMsgFormat, args);
+	va_end(args);
+}
+
+void Log(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_LOG, pMsgFormat, args);
+	va_end(args);
+}
+
+void DLog(char const *pGroupName, int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive(pGroupName, level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_LOG, pMsgFormat, args);
+	va_end(args);
+}
+
+void Error(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_ERROR, pMsgFormat, args);
+	va_end(args);
+}
+
+
+//-----------------------------------------------------------------------------
+// A couple of super-common dynamic spew messages, here for convenience 
+// These looked at the "developer" group, print if it's level 1 or higher 
+//-----------------------------------------------------------------------------
+
+void DevMsg(int level, char const* pMsgFormat, ...)
+{
+	if (!IsSpewActive("developer", level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_MESSAGE, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevWarning(int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive("developer", level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_WARNING, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevLog(int level, char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive("developer", level))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_LOG, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevMsg(char const *pMsgFormat, ...)
+{
+	if (!IsSpewActive("developer", 1))
+		return;
+
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_MESSAGE, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevWarning(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_WARNING, pMsgFormat, args);
+	va_end(args);
+}
+
+void DevLog(char const *pMsgFormat, ...)
+{
+	va_list args;
+	va_start(args, pMsgFormat);
+	_SpewMessage(SPEW_LOG, pMsgFormat, args);
+	va_end(args);
+}
+
+//-----------------------------------------------------------------------------
+// Find a group, return true if found, false if not. Return in ind the
+// index of the found group, or the index of the group right before where the
+// group should be inserted into the list to maintain sorted order.
+//-----------------------------------------------------------------------------
+
+bool FindSpewGroup(char const* pGroupName, int* pInd)
+{
+	int s = 0;
+	if (s_GroupCount)
+	{
+		int e = (int)(s_GroupCount - 1);
+		while (s <= e)
+		{
+			int m = (s + e) >> 1;
+			int cmp = Q_stricmp(pGroupName, s_pSpewGroups[m].m_GroupName);
+			if (!cmp)
+			{
+				*pInd = m;
+				return true;
+			}
+			if (cmp < 0)
+				e = m - 1;
+			else
+				s = m + 1;
+		}
+	}
+	*pInd = s;
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets the priority level for a spew group
+//-----------------------------------------------------------------------------
+
+void SpewActivate(char const* pGroupName, int level)
+{
+	Assert(pGroupName);
+
+	// check for the default group first...
+	if ((pGroupName[0] == '*') && (pGroupName[1] == '\0'))
+	{
+		s_DefaultLevel = level;
+		return;
+	}
+
+	// Normal case, search in group list using binary search.
+	// If not found, grow the list of groups and insert it into the
+	// right place to maintain sorted order. Then set the level.
+	int ind;
+	if (!FindSpewGroup(pGroupName, &ind))
+	{
+		// not defined yet, insert an entry.
+		++s_GroupCount;
+		if (s_pSpewGroups)
+		{
+			s_pSpewGroups = (SpewGroup_t*)realloc(s_pSpewGroups,
+				s_GroupCount * sizeof(SpewGroup_t));
+
+			// shift elements down to preserve order
+			int numToMove = s_GroupCount - ind - 1;
+			memmove(&s_pSpewGroups[ind + 1], &s_pSpewGroups[ind],
+				numToMove * sizeof(SpewGroup_t));
+		}
+		else
+			s_pSpewGroups = (SpewGroup_t*)malloc(s_GroupCount * sizeof(SpewGroup_t));
+
+		Assert(strlen(pGroupName) < MAX_GROUP_NAME_LENGTH);
+		strcpy(s_pSpewGroups[ind].m_GroupName, pGroupName);
+	}
+	s_pSpewGroups[ind].m_Level = level;
+}
+
+
+//-----------------------------------------------------------------------------
+// Tests to see if a particular spew is active
+//-----------------------------------------------------------------------------
+
+bool IsSpewActive(char const* pGroupName, int level)
+{
+	// If we don't find the spew group, use the default level.
+	int ind;
+	if (FindSpewGroup(pGroupName, &ind))
+		return s_pSpewGroups[ind].m_Level >= level;
+	else
+		return s_DefaultLevel >= level;
+}
+
+
+// If we don't have a function from math.h, then it doesn't link certain floating-point
+// functions in and printfs with %f cause runtime errors in the C libraries.
+float CrackSmokingCompiler(float a)
+{
+	return fabs(a);
+}
+
+void* Plat_SimpleLog(const char* file, int line)
+{
+	FILE* f = fopen("simple.log", "at+");
+	fprintf(f, "%s:%i\n", file, line);
+	fclose(f);
+
+	return NULL;
+}

reapi/include/cssdk/public/tier0/dbg.h

@@ -0,0 +1,451 @@
+//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// $Header: $
+// $NoKeywords: $
+//
+// The main debug library interfaces
+//=============================================================================
+
+
+#ifndef DBG_H
+#define DBG_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "osconfig.h"
+#include "basetypes.h"
+#include "tier0/platform.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+//-----------------------------------------------------------------------------
+// dll export stuff
+//-----------------------------------------------------------------------------
+
+#ifdef TIER0_DLL_EXPORT
+#define DBG_INTERFACE	DLL_EXPORT
+#define DBG_OVERLOAD	DLL_GLOBAL_EXPORT
+#define DBG_CLASS		DLL_CLASS_EXPORT
+#else
+#define DBG_INTERFACE	DLL_IMPORT
+#define DBG_OVERLOAD	DLL_GLOBAL_IMPORT
+#define DBG_CLASS		DLL_CLASS_IMPORT
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Usage model for the Dbg library
+//
+// 1. Spew.
+// 
+//   Spew can be used in a static and a dynamic mode. The static
+//   mode allows us to display assertions and other messages either only
+//   in debug builds, or in non-release builds. The dynamic mode allows us to
+//   turn on and off certain spew messages while the application is running.
+// 
+//   Static Spew messages:
+//
+//     Assertions are used to detect and warn about invalid states
+//     Spews are used to display a particular status/warning message.
+//
+//     To use an assertion, use
+//
+//     Assert( (f == 5) );
+//     AssertMsg( (f == 5), ("F needs to be %d here!\n", 5) );
+//     AssertFunc( (f == 5), BadFunc() );
+//     AssertEquals( f, 5 );
+//     AssertFloatEquals( f, 5.0f, 1e-3 );
+//
+//     The first will simply report that an assertion failed on a particular
+//     code file and line. The second version will display a print-f formatted message 
+//	   along with the file and line, the third will display a generic message and
+//     will also cause the function BadFunc to be executed, and the last two
+//	   will report an error if f is not equal to 5 (the last one asserts within
+//	   a particular tolerance).
+//
+//     To use a warning, use
+//      
+//     Warning("Oh I feel so %s all over\n", "yummy");
+//
+//     Warning will do its magic in only Debug builds. To perform spew in *all*
+//     builds, use RelWarning.
+//
+//	   Three other spew types, Msg, Log, and Error, are compiled into all builds.
+//	   These error types do *not* need two sets of parenthesis.
+//
+//	   Msg( "Isn't this exciting %d?", 5 );
+//	   Error( "I'm just thrilled" );
+//
+//   Dynamic Spew messages
+//
+//     It is possible to dynamically turn spew on and off. Dynamic spew is 
+//     identified by a spew group and priority level. To turn spew on for a 
+//     particular spew group, use SpewActivate( "group", level ). This will 
+//     cause all spew in that particular group with priority levels <= the 
+//     level specified in the SpewActivate function to be printed. Use DSpew 
+//     to perform the spew:
+//
+//     DWarning( "group", level, "Oh I feel even yummier!\n" );
+//
+//     Priority level 0 means that the spew will *always* be printed, and group
+//     '*' is the default spew group. If a DWarning is encountered using a group 
+//     whose priority has not been set, it will use the priority of the default 
+//     group. The priority of the default group is initially set to 0.      
+//
+//   Spew output
+//   
+//     The output of the spew system can be redirected to an externally-supplied
+//     function which is responsible for outputting the spew. By default, the 
+//     spew is simply printed using printf.
+//
+//     To redirect spew output, call SpewOutput.
+//
+//     SpewOutputFunc( OutputFunc );
+//
+//     This will cause OutputFunc to be called every time a spew message is
+//     generated. OutputFunc will be passed a spew type and a message to print.
+//     It must return a value indicating whether the debugger should be invoked,
+//     whether the program should continue running, or whether the program 
+//     should abort. 
+//
+// 2. Code activation
+//
+//   To cause code to be run only in debug builds, use DBG_CODE:
+//   An example is below.
+//
+//   DBG_CODE(
+//				{
+//					int x = 5;
+//					++x;
+//				}
+//           ); 
+//
+//   Code can be activated based on the dynamic spew groups also. Use
+//  
+//   DBG_DCODE( "group", level,
+//              { int x = 5; ++x; }
+//            );
+//
+// 3. Breaking into the debugger.
+//
+//   To cause an unconditional break into the debugger in debug builds only, use DBG_BREAK
+//
+//   DBG_BREAK();
+//
+//	 You can force a break in any build (release or debug) using
+//
+//	 DebuggerBreak();
+//-----------------------------------------------------------------------------
+
+/* Various types of spew messages */
+// I'm sure you're asking yourself why SPEW_ instead of DBG_ ?
+// It's because DBG_ is used all over the place in windows.h
+// For example, DBG_CONTINUE is defined. Feh.
+enum SpewType_t
+{
+	SPEW_MESSAGE = 0,
+	SPEW_WARNING,
+	SPEW_ASSERT,
+	SPEW_ERROR,
+	SPEW_LOG,
+
+	SPEW_TYPE_COUNT
+};
+
+enum SpewRetval_t
+{
+	SPEW_DEBUGGER = 0,
+	SPEW_CONTINUE,
+	SPEW_ABORT
+};
+
+/* type of externally defined function used to display debug spew */
+typedef SpewRetval_t(*SpewOutputFunc_t)(SpewType_t spewType, char const *pMsg);
+
+/* Used to redirect spew output */
+void   SpewOutputFunc(SpewOutputFunc_t func);
+
+/* Used ot get the current spew output function */
+SpewOutputFunc_t GetSpewOutputFunc(void);
+
+/* Used to manage spew groups and subgroups */
+void   SpewActivate(char const* pGroupName, int level);
+bool   IsSpewActive(char const* pGroupName, int level);
+
+/* Used to display messages, should never be called directly. */
+void   _SpewInfo(SpewType_t type, char const* pFile, int line);
+SpewRetval_t   _SpewMessage(char const* pMsg, ...);
+SpewRetval_t   _DSpewMessage(char const *pGroupName, int level, char const* pMsg, ...);
+
+/* Used to define macros, never use these directly. */
+#define  _Assert( _exp )			do {															\
+									if (!(_exp)) 													\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										if (_SpewMessage("Assertion Failed: " #_exp) == SPEW_DEBUGGER)		\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+									} while (0)
+
+#define  _AssertMsg( _exp, _msg )	do {															\
+									if (!(_exp)) 													\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										if (_SpewMessage(_msg) == SPEW_DEBUGGER)					\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+									} while (0)
+
+#define  _AssertFunc( _exp, _f )	do {															\
+									if (!(_exp)) 													\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										SpewRetval_t ret = _SpewMessage("Assertion Failed!" #_exp);	\
+										_f;															\
+										if (ret == SPEW_DEBUGGER)									\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+									} while (0)
+
+#define  _AssertEquals( _exp, _expectedValue ) \
+									do {															\
+									if ((_exp) != (_expectedValue)) 								\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										SpewRetval_t ret = _SpewMessage("Expected %d but got %d!", (_expectedValue), (_exp));	\
+										if (ret == SPEW_DEBUGGER)									\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+																											} while (0)
+
+#define  _AssertFloatEquals( _exp, _expectedValue, _tol ) \
+									do {															\
+									if (fabs((_exp) - (_expectedValue)) > (_tol))					\
+																											{ 																\
+										_SpewInfo( SPEW_ASSERT, __FILE__, __LINE__ );				\
+										SpewRetval_t ret = _SpewMessage("Expected %f but got %f!", (_expectedValue), (_exp));	\
+										if (ret == SPEW_DEBUGGER)									\
+																														{															\
+											DebuggerBreak();										\
+																														}															\
+																											}																\
+																											} while (0)
+
+/* Spew macros... */
+
+#ifdef _DEBUG
+
+#define  Assert( _exp )           _Assert( _exp )
+#define  AssertMsg( _exp, _msg )  _AssertMsg( _exp, _msg )
+#define  AssertFunc( _exp, _f )   _AssertFunc( _exp, _f )
+#define  AssertEquals( _exp, _expectedValue )              _AssertEquals( _exp, _expectedValue ) 
+#define  AssertFloatEquals( _exp, _expectedValue, _tol )   _AssertFloatEquals( _exp, _expectedValue, _tol )
+#define  Verify( _exp )           _Assert( _exp )
+
+#define  AssertMsg1( _exp, _msg, a1 )									_AssertMsg( _exp, CDbgFmtMsg( _msg, a1 ) )
+#define  AssertMsg2( _exp, _msg, a1, a2 )								_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2 ) )
+#define  AssertMsg3( _exp, _msg, a1, a2, a3 )							_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3 ) )
+#define  AssertMsg4( _exp, _msg, a1, a2, a3, a4 )						_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4 ) )
+#define  AssertMsg5( _exp, _msg, a1, a2, a3, a4, a5 )					_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5 ) )
+#define  AssertMsg6( _exp, _msg, a1, a2, a3, a4, a5, a6 )				_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6 ) )
+#define  AssertMsg6( _exp, _msg, a1, a2, a3, a4, a5, a6 )				_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6 ) )
+#define  AssertMsg7( _exp, _msg, a1, a2, a3, a4, a5, a6, a7 )			_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6, a7 ) )
+#define  AssertMsg8( _exp, _msg, a1, a2, a3, a4, a5, a6, a7, a8 )		_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6, a7, a8 ) )
+#define  AssertMsg9( _exp, _msg, a1, a2, a3, a4, a5, a6, a7, a8, a9 )	_AssertMsg( _exp, CDbgFmtMsg( _msg, a1, a2, a3, a4, a5, a6, a7, a8, a9 ) )
+
+
+#else /* Not _DEBUG */
+
+#define  Assert( _exp )           ((void)0)
+#define  AssertMsg( _exp, _msg )  ((void)0)
+#define  AssertFunc( _exp, _f )   ((void)0)
+#define  AssertEquals( _exp, _expectedValue )              ((void)0)
+#define  AssertFloatEquals( _exp, _expectedValue, _tol )   ((void)0)
+#define  Verify( _exp )			  (_exp)
+
+#define  AssertMsg1( _exp, _msg, a1 )									((void)0)
+#define  AssertMsg2( _exp, _msg, a1, a2 )								((void)0)
+#define  AssertMsg3( _exp, _msg, a1, a2, a3 )							((void)0)
+#define  AssertMsg4( _exp, _msg, a1, a2, a3, a4 )						((void)0)
+#define  AssertMsg5( _exp, _msg, a1, a2, a3, a4, a5 )					((void)0)
+#define  AssertMsg6( _exp, _msg, a1, a2, a3, a4, a5, a6 )				((void)0)
+#define  AssertMsg6( _exp, _msg, a1, a2, a3, a4, a5, a6 )				((void)0)
+#define  AssertMsg7( _exp, _msg, a1, a2, a3, a4, a5, a6, a7 )			((void)0)
+#define  AssertMsg8( _exp, _msg, a1, a2, a3, a4, a5, a6, a7, a8 )		((void)0)
+#define  AssertMsg9( _exp, _msg, a1, a2, a3, a4, a5, a6, a7, a8, a9 )	((void)0)
+
+#endif   /* _DEBUG */
+
+
+
+/* These are always compiled in */
+void Msg(char const* pMsg, ...);
+void DMsg(char const *pGroupName, int level, char const *pMsg, ...);
+
+void Warning(char const *pMsg, ...);
+void DWarning(char const *pGroupName, int level, char const *pMsg, ...);
+
+void Log(char const *pMsg, ...);
+void DLog(char const *pGroupName, int level, char const *pMsg, ...);
+
+void Error(char const *pMsg, ...);
+
+// You can use this macro like a runtime assert macro.
+// If the condition fails, then Error is called with the message. This macro is called
+// like AssertMsg, where msg must be enclosed in parenthesis:
+//
+// ErrorIfNot( bCondition, ("a b c %d %d %d", 1, 2, 3) );
+#define ErrorIfNot( condition, msg ) \
+	if ( (condition) )		\
+		;					\
+				else 					\
+	{						\
+		Error msg;			\
+	}
+
+/* A couple of super-common dynamic spew messages, here for convenience */
+/* These looked at the "developer" group */
+void DevMsg(int level, char const* pMsg, ...);
+void DevWarning(int level, char const *pMsg, ...);
+void DevLog(int level, char const *pMsg, ...);
+
+/* default level versions (level 1) */
+void DevMsg(char const* pMsg, ...);
+void DevWarning(char const *pMsg, ...);
+void DevLog(char const *pMsg, ...);
+
+/* Code macros, debugger interface */
+
+#ifdef _DEBUG
+
+#define DBG_CODE( _code )            if (0) ; else { _code }
+#define DBG_DCODE( _g, _l, _code )   if (IsSpewActive( _g, _l )) { _code } else {}
+#define DBG_BREAK()                  DebuggerBreak()	/* defined in platform.h */ 
+
+#else /* not _DEBUG */
+
+#define DBG_CODE( _code )            ((void)0)
+#define DBG_DCODE( _g, _l, _code )   ((void)0)
+#define DBG_BREAK()                  ((void)0)
+
+#endif /* _DEBUG */
+
+//-----------------------------------------------------------------------------
+// Macro to assist in asserting constant invariants during compilation
+
+#define UID_PREFIX generated_id_
+#define UID_CAT1(a,c) a ## c
+#define UID_CAT2(a,c) UID_CAT1(a,c)
+#define UNIQUE_ID UID_CAT2(UID_PREFIX,__LINE__)
+
+
+#ifdef _DEBUG
+#define COMPILE_TIME_ASSERT( pred )	switch(0){case 0:case pred:;}
+#define ASSERT_INVARIANT( pred )	static void UNIQUE_ID() { COMPILE_TIME_ASSERT( pred ) }
+#else
+#define COMPILE_TIME_ASSERT( pred )
+#define ASSERT_INVARIANT( pred )
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Templates to assist in validating pointers:
+
+// Have to use these stubs so we don't have to include windows.h here.
+void _AssertValidReadPtr(void* ptr, int count = 1);
+void _AssertValidWritePtr(void* ptr, int count = 1);
+void _AssertValidReadWritePtr(void* ptr, int count = 1);
+
+ void AssertValidStringPtr(const char* ptr, int maxchar = 0xFFFFFF);
+template<class T> inline void AssertValidReadPtr(T* ptr, int count = 1)		     { _AssertValidReadPtr((void*)ptr, count); }
+template<class T> inline void AssertValidWritePtr(T* ptr, int count = 1)		     { _AssertValidWritePtr((void*)ptr, count); }
+template<class T> inline void AssertValidReadWritePtr(T* ptr, int count = 1)	     { _AssertValidReadWritePtr((void*)ptr, count); }
+
+#define AssertValidThis() AssertValidReadWritePtr(this,sizeof(*this))
+
+//-----------------------------------------------------------------------------
+// Macro to protect functions that are not reentrant
+
+#ifdef _DEBUG
+class CReentryGuard
+{
+public:
+	CReentryGuard(int *pSemaphore)
+		: m_pSemaphore(pSemaphore)
+	{
+		++(*m_pSemaphore);
+	}
+
+	~CReentryGuard()
+	{
+		--(*m_pSemaphore);
+	}
+
+private:
+	int *m_pSemaphore;
+};
+
+#define ASSERT_NO_REENTRY() \
+	static int fSemaphore##__LINE__; \
+	Assert( !fSemaphore##__LINE__ ); \
+	CReentryGuard ReentryGuard##__LINE__( &fSemaphore##__LINE__ )
+#else
+#define ASSERT_NO_REENTRY()
+#endif
+
+//-----------------------------------------------------------------------------
+//
+// Purpose: Inline string formatter
+//
+
+class CDbgFmtMsg
+{
+public:
+	CDbgFmtMsg(const char *pszFormat, ...)
+	{
+		va_list arg_ptr;
+
+		va_start(arg_ptr, pszFormat);
+		_vsnprintf(m_szBuf, sizeof(m_szBuf) - 1, pszFormat, arg_ptr);
+		va_end(arg_ptr);
+
+		m_szBuf[sizeof(m_szBuf) - 1] = 0;
+	}
+
+	operator const char *() const
+	{
+		return m_szBuf;
+	}
+
+private:
+	char m_szBuf[256];
+};
+
+//-----------------------------------------------------------------------------
+//
+// Purpose: Embed debug info in each file.
+//
+//#ifdef _WIN32
+//#ifdef _DEBUG
+//#pragma comment(compiler)
+//#pragma comment(exestr,"*** DEBUG file detected, Last Compile: " __DATE__ ", " __TIME__ " ***")
+//#endif
+//#endif
+
+#endif /* DBG_H */

reapi/include/cssdk/public/tier0/platform.h

@@ -0,0 +1,630 @@
+//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// $Header: $
+// $NoKeywords: $
+//
+// Extremely low-level platform-specific stuff
+//=============================================================================
+
+
+#ifndef PLATFORM_H
+#define PLATFORM_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "osconfig.h"
+
+// need this for _alloca
+#include <malloc.h>
+
+// need this for memset
+#include <string.h>
+
+#include "archtypes.h"
+
+typedef float  float32;
+typedef double float64;
+
+// for when we don't care about how many bits we use
+typedef unsigned int uint;
+
+// This can be used to ensure the size of pointers to members when declaring
+// a pointer type for a class that has only been forward declared
+#ifdef _MSC_VER
+#define SINGLE_INHERITANCE __single_inheritance 
+#define MULTIPLE_INHERITANCE __multiple_inheritance 
+#else
+#define SINGLE_INHERITANCE  
+#define MULTIPLE_INHERITANCE 
+#endif
+
+/*
+FIXME: Enable this when we no longer fear change =)
+
+// need these for the limits
+#include <limits.h>
+#include <float.h>
+
+// Maximum and minimum representable values
+#define  INT8_MAX    SCHAR_MAX
+#define  INT16_MAX   SHRT_MAX
+#define  INT32_MAX   LONG_MAX
+#define  INT64_MAX   (((int64)~0) >> 1)
+
+#define  INT8_MIN    SCHAR_MIN
+#define  INT16_MIN   SHRT_MIN
+#define  INT32_MIN   LONG_MIN
+#define  INT64_MIN   (((int64)1) << 63)
+
+#define  UINT8_MAX   ((uint8)~0)
+#define  UINT16_MAX  ((uint16)~0)
+#define  UINT32_MAX  ((uint32)~0)
+#define  UINT64_MAX  ((uint64)~0)
+
+#define  UINT8_MIN   0
+#define  UINT16_MIN  0
+#define  UINT32_MIN  0
+#define  UINT64_MIN  0
+
+#ifndef  UINT_MIN
+#define  UINT_MIN    UINT32_MIN
+#endif
+
+#define  FLOAT32_MAX FLT_MAX
+#define  FLOAT64_MAX DBL_MAX
+
+#define  FLOAT32_MIN FLT_MIN
+#define  FLOAT64_MIN DBL_MIN
+*/
+
+// portability / compiler settings
+#if defined(_WIN32) && !defined(WINDED)
+
+#if defined(_M_IX86)
+#define __i386__	1
+#endif
+
+#elif __linux__
+typedef void * HINSTANCE;
+#define _MAX_PATH PATH_MAX
+#endif // defined(_WIN32) && !defined(WINDED)
+
+
+// Defines MAX_PATH
+#ifndef MAX_PATH
+#define MAX_PATH  260
+#endif
+
+// Used to step into the debugger
+#define  DebuggerBreak()  __asm { int 3 }
+
+// C functions for external declarations that call the appropriate C++ methods
+#ifndef EXPORT
+#ifdef _WIN32
+#define EXPORT	_declspec( dllexport )
+#else 
+#define EXPORT	/* */
+#endif
+#endif
+
+#if defined __i386__ && !defined __linux__
+#define id386	1
+#else
+#define id386	0
+#endif  // __i386__
+
+#ifdef _WIN32
+// Used for dll exporting and importing
+#define  DLL_EXPORT   extern "C" __declspec( dllexport ) 
+#define  DLL_IMPORT   extern "C" __declspec( dllimport )
+
+// Can't use extern "C" when DLL exporting a class
+#define  DLL_CLASS_EXPORT   __declspec( dllexport ) 
+#define  DLL_CLASS_IMPORT   __declspec( dllimport )
+
+// Can't use extern "C" when DLL exporting a global
+#define  DLL_GLOBAL_EXPORT   extern __declspec( dllexport ) 
+#define  DLL_GLOBAL_IMPORT   extern __declspec( dllimport )
+#elif defined __linux__
+
+// Used for dll exporting and importing
+#define  DLL_EXPORT   extern "C" 
+#define  DLL_IMPORT   extern "C" 
+
+// Can't use extern "C" when DLL exporting a class
+#define  DLL_CLASS_EXPORT   
+#define  DLL_CLASS_IMPORT  
+
+// Can't use extern "C" when DLL exporting a global
+#define  DLL_GLOBAL_EXPORT   extern
+#define  DLL_GLOBAL_IMPORT   extern 
+
+#else
+#error "Unsupported Platform."
+#endif
+
+// Used for standard calling conventions
+#ifdef _WIN32
+#define  FASTCALL			   __fastcall
+#define  FORCEINLINE		   __forceinline	
+#else
+#define  FASTCALL			   
+#define  FORCEINLINE		   inline
+#endif
+
+// Force a function call site -not- to inlined. (useful for profiling)
+#define DONT_INLINE(a) (((int)(a)+1)?(a):(a))
+
+// Pass hints to the compiler to prevent it from generating unnessecary / stupid code
+// in certain situations.  Several compilers other than MSVC also have an equivilent 
+// construct.
+//
+// Essentially the 'Hint' is that the condition specified is assumed to be true at 
+// that point in the compilation.  If '0' is passed, then the compiler assumes that
+// any subsequent code in the same 'basic block' is unreachable, and thus usually 
+// removed.
+#ifdef _MSC_VER
+#define HINT(THE_HINT)	__assume((THE_HINT))
+#else
+#define HINT(THE_HINT)	0
+#endif
+
+// Marks the codepath from here until the next branch entry point as unreachable,
+// and asserts if any attempt is made to execute it.
+#define UNREACHABLE() { Assert(0); HINT(0); }
+
+// In cases where no default is present or appropriate, this causes MSVC to generate 
+// as little code as possible, and throw an assertion in debug.
+#define NO_DEFAULT default: UNREACHABLE();
+
+#ifdef _WIN32
+// Alloca defined for this platform
+#define  stackalloc( _size ) _alloca( _size )
+#define  stackfree( _p )   0
+#elif __linux__
+// Alloca defined for this platform
+#define  stackalloc( _size ) alloca( _size )
+#define  stackfree( _p )   0
+#endif
+
+#ifdef _WIN32
+// Remove warnings from warning level 4.
+#pragma warning(disable : 4514) // warning C4514: 'acosl' : unreferenced inline function has been removed
+#pragma warning(disable : 4100) // warning C4100: 'hwnd' : unreferenced formal parameter
+#pragma warning(disable : 4127) // warning C4127: conditional expression is constant
+#pragma warning(disable : 4512) // warning C4512: 'InFileRIFF' : assignment operator could not be generated
+#pragma warning(disable : 4611) // warning C4611: interaction between '_setjmp' and C++ object destruction is non-portable
+#pragma warning(disable : 4706) // warning C4706: assignment within conditional expression
+#pragma warning(disable : 4710) // warning C4710: function 'x' not inlined
+#pragma warning(disable : 4702) // warning C4702: unreachable code
+#pragma warning(disable : 4505) // unreferenced local function has been removed
+#pragma warning(disable : 4239) // nonstandard extension used : 'argument' ( conversion from class Vector to class Vector& )
+#pragma warning(disable : 4097) // typedef-name 'BaseClass' used as synonym for class-name 'CFlexCycler::CBaseFlex'
+#pragma warning(disable : 4324) // Padding was added at the end of a structure
+#pragma warning(disable : 4244) // type conversion warning.
+#pragma warning(disable : 4305)	// truncation from 'const double ' to 'float '
+#pragma warning(disable : 4786)	// Disable warnings about long symbol names
+
+#if _MSC_VER >= 1300
+#pragma warning(disable : 4511)	// Disable warnings about private copy constructors
+#endif
+#endif
+//-----------------------------------------------------------------------------
+// Purpose: Standard functions for handling endian-ness
+//-----------------------------------------------------------------------------
+
+//-------------------------------------
+// Basic swaps
+//-------------------------------------
+
+template <typename T>
+inline T WordSwapC(T w)
+{
+	uint16 temp;
+
+	temp = ((*((uint16 *)&w) & 0xff00) >> 8);
+	temp |= ((*((uint16 *)&w) & 0x00ff) << 8);
+
+	return *((T*)&temp);
+}
+
+template <typename T>
+inline T DWordSwapC(T dw)
+{
+	uint32 temp;
+
+	temp = *((uint32 *)&dw) >> 24;
+	temp |= ((*((uint32 *)&dw) & 0x00FF0000) >> 8);
+	temp |= ((*((uint32 *)&dw) & 0x0000FF00) << 8);
+	temp |= ((*((uint32 *)&dw) & 0x000000FF) << 24);
+
+	return *((T*)&temp);
+}
+
+//-------------------------------------
+// Fast swaps
+//-------------------------------------
+
+#ifdef _MSC_VER
+
+#define WordSwap  WordSwapAsm
+#define DWordSwap DWordSwapAsm
+
+#pragma warning(push)
+#pragma warning (disable:4035) // no return value
+
+template <typename T>
+inline T WordSwapAsm(T w)
+{
+	__asm
+	{
+		mov ax, w
+			xchg al, ah
+	}
+}
+
+template <typename T>
+inline T DWordSwapAsm(T dw)
+{
+	__asm
+	{
+		mov eax, dw
+			bswap eax
+	}
+}
+
+#pragma warning(pop)
+
+// The assembly implementation is not compatible with floats
+template <>
+inline float DWordSwapAsm<float>(float f)
+{
+	return DWordSwapC(f);
+}
+
+#else
+
+#define WordSwap  WordSwapC
+#define DWordSwap DWordSwapC
+
+#endif
+
+//-------------------------------------
+// The typically used methods. 
+//-------------------------------------
+
+#if defined(__i386__)
+#define VALVE_LITTLE_ENDIAN 1
+#endif
+
+#ifdef _SGI_SOURCE
+#define VALVE_BIG_ENDIAN 1
+#endif
+
+#if defined(VALVE_LITTLE_ENDIAN)
+
+#define Valve_BigShort( val )		WordSwap( val )
+#define Valve_BigWord( val )		WordSwap( val )
+#define Valve_BigLong( val )		DWordSwap( val )
+#define Valve_BigDWord( val )		DWordSwap( val )
+#define Valve_BigFloat( val )		DWordSwap( val )
+#define Valve_LittleShort( val )	( val )
+#define Valve_LittleWord( val )	( val )
+#define Valve_LittleLong( val )	( val )
+#define Valve_LittleDWord( val )	( val )
+#define Valve_LittleFloat( val )	( val )
+
+#elif defined(BIG_ENDIAN)
+
+#define Valve_BigShort( val )		( val )
+#define Valve_BigWord( val )		( val )
+#define Valve_BigLong( val )		( val )
+#define Valve_BigDWord( val )		( val )
+#define Valve_BigFloat( val )		( val )
+#define Valve_LittleShort( val )	WordSwap( val )
+#define Valve_LittleWord( val )	WordSwap( val )
+#define Valve_LittleLong( val )	DWordSwap( val )
+#define Valve_LittleDWord( val )	DWordSwap( val )
+#define Valve_LittleFloat( val )	DWordSwap( val )
+
+#else
+
+// @Note (toml 05-02-02): this technique expects the compiler to 
+// optimize the expression and eliminate the other path. On any new 
+// platform/compiler this should be tested.
+inline short BigShort(short val)		{ int test = 1; return (*(char *)&test == 1) ? WordSwap(val) : val; }
+inline uint16 BigWord(uint16 val)		{ int test = 1; return (*(char *)&test == 1) ? WordSwap(val) : val; }
+inline long BigLong(long val)			{ int test = 1; return (*(char *)&test == 1) ? DWordSwap(val) : val; }
+inline uint32 BigDWord(uint32 val)	{ int test = 1; return (*(char *)&test == 1) ? DWordSwap(val) : val; }
+inline float BigFloat(float val)		{ int test = 1; return (*(char *)&test == 1) ? DWordSwap(val) : val; }
+inline short LittleShort(short val)	{ int test = 1; return (*(char *)&test == 1) ? val : WordSwap(val); }
+inline uint16 LittleWord(uint16 val)	{ int test = 1; return (*(char *)&test == 1) ? val : WordSwap(val); }
+inline long LittleLong(long val)		{ int test = 1; return (*(char *)&test == 1) ? val : DWordSwap(val); }
+inline uint32 LittleDWord(uint32 val)	{ int test = 1; return (*(char *)&test == 1) ? val : DWordSwap(val); }
+inline float LittleFloat(float val)	{ int test = 1; return (*(char *)&test == 1) ? val : DWordSwap(val); }
+
+#endif
+
+
+
+#ifdef TIER0_DLL_EXPORT
+#define PLATFORM_INTERFACE	DLL_EXPORT
+#define PLATFORM_OVERLOAD	DLL_GLOBAL_EXPORT
+#else
+#define PLATFORM_INTERFACE	DLL_IMPORT
+#define PLATFORM_OVERLOAD	DLL_GLOBAL_IMPORT
+#endif
+
+/*
+PLATFORM_INTERFACE double			Plat_FloatTime();		// Returns time in seconds since the module was loaded.
+PLATFORM_INTERFACE unsigned long	Plat_MSTime();			// Time in milliseconds.
+
+// b/w compatibility
+#define Sys_FloatTime Plat_FloatTime
+*/
+
+// Processor Information:
+struct CPUInformation
+{
+	int	 m_Size;		// Size of this structure, for forward compatability.
+
+	bool m_bRDTSC : 1,	// Is RDTSC supported?
+	m_bCMOV : 1,  // Is CMOV supported?
+		  m_bFCMOV : 1,  // Is FCMOV supported?
+				 m_bSSE : 1,	// Is SSE supported?
+					  m_bSSE2 : 1,	// Is SSE2 Supported?
+							m_b3DNow : 1,	// Is 3DNow! Supported?
+								   m_bMMX : 1,	// Is MMX supported?
+										m_bHT : 1;	// Is HyperThreading supported?
+
+	unsigned char m_nLogicalProcessors,		// Number op logical processors.
+		m_nPhysicalProcessors;	// Number of physical processors
+
+	int64 m_Speed;						// In cycles per second.
+
+	char* m_szProcessorID;				// Processor vendor Identification.
+};
+
+PLATFORM_INTERFACE const CPUInformation& GetCPUInformation();
+
+
+//-----------------------------------------------------------------------------
+// Thread related functions
+//-----------------------------------------------------------------------------
+// Registers the current thread with Tier0's thread management system. 
+// This should be called on every thread created in the game.
+PLATFORM_INTERFACE unsigned long Plat_RegisterThread(const char *pName = "Source Thread");
+
+// Registers the current thread as the primary thread.
+PLATFORM_INTERFACE unsigned long Plat_RegisterPrimaryThread();
+
+// VC-specific. Sets the thread's name so it has a friendly name in the debugger.
+// This should generally only be handled by Plat_RegisterThread and Plat_RegisterPrimaryThread
+PLATFORM_INTERFACE void	Plat_SetThreadName(unsigned long dwThreadID, const char *pName);
+
+// These would be private if it were possible to export private variables from a .DLL.
+// They need to be variables because they are checked by inline functions at performance
+// critical places.
+PLATFORM_INTERFACE unsigned long Plat_PrimaryThreadID;
+
+// Returns the ID of the currently executing thread.
+PLATFORM_INTERFACE unsigned long Plat_GetCurrentThreadID();
+
+// Returns the ID of the primary thread.
+inline unsigned long Plat_GetPrimaryThreadID()
+{
+	return Plat_PrimaryThreadID;
+}
+
+// Returns true if the current thread is the primary thread.
+inline bool Plat_IsPrimaryThread()
+{
+	//return true;
+	return (Plat_GetPrimaryThreadID() == Plat_GetCurrentThreadID());
+}
+
+//-----------------------------------------------------------------------------
+// Security related functions
+//-----------------------------------------------------------------------------
+// Ensure that the hardware key's drivers have been installed.
+PLATFORM_INTERFACE bool Plat_VerifyHardwareKeyDriver();
+
+// Ok, so this isn't a very secure way to verify the hardware key for now.  It 
+// is primarially depending on the fact that all the binaries have been wrapped
+// with the secure wrapper provided by the hardware keys vendor.
+PLATFORM_INTERFACE bool Plat_VerifyHardwareKey();
+
+// The same as above, but notifies user with a message box when the key isn't in 
+// and gives him an opportunity to correct the situation.
+PLATFORM_INTERFACE bool Plat_VerifyHardwareKeyPrompt();
+
+// Can be called in real time, doesn't perform the verify every frame.  Mainly just
+// here to allow the game to drop out quickly when the key is removed, rather than
+// allowing the wrapper to pop up it's own blocking dialog, which the engine doesn't 
+// like much.
+PLATFORM_INTERFACE bool Plat_FastVerifyHardwareKey();
+
+
+
+//-----------------------------------------------------------------------------
+// Include additional dependant header components.
+//-----------------------------------------------------------------------------
+//#include "tier0/fasttimer.h"
+
+
+//-----------------------------------------------------------------------------
+// Just logs file and line to simple.log
+//-----------------------------------------------------------------------------
+void* Plat_SimpleLog(const char* file, int line);
+
+//#define Plat_dynamic_cast Plat_SimpleLog(__FILE__,__LINE__),dynamic_cast
+
+//-----------------------------------------------------------------------------
+// Methods to invoke the constructor, copy constructor, and destructor
+//-----------------------------------------------------------------------------
+
+template <class T>
+inline void Construct(T* pMemory)
+{
+	new(pMemory)T;
+}
+
+template <class T>
+inline void CopyConstruct(T* pMemory, T const& src)
+{
+	new(pMemory)T(src);
+}
+
+template <class T>
+inline void Destruct(T* pMemory)
+{
+	pMemory->~T();
+
+#ifdef _DEBUG
+	memset(pMemory, 0xDD, sizeof(T));
+#endif
+}
+
+
+//
+// GET_OUTER()
+//
+// A platform-independent way for a contained class to get a pointer to its
+// owner. If you know a class is exclusively used in the context of some
+// "outer" class, this is a much more space efficient way to get at the outer
+// class than having the inner class store a pointer to it.
+//
+//	class COuter
+//	{
+//		class CInner // Note: this does not need to be a nested class to work
+//		{
+//			void PrintAddressOfOuter()
+//			{
+//				printf( "Outer is at 0x%x\n", GET_OUTER( COuter, m_Inner ) );
+//			}
+//		};
+//		
+//		CInner m_Inner;
+//		friend class CInner;
+//	};
+
+#define GET_OUTER( OuterType, OuterMember ) \
+   ( ( OuterType * ) ( (char *)this - offsetof( OuterType, OuterMember ) ) )
+
+
+/*	TEMPLATE_FUNCTION_TABLE()
+
+(Note added to platform.h so platforms that correctly support templated
+functions can handle portions as templated functions rather than wrapped
+functions)
+
+Helps automate the process of creating an array of function
+templates that are all specialized by a single integer.
+This sort of thing is often useful in optimization work.
+
+For example, using TEMPLATE_FUNCTION_TABLE, this:
+
+TEMPLATE_FUNCTION_TABLE(int, Function, ( int blah, int blah ), 10)
+{
+return argument * argument;
+}
+
+is equivilent to the following:
+
+(NOTE: the function has to be wrapped in a class due to code
+generation bugs involved with directly specializing a function
+based on a constant.)
+
+template<int argument>
+class FunctionWrapper
+{
+public:
+int Function( int blah, int blah )
+{
+return argument*argument;
+}
+}
+
+typedef int (*FunctionType)( int blah, int blah );
+
+class FunctionName
+{
+public:
+enum { count = 10 };
+FunctionType functions[10];
+};
+
+FunctionType FunctionName::functions[] =
+{
+FunctionWrapper<0>::Function,
+FunctionWrapper<1>::Function,
+FunctionWrapper<2>::Function,
+FunctionWrapper<3>::Function,
+FunctionWrapper<4>::Function,
+FunctionWrapper<5>::Function,
+FunctionWrapper<6>::Function,
+FunctionWrapper<7>::Function,
+FunctionWrapper<8>::Function,
+FunctionWrapper<9>::Function
+};
+*/
+
+bool vtune(bool resume);
+
+
+#define TEMPLATE_FUNCTION_TABLE(RETURN_TYPE, NAME, ARGS, COUNT)			\
+																		\
+typedef RETURN_TYPE (FASTCALL *__Type_##NAME) ARGS;						\
+																		\
+template<const int nArgument>											\
+struct __Function_##NAME												\
+{																		\
+	static RETURN_TYPE FASTCALL Run ARGS;								\
+};																		\
+																		\
+template <int i>														\
+struct __MetaLooper_##NAME : __MetaLooper_##NAME<i-1>					\
+{																		\
+	__Type_##NAME func;													\
+	inline __MetaLooper_##NAME() { func = __Function_##NAME<i>::Run; }	\
+};																		\
+																		\
+template<>																\
+struct __MetaLooper_##NAME<0>											\
+{																		\
+	__Type_##NAME func;													\
+	inline __MetaLooper_##NAME() { func = __Function_##NAME<0>::Run; }	\
+};																		\
+																		\
+class NAME																\
+{																		\
+private:																\
+    static const __MetaLooper_##NAME<COUNT> m;							\
+public:																	\
+	enum { count = COUNT };												\
+	static const __Type_##NAME* functions;								\
+};																		\
+const __MetaLooper_##NAME<COUNT> NAME::m;								\
+const __Type_##NAME* NAME::functions = (__Type_##NAME*)&m;				\
+template<int nArgument>													\
+RETURN_TYPE FASTCALL __Function_##NAME<nArgument>::Run ARGS						
+
+
+#define LOOP_INTERCHANGE(BOOLEAN, CODE)\
+	if( (BOOLEAN) )\
+		{\
+		CODE;\
+		} else\
+	{\
+		CODE;\
+	}
+
+
+#endif /* PLATFORM_H */

reapi/include/cssdk/public/utlmemory.h

@@ -34,6 +34,7 @@
 #endif
 
 #include "osconfig.h"
+#include "tier0/dbg.h"
 #include <string.h>
 
 #pragma warning (disable:4100)

reapi/src/natives/natives_helper.h

@@ -2,6 +2,7 @@
 
 #define CHECK_ISPLAYER(x)	if (params[x] <= 0 || params[x] > gpGlobals->maxClients) { MF_LogError(amx, AMX_ERR_NATIVE, "%s: invalid player index %i [%s]", __FUNCTION__, params[x], #x); return FALSE; }
 #define CHECK_ISENTITY(x)	if (params[x] > gpGlobals->maxEntities) { MF_LogError(amx, AMX_ERR_NATIVE, "%s: invalid entity index %i [%s]", __FUNCTION__, params[x], #x); return FALSE; }
+#define CHECK_GAMERULES()	if (!g_pGameRules) { MF_LogError(amx, AMX_ERR_NATIVE, "%s: gamerules not initialized", __FUNCTION__); return FALSE; }
 
 class CAmxArg
 {

reapi/src/natives/natives_members.cpp

@@ -91,18 +91,15 @@ cell AMX_NATIVE_CALL get_member(AMX *amx, cell *params)
 cell AMX_NATIVE_CALL set_member_game(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_member, arg_value, arg_elem };
-	member_t *member = memberlist[params[arg_member]];
 
+	CHECK_GAMERULES();
+
+	member_t *member = memberlist[params[arg_member]];
 	if (member == nullptr) {
 		MF_LogError(amx, AMX_ERR_NATIVE, "%s: unknown member id %i", __FUNCTION__, params[arg_member]);
 		return FALSE;
 	}
 
-	if (g_pGameRules == nullptr) {
-		MF_LogError(amx, AMX_ERR_NATIVE, "%s: gamerules not initialized", __FUNCTION__);
-		return FALSE;
-	}
-
 	cell* value = getAmxAddr(amx, params[arg_value]);
 	size_t element = (PARAMS_COUNT == 4) ? *getAmxAddr(amx, params[arg_elem]) : 0;
 
@@ -113,18 +110,15 @@ cell AMX_NATIVE_CALL set_member_game(AMX *amx, cell *params)
 cell AMX_NATIVE_CALL get_member_game(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_member, arg_3, arg_4 };
-	member_t *member = memberlist[params[arg_member]];
 
+	CHECK_GAMERULES();
+
+	member_t *member = memberlist[params[arg_member]];
 	if (member == nullptr) {
 		MF_LogError(amx, AMX_ERR_NATIVE, "%s: unknown member id %i", __FUNCTION__, params[arg_member]);
 		return FALSE;
 	}
 
-	if (g_pGameRules == nullptr) {
-		MF_LogError(amx, AMX_ERR_NATIVE, "%s: gamerules not initialized", __FUNCTION__);
-		return FALSE;
-	}
-
 	cell* dest;
 	size_t element;
 

reapi/src/natives/natives_misc.cpp

@@ -90,27 +90,29 @@ cell AMX_NATIVE_CALL rg_give_item(AMX *amx, cell *params)
 	if (type > GT_APPEND) {
 
 		auto pInfo = g_ReGameApi->GetWeaponSlot(itemName);
-		auto pItem = pPlayer->m_rgpPlayerItems[ pInfo->slot ];
+		if (pInfo != nullptr)
+		{
+			auto pItem = pPlayer->m_rgpPlayerItems[ pInfo->slot ];
+			while (pItem != nullptr) {
+				if (pItem->m_iId == pInfo->id) {
+					pItem = pItem->m_pNext;
+					continue;
+				}
+
+				switch (type)
+				{
+				case GT_DROP_AND_REPLACE:
+					pPlayer->CSPlayer()->DropPlayerItem(STRING(pItem->pev->classname));
+					break;
+				case GT_REPLACE:
+					pPlayer->pev->weapons &= ~(1 << pItem->m_iId);
+					pPlayer->RemovePlayerItem(pItem);
+					pItem->Kill();
+					break;
+				}
 
-		while (pItem != nullptr) {
-			if (pItem->m_iId == pInfo->id) {
 				pItem = pItem->m_pNext;
-				continue;
 			}
-
-			switch (type)
-			{
-			case GT_DROP_AND_REPLACE:
-				pPlayer->CSPlayer()->DropPlayerItem(STRING(pItem->pev->classname));
-				break;
-			case GT_REPLACE:
-				pPlayer->pev->weapons &= ~(1 << pItem->m_iId);
-				pPlayer->RemovePlayerItem(pItem);
-				pItem->Kill();
-				break;
-			}
-
-			pItem = pItem->m_pNext;
 		}
 	}
 
@@ -397,6 +399,8 @@ cell AMX_NATIVE_CALL rg_round_end(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_delay, arg_win, arg_event, arg_message, arg_sentence, arg_silent };
 
+	CHECK_GAMERULES();
+
 	size_t winstatus = params[arg_win];
 	if (winstatus <= 0) {
 		MF_LogError(amx, AMX_ERR_NATIVE, "%s: unknown win status %i", __FUNCTION__, winstatus);
@@ -442,6 +446,8 @@ cell AMX_NATIVE_CALL rg_update_teamscores(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_cts, arg_ts, arg_add };
 
+	CHECK_GAMERULES();
+
 	CSGameRules()->m_iNumCTWins = ((params[arg_add] != 0) ? CSGameRules()->m_iNumCTWins : 0) + params[arg_cts];
 	CSGameRules()->m_iNumTerroristWins = ((params[arg_add] != 0) ? CSGameRules()->m_iNumTerroristWins : 0) + params[arg_ts];
 	CSGameRules()->UpdateTeamScores();
@@ -529,7 +535,7 @@ cell AMX_NATIVE_CALL rg_find_ent_by_owner(AMX *amx, cell *params)
 		if (!pEntity->pvPrivateData || pEntity->free)
 			continue;
 
-		if (!strcmp(STRING(pEntity->v.classname), value))
+		if (FClassnameIs(pEntity, value))
 		{
 			startIndex = i;
 			return TRUE;
@@ -540,16 +546,67 @@ cell AMX_NATIVE_CALL rg_find_ent_by_owner(AMX *amx, cell *params)
 }
 
 /*
-* Find the item by name in the player's inventory.
+* Find the weapon by name in the player's inventory.
+*
+* @param index			Client index
+* @param weapon			Weapon name
+*
+* @return			Entity-index of weapon, 0 otherwise
+*
+* native rg_find_weapon_bpack_by_name(const index, const weapon[]);
+*/
+cell AMX_NATIVE_CALL rg_find_weapon_bpack_by_name(AMX *amx, cell *params)
+{
+	enum args_e { arg_count, arg_index, arg_weapon };
+
+	CHECK_ISPLAYER(arg_index);
+
+	CBasePlayer *pPlayer = g_ReGameFuncs->UTIL_PlayerByIndex(params[arg_index]);
+	if (pPlayer == nullptr || pPlayer->has_disconnected) {
+		MF_LogError(amx, AMX_ERR_NATIVE, "%s: player %i is not connected", __FUNCTION__, params[arg_index]);
+		return FALSE;
+	}
+
+	const char *pszWeaponName = getAmxString(amx, params[arg_weapon]);
+	auto pInfo = g_ReGameApi->GetWeaponSlot(pszWeaponName);
+	if (pInfo != nullptr)
+	{
+		auto pItem = pPlayer->m_rgpPlayerItems[ pInfo->slot ];
+		while (pItem)
+		{
+			if (FClassnameIs(pItem->pev, pszWeaponName)) {
+				return indexOfEdict(pItem->pev);
+			}
+
+			pItem = pItem->m_pNext;
+		}
+	}
+
+	return FALSE;
+}
+
+struct {
+	const char* pszItemName;
+	bool(*hasItem)(CBasePlayer* pl);
+} itemInfoStruct[] = {
+	{ "item_thighpack",		[](CBasePlayer* pl) -> bool { return pl->m_bHasDefuser; } },
+	{ "item_longjump",		[](CBasePlayer* pl) -> bool { return pl->m_fLongJump == TRUE; } },
+	{ "item_assaultsuit",		[](CBasePlayer* pl) -> bool { return pl->m_iKevlar == ARMOR_VESTHELM; } },
+	{ "item_kevlar",		[](CBasePlayer* pl) -> bool { return pl->m_iKevlar == ARMOR_KEVLAR; } },
+	{ "weapon_shield",		[](CBasePlayer* pl) -> bool { return pl->m_bOwnsShield; } },
+};
+
+/*
+* Check if the player already have this item.
 *
 * @param index			Client index
 * @param item			Item name
 *
-* @return			Entity-index of item, 0 otherwise
+* @return			1 if successfully, 0 otherwise
 *
-* native rg_find_item_bpack_by_name(const index, const item[]);
+* native bool:rg_has_item_by_name(const index, const item[]);
 */
-cell AMX_NATIVE_CALL rg_find_item_bpack_by_name(AMX *amx, cell *params)
+cell AMX_NATIVE_CALL rg_has_item_by_name(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_index, arg_item };
 
@@ -561,22 +618,30 @@ cell AMX_NATIVE_CALL rg_find_item_bpack_by_name(AMX *amx, cell *params)
 		return FALSE;
 	}
 
-	const char *itemName = getAmxString(amx, params[arg_item]);
+	const char *pszItemName = getAmxString(amx, params[arg_item]);
-	auto pInfo = g_ReGameApi->GetWeaponSlot(itemName);
+	// item_* and weapon_shield
-	if (pInfo == nullptr) {
+	for (auto& inf : itemInfoStruct) {
-		return 0;
+		if (FStrEq(inf.pszItemName, pszItemName)) {
-	}
+			return (cell)inf.hasItem(pPlayer);
-
-	auto pItem = pPlayer->m_rgpPlayerItems[ pInfo->slot ];
-	while (pItem) {
-		if (FClassnameIs(pItem->pev, itemName)) {
-			return indexOfEdict(pItem->pev);
 		}
-
-		pItem = pItem->m_pNext;
 	}
 
-	return 0;
+	// weapon_*
+	auto pInfo = g_ReGameApi->GetWeaponSlot(pszItemName);
+	if (pInfo != nullptr)
+	{
+		auto pItem = pPlayer->m_rgpPlayerItems[ pInfo->slot ];
+		while (pItem)
+		{
+			if (FClassnameIs(pItem->pev, pszItemName)) {
+				return TRUE;
+			}
+
+			pItem = pItem->m_pNext;
+		}
+	}
+
+	return FALSE;
 }
 
 /*
@@ -884,6 +949,7 @@ cell AMX_NATIVE_CALL rg_give_defusekit(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_index, arg_def, arg_color, arg_icon, arg_flash };
 
+	CHECK_GAMERULES();
 	CHECK_ISPLAYER(arg_index);
 
 	CBasePlayer *pPlayer = g_ReGameFuncs->UTIL_PlayerByIndex(params[arg_index]);
@@ -1006,6 +1072,7 @@ cell AMX_NATIVE_CALL rg_set_user_team(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_index, arg_team, arg_model, arg_sendinfo };
 
+	CHECK_GAMERULES();
 	CHECK_ISPLAYER(arg_index);
 
 	CBasePlayer *pPlayer = g_ReGameFuncs->UTIL_PlayerByIndex(params[arg_index]);
@@ -1164,6 +1231,7 @@ cell AMX_NATIVE_CALL rg_transfer_c4(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_index, arg_receiver };
 
+	CHECK_GAMERULES();
 	CHECK_ISPLAYER(arg_index);
 
 	CBasePlayer *pPlayer = g_ReGameFuncs->UTIL_PlayerByIndex(params[arg_index]);
@@ -1251,10 +1319,7 @@ cell AMX_NATIVE_CALL rg_set_account_rules(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_rules_index, arg_amount };
 
-	if (g_pGameRules == nullptr) {
+	CHECK_GAMERULES();
-		MF_LogError(amx, AMX_ERR_NATIVE, "%s: gamerules not initialized", __FUNCTION__);
-		return FALSE;
-	}
 
 	CSGameRules()->SetAccountRules(static_cast<RewardRules>(params[arg_rules_index]), params[arg_amount]);
 	return TRUE;
@@ -1273,10 +1338,7 @@ cell AMX_NATIVE_CALL rg_get_account_rules(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_rules_index };
 
-	if (g_pGameRules == nullptr) {
+	CHECK_GAMERULES();
-		MF_LogError(amx, AMX_ERR_NATIVE, "%s: gamerules not initialized", __FUNCTION__);
-		return FALSE;
-	}
 
 	return (cell)CSGameRules()->GetAccountRules(static_cast<RewardRules>(params[arg_rules_index]));
 }
@@ -1290,10 +1352,7 @@ cell AMX_NATIVE_CALL rg_get_account_rules(AMX *amx, cell *params)
 */
 cell AMX_NATIVE_CALL rg_is_bomb_planted(AMX *amx, cell *params)
 {
-	if (g_pGameRules == nullptr) {
+	CHECK_GAMERULES();
-		MF_LogError(amx, AMX_ERR_NATIVE, "%s: gamerules not initialized", __FUNCTION__);
-		return FALSE;
-	}
 
 	return (cell)CSGameRules()->IsBombPlanted();
 }
@@ -1332,10 +1391,7 @@ cell AMX_NATIVE_CALL rg_join_team(AMX *amx, cell *params)
 */
 cell AMX_NATIVE_CALL rg_balance_teams(AMX *amx, cell *params)
 {
-	if (g_pGameRules == nullptr) {
+	CHECK_GAMERULES();
-		MF_LogError(amx, AMX_ERR_NATIVE, "%s: gamerules not initialized", __FUNCTION__);
-		return FALSE;
-	}
 
 	CSGameRules()->BalanceTeams();
 	return TRUE;
@@ -1350,10 +1406,7 @@ cell AMX_NATIVE_CALL rg_balance_teams(AMX *amx, cell *params)
 */
 cell AMX_NATIVE_CALL rg_swap_all_players(AMX *amx, cell *params)
 {
-	if (g_pGameRules == nullptr) {
+	CHECK_GAMERULES();
-		MF_LogError(amx, AMX_ERR_NATIVE, "%s: gamerules not initialized", __FUNCTION__);
-		return FALSE;
-	}
 
 	CSGameRules()->SwapAllPlayers();
 	return TRUE;
@@ -1425,10 +1478,7 @@ cell AMX_NATIVE_CALL rg_switch_weapon(AMX *amx, cell *params)
 */
 cell AMX_NATIVE_CALL rg_get_join_team_priority(AMX *amx, cell *params)
 {
-	if (g_pGameRules == nullptr) {
+	CHECK_GAMERULES();
-		MF_LogError(amx, AMX_ERR_NATIVE, "%s: gamerules not initialized", __FUNCTION__);
-		return FALSE;
-	}
 
 	return CSGameRules()->SelectDefaultTeam();
 }
@@ -1447,6 +1497,7 @@ cell AMX_NATIVE_CALL rg_is_player_can_takedamage(AMX *amx, cell *params)
 {
 	enum args_e { arg_count, arg_index, arg_attacker };
 
+	CHECK_GAMERULES();
 	CHECK_ISPLAYER(arg_index);
 
 	CBasePlayer *pPlayer = g_ReGameFuncs->UTIL_PlayerByIndex(params[arg_index]);
@@ -1516,7 +1567,8 @@ AMX_NATIVE_INFO Misc_Natives_RG[] =
 	{ "rg_create_entity", rg_create_entity },
 	{ "rg_find_ent_by_class", rg_find_ent_by_class },
 	{ "rg_find_ent_by_owner", rg_find_ent_by_owner },
-	{ "rg_find_item_bpack_by_name", rg_find_item_bpack_by_name },
+	{ "rg_find_weapon_bpack_by_name", rg_find_weapon_bpack_by_name },
+	{ "rg_has_item_by_name", rg_has_item_by_name },
 
 	{ "rg_get_weapon_info", rg_get_weapon_info },
 	{ "rg_set_weapon_info", rg_set_weapon_info },
@@ -1762,7 +1814,7 @@ void RegisterNatives_Misc()
 {
 	if (!api_cfg.hasReGameDLL())
 		fillNatives(Misc_Natives_RG, [](AMX *amx, cell *params) -> cell { MF_LogError(amx, AMX_ERR_NATIVE, "%s: isn't available", "ReGameDll"); return FALSE; });
-		
+
 	if (!api_cfg.hasReHLDS())
 		fillNatives(Misc_Natives_RH, [](AMX *amx, cell *params) -> cell { MF_LogError(amx, AMX_ERR_NATIVE, "%s: isn't available", "ReHlds"); return FALSE; });
 

reapi/src/precompiled.h

@@ -9,6 +9,9 @@
 
 #include <vector>				// std::vector
 
+#include "basetypes.h"
+#include "asmlib.h"
+
 #include <extdll.h>
 #include <cbase.h>
 #include <pm_defs.h>

reapi/src/reapi_version.inc

@@ -5,4 +5,4 @@
 
 // reapi version
 #define REAPI_VERSION_MAJOR 4
-#define REAPI_VERSION_MINOR 2
+#define REAPI_VERSION_MINOR 3