WIP: a new batch of reverse functions

regamedll/build.gradle

@@ -188,7 +188,7 @@ class RegamedllSrc {
         h.regamedll_src(CppSourceSet) {
 
             source {
-		srcDirs "dlls", "game_shared", "pm_shared", "regamedll", "public", "version"
+		srcDirs "engine", "dlls", "game_shared", "pm_shared", "regamedll", "public", "version"
                 if (GradleCppUtils.windows) {
 			srcDirs "testsuite"
 		}

regamedll/common/mathlib.h

@@ -32,6 +32,19 @@
 #pragma once
 #endif
 
+#ifdef HOOK_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 // HOOK_GAMEDLL
+
+typedef float float_precision;
+
+#endif // HOOK_GAMEDLL
+
 /* <42b7f> ../common/mathlib.h:3 */
 typedef float vec_t;
 
@@ -54,12 +67,20 @@ typedef union DLONG_u
 
 #define M_PI			3.14159265358979323846
 
-#ifndef max
+//#ifndef max
-#define max(a,b) (((a) > (b)) ? (a) : (b))
+//#define max(a,b) (((a) > (b)) ? (a) : (b))
+//#endif
+//
+//#ifndef min
+//#define min(a,b) (((a) < (b)) ? (a) : (b))
+//#endif
+
+#ifndef _max
+#define _max(a,b) (((a) > (b)) ? (a) : (b))
 #endif
 
-#ifndef min
+#ifndef _min
-#define min(a,b) (((a) < (b)) ? (a) : (b))
+#define _min(a,b) (((a) < (b)) ? (a) : (b))
 #endif
 
 #define clamp(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))

regamedll/dlls/activity.h

@@ -140,13 +140,16 @@ typedef enum
 	ACT_WAVE,
 	ACT_YES,
 	ACT_NO,
+
 } Activity;
 
 typedef struct
 {
 	int type;
 	char *name;
+
 } activity_map_t;
+/* size: 8, cachelines: 1, members: 2 */
 
 extern activity_map_t activity_map[];
 

regamedll/dlls/airtank.cpp

@@ -16,12 +16,6 @@ TYPEDESCRIPTION (*CAirtank::pm_SaveData)[1];
 
 #endif // HOOK_GAMEDLL
 
-/* <4fc9> ../cstrike/dlls/airtank.cpp:29 */
-int CAirtank::BloodColor_(void)
-{
-	return DONT_BLEED;
-}
-
 /* <5329> ../cstrike/dlls/airtank.cpp:41 */
 LINK_ENTITY_TO_CLASS(item_airtank, CAirtank);
 
@@ -29,48 +23,77 @@ LINK_ENTITY_TO_CLASS(item_airtank, CAirtank);
 IMPLEMENT_SAVERESTORE(CAirtank, CGrenade);
 
 /* <50dd> ../cstrike/dlls/airtank.cpp:50 */
-void CAirtank::Spawn_(void)
+void CAirtank::__MAKE_VHOOK(Spawn)(void)
 {
-//	Vector(Vector::Spawn(//		float X,
+	Precache();
-//		float Y,
+
-//		float Z);  //    58
+	// motor
-//	Vector(Vector *const this,
+	pev->movetype = MOVETYPE_FLY;
-//		float X,
+	pev->solid = SOLID_BBOX;
-//		float Y,
+
-//		float Z);  //    58
+	SET_MODEL(ENT(pev), "models/w_oxygen.mdl");
+	UTIL_SetSize(pev, Vector(-16, -16, 0), Vector(16, 16, 36));
+	UTIL_SetOrigin(pev, pev->origin);
+
+	SetTouch(&CAirtank::TankTouch);
+	SetThink(&CAirtank::TankThink);
+
+	pev->flags |= FL_MONSTER;
+	pev->takedamage = DAMAGE_YES;
+	pev->health = 20;
+	pev->dmg = 50;
+	m_state = 1;
 }
 
 /* <4fef> ../cstrike/dlls/airtank.cpp:71 */
-void CAirtank::Precache_(void)
+void CAirtank::__MAKE_VHOOK(Precache)(void)
 {
+	PRECACHE_MODEL("models/w_oxygen.mdl");
+	PRECACHE_SOUND("doors/aliendoor3.wav");
 }
 
 /* <503d> ../cstrike/dlls/airtank.cpp:78 */
-void CAirtank::Killed_(entvars_t *pevAttacker, int iGib)
+void CAirtank::__MAKE_VHOOK(Killed)(entvars_t *pevAttacker, int iGib)
-{
+{
-//	Vector(Vector *const this,
+	pev->owner = ENT(pevAttacker);
-//		float X,
+
-//		float Y,
+	// UNDONE: this should make a big bubble cloud, not an explosion
-//		float Z);  //    84
+	Explode(pev->origin, Vector(0, 0, -1));
-//	Vector(Vector *const this,
-//		const Vector &v);  //    84
 }
 
 /* <5016> ../cstrike/dlls/airtank.cpp:88 */
 void CAirtank::TankThink(void)
 {
+	// Fire trigger
+	m_state = 1;
+	SUB_UseTargets(this, USE_TOGGLE, 0);
 }
 
 /* <525d> ../cstrike/dlls/airtank.cpp:96 */
 void CAirtank::TankTouch(CBaseEntity *pOther)
 {
-//	TankTouch(CAirtank *const this,
+	if (!pOther->IsPlayer())
-//			class CBaseEntity *pOther);  //    96
+	{
-//	EMIT_SOUND(edict_t *entity,
+		return;
-//			int channel,
+	}
-//			const char *sample,
+
-//			float volume,
+	if (!m_state)
-//			float attenuation);  //   104
+	{
+		// "no oxygen" sound
+		EMIT_SOUND(ENT(pev), CHAN_BODY, "player/pl_swim2.wav", VOL_NORM, ATTN_NORM);
+		return;
+	}
+
+	// give player 12 more seconds of air
+	pOther->pev->air_finished = gpGlobals->time + 12;
+
+	// suit recharge sound
+	EMIT_SOUND(ENT(pev), CHAN_VOICE, "doors/aliendoor3.wav", VOL_NORM, ATTN_NORM);
+
+	// recharge airtank in 30 seconds
+	pev->nextthink = gpGlobals->time + 30;
+	m_state = 0;
+	SUB_UseTargets(this, USE_TOGGLE, 1);
 }
 
 #ifdef HOOK_GAMEDLL
@@ -98,11 +121,6 @@ int CAirtank::Restore(CRestore &restore)
 void CAirtank::Killed(entvars_t *pevAttacker, int iGib)
 {
 	Killed_(pevAttacker, iGib);
-}
-
-int CAirtank::BloodColor(void)
-{
-	return BloodColor_();
 }
 
 #endif // HOOK_GAMEDLL

regamedll/dlls/airtank.h

@@ -42,19 +42,25 @@ public:
 	virtual int Save(CSave &save);
 	virtual int Restore(CRestore &restore);
 	virtual void Killed(entvars_t *pevAttacker, int iGib);
-	virtual int BloodColor(void);
+	virtual int BloodColor(void)
+	{
+		return BloodColor_();
+	}
 public:
 	void EXPORT TankThink(void);
 	void EXPORT TankTouch(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
 
-	NOBODY void Spawn_(void);
+	void Spawn_(void);
-	NOBODY void Precache_(void);
+	void Precache_(void);
-	NOBODY int Save_(CSave &save);
+	int Save_(CSave &save);
-	NOBODY int Restore_(CRestore &restore);
+	int Restore_(CRestore &restore);
-	NOBODY void Killed_(entvars_t *pevAttacker, int iGib);
+	void Killed_(entvars_t *pevAttacker, int iGib);
-	NOBODY int BloodColor_(void);
+	int BloodColor_(void)
+	{
+		return DONT_BLEED;
+	}
 
 #endif // HOOK_GAMEDLL
 
@@ -66,6 +72,6 @@ private:
 
 };
 
-//NOBODY void item_airtank(entvars_t *pev);
+C_DLLEXPORT void item_airtank(entvars_t *pev);
 
 #endif // AIRTANK_H

regamedll/dlls/ammo.cpp

@@ -1,217 +1,307 @@
 #include "precompiled.h"
 
-/* <a6c7> ../cstrike/dlls/ammo.cpp:16 */
+/* <a6c7> ../cstrike/dlls/ammo.cpp:16 */
-void C9MMAmmo::Spawn_(void)
+void C9MMAmmo::__MAKE_VHOOK(Spawn)(void)
-{
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
+	CBasePlayerAmmo::Spawn();
 }
 
-/* <a3e2> ../cstrike/dlls/ammo.cpp:22 */
+/* <a3e2> ../cstrike/dlls/ammo.cpp:22 */
-void C9MMAmmo::Precache_(void)
+void C9MMAmmo::__MAKE_VHOOK(Precache)(void)
-{
+{
+	PRECACHE_MODEL("models/w_9mmclip.mdl");
+	PRECACHE_SOUND("items/9mmclip1.wav");
 }
 
-/* <a861> ../cstrike/dlls/ammo.cpp:27 */
+/* <a861> ../cstrike/dlls/ammo.cpp:27 */
-BOOL C9MMAmmo::AddAmmo_(CBaseEntity *pOther)
+BOOL C9MMAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
-{
+{
-//	AddAmmo(C9MMAmmo *const this,
+	if (pOther->GiveAmmo(AMMO_9MM_BUY, "9mm", MAX_AMMO_9MM) == -1)
-//		class CBaseEntity *pOther);  //    27
+	{
-	return FALSE;
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
 }
 
-/* <ace9> ../cstrike/dlls/ammo.cpp:37 */
+/* <ace9> ../cstrike/dlls/ammo.cpp:37 */
-LINK_ENTITY_TO_CLASS(ammo_9mm, C9MMAmmo);
+LINK_ENTITY_TO_CLASS(ammo_9mm, C9MMAmmo);
 
-/* <a6a0> ../cstrike/dlls/ammo.cpp:42 */
+/* <a6a0> ../cstrike/dlls/ammo.cpp:42 */
-void CBuckShotAmmo::Spawn_(void)
+void CBuckShotAmmo::__MAKE_VHOOK(Spawn)(void)
-{
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_shotbox.mdl");
+	CBasePlayerAmmo::Spawn();
 }
 
-/* <a409> ../cstrike/dlls/ammo.cpp:48 */
+/* <a409> ../cstrike/dlls/ammo.cpp:48 */
-void CBuckShotAmmo::Precache_(void)
+void CBuckShotAmmo::__MAKE_VHOOK(Precache)(void)
-{
+{
-}
+	PRECACHE_MODEL("models/w_shotbox.mdl");
-
+	PRECACHE_SOUND("items/9mmclip1.wav");
-/* <a7d0> ../cstrike/dlls/ammo.cpp:53 */
-BOOL CBuckShotAmmo::AddAmmo_(CBaseEntity *pOther)
-{
-//	AddAmmo(CBuckShotAmmo *const this,
-//		class CBaseEntity *pOther);  //    53
-	return FALSE;
-}
-
-/* <adb3> ../cstrike/dlls/ammo.cpp:63 */
-LINK_ENTITY_TO_CLASS(ammo_buckshot, CBuckShotAmmo);
-
-/* <a679> ../cstrike/dlls/ammo.cpp:69 */
-void C556NatoAmmo::Spawn_(void)
-{
-}
-
-/* <a430> ../cstrike/dlls/ammo.cpp:75 */
-void C556NatoAmmo::Precache_(void)
-{
 }
 
-/* <a8f2> ../cstrike/dlls/ammo.cpp:80 */
+/* <a7d0> ../cstrike/dlls/ammo.cpp:53 */
-BOOL C556NatoAmmo::AddAmmo_(CBaseEntity *pOther)
+BOOL CBuckShotAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
-{
+{
-//	AddAmmo(C556NatoAmmo *const this,
+	if (pOther->GiveAmmo(AMMO_BUCKSHOT_BUY, "buckshot", MAX_AMMO_BUCKSHOT) == -1)
-//		class CBaseEntity *pOther);  //    80
+	{
-	return FALSE;
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
 }
 
-/* <ae7d> ../cstrike/dlls/ammo.cpp:90 */
+/* <adb3> ../cstrike/dlls/ammo.cpp:63 */
+LINK_ENTITY_TO_CLASS(ammo_buckshot, CBuckShotAmmo);
+
+/* <a679> ../cstrike/dlls/ammo.cpp:69 */
+void C556NatoAmmo::__MAKE_VHOOK(Spawn)(void)
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
+	CBasePlayerAmmo::Spawn();
+}
+
+/* <a430> ../cstrike/dlls/ammo.cpp:75 */
+void C556NatoAmmo::__MAKE_VHOOK(Precache)(void)
+{
+	PRECACHE_MODEL("models/w_9mmclip.mdl");
+	PRECACHE_SOUND("items/9mmclip1.wav");
+}
+
+/* <a8f2> ../cstrike/dlls/ammo.cpp:80 */
+BOOL C556NatoAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
+{
+	if (pOther->GiveAmmo(AMMO_556NATO_BUY, "556Nato", MAX_AMMO_556NATO) == -1)
+	{
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
+}
+
+/* <ae7d> ../cstrike/dlls/ammo.cpp:90 */
 LINK_ENTITY_TO_CLASS(ammo_556nato, C556NatoAmmo);
 
-/* <a652> ../cstrike/dlls/ammo.cpp:95 */
+/* <a652> ../cstrike/dlls/ammo.cpp:95 */
-void C556NatoBoxAmmo::Spawn_(void)
+void C556NatoBoxAmmo::__MAKE_VHOOK(Spawn)(void)
-{
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
+	CBasePlayerAmmo::Spawn();
 }
 
-/* <a457> ../cstrike/dlls/ammo.cpp:101 */
+/* <a457> ../cstrike/dlls/ammo.cpp:101 */
-void C556NatoBoxAmmo::Precache_(void)
+void C556NatoBoxAmmo::__MAKE_VHOOK(Precache)(void)
-{
+{
+	PRECACHE_MODEL("models/w_9mmclip.mdl");
+	PRECACHE_SOUND("items/9mmclip1.wav");
 }
 
-/* <a983> ../cstrike/dlls/ammo.cpp:106 */
+/* <a983> ../cstrike/dlls/ammo.cpp:106 */
-BOOL C556NatoBoxAmmo::AddAmmo_(CBaseEntity *pOther)
+BOOL C556NatoBoxAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
-{
+{
-//	AddAmmo(C556NatoBoxAmmo *const this,
+	if (pOther->GiveAmmo(AMMO_556NATOBOX_BUY, "556NatoBox", MAX_AMMO_556NATOBOX) == -1)
-//		class CBaseEntity *pOther);  //   106
+	{
-	return FALSE;
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
 }
 
-/* <af47> ../cstrike/dlls/ammo.cpp:116 */
+/* <af47> ../cstrike/dlls/ammo.cpp:116 */
-LINK_ENTITY_TO_CLASS(ammo_556natobox, C556NatoBoxAmmo);
+LINK_ENTITY_TO_CLASS(ammo_556natobox, C556NatoBoxAmmo);
-
+
-/* <a62b> ../cstrike/dlls/ammo.cpp:121 */
+/* <a62b> ../cstrike/dlls/ammo.cpp:121 */
-void C762NatoAmmo::Spawn_(void)
+void C762NatoAmmo::__MAKE_VHOOK(Spawn)(void)
-{
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
+	CBasePlayerAmmo::Spawn();
 }
 
-/* <a47e> ../cstrike/dlls/ammo.cpp:127 */
+/* <a47e> ../cstrike/dlls/ammo.cpp:127 */
-void C762NatoAmmo::Precache_(void)
+void C762NatoAmmo::__MAKE_VHOOK(Precache)(void)
-{
+{
+	PRECACHE_MODEL("models/w_9mmclip.mdl");
+	PRECACHE_SOUND("items/9mmclip1.wav");
 }
 
-/* <aa14> ../cstrike/dlls/ammo.cpp:132 */
+/* <aa14> ../cstrike/dlls/ammo.cpp:132 */
-BOOL C762NatoAmmo::AddAmmo_(CBaseEntity *pOther)
+BOOL C762NatoAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
-{
+{
-//	AddAmmo(C762NatoAmmo *const this,
+	if (pOther->GiveAmmo(AMMO_762NATO_BUY, "762Nato", MAX_AMMO_762NATO) == -1)
-//		class CBaseEntity *pOther);  //   132
+	{
-	return FALSE;
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
 }
 
-/* <b011> ../cstrike/dlls/ammo.cpp:142 */
+/* <b011> ../cstrike/dlls/ammo.cpp:142 */
-LINK_ENTITY_TO_CLASS(ammo_762nato, C762NatoAmmo);
+LINK_ENTITY_TO_CLASS(ammo_762nato, C762NatoAmmo);
 
-/* <a604> ../cstrike/dlls/ammo.cpp:147 */
+/* <a604> ../cstrike/dlls/ammo.cpp:147 */
-void C45ACPAmmo::Spawn_(void)
+void C45ACPAmmo::__MAKE_VHOOK(Spawn)(void)
-{
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
+	CBasePlayerAmmo::Spawn();
 }
 
-/* <a4a5> ../cstrike/dlls/ammo.cpp:153 */
+/* <a4a5> ../cstrike/dlls/ammo.cpp:153 */
-void C45ACPAmmo::Precache_(void)
+void C45ACPAmmo::__MAKE_VHOOK(Precache)(void)
-{
+{
+	PRECACHE_MODEL("models/w_9mmclip.mdl");
+	PRECACHE_SOUND("items/9mmclip1.wav");
 }
 
-/* <aaa5> ../cstrike/dlls/ammo.cpp:158 */
+/* <aaa5> ../cstrike/dlls/ammo.cpp:158 */
-BOOL C45ACPAmmo::AddAmmo_(CBaseEntity *pOther)
+BOOL C45ACPAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
-{
+{
-//	AddAmmo(C45ACPAmmo *const this,
+	if (pOther->GiveAmmo(AMMO_45ACP_BUY, "45acp", MAX_AMMO_45ACP) == -1)
-//		class CBaseEntity *pOther);  //   158
+	{
-	return FALSE;
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
 }
 
-/* <b0db> ../cstrike/dlls/ammo.cpp:168 */
+/* <b0db> ../cstrike/dlls/ammo.cpp:168 */
 LINK_ENTITY_TO_CLASS(ammo_45acp, C45ACPAmmo);
 
-/* <a5dd> ../cstrike/dlls/ammo.cpp:173 */
+/* <a5dd> ../cstrike/dlls/ammo.cpp:173 */
-void C50AEAmmo::Spawn_(void)
+void C50AEAmmo::__MAKE_VHOOK(Spawn)(void)
-{
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
+	CBasePlayerAmmo::Spawn();
 }
 
-/* <a4cc> ../cstrike/dlls/ammo.cpp:179 */
+/* <a4cc> ../cstrike/dlls/ammo.cpp:179 */
-void C50AEAmmo::Precache_(void)
+void C50AEAmmo::__MAKE_VHOOK(Precache)(void)
-{
+{
+	PRECACHE_MODEL("models/w_9mmclip.mdl");
+	PRECACHE_SOUND("items/9mmclip1.wav");
 }
 
-/* <ab36> ../cstrike/dlls/ammo.cpp:184 */
+/* <ab36> ../cstrike/dlls/ammo.cpp:184 */
-BOOL C50AEAmmo::AddAmmo_(CBaseEntity *pOther)
+BOOL C50AEAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
-{
+{
-//	AddAmmo(C50AEAmmo *const this,
+	if (pOther->GiveAmmo(AMMO_50AE_BUY, "50AE", MAX_AMMO_50AE) == -1)
-//		class CBaseEntity *pOther);  //   184
+	{
-	return FALSE;
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
 }
 
 /* <b1a5> ../cstrike/dlls/ammo.cpp:194 */
 LINK_ENTITY_TO_CLASS(ammo_50ae, C50AEAmmo);
 
-/* <a5b6> ../cstrike/dlls/ammo.cpp:199 */
+/* <a5b6> ../cstrike/dlls/ammo.cpp:199 */
-void C338MagnumAmmo::Spawn_(void)
+void C338MagnumAmmo::__MAKE_VHOOK(Spawn)(void)
-{
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
+	CBasePlayerAmmo::Spawn();
 }
 
-/* <a4f3> ../cstrike/dlls/ammo.cpp:205 */
+/* <a4f3> ../cstrike/dlls/ammo.cpp:205 */
-void C338MagnumAmmo::Precache_(void)
+void C338MagnumAmmo::__MAKE_VHOOK(Precache)(void)
-{
+{
+	PRECACHE_MODEL("models/w_9mmclip.mdl");
+	PRECACHE_SOUND("items/9mmclip1.wav");
 }
 
-/* <abc7> ../cstrike/dlls/ammo.cpp:210 */
+/* <abc7> ../cstrike/dlls/ammo.cpp:210 */
-BOOL C338MagnumAmmo::AddAmmo_(CBaseEntity *pOther)
+BOOL C338MagnumAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
-{
+{
-//	AddAmmo(C338MagnumAmmo *const this,
+	if (pOther->GiveAmmo(AMMO_338MAG_BUY, "338Magnum", MAX_AMMO_338MAGNUM) == -1)
-//		class CBaseEntity *pOther);  //   210
+	{
-	return FALSE;
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
 }
 
-/* <b26f> ../cstrike/dlls/ammo.cpp:220 */
+/* <b26f> ../cstrike/dlls/ammo.cpp:220 */
 LINK_ENTITY_TO_CLASS(ammo_338magnum, C338MagnumAmmo);
 
-/* <a58f> ../cstrike/dlls/ammo.cpp:226 */
+/* <a58f> ../cstrike/dlls/ammo.cpp:226 */
-void C57MMAmmo::Spawn_(void)
+void C57MMAmmo::__MAKE_VHOOK(Spawn)(void)
-{
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
+	CBasePlayerAmmo::Spawn();
 }
 
-/* <a51a> ../cstrike/dlls/ammo.cpp:232 */
+/* <a51a> ../cstrike/dlls/ammo.cpp:232 */
-void C57MMAmmo::Precache_(void)
+void C57MMAmmo::__MAKE_VHOOK(Precache)(void)
-{
+{
+	PRECACHE_MODEL("models/w_9mmclip.mdl");
+	PRECACHE_SOUND("items/9mmclip1.wav");
 }
 
-/* <ac58> ../cstrike/dlls/ammo.cpp:237 */
+/* <ac58> ../cstrike/dlls/ammo.cpp:237 */
-BOOL C57MMAmmo::AddAmmo_(CBaseEntity *pOther)
+BOOL C57MMAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
-{
+{
-//	AddAmmo(C57MMAmmo *const this,
+	if (pOther->GiveAmmo(AMMO_57MM_BUY, "57mm", MAX_AMMO_57MM) == -1)
-//		class CBaseEntity *pOther);  //   237
+	{
-	return FALSE;
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
 }
 
-/* <b339> ../cstrike/dlls/ammo.cpp:247 */
+/* <b339> ../cstrike/dlls/ammo.cpp:247 */
 LINK_ENTITY_TO_CLASS(ammo_57mm, C57MMAmmo);
 
-/* <a568> ../cstrike/dlls/ammo.cpp:251 */
+/* <a568> ../cstrike/dlls/ammo.cpp:251 */
-void C357SIGAmmo::Spawn_(void)
+void C357SIGAmmo::__MAKE_VHOOK(Spawn)(void)
-{
+{
+	Precache();
+	SET_MODEL(ENT(pev), "models/w_9mmclip.mdl");
+	CBasePlayerAmmo::Spawn();
 }
 
-/* <a541> ../cstrike/dlls/ammo.cpp:257 */
+/* <a541> ../cstrike/dlls/ammo.cpp:257 */
-void C357SIGAmmo::Precache_(void)
+void C357SIGAmmo::__MAKE_VHOOK(Precache)(void)
-{
+{
+	PRECACHE_MODEL("models/w_9mmclip.mdl");
+	PRECACHE_SOUND("items/9mmclip1.wav");
 }
 
-/* <a73d> ../cstrike/dlls/ammo.cpp:262 */
+/* <a73d> ../cstrike/dlls/ammo.cpp:262 */
-BOOL C357SIGAmmo::AddAmmo_(CBaseEntity *pOther)
+BOOL C357SIGAmmo::__MAKE_VHOOK(AddAmmo)(CBaseEntity *pOther)
-{
+{
-//	AddAmmo(C357SIGAmmo *const this,
+	if (pOther->GiveAmmo(AMMO_357SIG_BUY, "357SIG", MAX_AMMO_357SIG) == -1)
-//		class CBaseEntity *pOther);  //   262
+	{
-	return FALSE;
+		return FALSE;
+	}
+
+	EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", VOL_NORM, ATTN_NORM);
+	return TRUE;
 }
 
-/* <b403> ../cstrike/dlls/ammo.cpp:272 */
+/* <b403> ../cstrike/dlls/ammo.cpp:272 */
 LINK_ENTITY_TO_CLASS(ammo_357sig, C357SIGAmmo);
-
+
-#ifdef HOOK_GAMEDLL
+#ifdef HOOK_GAMEDLL
-
+
 void C9MMAmmo::Spawn(void)
 {
 	Spawn_();
@@ -226,7 +316,7 @@ BOOL C9MMAmmo::AddAmmo(CBaseEntity *pOther)
 {
 	return AddAmmo_(pOther);
 }
-
+
 void CBuckShotAmmo::Spawn(void)
 {
 	Spawn_();
@@ -241,7 +331,7 @@ BOOL CBuckShotAmmo::AddAmmo(CBaseEntity *pOther)
 {
 	return AddAmmo_(pOther);
 }
-
+
 void C556NatoAmmo::Spawn(void)
 {
 	Spawn_();
@@ -256,110 +346,110 @@ BOOL C556NatoAmmo::AddAmmo(CBaseEntity *pOther)
 {
 	return AddAmmo_(pOther);
 }
-
+
-void C556NatoBoxAmmo::Spawn(void)
+void C556NatoBoxAmmo::Spawn(void)
-{
+{
-	Spawn_();
+	Spawn_();
-}
+}
-
+
-void C556NatoBoxAmmo::Precache(void)
+void C556NatoBoxAmmo::Precache(void)
-{
+{
-	Precache_();
+	Precache_();
-}
+}
-
+
-BOOL C556NatoBoxAmmo::AddAmmo(CBaseEntity *pOther)
+BOOL C556NatoBoxAmmo::AddAmmo(CBaseEntity *pOther)
-{
+{
-	return AddAmmo_(pOther);
+	return AddAmmo_(pOther);
-}
+}
-
+
-void C762NatoAmmo::Spawn(void)
+void C762NatoAmmo::Spawn(void)
-{
+{
-	Spawn_();
+	Spawn_();
-}
+}
-
+
-void C762NatoAmmo::Precache(void)
+void C762NatoAmmo::Precache(void)
-{
+{
-	Precache_();
+	Precache_();
-}
+}
-
+
-BOOL C762NatoAmmo::AddAmmo(CBaseEntity *pOther)
+BOOL C762NatoAmmo::AddAmmo(CBaseEntity *pOther)
-{
+{
-	return AddAmmo_(pOther);
+	return AddAmmo_(pOther);
-}
+}
-
+
-void C45ACPAmmo::Spawn(void)
+void C45ACPAmmo::Spawn(void)
-{
+{
-	Spawn_();
+	Spawn_();
-}
+}
-
+
-void C45ACPAmmo::Precache(void)
+void C45ACPAmmo::Precache(void)
-{
+{
-	Precache_();
+	Precache_();
-}
+}
-
+
-BOOL C45ACPAmmo::AddAmmo(CBaseEntity *pOther)
+BOOL C45ACPAmmo::AddAmmo(CBaseEntity *pOther)
-{
+{
-	return AddAmmo_(pOther);
+	return AddAmmo_(pOther);
-}
+}
-
+
-void C50AEAmmo::Spawn(void)
+void C50AEAmmo::Spawn(void)
-{
+{
-	Spawn_();
+	Spawn_();
-}
+}
-
+
-void C50AEAmmo::Precache(void)
+void C50AEAmmo::Precache(void)
-{
+{
-	Precache_();
+	Precache_();
-}
+}
-
+
-BOOL C50AEAmmo::AddAmmo(CBaseEntity *pOther)
+BOOL C50AEAmmo::AddAmmo(CBaseEntity *pOther)
-{
+{
-	return AddAmmo_(pOther);
+	return AddAmmo_(pOther);
-}
+}
-
+
-void C338MagnumAmmo::Spawn(void)
+void C338MagnumAmmo::Spawn(void)
-{
+{
-	Spawn_();
+	Spawn_();
-}
+}
-
+
-void C338MagnumAmmo::Precache(void)
+void C338MagnumAmmo::Precache(void)
-{
+{
-	Precache_();
+	Precache_();
-}
+}
-
+
-BOOL C338MagnumAmmo::AddAmmo(CBaseEntity *pOther)
+BOOL C338MagnumAmmo::AddAmmo(CBaseEntity *pOther)
-{
+{
-	return AddAmmo_(pOther);
+	return AddAmmo_(pOther);
-}
+}
-
+
-void C57MMAmmo::Spawn(void)
+void C57MMAmmo::Spawn(void)
-{
+{
-	Spawn_();
+	Spawn_();
-}
+}
-
+
-void C57MMAmmo::Precache(void)
+void C57MMAmmo::Precache(void)
-{
+{
-	Precache_();
+	Precache_();
-}
+}
-
+
-BOOL C57MMAmmo::AddAmmo(CBaseEntity *pOther)
+BOOL C57MMAmmo::AddAmmo(CBaseEntity *pOther)
-{
+{
-	return AddAmmo_(pOther);
+	return AddAmmo_(pOther);
-}
+}
-
+
-void C357SIGAmmo::Spawn(void)
+void C357SIGAmmo::Spawn(void)
-{
+{
-	Spawn_();
+	Spawn_();
-}
+}
-
+
-void C357SIGAmmo::Precache(void)
+void C357SIGAmmo::Precache(void)
-{
+{
-	Precache_();
+	Precache_();
-}
+}
-
+
-BOOL C357SIGAmmo::AddAmmo(CBaseEntity *pOther)
+BOOL C357SIGAmmo::AddAmmo(CBaseEntity *pOther)
-{
+{
-	return AddAmmo_(pOther);
+	return AddAmmo_(pOther);
-}
+}
-
+
-#endif // HOOK_GAMEDLL
+#endif // HOOK_GAMEDLL

regamedll/dlls/ammo.h

@@ -41,9 +41,11 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -57,9 +59,11 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -73,9 +77,11 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -89,9 +95,11 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -105,9 +113,11 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -121,9 +131,11 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -137,9 +149,11 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -153,9 +167,11 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -169,9 +185,11 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -185,11 +203,24 @@ public:
 	virtual BOOL AddAmmo(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	BOOL AddAmmo_(CBaseEntity *pOther);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
+
+C_DLLEXPORT void ammo_9mm(entvars_t *pev);		// C9MMAmmo
+C_DLLEXPORT void ammo_buckshot(entvars_t *pev);		// CBuckShotAmmo
+C_DLLEXPORT void ammo_556nato(entvars_t *pev);		// C556NatoAmmo
+C_DLLEXPORT void ammo_556natobox(entvars_t *pev);	// C556NatoBoxAmmo
+C_DLLEXPORT void ammo_762nato(entvars_t *pev);		// C762NatoAmmo
+C_DLLEXPORT void ammo_45acp(entvars_t *pev);		// C45ACPAmmo
+C_DLLEXPORT void ammo_50ae(entvars_t *pev);		// C50AEAmmo
+C_DLLEXPORT void ammo_338magnum(entvars_t *pev);	// C338MagnumAmmo
+C_DLLEXPORT void ammo_57mm(entvars_t *pev);		// C57MMAmmo
+C_DLLEXPORT void ammo_357sig(entvars_t *pev);		// C357SIGAmmo
 
 #endif // AMMO_H

regamedll/dlls/animating.cpp

@@ -64,23 +64,44 @@ int CBaseAnimating::LookupActivity(int activity)
 }
 
 /* <10653> ../cstrike/dlls/animating.cpp:91 */
-NOBODY int CBaseAnimating::LookupActivityHeaviest(int activity)
+int CBaseAnimating::LookupActivityHeaviest(int activity)
 {
-//	{ 
+	void *pmodel = GET_MODEL_PTR(ENT(pev));
-//		void *pmodel;                                        //    93
+	return ::LookupActivityHeaviest(pmodel, pev, activity);
-//	} 
 }
 
 /* <107b1> ../cstrike/dlls/animating.cpp:136 */
-NOBODY void CBaseAnimating::DispatchAnimEvents(float flInterval)
+void CBaseAnimating::DispatchAnimEvents(float flInterval)
 {
-//	{
+	MonsterEvent_t event;
-//		MonsterEvent_t event;                                 //   138
+	void *pmodel = GET_MODEL_PTR(ENT(pev));
-//		void *pmodel;                                        //   140
+
-//		float flStart;                                        //   152
+	if (!pmodel)
-//		float flEnd;                                          //   153
+	{
-//		int index;                                            //   160
+		ALERT(at_aiconsole, "Gibbed monster is thinking!\n");
-//	}
+		return;
+	}
+
+	// FIXME: I have to do this or some events get missed, and this is probably causing the problem below
+	flInterval = 0.1f;
+
+	// FIX: this still sometimes hits events twice
+	float flStart = pev->frame + (m_flLastEventCheck - pev->animtime) * m_flFrameRate * pev->framerate;
+	float flEnd = pev->frame + flInterval * m_flFrameRate * pev->framerate;
+
+	m_fSequenceFinished = FALSE;
+	m_flLastEventCheck = pev->animtime + flInterval;
+
+	if (flEnd >= 256.0f || flEnd <= 0.0f)
+	{
+		m_fSequenceFinished = TRUE;
+	}
+
+	int index = 0;
+	while ((index = GetAnimationEvent(pmodel, pev, &event, flStart, flEnd, index)) != 0)
+	{
+		HandleAnimEvent(&event);
+	}
 }
 
 /* <106a1> ../cstrike/dlls/animating.cpp:100 */
@@ -114,7 +135,7 @@ BOOL CBaseAnimating::GetSequenceFlags(void)
 /* <10837> ../cstrike/dlls/animating.cpp:171 */
 float CBaseAnimating::SetBoneController(int iController, float flValue)
 {
-	void *pmodel = GET_MODEL_PTR( ENT(pev) );
+	void *pmodel = GET_MODEL_PTR(ENT(pev));
 
 	return SetController(pmodel, pev, iController, flValue);
 }
@@ -131,96 +152,134 @@ void CBaseAnimating::InitBoneControllers(void)
 }
 
 /* <108d3> ../cstrike/dlls/animating.cpp:192 */
-NOBODY float CBaseAnimating::SetBlending(int iBlender, float flValue)
+NOXREF float CBaseAnimating::SetBlending(int iBlender, float flValue)
 {
-//	{ 
+	void *pmodel = GET_MODEL_PTR(ENT(pev));
-//		void *pmodel;                                        //   194
+	return ::SetBlending(pmodel, pev, iBlender, flValue);
-//	} 
 }
 
 /* <1092f> ../cstrike/dlls/animating.cpp:201 */
-NOBODY void CBaseAnimating::GetBonePosition(int iBone, Vector &origin, Vector &angles)
+NOXREF void CBaseAnimating::GetBonePosition(int iBone, Vector &origin, Vector &angles)
 {
+	GET_BONE_POSITION(ENT(pev), iBone, origin, angles);
 }
 
 /* <10984> ../cstrike/dlls/animating.cpp:208 */
-NOBODY void CBaseAnimating::GetAttachment(int iAttachment, Vector &origin, Vector &angles)
+NOXREF void CBaseAnimating::GetAttachment(int iAttachment, Vector &origin, Vector &angles)
 {
+	GET_ATTACHMENT(ENT(pev), iAttachment, origin, angles);
 }
 
 /* <109d4> ../cstrike/dlls/animating.cpp:215 */
-NOBODY int CBaseAnimating::FindTransition(int iEndingSequence, int iGoalSequence, int *piDir)
+NOXREF int CBaseAnimating::FindTransition(int iEndingSequence, int iGoalSequence, int *piDir)
 {
-//	{
+	void *pmodel = GET_MODEL_PTR(ENT(pev));
-//		void *pmodel;                                        //   217
+
-//		{
+	if (piDir == NULL)
-//			int iDir;                                     //   221
+	{
-//			int sequence;                                 //   222
+		int iDir;
-//		}
+		int sequence = ::FindTransition(pmodel, iEndingSequence, iGoalSequence, &iDir);
-//	}
+
+		if (iDir != 1)
+			sequence = -1;
+
+		return sequence;
+	}
+
+	return ::FindTransition(pmodel, iEndingSequence, iGoalSequence, piDir);
+
 }
 
 /* <10a5d> ../cstrike/dlls/animating.cpp:234 */
 NOXREF void CBaseAnimating::GetAutomovement(Vector &origin, Vector &angles, float flInterval)
 {
+	;
 }
 
 /* <10aad> ../cstrike/dlls/animating.cpp:239 */
-NOBODY void CBaseAnimating::SetBodygroup(int iGroup, int iValue)
+NOXREF void CBaseAnimating::SetBodygroup(int iGroup, int iValue)
 {
+	::SetBodygroup(GET_MODEL_PTR(ENT(pev)), pev, iGroup, iValue);
 }
 
 /* <10af0> ../cstrike/dlls/animating.cpp:244 */
-NOBODY int CBaseAnimating::GetBodygroup(int iGroup)
+NOXREF int CBaseAnimating::GetBodygroup(int iGroup)
 {
+	return ::GetBodygroup(GET_MODEL_PTR(ENT(pev)), pev, iGroup);
 }
 
 /* <10b5f> ../cstrike/dlls/animating.cpp:250 */
-NOBODY int CBaseAnimating::ExtractBbox(int sequence, float *mins, float *maxs)
+int CBaseAnimating::ExtractBbox(int sequence, float *mins, float *maxs)
 {
+	return ::ExtractBbox(GET_MODEL_PTR(ENT(pev)), sequence, mins, maxs);
 }
 
 /* <10b99> ../cstrike/dlls/animating.cpp:258 */
-NOBODY void CBaseAnimating::SetSequenceBox(void)
+void CBaseAnimating::SetSequenceBox(void)
 {
-//	{
+	Vector mins, maxs;
-//		class Vector mins;                                    //   260
+
-//		class Vector maxs;                                    //   260
+	// Get sequence bbox
-//		ExtractBbox(CBaseAnimating *const this,
+	if (ExtractBbox(pev->sequence, mins, maxs))
-//				int sequence,
+	{
-//				float *mins,
+		// expand box for rotation
-//				float *maxs);  //   263
+		// find min / max for rotations
-//		{
+		float yaw = pev->angles.y * (M_PI / 180.0);
-//			float yaw;                                    //   267
+
-//			class Vector xvector;                         //   269
+		Vector xvector, yvector;
-//			class Vector yvector;                         //   269
+		xvector.x = cos(yaw);
-//			class Vector bounds;                          //   274
+		xvector.y = sin(yaw);
-//			class Vector rmin;                            //   279
+		yvector.x = -sin(yaw);
-//			class Vector rmax;                            //   280
+		yvector.y = cos(yaw);
-//			class Vector base;                            //   281
+
-//			class Vector transformed;                     //   281
+		Vector bounds[2];
-//			Vector(Vector *const this,
+		bounds[0] = mins;
-//				float X,
+		bounds[1] = maxs;
-//				float Y,
+
-//				float Z);  //   280
+		Vector rmin(9999, 9999, 9999);
-//			Vector(Vector *const this,
+		Vector rmax(-9999, -9999, -9999);
-//				float X,
+
-//				float Y,
+		Vector base, transformed;
-//				float Z);  //   279
+		for (int i = 0; i <= 1; i++)
-//			{
+		{
-//				int i;                                //   283
+			base.x = bounds[i].x;
-//				{
+			for (int j = 0; j <= 1; j++)
-//					int j;                        //   286
+			{
-//					{
+				base.y = bounds[j].y;
-//						int k;                //   289
+				for (int k = 0; k <= 1; k++)
-//						{
+				{
-//							int l;        //   298
+					base.z = bounds[k].z;
-//						}
+
-//					}
+					// transform the point
-//				}
+					transformed.x = xvector.x * base.x + yvector.x * base.y;
-//			}
+					transformed.y = xvector.y * base.x + yvector.y * base.y;
-//		}
+					transformed.z = base.z;
-//	}
+
+					if (transformed.x < rmin.x)
+						rmin.x = transformed.x;
+
+					if (transformed.x > rmax.x)
+						rmax.x = transformed.x;
+
+					if (transformed.y < rmin.y)
+						rmin.y = transformed.y;
+
+					if (transformed.y > rmax.y)
+						rmax.y = transformed.y;
+
+					if (transformed.z < rmin.z)
+						rmin.z = transformed.z;
+
+					if (transformed.z > rmax.z)
+						rmax.z = transformed.z;
+				}
+			}
+		}
+
+		rmin.z = 0;
+		rmax.z = rmin.z + 1;
+		UTIL_SetSize(pev, rmin, rmax);
+	}
 }
 
 #ifdef HOOK_GAMEDLL
@@ -235,9 +294,4 @@ int CBaseAnimating::Restore(CRestore &restore)
 	return Restore_(restore);
 }
 
-//void CBaseAnimating::HandleAnimEvent(MonsterEvent_t *pEvent)
-//{
-//	HandleAnimEvent_(pEvent);
-//}
-
 #endif // HOOK_GAMEDLL

regamedll/dlls/animation.cpp

@@ -30,94 +30,154 @@ float sclp;
 float sclq;
 
 /* <1523e> ../cstrike/dlls/animation.cpp:57 */
-NOBODY int ExtractBbox(void *pmodel, int sequence, float *mins, float *maxs)
+int ExtractBbox(void *pmodel, int sequence, float *mins, float *maxs)
 {
-//	{
+	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
-//		studiohdr_t *pstudiohdr;                             //    59
+
-//		mstudioseqdesc_t *pseqdesc;                          //    65
+	if (!pstudiohdr)
-//	}
+	{
+		return 0;
+	}
+
+	mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+
+	mins[0] = pseqdesc[sequence].bbmin[0];
+	mins[1] = pseqdesc[sequence].bbmin[1];
+	mins[2] = pseqdesc[sequence].bbmin[2];
+
+	maxs[0] = pseqdesc[sequence].bbmax[0];
+	maxs[1] = pseqdesc[sequence].bbmax[1];
+	maxs[2] = pseqdesc[sequence].bbmax[2];
+
+	return 1;
 }
 
 /* <152c6> ../cstrike/dlls/animation.cpp:81 */
 int LookupActivity(void *pmodel, entvars_t *pev, int activity)
 {
-	int i;
+	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
-	int weightTotal = 0;
+
-	int activitySequenceCount = 0;
+	if (!pstudiohdr)
-	int weight = 0;
+	{
-	int select;
+		return 0;
-
+	}
-	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
+
-	if (!pstudiohdr)
+	mstudioseqdesc_t *pseqdesc;
-		return 0;
+
-
+	int i;
-	mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
+	int weightTotal = 0;
-	for (i = 0; i < pstudiohdr->numseq; i++)
+	int activitySequenceCount = 0;
-	{
+	int weight = 0;
-		if (pseqdesc[i].activity == activity)
+	int select;
-		{
+
-			weightTotal += pseqdesc[i].actweight;
+	pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
-			activitySequenceCount++;
+
-		}
+	for (i = 0; i < pstudiohdr->numseq; i++)
-	}
+	{
-	if (activitySequenceCount)
+		if (pseqdesc[i].activity == activity)
-	{
+		{
-		if (!weightTotal)
+			weightTotal += pseqdesc[i].actweight;
-		{
+			++activitySequenceCount;
-			select = RANDOM_LONG(0, activitySequenceCount - 1);
+		}
-			for (i = 0; i < pstudiohdr->numseq; i++)
+	}
-			{
+
-				if (pseqdesc[i].activity == activity)
+	if (activitySequenceCount > 0)
-				{
+	{
-					if (!select)
+		if (weightTotal)
-						return i;
+		{
-					--select;
+			int which = RANDOM_LONG(0, weightTotal - 1);
-				}
+
-			}
+			for (i = 0; i < pstudiohdr->numseq; i++)
-			return ACTIVITY_NOT_AVAILABLE;
+			{
-		}
+				if (pseqdesc[i].activity == activity)
-		select = RANDOM_LONG(0, weightTotal - 1);
+				{
-		for (i = 0; i < pstudiohdr->numseq; i++)
+					weight += pseqdesc[i].actweight;
-		{
+
-			if (pseqdesc[i].activity == activity)
+					if (weight > which)
-			{
+					{
-				weight += pseqdesc[i].actweight;
+						return i;
-				if (weight > select)
+					}
-					return i;
+				}
-			}
+			}
-		}
+		}
-	}
+		else
+		{
+			select = RANDOM_LONG(0, activitySequenceCount - 1);
+
+			for (i = 0; i < pstudiohdr->numseq; i++)
+			{
+				if (pseqdesc[i].activity == activity)
+				{
+					if (select == 0)
+					{
+						return i;
+					}
+
+					--select;
+				}
+			}
+		}
+	}
+
 	return ACTIVITY_NOT_AVAILABLE;
 }
 
 /* <1539a> ../cstrike/dlls/animation.cpp:149 */
-NOBODY int LookupActivityHeaviest(void *pmodel, entvars_t *pev, int activity)
+int LookupActivityHeaviest(void *pmodel, entvars_t *pev, int activity)
 {
-//	{
+	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
-//		studiohdr_t *pstudiohdr;                             //   151
+
-//		mstudioseqdesc_t *pseqdesc;                          //   157
+	if (!pstudiohdr)
-//		int weight;                                           //   161
+	{
-//		int seq;                                              //   162
+		return 0;
-//		{
+	}
-//			int i;                                        //   163
+
-//		}
+	mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
-//	}
+	int weight = 0;
+	int seq = ACTIVITY_NOT_AVAILABLE;
+
+	for (int i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (pseqdesc[i].activity == activity)
+		{
+			if (pseqdesc[i].actweight > weight)
+			{
+				weight = pseqdesc[i].actweight;
+				seq = i;
+			}
+		}
+	}
+
+	return seq;
 }
 
 /* <15439> ../cstrike/dlls/animation.cpp:178 */
-NOBODY void GetEyePosition(void *pmodel, float *vecEyePosition)
+NOXREF void GetEyePosition(void *pmodel, float *vecEyePosition)
 {
-//	{
+	studiohdr_t *pstudiohdr;
-//		studiohdr_t *pstudiohdr;                             //   180
+	
-//	}
+	pstudiohdr = (studiohdr_t *)pmodel;
+
+	if (!pstudiohdr)
+	{
+		ALERT(at_console, "GetEyePosition() Can't get pstudiohdr ptr!\n");
+		return;
+	}
+	
+	vecEyePosition[0] = pstudiohdr->eyeposition[0];
+	vecEyePosition[1] = pstudiohdr->eyeposition[1];
+	vecEyePosition[2] = pstudiohdr->eyeposition[2];
 }
 
 /* <15485> ../cstrike/dlls/animation.cpp:193 */
 int LookupSequence(void *pmodel, const char *label)
 {
 	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
+
 	if (!pstudiohdr)
+	{
 		return 0;
+	}
 
 	mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
 	for (int i = 0; i < pstudiohdr->numseq; i++)
@@ -129,35 +189,62 @@ int LookupSequence(void *pmodel, const char *label)
 }
 
 /* <1518c> ../cstrike/dlls/animation.cpp:215 */
-NOBODY int IsSoundEvent(int eventNumber)
+int IsSoundEvent(int eventNumber)
 {
+	if (eventNumber == SCRIPT_EVENT_SOUND || eventNumber == SCRIPT_EVENT_SOUND_VOICE)
+	{
+		return 1;
+	}
+
+	return 0;
 }
 
 /* <15539> ../cstrike/dlls/animation.cpp:223 */
-NOBODY void SequencePrecache(void *pmodel, const char *pSequenceName)
+NOXREF void SequencePrecache(void *pmodel, const char *pSequenceName)
 {
-//	{
+	int index = LookupSequence(pmodel, pSequenceName);
-//		int index;                                            //   225
+
-//		LookupSequence(void *pmodel,
+	if (index >= 0)
-//				const char *label);  //   225
+	{
-//		{
+		studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
-//			studiohdr_t *pstudiohdr;                     //   228
+		if (!pstudiohdr || index >= pstudiohdr->numseq)
-//			mstudioseqdesc_t *pseqdesc;                  //   234
+		{
-//			mstudioevent_t *pevent;                      //   235
+			return;
-//			{
+		}
-//				int i;                                //   240
+
-//				IsSoundEvent(int eventNumber);  //   248
+		mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + index;
-//			}
+		mstudioevent_t *pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
-//		}
+
-//	}
+		for (int i = 0; i < pseqdesc->numevents; i++)
+		{
+			// Don't send client-side events to the server AI
+			if (pevent[i].event >= EVENT_CLIENT)
+				continue;
+
+			// UNDONE: Add a callback to check to see if a sound is precached yet and don't allocate a copy
+			// of it's name if it is.
+			if (IsSoundEvent(pevent[i].event))
+			{
+				if (!Q_strlen(pevent[i].options))
+				{
+					ALERT(at_error, "Bad sound event %d in sequence %s :: %s (sound is \"%s\")\n", pevent[i].event, pstudiohdr->name, pSequenceName, pevent[i].options);
+				}
+
+				PRECACHE_SOUND((char *)(gpGlobals->pStringBase + ALLOC_STRING(pevent[i].options)));
+			}
+		}
+	}
 }
 
 /* <15634> ../cstrike/dlls/animation.cpp:263 */
 void GetSequenceInfo(void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed)
 {
 	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
+
 	if (!pstudiohdr)
+	{
 		return;
+	}
 
 	if (pev->sequence >= pstudiohdr->numseq)
 	{
@@ -183,22 +270,66 @@ void GetSequenceInfo(void *pmodel, entvars_t *pev, float *pflFrameRate, float *p
 int GetSequenceFlags(void *pmodel, entvars_t *pev)
 {
 	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
+
 	if (!pstudiohdr || pev->sequence >= pstudiohdr->numseq)
+	{
 		return 0;
+	}
 
 	mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
 	return pseqdesc->flags;
 }
 
 /* <15717> ../cstrike/dlls/animation.cpp:312 */
-NOBODY int GetAnimationEvent(void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index)
+int GetAnimationEvent(void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index)
 {
-//	{
+	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
-//		studiohdr_t *pstudiohdr;                             //   314
+
-//		int events;                                           //   320
+	if (!pstudiohdr || pev->sequence >= pstudiohdr->numseq || !pMonsterEvent)
-//		mstudioseqdesc_t *pseqdesc;                          //   322
+	{
-//		mstudioevent_t *pevent;                              //   323
+		return 0;
-//	}
+	}
+
+	// int events = 0;
+
+	mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+	mstudioevent_t *pevent = (mstudioevent_t *)((byte *)pstudiohdr + pseqdesc->eventindex);
+
+	if (pseqdesc->numevents == 0 || index > pseqdesc->numevents)
+	{
+		return 0;
+	}
+
+	if (pseqdesc->numframes > 1)
+	{
+		flStart *= (pseqdesc->numframes - 1) / 256.0;
+		flEnd *= (pseqdesc->numframes - 1) / 256.0;
+	}
+	else
+	{
+		flStart = 0;
+		flEnd = 1.0;
+	}
+
+	for (; index < pseqdesc->numevents; index++)
+	{
+		// Don't send client-side events to the server AI
+		if (pevent[index].event >= EVENT_CLIENT)
+			continue;
+
+		if ((pevent[index].frame >= flStart && pevent[index].frame < flEnd) ||
+			((pseqdesc->flags & STUDIO_LOOPING)
+				&& flEnd >= pseqdesc->numframes - 1
+				&& pevent[index].frame < flEnd - pseqdesc->numframes + 1))
+		{
+			pMonsterEvent->event = pevent[index].event;
+			pMonsterEvent->options = pevent[index].options;
+
+			return index + 1;
+		}
+	}
+
+	return 0;
 }
 
 /* <157e1> ../cstrike/dlls/animation.cpp:359 */
@@ -207,7 +338,9 @@ float SetController(void *pmodel, entvars_t *pev, int iController, float flValue
 	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
 
 	if (!pstudiohdr)
+	{
 		return flValue;
+	}
 
 	int i;
 	mstudiobonecontroller_t *pbonecontroller = (mstudiobonecontroller_t *)((byte *)pstudiohdr + pstudiohdr->bonecontrollerindex);
@@ -257,36 +390,143 @@ float SetController(void *pmodel, entvars_t *pev, int iController, float flValue
 }
 
 /* <15883> ../cstrike/dlls/animation.cpp:414 */
-NOBODY float SetBlending(void *pmodel, entvars_t *pev, int iBlender, float flValue)
+float SetBlending(void *pmodel, entvars_t *pev, int iBlender, float flValue)
-{
+{
-//	{
+	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
-//		studiohdr_t *pstudiohdr;                             //   416
+	if (!pstudiohdr)
-//		mstudioseqdesc_t *pseqdesc;                          //   422
+	{
-//		int setting;                                          //   445
+		return flValue;
-//	}
+	}
+
+	mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex) + (int)pev->sequence;
+
+	if (pseqdesc->blendtype[iBlender] == 0)
+	{
+		return flValue;
+	}
+
+	if (pseqdesc->blendtype[iBlender] & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
+	{
+		// ugly hack, invert value if end < start
+		if (pseqdesc->blendend[iBlender] < pseqdesc->blendstart[iBlender])
+			flValue = -flValue;
+
+		// does the controller not wrap?
+		if (pseqdesc->blendstart[iBlender] + 359.0 >= pseqdesc->blendend[iBlender])
+		{
+			if (flValue > ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) + 180)
+			{
+				flValue = flValue - 360;
+			}
+
+			if (flValue < ((pseqdesc->blendstart[iBlender] + pseqdesc->blendend[iBlender]) / 2.0) - 180)
+			{
+				flValue = flValue + 360;
+			}
+		}
+	}
+
+	int setting = (int64_t)(255.0f * (flValue - pseqdesc->blendstart[iBlender]) / (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]));
+
+	if (setting < 0)
+		setting = 0;
+
+	if (setting > 255)
+		setting = 255;
+
+	pev->blending[iBlender] = setting;
+
+	return setting * (1.0 / 255.0) * (pseqdesc->blendend[iBlender] - pseqdesc->blendstart[iBlender]) + pseqdesc->blendstart[iBlender];
 }
 
 /* <15917> ../cstrike/dlls/animation.cpp:458 */
-NOBODY int FindTransition(void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir)
+int FindTransition(void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir)
 {
-//	{
+	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
-//		studiohdr_t *pstudiohdr;                             //   460
+	if (!pstudiohdr)
-//		mstudioseqdesc_t *pseqdesc;                          //   466
+	{
-//		int iEndNode;                                         //   475
+		return iGoalAnim;
-//		byte *pTransition;                                   //   492
+	}
-//		int iInternNode;                                      //   494
+
-//		int i;                                                //   499
+	mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)pstudiohdr + pstudiohdr->seqindex);
-//	}
+
+	// bail if we're going to or from a node 0
+	if (pseqdesc[iEndingAnim].entrynode == 0 || pseqdesc[iGoalAnim].entrynode == 0)
+	{
+		return iGoalAnim;
+	}
+
+	int iEndNode;
+
+	if (*piDir > 0)
+	{
+		iEndNode = pseqdesc[iEndingAnim].exitnode;
+	}
+	else
+	{
+		iEndNode = pseqdesc[iEndingAnim].entrynode;
+	}
+
+	if (iEndNode == pseqdesc[iGoalAnim].entrynode)
+	{
+		*piDir = 1;
+		return iGoalAnim;
+	}
+
+	byte *pTransition = ((byte *)pstudiohdr + pstudiohdr->transitionindex);
+
+	int iInternNode = pTransition[(iEndNode - 1)*pstudiohdr->numtransitions + (pseqdesc[iGoalAnim].entrynode - 1)];
+
+	if (iInternNode == 0)
+	{
+		return iGoalAnim;
+	}
+
+	// look for someone going
+	for (int i = 0; i < pstudiohdr->numseq; i++)
+	{
+		if (pseqdesc[i].entrynode == iEndNode && pseqdesc[i].exitnode == iInternNode)
+		{
+			*piDir = 1;
+			return i;
+		}
+		if (pseqdesc[i].nodeflags)
+		{
+			if (pseqdesc[i].exitnode == iEndNode && pseqdesc[i].entrynode == iInternNode)
+			{
+				*piDir = -1;
+				return i;
+			}
+		}
+	}
+
+	ALERT(at_console, "error in transition graph");
+	return iGoalAnim;
 }
 
 /* <159d8> ../cstrike/dlls/animation.cpp:523 */
-NOBODY void SetBodygroup(void *pmodel, entvars_t *pev, int iGroup, int iValue)
+void SetBodygroup(void *pmodel, entvars_t *pev, int iGroup, int iValue)
 {
-//	{
+	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
-//		studiohdr_t *pstudiohdr;                             //   525
+	if (!pstudiohdr)
-//		mstudiobodyparts_t *pbodypart;                       //   534
+	{
-//		int iCurrent;                                         //   539
+		return;
-//	}
+	}
+
+	if (iGroup > pstudiohdr->numbodyparts)
+	{
+		return;
+	}
+
+	mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
+
+	if (iValue >= pbodypart->nummodels)
+	{
+		return;
+	}
+
+	int iCurrent = (pev->body / pbodypart->base) % pbodypart->nummodels;
+	pev->body += (iValue - iCurrent) * pbodypart->base;
 }
 
 /* <15a6d> ../cstrike/dlls/animation.cpp:545 */
@@ -294,11 +534,10 @@ int GetBodygroup(void *pmodel, entvars_t *pev, int iGroup)
 {
 	studiohdr_t *pstudiohdr = (studiohdr_t *)pmodel;
 
-	if (!pstudiohdr)
+	if (!pstudiohdr || iGroup > pstudiohdr->numbodyparts)
-		return 0;
+	{
-
-	if (iGroup > pstudiohdr->numbodyparts)
 		return 0;
+	}
 
 	mstudiobodyparts_t *pbodypart = (mstudiobodyparts_t *)((byte *)pstudiohdr + pstudiohdr->bodypartindex) + iGroup;
 

regamedll/dlls/animation.h

@@ -36,20 +36,20 @@
 #include "studio.h"
 #include "r_studioint.h"
 
-NOBODY int ExtractBbox(void *pmodel, int sequence, float *mins, float *maxs);
+int ExtractBbox(void *pmodel, int sequence, float *mins, float *maxs);
 int LookupActivity(void *pmodel, entvars_t *pev, int activity);
-NOBODY int LookupActivityHeaviest(void *pmodel, entvars_t *pev, int activity);
+int LookupActivityHeaviest(void *pmodel, entvars_t *pev, int activity);
-NOBODY void GetEyePosition(void *pmodel, float *vecEyePosition);
+NOXREF void GetEyePosition(void *pmodel, float *vecEyePosition);
 int LookupSequence(void *pmodel, const char *label);
-NOBODY int IsSoundEvent(int eventNumber);
+int IsSoundEvent(int eventNumber);
-NOBODY void SequencePrecache(void *pmodel, const char *pSequenceName);
+NOXREF void SequencePrecache(void *pmodel, const char *pSequenceName);
 void GetSequenceInfo(void *pmodel, entvars_t *pev, float *pflFrameRate, float *pflGroundSpeed);
 int GetSequenceFlags(void *pmodel, entvars_t *pev);
-NOBODY int GetAnimationEvent(void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index);
+int GetAnimationEvent(void *pmodel, entvars_t *pev, MonsterEvent_t *pMonsterEvent, float flStart, float flEnd, int index);
 float SetController(void *pmodel, entvars_t *pev, int iController, float flValue);
-NOBODY float SetBlending(void *pmodel, entvars_t *pev, int iBlender, float flValue);
+float SetBlending(void *pmodel, entvars_t *pev, int iBlender, float flValue);
-NOBODY int FindTransition(void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir);
+int FindTransition(void *pmodel, int iEndingAnim, int iGoalAnim, int *piDir);
-NOBODY void SetBodygroup(void *pmodel, entvars_t *pev, int iGroup, int iValue);
+void SetBodygroup(void *pmodel, entvars_t *pev, int iGroup, int iValue);
 int GetBodygroup(void *pmodel, entvars_t *pev, int iGroup);
 C_DLLEXPORT int Server_GetBlendingInterface(int version, struct sv_blending_interface_s **ppinterface, struct engine_studio_api_s *pstudio, float *rotationmatrix, float *bonetransform);
 void AngleQuaternion(vec_t *angles, vec_t *quaternion);

regamedll/dlls/basemonster.h

@@ -70,14 +70,8 @@ public:
 	virtual void MonsterInitDead(void);
 	NOBODY virtual void Look(int iDistance);
 	NOBODY virtual CBaseEntity *BestVisibleEnemy(void);
-
-#ifdef _WIN32
-	NOBODY virtual BOOL FInViewCone(Vector *pOrigin);
-	NOBODY virtual BOOL FInViewCone(CBaseEntity *pEntity);
-#else
 	NOBODY virtual BOOL FInViewCone(CBaseEntity *pEntity);
 	NOBODY virtual BOOL FInViewCone(Vector *pOrigin);
-#endif // _WIN32
 
 #ifdef HOOK_GAMEDLL
 

regamedll/dlls/bmodels.cpp

@@ -43,12 +43,12 @@ Vector VecBModelOrigin(entvars_t *pevBModel)
 LINK_ENTITY_TO_CLASS(func_wall, CFuncWall);
 
 /* <1d193> ../cstrike/dlls/bmodels.cpp:65 */
-NOBODY void CFuncWall::Spawn_(void)
+NOBODY void CFuncWall::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <1d873> ../cstrike/dlls/bmodels.cpp:77 */
-NOBODY void CFuncWall::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CFuncWall::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	Use(CFuncWall *const this,
 //		class CBaseEntity *pActivator,
@@ -61,7 +61,7 @@ NOBODY void CFuncWall::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_T
 LINK_ENTITY_TO_CLASS(func_wall_toggle, CFuncWallToggle);
 
 /* <1e28f> ../cstrike/dlls/bmodels.cpp:98 */
-NOBODY void CFuncWallToggle::Spawn_(void)
+NOBODY void CFuncWallToggle::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(CFuncWall *const this);  //   100
 //	TurnOff(CFuncWallToggle *const this);  //   102
@@ -83,7 +83,7 @@ NOBODY BOOL CFuncWallToggle::IsOn(void)
 }
 
 /* <1e101> ../cstrike/dlls/bmodels.cpp:130 */
-NOBODY void CFuncWallToggle::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CFuncWallToggle::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		int status;                                           //   132
@@ -97,7 +97,7 @@ NOBODY void CFuncWallToggle::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller,
 LINK_ENTITY_TO_CLASS(func_conveyor, CFuncConveyor);
 
 /* <1e1c3> ../cstrike/dlls/bmodels.cpp:156 */
-NOBODY void CFuncConveyor::Spawn_(void)
+NOBODY void CFuncConveyor::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(CFuncWall *const this);  //   159
 //	UpdateSpeed(CFuncConveyor *const this,
@@ -114,7 +114,7 @@ NOBODY void CFuncConveyor::UpdateSpeed(float speed)
 }
 
 /* <1e021> ../cstrike/dlls/bmodels.cpp:194 */
-NOBODY void CFuncConveyor::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CFuncConveyor::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	UpdateSpeed(CFuncConveyor *const this,
 //			float speed);  //   197
@@ -124,7 +124,7 @@ NOBODY void CFuncConveyor::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, U
 LINK_ENTITY_TO_CLASS(func_illusionary, CFuncIllusionary);
 
 /* <1ddc9> ../cstrike/dlls/bmodels.cpp:219 */
-NOBODY void CFuncIllusionary::KeyValue_(KeyValueData *pkvd)
+NOBODY void CFuncIllusionary::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   221
@@ -133,7 +133,7 @@ NOBODY void CFuncIllusionary::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <1d1db> ../cstrike/dlls/bmodels.cpp:230 */
-NOBODY void CFuncIllusionary::Spawn_(void)
+NOBODY void CFuncIllusionary::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -141,7 +141,7 @@ NOBODY void CFuncIllusionary::Spawn_(void)
 LINK_ENTITY_TO_CLASS(func_monsterclip, CFuncMonsterClip);
 
 /* <1e24f> ../cstrike/dlls/bmodels.cpp:264 */
-NOBODY void CFuncMonsterClip::Spawn_(void)
+NOBODY void CFuncMonsterClip::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(CFuncWall *const this);  //   266
 }
@@ -153,7 +153,7 @@ LINK_ENTITY_TO_CLASS(func_rotating, CFuncRotating);
 IMPLEMENT_SAVERESTORE(CFuncRotating, CBaseEntity);
 
 /* <1dc21> ../cstrike/dlls/bmodels.cpp:315 */
-NOBODY void CFuncRotating::KeyValue_(KeyValueData *pkvd)
+NOBODY void CFuncRotating::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   317
@@ -176,13 +176,13 @@ NOBODY void CFuncRotating::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <1d5c4> ../cstrike/dlls/bmodels.cpp:362 */
-NOBODY void CFuncRotating::Spawn_(void)
+NOBODY void CFuncRotating::__MAKE_VHOOK(Spawn)(void)
 {
 //	operator*(const Vector ::Spawn(//			float fl);  //   404
 }
 
 /* <1d28a> ../cstrike/dlls/bmodels.cpp:447 */
-NOBODY void CFuncRotating::Precache_(void)
+NOBODY void CFuncRotating::__MAKE_VHOOK(Precache)(void)
 {
 //	{
 //		char *szSoundFile;                                   //   449
@@ -267,7 +267,7 @@ NOBODY void CFuncRotating::RotatingUse(CBaseEntity *pActivator, CBaseEntity *pCa
 }
 
 /* <1d325> ../cstrike/dlls/bmodels.cpp:706 */
-NOBODY void CFuncRotating::Blocked_(CBaseEntity *pOther)
+NOBODY void CFuncRotating::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
 {
 }
 
@@ -278,7 +278,7 @@ LINK_ENTITY_TO_CLASS(func_pendulum, CPendulum);
 IMPLEMENT_SAVERESTORE(CPendulum, CBaseEntity);
 
 /* <1db2a> ../cstrike/dlls/bmodels.cpp:765 */
-NOBODY void CPendulum::KeyValue_(KeyValueData *pkvd)
+NOBODY void CPendulum::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   767
@@ -292,7 +292,7 @@ NOBODY void CPendulum::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <1d9c7> ../cstrike/dlls/bmodels.cpp:782 */
-NOBODY void CPendulum::Spawn_(void)
+NOBODY void CPendulum::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(CPendulum *const this);  //   782
 }
@@ -316,7 +316,7 @@ NOBODY void CPendulum::Stop(void)
 }
 
 /* <1d3a7> ../cstrike/dlls/bmodels.cpp:861 */
-NOBODY void CPendulum::Blocked_(CBaseEntity *pOther)
+NOBODY void CPendulum::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
 {
 }
 
@@ -332,7 +332,7 @@ NOBODY void CPendulum::Swing(void)
 }
 
 /* <1d3f5> ../cstrike/dlls/bmodels.cpp:909 */
-NOBODY void CPendulum::Touch_(CBaseEntity *pOther)
+NOBODY void CPendulum::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
 //	{
 //		entvars_t *pevOther;                                 //   911

regamedll/dlls/bot/cs_bot.cpp

@@ -19,19 +19,19 @@ NOBODY int GetBotFollowCount(CBasePlayer *leader)
 }
 
 /* <2e86df> ../cstrike/dlls/bot/cs_bot.cpp:62 */
-NOBODY void CCSBot::Walk_(void)
+NOBODY void CCSBot::__MAKE_VHOOK(Walk)(void)
 {
 //	IsElapsed(const class CountdownTimer *const this);  //    64
 //	Walk(CBot *const this);  //    66
 }
 
 /* <2e8732> ../cstrike/dlls/bot/cs_bot.cpp:80 */
-NOBODY bool CCSBot::Jump_(bool mustJump)
+NOBODY bool CCSBot::__MAKE_VHOOK(Jump)(bool mustJump)
 {
 }
 
 /* <2e8e39> ../cstrike/dlls/bot/cs_bot.cpp:97 */
-NOBODY int CCSBot::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+NOBODY int CCSBot::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 //	{
 //		class CBaseEntity *attacker;                         //    99
@@ -57,7 +57,7 @@ NOBODY int CCSBot::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker,
 }
 
 /* <2e8769> ../cstrike/dlls/bot/cs_bot.cpp:171 */
-NOBODY void CCSBot::Killed_(entvars_t *pevAttacker, int iGib)
+NOBODY void CCSBot::__MAKE_VHOOK(Killed)(entvars_t *pevAttacker, int iGib)
 {
 //	{
 //		float const deathDanger;                               //   178

regamedll/dlls/bot/cs_bot.h

@@ -45,13 +45,13 @@
 
 #ifdef HOOK_GAMEDLL
 
-#define navAreaCount (*pnavAreaCount)
+#define _navAreaCount (*pnavAreaCount)
-#define currentIndex (*pcurrentIndex)
+#define _currentIndex (*pcurrentIndex)
 
 #endif // HOOK_GAMEDLL
 
-extern int navAreaCount;
+extern int _navAreaCount;
-extern int currentIndex;
+extern int _currentIndex;
 
 /* <3327a8> ../cstrike/dlls/bot/cs_bot.h:44 */
 class BotState
@@ -676,7 +676,7 @@ public:
 	NOBODY void StartVoiceFeedback(float duration);
 	bool IsUsingVoice(void) const
 	{
-		return (m_voiceFeedbackEndTimestamp > gpGlobals->time);
+		return (m_voiceFeedbackEndTimestamp != 0.0f);	//return (m_voiceFeedbackEndTimestamp > gpGlobals->time);
 	}
 	void SetEnemy(CBasePlayer *enemy);
 	CBasePlayer *GetEnemy(void)
@@ -685,7 +685,7 @@ public:
 	}
 	int GetNearbyEnemyCount(void) const
 	{
-		return min( GetEnemiesRemaining(), m_nearbyEnemyCount );
+		return _min(GetEnemiesRemaining(), m_nearbyEnemyCount);
 	}
 	unsigned int GetEnemyPlace(void) const
 	{
@@ -698,7 +698,7 @@ public:
 	}
 	int GetNearbyFriendCount(void) const
 	{
-		return min( GetFriendsRemaining(), m_nearbyFriendCount );
+		return _min(GetFriendsRemaining(), m_nearbyFriendCount);
 	}
 	CBasePlayer *GetClosestVisibleFriend(void) const
 	{
@@ -1432,7 +1432,7 @@ public:
 		else
 		{
 			const float k = 1.5f; // 2.0f;
-			float trimSpeed = min(speed, 200.0f);
+			float trimSpeed = (speed < 200.0f) ? speed : 200.0f;
 
 			m_cutoff.x = playerOrigin.x + k * trimSpeed * m_forward.x;
 			m_cutoff.y = playerOrigin.y + k * trimSpeed * m_forward.y;

regamedll/dlls/bot/cs_bot_chatter.cpp

@@ -199,11 +199,11 @@ char *BotPhrase::GetSpeakable(int bankIndex, float *duration) const
 	}
 
 	// find phrase that meets the current criteria
-	int start = m_index[bankIndex];
+	int start = m_index[ bankIndex ];
 	while (true)
 	{
-		BotSpeakableVector *speakables = m_voiceBank[bankIndex];
+		BotSpeakableVector *speakables = m_voiceBank[ bankIndex ];
-		int &index = m_index[bankIndex];
+		int &index = m_index[ bankIndex ];
 
 #ifdef HOOK_GAMEDLL
 		// TODO: temporary fix of std::vector padding
@@ -212,8 +212,8 @@ char *BotPhrase::GetSpeakable(int bankIndex, float *duration) const
 
 		const BotSpeakable *speak = (*speakables)[index++];
 
-		if (m_index[bankIndex] >= m_count[bankIndex])
+		if (m_index[ bankIndex ] >= m_count[ bankIndex ])
-			m_index[bankIndex] = 0;
+			m_index[ bankIndex ] = 0;
 
 		// check place criteria
 		// if this speakable has a place criteria, it must match to be used
@@ -225,7 +225,7 @@ char *BotPhrase::GetSpeakable(int bankIndex, float *duration) const
 			// check count criteria
 			// if this speakable has a count criteria, it must match to be used
 			// if this speakable does not have a count criteria, we dont care what the count is set to
-			if (speak->m_count == UNDEFINED_COUNT || speak->m_count == min(m_countCriteria, COUNT_MANY))
+			if (speak->m_count == UNDEFINED_COUNT || speak->m_count == _min(m_countCriteria, COUNT_MANY))
 			{
 				if (duration)
 					*duration = speak->m_duration;

regamedll/dlls/bot/cs_bot_event.cpp

@@ -1,7 +1,7 @@
 #include "precompiled.h"
 
 /* <31d087> ../cstrike/dlls/bot/cs_bot_event.cpp:22 */
-void CCSBot::OnEvent_(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+void CCSBot::__MAKE_VHOOK(OnEvent)(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
 {
 //	{
 //		class CCSBotManager *ctrl;                           //    63

regamedll/dlls/bot/cs_bot_init.cpp

@@ -88,7 +88,7 @@ void Bot_RegisterCvars(void)
 //}
 
 /* <3342ac> ../cstrike/dlls/bot/cs_bot_init.cpp:137 */
-NOBODY bool CCSBot::Initialize_(const BotProfile *profile)
+NOBODY bool CCSBot::__MAKE_VHOOK(Initialize)(const BotProfile *profile)
 {
 	CBot::Initialize(profile);
 
@@ -264,7 +264,7 @@ NOBODY void CCSBot::ResetValues(void)
 }
 
 /* <3342e4> ../cstrike/dlls/bot/cs_bot_init.cpp:336 */
-NOBODY void CCSBot::SpawnBot_(void)
+NOBODY void CCSBot::__MAKE_VHOOK(SpawnBot)(void)
 {
 //	{
 //		class CCSBotManager *ctrl;                           //   338
@@ -273,7 +273,7 @@ NOBODY void CCSBot::SpawnBot_(void)
 }
 
 /* <3338f7> ../cstrike/dlls/bot/cs_bot_init.cpp:366 */
-NOBODY void CCSBot::RoundRespawn_(void)
+NOBODY void CCSBot::__MAKE_VHOOK(RoundRespawn)(void)
 {
 }
 

regamedll/dlls/bot/cs_bot_learn.cpp

@@ -13,8 +13,8 @@ const float updateTimesliceDuration = 0.0;//TODO: what value?? check it.
 
 #endif // HOOK_GAMEDLL
 
-int navAreaCount;
+int _navAreaCount;
-int currentIndex;
+int _currentIndex;
 
 /* <343cbe> ../cstrike/dlls/bot/cs_bot_learn.cpp:95 */
 NOBODY inline class CNavNode *LadderEndSearch(CBaseEntity *entity, const Vector *pos, NavDirType mountDir)
@@ -194,8 +194,8 @@ void CCSBot::StartAnalyzeAlphaProcess(void)
 	m_processMode = PROCESS_ANALYZE_ALPHA;
 	m_analyzeIter = TheNavAreaList.begin();
 
-	navAreaCount = TheNavAreaList.size();
+	_navAreaCount = TheNavAreaList.size();
-	currentIndex = 0;
+	_currentIndex = 0;
 
 	ApproachAreaAnalysisPrep();
 	DestroyHidingSpots();

regamedll/dlls/bot/cs_bot_manager.cpp

@@ -7,34 +7,34 @@
 
 CBotManager *TheBots = NULL;
 
-cvar_t cv_bot_traceview = { "bot_traceview", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_traceview = { "bot_traceview", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_stop = { "bot_stop", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_stop = { "bot_stop", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_show_nav = { "bot_show_nav", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_show_nav = { "bot_show_nav", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_show_danger = { "bot_show_danger", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_show_danger = { "bot_show_danger", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_nav_edit = { "bot_nav_edit", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_nav_edit = { "bot_nav_edit", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_nav_zdraw = { "bot_nav_zdraw", "4", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_nav_zdraw = { "bot_nav_zdraw", "4", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_walk = { "bot_walk", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_walk = { "bot_walk", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_difficulty = { "bot_difficulty", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_difficulty = { "bot_difficulty", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_debug = { "bot_debug", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_debug = { "bot_debug", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_quicksave = { "bot_quicksave", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_quicksave = { "bot_quicksave", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_quota = { "bot_quota", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_quota = { "bot_quota", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_quota_match = { "bot_quota_match", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_quota_match = { "bot_quota_match", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_prefix = { "bot_prefix", "", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_prefix = { "bot_prefix", "", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_allow_rogues = { "bot_allow_rogues", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_allow_rogues = { "bot_allow_rogues", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_allow_pistols = { "bot_allow_pistols", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_allow_pistols = { "bot_allow_pistols", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_allow_shotguns = { "bot_allow_shotguns", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_allow_shotguns = { "bot_allow_shotguns", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_allow_sub_machine_guns = { "bot_allow_sub_machine_guns", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_allow_sub_machine_guns = { "bot_allow_sub_machine_guns", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_allow_rifles = { "bot_allow_rifles", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_allow_rifles = { "bot_allow_rifles", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_allow_machine_guns = { "bot_allow_machine_guns", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_allow_machine_guns = { "bot_allow_machine_guns", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_allow_grenades = { "bot_allow_grenades", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_allow_grenades = { "bot_allow_grenades", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_allow_snipers = { "bot_allow_snipers", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_allow_snipers = { "bot_allow_snipers", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_allow_shield = { "bot_allow_shield", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_allow_shield = { "bot_allow_shield", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_join_team = { "bot_join_team", "any", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_join_team = { "bot_join_team", "any", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_join_after_player = { &unk_1EF09A, "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_join_after_player = { &unk_1EF09A, "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_auto_vacate = { "bot_auto_vacate", "1", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_auto_vacate = { "bot_auto_vacate", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_zombie = { "bot_zombie", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_zombie = { "bot_zombie", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_defer_to_human = { "bot_defer_to_human", "0", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_defer_to_human = { "bot_defer_to_human", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_bot_chatter = { "bot_chatter", "normal", FCVAR_SERVER,  0.0f, NULL };
+cvar_t cv_bot_chatter = { "bot_chatter", "normal", FCVAR_SERVER, 0.0f, NULL };
 cvar_t cv_bot_profile_db = { "bot_profile_db", "BotProfile.db", FCVAR_SERVER, 0.0f, NULL };
 
 float CCSBotManager::m_flNextCVarCheck;
@@ -112,7 +112,7 @@ NOBODY CCSBotManager::CCSBotManager(void)
 }
 
 /* <36b22a> ../cstrike/dlls/bot/cs_bot_manager.cpp:111 */
-void CCSBotManager::RestartRound_(void)
+void CCSBotManager::__MAKE_VHOOK(RestartRound)(void)
 {
 	// extend
 	CBotManager::RestartRound();
@@ -159,19 +159,38 @@ NOBODY void UTIL_DrawBox(Extent *extent, int lifetime, int red, int green, int b
 }
 
 /* <36b13d> ../cstrike/dlls/bot/cs_bot_manager.cpp:195 */
-NOBODY void CCSBotManager::StartFrame_(void)
+NOBODY void CCSBotManager::__MAKE_VHOOK(StartFrame)(void)
 {
 
 }
 
 /* <36b62a> ../cstrike/dlls/bot/cs_bot_manager.cpp:276 */
-NOBODY bool CCSBotManager::IsWeaponUseable(CBasePlayerItem *item) const
+bool CCSBotManager::IsWeaponUseable(CBasePlayerItem *item) const
 {
-//	{
+	if (item == NULL)
-//		int weaponClass;                                      //   284
+	{
-//		AllowShotguns(const class CCSBotManager *const this);  //   286
+		return false;
-//	}
+	}
-	return false;
+
+	if (item->m_iId != WEAPON_C4)
+	{
+		int weaponClass = WeaponIDToWeaponClass(item->m_iId);
+
+		if ((!AllowShotguns() && weaponClass == WEAPONCLASS_SHOTGUN)
+			|| (!AllowMachineGuns() && weaponClass == WEAPONCLASS_MACHINEGUN)
+			|| (!AllowRifles() && weaponClass == WEAPONCLASS_RIFLE)
+			//|| (!AllowShotguns() && weaponClass == WEAPONCLASS_SHOTGUN) // TODO: already is checked shotguns!
+			|| (!AllowSnipers() && weaponClass == WEAPONCLASS_SNIPERRIFLE)
+			|| (!AllowSubMachineGuns() && weaponClass == WEAPONCLASS_SUBMACHINEGUN)
+			|| (!AllowTacticalShield() && item->m_iId == WEAPON_SHIELDGUN)
+			|| (!AllowPistols() && weaponClass == WEAPONCLASS_PISTOL)
+			|| (!AllowGrenades() && weaponClass == WEAPONCLASS_GRENADE))
+		{
+			return false;
+		}
+	}
+
+	return true;
 }
 
 /* <36b68c> ../cstrike/dlls/bot/cs_bot_manager.cpp:306 */
@@ -187,7 +206,7 @@ NOBODY bool CCSBotManager::IsOnOffense(CBasePlayer *player) const
 }
 
 /* <36a3b6> ../cstrike/dlls/bot/cs_bot_manager.cpp:331 */
-void CCSBotManager::ServerActivate_(void)
+void CCSBotManager::__MAKE_VHOOK(ServerActivate)(void)
 {
 	DestroyNavigationMap();
 	IMPLEMENT_ARRAY(m_isMapDataLoaded) = false;
@@ -208,7 +227,7 @@ void CCSBotManager::ServerActivate_(void)
 }
 
 /* <36afcd> ../cstrike/dlls/bot/cs_bot_manager.cpp:369 */
-void CCSBotManager::AddServerCommand_(const char *cmd)
+void CCSBotManager::__MAKE_VHOOK(AddServerCommand)(const char *cmd)
 {
 #if defined(HOOK_GAMEDLL) && !defined(REGAMEDLL_UNIT_TESTS)
 	ADD_SERVER_COMMAND((char *)cmd, (xcommand_t)GetOriginalFuncAddrOrDefault("_Z17Bot_ServerCommandv", (void *)Bot_ServerCommand));
@@ -218,7 +237,7 @@ void CCSBotManager::AddServerCommand_(const char *cmd)
 }
 
 /* <36b0e0> ../cstrike/dlls/bot/cs_bot_manager.cpp:375 */
-void CCSBotManager::AddServerCommands_(void)
+void CCSBotManager::__MAKE_VHOOK(AddServerCommands)(void)
 {
 	static bool fFirstTime = true;
 
@@ -274,13 +293,13 @@ void CCSBotManager::AddServerCommands_(void)
 }
 
 /* <36b2ac> ../cstrike/dlls/bot/cs_bot_manager.cpp:413 */
-void CCSBotManager::ServerDeactivate_(void)
+void CCSBotManager::__MAKE_VHOOK(ServerDeactivate)(void)
 {
 	m_bServerActive = false;
 }
 
 /* <36b5fa> ../cstrike/dlls/bot/cs_bot_manager.cpp:415 */
-void CCSBotManager::ClientDisconnect_(CBasePlayer *pPlayer)
+void CCSBotManager::__MAKE_VHOOK(ClientDisconnect)(CBasePlayer *pPlayer)
 {
 	if (!pPlayer || !pPlayer->IsBot())
 		return;
@@ -315,7 +334,7 @@ void PrintAllEntities(void)
 }
 
 /* <36ace2> ../cstrike/dlls/bot/cs_bot_manager.cpp:484 */
-void CCSBotManager::ServerCommand_(const char *pcmd)
+void CCSBotManager::__MAKE_VHOOK(ServerCommand)(const char *pcmd)
 {
 	if (!m_bServerActive || !UTIL_IsGame("czero"))
 		return;
@@ -326,7 +345,6 @@ void CCSBotManager::ServerCommand_(const char *pcmd)
 	if (FStrEq(pcmd, "bot_about"))
 	{
 		Q_sprintf(buffer, "\n--------------------------------------------------------------------------\nThe Official Counter-Strike Bot V%d.%02d\nCreated by Michael S. Booth\nWeb: www.turtlerockstudios.com\\csbot\nE-mail: csbot@turtlerockstudios.com\n--------------------------------------------------------------------------\n\n", CSBOT_VERSION_MAJOR, CSBOT_VERSION_MINOR);
-
 		CONSOLE_ECHO(buffer);
 		HintMessageToAllPlayers(buffer);
 	}
@@ -352,7 +370,7 @@ void CCSBotManager::ServerCommand_(const char *pcmd)
 
 		for (int iIndex = 1; iIndex <= gpGlobals->maxClients; iIndex++)
 		{
-			CBasePlayer *pPlayer = (CBasePlayer *)UTIL_PlayerByIndex( iIndex );
+			CBasePlayer *pPlayer = (CBasePlayer *)UTIL_PlayerByIndex(iIndex);
 
 			if (pPlayer == NULL)
 				continue;
@@ -384,7 +402,7 @@ void CCSBotManager::ServerCommand_(const char *pcmd)
 
 		for (int iIndex = 1; iIndex <= gpGlobals->maxClients; iIndex++)
 		{
-			CBasePlayer *pPlayer = (CBasePlayer *)UTIL_PlayerByIndex( iIndex );
+			CBasePlayer *pPlayer = (CBasePlayer *)UTIL_PlayerByIndex(iIndex);
 
 			if (pPlayer == NULL)
 				continue;
@@ -460,59 +478,59 @@ void CCSBotManager::ServerCommand_(const char *pcmd)
 	{
 		PrintAllEntities();
 	}
-	else if (FStrEq(pcmd, "bot_nav_delete") )
+	else if (FStrEq(pcmd, "bot_nav_delete"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_DELETE;
 	}
-	else if (FStrEq(pcmd, "bot_nav_split") )
+	else if (FStrEq(pcmd, "bot_nav_split"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_SPLIT;
 	}
-	else if (FStrEq(pcmd, "bot_nav_merge") )
+	else if (FStrEq(pcmd, "bot_nav_merge"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_MERGE;
 	}
-	else if (FStrEq(pcmd, "bot_nav_mark") )
+	else if (FStrEq(pcmd, "bot_nav_mark"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_MARK;
 	}
-	else if (FStrEq(pcmd, "bot_nav_begin_area") )
+	else if (FStrEq(pcmd, "bot_nav_begin_area"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_BEGIN_AREA;
 	}
-	else if (FStrEq(pcmd, "bot_nav_end_area") )
+	else if (FStrEq(pcmd, "bot_nav_end_area"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_END_AREA;
 	}
-	else if (FStrEq(pcmd, "bot_nav_connect") )
+	else if (FStrEq(pcmd, "bot_nav_connect"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_CONNECT;
 	}
-	else if (FStrEq(pcmd, "bot_nav_disconnect") )
+	else if (FStrEq(pcmd, "bot_nav_disconnect"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_DISCONNECT;
 	}
-	else if (FStrEq(pcmd, "bot_nav_splice") )
+	else if (FStrEq(pcmd, "bot_nav_splice"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_SPLICE;
 	}
-	else if (FStrEq(pcmd, "bot_nav_crouch") )
+	else if (FStrEq(pcmd, "bot_nav_crouch"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_ATTRIB_CROUCH;
 	}
-	else if (FStrEq(pcmd, "bot_nav_jump") )
+	else if (FStrEq(pcmd, "bot_nav_jump"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_ATTRIB_JUMP;
 	}
-	else if (FStrEq(pcmd, "bot_nav_precise") )
+	else if (FStrEq(pcmd, "bot_nav_precise"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_ATTRIB_PRECISE;
 	}
-	else if (FStrEq(pcmd, "bot_nav_no_jump") )
+	else if (FStrEq(pcmd, "bot_nav_no_jump"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_ATTRIB_NO_JUMP;
 	}
-	else if (FStrEq(pcmd, "bot_nav_analyze") )
+	else if (FStrEq(pcmd, "bot_nav_analyze"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_isAnalysisRequested) = true;
 	}
@@ -591,23 +609,23 @@ void CCSBotManager::ServerCommand_(const char *pcmd)
 			}
 		}
 	}
-	else if (FStrEq(pcmd, "bot_nav_toggle_place_mode") )
+	else if (FStrEq(pcmd, "bot_nav_toggle_place_mode"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_TOGGLE_PLACE_MODE;
 	}
-	else if (FStrEq(pcmd, "bot_nav_place_floodfill") )
+	else if (FStrEq(pcmd, "bot_nav_place_floodfill"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_PLACE_FLOODFILL;
 	}
-	else if (FStrEq(pcmd, "bot_nav_place_pick") )
+	else if (FStrEq(pcmd, "bot_nav_place_pick"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_PLACE_PICK;
 	}
-	else if (FStrEq(pcmd, "bot_nav_toggle_place_painting") )
+	else if (FStrEq(pcmd, "bot_nav_toggle_place_painting"))
 	{
 		IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_TOGGLE_PLACE_PAINTING;
 	}
-	else if (FStrEq(pcmd, "bot_goto_mark") )
+	else if (FStrEq(pcmd, "bot_goto_mark"))
 	{
 		// tell the first bot we find to go to our marked area
 		CNavArea *area = GetMarkedArea();// TODO: reverse me
@@ -633,7 +651,7 @@ void CCSBotManager::ServerCommand_(const char *pcmd)
 			}
 		}
 	}
-	else if (FStrEq(pcmd, "bot_memory_usage") )
+	else if (FStrEq(pcmd, "bot_memory_usage"))
 	{
 		CONSOLE_ECHO("Memory usage:\n");
 		CONSOLE_ECHO("  %d bytes per bot\b", sizeof(CCSBot));
@@ -653,7 +671,7 @@ void CCSBotManager::ServerCommand_(const char *pcmd)
 
 			for (SpotEncounterList::iterator siter = area->m_spotEncounterList.begin(); siter != area->m_spotEncounterList.end(); ++siter)
 			{
-				// TODO: Fix me
+				// TODO: Fix me, this is crashed in HOOK_GAMEDLL
 				SpotEncounter se = (*siter);
 
 				encounterMem += sizeof(SpotEncounter);
@@ -1108,7 +1126,7 @@ NOBODY CNavArea *CCSBotManager::GetRandomAreaInZone(const Zone *zone) const
 }
 
 /* <36b02d> ../cstrike/dlls/bot/cs_bot_manager.cpp:1477 */
-void CCSBotManager::OnEvent_(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+void CCSBotManager::__MAKE_VHOOK(OnEvent)(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
 {
 	switch (event)
 	{
@@ -1147,9 +1165,17 @@ void CCSBotManager::OnEvent_(GameEventType event, CBaseEntity *entity, CBaseEnti
 	CBotManager::OnEvent(event, entity, other);
 }
 
-NOBODY BOOL CCSBotManager::ClientCommand_(CBasePlayer *pPlayer, const char *pcmd)
+BOOL CCSBotManager::__MAKE_VHOOK(ClientCommand)(CBasePlayer *pPlayer, const char *pcmd)
 {
+	// TODO: rly?
+#ifndef REGAMEDLL_FIXES
+	if (pPlayer && UTIL_GetLocalPlayer())
+	{
+		UTIL_GetLocalPlayer();
+	}
+#endif // REGAMEDLL_FIXES
 
+	return FALSE;
 }
 
 /* <36bdb3> ../cstrike/dlls/bot/cs_bot_manager.cpp:1541 */
@@ -1169,14 +1195,14 @@ void CCSBotManager::SetLooseBomb(CBaseEntity *bomb)
 }
 
 /* <36b14d> ../cstrike/dlls/bot/cs_bot_manager.cpp:1565 */
-NOBODY bool CCSBotManager::IsImportantPlayer_(CBasePlayer *player)
+NOBODY bool CCSBotManager::__MAKE_VHOOK(IsImportantPlayer)(CBasePlayer *player)
 {
 //	IsImportantPlayer(const class CCSBotManager *const this,
 //				class CBasePlayer *player);  //  1565
 }
 
 /* <36b1a7> ../cstrike/dlls/bot/cs_bot_manager.cpp:1602 */
-NOBODY unsigned int CCSBotManager::GetPlayerPriority_(CBasePlayer *player) const
+NOBODY unsigned int CCSBotManager::__MAKE_VHOOK(GetPlayerPriority)(CBasePlayer *player) const
 {
 //	{
 //		unsigned int const lowestPriority;                     //  1604

regamedll/dlls/bot/cs_bot_manager.h

@@ -113,7 +113,7 @@ public:
 	CCSBotManager(void);
 public:
 	virtual void ClientDisconnect(CBasePlayer *pPlayer);
-	NOBODY virtual BOOL ClientCommand(CBasePlayer *pPlayer, const char *pcmd);
+	virtual BOOL ClientCommand(CBasePlayer *pPlayer, const char *pcmd);
 
 	virtual void ServerActivate(void);
 	virtual void ServerDeactivate(void);
@@ -357,7 +357,7 @@ public:
 	{
 		return friendlyfire.value != 0;
 	}
-	NOBODY bool IsWeaponUseable(CBasePlayerItem *item) const;
+	bool IsWeaponUseable(CBasePlayerItem *item) const;
 	bool IsDefenseRushing(void) const
 	{
 		return m_isDefenseRushing;

regamedll/dlls/bot/cs_bot_statemachine.cpp

@@ -174,20 +174,20 @@ NOBODY void CCSBot::Attack(CBasePlayer *victim)
 		return;
 
 	// change enemy
-	SetEnemy( victim );
+	SetEnemy(victim);
 
 	// Do not "re-enter" the attack state if we are already attacking
 	if (IsAttacking())
 		return;
 
 	if (IsAtHidingSpot())
-		m_attackState.SetCrouchAndHold( (RANDOM_FLOAT(0, 100) < 60.0f) != 0 );
+		m_attackState.SetCrouchAndHold((RANDOM_FLOAT(0, 100) < 60.0f) != 0);
 	else
-		m_attackState.SetCrouchAndHold( 0 );
+		m_attackState.SetCrouchAndHold(0);
 
 	PrintIfWatched("ATTACK BEGIN (reaction time = %g (+ update time), surprise time = %g, attack delay = %g)\n");
 	m_isAttacking = true;
-	m_attackState.OnEnter( this );// TODO: Reverse me
+	m_attackState.OnEnter(this);// TODO: Reverse me
 
 	// cheat a bit and give the bot the initial location of its victim
 	m_lastEnemyPosition = victim->pev->origin;
@@ -198,7 +198,7 @@ NOBODY void CCSBot::Attack(CBasePlayer *victim)
 	Vector toEnemy = victim->pev->origin - pev->origin;
 	Vector idealAngle;
 
-	idealAngle = UTIL_VecToAngles( toEnemy );
+	idealAngle = UTIL_VecToAngles(toEnemy);
 
 	float deltaYaw = (float)abs(m_lookYaw - idealAngle.y);
 
@@ -213,11 +213,11 @@ NOBODY void CCSBot::Attack(CBasePlayer *victim)
 	float turn = deltaYaw / 180.0f;
 	float accuracy = GetProfile()->GetSkill() / (1.0f + turn);
 
-	SetAimOffset( accuracy );
+	SetAimOffset(accuracy);
 
 	// define time when aim offset will automatically be updated
 	// longer time the more we had to turn (surprise)
-	m_aimOffsetTimestamp = gpGlobals->time + RANDOM_FLOAT( 0.25f + turn, 1.5f );
+	m_aimOffsetTimestamp = gpGlobals->time + RANDOM_FLOAT(0.25f + turn, 1.5f);
 }
 
 /* <3b4416> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:366 */
@@ -253,7 +253,7 @@ NOBODY bool CCSBot::IsDefusingBomb(void) const
 /* <3b44ed> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:411 */
 bool CCSBot::IsHiding(void) const
 {
-	return (m_state == static_cast<const BotState *>( &m_hideState ));
+	return (m_state == static_cast<const BotState *>(&m_hideState));
 }
 
 /* <3b450f> ../cstrike/dlls/bot/cs_bot_statemachine.cpp:423 */

regamedll/dlls/bot/cs_bot_update.cpp

@@ -1,16 +1,11 @@
 #include "precompiled.h"
 
 /* <3c635f> ../cstrike/dlls/bot/cs_bot_update.cpp:26 */
-void CCSBot::Upkeep_(void)
+void CCSBot::__MAKE_VHOOK(Upkeep)(void)
 {
-#ifndef HOOK_GAMEDLL
+	if (IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_isLearningMap) || !IsAlive())
-	if (CCSBotManager::pm_isLearningMap || !IsAlive())
 		return;
-#else
+
-	if ((*CCSBotManager::pm_isLearningMap) || !IsAlive())
-		return;
-#endif // HOOK_GAMEDLL
-	
 	if (m_isRapidFiring)
 		TogglePrimaryAttack();
 
@@ -37,7 +32,7 @@ void CCSBot::Upkeep_(void)
 				if (IsUsingAWP() || IsUsingShotgun() || IsUsingMachinegun() || GetProfile()->GetSkill() < 0.8f
 					|| (IsActiveWeaponRecoilHigh() && !IsUsingPistol() && !IsUsingSniperRifle()))
 				{
-					if (IsEnemyPartVisible( CHEST ))
+					if (IsEnemyPartVisible(CHEST))
 					{
 						// No headshots in this game, go for the chest.
 						aimBlocked = true;
@@ -47,13 +42,13 @@ void CCSBot::Upkeep_(void)
 				if (aimBlocked)
 					m_aimSpot.z -= feetOffset * 0.25f;
 
-				else if (!IsEnemyPartVisible( HEAD ))
+				else if (!IsEnemyPartVisible(HEAD))
 				{
-					if (IsEnemyPartVisible( CHEST ))
+					if (IsEnemyPartVisible(CHEST))
 					{
 						m_aimSpot.z -= feetOffset * 0.5f;
 					}
-					else if (IsEnemyPartVisible( LEFT_SIDE ))
+					else if (IsEnemyPartVisible(LEFT_SIDE))
 					{
 						Vector2D to = (m_enemy->pev->origin - pev->origin).Make2D();
 						to.NormalizeInPlace();
@@ -62,7 +57,7 @@ void CCSBot::Upkeep_(void)
 						m_aimSpot.y += to.x * 16.0f;
 						m_aimSpot.z -= feetOffset * 0.5f;
 					}
-					else if (IsEnemyPartVisible( RIGHT_SIDE ))
+					else if (IsEnemyPartVisible(RIGHT_SIDE))
 					{
 						Vector2D to = (m_enemy->pev->origin - pev->origin).Make2D();
 						to.NormalizeInPlace();
@@ -96,7 +91,7 @@ void CCSBot::Upkeep_(void)
 		{
 			// dont look at spots just in front of our face - it causes erratic view rotation
 			const float tooCloseRange = 100.0f;
-			if ((m_lookAtSpot - pev->origin).IsLengthLessThan( tooCloseRange ))
+			if ((m_lookAtSpot - pev->origin).IsLengthLessThan(tooCloseRange))
 				m_lookAtSpotState = NOT_LOOKING_AT_SPOT;
 		}
 

regamedll/dlls/bot/cs_bot_vision.cpp

@@ -12,17 +12,14 @@ float StayOnLadderLine(CCSBot *me, const CNavLadder *ladder)
 	// move toward ladder mount point
 	switch (faceDir)
 	{
-		case NORTH:
+	case NORTH:
-			return stiffness * (ladder->m_top.x - me->pev->origin.x);
+		return stiffness * (ladder->m_top.x - me->pev->origin.x);
-
+	case EAST:
-		case EAST:
+		return stiffness * (ladder->m_top.y - me->pev->origin.y);
-			return stiffness * (ladder->m_top.y - me->pev->origin.y);
+	case SOUTH:
-
+		return -stiffness * (ladder->m_top.x - me->pev->origin.x);
-		case SOUTH:
+	case WEST:
-			return -stiffness * (ladder->m_top.x - me->pev->origin.x);
+		return -stiffness * (ladder->m_top.y - me->pev->origin.y);
-
-		case WEST:
-			return -stiffness * (ladder->m_top.y - me->pev->origin.y);
 	}
 
 	return 0.0f;
@@ -175,7 +172,7 @@ void __declspec(naked) CCSBot::UpdateLookAngles(void)
 }
 
 /* <3d8c91> ../cstrike/dlls/bot/cs_bot_vision.cpp:238 */
-NOBODY bool CCSBot::IsVisible_(const Vector *pos, bool testFOV) const
+NOBODY bool CCSBot::__MAKE_VHOOK(IsVisible)(const Vector *pos, bool testFOV) const
 {
 //	{
 //		const Vector *eye;                            //   248
@@ -187,7 +184,7 @@ NOBODY bool CCSBot::IsVisible_(const Vector *pos, bool testFOV) const
 }
 
 /* <3d8d9b> ../cstrike/dlls/bot/cs_bot_vision.cpp:269 */
-NOBODY bool CCSBot::IsVisible_(CBasePlayer *player, bool testFOV, unsigned char *visParts) const
+NOBODY bool CCSBot::__MAKE_VHOOK(IsVisible)(CBasePlayer *player, bool testFOV, unsigned char *visParts) const
 {
 //	{
 //		float const topOfHead;                                 //   271
@@ -207,7 +204,7 @@ NOBODY bool CCSBot::IsVisible_(CBasePlayer *player, bool testFOV, unsigned char
 }
 
 /* <3d8f9f> ../cstrike/dlls/bot/cs_bot_vision.cpp:302 */
-bool CCSBot::IsEnemyPartVisible_(VisiblePartType part) const
+bool CCSBot::__MAKE_VHOOK(IsEnemyPartVisible)(VisiblePartType part) const
 {
 	if (!IsEnemyVisible())
 		return false;
@@ -512,7 +509,7 @@ NOBODY float CCSBot::GetRangeToNearestRecognizedEnemy(void)
 }
 
 /* <3da170> ../cstrike/dlls/bot/cs_bot_vision.cpp:1063 */
-NOBODY void CCSBot::Blind_(float duration, float holdTime, float fadeTime, int alpha)
+NOBODY void CCSBot::__MAKE_VHOOK(Blind)(float duration, float holdTime, float fadeTime, int alpha)
 {
 //	Say(BotChatterInterface *const this,
 //		const char *phraseName,

regamedll/dlls/bot/cs_bot_weapon.cpp

@@ -1,489 +1,491 @@
-#include "precompiled.h"
+#include "precompiled.h"
-
+
-/* <3eb434> ../cstrike/dlls/bot/cs_bot_weapon.cpp:17 */
+/* <3eb434> ../cstrike/dlls/bot/cs_bot_weapon.cpp:17 */
-NOBODY void CCSBot::FireWeaponAtEnemy(void)
+NOBODY void CCSBot::FireWeaponAtEnemy(void)
-{
+{
-//	{
+//	{
-//		class CBasePlayer *enemy;                            //    20
+//		class CBasePlayer *enemy;                            //    20
-//		IsUsingSniperRifle(const class CCSBot *const this);  //    29
+//		IsUsingSniperRifle(const class CCSBot *const this);  //    29
-//		{
+//		{
-//			class Vector2D toAimSpot;                     //    47
+//			class Vector2D toAimSpot;                     //    47
-//			float rangeToEnemy;                           //    48
+//			float rangeToEnemy;                           //    48
-//			float yaw;                                    //    50
+//			float yaw;                                    //    50
-//			class Vector2D dir;                           //    51
+//			class Vector2D dir;                           //    51
-//			float onTarget;                               //    53
+//			float onTarget;                               //    53
-//			float const halfSize;                          //    57
+//			float const halfSize;                          //    57
-//			float const halfPI;                            //    60
+//			float const halfPI;                            //    60
-//			float aimTolerance;                           //    61
+//			float aimTolerance;                           //    61
-//			{
+//			{
-//				class CCSBotManager *ctrl;           //    65
+//				class CCSBotManager *ctrl;           //    65
-//				bool doAttack;                        //    67
+//				bool doAttack;                        //    67
-//				IsUsingKnife(const class CCSBot *const this);  //    86
+//				IsUsingKnife(const class CCSBot *const this);  //    86
-//				{
+//				{
-//					float const knifeRange;        //   121
+//					float const knifeRange;        //   121
-//					ForceRun(CCSBot *const this,
+//					ForceRun(CCSBot *const this,
-//						float duration);  //   125
+//						float duration);  //   125
-//					{
+//					{
-//						float const knifeStabChance;     //   142
+//						float const knifeStabChance;     //   142
-//					}
+//					}
-//				}
+//				}
-//				IsUsingPistol(const class CCSBot *const this);  //   157
+//				IsUsingPistol(const class CCSBot *const this);  //   157
-//				{
+//				{
-//					float const closePistolRange;  //   160
+//					float const closePistolRange;  //   160
-//					StartRapidFire(CCSBot *const this);  //   165
+//					StartRapidFire(CCSBot *const this);  //   165
-//				}
+//				}
-//				{
+//				{
-//					float const sprayRange;        //   175
+//					float const sprayRange;        //   175
-//					IsUsingMachinegun(const class CCSBot *const this);  //   176
+//					IsUsingMachinegun(const class CCSBot *const this);  //   176
-//					{
+//					{
-//						float const distantTargetRange;        //   183
+//						float const distantTargetRange;        //   183
-//						IsUsingSniperRifle(const class CCSBot *const this);  //   184
+//						IsUsingSniperRifle(const class CCSBot *const this);  //   184
-//					}
+//					}
-//				}
+//				}
-//			}
+//			}
-//			NormalizeInPlace(Vector2D *const this);  //    48
+//			NormalizeInPlace(Vector2D *const this);  //    48
-//			DotProduct(const class Vector2D &a,
+//			DotProduct(const class Vector2D &a,
-//					const class Vector2D &b);  //    53
+//					const class Vector2D &b);  //    53
-//			IsUsingSniperRifle(const class CCSBot *const this);  //    57
+//			IsUsingSniperRifle(const class CCSBot *const this);  //    57
-//		}
+//		}
-//		IsActiveWeaponReloading(const class CBot *const this);  //    40
+//		IsActiveWeaponReloading(const class CBot *const this);  //    40
-//		GetTimeSinceAcquiredCurrentEnemy(const class CCSBot *const this);  //    33
+//		GetTimeSinceAcquiredCurrentEnemy(const class CCSBot *const this);  //    33
-//		GetSurpriseDelay(const class CCSBot *const this);  //    34
+//		GetSurpriseDelay(const class CCSBot *const this);  //    34
-//		ClearSurpriseDelay(CCSBot *const this);  //    37
+//		ClearSurpriseDelay(CCSBot *const this);  //    37
-//		IsNotMoving(const class CCSBot *const this);  //    29
+//		IsNotMoving(const class CCSBot *const this);  //    29
-//		StopRapidFire(CCSBot *const this);  //    24
+//		StopRapidFire(CCSBot *const this);  //    24
-//	}
+//	}
-}
+}
-
+
-/* <3ea12d> ../cstrike/dlls/bot/cs_bot_weapon.cpp:210 */
+/* <3ea12d> ../cstrike/dlls/bot/cs_bot_weapon.cpp:210 */
-void CCSBot::SetAimOffset(float accuracy)
+void CCSBot::SetAimOffset(float accuracy)
-{
+{
-	// if our accuracy is less than perfect, it will improve as we "focus in" while not rotating our view
+	// if our accuracy is less than perfect, it will improve as we "focus in" while not rotating our view
-	if (accuracy < 1.0f)
+	if (accuracy < 1.0f)
-	{
+	{
-		// if we moved our view, reset our "focus" mechanism
+		// if we moved our view, reset our "focus" mechanism
-		if (IsViewMoving( 100 ))
+		if (IsViewMoving(100.0f))
-			m_aimSpreadTimestamp = gpGlobals->time;
+		{
-
+			m_aimSpreadTimestamp = gpGlobals->time;
-		// focusTime is the time it takes for a bot to "focus in" for very good aim, from 2 to 5 seconds
+		}
-		const float focusTime = max( 5.0f * (1.0f - accuracy), 2.0f );
+
-
+		// focusTime is the time it takes for a bot to "focus in" for very good aim, from 2 to 5 seconds
-		float focusInterval = gpGlobals->time - m_aimSpreadTimestamp;
+		const float focusTime = _max(5.0f * (1.0f - accuracy), 2.0f);
-		float focusAccuracy = focusInterval / focusTime;
+
-
+		float focusInterval = gpGlobals->time - m_aimSpreadTimestamp;
-		// limit how much "focus" will help
+		float focusAccuracy = focusInterval / focusTime;
-		const float maxFocusAccuracy = 0.75f;
+
-
+		// limit how much "focus" will help
-		if (focusAccuracy > maxFocusAccuracy)
+		const float maxFocusAccuracy = 0.75f;
-			focusAccuracy = maxFocusAccuracy;
+
-
+		if (focusAccuracy > maxFocusAccuracy)
-		accuracy = max( accuracy, focusAccuracy );
+			focusAccuracy = maxFocusAccuracy;
-	}
+
-
+		accuracy = _max(accuracy, focusAccuracy);
-	PrintIfWatched("Accuracy = %4.3f\n", accuracy);
+	}
-
+
-	float range = (m_lastEnemyPosition - pev->origin).Length();
+	PrintIfWatched("Accuracy = %4.3f\n", accuracy);
-	const float_precision maxOffset = range * ((float_precision)m_iFOV / DEFAULT_FOV) * 0.1;
+
-	float error = maxOffset * (1 - accuracy);
+	float range = (m_lastEnemyPosition - pev->origin).Length();
-
+	const float_precision maxOffset = range * ((float_precision)m_iFOV / DEFAULT_FOV) * 0.1;
+	float error = maxOffset * (1 - accuracy);
+
 	m_aimOffsetGoal[0] = RANDOM_FLOAT(-error, error);
 	m_aimOffsetGoal[1] = RANDOM_FLOAT(-error, error);
 	m_aimOffsetGoal[2] = RANDOM_FLOAT(-error, error);
 
 	// define time when aim offset will automatically be updated
-	m_aimOffsetTimestamp = gpGlobals->time + RANDOM_FLOAT(0.25, 1);
+	m_aimOffsetTimestamp = gpGlobals->time + RANDOM_FLOAT(0.25, 1);
-}
+}
-
+
-/* <3ea224> ../cstrike/dlls/bot/cs_bot_weapon.cpp:252 */
+/* <3ea224> ../cstrike/dlls/bot/cs_bot_weapon.cpp:252 */
-void CCSBot::UpdateAimOffset(void)
+void CCSBot::UpdateAimOffset(void)
-{
+{
-	if (gpGlobals->time >= m_aimOffsetTimestamp)
+	if (gpGlobals->time >= m_aimOffsetTimestamp)
-	{
+	{
-		SetAimOffset(GetProfile()->GetSkill());
+		SetAimOffset(GetProfile()->GetSkill());
-	}
+	}
-
+
-	// move current offset towards goal offset
+	// move current offset towards goal offset
-	Vector d = m_aimOffsetGoal - m_aimOffset;
+	Vector d = m_aimOffsetGoal - m_aimOffset;
-	const float stiffness = 0.1f;
+	const float stiffness = 0.1f;
-
+
-	m_aimOffset.x += stiffness * d.x;
+	m_aimOffset.x += stiffness * d.x;
-	m_aimOffset.y += stiffness * d.y;
+	m_aimOffset.y += stiffness * d.y;
-	m_aimOffset.z += stiffness * d.z;
+	m_aimOffset.z += stiffness * d.z;
-}
+}
-
+
-/* <3ea2b7> ../cstrike/dlls/bot/cs_bot_weapon.cpp:271 */
+/* <3ea2b7> ../cstrike/dlls/bot/cs_bot_weapon.cpp:271 */
-NOBODY bool CCSBot::AdjustZoom(float range)
+NOBODY bool CCSBot::AdjustZoom(float range)
-{
+{
-//	IsUsingSniperRifle(const class CCSBot *const this);  //   273
+//	IsUsingSniperRifle(const class CCSBot *const this);  //   273
-//	{
+//	{
-//		float const sniperZoomRange;                           //   275
+//		float const sniperZoomRange;                           //   275
-//		float const sniperFarZoomRange;                        //   276
+//		float const sniperFarZoomRange;                        //   276
-//		GetZoomLevel(const class CCSBot *const this);  //   282
+//		GetZoomLevel(const class CCSBot *const this);  //   282
-//		GetZoomLevel(const class CCSBot *const this);  //   291
+//		GetZoomLevel(const class CCSBot *const this);  //   291
-//		GetZoomLevel(const class CCSBot *const this);  //   300
+//		GetZoomLevel(const class CCSBot *const this);  //   300
-//	}
+//	}
-}
+}
-
+
-/* <3e9e2d> ../cstrike/dlls/bot/cs_bot_weapon.cpp:320 */
+/* <3e9e2d> ../cstrike/dlls/bot/cs_bot_weapon.cpp:320 */
-bool isSniperRifle(CBasePlayerItem *item)
+bool isSniperRifle(CBasePlayerItem *item)
-{
+{
-	switch (item->m_iId)
+	switch (item->m_iId)
-	{
+	{
-	case WEAPON_SCOUT:
+	case WEAPON_SCOUT:
-	case WEAPON_SG550:
+	case WEAPON_SG550:
-	case WEAPON_AWP:
+	case WEAPON_AWP:
-	case WEAPON_G3SG1:
+	case WEAPON_G3SG1:
-		break;
+		break;
-	default:
+	default:
-		return false;
+		return false;
-	}
+	}
-
+
-	return true;
+	return true;
-}
+}
-
+
-/* <3ea3ab> ../cstrike/dlls/bot/cs_bot_weapon.cpp:342 */
+/* <3ea3ab> ../cstrike/dlls/bot/cs_bot_weapon.cpp:342 */
-bool CCSBot::IsUsingAWP(void)
+bool CCSBot::IsUsingAWP(void)
-{
+{
-	return (m_pActiveItem && m_pActiveItem->m_iId == WEAPON_AWP);
+	return (m_pActiveItem && m_pActiveItem->m_iId == WEAPON_AWP);
-}
+}
-
+
-/* <3ea3ce> ../cstrike/dlls/bot/cs_bot_weapon.cpp:357 */
+/* <3ea3ce> ../cstrike/dlls/bot/cs_bot_weapon.cpp:357 */
-NOBODY bool CCSBot::DoesActiveWeaponHaveSilencer(void)
+NOBODY bool CCSBot::DoesActiveWeaponHaveSilencer(void)
-{
+{
-}
+}
-
+
-/* <3ea3f1> ../cstrike/dlls/bot/cs_bot_weapon.cpp:375 */
+/* <3ea3f1> ../cstrike/dlls/bot/cs_bot_weapon.cpp:375 */
-bool CCSBot::IsUsingSniperRifle(void)
+bool CCSBot::IsUsingSniperRifle(void)
-{
+{
-	if (m_pActiveItem)
+	if (m_pActiveItem)
-	{
+	{
-		return isSniperRifle(m_pActiveItem);
+		return isSniperRifle(m_pActiveItem);
-	}
+	}
-	return false;
+	return false;
-}
+}
-
+
-/* <3ea462> ../cstrike/dlls/bot/cs_bot_weapon.cpp:387 */
+/* <3ea462> ../cstrike/dlls/bot/cs_bot_weapon.cpp:387 */
-NOBODY bool CCSBot::IsSniper(void)
+NOBODY bool CCSBot::IsSniper(void)
-{
+{
-//	{
+//	{
-//		int i;                                                //   389
+//		int i;                                                //   389
-//		{
+//		{
-//			class CBasePlayerItem *item;                 //   391
+//			class CBasePlayerItem *item;                 //   391
-//			isSniperRifle(CBasePlayerItem *item);  //   393
+//			isSniperRifle(CBasePlayerItem *item);  //   393
-//		}
+//		}
-//	}
+//	}
-}
+}
-
+
-/* <3ea4c1> ../cstrike/dlls/bot/cs_bot_weapon.cpp:405 */
+/* <3ea4c1> ../cstrike/dlls/bot/cs_bot_weapon.cpp:405 */
-NOBODY bool CCSBot::IsSniping(void)
+NOBODY bool CCSBot::IsSniping(void)
-{
+{
-}
+}
-
+
-/* <3ea4e8> ../cstrike/dlls/bot/cs_bot_weapon.cpp:417 */
+/* <3ea4e8> ../cstrike/dlls/bot/cs_bot_weapon.cpp:417 */
-bool CCSBot::IsUsingShotgun(void)
+bool CCSBot::IsUsingShotgun(void)
-{
+{
-	return (m_pActiveItem && (m_pActiveItem->m_iId == WEAPON_XM1014 || m_pActiveItem->m_iId == WEAPON_M3));
+	return (m_pActiveItem && (m_pActiveItem->m_iId == WEAPON_XM1014 || m_pActiveItem->m_iId == WEAPON_M3));
-}
+}
-
+
-/* <3ea50f> ../cstrike/dlls/bot/cs_bot_weapon.cpp:437 */
+/* <3ea50f> ../cstrike/dlls/bot/cs_bot_weapon.cpp:437 */
-bool CCSBot::IsUsingMachinegun(void)
+bool CCSBot::IsUsingMachinegun(void)
-{
+{
-	return (m_pActiveItem && m_pActiveItem->m_iId == WEAPON_M249);
+	return (m_pActiveItem && m_pActiveItem->m_iId == WEAPON_M249);
-}
+}
-
+
-/* <3ea532> ../cstrike/dlls/bot/cs_bot_weapon.cpp:449 */
+/* <3ea532> ../cstrike/dlls/bot/cs_bot_weapon.cpp:449 */
-NOBODY bool CCSBot::IsPrimaryWeaponEmpty(void)
+NOBODY bool CCSBot::IsPrimaryWeaponEmpty(void)
-{
+{
-//	{
+//	{
-//		class CBasePlayerWeapon *gun;                        //   451
+//		class CBasePlayerWeapon *gun;                        //   451
-//	}
+//	}
-}
+}
-
+
-/* <3ea578> ../cstrike/dlls/bot/cs_bot_weapon.cpp:467 */
+/* <3ea578> ../cstrike/dlls/bot/cs_bot_weapon.cpp:467 */
-NOBODY bool CCSBot::IsPistolEmpty(void)
+NOBODY bool CCSBot::IsPistolEmpty(void)
-{
+{
-//	{
+//	{
-//		class CBasePlayerWeapon *gun;                        //   469
+//		class CBasePlayerWeapon *gun;                        //   469
-//	}
+//	}
-}
+}
-
+
-/* <3ea5d9> ../cstrike/dlls/bot/cs_bot_weapon.cpp:485 */
+/* <3ea5d9> ../cstrike/dlls/bot/cs_bot_weapon.cpp:485 */
-NOBODY bool CCSBot::DoEquip(CBasePlayerWeapon *gun)
+NOBODY bool CCSBot::DoEquip(CBasePlayerWeapon *gun)
-{
+{
-//	Start(IntervalTimer *const this);  //   496
+//	Start(IntervalTimer *const this);  //   496
-}
+}
-
+
-/* <3ea621> ../cstrike/dlls/bot/cs_bot_weapon.cpp:510 */
+/* <3ea621> ../cstrike/dlls/bot/cs_bot_weapon.cpp:510 */
-NOBODY void CCSBot::EquipBestWeapon(bool mustEquip)
+NOBODY void CCSBot::EquipBestWeapon(bool mustEquip)
-{
+{
-//	{
+//	{
-//		class CCSBotManager *ctrl;                           //   523
+//		class CCSBotManager *ctrl;                           //   523
-//		class CBasePlayerWeapon *primary;                    //   525
+//		class CBasePlayerWeapon *primary;                    //   525
-//		GetElapsedTime(const class IntervalTimer *const this);  //   513
+//		GetElapsedTime(const class IntervalTimer *const this);  //   513
-//		{
+//		{
-//			int weaponClass;                              //   528
+//			int weaponClass;                              //   528
-//			AllowShotguns(const class CCSBotManager *const this);  //   530
+//			AllowShotguns(const class CCSBotManager *const this);  //   530
-//			DoEquip(CCSBot *const this,
+//			DoEquip(CCSBot *const this,
-//				class CBasePlayerWeapon *gun);  //   538
+//				class CBasePlayerWeapon *gun);  //   538
-//		}
+//		}
-//		DoEquip(CCSBot *const this,
+//		DoEquip(CCSBot *const this,
-//			class CBasePlayerWeapon *gun);  //   545
+//			class CBasePlayerWeapon *gun);  //   545
-//		EquipKnife(CCSBot *const this);  //   550
+//		EquipKnife(CCSBot *const this);  //   550
-//	}
+//	}
-}
+}
-
+
-/* <3ea7fe> ../cstrike/dlls/bot/cs_bot_weapon.cpp:557 */
+/* <3ea7fe> ../cstrike/dlls/bot/cs_bot_weapon.cpp:557 */
-NOBODY void CCSBot::EquipPistol(void)
+NOBODY void CCSBot::EquipPistol(void)
-{
+{
-//	{
+//	{
-//		class CCSBotManager *ctrl;                           //   563
+//		class CCSBotManager *ctrl;                           //   563
-//		GetElapsedTime(const class IntervalTimer *const this);  //   560
+//		GetElapsedTime(const class IntervalTimer *const this);  //   560
-//		IsUsingPistol(const class CCSBot *const this);  //   566
+//		IsUsingPistol(const class CCSBot *const this);  //   566
-//		DoEquip(CCSBot *const this,
+//		DoEquip(CCSBot *const this,
-//			class CBasePlayerWeapon *gun);  //   567
+//			class CBasePlayerWeapon *gun);  //   567
-//	}
+//	}
-}
+}
-
+
-/* <3ea91a> ../cstrike/dlls/bot/cs_bot_weapon.cpp:575 */
+/* <3ea91a> ../cstrike/dlls/bot/cs_bot_weapon.cpp:575 */
-NOBODY void CCSBot::EquipKnife(void)
+NOBODY void CCSBot::EquipKnife(void)
-{
+{
-//	IsUsingKnife(const class CCSBot *const this);  //   581
+//	IsUsingKnife(const class CCSBot *const this);  //   581
-//	EquipKnife(CCSBot *const this);  //   575
+//	EquipKnife(CCSBot *const this);  //   575
-}
+}
-
+
-/* <3ea98b> ../cstrike/dlls/bot/cs_bot_weapon.cpp:589 */
+/* <3ea98b> ../cstrike/dlls/bot/cs_bot_weapon.cpp:589 */
-NOBODY bool CCSBot::HasGrenade(void)
+NOBODY bool CCSBot::HasGrenade(void)
-{
+{
-}
+}
-
+
-/* <3ea9ae> ../cstrike/dlls/bot/cs_bot_weapon.cpp:598 */
+/* <3ea9ae> ../cstrike/dlls/bot/cs_bot_weapon.cpp:598 */
-NOBODY bool CCSBot::EquipGrenade(bool noSmoke)
+NOBODY bool CCSBot::EquipGrenade(bool noSmoke)
-{
+{
-//	IsSniper(const class CCSBot *const this);  //   601
+//	IsSniper(const class CCSBot *const this);  //   601
-//	IsUsingGrenade(const class CCSBot *const this);  //   604
+//	IsUsingGrenade(const class CCSBot *const this);  //   604
-//	HasGrenade(const class CCSBot *const this);  //   607
+//	HasGrenade(const class CCSBot *const this);  //   607
-}
+}
-
+
-/* <3eaa8c> ../cstrike/dlls/bot/cs_bot_weapon.cpp:624 */
+/* <3eaa8c> ../cstrike/dlls/bot/cs_bot_weapon.cpp:624 */
-bool CCSBot::IsUsingKnife(void)
+bool CCSBot::IsUsingKnife(void)
-{
+{
-	CBasePlayerWeapon *gun = (CBasePlayerWeapon *)m_pActiveItem;
+	CBasePlayerWeapon *gun = (CBasePlayerWeapon *)m_pActiveItem;
-	return (gun && gun->m_iId == 29);
+	return (gun && gun->m_iId == 29);
-}
+}
-
+
-/* <3eaac2> ../cstrike/dlls/bot/cs_bot_weapon.cpp:638 */
+/* <3eaac2> ../cstrike/dlls/bot/cs_bot_weapon.cpp:638 */
-bool CCSBot::IsUsingPistol(void)
+bool CCSBot::IsUsingPistol(void)
-{
+{
-	UNTESTED
+	UNTESTED
-
+
-	CBasePlayerWeapon *gun = (CBasePlayerWeapon *)m_pActiveItem;
+	CBasePlayerWeapon *gun = (CBasePlayerWeapon *)m_pActiveItem;
-	if (gun)
+	if (gun)
-	{
+	{
-		switch (gun->m_iId)
+		switch (gun->m_iId)
-		{
+		{
-		case WEAPON_USP:
+		case WEAPON_USP:
-		case WEAPON_GLOCK18:
+		case WEAPON_GLOCK18:
-		case WEAPON_P228:
+		case WEAPON_P228:
-		case WEAPON_DEAGLE:
+		case WEAPON_DEAGLE:
-		case WEAPON_ELITE:
+		case WEAPON_ELITE:
-		case WEAPON_FIVESEVEN:
+		case WEAPON_FIVESEVEN:
-			return true;
+			return true;
-		default:
+		default:
-			break;
+			break;
-		}
+		}
-
+
-		// TODO: check it, from  the dwarf should be used function IsPistol
+		// TODO: check it, from  the dwarf should be used function IsPistol
-//	{
+//	{
-//		class CBasePlayerWeapon *gun;                        //   640
+//		class CBasePlayerWeapon *gun;                        //   640
-//		IsPistol(CBasePlayerWeapon *const this);  //   642
+//		IsPistol(CBasePlayerWeapon *const this);  //   642
-//	}
+//	}
-		//return gun->IsPistol();
+		//return gun->IsPistol();
-	}
+	}
-	return false;
+	return false;
-}
+}
-
+
-/* <3eab09> ../cstrike/dlls/bot/cs_bot_weapon.cpp:652 */
+/* <3eab09> ../cstrike/dlls/bot/cs_bot_weapon.cpp:652 */
-bool CCSBot::IsUsingGrenade(void)
+bool CCSBot::IsUsingGrenade(void)
-{
+{
-	CBasePlayerWeapon *gun = (CBasePlayerWeapon *)m_pActiveItem;
+	CBasePlayerWeapon *gun = (CBasePlayerWeapon *)m_pActiveItem;
-	return (gun && (gun->m_iId == WEAPON_SMOKEGRENADE || gun->m_iId == WEAPON_FLASHBANG || gun->m_iId == WEAPON_HEGRENADE));
+	return (gun && (gun->m_iId == WEAPON_SMOKEGRENADE || gun->m_iId == WEAPON_FLASHBANG || gun->m_iId == WEAPON_HEGRENADE));
-}
+}
-
+
-/* <3eab3f> ../cstrike/dlls/bot/cs_bot_weapon.cpp:672 */
+/* <3eab3f> ../cstrike/dlls/bot/cs_bot_weapon.cpp:672 */
-NOBODY bool CCSBot::IsUsingHEGrenade(void)
+NOBODY bool CCSBot::IsUsingHEGrenade(void)
-{
+{
-//	{
+//	{
-//		class CBasePlayerWeapon *gun;                        //   674
+//		class CBasePlayerWeapon *gun;                        //   674
-//	}
+//	}
-}
+}
-
+
-/* <3eab80> ../cstrike/dlls/bot/cs_bot_weapon.cpp:690 */
+/* <3eab80> ../cstrike/dlls/bot/cs_bot_weapon.cpp:690 */
-void CCSBot::ThrowGrenade(const Vector *target)
+void CCSBot::ThrowGrenade(const Vector *target)
-{
+{
-	if (IsUsingGrenade() && !m_isWaitingToTossGrenade)
+	if (IsUsingGrenade() && !m_isWaitingToTossGrenade)
-	{
+	{
-		const float angleTolerance = 1.0f;
+		const float angleTolerance = 1.0f;
-
+
-		SetLookAt("GrenadeThrow", target, PRIORITY_UNINTERRUPTABLE, 3.0f, false, angleTolerance);
+		SetLookAt("GrenadeThrow", target, PRIORITY_UNINTERRUPTABLE, 3.0f, false, angleTolerance);
-
+
-		m_isWaitingToTossGrenade = true;
+		m_isWaitingToTossGrenade = true;
-		m_tossGrenadeTimer.Start( 3.0f );
+		m_tossGrenadeTimer.Start(3.0f);
-	}
+	}
-}
+}
-
+
-/* <3eac08> ../cstrike/dlls/bot/cs_bot_weapon.cpp:709 */
+/* <3eac08> ../cstrike/dlls/bot/cs_bot_weapon.cpp:709 */
-NOBODY bool CCSBot::FindGrenadeTossPathTarget(const Vector *pos)
+NOBODY bool CCSBot::FindGrenadeTossPathTarget(const Vector *pos)
-{
+{
-//	{
+//	{
-//		int i;                                                //   715
+//		int i;                                                //   715
-//		Vector dir;                                     //   726
+//		Vector dir;                                     //   726
-//		float length;                                         //   727
+//		float length;                                         //   727
-//		float const inc;                                       //   729
+//		float const inc;                                       //   729
-//		Vector p;                                       //   730
+//		Vector p;                                       //   730
-//		Vector visibleSpot;                             //   731
+//		Vector visibleSpot;                             //   731
-//		float const bufferRange;                               //   745
+//		float const bufferRange;                               //   745
-//		TraceResult result;                                   //   747
+//		TraceResult result;                                   //   747
-//		Vector check;                                   //   748
+//		Vector check;                                   //   748
-//		operator+(const Vector *const this,
+//		operator+(const Vector *const this,
-//				const Vector &v);  //   718
+//				const Vector &v);  //   718
-//		operator-(const Vector *const this,
+//		operator-(const Vector *const this,
-//				const Vector &v);  //   726
+//				const Vector &v);  //   726
-//		NormalizeInPlace(Vector *const this);  //   727
+//		NormalizeInPlace(Vector *const this);  //   727
-//		Vector(Vector *const this,
+//		Vector(Vector *const this,
-//			const Vector &v);  //   731
+//			const Vector &v);  //   731
-//		operator+(const Vector *const this,
+//		operator+(const Vector *const this,
-//				const Vector &v);  //   751
+//				const Vector &v);  //   751
-//		{
+//		{
-//			float range;                                  //   756
+//			float range;                                  //   756
-//		}
+//		}
-//		operator+(const Vector *const this,
+//		operator+(const Vector *const this,
-//				const Vector &v);  //   764
+//				const Vector &v);  //   764
-//		{
+//		{
-//			float range;                                  //   769
+//			float range;                                  //   769
-//		}
+//		}
-//		operator+(const Vector *const this,
+//		operator+(const Vector *const this,
-//				const Vector &v);  //   777
+//				const Vector &v);  //   777
-//		{
+//		{
-//			float range;                                  //   782
+//			float range;                                  //   782
-//		}
+//		}
-//		operator+(const Vector *const this,
+//		operator+(const Vector *const this,
-//				const Vector &v);  //   790
+//				const Vector &v);  //   790
-//		{
+//		{
-//			float range;                                  //   795
+//			float range;                                  //   795
-//		}
+//		}
-//		{
+//		{
-//			float t;                                      //   732
+//			float t;                                      //   732
-//			operator*(float fl,
+//			operator*(float fl,
-//					const Vector &v);  //   734
+//					const Vector &v);  //   734
-//			operator+(const Vector *const this,
+//			operator+(const Vector *const this,
-//					const Vector &v);  //   734
+//					const Vector &v);  //   734
-//		}
+//		}
-//	}
+//	}
-}
+}
-
+
-/* <3eaf22> ../cstrike/dlls/bot/cs_bot_weapon.cpp:810 */
+/* <3eaf22> ../cstrike/dlls/bot/cs_bot_weapon.cpp:810 */
-NOBODY void CCSBot::ReloadCheck(void)
+NOBODY void CCSBot::ReloadCheck(void)
-{
+{
-//	{
+//	{
-//		float const safeReloadWaitTime;                        //   812
+//		float const safeReloadWaitTime;                        //   812
-//		float const reloadAmmoRatio;                           //   813
+//		float const reloadAmmoRatio;                           //   813
-//		IsActiveWeaponReloading(const class CBot *const this);  //   819
+//		IsActiveWeaponReloading(const class CBot *const this);  //   819
-//		IsPistolEmpty(const class CCSBot *const this);  //   827
+//		IsPistolEmpty(const class CCSBot *const this);  //   827
-//		IsUsingAWP(const class CCSBot *const this);  //   848
+//		IsUsingAWP(const class CCSBot *const this);  //   848
-//		GetNearbyEnemyCount(const class CCSBot *const this);  //   854
+//		GetNearbyEnemyCount(const class CCSBot *const this);  //   854
-//		{
+//		{
-//			float const hideChance;                        //   857
+//			float const hideChance;                        //   857
-//			{
+//			{
-//				float const safeTime;                  //   861
+//				float const safeTime;                  //   861
-//				GetTimeSinceLastSawEnemy(const class CCSBot *const this);  //   862
+//				GetTimeSinceLastSawEnemy(const class CCSBot *const this);  //   862
-//				{
+//				{
-//					const Vector *spot;   //   865
+//					const Vector *spot;   //   865
-//				}
+//				}
-//			}
+//			}
-//		}
+//		}
-//		GetTimeSinceLastSawEnemy(const class CCSBot *const this);  //   835
+//		GetTimeSinceLastSawEnemy(const class CCSBot *const this);  //   835
-//		IsPistol(CBasePlayerWeapon *const this);  //   827
+//		IsPistol(CBasePlayerWeapon *const this);  //   827
-//	}
+//	}
-}
+}
-
+
-/* <3eb0ac> ../cstrike/dlls/bot/cs_bot_weapon.cpp:885 */
+/* <3eb0ac> ../cstrike/dlls/bot/cs_bot_weapon.cpp:885 */
-NOBODY void CCSBot::SilencerCheck(void)
+NOBODY void CCSBot::SilencerCheck(void)
-{
+{
-//	{
+//	{
-//		float const safeSilencerWaitTime;                      //   887
+//		float const safeSilencerWaitTime;                      //   887
-//		IsActiveWeaponReloading(const class CBot *const this);  //   889
+//		IsActiveWeaponReloading(const class CBot *const this);  //   889
-//		DoesActiveWeaponHaveSilencer(const class CCSBot *const this);  //   892
+//		DoesActiveWeaponHaveSilencer(const class CCSBot *const this);  //   892
-//		GetNearbyEnemyCount(const class CCSBot *const this);  //   896
+//		GetNearbyEnemyCount(const class CCSBot *const this);  //   896
-//		{
+//		{
-//			bool isSilencerOn;                            //   899
+//			bool isSilencerOn;                            //   899
-//			class CBasePlayerWeapon *myGun;              //   901
+//			class CBasePlayerWeapon *myGun;              //   901
-//		}
+//		}
-//	}
+//	}
-}
+}
-
+
-/* <3eb1a9> ../cstrike/dlls/bot/cs_bot_weapon.cpp:926 */
+/* <3eb1a9> ../cstrike/dlls/bot/cs_bot_weapon.cpp:926 */
-NOBODY void CCSBot::OnTouchingWeapon_(CWeaponBox *box)
+NOBODY void CCSBot::__MAKE_VHOOK(OnTouchingWeapon)(CWeaponBox *box)
-{
+{
-//	{
+//	{
-//		class CBasePlayerItem *droppedGun;                   //   929
+//		class CBasePlayerItem *droppedGun;                   //   929
-//		class CBasePlayerWeapon *myGun;                      //   934
+//		class CBasePlayerWeapon *myGun;                      //   934
-//		float const safeTime;                                  //   947
+//		float const safeTime;                                  //   947
-//		GetTimeSinceLastSawEnemy(const class CCSBot *const this);  //   948
+//		GetTimeSinceLastSawEnemy(const class CCSBot *const this);  //   948
-//		{
+//		{
-//			int i;                                        //   952
+//			int i;                                        //   952
-//			{
+//			{
-//				int prefID;                           //   954
+//				int prefID;                           //   954
-//				GetWeaponPreference(const class BotProfile *const this,
+//				GetWeaponPreference(const class BotProfile *const this,
-//							int i);  //   954
+//							int i);  //   954
-//			}
+//			}
-//		}
+//		}
-//	}
+//	}
-}
+}
-
+
-/* <3eb277> ../cstrike/dlls/bot/cs_bot_weapon.cpp:977 */
+/* <3eb277> ../cstrike/dlls/bot/cs_bot_weapon.cpp:977 */
-NOBODY bool CCSBot::IsFriendInLineOfFire(void)
+NOBODY bool CCSBot::IsFriendInLineOfFire(void)
-{
+{
-//	{
+//	{
-//		Vector aimDir;                                  //   981
+//		Vector aimDir;                                  //   981
-//		TraceResult result;                                   //   984
+//		TraceResult result;                                   //   984
-//		Vector target;                                  //   985
+//		Vector target;                                  //   985
-//		operator+(const Vector *const this,
+//		operator+(const Vector *const this,
-//				const Vector &v);  //   980
+//				const Vector &v);  //   980
-//		operator*(float fl,
+//		operator*(float fl,
-//				const Vector &v);  //   985
+//				const Vector &v);  //   985
-//		operator+(const Vector *const this,
+//		operator+(const Vector *const this,
-//				const Vector &v);  //   985
+//				const Vector &v);  //   985
-//		{
+//		{
-//			class CBaseEntity *victim;                   //   990
+//			class CBaseEntity *victim;                   //   990
-//			Instance(edict_t *pent);  //   990
+//			Instance(edict_t *pent);  //   990
-//		}
+//		}
-//	}
+//	}
-}
+}
-
+
-/* <3eb84d> ../cstrike/dlls/bot/cs_bot_weapon.cpp:1009 */
+/* <3eb84d> ../cstrike/dlls/bot/cs_bot_weapon.cpp:1009 */
-NOBODY float CCSBot::ComputeWeaponSightRange(void)
+NOBODY float CCSBot::ComputeWeaponSightRange(void)
-{
+{
-//	{
+//	{
-//		Vector aimDir;                                  //  1013
+//		Vector aimDir;                                  //  1013
-//		TraceResult result;                                   //  1016
+//		TraceResult result;                                   //  1016
-//		Vector target;                                  //  1017
+//		Vector target;                                  //  1017
-//		operator+(const Vector *const this,
+//		operator+(const Vector *const this,
-//				const Vector &v);  //  1012
+//				const Vector &v);  //  1012
-//		operator*(float fl,
+//		operator*(float fl,
-//				const Vector &v);  //  1017
+//				const Vector &v);  //  1017
-//		operator+(const Vector *const this,
+//		operator+(const Vector *const this,
-//				const Vector &v);  //  1017
+//				const Vector &v);  //  1017
-//		operator-(const Vector *const this,
+//		operator-(const Vector *const this,
-//				const Vector &v);  //  1020
+//				const Vector &v);  //  1020
-//		Length(const Vector *const this);  //  1020
+//		Length(const Vector *const this);  //  1020
-//	}
+//	}
-}
+}
-
+
 #ifdef HOOK_GAMEDLL
 
-void CCSBot::OnTouchingWeapon(CWeaponBox *box)
+void CCSBot::OnTouchingWeapon(CWeaponBox *box)
-{
+{
-	OnTouchingWeapon_(box);
+	OnTouchingWeapon_(box);
 }
 
 #endif // HOOK_GAMEDLL

regamedll/dlls/buttons.cpp

@@ -64,7 +64,7 @@ IMPLEMENT_SAVERESTORE(CEnvGlobal, CBaseEntity);
 LINK_ENTITY_TO_CLASS(env_global, CEnvGlobal);
 
 /* <26863> ../cstrike/dlls/buttons.cpp:66 */
-NOBODY void CEnvGlobal::KeyValue_(KeyValueData *pkvd)
+NOBODY void CEnvGlobal::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //    70
@@ -76,14 +76,14 @@ NOBODY void CEnvGlobal::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <26486> ../cstrike/dlls/buttons.cpp:80 */
-NOBODY void CEnvGlobal::Spawn_(void)
+NOBODY void CEnvGlobal::__MAKE_VHOOK(Spawn)(void)
 {
 //	EntityInTable(CGlobalState::Spawn(//			string_t globalname);  //    89
 //	Spawn(CEnvGlobal *const this);  //    80
 }
 
 /* <25ee7> ../cstrike/dlls/buttons.cpp:95 */
-NOBODY void CEnvGlobal::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CEnvGlobal::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		GLOBALESTATE oldState;                                //    97
@@ -100,7 +100,7 @@ IMPLEMENT_SAVERESTORE(CMultiSource, CBaseEntity);
 LINK_ENTITY_TO_CLASS(multisource, CMultiSource);
 
 /* <26d1e> ../cstrike/dlls/buttons.cpp:148 */
-NOBODY void CMultiSource::KeyValue_(KeyValueData *pkvd)
+NOBODY void CMultiSource::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   150
@@ -121,12 +121,12 @@ NOBODY void CMultiSource::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <256e2> ../cstrike/dlls/buttons.cpp:168 */
-NOBODY void CMultiSource::Spawn_(void)
+NOBODY void CMultiSource::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <2633b> ../cstrike/dlls/buttons.cpp:179 */
-NOBODY void CMultiSource::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CMultiSource::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		int i;                                                //   181
@@ -142,7 +142,7 @@ NOBODY void CMultiSource::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, US
 }
 
 /* <26419> ../cstrike/dlls/buttons.cpp:211 */
-NOBODY BOOL CMultiSource::IsTriggered_(CBaseEntity *)
+NOBODY BOOL CMultiSource::__MAKE_VHOOK(IsTriggered)(CBaseEntity *)
 {
 //	{
 //		int i;                                                //   214
@@ -173,7 +173,7 @@ NOBODY void CMultiSource::Register(void)
 IMPLEMENT_SAVERESTORE(CBaseButton, CBaseToggle);
 
 /* <25709> ../cstrike/dlls/buttons.cpp:289 */
-NOBODY void CBaseButton::Precache_(void)
+NOBODY void CBaseButton::__MAKE_VHOOK(Precache)(void)
 {
 //	{
 //		char *pszSound;                                      //   291
@@ -183,7 +183,7 @@ NOBODY void CBaseButton::Precache_(void)
 }
 
 /* <269cb> ../cstrike/dlls/buttons.cpp:355 */
-NOBODY void CBaseButton::KeyValue_(KeyValueData *pkvd)
+NOBODY void CBaseButton::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   357
@@ -195,7 +195,7 @@ NOBODY void CBaseButton::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <26e90> ../cstrike/dlls/buttons.cpp:394 */
-NOBODY int CBaseButton::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+NOBODY int CBaseButton::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 //	{
 //		enum BUTTON_CODE code;                                //   396
@@ -215,7 +215,7 @@ NOBODY int CBaseButton::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttac
 LINK_ENTITY_TO_CLASS(func_button, CBaseButton);
 
 /* <25c2c> ../cstrike/dlls/buttons.cpp:442 */
-NOBODY void CBaseButton::Spawn_(void)
+NOBODY void CBaseButton::__MAKE_VHOOK(Spawn)(void)
 {
 //	{
 //		char *pszSound;                                      //   444
@@ -366,7 +366,7 @@ NOBODY void CBaseButton::ButtonBackHome(void)
 LINK_ENTITY_TO_CLASS(func_rot_button, CRotButton);
 
 /* <25a06> ../cstrike/dlls/buttons.cpp:808 */
-NOBODY void CRotButton::Spawn_(void)
+NOBODY void CRotButton::__MAKE_VHOOK(Spawn)(void)
 {
 //	{
 //		char *pszSound;                                      //   810
@@ -381,7 +381,7 @@ NOBODY void CRotButton::Spawn_(void)
 }
 
 /* <2577a> ../cstrike/dlls/buttons.cpp:878 */
-NOBODY int CMomentaryRotButton::ObjectCaps_(void)
+NOBODY int CMomentaryRotButton::__MAKE_VHOOK(ObjectCaps)(void)
 {
 //	{
 //		int flags;                                            //   880
@@ -395,7 +395,7 @@ IMPLEMENT_SAVERESTORE(CMomentaryRotButton, CBaseToggle);
 LINK_ENTITY_TO_CLASS(momentary_rot_button, CMomentaryRotButton);
 
 /* <25acc> ../cstrike/dlls/buttons.cpp:922 */
-NOBODY void CMomentaryRotButton::Spawn_(void)
+NOBODY void CMomentaryRotButton::__MAKE_VHOOK(Spawn)(void)
 {
 //	{
 //		char *pszSound;                                      //   952
@@ -412,7 +412,7 @@ NOBODY void CMomentaryRotButton::Spawn_(void)
 }
 
 /* <2678f> ../cstrike/dlls/buttons.cpp:958 */
-NOBODY void CMomentaryRotButton::KeyValue_(KeyValueData *pkvd)
+NOBODY void CMomentaryRotButton::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   960
@@ -434,7 +434,7 @@ NOBODY void CMomentaryRotButton::PlaySound(void)
 }
 
 /* <27dc0> ../cstrike/dlls/buttons.cpp:982 */
-NOBODY void CMomentaryRotButton::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CMomentaryRotButton::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	UpdateTarget(CMomentaryRotButton *const this,
 //			float value);  //   987
@@ -514,17 +514,17 @@ LINK_ENTITY_TO_CLASS(env_spark, CEnvSpark);
 LINK_ENTITY_TO_CLASS(env_debris, CEnvSpark);
 
 /* <257b7> ../cstrike/dlls/buttons.cpp:1146 */
-NOBODY void CEnvSpark::Spawn_(void)
+NOBODY void CEnvSpark::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <257de> ../cstrike/dlls/buttons.cpp:1173 */
-NOBODY void CEnvSpark::Precache_(void)
+NOBODY void CEnvSpark::__MAKE_VHOOK(Precache)(void)
 {
 }
 
 /* <26b97> ../cstrike/dlls/buttons.cpp:1183 */
-NOBODY void CEnvSpark::KeyValue_(KeyValueData *pkvd)
+NOBODY void CEnvSpark::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //  1185
@@ -564,12 +564,12 @@ NOBODY void CEnvSpark::SparkStop(CBaseEntity *pActivator, CBaseEntity *pCaller,
 LINK_ENTITY_TO_CLASS(button_target, CButtonTarget);
 
 /* <258ca> ../cstrike/dlls/buttons.cpp:1235 */
-NOBODY void CButtonTarget::Spawn_(void)
+NOBODY void CButtonTarget::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <25fc3> ../cstrike/dlls/buttons.cpp:1246 */
-NOBODY void CButtonTarget::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CButtonTarget::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	Use(CButtonTarget *const this,
 //		class CBaseEntity *pActivator,
@@ -579,7 +579,7 @@ NOBODY void CButtonTarget::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, U
 }
 
 /* <258f1> ../cstrike/dlls/buttons.cpp:1258 */
-NOBODY int CButtonTarget::ObjectCaps_(void)
+NOBODY int CButtonTarget::__MAKE_VHOOK(ObjectCaps)(void)
 {
 //	{
 //		int caps;                                             //  1260
@@ -587,7 +587,7 @@ NOBODY int CButtonTarget::ObjectCaps_(void)
 }
 
 /* <2592e> ../cstrike/dlls/buttons.cpp:1269 */
-NOBODY int CButtonTarget::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+NOBODY int CButtonTarget::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 //	Instance(entvars_t *pev);  //  1271
 }

regamedll/dlls/career_tasks.cpp

@@ -60,7 +60,7 @@ CPreventDefuseTask::CPreventDefuseTask(const char *taskName, GameEventType event
 }
 
 /* <1ef296> ../cstrike/dlls/career_tasks.cpp:147 */
-void CPreventDefuseTask::Reset_(void)
+void CPreventDefuseTask::__MAKE_VHOOK(Reset)(void)
 {
 	m_bombPlantedThisRound = false;
 	m_defuseStartedThisRound = false;
@@ -69,7 +69,7 @@ void CPreventDefuseTask::Reset_(void)
 }
 
 /* <1efbf8> ../cstrike/dlls/career_tasks.cpp:156 */
-void CPreventDefuseTask::OnEvent_(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim)
+void CPreventDefuseTask::__MAKE_VHOOK(OnEvent)(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim)
 {
 	if (IsComplete())
 		return;
@@ -128,27 +128,27 @@ CCareerTask::CCareerTask(const char *taskName, GameEventType event, const char *
 	if (m_isComplete)
 	{
 		MESSAGE_BEGIN(MSG_ALL, gmsgCZCareer);
-		WRITE_STRING("TASKDONE");
+			WRITE_STRING("TASKDONE");
-		WRITE_BYTE(m_id);
+			WRITE_BYTE(m_id);
 		MESSAGE_END();
 	}
 }
 
 /* <1ef211> ../cstrike/dlls/career_tasks.cpp:240 */
-void CCareerTask::Reset_(void)
+void CCareerTask::__MAKE_VHOOK(Reset)(void)
 {
 	m_eventsSeen = 0;
 	m_isComplete = false;
 
 	MESSAGE_BEGIN(MSG_ALL, gmsgCZCareer);
-	WRITE_STRING("TASKUNDONE");
+		WRITE_STRING("TASKUNDONE");
-	WRITE_BYTE(m_id);
+		WRITE_BYTE(m_id);
 	MESSAGE_END();
 
 	MESSAGE_BEGIN(MSG_ALL, gmsgCZCareer);
-	WRITE_STRING("TASKPART");
+		WRITE_STRING("TASKPART");
-	WRITE_BYTE(m_id);
+		WRITE_BYTE(m_id);
-	WRITE_SHORT(m_eventsSeen);
+		WRITE_SHORT(m_eventsSeen);
 	MESSAGE_END();
 }
 
@@ -156,9 +156,9 @@ void CCareerTask::Reset_(void)
 void CCareerTask::SendPartialNotification(void)
 {
 	MESSAGE_BEGIN(MSG_ALL, gmsgCZCareer);
-	WRITE_STRING("TASKPART");
+		WRITE_STRING("TASKPART");
-	WRITE_BYTE(m_id);
+		WRITE_BYTE(m_id);
-	WRITE_SHORT(m_eventsSeen);
+		WRITE_SHORT(m_eventsSeen);
 	MESSAGE_END();
 
 	UTIL_LogPrintf("Career Task Partial %d %d\n", m_id, m_eventsSeen);
@@ -254,14 +254,14 @@ void CCareerTask::OnWeaponInjury(int weaponId, int weaponClassId, bool attackerH
 }
 
 /* <1ef79d> ../cstrike/dlls/career_tasks.cpp:385 */
-void CCareerTask::OnEvent_(GameEventType event, CBasePlayer *pVictim, CBasePlayer *pAttacker)
+void CCareerTask::__MAKE_VHOOK(OnEvent)(GameEventType event, CBasePlayer *pVictim, CBasePlayer *pAttacker)
 {
 	if (m_isComplete)
 		return;
 
 	if (event == m_event)
 	{
-		if ((m_defuser && !pAttacker->m_bIsDefusing) || (m_vip && !pAttacker->m_bIsVIP))
+		if ((m_defuser && !pAttacker->m_bIsDefusing) || (m_vip && !pAttacker->m_bIsVIP))
 			return;
 
 		if (m_rescuer)
@@ -271,32 +271,37 @@ void CCareerTask::OnEvent_(GameEventType event, CBasePlayer *pVictim, CBasePlaye
 
 			while ((hostageEntity = UTIL_FindEntityByClassname(hostageEntity, "hostage_entity")) != NULL)
 			{
-				CHostage *hostage = (CHostage *)hostageEntity;
+				if (hostageEntity->pev->takedamage != DAMAGE_YES)
-
-				if (!hostage || hostage->pev->takedamage != DAMAGE_YES)
 					continue;
 
+				CHostage *hostage = reinterpret_cast<CHostage *>(hostageEntity);
+
 				if (hostage->m_improv)
 				{
 					if (!hostage->IsFollowingSomeone())
+					{
 						continue;
+					}
 				}
-				else if (!hostage->m_hTargetEnt || hostage->m_State != CHostage::FOLLOW)
+				else if (hostage->m_hTargetEnt == NULL || hostage->m_State != CHostage::FOLLOW)
+				{
 					continue;
+				}
 
 				if (hostage->IsValid() && hostage->m_target == pAttacker)
 					++hostages_;
 			}
 
 			if (!hostages_)
+			{
 				return;
+			}
 		}
 
-		if ((m_event != EVENT_KILL || (!m_weaponId && !m_weaponClassId))
+		if (m_event != EVENT_KILL || (!m_weaponId && !m_weaponClassId)
-			&& (m_event != EVENT_HEADSHOT || (!m_weaponId && !m_weaponClassId))
+			&& m_event != EVENT_HEADSHOT || (!m_weaponId && !m_weaponClassId)
-			&& (m_event != EVENT_PLAYER_TOOK_DAMAGE || (!m_weaponId && !m_weaponClassId)))
+			&& m_event != EVENT_PLAYER_TOOK_DAMAGE || (!m_weaponId && !m_weaponClassId))
 		{
-
 			if (m_event == EVENT_ROUND_WIN)
 			{
 				if (!Q_strcmp(m_name, "defendhostages"))
@@ -306,12 +311,7 @@ void CCareerTask::OnEvent_(GameEventType event, CBasePlayer *pVictim, CBasePlaye
 
 					while ((hostageEntity = UTIL_FindEntityByClassname(hostageEntity, "hostage_entity")) != NULL)
 					{
-						CHostage *hostage = (CHostage *)hostageEntity;
+						if (hostageEntity->pev->takedamage != 1.0f && hostageEntity->pev->deadflag != DEAD_DEAD)
-
-						if (!hostage || hostage->IsValid())
-							continue;
-
-						if (hostage->pev->deadflag != DEAD_DEAD)
 							++hostages_;
 					}
 
@@ -342,41 +342,49 @@ void CCareerTask::OnEvent_(GameEventType event, CBasePlayer *pVictim, CBasePlaye
 				}
 				else if (!Q_strcmp(m_name, "winfast"))
 				{
-					if (m_eventsNeeded >= (int)TheCareerTasks->GetRoundElapsedTime())
+					if (m_eventsNeeded >= TheCareerTasks->GetRoundElapsedTime())
 					{
 						m_eventsSeen = m_eventsNeeded;
 						SendPartialNotification();
 					}
 				}
 				else if (IsTaskCompletableThisRound())
+				{
+					++m_eventsSeen;
 					SendPartialNotification();
+				}
+			}
+			else
+			{
+				++m_eventsSeen;
+				SendPartialNotification();
 			}
 		}
 	}
 
-	if (event == m_event && !m_mustLive && (m_eventsSeen >= m_eventsNeeded) && IsTaskCompletableThisRound())
+	if (event == m_event && !m_mustLive && m_eventsSeen >= m_eventsNeeded && IsTaskCompletableThisRound())
 	{
 		CBasePlayer *player = UTIL_GetLocalPlayer();
 		EMIT_SOUND(ENT(player->pev), CHAN_VOICE, "events/task_complete.wav", VOL_NORM, ATTN_NORM); 
-		m_isComplete = true;
 
+		m_isComplete = true;
 		MESSAGE_BEGIN(MSG_ALL, gmsgCZCareer);
-		WRITE_STRING("TASKDONE");
+			WRITE_STRING("TASKDONE");
-		WRITE_BYTE(m_id);
+			WRITE_BYTE(m_id);
 		MESSAGE_END();
 
 		if (TheTutor)
+		{
 			TheTutor->OnEvent(EVENT_CAREER_TASK_DONE);
+		}
 
 		UTIL_LogPrintf("Career Task Done %d\n", m_id);
 
 		if (m_event == EVENT_ROUND_WIN && !Q_strcmp(m_name, "winfast"))
 		{
-			TheCareerTasks->SetFinishedTaskTime( TheCareerTasks->GetRoundElapsedTime() );
+			TheCareerTasks->SetFinishedTaskTime((int)TheCareerTasks->GetRoundElapsedTime());
-			player->SyncRoundTimer();
+			UTIL_GetLocalPlayer()->SyncRoundTimer();
 		}
-
-		return;
 	}
 	else if (event >= EVENT_ROUND_DRAW)
 	{
@@ -387,35 +395,37 @@ void CCareerTask::OnEvent_(GameEventType event, CBasePlayer *pVictim, CBasePlaye
 				m_eventsSeen = 0;
 				SendPartialNotification();
 				m_diedThisRound = true;
-			}
+			}		
 		}
 		else if (m_mustLive)
 		{
-			CBasePlayer *player = UTIL_GetLocalPlayer();
-
 			if (m_eventsSeen >= m_eventsNeeded && !m_diedThisRound && IsTaskCompletableThisRound())
 			{
+				CBasePlayer *player = UTIL_GetLocalPlayer();
 				EMIT_SOUND(ENT(player->pev), CHAN_VOICE, "events/task_complete.wav", VOL_NORM, ATTN_NORM); 
 
 				m_isComplete = true;
 				MESSAGE_BEGIN(MSG_ALL, gmsgCZCareer);
-				WRITE_STRING("TASKDONE");
+					WRITE_STRING("TASKDONE");
-				WRITE_BYTE(m_id);
+					WRITE_BYTE(m_id);
 				MESSAGE_END();
 
 				UTIL_LogPrintf("Career Task Done %d\n", m_id);
 
 				if (m_event == EVENT_ROUND_WIN && !Q_strcmp(m_name, "winfast"))
 				{
-					TheCareerTasks->SetFinishedTaskTime( TheCareerTasks->GetRoundElapsedTime() );
+					TheCareerTasks->SetFinishedTaskTime((signed __int64)(TheCareerTasks->GetRoundElapsedTime()));
-					player->SyncRoundTimer();
+					UTIL_GetLocalPlayer()->SyncRoundTimer();
 				}
 
 				if (TheTutor)
+				{
 					TheTutor->OnEvent(EVENT_CAREER_TASK_DONE);
+				}
 			}
 
 			m_diedThisRound = false;
+
 			if (m_mustLive)
 			{
 				m_eventsSeen = 0;
@@ -509,12 +519,14 @@ void CCareerTaskManager::AddTask(const char *taskName, const char *weaponName, i
 
 				m_tasks.push_back(newTask);
 
-				if (pTaskInfo->event == EVENT_ROUND_WIN && Q_strcmp(taskName, "winfast"))
+				if (pTaskInfo->event == EVENT_ROUND_WIN && !Q_strcmp(taskName, "winfast"))
 				{
 					m_taskTime = eventCount;
 
 					if (isComplete)
-						m_finishedTaskTime = eventCount;
+					{
+						m_finishedTaskTime = eventCount;
+					}
 				}
 
 				return;
@@ -523,8 +535,8 @@ void CCareerTaskManager::AddTask(const char *taskName, const char *weaponName, i
 	}
 
 	MESSAGE_BEGIN(MSG_ALL, gmsgCZCareer);
-	WRITE_STRING("TASKDONE");
+		WRITE_STRING("TASKDONE");
-	WRITE_BYTE(m_nextId);
+		WRITE_BYTE(m_nextId);
 	MESSAGE_END();
 }
 
@@ -532,9 +544,12 @@ void CCareerTaskManager::AddTask(const char *taskName, const char *weaponName, i
 void CCareerTaskManager::HandleEvent(GameEventType event, CBasePlayer *pAttacker, CBasePlayer *pVictim)
 {
 	if (event == EVENT_ROUND_START)
+	{
 		m_roundStartTime = gpGlobals->time;
+		return;
+	}
 
-	else if ((event <= EVENT_ROUND_LOSS && event >= EVENT_ROUND_DRAW) && m_shouldLatchRoundEndMessage)
+	if ((event <= EVENT_ROUND_LOSS && event >= EVENT_ROUND_DRAW) && m_shouldLatchRoundEndMessage)
 	{
 		m_roundEndMessage = event;
 		return;

regamedll/dlls/career_tasks.h

@@ -93,7 +93,7 @@ private:
 	bool m_isComplete;
 	const char *m_name;
 	int m_id;
-	enum GameEventType m_event;
+	GameEventType m_event;
 	int m_eventsNeeded;
 	int m_eventsSeen;
 	bool m_mustLive;

regamedll/dlls/cbase.cpp

@@ -67,6 +67,16 @@ static NEW_DLL_FUNCTIONS gNewDLLFunctions
 	NULL
 };
 
+// Global Savedata for Delay
+TYPEDESCRIPTION	CBaseEntity::m_SaveData[] = 
+{
+	DEFINE_FIELD(CBaseEntity, m_pGoalEnt, FIELD_CLASSPTR),
+	DEFINE_FIELD(CBaseEntity, m_pfnThink, FIELD_FUNCTION),	// UNDONE: Build table of these!!!
+	DEFINE_FIELD(CBaseEntity, m_pfnTouch, FIELD_FUNCTION),
+	DEFINE_FIELD(CBaseEntity, m_pfnUse, FIELD_FUNCTION),
+	DEFINE_FIELD(CBaseEntity, m_pfnBlocked, FIELD_FUNCTION),
+};
+
 CMemoryPool hashItemMemPool(sizeof(hash_item_t), 64);
 BOOL gTouchDisabled = FALSE;
 
@@ -74,6 +84,7 @@ BOOL gTouchDisabled = FALSE;
 
 DLL_FUNCTIONS gFunctionTable;
 NEW_DLL_FUNCTIONS gNewDLLFunctions;
+TYPEDESCRIPTION	IMPLEMENT_ARRAY_CLASS(CBaseEntity, m_SaveData)[5];
 
 CMemoryPool hashItemMemPool;
 BOOL gTouchDisabled;
@@ -84,8 +95,11 @@ BOOL gTouchDisabled;
 int CaseInsensitiveHash(const char *string, int iBounds)
 {
 	unsigned int hash = 0;
-	if (!*string)
+
+	if (!string[0])
+	{
 		return 0;
+	}
 
 	while (*string)
 	{
@@ -272,18 +286,22 @@ void RemoveEntityHashValue(entvars_t *pev, const char *value, hash_types_e field
 }
 
 /* <31125> ../cstrike/dlls/cbase.cpp:337 */
-NOBODY void printEntities(void)
+void printEntities(void)
-{
+{
-//	{ 
+	for (int i = 0; i < stringsHashTable.Count(); i++)
-//		int i;                                                //   339
+	{
-//		{
+		hash_item_t *item = &stringsHashTable[i];
-//			class hash_item_t *item;                     //   345
+
-//			operator[](CUtlVector<hash_item_t> *const this,
+		if (item->pev)
-//					int i);  //   341
+		{
-//			ENTINDEX(edict_t *pEdict);  //   343
+			UTIL_LogPrintf("Print: %s %i %p\n", STRING(stringsHashTable[i].pev->classname), ENTINDEX(ENT(item->pev)), item->pev);
-//			ENTINDEX(edict_t *pEdict);  //   348
+		}
-//		} 
+
-//	} 
+		for (item = stringsHashTable[i].next; item; item = item->next)
+		{
+			UTIL_LogPrintf("Print: %s %i %p\n", STRING(item->pev->classname), ENTINDEX(ENT(item->pev)), item->pev);
+		}
+	}
 }
 
 /* <311e9> ../cstrike/dlls/cbase.cpp:354 */
@@ -303,33 +321,69 @@ void REMOVE_ENTITY(edict_t *e)
 }
 
 /* <30158> ../cstrike/dlls/cbase.cpp:375 */
-//NOBODY void CONSOLE_ECHO(char *pszMsg, ...)
+void CONSOLE_ECHO_(char *pszMsg, ...)
-//{
+{
-//	{ 
+	va_list argptr;
-//		va_list argptr;                                       //   377
+	static char szStr[1024];
-//		char szStr;                                           //   378
+
-//	} 
+	va_start(argptr, pszMsg);
-//}
+	vsprintf(szStr, pszMsg, argptr);
+	va_end(argptr);
+
+	SERVER_PRINT(szStr);
+}
 
 /* <31273> ../cstrike/dlls/cbase.cpp:386 */
-NOBODY void loopPerformance(void)
+void loopPerformance(void)
 {
-//	{
+	CPerformanceCounter loopCounter;
-//		class CPerformanceCounter loopCounter;                //   390
+	loopCounter.InitializePerformanceCounter();
-//		double start;                                         //   393
+
-//		int i;                                                //   395
+	double start, end;
-//		double end;                                           //   419
+	int i;
-//		GetCurTime(CPerformanceCounter *const this);  //   393
+
-//		{ 
+	start = loopCounter.GetCurTime();
-//			class CBaseEntity *pSpot;                    //   398
+
-//		} 
+	for (i = 0; i < 100; i++)
-//		GetCurTime(CPerformanceCounter *const this);  //   419
+	{
-//		GetCurTime(CPerformanceCounter *const this);  //   422
+		CBaseEntity *pSpot;
-//		{ 
+		for (pSpot = UTIL_FindEntityByString_Old(NULL, "classname", "info_player_start"); pSpot != NULL; pSpot = UTIL_FindEntityByString_Old(pSpot, "classname", "info_player_start"))
-//			class CBaseEntity *pSpot;                    //   426
+			;
-//		} 
+
-//		GetCurTime(CPerformanceCounter *const this);  //   447
+		for (pSpot = UTIL_FindEntityByString_Old(NULL, "classname", "info_player_deathmatch"); pSpot != NULL; pSpot = UTIL_FindEntityByString_Old(pSpot, "classname", "info_player_deathmatch"))
-//	} 
+			;
+
+		for (pSpot = UTIL_FindEntityByString_Old(NULL, "classname", "player"); pSpot != NULL; pSpot = UTIL_FindEntityByString_Old(pSpot, "classname", "player"))
+			;
+
+		for (pSpot = UTIL_FindEntityByString_Old(NULL, "classname", "bodyque"); pSpot != NULL; pSpot = UTIL_FindEntityByString_Old(pSpot, "classname", "bodyque"))
+			;
+	}
+
+	end = loopCounter.GetCurTime();
+	CONSOLE_ECHO(" Time in old search loop %.4f\n", (end - start) * 1000.0);
+
+	// check time new search loop
+	start = loopCounter.GetCurTime();
+
+	for (i = 0; i < 100; i++)
+	{
+		CBaseEntity *pSpot;
+		for (pSpot = UTIL_FindEntityByString(NULL, "classname", "info_player_start"); pSpot != NULL; pSpot = UTIL_FindEntityByString(pSpot, "classname", "info_player_start"))
+			;
+
+		for (pSpot = UTIL_FindEntityByString(NULL, "classname", "info_player_deathmatch"); pSpot != NULL; pSpot = UTIL_FindEntityByString(pSpot, "classname", "info_player_deathmatch"))
+			;
+
+		for (pSpot = UTIL_FindEntityByString(NULL, "classname", "player"); pSpot != NULL; pSpot = UTIL_FindEntityByString(pSpot, "classname", "player"))
+			;
+
+		for (pSpot = UTIL_FindEntityByString(NULL, "classname", "bodyque"); pSpot != NULL; pSpot = UTIL_FindEntityByString(pSpot, "classname", "bodyque"))
+			;
+	}
+
+	end = loopCounter.GetCurTime();
+	CONSOLE_ECHO(" Time in new search loop %.4f\n", (end - start) * 1000.0);
 }
 
 /* <313df> ../cstrike/dlls/cbase.cpp:451 */
@@ -340,8 +394,11 @@ C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion
 
 	Q_memcpy(pFunctionTable, &gFunctionTable, sizeof(DLL_FUNCTIONS));
 	stringsHashTable.AddMultipleToTail(2048);
+
 	for (int i = 0; i < stringsHashTable.Count(); i++)
+	{
 		stringsHashTable[i].next = NULL;
+	}
 
 	EmptyEntityHashTable();
 	return 1;
@@ -355,6 +412,7 @@ NOXREF extern "C" C_EXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int
 		*interfaceVersion = INTERFACE_VERSION;
 		return 0;
 	}
+
 	Q_memcpy(pFunctionTable, &gFunctionTable, sizeof(DLL_FUNCTIONS));
 	return 1;
 }
@@ -371,32 +429,65 @@ extern "C" C_EXPORT int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pFunctionTable, in
 	return 1;
 }
 
-int (*pDispatchSpawn)(edict_t *);
-
 /* <30ab0> ../cstrike/dlls/cbase.cpp:498 */
-NOBODY int __declspec(naked) DispatchSpawn(edict_t *pent)
+int DispatchSpawn(edict_t *pent)
 {
-	//Reverse me
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
-	__asm
+
+	if (pEntity != NULL)
 	{
-		jmp pDispatchSpawn;
+		// Initialize these or entities who don't link to the world won't have anything in here
+		pEntity->pev->absmin = pEntity->pev->origin - Vector(1, 1, 1);
+		pEntity->pev->absmax = pEntity->pev->origin + Vector(1, 1, 1);
+		pEntity->Spawn();
+
+		// Try to get the pointer again, in case the spawn function deleted the entity.
+		// UNDONE: Spawn() should really return a code to ask that the entity be deleted, but
+		// that would touch too much code for me to do that right now.
+		pEntity = (CBaseEntity *)GET_PRIVATE(pent);
+
+		if (pEntity)
+		{
+			if (g_pGameRules && !g_pGameRules->IsAllowedToSpawn(pEntity))
+			{
+				// return that this entity should be deleted
+				return -1;
+			}
+
+			if (pEntity->pev->flags & FL_KILLME)
+			{
+				return -1;
+			}
+		}
+
+		// Handle global stuff here
+		if (pEntity && pEntity->pev->globalname)
+		{
+			const globalentity_t *pGlobal = gGlobalState.EntityFromTable(pEntity->pev->globalname);
+
+			if (pGlobal)
+			{
+				// Already dead? delete
+				if (pGlobal->state == GLOBAL_DEAD)
+					return -1;
+
+				else if (!FStrEq(STRING(gpGlobals->mapname), pGlobal->levelName))
+				{
+					// Hasn't been moved to this level yet, wait but stay alive
+					// In this level & not dead, continue on as normal
+					pEntity->MakeDormant();
+				}
+			}
+			else
+			{
+				// Spawned entities default to 'On'
+				gGlobalState.EntityAdd(pEntity->pev->globalname, gpGlobals->mapname, GLOBAL_ON);
+			}
+		}
+
 	}
 
-//	{
+	return 0;
-//		class CBaseEntity *pEntity;                          //   500
-//		GET_PRIVATE(edict_t *pent);  //   500
-//		operator-(const class Vector *const this,
-//				const class Vector &v);  //   505
-//		operator+(const class Vector *const this,
-//				const class Vector &v);  //   506
-//		GET_PRIVATE(edict_t *pent);  //   513
-//		{
-//			const globalentity_t *pGlobal;              //   527
-//			FStrEq(const char *sz1,
-//				const char *sz2);  //   533
-//			MakeDormant(CBaseEntity *const this);  //   534
-//		} 
-//	} 
 }
 
 /* <2e8a0> ../cstrike/dlls/cbase.cpp:549 */
@@ -407,15 +498,23 @@ void DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd)
 
 	EntvarsKeyvalue(VARS(pentKeyvalue), pkvd);
 
+	// If the key was an entity variable, or there's no class set yet, don't look for the object, it may
+	// not exist yet.
 	if (pkvd->fHandled || !pkvd->szClassName)
 		return;
 
+	// Get the actualy entity object
 	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentKeyvalue);
 
-	if (pEntity)
+	if (!pEntity)
-		pEntity->KeyValue(pkvd);
+		return;
+
+	pEntity->KeyValue(pkvd);
 }
 
+// HACKHACK -- this is a hack to keep the node graph entity from "touching" things (like triggers)
+// while it builds the graph
+
 /* <2e7db> ../cstrike/dlls/cbase.cpp:574 */
 void DispatchTouch(edict_t *pentTouched, edict_t *pentOther)
 {
@@ -430,62 +529,93 @@ void DispatchTouch(edict_t *pentTouched, edict_t *pentOther)
 }
 
 /* <2fa9b> ../cstrike/dlls/cbase.cpp:587 */
-NOBODY void DispatchUse(edict_t *pentUsed, edict_t *pentOther)
+void DispatchUse(edict_t *pentUsed, edict_t *pentOther)
 {
-//	{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentUsed);
-//		class CBaseEntity *pEntity;                          //   589
+	CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE(pentOther);
-//		class CBaseEntity *pOther;                           //   590
+	
-//		GET_PRIVATE(edict_t *pent);  //   589
+	if (pEntity && !(pEntity->pev->flags & FL_KILLME))
-//		GET_PRIVATE(edict_t *pent);  //   590
+	{
-//	} 
+		pEntity->Use(pOther, pOther, USE_TOGGLE, 0);
+	}
 }
 
 /* <2fb2f> ../cstrike/dlls/cbase.cpp:596 */
-NOBODY void DispatchThink(edict_t *pent)
+void DispatchThink(edict_t *pent)
 {
-//	{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
-//		class CBaseEntity *pEntity;                          //   598
+
-//		GET_PRIVATE(edict_t *pent);  //   598
+	if (pEntity != NULL)
-//	} 
+	{
+		if ((pEntity->pev->flags & FL_DORMANT))
+		{
+			ALERT(at_error, "Dormant entity %s is thinking!!\n", STRING(pEntity->pev->classname));
+		}	
+		pEntity->Think();
+	}
 }
 
 /* <2fb89> ../cstrike/dlls/cbase.cpp:612 */
-NOBODY void DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther)
+void DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther)
 {
-//	{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pentBlocked);
-//		class CBaseEntity *pEntity;                          //   614
+	CBaseEntity *pOther = (CBaseEntity *)GET_PRIVATE(pentOther);
-//		class CBaseEntity *pOther;                           //   615
+
-//		GET_PRIVATE(edict_t *pent);  //   614
+	if (pEntity != NULL)
-//		GET_PRIVATE(edict_t *pent);  //   615
+	{
-//	} 
+		pEntity->Blocked(pOther);
+	}
 }
 
 /* <2ff56> ../cstrike/dlls/cbase.cpp:621 */
-NOBODY void DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData)
+void DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData)
 {
-//	{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
-//		class CBaseEntity *pEntity;                          //   623
+
-//		GET_PRIVATE(edict_t *pent);  //   623
+	if (pEntity != NULL && pSaveData != NULL)
-//		{
+	{
-//			ENTITYTABLE *pTable;                         //   627
+		ENTITYTABLE *pTable = &pSaveData->pTable[ pSaveData->currentIndex ];
-//			class CSave saveHelper;                       //   646
+
-//			{ 
+		if (pTable->pent != pent)
-//				float delta;                          //   638
+		{
-//			} 
+			ALERT(at_error, "ENTITY TABLE OR INDEX IS WRONG!!!!\n");
-//			CSave(CSave *const this,
+		}
-//				SAVERESTOREDATA *pdata);  //   646
+
-//			~CSave(CSave *const this,
+		if (pEntity->ObjectCaps() & FCAP_DONT_SAVE)
-//				intconst __in_chrg);  //   646
+			return;
-//		} 
+
-//	} 
+		// These don't use ltime & nextthink as times really, but we'll fudge around it.
+		if (pEntity->pev->movetype == MOVETYPE_PUSH)
+		{
+			float_precision delta = pEntity->pev->nextthink - pEntity->pev->ltime;
+			pEntity->pev->ltime = gpGlobals->time;
+			pEntity->pev->nextthink = pEntity->pev->ltime + delta;
+		}
+
+		// Remember entity position for file I/O
+		pTable->location = pSaveData->size;
+
+		// Remember entity class for respawn
+		pTable->classname = pEntity->pev->classname;
+
+		CSave saveHelper(pSaveData);
+		pEntity->Save(saveHelper);
+
+		// Size of entity block is data size written to block
+		pTable->size = pSaveData->size - pTable->location;
+	}
 }
 
+// Find the matching global entity.  Spit out an error if the designer made entities of
+// different classes with the same global name
+
 /* <31697> ../cstrike/dlls/cbase.cpp:656 */
 CBaseEntity *FindGlobalEntity(string_t classname, string_t globalname)
 {
 	edict_t *pent = FIND_ENTITY_BY_STRING(NULL, "globalname", STRING(globalname));
 	CBaseEntity *pReturn = CBaseEntity::Instance(pent);
-	if (pReturn)
+
+	if (pReturn != NULL)
 	{
 		if (!FClassnameIs(pReturn->pev, STRING(classname)))
 		{
@@ -493,88 +623,152 @@ CBaseEntity *FindGlobalEntity(string_t classname, string_t globalname)
 			pReturn = NULL;
 		}
 	}
+
 	return pReturn;
 }
 
 /* <3179c> ../cstrike/dlls/cbase.cpp:673 */
-NOBODY int DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity)
+int DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity)
 {
-//	{
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
-//		class CBaseEntity *pEntity;                          //   675
+
-//		GET_PRIVATE(edict_t *pent);  //   675
+	if (pEntity && pSaveData)
-//		{ 
+	{
-//			entvars_t tmpVars;                            //   679
+		entvars_t tmpVars;
-//			class Vector oldOffset;                       //   680
+		Vector oldOffset;
-//			class CRestore restoreHelper;                 //   682
+		CRestore restoreHelper(pSaveData);
-//			CRestore(CRestore *const this,
+
-//				SAVERESTOREDATA *pdata);  //   682
+		if (globalEntity)
-//			{
+		{
-//				class CRestore tmpRestore;            //   685
+			CRestore tmpRestore(pSaveData);
-//				const globalentity_t *pGlobal;      //   695
+			tmpRestore.PrecacheMode(0);
-//				class CBaseEntity *pNewEntity;       //   706
+			tmpRestore.ReadEntVars("ENTVARS", &tmpVars);
-//				CRestore(CRestore *const this,
+
-//					SAVERESTOREDATA *pdata);  //   685
+			// HACKHACK - reset the save pointers, we're going to restore for real this time
-//				PrecacheMode(CRestore *const this,
+			pSaveData->size = pSaveData->pTable[pSaveData->currentIndex].location;
-//						BOOL mode);  //   686
+			pSaveData->pCurrentData = pSaveData->pBaseData + pSaveData->size;
-//				FStrEq(const char *sz1,
+
-//					const char *sz2);  //   701
+			const globalentity_t *pGlobal = gGlobalState.EntityFromTable(tmpVars.globalname);
-//				SetGlobalMode(CRestore *const this,
+
-//						int global);  //   710
+			// Don't overlay any instance of the global that isn't the latest
-//				operator-(const class Vector *const this,
+			// pSaveData->szCurrentMapName is the level this entity is coming from
-//						const class Vector &v);  //   711
+			// pGlobla->levelName is the last level the global entity was active in.
-//				operator+(const class Vector *const this,
+			// If they aren't the same, then this global update is out of date.
-//						const class Vector &v);  //   711
+			if (!FStrEq(pSaveData->szCurrentMapName, pGlobal->levelName))
-//				~CRestore(CRestore *const this,
+			{
-//						intconst __in_chrg);  //   685
+				return 0;
-//				~CRestore(CRestore *const this,
+			}
-//						intconst __in_chrg);  //   685
+
-//			} 
+			// Compute the new global offset
-//			GET_PRIVATE(edict_t *pent);  //   738
+			oldOffset = pSaveData->vecLandmarkOffset;
-//			{
+			CBaseEntity *pNewEntity = FindGlobalEntity(tmpVars.classname, tmpVars.globalname);
-//				const globalentity_t *pGlobal;      //   752
+
-//				FStrEq(const char *sz1,
+			if (pNewEntity != NULL)
-//					const char *sz2);  //   758
+			{
-//				MakeDormant(CBaseEntity *const this);  //   760
+				// Tell the restore code we're overlaying a global entity from another level
-//			} 
+				// Don't overwrite global fields
-//			~CRestore(CRestore *const this,
+				restoreHelper.SetGlobalMode(1);
-//					intconst __in_chrg);  //   682
+
-//			~CRestore(CRestore *const this,
+				pSaveData->vecLandmarkOffset = (pSaveData->vecLandmarkOffset - pNewEntity->pev->mins) + tmpVars.mins;
-//					intconst __in_chrg);  //   682
+
-//		} 
+				// we're going to restore this data OVER the old entity
-//	} 
+				pEntity = pNewEntity;
+				pent = ENT(pEntity->pev);
+
+				// Update the global table to say that the global definition of this entity should come from this level
+				gGlobalState.EntityUpdate(pEntity->pev->globalname, gpGlobals->mapname);
+			}
+			else
+			{
+				// This entity will be freed automatically by the engine.  If we don't do a restore on a matching entity (below)
+				// or call EntityUpdate() to move it to this level, we haven't changed global state at all.
+
+				return 0;
+			}
+
+		}
+
+		if (pEntity->ObjectCaps() & FCAP_MUST_SPAWN)
+		{
+			pEntity->Restore(restoreHelper);
+			pEntity->Spawn();
+		}
+		else
+		{
+			pEntity->Restore(restoreHelper);
+			pEntity->Precache();
+		}
+
+		// Again, could be deleted, get the pointer again.
+		pEntity = (CBaseEntity *)GET_PRIVATE(pent);
+
+		// Is this an overriding global entity (coming over the transition), or one restoring in a level
+		if (globalEntity)
+		{
+			pSaveData->vecLandmarkOffset = oldOffset;
+
+			if (pEntity != NULL)
+			{
+				UTIL_SetOrigin(pEntity->pev, pEntity->pev->origin);
+				pEntity->OverrideReset();
+			}
+		}
+		else if (pEntity != NULL && pEntity->pev->globalname)
+		{
+			const globalentity_t *pGlobal = gGlobalState.EntityFromTable(pEntity->pev->globalname);
+
+			if (pGlobal != NULL)
+			{
+				// Already dead? delete
+				if (pGlobal->state == GLOBAL_DEAD)
+					return -1;
+
+				else if (!FStrEq(STRING(gpGlobals->mapname), pGlobal->levelName))
+				{
+					// Hasn't been moved to this level yet, wait but stay alive
+					pEntity->MakeDormant();
+				}
+				// In this level & not dead, continue on as normal
+			}
+			else
+			{
+				ALERT(at_error, "Global Entity %s (%s) not in table!!!\n", STRING(pEntity->pev->globalname), STRING(pEntity->pev->classname));
+
+				// Spawned entities default to 'On'
+				gGlobalState.EntityAdd(pEntity->pev->globalname, gpGlobals->mapname, GLOBAL_ON);
+			}
+		}
+	}
+
+	return 0;
 }
 
 /* <2fdcd> ../cstrike/dlls/cbase.cpp:776 */
-NOBODY void DispatchObjectCollsionBox(edict_t *pent)
+void DispatchObjectCollsionBox(edict_t *pent)
 {
-//	{ 
+	CBaseEntity *pEntity = (CBaseEntity *)GET_PRIVATE(pent);
-//		class CBaseEntity *pEntity;                          //   778
+
-//		GET_PRIVATE(edict_t *pent);  //   778
+	if (pEntity != NULL)
-//	} 
+	{
+		pEntity->SetObjectCollisionBox();
+	}
+	else
+		SetObjectCollisionBox(&pent->v);
+
 }
 
 /* <2fe94> ../cstrike/dlls/cbase.cpp:788 */
-NOBODY void SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount)
+void SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount)
 {
-//	{ 
+	CSave saveHelper(pSaveData);
-//		class CSave saveHelper;                               //   790
+	saveHelper.WriteFields(pname, pBaseData, pFields, fieldCount);
-//		CSave(CSave *const this,
-//			SAVERESTOREDATA *pdata);  //   790
-//		~CSave(CSave *const this,
-//			intconst __in_chrg);  //   790
-//	} 
 }
 
 /* <30047> ../cstrike/dlls/cbase.cpp:795 */
-NOBODY void SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount)
+void SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount)
 {
-//	{ 
+	CRestore restoreHelper(pSaveData);
-//		class CRestore restoreHelper;                         //   797
+	restoreHelper.ReadFields(pname, pBaseData, pFields, fieldCount);
-//		CRestore(CRestore *const this,
-//			SAVERESTOREDATA *pdata);  //   797
-//		~CRestore(CRestore *const this,
-//				intconst __in_chrg);  //   797
-//	} 
 }
 
 /* <31a74> ../cstrike/dlls/cbase.cpp:802 */
@@ -632,7 +826,7 @@ CBaseEntity *EHANDLE::operator->(void)
 }
 
 /* <301be> ../cstrike/dlls/cbase.cpp:857 */
-int CBaseEntity::TakeHealth_(float flHealth, int bitsDamageType)
+int CBaseEntity::__MAKE_VHOOK(TakeHealth)(float flHealth, int bitsDamageType)
 {
 	if (pev->takedamage == DAMAGE_NO)
 		return 0;
@@ -649,102 +843,213 @@ int CBaseEntity::TakeHealth_(float flHealth, int bitsDamageType)
 }
 
 /* <305af> ../cstrike/dlls/cbase.cpp:876 */
-NOBODY int CBaseEntity::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+int CBaseEntity::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
-//	{ 
+	Vector vecTemp;
-//		class Vector vecTemp;                                 //   878
+
-//	} 
+	if (pev->takedamage == DAMAGE_NO)
-//	TakeDamage(CBaseEntity *const this,
+		return 0;
-//			entvars_t *pevInflictor,
+
-//			entvars_t *pevAttacker,
+	// UNDONE: some entity types may be immune or resistant to some bitsDamageType
-//			float flDamage,
+	// if Attacker == Inflictor, the attack was a melee or other instant-hit attack.
-//			int bitsDamageType);  //   876
+	// (that is, no actual entity projectile was involved in the attack so use the shooter's origin). 
-	return 0;
+	if (pevAttacker == pevInflictor)	
+	{
+		vecTemp = pevInflictor->origin - (VecBModelOrigin(pev));
+	}
+	else
+	{
+		// an actual missile was involved.
+		vecTemp = pevInflictor->origin - (VecBModelOrigin(pev));
+	}
+
+	// this global is still used for glass and other non-monster killables, along with decals.
+	g_vecAttackDir = vecTemp.Normalize();
+		
+	// save damage based on the target's armor level
+	// figure momentum add (don't let hurt brushes or other triggers move player)
+	if ((!FNullEnt(pevInflictor)) && (pev->movetype == MOVETYPE_WALK || pev->movetype == MOVETYPE_STEP) && (pevAttacker->solid != SOLID_TRIGGER))
+	{
+		Vector vecDir = pev->origin - (pevInflictor->absmin + pevInflictor->absmax) * 0.5;
+		vecDir = vecDir.Normalize();
+
+		float_precision flForce = flDamage * ((32 * 32 * 72.0) / (pev->size.x * pev->size.y * pev->size.z)) * 5;
+		
+		if (flForce > 1000.0) 
+			flForce = 1000.0;
+
+		pev->velocity = pev->velocity + vecDir * flForce;
+	}
+
+	// do the damage
+	pev->health -= flDamage;
+	if (pev->health <= 0)
+	{
+		Killed(pevAttacker, GIB_NORMAL);
+		return 0;
+	}
+
+	return 1;
 }
 
 /* <2fe50> ../cstrike/dlls/cbase.cpp:927 */
-NOBODY void CBaseEntity::Killed_(entvars_t *pevAttacker, int iGib)
+void CBaseEntity::__MAKE_VHOOK(Killed)(entvars_t *pevAttacker, int iGib)
 {
+	pev->takedamage = DAMAGE_NO;
+	pev->deadflag = DEAD_DEAD;
+	UTIL_Remove(this);
 }
 
 /* <2fc1c> ../cstrike/dlls/cbase.cpp:935 */
-NOBODY CBaseEntity *CBaseEntity::GetNextTarget_(void)
+CBaseEntity *CBaseEntity::__MAKE_VHOOK(GetNextTarget)(void)
 {
-//	{
+	if (FStringNull(pev->target))
-//		edict_t *pTarget;                                    //   939
+		return NULL;
-//		FIND_ENTITY_BY_TARGETNAME(edict_t *entStart,
+
-//						const char *pszName);  //   939
+	edict_t *pTarget = FIND_ENTITY_BY_TARGETNAME(NULL, STRING(pev->target));
-//		FNullEnt(const edict_t *pent);  //   940
+
-//		Instance(edict_t *pent);  //   943
+	if (FNullEnt(pTarget))
-//	}
+	{
-	return NULL;
+		return NULL;
+	}
+
+	return Instance(pTarget);
 }
 
 /* <302a6> ../cstrike/dlls/cbase.cpp:958 */
-NOBODY int CBaseEntity::Save(CSave &save)
+int CBaseEntity::__MAKE_VHOOK(Save)(CSave &save)
 {
-//	Save(CBaseEntity *const this,
+	if (save.WriteEntVars("ENTVARS", pev))
-//		class CSave &save);  //   958
+	{
+		return save.WriteFields("BASE", this, IMPLEMENT_ARRAY(m_SaveData), ARRAYSIZE(IMPLEMENT_ARRAY(m_SaveData)));
+	}
+
 	return 0;
 }
 
 /* <30440> ../cstrike/dlls/cbase.cpp:966 */
-NOBODY int CBaseEntity::Restore(CRestore &restore)
+int CBaseEntity::__MAKE_VHOOK(Restore)(CRestore &restore)
 {
-//	{
+	int status;
-//		int status;                                           //   968
+
-//	} 
+	status = restore.ReadEntVars("ENTVARS", pev);
-//	Restore(CBaseEntity *const this,
+
-//		class CRestore &restore);  //   966
+	if (status)
-	return 0;
+	{
+		status = restore.ReadFields("BASE", this, IMPLEMENT_ARRAY(m_SaveData), ARRAYSIZE(IMPLEMENT_ARRAY(m_SaveData)));
+	}
+
+	if (pev->modelindex != 0 && !FStringNull(pev->model))
+	{
+		Vector mins, maxs;
+
+		// Set model is about to destroy these
+		mins = pev->mins;
+		maxs = pev->maxs;
+
+		PRECACHE_MODEL((char *)STRING(pev->model));
+		SET_MODEL(ENT(pev), STRING(pev->model));
+
+		// Reset them
+		UTIL_SetSize(pev, mins, maxs);
+	}
+
+	return status;
 }
 
 /* <2fcf6> ../cstrike/dlls/cbase.cpp:991 */
-NOBODY void SetObjectCollisionBox(entvars_t *pev)
+void SetObjectCollisionBox(entvars_t *pev)
 {
-//	operator+(const class Vector *const this,
+	if ((pev->solid == SOLID_BSP) && (pev->angles.x || pev->angles.y || pev->angles.z))
-//			const class Vector &v);  //  1017
+	{
-//	operator+(const class Vector *const this,
+		// expand for rotation
-//			const class Vector &v);  //  1018
+		float_precision max, v;
-//	{ 
+		int i;
-//		float max;                                            //   996
+
-//		float v;                                              //   996
+		max = 0;
-//		int i;                                                //   997
+		for (i = 0 ; i < 3 ; i++)
-//		fabs(double __x);  //  1002
+		{
-//		fabs(double __x);  //  1005
+			v = fabs((float_precision)((float *)pev->mins)[i]);
-//	} 
+			if (v > max)
+			{
+				max = v;
+			}
+
+			v = fabs((float_precision)((float *)pev->maxs)[i]);
+			if (v > max)
+			{
+				max = v;
+			}
+		}
+		for (i = 0; i < 3; i++)
+		{
+			((float *)pev->absmin)[i] = ((float *)pev->origin)[i] - max;
+			((float *)pev->absmax)[i] = ((float *)pev->origin)[i] + max;
+		}
+	}
+	else
+	{
+		pev->absmin = pev->origin + pev->mins;
+		pev->absmax = pev->origin + pev->maxs;
+	}
+
+	pev->absmin.x -= 1;
+	pev->absmin.y -= 1;
+	pev->absmin.z -= 1;
+
+	pev->absmax.x += 1;
+	pev->absmax.y += 1;
+	pev->absmax.z += 1;
 }
 
 /* <2fe2a> ../cstrike/dlls/cbase.cpp:1030 */
-NOBODY void CBaseEntity::SetObjectCollisionBox(void)
+void CBaseEntity::__MAKE_VHOOK(SetObjectCollisionBox)(void)
 {
 	::SetObjectCollisionBox(pev);
 }
 
 /* <31c0e> ../cstrike/dlls/cbase.cpp:1036 */
-NOBODY int CBaseEntity::Intersects(CBaseEntity *pOther)
+int CBaseEntity::Intersects(CBaseEntity *pOther)
 {
+	if (pOther->pev->absmin.x > pev->absmax.x
+		|| pOther->pev->absmin.y > pev->absmax.y
+		|| pOther->pev->absmin.z > pev->absmax.z
+		|| pOther->pev->absmax.x < pev->absmin.x
+		|| pOther->pev->absmax.y < pev->absmin.y
+		|| pOther->pev->absmax.z < pev->absmin.z)
+		 return 0;
+	return 1;
 }
 
 /* <31c43> ../cstrike/dlls/cbase.cpp:1048 */
 void CBaseEntity::MakeDormant(void)
 {
 	pev->flags |= FL_DORMANT;
+
+	// Don't touch
 	pev->solid = SOLID_NOT;
+
+	// Don't move
 	pev->movetype = MOVETYPE_NONE;
+
+	// Don't draw
 	pev->effects |= EF_NODRAW;
+
+	// Don't think
 	pev->nextthink = 0;
+
+	// Relink
 	UTIL_SetOrigin(pev, pev->origin);
 }
 
 /* <31c66> ../cstrike/dlls/cbase.cpp:1064 */
-NOBODY int CBaseEntity::IsDormant(void)
+int CBaseEntity::IsDormant(void)
 {
 	return (pev->flags & FL_DORMANT) == FL_DORMANT;
 }
 
 /* <30221> ../cstrike/dlls/cbase.cpp:1069 */
-BOOL CBaseEntity::IsInWorld_(void)
+BOOL CBaseEntity::__MAKE_VHOOK(IsInWorld)(void)
 {
 	// position
 	if (pev->origin.x >= 4096.0 || pev->origin.y >= 4096.0 || pev->origin.z >= 4096.0)
@@ -781,13 +1086,20 @@ int CBaseEntity::ShouldToggle(USE_TYPE useType, BOOL currentState)
 }
 
 /* <30258> ../cstrike/dlls/cbase.cpp:1100 */
-NOBODY int CBaseEntity::DamageDecal_(int bitsDamageType)
+int CBaseEntity::__MAKE_VHOOK(DamageDecal)(int bitsDamageType)
 {
-//	DamageDecal(CBaseEntity *const this,
+	if (pev->rendermode == kRenderTransAlpha)
-//			int bitsDamageType);  //  1100
+		return -1;
-	return 0;
+
+	if (pev->rendermode != kRenderNormal)
+		return DECAL_BPROOF1;
+
+	return DECAL_GUNSHOT1 + RANDOM_LONG(0, 4);
 }
 
+// NOTE: szName must be a pointer to constant memory, e.g. "monster_class" because the entity
+// will keep a pointer to it after this call.
+
 /* <31cd1> ../cstrike/dlls/cbase.cpp:1115 */
 CBaseEntity *CBaseEntity::Create(char *szName, const Vector &vecOrigin, const Vector &vecAngles, edict_t *pentOwner)
 {
@@ -813,7 +1125,7 @@ CBaseEntity *CBaseEntity::Create(char *szName, const Vector &vecOrigin, const Ve
 }
 
 /* <30885> ../cstrike/dlls/cbase.cpp:1134 */
-NOBODY void OnFreeEntPrivateData(edict_t *pEnt)
+void OnFreeEntPrivateData(edict_t *pEnt)
 {
 	CBaseEntity *pEntity = CBaseEntity::Instance(pEnt);
 	if (!pEntity)
@@ -824,6 +1136,21 @@ NOBODY void OnFreeEntPrivateData(edict_t *pEnt)
 }
 
 #ifdef HOOK_GAMEDLL
+
+int CBaseEntity::Save(CSave &save)
+{
+	return Save_(save);
+}
+
+int CBaseEntity::Restore(CRestore &restore)
+{
+	return Restore_(restore);
+}
+
+void CBaseEntity::SetObjectCollisionBox(void)
+{
+	SetObjectCollisionBox_();
+}
 
 void CBaseEntity::TraceAttack(entvars_t *pevAttacker,float flDamage,Vector vecDir,TraceResult *ptr,int bitsDamageType)
 {

regamedll/dlls/cbase.h

@@ -58,7 +58,7 @@
 #define SetTouch(a)\
 	m_pfnTouch = static_cast<void (CBaseEntity::*)(CBaseEntity *)>(a)
 #define SetUse(a)\
-	m_pfnUse = static_cast<void (CBaseEntity::*)(CBaseEntity *,CBaseEntity *,USE_TYPE,float)>(a)
+	m_pfnUse = static_cast<void (CBaseEntity::*)(CBaseEntity *, CBaseEntity *, USE_TYPE, float)>(a)
 #define SetBlocked(a)\
 	m_pfnBlocked = static_cast<void (CBaseEntity::*)(CBaseEntity *)>(a)
 
@@ -187,6 +187,7 @@
 typedef enum
 {
 	CLASSNAME
+
 } hash_types_e;
 
 typedef struct hash_item_s
@@ -195,6 +196,7 @@ typedef struct hash_item_s
 	struct hash_item_s *next;
 	struct hash_item_s *lastHash;
 	int pevIndex;
+
 } hash_item_t;
 /* size: 16, cachelines: 1, members: 4 */
 
@@ -210,6 +212,7 @@ typedef struct locksounds
 	float flwaitSentence;
 	BYTE bEOFLocked;
 	BYTE bEOFUnlocked;
+
 } locksound_t;
 /* size: 36, cachelines: 1, members: 10 */
 
@@ -226,6 +229,7 @@ typedef enum
 	TRAIN_SAFE,
 	TRAIN_BLOCKING,
 	TRAIN_FOLLOWING
+
 } TRAIN_CODE;
 
 typedef enum
@@ -234,6 +238,7 @@ typedef enum
 	TS_AT_BOTTOM,
 	TS_GOING_UP,
 	TS_GOING_DOWN,
+
 } TOGGLE_STATE;
 
 class CGrenade;
@@ -342,10 +347,7 @@ public:
 		return FCAP_ACROSS_TRANSITION;
 	}
 	virtual void Activate(void) {}
-	NOBODY virtual void SetObjectCollisionBox(void);
+	virtual void SetObjectCollisionBox(void);
-	//{
-	//	::SetObjectCollisionBox(pev);
-	//}
 	virtual int Classify(void)
 	{
 		return CLASS_NONE;
@@ -355,9 +357,9 @@ public:
 		return DeathNotice_(pevChild);
 	}
 	virtual void TraceAttack(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
-	NOBODY virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
+	virtual int TakeDamage(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
 	virtual int TakeHealth(float flHealth, int bitsDamageType);
-	NOBODY virtual void Killed(entvars_t *pevAttacker, int iGib);
+	virtual void Killed(entvars_t *pevAttacker, int iGib);
 	virtual int BloodColor(void)
 	{
 		return DONT_BLEED;
@@ -402,7 +404,7 @@ public:
 		return (pev->velocity != g_vecZero);
 	}
 	virtual void OverrideReset(void) {}
-	NOBODY virtual int DamageDecal(int bitsDamageType);
+	virtual int DamageDecal(int bitsDamageType);
 	virtual void SetToggleState(int state) {}
 	virtual void StartSneaking(void) {}
 	virtual void StopSneaking(void) {}
@@ -443,7 +445,7 @@ public:
 	{
 		return "";
 	}
-	NOBODY virtual CBaseEntity *GetNextTarget(void);
+	virtual CBaseEntity *GetNextTarget(void);
 	virtual void Think(void)
 	{
 		if (m_pfnThink)
@@ -494,18 +496,14 @@ public:
 		return GETENTITYILLUM(ENT(pev));
 	}
 
-#ifdef _WIN32
-	NOBODY virtual BOOL FVisible(Vector &vecOrigin);
-	NOBODY virtual BOOL FVisible(CBaseEntity *pEntity);
-#else
 	NOBODY virtual BOOL FVisible(CBaseEntity *pEntity);
 	NOBODY virtual BOOL FVisible(Vector &vecOrigin);
-#endif // _WIN32
 
 #ifdef HOOK_GAMEDLL
 
 	int Save_(CSave &save);
 	int Restore_(CRestore &restore);
+	void SetObjectCollisionBox_(void);
 	void DeathNotice_(entvars_t *pevChild) { }
 	void TraceAttack_(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType);
 	int TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType);
@@ -546,16 +544,16 @@ public:
 	void EXPORT SUB_DoNothing(void);
 	void EXPORT SUB_StartFadeOut(void);
 	void EXPORT SUB_FadeOut(void);
-	NOBODY void EXPORT SUB_CallUseToggle(void)
+	void EXPORT SUB_CallUseToggle(void)
 	{
-		Use(this,this,USE_TOGGLE,0);
+		Use(this, this, USE_TOGGLE, 0);
 	}
 	NOBODY int ShouldToggle(USE_TYPE useType, BOOL currentState);
 	NOBODY void FireBullets(ULONG cShots, Vector vecSrc, Vector vecDirShooting, Vector vecSpread, float flDistance, int iBulletType, int iTracerFreq = 4, int iDamage = 0, entvars_t *pevAttacker = NULL);
 	Vector FireBullets3(Vector vecSrc, Vector vecDirShooting, float vecSpread, float flDistance, int iPenetration, int iBulletType, int iDamage, float flRangeModifier, entvars_t *pevAttacker, bool bPistol, int shared_rand = 0);
 	void SUB_UseTargets(CBaseEntity *pActivator, USE_TYPE useType, float value);
-	NOBODY int Intersects(CBaseEntity *pOther);
+	int Intersects(CBaseEntity *pOther);
-	NOXREF void MakeDormant(void);
+	void MakeDormant(void);
 	int IsDormant(void);
 	BOOL IsLockedByMaster(void)
 	{
@@ -577,8 +575,10 @@ public:
 	CBaseMonster *GetMonsterPointer(entvars_t *pevMonster)
 	{
 		CBaseEntity *pEntity = Instance(pevMonster);
-		if (pEntity)
+		if (pEntity != NULL)
+		{
 			return pEntity->MyMonsterPointer();
+		}
 		return NULL;
 	}
 	CBaseMonster *GetMonsterPointer(edict_t *pentMonster)
@@ -765,7 +765,6 @@ public:
 
 	int Save_(CSave &save);
 	int Restore_(CRestore &restore);
-	void HandleAnimEvent_(MonsterEvent_t *pEvent);
 
 #endif // HOOK_GAMEDLL
 
@@ -773,21 +772,23 @@ public:
 	float StudioFrameAdvance(float flInterval = 0.0f);
 	BOOL GetSequenceFlags(void);
 	int LookupActivity(int activity);
-	NOBODY int LookupActivityHeaviest(int activity);
+	int LookupActivityHeaviest(int activity);
 	int LookupSequence(const char *label);
 	void ResetSequenceInfo(void);
-	NOBODY void DispatchAnimEvents(float flFutureInterval = 0.1f);
+	void DispatchAnimEvents(float flFutureInterval = 0.1f);
 	float SetBoneController(int iController, float flValue);
 	void InitBoneControllers(void);
-	NOBODY float SetBlending(int iBlender, float flValue);
+
-	NOBODY void GetBonePosition(int iBone, Vector &origin, Vector &angles);
+	NOXREF float SetBlending(int iBlender, float flValue);
+	NOXREF void GetBonePosition(int iBone, Vector &origin, Vector &angles);
 	NOXREF void GetAutomovement(Vector &origin, Vector &angles, float flInterval = 0.1f);
-	NOBODY int FindTransition(int iEndingSequence, int iGoalSequence, int *piDir);
+	NOXREF int FindTransition(int iEndingSequence, int iGoalSequence, int *piDir);
-	NOBODY void GetAttachment(int iAttachment, Vector &origin, Vector &angles);
+	NOXREF void GetAttachment(int iAttachment, Vector &origin, Vector &angles);
-	NOBODY void SetBodygroup(int iGroup, int iValue);
+	NOXREF void SetBodygroup(int iGroup, int iValue);
-	NOBODY int GetBodygroup(int iGroup);
+	NOXREF int GetBodygroup(int iGroup);
-	NOBODY int ExtractBbox(int sequence, float *mins, float *maxs);
+
-	NOBODY void SetSequenceBox(void);
+	int ExtractBbox(int sequence, float *mins, float *maxs);
+	void SetSequenceBox(void);
 public:
 	static TYPEDESCRIPTION IMPLEMENT_ARRAY(m_SaveData)[5];
 
@@ -932,9 +933,9 @@ public:
 class CWorld: public CBaseEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
 
 #ifdef HOOK_GAMEDLL
 
@@ -950,24 +951,43 @@ public:
 class CDecal: public CBaseEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void KeyValue(KeyValueData *);
+	virtual void KeyValue(KeyValueData *);
+
+#ifdef HOOK_GAMEDLL
+
+	void Spawn_(void);
+	void KeyValue_(KeyValueData *);
+
+#endif // HOOK_GAMEDLL
+
 public:
-	NOBODY void StaticDecal(void);
+	void EXPORT StaticDecal(void);
-	NOBODY void TriggerDecal(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	void EXPORT TriggerDecal(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 };/* size: 152, cachelines: 3, members: 1 */
 
+// Body queue class here.... It's really just CBaseEntity
+
 /* <1d9fd1> ../cstrike/dlls/world.cpp:207 */
 class CCorpse: public CBaseEntity
 {
-	// TODO: back to private
 public:
 	/* <1dabe0> ../cstrike/dlls/world.cpp:209 */
-	virtual int ObjectCaps(void)//_ZN7CCorpse10ObjectCapsEv
+	virtual int ObjectCaps(void)
+	{
+		ObjectCaps_();
+	}
+
+#ifdef HOOK_GAMEDLL
+
+	int ObjectCaps_(void)
 	{
 		return FCAP_DONT_SAVE;
 	}
+
+#endif // HOOK_GAMEDLL
+
 };/* size: 152, cachelines: 3, members: 1 */
 
 /* <170b59> ../cstrike/dlls/sound.cpp:117 */
@@ -1065,7 +1085,6 @@ public:
 template <class T>
 T *GetClassPtr(T *a)
 {
-	T *backup = a;
 	entvars_t *pev = (entvars_t *)a;
 	if (!pev)
 		pev = VARS(CREATE_ENTITY());
@@ -1087,30 +1106,30 @@ int CaseInsensitiveHash(const char *string, int iBounds);
 void EmptyEntityHashTable(void);
 void AddEntityHashValue(entvars_t *pev, const char *value, hash_types_e fieldType);
 void RemoveEntityHashValue(entvars_t *pev, const char *value, hash_types_e fieldType);
-NOBODY void printEntities(void);
+void printEntities(void);
 edict_t *CREATE_NAMED_ENTITY(string_t iClass);
 void REMOVE_ENTITY(edict_t *e);
-//NOBODY void CONSOLE_ECHO(char *pszMsg, ...);	// already declared bot_util.cpp
+void CONSOLE_ECHO_(char *pszMsg, ...);
-NOBODY void loopPerformance(void);
+void loopPerformance(void);
 
 extern "C" C_EXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion);
 NOXREF extern "C" C_EXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion);
 extern "C" C_EXPORT int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion);
 
-NOBODY int DispatchSpawn(edict_t *pent);
+int DispatchSpawn(edict_t *pent);
 void DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd);
 void DispatchTouch(edict_t *pentTouched, edict_t *pentOther);
-NOBODY void DispatchUse(edict_t *pentUsed, edict_t *pentOther);
+void DispatchUse(edict_t *pentUsed, edict_t *pentOther);
-NOBODY void DispatchThink(edict_t *pent);
+void DispatchThink(edict_t *pent);
-NOBODY void DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther);
+void DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther);
-NOBODY void DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData);
+void DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData);
-NOBODY int DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity);
+int DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity);
 CBaseEntity *FindGlobalEntity(string_t classname, string_t globalname);
-NOBODY void DispatchObjectCollsionBox(edict_t *pent);
+void DispatchObjectCollsionBox(edict_t *pent);
-NOBODY void SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+void SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
-NOBODY void SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+void SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
-NOBODY void SetObjectCollisionBox(entvars_t *pev);
+void SetObjectCollisionBox(entvars_t *pev);
-NOBODY void OnFreeEntPrivateData(edict_t *pEnt);
+void OnFreeEntPrivateData(edict_t *pEnt);
 
 #ifdef HOOK_GAMEDLL
 
@@ -1127,7 +1146,6 @@ typedef CBaseEntity *(CBaseEntity::*CBASE_ISTANCE_INT)(int);
 #endif // HOOK_GAMEDLL
 
 //Refs
-extern int (*pDispatchSpawn)(edict_t *);
 extern void (*pCGib__SpawnHeadGib)(void);
 
 #endif // CBASE_H

regamedll/dlls/cdll_dll.h

@@ -39,13 +39,13 @@
 
 #define DEFAULT_FOV			90		// the default field of view
 
-#define HIDEHUD_WEAPONS			(1<<0)
+#define HIDEHUD_WEAPONS			(1 << 0)
-#define HIDEHUD_FLASHLIGHT		(1<<1)
+#define HIDEHUD_FLASHLIGHT		(1 << 1)
-#define HIDEHUD_ALL			(1<<2)
+#define HIDEHUD_ALL			(1 << 2)
-#define HIDEHUD_HEALTH			(1<<3)
+#define HIDEHUD_HEALTH			(1 << 3)
-#define HIDEHUD_TIMER			(1<<4)
+#define HIDEHUD_TIMER			(1 << 4)
-#define HIDEHUD_MONEY			(1<<5)
+#define HIDEHUD_MONEY			(1 << 5)
-#define HIDEHUD_CROSSHAIR		(1<<6)
+#define HIDEHUD_CROSSHAIR		(1 << 6)
 
 #define STATUSICON_HIDE			0
 #define STATUSICON_SHOW			1
@@ -78,17 +78,16 @@
 #define DATA_IUSER3_INBOMBZONE		(1<<2)
 #define DATA_IUSER3_HOLDINGSHIELD	(1<<3)
 
-#define VGUI_MENU_TEAM			2
+#define MENU_KEY_1			(1<<0)
-#define VGUI_MENU_MAPBRIEFING		4
+#define MENU_KEY_2			(1<<1)
-#define VGUI_MENU_CLASS_T		26
+#define MENU_KEY_3			(1<<2)
-#define VGUI_MENU_CLASS_CT		27
+#define MENU_KEY_4			(1<<3)
-#define VGUI_MENU_BUY			28
+#define MENU_KEY_5			(1<<4)
-#define VGUI_MENU_BUY_PISTOL		29
+#define MENU_KEY_6			(1<<5)
-#define VGUI_MENU_BUY_SHOTGUN		30
+#define MENU_KEY_7			(1<<6)
-#define VGUI_MENU_BUY_RIFLE		31
+#define MENU_KEY_8			(1<<7)
-#define VGUI_MENU_BUY_SUBMACHINEGUN	32
+#define MENU_KEY_9			(1<<8)
-#define VGUI_MENU_BUY_MACHINEGUN	33
+#define MENU_KEY_0			(1<<9)
-#define VGUI_MENU_BUY_ITEM		34
 
 #define MAX_AMMO_TYPES			32		// ???
 #define MAX_AMMO_SLOTS			32		// not really slots
@@ -99,6 +98,36 @@
 #define HUD_PRINTCENTER			4
 
 #define WEAPON_SUIT			31
-#define WEAPON_ALLWEAPONS		(~( 1 << WEAPON_SUIT ))
+#define WEAPON_ALLWEAPONS		(~(1 << WEAPON_SUIT))
+
+// custom enum
+enum VGUIMenu
+{
+	VGUI_Menu_Team = 2,
+	VGUI_Menu_MapBriefing = 4,
+
+	VGUI_Menu_Class_T = 26,
+	VGUI_Menu_Class_CT,
+	VGUI_Menu_Buy,
+	VGUI_Menu_Buy_Pistol,
+	VGUI_Menu_Buy_ShotGun,
+	VGUI_Menu_Buy_Rifle,
+	VGUI_Menu_Buy_SubMachineGun,
+	VGUI_Menu_Buy_MachineGun,
+	VGUI_Menu_Buy_Item,
+};
+
+// custom enum
+enum VGUIMenuSlot
+{
+	VGUI_MenuSlot_Buy_Pistol = 1,
+	VGUI_MenuSlot_Buy_ShotGun,
+	VGUI_MenuSlot_Buy_SubMachineGun,
+	VGUI_MenuSlot_Buy_Rifle,
+	VGUI_MenuSlot_Buy_MachineGun,
+	VGUI_MenuSlot_Buy_PrimAmmo,
+	VGUI_MenuSlot_Buy_SecAmmo,
+	VGUI_MenuSlot_Buy_Item,
+};
 
 #endif // CDLL_DLL_H

regamedll/dlls/client.h

@@ -32,6 +32,35 @@
 #pragma once
 #endif
 
+// custom enum
+enum ChooseTeamMenuSlot
+{
+	MENU_SLOT_TEAM_UNDEFINED = -1,
+
+	MENU_SLOT_TEAM_TERRORIST = 1,
+	MENU_SLOT_TEAM_CT,
+	MENU_SLOT_TEAM_VIP,
+
+	MENU_SLOT_TEAM_RANDOM = 5,
+	MENU_SLOT_TEAM_SPECT
+};
+
+// custom enum
+enum BuyItemMenuSlot
+{
+	MENU_SLOT_ITEM_VEST = 1,
+	MENU_SLOT_ITEM_VESTHELM,
+	MENU_SLOT_ITEM_FLASHGREN,
+	MENU_SLOT_ITEM_HEGREN,
+	MENU_SLOT_ITEM_SMOKEGREN,
+	MENU_SLOT_ITEM_NVG,
+	MENU_SLOT_ITEM_DEFUSEKIT,
+	MENU_SLOT_ITEM_SHIELD,
+};
+
+#define CS_NUM_SKIN			4
+#define CZ_NUM_SKIN			5
+
 #define FIELD_ORIGIN0			0
 #define FIELD_ORIGIN1			1
 #define FIELD_ORIGIN2			2
@@ -55,6 +84,7 @@
 typedef struct
 {
 	float m_fTimeEnteredPVS;
+
 } ENTITYPVSSTATUS;
 /* size: 4, cachelines: 1, members: 1 */
 
@@ -63,7 +93,8 @@ typedef struct
 	ENTITYPVSSTATUS m_Status[1380];
 	int headnode;
 	int num_leafs;
-	short int leafnums[MAX_ENT_LEAFS];
+	short int leafnums[ MAX_ENT_LEAFS ];
+
 } PLAYERPVSSTATUS;
 /* size: 5624, cachelines: 88, members: 4 */
 
@@ -71,13 +102,14 @@ typedef struct
 {
 	char name[32];
 	int field;
+
 } entity_field_alias_t;
 /* size: 36, cachelines: 1, members: 2 */
 
 #ifdef HOOK_GAMEDLL
 
-//#define g_flTimeLimit (*pg_flTimeLimit)
+#define g_flTimeLimit (*pg_flTimeLimit)
-//#define g_flResetTime (*pg_flResetTime)
+#define g_flResetTime (*pg_flResetTime)
 #define g_bClientPrintEnable (*pg_bClientPrintEnable)
 
 #define g_PVSStatus (*pg_PVSStatus)
@@ -96,7 +128,7 @@ extern PLAYERPVSSTATUS g_PVSStatus[32];
 
 #ifdef HOOK_GAMEDLL
 
-extern float g_flTimeLimit;
+extern float g_flTimeLimit;// exported
 extern float g_flResetTime;
 extern bool g_bClientPrintEnable;
 extern bool g_skipCareerInitialSpawn;
@@ -113,11 +145,11 @@ extern int g_serveractive;
 extern unsigned short m_usResetDecals;
 extern unsigned short g_iShadowSprite;
 
-NOXREF int CMD_ARGC_(void);
+int CMD_ARGC_(void);
-NOXREF const char *CMD_ARGV_(int i);
+const char *CMD_ARGV_(int i);
 NOXREF void set_suicide_frame(entvars_t *pev);
-NOXREF void TeamChangeUpdate(CBasePlayer *player, int team_id);
+void TeamChangeUpdate(CBasePlayer *player, int team_id);
-NOXREF void BlinkAccount(CBasePlayer *player, int numBlinks);
+void BlinkAccount(CBasePlayer *player, int numBlinks);
 BOOL ClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char *szRejectReason);
 void ClientDisconnect(edict_t *pEntity);
 void respawn(entvars_t *pev, BOOL fCopyCorpse = FALSE);
@@ -125,43 +157,44 @@ void ClientKill(edict_t *pEntity);
 void ShowMenu(CBasePlayer *pPlayer, int bitsValidSlots, int nDisplayTime, BOOL fNeedMore, char *pszText);
 void ShowVGUIMenu(CBasePlayer *pPlayer, int MenuType, int BitMask, char *szOldMenu);
 NOXREF C_DLLEXPORT int CountTeams(void);
-NOBODY void ListPlayers(CBasePlayer *current);
+void ListPlayers(CBasePlayer *current);
 C_DLLEXPORT int CountTeamPlayers(int iTeam);
 void ProcessKickVote(CBasePlayer *pVotingPlayer, CBasePlayer *pKickPlayer);
 TeamName SelectDefaultTeam(void);
 void CheckStartMoney(void);
 void ClientPutInServer(edict_t *pEntity);
 int Q_strlen_(const char *str);
-NOBODY void Host_Say(edict_t *pEntity, int teamonly);
+void Host_Say(edict_t *pEntity, int teamonly);
-NOBODY void DropPrimary(CBasePlayer *pPlayer);
+void DropSecondary(CBasePlayer *pPlayer);
-NOBODY bool CanBuyThis(CBasePlayer *pPlayer, int iWeapon);
+void DropPrimary(CBasePlayer *pPlayer);
-NOBODY void BuyPistol(CBasePlayer *pPlayer, int iSlot);
+bool CanBuyThis(CBasePlayer *pPlayer, int iWeapon);
-NOBODY void BuyShotgun(CBasePlayer *pPlayer, int iSlot);
+void BuyPistol(CBasePlayer *pPlayer, int iSlot);
-NOBODY void BuySubMachineGun(CBasePlayer *pPlayer, int iSlot);
+void BuyShotgun(CBasePlayer *pPlayer, int iSlot);
-NOBODY void BuyWeaponByWeaponID(CBasePlayer *pPlayer, WeaponIdType weaponID);
+void BuySubMachineGun(CBasePlayer *pPlayer, int iSlot);
-NOBODY void BuyRifle(CBasePlayer *pPlayer, int iSlot);
+void BuyWeaponByWeaponID(CBasePlayer *pPlayer, WeaponIdType weaponID);
-NOBODY void BuyMachineGun(CBasePlayer *pPlayer, int iSlot);
+void BuyRifle(CBasePlayer *pPlayer, int iSlot);
-NOBODY void BuyItem(CBasePlayer *pPlayer, int iSlot);
+void BuyMachineGun(CBasePlayer *pPlayer, int iSlot);
-NOBODY void HandleMenu_ChooseAppearance(CBasePlayer *player, int slot);
+void BuyItem(CBasePlayer *pPlayer, int iSlot);
-NOBODY BOOL HandleMenu_ChooseTeam(CBasePlayer *player, int slot);
+void HandleMenu_ChooseAppearance(CBasePlayer *player, int slot);
-NOBODY void Radio1(CBasePlayer *player, int slot);
+BOOL HandleMenu_ChooseTeam(CBasePlayer *player, int slot);
-NOBODY void Radio2(CBasePlayer *player, int slot);
+void Radio1(CBasePlayer *player, int slot);
-NOBODY void Radio3(CBasePlayer *player, int slot);
+void Radio2(CBasePlayer *player, int slot);
-NOBODY bool BuyGunAmmo(CBasePlayer &player, CBasePlayerItem &weapon, bool bBlinkMoney);
+void Radio3(CBasePlayer *player, int slot);
-NOBODY bool BuyAmmo(CBasePlayer *player, int nSlot, bool bBlinkMoney);
+bool BuyGunAmmo(CBasePlayer *player, CBasePlayerItem *weapon, bool bBlinkMoney);
-NOBODY CBaseEntity *EntityFromUserID(int userID);
+bool BuyAmmo(CBasePlayer *player, int nSlot, bool bBlinkMoney);
-NOBODY int CountPlayersInServer(void);
+CBaseEntity *EntityFromUserID(int userID);
-NOBODY BOOL HandleBuyAliasCommands(CBasePlayer *pPlayer, const char *pszCommand);
+NOXREF int CountPlayersInServer(void);
-NOBODY BOOL HandleRadioAliasCommands(CBasePlayer *pPlayer, const char *pszCommand);
+BOOL HandleBuyAliasCommands(CBasePlayer *pPlayer, const char *pszCommand);
-NOBODY void ClientCommand(edict_t *pEntity);
+BOOL HandleRadioAliasCommands(CBasePlayer *pPlayer, const char *pszCommand);
-NOBODY void ClientUserInfoChanged(edict_t *pEntity, char *infobuffer);
+void ClientCommand(edict_t *pEntity);
-NOBODY void ServerDeactivate(void);
+void ClientUserInfoChanged(edict_t *pEntity, char *infobuffer);
+void ServerDeactivate(void);
 void ServerActivate(edict_t *pEdictList, int edictCount, int clientMax);
 void PlayerPreThink(edict_t *pEntity);
 void PlayerPostThink(edict_t *pEntity);
 void ParmsNewLevel(void);
-NOBODY void ParmsChangeLevel(void);
+void ParmsChangeLevel(void);
-NOBODY void StartFrame(void);
+void StartFrame(void);
 void ClientPrecache(void);
 const char *GetGameDescription(void);
 void Sys_Error(const char *error_string);
@@ -170,15 +203,15 @@ void SpectatorConnect(edict_t *pEntity);
 void SpectatorDisconnect(edict_t *pEntity);
 void SpectatorThink(edict_t *pEntity);
 void SetupVisibility(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas);
-NOXREF void ResetPlayerPVS(edict_t *client, int clientnum);
+void ResetPlayerPVS(edict_t *client, int clientnum);
-NOXREF bool CheckPlayerPVSLeafChanged(edict_t *client, int clientnum);
+bool CheckPlayerPVSLeafChanged(edict_t *client, int clientnum);
-NOXREF void MarkEntityInPVS(int clientnum, int entitynum, float time, bool inpvs);
+void MarkEntityInPVS(int clientnum, int entitynum, float time, bool inpvs);
-NOXREF bool CheckEntityRecentlyInPVS(int clientnum, int entitynum, float currenttime);
+bool CheckEntityRecentlyInPVS(int clientnum, int entitynum, float currenttime);
 int AddToFullPack(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet);
 void CreateBaseline(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, Vector player_mins, Vector player_maxs);
-NOXREF void Entity_FieldInit(struct delta_s *pFields);
+void Entity_FieldInit(struct delta_s *pFields);
 void Entity_Encode(struct delta_s *pFields, const unsigned char *from, const unsigned char *to);
-NOXREF void Player_FieldInit(struct delta_s *pFields);
+void Player_FieldInit(struct delta_s *pFields);
 void Player_Encode(struct delta_s *pFields, const unsigned char *from, const unsigned char *to);
 void Custom_Entity_FieldInit(delta_s *pFields);
 void Custom_Encode(struct delta_s *pFields, const unsigned char *from, const unsigned char *to);
@@ -193,9 +226,4 @@ void CreateInstancedBaselines(void);
 int InconsistentFile(const edict_t *player, const char *filename, char *disconnect_message);
 int AllowLagCompensation(void);
 
-// refs
-extern void (*pClientCommand)(edict_t *pEntity);
-extern void (*pHandleMenu_ChooseAppearance)(void);
-extern void (*pHandleMenu_ChooseTeam)(void);
-
 #endif // CLIENT_H

regamedll/dlls/combat.cpp

@@ -2,7 +2,7 @@
 
 #define GERMAN_GIB_COUNT	4
 #define HUMAN_GIB_COUNT		6
-#define ALIEN_GIB_COUNT		4
+#define ALIEN_GIB_COUNT		4
 
 /* <5f4cb> ../cstrike/dlls/combat.cpp:52 */
 void CGib::LimitVelocity(void)
@@ -131,7 +131,7 @@ void CGib::SpawnRandomGibs(entvars_t *pevVictim, int cGibs, int human)
 }
 
 /* <5f58a> ../cstrike/dlls/combat.cpp:263 */
-BOOL CBaseMonster::HasHumanGibs_(void)
+BOOL CBaseMonster::__MAKE_VHOOK(HasHumanGibs)(void)
 {
 	int myClass = Classify();
 
@@ -145,7 +145,7 @@ BOOL CBaseMonster::HasHumanGibs_(void)
 }
 
 /* <5f5ca> ../cstrike/dlls/combat.cpp:278 */
-BOOL CBaseMonster::HasAlienGibs_(void)
+BOOL CBaseMonster::__MAKE_VHOOK(HasAlienGibs)(void)
 {
 	int myClass = Classify();
 	if (myClass == CLASS_ALIEN_MILITARY
@@ -160,7 +160,7 @@ BOOL CBaseMonster::HasAlienGibs_(void)
 }
 
 /* <5f60a> ../cstrike/dlls/combat.cpp:295 */
-void CBaseMonster::FadeMonster_(void)
+void CBaseMonster::__MAKE_VHOOK(FadeMonster)(void)
 {
 	StopAnimation();
 
@@ -174,7 +174,7 @@ void CBaseMonster::FadeMonster_(void)
 }
 
 /* <60a59> ../cstrike/dlls/combat.cpp:310 */
-void CBaseMonster::GibMonster_(void)
+void CBaseMonster::__MAKE_VHOOK(GibMonster)(void)
 {
 	TraceResult tr;
 	BOOL gibbed = FALSE;
@@ -219,7 +219,7 @@ void CBaseMonster::GibMonster_(void)
 }
 
 /* <5f65e> ../cstrike/dlls/combat.cpp:355 */
-NOBODY Activity CBaseMonster::GetDeathActivity_(void)
+NOBODY Activity CBaseMonster::__MAKE_VHOOK(GetDeathActivity)(void)
 {
 //	{
 //		Activity deathActivity;                               //   357
@@ -255,7 +255,7 @@ NOBODY Activity CBaseMonster::GetSmallFlinchActivity(void)
 }
 
 /* <5f8a6> ../cstrike/dlls/combat.cpp:525 */
-void CBaseMonster::BecomeDead_(void)
+void CBaseMonster::__MAKE_VHOOK(BecomeDead)(void)
 {
 	// don't let autoaim aim at corpses.
 	pev->takedamage = DAMAGE_YES;
@@ -324,10 +324,10 @@ void CBaseMonster::CallGibMonster(void)
 }
 
 /* <5f938> ../cstrike/dlls/combat.cpp:598 */
-void CBaseMonster::Killed_(entvars_t *pevAttacker, int iGib)
+void CBaseMonster::__MAKE_VHOOK(Killed)(entvars_t *pevAttacker, int iGib)
 {
-	unsigned int cCount = 0;
+	// unsigned int cCount = 0;
-	BOOL fDone = FALSE;
+	// BOOL fDone = FALSE;
 
 	if (HasMemory(bits_MEMORY_KILLED))
 	{
@@ -450,7 +450,7 @@ void CGib::BounceGibTouch(CBaseEntity *pOther)
 		if (m_material != matNone && !RANDOM_LONG(0, 2))
 		{
 			float zvel = fabs(pev->velocity.z);
-			float volume = 0.8 * min(1, zvel / 450);
+			float volume = 0.8 * _min(1, zvel / 450);
 
 			CBreakable::MaterialSoundRandom(edict(), (Materials)m_material, volume);
 		}
@@ -525,7 +525,7 @@ void CGib::Spawn(const char *szGibModel)
 }
 
 /* <60aea> ../cstrike/dlls/combat.cpp:815 */
-int CBaseMonster::TakeHealth_(float flHealth, int bitsDamageType)
+int CBaseMonster::__MAKE_VHOOK(TakeHealth)(float flHealth, int bitsDamageType)
 {
 	if (pev->takedamage == DAMAGE_NO)
 		return 0;
@@ -546,7 +546,7 @@ int CBaseMonster::TakeHealth_(float flHealth, int bitsDamageType)
 // When a monster is poisoned via an arrow etc it takes all the poison damage at once.
 
 /* <60d7a> ../cstrike/dlls/combat.cpp:845 */
-int CBaseMonster::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+int CBaseMonster::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 	float flTake;
 	Vector vecDir;
@@ -556,7 +556,7 @@ int CBaseMonster::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, f
 
 	if (!IsAlive())
 	{
-		return DeadTakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);// Reverse me
+		return DeadTakeDamage(pevInflictor, pevAttacker, flDamage, bitsDamageType);
 	}
 
 	if (pev->deadflag == DEAD_NO)
@@ -1070,7 +1070,7 @@ NOBODY CBaseEntity *CBaseMonster::CheckTraceHullAttack(float flDist, int iDamage
 }
 
 /* <61ae6> ../cstrike/dlls/combat.cpp:1490 */
-NOBODY BOOL CBaseMonster::FInViewCone_(CBaseEntity *pEntity)
+NOBODY BOOL CBaseMonster::__MAKE_VHOOK(FInViewCone)(CBaseEntity *pEntity)
 {
 //	{
 //		class Vector2D vec2LOS;                               //  1492
@@ -1085,7 +1085,7 @@ NOBODY BOOL CBaseMonster::FInViewCone_(CBaseEntity *pEntity)
 }
 
 /* <61be6> ../cstrike/dlls/combat.cpp:1517 */
-NOBODY BOOL CBaseMonster::FInViewCone_(Vector *pOrigin)
+NOBODY BOOL CBaseMonster::__MAKE_VHOOK(FInViewCone)(Vector *pOrigin)
 {
 //	{
 //		class Vector2D vec2LOS;                               //  1519
@@ -1100,7 +1100,7 @@ NOBODY BOOL CBaseMonster::FInViewCone_(Vector *pOrigin)
 }
 
 /* <5ecb4> ../cstrike/dlls/combat.cpp:1543 */
-NOBODY BOOL CBaseEntity::FVisible_(CBaseEntity *pEntity)
+NOBODY BOOL CBaseEntity::__MAKE_VHOOK(FVisible)(CBaseEntity *pEntity)
 {
 //	{
 //		TraceResult tr;                                       //  1545
@@ -1113,7 +1113,7 @@ NOBODY BOOL CBaseEntity::FVisible_(CBaseEntity *pEntity)
 }
 
 /* <5e9bb> ../cstrike/dlls/combat.cpp:1576 */
-NOBODY BOOL CBaseEntity::FVisible_(Vector &vecOrigin)
+NOBODY BOOL CBaseEntity::__MAKE_VHOOK(FVisible)(Vector &vecOrigin)
 {
 //	{
 //		TraceResult tr;                                       //  1578
@@ -1123,7 +1123,7 @@ NOBODY BOOL CBaseEntity::FVisible_(Vector &vecOrigin)
 }
 
 /* <5e872> ../cstrike/dlls/combat.cpp:1600 */
-void CBaseEntity::TraceAttack_(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
+void CBaseEntity::__MAKE_VHOOK(TraceAttack)(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
 {
 	Vector vecOrigin = ptr->vecEndPos - vecDir * 4;
 
@@ -1142,7 +1142,7 @@ void CBaseEntity::TraceAttack_(entvars_t *pevAttacker, float flDamage, Vector ve
 }
 
 /* <61ce5> ../cstrike/dlls/combat.cpp:1647 */
-void CBaseMonster::TraceAttack_(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
+void CBaseMonster::__MAKE_VHOOK(TraceAttack)(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
 {
 	Vector vecOrigin = ptr->vecEndPos - vecDir * 4;
 
@@ -1550,7 +1550,7 @@ Vector __declspec(naked) CBaseEntity::FireBullets3(Vector vecSrc, Vector vecDirS
 }
 
 /* <5eb17> ../cstrike/dlls/combat.cpp:2075 */
-void CBaseEntity::TraceBleed_(float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
+void CBaseEntity::__MAKE_VHOOK(TraceBleed)(float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
 {
 	if (BloodColor() == DONT_BLEED)
 		return;

regamedll/dlls/debug.cpp

@@ -5,18 +5,18 @@
 */
 #ifndef HOOK_GAMEDLL
 
-DebugOutputLevel outputLevel[NUM_LEVELS] =
+DebugOutputLevel outputLevel[ NUM_LEVELS ] =
 {
-	{ "bot", DEBUG_BOT },
+	{ "bot",	DEBUG_BOT },
-	{ "career", DEBUG_CAREER },
+	{ "career",	DEBUG_CAREER },
-	{ "tutor", DEBUG_TUTOR },
+	{ "tutor",	DEBUG_TUTOR },
-	{ "stats", DEBUG_STATS },
+	{ "stats",	DEBUG_STATS },
-	{ "hostage", DEBUG_HOSTAGE },
+	{ "hostage",	DEBUG_HOSTAGE },
-	{ "all", DEBUG_ALL }
+	{ "all",	DEBUG_ALL }
 };
 
 unsigned int theDebugOutputTypes;
-static char theDebugBuffer[DebugBufferSize];
+static char theDebugBuffer[ DebugBufferSize ];
 
 #else // HOOK_GAMEDLL
 
@@ -27,7 +27,7 @@ char theDebugBuffer[ DebugBufferSize ];
 #endif // HOOK_GAMEDLL
 
 /* <22fe8b> ../cstrike/dlls/debug.cpp:39 */
-NOXREF bool IsDeveloper(void)
+bool IsDeveloper(void)
 {
 	return (CVAR_GET_FLOAT("developer") > 0.0);
 }
@@ -35,143 +35,203 @@ NOXREF bool IsDeveloper(void)
 /* <22ff69> ../cstrike/dlls/debug.cpp:45 */
 NOXREF void UTIL_DPrintf(DebugOutputType outputType, char *pszMsg, ...)
 {
-	va_list argptr;
+	if (!IsDeveloper())
-	va_start(argptr, pszMsg);
+		return;
 
-	if (IsDeveloper())
+	if (theDebugOutputTypes & outputType)
 	{
-		if (theDebugOutputTypes & outputType)
+		va_list argptr;
-		{
+		va_start(argptr, pszMsg);
-#ifdef REGAMEDLL_FIXES
-			Q_vsnprintf(theDebugBuffer, DebugBufferSize, pszMsg, argptr);
-#else
-			vsprintf(theDebugBuffer, pszMsg, argptr);
-#endif // REGAMEDLL_FIXES
-			SERVER_PRINT(theDebugBuffer);
-		}
-	}
-}
-
-// OVERLOAD
-void UTIL_DPrintf(char *pszMsg, ...)
-{
-	va_list argptr;
-	va_start(argptr, pszMsg);
-
-	if (IsDeveloper())
-	{
-#ifdef REGAMEDLL_FIXES
-		Q_vsnprintf(theDebugBuffer, DebugBufferSize, pszMsg, argptr);
-#else
 		vsprintf(theDebugBuffer, pszMsg, argptr);
-#endif // REGAMEDLL_FIXES
+		va_end(argptr);
+
 		SERVER_PRINT(theDebugBuffer);
 	}
 }
 
+/* <22fe23> ../cstrike/dlls/debug.cpp:56 */
+void UTIL_DPrintf(char *pszMsg, ...)
+{
+	if (!IsDeveloper())
+		return;
+
+	va_list argptr;
+	va_start(argptr, pszMsg);
+	vsprintf(theDebugBuffer, pszMsg, argptr);
+	va_end(argptr);
+
+	SERVER_PRINT(theDebugBuffer);
+}
+
 /* <22fe97> ../cstrike/dlls/debug.cpp:78 */
-NOXREF void PrintDebugFlags(void)
+void PrintDebugFlags(void)
 {
 	char *tmp;
-	char *state;
 	int remainder = DebugBufferSize;
 
-	theDebugBuffer[0] = 0;
+	theDebugBuffer[0] = '\0';
 	tmp = BufPrintf(theDebugBuffer, remainder, "mp_debug:\n");
 
 	for (int i = 0; i < NUM_LEVELS - 1; i++)
 	{
-		DebugOutputLevel *level = &outputLevel[i];
+		DebugOutputLevel level = outputLevel[i];
-		if (theDebugOutputTypes & level->value)
-			state = "on";
-		else 
-			state = "off";
 
-		tmp = BufPrintf(tmp, remainder, "  %s: %s\n", level->name, state);
+		tmp = BufPrintf(tmp, remainder, "  %s: %s\n", level.name, (theDebugOutputTypes & level.value) ? "on" : "off");
 	}
 	SERVER_PRINT(theDebugBuffer);
 }
 
 /* <22fed4> ../cstrike/dlls/debug.cpp:94 */
-NOBODY void SetDebugFlag(const char *flagStr, bool state)
+void SetDebugFlag(const char *flagStr, bool state)
 {
-//	{
+	if (flagStr != NULL)
-//		enum DebugOutputType flag;                            //    96
+	{
-//		{
+		DebugOutputType flag;
-//			int i;                                        //    97
+		for (int i = 0; i < ARRAYSIZE(outputLevel); i++)
-//			{
+		{
-//				class DebugOutputLevel level;         //    99
+			DebugOutputLevel level = outputLevel[ i ];
-//				FStrEq(const char *sz1,
+
-//					const char *sz2);  //   100
+			if (FStrEq(level.name, flagStr))
-//			}
+			{
-//		}
+				flag = level.value;
-//	}
+
+				if (state)
+					theDebugOutputTypes |= flag;
+				else
+					theDebugOutputTypes &= ~flag;
+
+				SERVER_PRINT(SharedVarArgs("mp_debug: %s is now %s\n", flagStr, state ? "on" : "off"));
+				return;
+			}
+		}
+	}
+
+	SERVER_PRINT(SharedVarArgs("mp_debug: unknown variable '%s'\n", flagStr));
 }
 
 /* <23001f> ../cstrike/dlls/debug.cpp:126 */
-NOBODY void PrintDebugFlag(const char *flagStr)
+void PrintDebugFlag(const char *flagStr)
 {
-//	{
+	if (flagStr != NULL)
-//		enum DebugOutputType flag;                            //   128
+	{
-//		{
+		DebugOutputType flag;
-//			int i;                                        //   129
+		for (int i = 0; i < ARRAYSIZE(outputLevel); i++)
-//			{
+		{
-//				class DebugOutputLevel level;         //   131
+			DebugOutputLevel level = outputLevel[ i ];
-//				FStrEq(const char *sz1,
+
-//					const char *sz2);  //   132
+			if (FStrEq(level.name, flagStr))
-//			}
+			{
-//		}
+				flag = level.value;
-//	}
+				SERVER_PRINT(SharedVarArgs("mp_debug: %s is %s\n", flagStr, (flag & theDebugOutputTypes) ? "on" : "off"));
+				return;
+			}
+		}
+	}
+
+	SERVER_PRINT(SharedVarArgs("mp_debug: unknown variable '%s'\n", flagStr));
 }
 
 /* <2300a9> ../cstrike/dlls/debug.cpp:149 */
-NOBODY void UTIL_SetDprintfFlags(const char *flagStr)
+void UTIL_SetDprintfFlags(const char *flagStr)
 {
-//	IsDeveloper(void);  //   151
+	if (!IsDeveloper())
-//	PrintDebugFlags(void);  //   156
+		return;
+
+	if (flagStr != NULL && flagStr[0] != '\0')
+	{
+		if (flagStr[0] == '+')
+			SetDebugFlag(&flagStr[1], true);
+
+		else if (flagStr[0] == '-')
+			SetDebugFlag(&flagStr[1], false);
+		else
+			PrintDebugFlag(flagStr);
+	}
+	else
+		PrintDebugFlags();
 }
 
 /* <23012d> ../cstrike/dlls/debug.cpp:175 */
-NOBODY void UTIL_BotDPrintf(char *pszMsg, ...)
+NOXREF void UTIL_BotDPrintf(char *pszMsg, ...)
 {
-//	IsDeveloper(void);  //   177
+	if (!IsDeveloper())
-//	{
+		return;
-//		va_list argptr;                                       //   182
+
-//	}
+	if (theDebugOutputTypes & DEBUG_BOT)
+	{
+		va_list argptr;
+		va_start(argptr, pszMsg);
+		vsprintf(theDebugBuffer, pszMsg, argptr);
+		va_end(argptr);
+
+		SERVER_PRINT(theDebugBuffer);
+	}
 }
 
 /* <230181> ../cstrike/dlls/debug.cpp:193 */
-NOBODY void UTIL_CareerDPrintf(char *pszMsg, ...)
+void UTIL_CareerDPrintf(char *pszMsg, ...)
 {
-//	IsDeveloper(void);  //   195
+	if (!IsDeveloper())
-//	{
+		return;
-//		va_list argptr;                                       //   200
+
-//	}
+	if (theDebugOutputTypes & DEBUG_CAREER)
+	{
+		va_list argptr;
+		va_start(argptr, pszMsg);
+		vsprintf(theDebugBuffer, pszMsg, argptr);
+		va_end(argptr);
+
+		SERVER_PRINT(theDebugBuffer);
+	}
 }
 
 /* <2301d5> ../cstrike/dlls/debug.cpp:211 */
-NOBODY void UTIL_TutorDPrintf(char *pszMsg, ...)
+NOXREF void UTIL_TutorDPrintf(char *pszMsg, ...)
 {
-//	IsDeveloper(void);  //   213
+	if (!IsDeveloper())
-//	{
+		return;
-//		va_list argptr;                                       //   218
+
-//	}
+	if (theDebugOutputTypes & DEBUG_TUTOR)
+	{
+		va_list argptr;
+		va_start(argptr, pszMsg);
+		vsprintf(theDebugBuffer, pszMsg, argptr);
+		va_end(argptr);
+
+		SERVER_PRINT(theDebugBuffer);
+	}
 }
 
 /* <230229> ../cstrike/dlls/debug.cpp:229 */
-NOBODY void UTIL_StatsDPrintf(char *pszMsg, ...)
+NOXREF void UTIL_StatsDPrintf(char *pszMsg, ...)
 {
-//	IsDeveloper(void);  //   231
+	if (!IsDeveloper())
-//	{
+		return;
-//		va_list argptr;                                       //   236
+
-//	}
+	if (theDebugOutputTypes & DEBUG_STATS)
+	{
+		va_list argptr;
+		va_start(argptr, pszMsg);
+		vsprintf(theDebugBuffer, pszMsg, argptr);
+		va_end(argptr);
+
+		SERVER_PRINT(theDebugBuffer);
+	}
 }
 
 /* <23027d> ../cstrike/dlls/debug.cpp:247 */
-NOBODY void UTIL_HostageDPrintf(char *pszMsg, ...)
+NOXREF void UTIL_HostageDPrintf(char *pszMsg, ...)
 {
-//	IsDeveloper(void);  //   249
+	if (!IsDeveloper())
-//	{
+		return;
-//		va_list argptr;                                       //   254
+
-//	}
+	if (theDebugOutputTypes & DEBUG_HOSTAGE)
+	{
+		va_list argptr;
+		va_start(argptr, pszMsg);
+		vsprintf(theDebugBuffer, pszMsg, argptr);
+		va_end(argptr);
+
+		SERVER_PRINT(theDebugBuffer);
+	}
 }

regamedll/dlls/debug.h

@@ -37,19 +37,21 @@ const int DebugBufferSize = 1024;
 
 typedef enum
 {
-	DEBUG_NONE = 0,
+	DEBUG_NONE	= 0,
-	DEBUG_BOT,
+	DEBUG_BOT	= (1<<0),
-	DEBUG_CAREER,
+	DEBUG_CAREER	= (1<<1),
-	DEBUG_TUTOR,
+	DEBUG_TUTOR	= (1<<2),
-	DEBUG_STATS,
+	DEBUG_STATS	= (1<<3),
-	DEBUG_HOSTAGE,
+	DEBUG_HOSTAGE	= (1<<4),
-	DEBUG_ALL = 0xFFFFFFFF,
+	DEBUG_ALL	= 0xFFFFFFFF,
+
 } DebugOutputType;
 
 struct DebugOutputLevel
 {
 	const char *name;
 	DebugOutputType value;
+
 };/* size: 8, cachelines: 1, members: 2 */
 
 #ifdef HOOK_GAMEDLL
@@ -60,23 +62,24 @@ struct DebugOutputLevel
 
 #endif // HOOK_GAMEDLL
 
-extern DebugOutputLevel outputLevel[NUM_LEVELS];
+extern DebugOutputLevel outputLevel[ NUM_LEVELS ];
 extern unsigned int theDebugOutputTypes;
-extern char theDebugBuffer[DebugBufferSize];
+extern char theDebugBuffer[ DebugBufferSize ];
 
-NOXREF bool IsDeveloper(void);
+bool IsDeveloper(void);
-NOBODY void UTIL_DPrintf(DebugOutputType outputType, char *pszMsg, ...);
+NOXREF void UTIL_DPrintf(DebugOutputType outputType, char *pszMsg, ...);
 void UTIL_DPrintf(char *pszMsg, ...);
-NOXREF void PrintDebugFlags(void);
+void PrintDebugFlags(void);
 
-NOBODY void SetDebugFlag(const char *flagStr, bool state);
+void SetDebugFlag(const char *flagStr, bool state);
-NOBODY void PrintDebugFlag(const char *flagStr);
+void PrintDebugFlag(const char *flagStr);
-NOBODY void UTIL_SetDprintfFlags(const char *flagStr);
+void UTIL_SetDprintfFlags(const char *flagStr);
-NOBODY void UTIL_BotDPrintf(char *pszMsg, ...);
+
-NOBODY void UTIL_CareerDPrintf(char *pszMsg, ...);
+NOXREF void UTIL_BotDPrintf(char *pszMsg, ...);
-NOBODY void UTIL_TutorDPrintf(char *pszMsg, ...);
+void UTIL_CareerDPrintf(char *pszMsg, ...);
-NOBODY void UTIL_StatsDPrintf(char *pszMsg, ...);
+NOXREF void UTIL_TutorDPrintf(char *pszMsg, ...);
-NOBODY void UTIL_HostageDPrintf(char *pszMsg, ...);
+NOXREF void UTIL_StatsDPrintf(char *pszMsg, ...);
+NOXREF void UTIL_HostageDPrintf(char *pszMsg, ...);
 
 #ifdef HOOK_GAMEDLL
 

regamedll/dlls/doors.cpp

@@ -56,7 +56,7 @@ NOBODY void PlayLockSounds(entvars_t *pev, locksound_t *pls, int flocked, int fb
 }
 
 /* <69a4f> ../cstrike/dlls/doors.cpp:201 */
-NOBODY void CBaseDoor::KeyValue_(KeyValueData *pkvd)
+NOBODY void CBaseDoor::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   204
@@ -75,7 +75,7 @@ LINK_ENTITY_TO_CLASS(func_door, CBaseDoor);
 LINK_ENTITY_TO_CLASS(func_water, CBaseDoor);
 
 /* <690bc> ../cstrike/dlls/doors.cpp:285 */
-NOBODY void CBaseDoor::Spawn_(void)
+NOBODY void CBaseDoor::__MAKE_VHOOK(Spawn)(void)
 {
 //	fabs(double __x);  //   312
 //	fabs(double __x);  //   312
@@ -87,12 +87,12 @@ NOBODY void CBaseDoor::Spawn_(void)
 }
 
 /* <69949> ../cstrike/dlls/doors.cpp:334 */
-NOBODY void CBaseDoor::Restart_(void)
+NOBODY void CBaseDoor::__MAKE_VHOOK(Restart)(void)
 {
 }
 
 /* <69289> ../cstrike/dlls/doors.cpp:350 */
-NOBODY void CBaseDoor::SetToggleState_(int state)
+NOBODY void CBaseDoor::__MAKE_VHOOK(SetToggleState)(int state)
 {
 //	SetToggleState(CBaseDoor *const this,
 //			int state);  //   350
@@ -102,7 +102,7 @@ NOBODY void CBaseDoor::SetToggleState_(int state)
 #define noiseArrived noise2
 
 /* <6924c> ../cstrike/dlls/doors.cpp:359 */
-NOBODY void CBaseDoor::Precache_(void)
+NOBODY void CBaseDoor::__MAKE_VHOOK(Precache)(void)
 {
 //	{
 //		char *pszSound;                                      //   361
@@ -120,7 +120,7 @@ NOBODY void CBaseDoor::DoorTouch(CBaseEntity *pOther)
 }
 
 /* <6a33b> ../cstrike/dlls/doors.cpp:543 */
-NOBODY void CBaseDoor::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CBaseDoor::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	DoorActivate(CBaseDoor *const this);  //   548
 }
@@ -208,7 +208,7 @@ NOBODY void CBaseDoor::DoorHitBottom(void)
 }
 
 /* <6a465> ../cstrike/dlls/doors.cpp:817 */
-NOBODY void CBaseDoor::Blocked_(CBaseEntity *pOther)
+NOBODY void CBaseDoor::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
 {
 //	{
 //		edict_t *pentTarget;                                 //   819
@@ -223,7 +223,7 @@ NOBODY void CBaseDoor::Blocked_(CBaseEntity *pOther)
 LINK_ENTITY_TO_CLASS(func_door_rotating, CRotDoor);
 
 /* <698be> ../cstrike/dlls/doors.cpp:946 */
-NOBODY void CRotDoor::Restart_(void)
+NOBODY void CRotDoor::__MAKE_VHOOK(Restart)(void)
 {
 //	operator*(const Vector ::Restart(//			float fl);  //   953
 //	{
@@ -234,7 +234,7 @@ NOBODY void CRotDoor::Restart_(void)
 }
 
 /* <69177> ../cstrike/dlls/doors.cpp:978 */
-NOBODY void CRotDoor::Spawn_(void)
+NOBODY void CRotDoor::__MAKE_VHOOK(Spawn)(void)
 {
 //	operator*(const class Vector  *const this,
 //			float fl);  //   986
@@ -250,7 +250,7 @@ NOBODY void CRotDoor::Spawn_(void)
 }
 
 /* <68fcc> ../cstrike/dlls/doors.cpp:1028 */
-NOBODY void CRotDoor::SetToggleState_(int state)
+NOBODY void CRotDoor::__MAKE_VHOOK(SetToggleState)(int state)
 {
 }
 
@@ -261,7 +261,7 @@ LINK_ENTITY_TO_CLASS(momentary_door, CMomentaryDoor);
 IMPLEMENT_SAVERESTORE(CMomentaryDoor, CBaseToggle);
 
 /* <69001> ../cstrike/dlls/doors.cpp:1065 */
-NOBODY void CMomentaryDoor::Spawn_(void)
+NOBODY void CMomentaryDoor::__MAKE_VHOOK(Spawn)(void)
 {
 //	fabs(double __x);  //  1082
 //	fabs(double __x);  //  1082
@@ -273,12 +273,12 @@ NOBODY void CMomentaryDoor::Spawn_(void)
 }
 
 /* <68fa5> ../cstrike/dlls/doors.cpp:1096 */
-NOBODY void CMomentaryDoor::Precache_(void)
+NOBODY void CMomentaryDoor::__MAKE_VHOOK(Precache)(void)
 {
 }
 
 /* <69970> ../cstrike/dlls/doors.cpp:1143 */
-NOBODY void CMomentaryDoor::KeyValue_(KeyValueData *pkvd)
+NOBODY void CMomentaryDoor::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //  1146
@@ -291,7 +291,7 @@ NOBODY void CMomentaryDoor::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <6953e> ../cstrike/dlls/doors.cpp:1165 */
-NOBODY void CMomentaryDoor::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CMomentaryDoor::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		Vector move;                                    //  1172

regamedll/dlls/effects.h

@@ -72,16 +72,16 @@
 class CSprite: public CPointEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void Restart(void);
+	virtual void Restart(void);
-	NOBODY virtual int Save(CSave &save);
+	virtual int Save(CSave &save);
-	NOBODY virtual int Restore(CRestore &restore);
+	virtual int Restore(CRestore &restore);
-	NOBODY virtual int ObjectCaps(void)
+	virtual int ObjectCaps(void)
 	{
 		return ObjectCaps_();
 	}
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
 
@@ -96,19 +96,19 @@ public:
 		if (pev->spawnflags & SF_SPRITE_TEMPORARY)
 			flags = FCAP_DONT_SAVE;
 
-		return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION)|flags;
+		return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags;
 	}
 	void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #endif // HOOK_GAMEDLL
 
 public:
-	NOBODY void EXPORT AnimateThink(void);
+	void EXPORT AnimateThink(void);
-	NOBODY void EXPORT ExpandThink(void);
+	void EXPORT ExpandThink(void);
 
-	NOBODY void Animate(float frames);
+	void Animate(float frames);
-	NOBODY void Expand(float scaleSpeed, float fadeSpeed);
+	NOXREF void Expand(float scaleSpeed, float fadeSpeed);
-	NOBODY void SpriteInit(const char *pSpriteName, const Vector &origin);
+	void SpriteInit(const char *pSpriteName, const Vector &origin);
 
 	void SetAttachment(edict_t *pEntity, int attachment)
 	{
@@ -120,8 +120,8 @@ public:
 			pev->movetype = MOVETYPE_FOLLOW;
 		}
 	}
-	NOBODY void TurnOff(void);
+	void TurnOff(void);
-	NOBODY void TurnOn(void);
+	void TurnOn(void);
 	float Frames(void)
 	{
 		return m_maxFrame;
@@ -161,8 +161,8 @@ public:
 		pev->nextthink = gpGlobals->time;
 	}
 
-	NOBODY void EXPORT AnimateUntilDead(void);
+	void EXPORT AnimateUntilDead(void);
-	NOBODY static CSprite *SpriteCreate(const char *pSpriteName, const Vector &origin, BOOL animate);
+	static CSprite *SpriteCreate(const char *pSpriteName, const Vector &origin, BOOL animate);
 
 	static TYPEDESCRIPTION IMPLEMENT_ARRAY(m_SaveData)[2];
 
@@ -177,13 +177,13 @@ private:
 class CBeam: public CBaseEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual int ObjectCaps(void)
+	virtual int ObjectCaps(void)
 	{
 		return ObjectCaps_();
 	}
-	NOBODY virtual Vector Center(void)
+	virtual Vector Center(void)
 	{
 		return Center_();
 	}
@@ -198,7 +198,7 @@ public:
 		if (pev->spawnflags & SF_BEAM_TEMPORARY)
 			flags = FCAP_DONT_SAVE;
 
-		return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION)|flags;
+		return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | flags;
 	}
 	Vector Center_(void)
 	{
@@ -208,15 +208,15 @@ public:
 #endif // HOOK_GAMEDLL
 
 public:
-	NOBODY void EXPORT TriggerTouch(CBaseEntity *pOther);
+	void EXPORT TriggerTouch(CBaseEntity *pOther);
 
 	void SetType(int type)
 	{
-		pev->rendermode = (pev->rendermode & 0xF0)|(type & 0x0F);
+		pev->rendermode = (pev->rendermode & 0xF0) | (type & 0x0F);
 	}
 	void SetFlags(int flags)
 	{
-		pev->rendermode = (pev->rendermode & 0x0F)|(flags&0xF0);
+		pev->rendermode = (pev->rendermode & 0x0F) | (flags & 0xF0);
 	}
 	void SetStartPos(const Vector &pos)
 	{
@@ -226,8 +226,8 @@ public:
 	{
 		pev->angles = pos;
 	}
-	NOBODY void SetStartEntity(int entityIndex);
+	void SetStartEntity(int entityIndex);
-	NOBODY void SetEndEntity(int entityIndex);
+	void SetEndEntity(int entityIndex);
 	void SetStartAttachment(int attachment)
 	{
 		pev->sequence = (pev->sequence & 0x0FFF) | ((attachment & 0xF) << 12);
@@ -283,8 +283,8 @@ public:
 		return pev->skin & 0xFFF;
 	}
 
-	NOBODY const Vector &GetStartPos(void);
+	const Vector &GetStartPos(void);
-	NOBODY const Vector &GetEndPos(void);
+	const Vector &GetEndPos(void);
 
 	int GetTexture(void)
 	{
@@ -311,17 +311,17 @@ public:
 		return pev->animtime;
 	}
 
-	NOBODY void RelinkBeam(void);
+	void RelinkBeam(void);
-	NOBODY void DoSparks(const Vector &start, const Vector &end);
+	void DoSparks(const Vector &start, const Vector &end);
-	NOBODY CBaseEntity *RandomTargetname(const char *szName);
+	CBaseEntity *RandomTargetname(const char *szName);
-	NOBODY void BeamDamage(TraceResult *ptr);
+	void BeamDamage(TraceResult *ptr);
-	NOBODY void BeamInit(const char *pSpriteName, int width);
+	void BeamInit(const char *pSpriteName, int width);
-	NOBODY void PointsInit(const Vector &start, const Vector &end);
+	void PointsInit(const Vector &start, const Vector &end);
-	NOBODY void PointEntInit(const Vector &start, int endIndex);
+	void PointEntInit(const Vector &start, int endIndex);
-	NOBODY void EntsInit(int startIndex, int endIndex);
+	void EntsInit(int startIndex, int endIndex);
-	NOBODY void HoseInit(const Vector &start, const Vector &direction);
+	void HoseInit(const Vector &start, const Vector &direction);
 
-	NOBODY static CBeam *BeamCreate(const char *pSpriteName, int width);
+	static CBeam *BeamCreate(const char *pSpriteName, int width);
 
 	void LiveForTime(float time)
 	{
@@ -341,12 +341,12 @@ public:
 class CLaser: public CBeam
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual int Save(CSave &save);
+	virtual int Save(CSave &save);
-	NOBODY virtual int Restore(CRestore &restore);
+	virtual int Restore(CRestore &restore);
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
 
@@ -360,12 +360,12 @@ public:
 #endif // HOOK_GAMEDLL
 
 public:
-	NOBODY void TurnOn(void);
+	void TurnOn(void);
-	NOBODY void TurnOff(void);
+	void TurnOff(void);
-	NOBODY int IsOn(void);
+	int IsOn(void);
 
-	NOBODY void FireAtPoint(TraceResult &point);
+	void FireAtPoint(TraceResult &point);
-	NOBODY void EXPORT StrikeThink(void);
+	void EXPORT StrikeThink(void);
 
 public:
 	static TYPEDESCRIPTION IMPLEMENT_ARRAY(m_SaveData)[3];
@@ -381,16 +381,16 @@ public:
 class CBubbling: public CBaseEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual int Save(CSave &save);
+	virtual int Save(CSave &save);
-	NOBODY virtual int Restore(CRestore &restore);
+	virtual int Restore(CRestore &restore);
-	NOBODY virtual int ObjectCaps(void)
+	virtual int ObjectCaps(void)
 	{
 		return ObjectCaps_();
 	}
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
 
@@ -401,7 +401,7 @@ public:
 	int Restore_(CRestore &restore);
 	int ObjectCaps_(void)
 	{
-		return CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION;
+		return (CBaseEntity::ObjectCaps() & ~FCAP_ACROSS_TRANSITION);
 	}
 	void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
@@ -425,12 +425,12 @@ public:
 class CLightning: public CBeam
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual int Save(CSave &save);
+	virtual int Save(CSave &save);
-	NOBODY virtual int Restore(CRestore &restore);
+	virtual int Restore(CRestore &restore);
-	NOBODY virtual void Activate(void);
+	virtual void Activate(void);
 
 #ifdef HOOK_GAMEDLL
 
@@ -486,10 +486,10 @@ public:
 class CGlow: public CPointEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual int Save(CSave &save);
+	virtual int Save(CSave &save);
-	NOBODY virtual int Restore(CRestore &restore);
+	virtual int Restore(CRestore &restore);
-	NOBODY virtual void Think(void);
+	virtual void Think(void);
 
 #ifdef HOOK_GAMEDLL
 
@@ -500,7 +500,7 @@ public:
 
 #endif // HOOK_GAMEDLL
 
-	NOBODY void Animate(float frames);
+	void Animate(float frames);
 public:
 	static TYPEDESCRIPTION IMPLEMENT_ARRAY(m_SaveData)[2];
 
@@ -517,6 +517,13 @@ public:
 	virtual void Spawn(void);
 	virtual void Think(void);
 
+#ifdef HOOK_GAMEDLL
+
+	void Spawn_(void);
+	void Think_(void);
+
+#endif // HOOK_GAMEDLL
+
 public:
 	float m_lastTime;
 	float m_tmBeepPeriod;
@@ -571,7 +578,7 @@ class CEnvShooter: public CGibShooter
 public:
 	virtual void Precache(void);
 	virtual void KeyValue(KeyValueData *pkvd);
-	CGib *CreateGib(void);
+	virtual CGib *CreateGib(void);
 
 #ifdef HOOK_GAMEDLL
 
@@ -589,14 +596,16 @@ public:
 class CTestEffect: public CBaseDelay
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+
 #endif // HOOK_GAMEDLL
 
 public:
@@ -617,14 +626,16 @@ public:
 class CBlood: public CPointEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void KeyValue_(KeyValueData *pkvd);
 	void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+
 #endif // HOOK_GAMEDLL
 
 public:
@@ -659,9 +670,9 @@ public:
 class CShake: public CPointEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
 
@@ -719,14 +730,16 @@ public:
 class CFade: public CPointEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void KeyValue_(KeyValueData *pkvd);
 	void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+
 #endif // HOOK_GAMEDLL
 
 public:
@@ -757,16 +770,18 @@ public:
 class CMessage: public CPointEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
 	void KeyValue_(KeyValueData *pkvd);
 	void Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+
 #endif // HOOK_GAMEDLL
 
 };/* size: 152, cachelines: 3, members: 1 */
@@ -775,9 +790,9 @@ public:
 class CEnvFunnel: public CBaseDelay
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
 
@@ -796,9 +811,9 @@ public:
 class CEnvBeverage: public CBaseDelay
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
 
@@ -814,12 +829,14 @@ public:
 class CItemSoda: public CBaseEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
 
 #ifdef HOOK_GAMEDLL
+
 	void Spawn_(void);
 	void Precache_(void);
+
 #endif // HOOK_GAMEDLL
 
 public:
@@ -828,6 +845,27 @@ public:
 
 };/* size: 152, cachelines: 3, members: 1 */
 
-NOBODY int IsPointEntity(CBaseEntity *pEnt);
+int IsPointEntity(CBaseEntity *pEnt);
+
+// linked objects
+C_DLLEXPORT void info_target(entvars_t *pev);
+C_DLLEXPORT void env_bubbles(entvars_t *pev);
+C_DLLEXPORT void beam(entvars_t *pev);
+C_DLLEXPORT void env_lightning(entvars_t *pev);
+C_DLLEXPORT void env_beam(entvars_t *pev);
+C_DLLEXPORT void env_laser(entvars_t *pev);
+C_DLLEXPORT void env_glow(entvars_t *pev);
+C_DLLEXPORT void env_bombglow(entvars_t *pev);
+C_DLLEXPORT void env_sprite(entvars_t *pev);
+C_DLLEXPORT void gibshooter(entvars_t *pev);
+C_DLLEXPORT void env_shooter(entvars_t *pev);
+C_DLLEXPORT void test_effect(entvars_t *pev);
+C_DLLEXPORT void env_blood(entvars_t *pev);
+C_DLLEXPORT void env_shake(entvars_t *pev);
+C_DLLEXPORT void env_fade(entvars_t *pev);
+C_DLLEXPORT void env_message(entvars_t *pev);
+C_DLLEXPORT void env_funnel(entvars_t *pev);
+C_DLLEXPORT void env_beverage(entvars_t *pev);
+C_DLLEXPORT void item_sodacan(entvars_t *pev);
 
 #endif // EFFECTS_H

regamedll/dlls/enginecallback.h

@@ -85,8 +85,12 @@ extern enginefuncs_t g_engfuncs;
 #define ADD_SERVER_COMMAND		(*g_engfuncs.pfnAddServerCommand)
 #define SET_CLIENT_LISTENING		(*g_engfuncs.pfnVoice_SetClientListening)
 #define GETPLAYERAUTHID			(*g_engfuncs.pfnGetPlayerAuthId)
+#define GET_FILE_SIZE			(*g_engfuncs.pfnGetFileSize)
 #define GET_APPROX_WAVE_PLAY_LEN	(*g_engfuncs.pfnGetApproxWavePlayLen)
 #define IS_CAREER_MATCH			(*g_engfuncs.pfnIsCareerMatch)
+#define GET_LOCALIZED_STRING_LENGTH	(*g_engfuncs.pfnGetLocalizedStringLength)
+#define REGISTER_TUTOR_MESSAGE_SHOWN	(*g_engfuncs.pfnRegisterTutorMessageShown)
+#define GET_TIMES_TUTOR_MESSAGE_SHOWN	(*g_engfuncs.pfnGetTimesTutorMessageShown)
 #define ENG_CHECK_PARM			(*g_engfuncs.pfnEngCheckParm)
 
 /* <472a4> ../cstrike/dlls/enginecallback.h:77 */
@@ -157,6 +161,7 @@ inline void *GET_PRIVATE(edict_t *pent)
 #define SET_KEY_VALUE			(*g_engfuncs.pfnSetKeyValue)
 #define SET_CLIENT_KEY_VALUE		(*g_engfuncs.pfnSetClientKeyValue)
 #define IS_MAP_VALID			(*g_engfuncs.pfnIsMapValid)
+#define STATIC_DECAL			(*g_engfuncs.pfnStaticDecal)
 #define IS_DEDICATED_SERVER		(*g_engfuncs.pfnIsDedicatedServer)
 #define PRECACHE_EVENT			(*g_engfuncs.pfnPrecacheEvent)
 #define PLAYBACK_EVENT_FULL		(*g_engfuncs.pfnPlaybackEvent)
@@ -171,6 +176,7 @@ inline void *GET_PRIVATE(edict_t *pent)
 #define DELTA_FINDFIELD			(*g_engfuncs.pfnDeltaFindField)
 #define DELTA_SETBYINDEX		(*g_engfuncs.pfnDeltaSetFieldByIndex)
 #define DELTA_UNSETBYINDEX		(*g_engfuncs.pfnDeltaUnsetFieldByIndex)
+#define	REMOVE_KEY_VALUE		(*g_engfuncs.pfnInfo_RemoveKey)
 #define SET_PHYSICS_KEY_VALUE		(*g_engfuncs.pfnSetPhysicsKeyValue)
 #define ENGINE_GETPHYSINFO		(*g_engfuncs.pfnGetPhysicsInfoString)
 #define ENGINE_SETGROUPMASK		(*g_engfuncs.pfnSetGroupMask)

regamedll/dlls/explode.cpp

@@ -21,25 +21,58 @@ TYPEDESCRIPTION (*CEnvExplosion::pm_SaveData)[2];
 LINK_ENTITY_TO_CLASS(spark_shower, CShower);
 
 /* <7f49c> ../cstrike/dlls/explode.cpp:39 */
-NOBODY void CShower::Spawn_(void)
+void CShower::__MAKE_VHOOK(Spawn)(void)
 {
-//	operator*(float fl,
+	pev->velocity = RANDOM_FLOAT(200, 300) * pev->angles;
-//			const Vector &v);  //    41
+	pev->velocity.x += RANDOM_FLOAT(-100, 100);
-//	edict(CBaseEntity *const this);  //    52
+	pev->velocity.y += RANDOM_FLOAT(-100, 100);
+
+	if (pev->velocity.z >= 0)
+		pev->velocity.z += 200;
+	else
+		pev->velocity.z -= 200;
+
+	pev->movetype = MOVETYPE_BOUNCE;
+	pev->gravity = 0.5f;
+	pev->nextthink = gpGlobals->time + 0.1f;
+	pev->solid = SOLID_NOT;
+
+	// Need a model, just use the grenade, we don't draw it anyway
+	SET_MODEL(edict(), "models/grenade.mdl");
+	UTIL_SetSize(pev, g_vecZero, g_vecZero);
+
+	pev->effects |= EF_NODRAW;
+	pev->speed = RANDOM_FLOAT(0.5, 1.5);
+	pev->angles = g_vecZero;
 }
 
 /* <7f475> ../cstrike/dlls/explode.cpp:61 */
-NOBODY void CShower::Think_(void)
+void CShower::__MAKE_VHOOK(Think)(void)
 {
+	UTIL_Sparks(pev->origin);
+
+	pev->speed -= 0.1f;
+
+	if (pev->speed > 0)
+		pev->nextthink = gpGlobals->time + 0.1f;
+	else
+		UTIL_Remove(this);
+
+	pev->flags &= ~FL_ONGROUND;
 }
 
 /* <7f122> ../cstrike/dlls/explode.cpp:73 */
-NOBODY void CShower::Touch_(CBaseEntity *pOther)
+void CShower::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
-//	operator*(const Vector *const this,
+	if (pev->flags & FL_ONGROUND)
-//			float fl);  //    76
+		pev->velocity = pev->velocity * 0.1f;
-//	operator*(const Vector *const this,
+	else
-//			float fl);  //    78
+		pev->velocity = pev->velocity * 0.6f;
+
+	if ((pev->velocity.x * pev->velocity.x + pev->velocity.y * pev->velocity.y) < 10.0f)
+	{
+		pev->speed = 0;
+	}
 }
 
 /* <7f566> ../cstrike/dlls/explode.cpp:106 */
@@ -49,75 +82,166 @@ IMPLEMENT_SAVERESTORE(CEnvExplosion, CBaseMonster);
 LINK_ENTITY_TO_CLASS(env_explosion, CEnvExplosion);
 
 /* <7f5b2> ../cstrike/dlls/explode.cpp:109 */
-NOBODY void CEnvExplosion::KeyValue_(KeyValueData *pkvd)
+void CEnvExplosion::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
-//	FStrEq(const char *sz1,
+	if (FStrEq(pkvd->szKeyName, "iMagnitude"))
-//		const char *sz2);  //   111
+	{
-//	KeyValue(CBaseEntity *const this,
+		m_iMagnitude = Q_atoi(pkvd->szValue);
-//		KeyValueData *pkvd);  //   117
+		pkvd->fHandled = TRUE;
-//	KeyValue(CEnvExplosion *const this,
+	}
-//		KeyValueData *pkvd);  //   109
+	else
+		CBaseEntity::KeyValue(pkvd);
 }
 
-
 /* <7f1a5> ../cstrike/dlls/explode.cpp:120 */
-NOBODY void CEnvExplosion::Spawn_(void)
+void CEnvExplosion::__MAKE_VHOOK(Spawn)(void)
 {
-//	{
+	pev->solid = SOLID_NOT;
-//		float flSpriteScale;                                  //   133
+	pev->effects = EF_NODRAW;
-//	}
+	pev->movetype = MOVETYPE_NONE;
+
+	float flSpriteScale = (m_iMagnitude - 50) * 0.6f;
+
+	if (flSpriteScale < 10.0f)
+	{
+		flSpriteScale = 10.0f;
+	}
+
+	m_spriteScale = (int)flSpriteScale;
 }
 
 /* <7f233> ../cstrike/dlls/explode.cpp:150 */
-NOBODY void CEnvExplosion::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CEnvExplosion::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
-//	{
+	TraceResult tr;
-//		TraceResult tr;                                       //   152
+
-//		Vector vecSpot;                                 //   157
+	pev->model = iStringNull;//invisible
-//		operator+(const Vector *const this,
+	pev->solid = SOLID_NOT;//intangible
-//				const Vector &v);  //   159
+
-//		operator+(const Vector *const this,
+	Vector vecSpot;// trace starts here!
-//				const Vector &v);  //   161
+
-//		MESSAGE_BEGIN(int msg_dest,
+	vecSpot = pev->origin + Vector(0, 0, 8);
-//				int msg_type,
+
-//				const float *pOrigin,
+	UTIL_TraceLine(vecSpot, vecSpot + Vector (0, 0, -40), ignore_monsters, ENT(pev), & tr);
-//				edict_t *ed);  //   189
+
-//		{
+	// Pull out of the wall a bit
-//			int sparkCount;                               //   226
+	if (tr.flFraction != 1.0f)
-//			{
+	{
-//				int i;                                //   228
+		pev->origin = tr.vecEndPos + (tr.vecPlaneNormal * (m_iMagnitude - 24) * 0.6f);
-//			}
+	}
-//		}
+	else
-//		operator*(const Vector *const this,
+	{
-//				float fl);  //   166
+		pev->origin = pev->origin;
-//		operator*(const Vector *const this,
+	}
-//				float fl);  //   166
+
-//		operator+(const Vector *const this,
+	// draw decal
-//				const Vector &v);  //   166
+	if (! (pev->spawnflags & SF_ENVEXPLOSION_NODECAL))
-//		MESSAGE_BEGIN(int msg_dest,
+	{
-//				int msg_type,
+		if (RANDOM_FLOAT(0, 1) < 0.5)
-//				const float *pOrigin,
+		{
-//				edict_t *ed);  //   202
+			UTIL_DecalTrace(&tr, DECAL_SCORCH1);
-//	}
+		}
+		else
+		{
+			UTIL_DecalTrace(&tr, DECAL_SCORCH2);
+		}
+	}
+
+	// draw fireball
+	if (!(pev->spawnflags & SF_ENVEXPLOSION_NOFIREBALL))
+	{
+		MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
+			WRITE_BYTE(TE_EXPLOSION);
+			WRITE_COORD(pev->origin.x);
+			WRITE_COORD(pev->origin.y);
+			WRITE_COORD(pev->origin.z);
+			WRITE_SHORT(g_sModelIndexFireball);
+			WRITE_BYTE((byte)m_spriteScale); // scale * 10
+			WRITE_BYTE(15); // framerate
+			WRITE_BYTE(TE_EXPLFLAG_NONE);
+		MESSAGE_END();
+	}
+	else
+	{
+		MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
+			WRITE_BYTE(TE_EXPLOSION);
+			WRITE_COORD(pev->origin.x);
+			WRITE_COORD(pev->origin.y);
+			WRITE_COORD(pev->origin.z);
+			WRITE_SHORT(g_sModelIndexFireball);
+			WRITE_BYTE(0); // no sprite
+			WRITE_BYTE(15); // framerate
+			WRITE_BYTE(TE_EXPLFLAG_NONE);
+		MESSAGE_END();
+	}
+
+	// do damage
+	if (!(pev->spawnflags & SF_ENVEXPLOSION_NODAMAGE))
+	{
+		RadiusDamage(pev, pev, m_iMagnitude, CLASS_NONE, DMG_BLAST);
+	}
+
+	SetThink(&CEnvExplosion::Smoke);
+	pev->nextthink = gpGlobals->time + 0.3f;
+
+	// draw sparks
+	if (!(pev->spawnflags & SF_ENVEXPLOSION_NOSPARKS))
+	{
+		int sparkCount = RANDOM_LONG(0, 3);
+
+		for (int i = 0; i < sparkCount; i++)
+		{
+			Create("spark_shower", pev->origin, tr.vecPlaneNormal, NULL);
+		}
+	}
 }
 
 /* <7f1e1> ../cstrike/dlls/explode.cpp:235 */
-NOBODY void CEnvExplosion::Smoke(void)
+void CEnvExplosion::Smoke(void)
 {
-//	MESSAGE_BEGIN(int msg_dest,
+	if (!(pev->spawnflags & SF_ENVEXPLOSION_NOSMOKE))
-//			int msg_type,
+	{
-//			const float *pOrigin,
+		MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pev->origin);
-//			edict_t *ed);  //   239
+			WRITE_BYTE(TE_SMOKE);
+			WRITE_COORD(pev->origin.x);
+			WRITE_COORD(pev->origin.y);
+			WRITE_COORD(pev->origin.z);
+			WRITE_SHORT(g_sModelIndexSmoke);
+			WRITE_BYTE((byte)m_spriteScale); // scale * 10
+			WRITE_BYTE(12); // framerate
+		MESSAGE_END();
+	}
+
+	if (!(pev->spawnflags & SF_ENVEXPLOSION_REPEATABLE))
+	{
+		UTIL_Remove(this);
+	}
 }
 
+// HACKHACK -- create one of these and fake a keyvalue to get the right explosion setup
+
 /* <7f7f4> ../cstrike/dlls/explode.cpp:258 */
-NOBODY void ExplosionCreate(Vector &center, Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage)
+void ExplosionCreate(Vector &center, Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage)
 {
-//	{
+	KeyValueData kvd;
-//		KeyValueData kvd;                                     //   260
+	char buf[128];
-//		char buf;                                             //   261
+
-//		class CBaseEntity *pExplosion;                       //   263
+	CBaseEntity *pExplosion = CBaseEntity::Create("env_explosion", center, angles, pOwner);
-//	}
+
+	Q_sprintf(buf, "%3d", magnitude);
+
+	kvd.szKeyName = "iMagnitude";
+	kvd.szValue = buf;
+
+	pExplosion->KeyValue(&kvd);
+
+	if (!doDamage)
+	{
+		pExplosion->pev->spawnflags |= SF_ENVEXPLOSION_NODAMAGE;
+	}
+
+	pExplosion->Spawn();
+	pExplosion->Use(NULL, NULL, USE_TOGGLE, 0);
 }
 
 #ifdef HOOK_GAMEDLL

regamedll/dlls/explode.h

@@ -43,13 +43,13 @@
 class CShower: public CBaseEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual int ObjectCaps(void)
+	virtual int ObjectCaps(void)
 	{
 		return ObjectCaps_();
 	}
-	NOBODY virtual void Think(void);
+	virtual void Think(void);
-	NOBODY virtual void Touch(CBaseEntity *pOther);
+	virtual void Touch(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
 
@@ -69,11 +69,11 @@ public:
 class CEnvExplosion: public CBaseMonster
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual int Save(CSave &save);
+	virtual int Save(CSave &save);
-	NOBODY virtual int Restore(CRestore &restore);
+	virtual int Restore(CRestore &restore);
-	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 #ifdef HOOK_GAMEDLL
 
@@ -86,7 +86,7 @@ public:
 #endif // HOOK_GAMEDLL
 
 public:
-	NOBODY void EXPORT Smoke(void);
+	void EXPORT Smoke(void);
 
 public:
 	static TYPEDESCRIPTION IMPLEMENT_ARRAY(m_SaveData)[2];
@@ -97,6 +97,10 @@ public:
 
 };/* size: 412, cachelines: 7, members: 4 */
 
-NOBODY void ExplosionCreate(Vector &center, Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage);
+void ExplosionCreate(Vector &center, Vector &angles, edict_t *pOwner, int magnitude, BOOL doDamage);
+
+// linked objects
+C_DLLEXPORT void spark_shower(entvars_t *pev);
+C_DLLEXPORT void env_explosion(entvars_t *pev);
 
 #endif // EXPLODE_H

regamedll/dlls/extdll.h

@@ -87,7 +87,6 @@ typedef float vec_t;					// needed before including progdefs.h
 #include "vector.h"
 // Defining it as a (bogus) struct helps enforce type-checking
 #define vec3_t Vector
-#define TI_LOX
 // Shared engine/DLL constants
 
 #include "const.h"

regamedll/dlls/func_break.cpp

@@ -122,7 +122,7 @@ TYPEDESCRIPTION (*CPushable::pm_SaveData)[2];
 #endif // HOOK_GAMEDLL
 
 /* <85bf3> ../cstrike/dlls/func_break.cpp:76 */
-NOBODY void CBreakable::KeyValue_(KeyValueData *pkvd)
+NOBODY void CBreakable::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //    90
@@ -158,12 +158,12 @@ LINK_ENTITY_TO_CLASS(func_breakable, CBreakable);
 IMPLEMENT_SAVERESTORE(CBreakable, CBaseEntity);
 
 /* <85663> ../cstrike/dlls/func_break.cpp:157 */
-NOBODY void CBreakable::Spawn_(void)
+NOBODY void CBreakable::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <8568a> ../cstrike/dlls/func_break.cpp:191 */
-NOBODY void CBreakable::Restart_(void)
+NOBODY void CBreakable::__MAKE_VHOOK(Restart)(void)
 {
 }
 
@@ -178,7 +178,6 @@ const char **CBreakable::MaterialSoundList(Materials precacheMaterial, int &soun
 		{
 			pSoundList = pSoundsWood;
 			soundCount = ARRAYSIZE(pSoundsWood);
-			const int dad = ARRAYSIZE(pSoundsConcrete);
 			break;
 		}
 		case matFlesh:
@@ -218,15 +217,17 @@ const char **CBreakable::MaterialSoundList(Materials precacheMaterial, int &soun
 }
 
 /* <86526> ../cstrike/dlls/func_break.cpp:303 */
-NOBODY void CBreakable::MaterialSoundPrecache(Materials precacheMaterial)
+void CBreakable::MaterialSoundPrecache(Materials precacheMaterial)
-{
+{
-//	{
+	const char **pSoundList;
-//		const char ** pSoundList;                           //   305
+	int i, soundCount = 0;
-//		int i;                                                //   306
+
-//		int soundCount;                                       //   306
+	pSoundList = MaterialSoundList(precacheMaterial, soundCount);
-//		MaterialSoundList(Materials precacheMaterial,
+
-//					int &soundCount);  //   308
+	for (i = 0; i < soundCount; i++)
-//	}
+	{
+		PRECACHE_SOUND((char *)pSoundList[i]);
+	}
 }
 
 /* <86598> ../cstrike/dlls/func_break.cpp:316 */
@@ -236,11 +237,13 @@ void CBreakable::MaterialSoundRandom(edict_t *pEdict, Materials soundMaterial, f
 	const char **pSoundList = MaterialSoundList(soundMaterial, soundCount);
 
 	if (soundCount)
+	{
 		EMIT_SOUND(pEdict, CHAN_BODY, pSoundList[ RANDOM_LONG(0, soundCount - 1) ], volume, 1.0);
+	}
 }
 
 /* <8634b> ../cstrike/dlls/func_break.cpp:328 */
-NOBODY void CBreakable::Precache_(void)
+NOBODY void CBreakable::__MAKE_VHOOK(Precache)(void)
 {
 //	{
 //		const char *pGibName;                               //   330
@@ -271,7 +274,7 @@ NOBODY void CBreakable::BreakTouch(CBaseEntity *pOther)
 }
 
 /* <85f2d> ../cstrike/dlls/func_break.cpp:538 */
-NOBODY void CBreakable::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CBreakable::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	Use(CBreakable *const this,
 //		class CBaseEntity *pActivator,
@@ -281,7 +284,7 @@ NOBODY void CBreakable::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_
 }
 
 /* <85964> ../cstrike/dlls/func_break.cpp:554 */
-NOBODY void CBreakable::TraceAttack_(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
+NOBODY void CBreakable::__MAKE_VHOOK(TraceAttack)(entvars_t *pevAttacker, float flDamage, Vector vecDir, TraceResult *ptr, int bitsDamageType)
 {
 //	{
 //		float flVolume;                                       //   565
@@ -301,7 +304,7 @@ NOBODY void CBreakable::TraceAttack_(entvars_t *pevAttacker, float flDamage, Vec
 }
 
 /* <86719> ../cstrike/dlls/func_break.cpp:588 */
-NOBODY int CBreakable::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+NOBODY int CBreakable::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 //	{
 //		Vector vecTemp;                                 //   590
@@ -367,7 +370,7 @@ NOBODY BOOL CBreakable::IsBreakable(void)
 }
 
 /* <85a99> ../cstrike/dlls/func_break.cpp:839 */
-NOBODY int CBreakable::DamageDecal_(int bitsDamageType)
+NOBODY int CBreakable::__MAKE_VHOOK(DamageDecal)(int bitsDamageType)
 {
 //	DamageDecal(CBreakable *const this,
 //			int bitsDamageType);  //   839
@@ -380,12 +383,12 @@ LINK_ENTITY_TO_CLASS(func_pushable, CPushable);
 IMPLEMENT_SAVERESTORE(CPushable, CBreakable);
 
 /* <856d7> ../cstrike/dlls/func_break.cpp:893 */
-NOBODY void CPushable::Spawn_(void)
+NOBODY void CPushable::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <863eb> ../cstrike/dlls/func_break.cpp:920 */
-NOBODY void CPushable::Precache_(void)
+NOBODY void CPushable::__MAKE_VHOOK(Precache)(void)
 {
 //	{
 //		int i;                                                //   922
@@ -393,7 +396,7 @@ NOBODY void CPushable::Precache_(void)
 }
 
 /* <85fa3> ../cstrike/dlls/func_break.cpp:930 */
-NOBODY void CPushable::KeyValue_(KeyValueData *pkvd)
+NOBODY void CPushable::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	{
 //		int bbox;                                             //   934
@@ -410,7 +413,7 @@ NOBODY void CPushable::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <86c0d> ../cstrike/dlls/func_break.cpp:969 */
-NOBODY void CPushable::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CPushable::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	Use(CPushable *const this,
 //		class CBaseEntity *pActivator,
@@ -422,7 +425,7 @@ NOBODY void CPushable::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_T
 }
 
 /* <86b99> ../cstrike/dlls/func_break.cpp:983 */
-NOBODY void CPushable::Touch_(CBaseEntity *pOther)
+NOBODY void CPushable::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
 //	FClassnameIs(entvars_t *pev,
 //			const char *szClassname);  //   985
@@ -449,7 +452,7 @@ NOBODY void CPushable::Move(CBaseEntity *pOther, int push)
 }
 
 /* <868b0> ../cstrike/dlls/func_break.cpp:1061 */
-NOBODY int CPushable::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+NOBODY int CPushable::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 //	TakeDamage(CPushable *const this,
 //			entvars_t *pevInflictor,

regamedll/dlls/func_break.h

@@ -136,7 +136,7 @@ public:
 		pev->impulse = magnitude;
 	}
 
-	NOBODY static void MaterialSoundPrecache(Materials precacheMaterial);
+	static void MaterialSoundPrecache(Materials precacheMaterial);
 	static void MaterialSoundRandom(edict_t *pEdict, Materials soundMaterial, float volume);
 	static const char **MaterialSoundList(Materials precacheMaterial, int &soundCount);
 

regamedll/dlls/func_tank.cpp

@@ -55,7 +55,7 @@ TYPEDESCRIPTION (*CFuncTankControls::pm_SaveData)[1];
 #endif // HOOK_GAMEDLL
 
 /* <8ea25> ../cstrike/dlls/func_tank.cpp:177 */
-NOBODY void CFuncTank::Spawn_(void)
+NOBODY void CFuncTank::__MAKE_VHOOK(Spawn)(void)
 {
 //	IsActive(CFuncTank *const this);  //   188
 //	BarrelPosition(CFuncTank *const this);  //   191
@@ -65,13 +65,13 @@ NOBODY void CFuncTank::Spawn_(void)
 IMPLEMENT_SAVERESTORE(CFuncTank, CBaseEntity);
 
 /* <8d64d> ../cstrike/dlls/func_tank.cpp:202 */
-NOBODY void CFuncTank::Precache_(void)
+NOBODY void CFuncTank::__MAKE_VHOOK(Precache)(void)
 {
 //	Precache(CFuncTank *const this);  //   202
 }
 
 /* <8e19e> ../cstrike/dlls/func_tank.cpp:214 */
-NOBODY void CFuncTank::KeyValue_(KeyValueData *pkvd)
+NOBODY void CFuncTank::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   226
@@ -131,7 +131,7 @@ NOBODY void CFuncTank::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <8dca8> ../cstrike/dlls/func_tank.cpp:329 */
-NOBODY BOOL CFuncTank::OnControls_(entvars_t *pevTest)
+NOBODY BOOL CFuncTank::__MAKE_VHOOK(OnControls)(entvars_t *pevTest)
 {
 //	{
 //		Vector offset;                                  //   334
@@ -165,7 +165,7 @@ NOBODY void CFuncTank::ControllerPostFrame(void)
 }
 
 /* <8ee12> ../cstrike/dlls/func_tank.cpp:424 */
-NOBODY void CFuncTank::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CFuncTank::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	IsActive(CFuncTank *const this);  //   448
 //	IsActive(CFuncTank *const this);  //   451
@@ -186,7 +186,7 @@ NOBODY BOOL CFuncTank::InRange(float range)
 }
 
 /* <8f717> ../cstrike/dlls/func_tank.cpp:477 */
-NOBODY void CFuncTank::Think_(void)
+NOBODY void CFuncTank::__MAKE_VHOOK(Think)(void)
 {
 //	fabs(double __x);  //   482
 //	fabs(double __x);  //   482
@@ -268,7 +268,7 @@ NOBODY void CFuncTank::AdjustAnglesForBarrel(Vector &angles, float distance)
 }
 
 /* <8d4ad> ../cstrike/dlls/func_tank.cpp:656 */
-NOBODY void CFuncTank::Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
+NOBODY void CFuncTank::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
 {
 //	{
 //		class CSprite *pSprite;                              //   662
@@ -347,7 +347,7 @@ NOBODY void CFuncTank::StopRotSound(void)
 LINK_ENTITY_TO_CLASS(func_tank, CFuncTankGun);
 
 /* <8c3d5> ../cstrike/dlls/func_tank.cpp:726 */
-NOBODY void CFuncTankGun::Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
+NOBODY void CFuncTankGun::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
 {
 //	{
 //		int i;                                                //   728
@@ -368,14 +368,14 @@ LINK_ENTITY_TO_CLASS(func_tanklaser, CFuncTankLaser);
 IMPLEMENT_SAVERESTORE(CFuncTankLaser, CFuncTank);
 
 /* <8deed> ../cstrike/dlls/func_tank.cpp:795 */
-NOBODY void CFuncTankLaser::Activate_(void)
+NOBODY void CFuncTankLaser::__MAKE_VHOOK(Activate)(void)
 {
 //	GetLaser(CFuncTankLaser *const this);  //   797
 //	Activate(CFuncTankLaser *const this);  //   795
 }
 
 /* <8e8ca> ../cstrike/dlls/func_tank.cpp:809 */
-NOBODY void CFuncTankLaser::KeyValue_(KeyValueData *pkvd)
+NOBODY void CFuncTankLaser::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   811
@@ -402,12 +402,12 @@ NOBODY CLaser *CFuncTankLaser::GetLaser(void)
 }
 
 /* <8f809> ../cstrike/dlls/func_tank.cpp:845 */
-NOBODY void CFuncTankLaser::Think_(void)
+NOBODY void CFuncTankLaser::__MAKE_VHOOK(Think)(void)
 {
 }
 
 /* <8df51> ../cstrike/dlls/func_tank.cpp:854 */
-NOBODY void CFuncTankLaser::Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
+NOBODY void CFuncTankLaser::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
 {
 //	{
 //		int i;                                                //   856
@@ -427,13 +427,13 @@ NOBODY void CFuncTankLaser::Fire_(const Vector &barrelEnd, const Vector &forward
 LINK_ENTITY_TO_CLASS(func_tankrocket, CFuncTankRocket);
 
 /* <8e736> ../cstrike/dlls/func_tank.cpp:895 */
-NOBODY void CFuncTankRocket::Precache_(void)
+NOBODY void CFuncTankRocket::__MAKE_VHOOK(Precache)(void)
 {
 //	Precache(CFuncTank *const this);  //   898
 }
 
 /* <8d7b6> ../cstrike/dlls/func_tank.cpp:903 */
-NOBODY void CFuncTankRocket::Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
+NOBODY void CFuncTankRocket::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
 {
 //	{
 //		int i;                                                //   905
@@ -454,7 +454,7 @@ NOBODY void CFuncTankRocket::Fire_(const Vector &barrelEnd, const Vector &forwar
 LINK_ENTITY_TO_CLASS(func_tankmortar, CFuncTankMortar);
 
 /* <8e790> ../cstrike/dlls/func_tank.cpp:933 */
-NOBODY void CFuncTankMortar::KeyValue_(KeyValueData *pkvd)
+NOBODY void CFuncTankMortar::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   935
@@ -465,7 +465,7 @@ NOBODY void CFuncTankMortar::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <8dbfa> ../cstrike/dlls/func_tank.cpp:945 */
-NOBODY void CFuncTankMortar::Fire_(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
+NOBODY void CFuncTankMortar::__MAKE_VHOOK(Fire)(const Vector &barrelEnd, const Vector &forward, entvars_t *pevAttacker)
 {
 //	{
 //		int bulletCount;                                      //   949
@@ -486,12 +486,12 @@ LINK_ENTITY_TO_CLASS(func_tankcontrols, CFuncTankControls);
 IMPLEMENT_SAVERESTORE(CFuncTankControls, CBaseEntity);
 
 /* <8d310> ../cstrike/dlls/func_tank.cpp:1003 */
-NOBODY void CFuncTankControls::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CFuncTankControls::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 }
 
 /* <8d39a> ../cstrike/dlls/func_tank.cpp:1012 */
-NOBODY void CFuncTankControls::Think_(void)
+NOBODY void CFuncTankControls::__MAKE_VHOOK(Think)(void)
 {
 //	{
 //		edict_t *pTarget;                                    //  1014
@@ -504,7 +504,7 @@ NOBODY void CFuncTankControls::Think_(void)
 }
 
 /* <8d373> ../cstrike/dlls/func_tank.cpp:1030 */
-NOBODY void CFuncTankControls::Spawn_(void)
+NOBODY void CFuncTankControls::__MAKE_VHOOK(Spawn)(void)
 {
 }
 

regamedll/dlls/game.cpp

@@ -11,88 +11,87 @@ cvar_t *g_footsteps = NULL;
 cvar_t *g_psv_accelerate = NULL;
 cvar_t *g_psv_friction = NULL;
 cvar_t *g_psv_stopspeed = NULL;
+cvar_t displaysoundlist = { "displaysoundlist", "0", 0, 0.0f, NULL };
+cvar_t timelimit = { "mp_timelimit", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t flashlight = { "mp_flashlight", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t decalfrequency = { "decalfrequency", "30", FCVAR_SERVER, 0.0f, NULL };
+cvar_t fadetoblack = { "mp_fadetoblack", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t fragsleft = { "mp_fragsleft", "", FCVAR_SERVER | FCVAR_UNLOGGED, 0.0f, NULL };
+cvar_t timeleft = { "mp_timeleft", "0", FCVAR_SERVER | FCVAR_UNLOGGED, 0.0f, NULL };
+cvar_t friendlyfire = { "mp_friendlyfire", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t allowmonsters = { "mp_allowmonsters", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t roundtime = { "mp_roundtime", "5", FCVAR_SERVER, 0.0f, NULL };
+cvar_t buytime = { "mp_buytime", "1.5", FCVAR_SERVER, 0.0f, NULL };
+cvar_t freezetime = { "mp_freezetime", "6", FCVAR_SERVER, 0.0f, NULL };
+cvar_t c4timer = { "mp_c4timer", "45", FCVAR_SERVER, 0.0f, NULL };
+cvar_t ghostfrequency = { "mp_ghostfrequency", "0.1", FCVAR_SERVER, 0.0f, NULL };
+cvar_t autokick = { "mp_autokick", "1", FCVAR_SERVER, 0.0f, NULL };
+cvar_t autokick_timeout = { "mp_autokick_timeout", "-1", FCVAR_SERVER, 0.0f, NULL };
+cvar_t restartround = { "sv_restartround", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t sv_restart = { "sv_restart", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t limitteams = { "mp_limitteams", "2", FCVAR_SERVER, 0.0f, NULL };
+cvar_t autoteambalance = { "mp_autoteambalance", "1", FCVAR_SERVER, 0.0f, NULL };
+cvar_t tkpunish = { "mp_tkpunish", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t hostagepenalty = { "mp_hostagepenalty", "13", FCVAR_SERVER, 0.0f, NULL };
+cvar_t mirrordamage = { "mp_mirrordamage", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t logmessages = { "mp_logmessages", "1", FCVAR_SERVER, 0.0f, NULL };
+cvar_t forcecamera = { "mp_forcecamera", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t forcechasecam = { "mp_forcechasecam", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t mapvoteratio = { "mp_mapvoteratio", "0.66", FCVAR_SERVER, 0.0f, NULL };
+cvar_t logdetail = { "mp_logdetail", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t startmoney = { "mp_startmoney", "800", FCVAR_SERVER, 0.0f, NULL };
+cvar_t maxrounds = { "mp_maxrounds", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t winlimit = { "mp_winlimit", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t windifference = { "mp_windifference", "1", FCVAR_SERVER, 0.0f, NULL };
+cvar_t playerid = { "mp_playerid", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t allow_spectators = { "allow_spectators", "1.0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t mp_chattime = { "mp_chattime", "10", FCVAR_SERVER, 0.0f, NULL };
+cvar_t kick_percent = { "mp_kickpercent", "0.66", FCVAR_SERVER, 0.0f, NULL };
+cvar_t humans_join_team = { "humans_join_team", "0", FCVAR_SERVER, 0.0f, NULL };
+cvar_t sk_plr_9mm_bullet1 = { "sk_plr_9mm_bullet1", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_9mm_bullet2 = { "sk_plr_9mm_bullet2", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_9mm_bullet3 = { "sk_plr_9mm_bullet3", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_357_bullet1 = { "sk_plr_357_bullet1", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_357_bullet2 = { "sk_plr_357_bullet2", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_357_bullet3 = { "sk_plr_357_bullet3", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_9mmAR_bullet1 = { "sk_plr_9mmAR_bullet1", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_9mmAR_bullet2 = { "sk_plr_9mmAR_bullet2", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_9mmAR_bullet3 = { "sk_plr_9mmAR_bullet3", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_9mmAR_grenade1 = { "sk_plr_9mmAR_grenade1", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_9mmAR_grenade2 = { "sk_plr_9mmAR_grenade2", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_9mmAR_grenade3 = { "sk_plr_9mmAR_grenade3", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_buckshot1 = { "sk_plr_buckshot1", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_buckshot2 = { "sk_plr_buckshot2", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_buckshot3 = { "sk_plr_buckshot3", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_rpg1 = { "sk_plr_rpg1", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_rpg2 = { "sk_plr_rpg2", "0", 0, 0.0f, NULL };
+cvar_t sk_plr_rpg3 = { "sk_plr_rpg3", "0", 0, 0.0f, NULL };
+cvar_t sk_12mm_bullet1 = { "sk_12mm_bullet1", "0", 0, 0.0f, NULL };
+cvar_t sk_12mm_bullet2 = { "sk_12mm_bullet2", "0", 0, 0.0f, NULL };
+cvar_t sk_12mm_bullet3 = { "sk_12mm_bullet3", "0", 0, 0.0f, NULL };
+cvar_t sk_9mmAR_bullet1 = { "sk_9mmAR_bullet1", "0", 0, 0.0f, NULL };
+cvar_t sk_9mmAR_bullet2 = { "sk_9mmAR_bullet2", "0", 0, 0.0f, NULL };
+cvar_t sk_9mmAR_bullet3 = { "sk_9mmAR_bullet3", "0", 0, 0.0f, NULL };
+cvar_t sk_9mm_bullet1 = { "sk_9mm_bullet1", "0", 0, 0.0f, NULL };
+cvar_t sk_9mm_bullet2 = { "sk_9mm_bullet2", "0", 0, 0.0f, NULL };
+cvar_t sk_9mm_bullet3 = { "sk_9mm_bullet3", "0", 0, 0.0f, NULL };
+cvar_t sk_suitcharger1 = { "sk_suitcharger1", "0", 0, 0.0f, NULL };
+cvar_t sk_suitcharger2 = { "sk_suitcharger2", "0", 0, 0.0f, NULL };
+cvar_t sk_suitcharger3 = { "sk_suitcharger3", "0", 0, 0.0f, NULL };
+cvar_t sk_battery1 = { "sk_battery1", "0", 0, 0.0f, NULL };
+cvar_t sk_battery2 = { "sk_battery2", "0", 0, 0.0f, NULL };
+cvar_t sk_battery3 = { "sk_battery3", "0", 0, 0.0f, NULL };
+cvar_t sk_healthcharger1 = { "sk_healthcharger1", "0", 0, 0.0f, NULL };
+cvar_t sk_healthcharger2 = { "sk_healthcharger2", "0", 0, 0.0f, NULL };
+cvar_t sk_healthcharger3 = { "sk_healthcharger3", "0", 0, 0.0f, NULL };
+cvar_t sk_healthkit1 = { "sk_healthkit1", "0", 0, 0.0f, NULL };
+cvar_t sk_healthkit2 = { "sk_healthkit2", "0", 0, 0.0f, NULL };
+cvar_t sk_healthkit3 = { "sk_healthkit3", "0", 0, 0.0f, NULL };
+cvar_t sk_scientist_heal1 = { "sk_scientist_heal1", "0", 0, 0.0f, NULL };
+cvar_t sk_scientist_heal2 = { "sk_scientist_heal2", "0", 0, 0.0f, NULL };
+cvar_t sk_scientist_heal3 = { "sk_scientist_heal3", "0", 0, 0.0f, NULL };
 
-cvar_t displaysoundlist = { "displaysoundlist", "0" };
+#else // HOOK_GAMEDLL
-cvar_t timelimit = { "mp_timelimit", "0", FCVAR_SERVER };
-cvar_t flashlight = { "mp_flashlight", "0", FCVAR_SERVER };
-cvar_t decalfrequency = { "decalfrequency", "30", FCVAR_SERVER };
-cvar_t fadetoblack = { "mp_fadetoblack", "0", FCVAR_SERVER };
-cvar_t fragsleft = { "mp_fragsleft", "", FCVAR_SERVER|FCVAR_UNLOGGED };
-cvar_t timeleft = { "mp_timeleft", "0", FCVAR_SERVER|FCVAR_UNLOGGED };
-cvar_t friendlyfire = { "mp_friendlyfire", "0", FCVAR_SERVER };
-cvar_t allowmonsters = { "mp_allowmonsters", "0", FCVAR_SERVER };
-cvar_t roundtime = { "mp_roundtime", "5", FCVAR_SERVER };
-cvar_t buytime = { "mp_buytime", "1.5", FCVAR_SERVER };
-cvar_t freezetime = { "mp_freezetime", "6", FCVAR_SERVER };
-cvar_t c4timer = { "mp_c4timer", "45", FCVAR_SERVER };
-cvar_t ghostfrequency = { "mp_ghostfrequency", "0.1", FCVAR_SERVER };
-cvar_t autokick = { "mp_autokick", "1", FCVAR_SERVER };
-cvar_t autokick_timeout = { "mp_autokick_timeout", "-1", FCVAR_SERVER };
-cvar_t restartround = { "sv_restartround", "0", FCVAR_SERVER };
-cvar_t sv_restart = { "sv_restart", "0", FCVAR_SERVER };
-cvar_t limitteams = { "mp_limitteams", "2", FCVAR_SERVER };
-cvar_t autoteambalance = { "mp_autoteambalance", "1", FCVAR_SERVER };
-cvar_t tkpunish = { "mp_tkpunish", "0", FCVAR_SERVER };
-cvar_t hostagepenalty = { "mp_hostagepenalty", "13", FCVAR_SERVER };
-cvar_t mirrordamage = { "mp_mirrordamage", "0", FCVAR_SERVER };
-cvar_t logmessages = { "mp_logmessages", "1", FCVAR_SERVER };
-cvar_t forcecamera = { "mp_forcecamera", "0", FCVAR_SERVER };
-cvar_t forcechasecam = { "mp_forcechasecam", "0", FCVAR_SERVER };
-cvar_t mapvoteratio = { "mp_mapvoteratio", "0.66", FCVAR_SERVER };
-cvar_t logdetail = { "mp_logdetail", "0", FCVAR_SERVER };
-cvar_t startmoney = { "mp_startmoney", "800", FCVAR_SERVER };
-cvar_t maxrounds = { "mp_maxrounds", "0", FCVAR_SERVER };
-cvar_t winlimit = { "mp_winlimit", "0", FCVAR_SERVER };
-cvar_t windifference = { "mp_windifference", "1", FCVAR_SERVER };
-cvar_t playerid = { "mp_playerid", "0", FCVAR_SERVER };
-cvar_t allow_spectators = { "allow_spectators", "1.0", FCVAR_SERVER };
-cvar_t mp_chattime = { "mp_chattime", "10", FCVAR_SERVER };
-cvar_t kick_percent = { "mp_kickpercent", "0.66", FCVAR_SERVER };
-cvar_t humans_join_team = { "humans_join_team", "0", FCVAR_SERVER };
-cvar_t sk_plr_9mm_bullet1 = { "sk_plr_9mm_bullet1", "0" };
-cvar_t sk_plr_9mm_bullet2 = { "sk_plr_9mm_bullet2", "0" };
-cvar_t sk_plr_9mm_bullet3 = { "sk_plr_9mm_bullet3", "0" };
-cvar_t sk_plr_357_bullet1 = { "sk_plr_357_bullet1", "0" };
-cvar_t sk_plr_357_bullet2 = { "sk_plr_357_bullet2", "0" };
-cvar_t sk_plr_357_bullet3 = { "sk_plr_357_bullet3", "0" };
-cvar_t sk_plr_9mmAR_bullet1 = { "sk_plr_9mmAR_bullet1", "0" };
-cvar_t sk_plr_9mmAR_bullet2 = { "sk_plr_9mmAR_bullet2", "0" };
-cvar_t sk_plr_9mmAR_bullet3 = { "sk_plr_9mmAR_bullet3", "0" };
-cvar_t sk_plr_9mmAR_grenade1 = { "sk_plr_9mmAR_grenade1", "0" };
-cvar_t sk_plr_9mmAR_grenade2 = { "sk_plr_9mmAR_grenade2", "0" };
-cvar_t sk_plr_9mmAR_grenade3 = { "sk_plr_9mmAR_grenade3", "0" };
-cvar_t sk_plr_buckshot1 = { "sk_plr_buckshot1", "0" };
-cvar_t sk_plr_buckshot2 = { "sk_plr_buckshot2", "0" };
-cvar_t sk_plr_buckshot3 = { "sk_plr_buckshot3", "0" };
-cvar_t sk_plr_rpg1 = { "sk_plr_rpg1", "0" };
-cvar_t sk_plr_rpg2 = { "sk_plr_rpg2", "0" };
-cvar_t sk_plr_rpg3 = { "sk_plr_rpg3", "0" };
-cvar_t sk_12mm_bullet1 = { "sk_12mm_bullet1", "0" };
-cvar_t sk_12mm_bullet2 = { "sk_12mm_bullet2", "0" };
-cvar_t sk_12mm_bullet3 = { "sk_12mm_bullet3", "0" };
-cvar_t sk_9mmAR_bullet1 = { "sk_9mmAR_bullet1", "0" };
-cvar_t sk_9mmAR_bullet2 = { "sk_9mmAR_bullet2", "0" };
-cvar_t sk_9mmAR_bullet3 = { "sk_9mmAR_bullet3", "0" };
-cvar_t sk_9mm_bullet1 = { "sk_9mm_bullet1", "0" };
-cvar_t sk_9mm_bullet2 = { "sk_9mm_bullet2", "0" };
-cvar_t sk_9mm_bullet3 = { "sk_9mm_bullet3", "0" };
-cvar_t sk_suitcharger1 = { "sk_suitcharger1", "0" };
-cvar_t sk_suitcharger2 = { "sk_suitcharger2", "0" };
-cvar_t sk_suitcharger3 = { "sk_suitcharger3", "0" };
-cvar_t sk_battery1 = { "sk_battery1", "0" };
-cvar_t sk_battery2 = { "sk_battery2", "0" };
-cvar_t sk_battery3 = { "sk_battery3", "0" };
-cvar_t sk_healthcharger1 = { "sk_healthcharger1", "0" };
-cvar_t sk_healthcharger2 = { "sk_healthcharger2", "0" };
-cvar_t sk_healthcharger3 = { "sk_healthcharger3", "0" };
-cvar_t sk_healthkit1 = { "sk_healthkit1", "0" };
-cvar_t sk_healthkit2 = { "sk_healthkit2", "0" };
-cvar_t sk_healthkit3 = { "sk_healthkit3", "0" };
-cvar_t sk_scientist_heal1 = { "sk_scientist_heal1", "0" };
-cvar_t sk_scientist_heal2 = { "sk_scientist_heal2", "0" };
-cvar_t sk_scientist_heal3 = { "sk_scientist_heal3", "0" };
-
-#else //HOOK_GAMEDLL
 
 cvar_t *g_psv_gravity;
 cvar_t *g_psv_aim;
@@ -402,7 +401,7 @@ cvar_t sk_scientist_heal3;
 //cvar_t sk_player_leg2;
 //cvar_t sk_player_leg3;
 
-#endif //HOOK_GAMEDLL
+#endif // HOOK_GAMEDLL
 
 /* <9c900> ../cstrike/dlls/game.cpp:500 */
 void GameDLLInit(void)

regamedll/dlls/game.h

@@ -221,6 +221,6 @@ extern cvar_t sk_scientist_heal1;
 extern cvar_t sk_scientist_heal2;
 extern cvar_t sk_scientist_heal3;
 
-NOBODY void GameDLLInit(void);
+void GameDLLInit(void);
 
 #endif // GAME_H

regamedll/dlls/gamerules.cpp

@@ -14,53 +14,87 @@ CHalfLifeMultiplay *g_pGameRules;
 #endif //HOOK_GAMEDLL
 
 /* <ad93d> ../cstrike/dlls/gamerules.cpp:36 */
-BOOL CGameRules::CanHaveAmmo_(CBasePlayer *pPlayer, const char *pszAmmoName, int iMaxCarry)
+BOOL CGameRules::__MAKE_VHOOK(CanHaveAmmo)(CBasePlayer *pPlayer, const char *pszAmmoName, int iMaxCarry)
 {
-	if (pszAmmoName)
+	int iAmmoIndex;
+
+	if (pszAmmoName != NULL)
 	{
-		int iAmmoIndex = pPlayer->GetAmmoIndex(pszAmmoName);
+		iAmmoIndex = pPlayer->GetAmmoIndex(pszAmmoName);
 
 		if (iAmmoIndex > -1)
 		{
 			if (pPlayer->AmmoInventory(iAmmoIndex) < iMaxCarry)
+			{
+				// player has room for more of this type of ammo
 				return TRUE;
+			}
 		}
 	}
+
 	return FALSE;
 }
 
 /* <ad89d> ../cstrike/dlls/gamerules.cpp:59 */
-NOBODY edict_t *CGameRules::GetPlayerSpawnSpot_(CBasePlayer *pPlayer)
+edict_t *CGameRules::__MAKE_VHOOK(GetPlayerSpawnSpot)(CBasePlayer *pPlayer)
 {
-//	{
+	edict_t *pentSpawnSpot = EntSelectSpawnPoint(pPlayer);
-//		edict_t *pentSpawnSpot;                              //    61
+
-//		VARS(edict_t *pent);  //    66
+	pPlayer->pev->origin = VARS(pentSpawnSpot)->origin;// + Vector(0, 0, 1);
-//		VARS(edict_t *pent);  //    63
+	pPlayer->pev->origin.z += 1;
-//		operator+(const Vector *const this,
+
-//				const Vector &v);  //    63
+	pPlayer->pev->v_angle = g_vecZero;
-//	}
+	pPlayer->pev->velocity = g_vecZero;
+	pPlayer->pev->angles = VARS(pentSpawnSpot)->angles;
+	pPlayer->pev->punchangle = g_vecZero;
+	pPlayer->pev->fixangle = 1;
+
+	return pentSpawnSpot;
 }
 
 /* <ad9a3> ../cstrike/dlls/gamerules.cpp:75 */
-NOBODY BOOL CGameRules::CanHavePlayerItem_(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
+BOOL CGameRules::__MAKE_VHOOK(CanHavePlayerItem)(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
 {
-	/*if (pPlayer->pev->deadflag != DEAD_NO)
+	// only living players can have items
+	if (pPlayer->pev->deadflag != DEAD_NO)
+	{
 		return FALSE;
+	}
 
 	CCSBotManager *ctrl = TheCSBots();
-	if (!pPlayer->AddPlayerItem(pWeapon) ||	ctrl->IsWeaponUseable(pWeapon))
+
+	if (pPlayer->IsBot() && !ctrl->IsWeaponUseable(pWeapon))
 	{
-		// TODO: check it
+		return FALSE;
-		if (pWeapon->pszAmmo1() && CanHaveAmmo(pPlayer,pWeapon->pszAmmo1(),pWeapon->iMaxAmmo1()) || !pPlayer->HasPlayerItem(pWeapon))
+	}
-		{
+
-			return TRUE;
+	if (pWeapon->pszAmmo1())
-		}
+	{
-	}*/
+		if (!CanHaveAmmo(pPlayer, pWeapon->pszAmmo1(), pWeapon->iMaxAmmo1()))
-	return FALSE;
+		{
+			// we can't carry anymore ammo for this gun. We can only 
+			// have the gun if we aren't already carrying one of this type
+			if (pPlayer->HasPlayerItem(pWeapon))
+			{
+				return FALSE;
+			}
+		}
+	}
+	else
+	{
+		// weapon doesn't use ammo, don't take another if you already have it.
+		if (pPlayer->HasPlayerItem(pWeapon))
+		{
+			return FALSE;
+		}
+	}
+
+	// note: will fall through to here if GetItemInfo doesn't fill the struct!
+	return TRUE;
 }
 
 /* <ad85d> ../cstrike/dlls/gamerules.cpp:119 */
-void CGameRules::RefreshSkillData_(void)
+void CGameRules::__MAKE_VHOOK(RefreshSkillData)(void)
 {
 	int iSkill = (int)CVAR_GET_FLOAT("skill");
 
@@ -82,38 +116,48 @@ void CGameRules::RefreshSkillData_(void)
 	gSkillData.healthkitCapacity = 15;
 }
 
+void (*pInstallGameRules)(void);
+
 /* <ada23> ../cstrike/dlls/gamerules.cpp:157 */
-NOBODY CGameRules *InstallGameRules(void)
+NOBODY __declspec(naked) CGameRules *InstallGameRules(void)
 {
+	__asm
+	{
+		jmp pInstallGameRules
+	}
+#if 0
 	SERVER_COMMAND("exec game.cfg\n");
 	SERVER_EXECUTE();
 
 	if (!gpGlobals->deathmatch)
+	{
 		return new CHalfLifeTraining;
+	}
 
 	return new CHalfLifeMultiplay;
+#endif
 }
 
 #ifdef HOOK_GAMEDLL
 
-BOOL CGameRules::CanHaveAmmo(CBasePlayer *pPlayer, const char *pszAmmoName, int iMaxCarry)
-{
-	return CanHaveAmmo_(pPlayer,pszAmmoName,iMaxCarry);
-}
-
-edict_t *CGameRules::GetPlayerSpawnSpot(CBasePlayer *pPlayer)
-{
-	return GetPlayerSpawnSpot_(pPlayer);
-}
-
-BOOL CGameRules::CanHavePlayerItem(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
-{
-	return CanHavePlayerItem_(pPlayer,pWeapon);
-}
-
 void CGameRules::RefreshSkillData(void)
 {
 	RefreshSkillData_();
-}
+}
+
+edict_t *CGameRules::GetPlayerSpawnSpot(CBasePlayer *pPlayer)
+{
+	return GetPlayerSpawnSpot_(pPlayer);
+}
+
+BOOL CGameRules::CanHavePlayerItem(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
+{
+	return CanHavePlayerItem_(pPlayer, pWeapon);
+}
+
+BOOL CGameRules::CanHaveAmmo(CBasePlayer *pPlayer, const char *pszAmmoName, int iMaxCarry)
+{
+	return CanHaveAmmo_(pPlayer, pszAmmoName, iMaxCarry);
+}
 
 #endif // HOOK_GAMEDLL

regamedll/dlls/gamerules.h

@@ -34,12 +34,111 @@
 
 #include "game_shared/voice_gamemgr.h"
 
-#define COM_TOKEN_LEN		1500
+#define COM_TOKEN_LEN			1500
 
-#define MAX_RULE_BUFFER		1024
+#define MAX_RULE_BUFFER			1024
-#define MAX_VOTE_MAPS		100
+#define MAX_VOTE_MAPS			100
-#define ITEM_RESPAWN_TIME	30
+#define MAX_VIP_QUEUES			5
-#define MAX_VIP_QUEUES		5
+
+#define MAX_BOMB_RADIUS			2048
+
+#define MAP_VIP_SAFETYZONE_INIT		0	// initial
+#define MAP_HAVE_VIP_SAFETYZONE_YES	1	// on map have of vip safety zone
+#define MAP_HAVE_VIP_SAFETYZONE_NO	2	// there is no safety zone
+
+#define MAP_HAS_CAMERAS_INIT		2	// initial
+#define MAP_HAS_CAMERAS_YES		1	// on map have of camera's
+
+#define ITEM_RESPAWN_TIME		30
+#define WEAPON_RESPAWN_TIME		20
+#define AMMO_RESPAWN_TIME		20
+
+// longest the intermission can last, in seconds
+#define MAX_INTERMISSION_TIME		120
+
+// when we are within this close to running out of entities,  items 
+// marked with the ITEM_FLAG_LIMITINWORLD will delay their respawn
+#define ENTITY_INTOLERANCE		100
+
+#define MAX_MOTD_CHUNK			60
+#define MAX_MOTD_LENGTH			1536 // (MAX_MOTD_CHUNK * 4)
+
+// custom enum
+enum
+{
+	WINSTATUS_CTS = 1,
+	WINSTATUS_TERRORISTS,
+	WINSTATUS_DRAW,
+};
+
+// custom enum
+enum ScenarionEventEndRound
+{
+	ROUND_TARGET_BOMB = 1,
+	ROUND_VIP_ESCAPED,
+	ROUND_VIP_ASSASSINATED,
+	ROUND_TERRORISTS_ESCAPED,
+	ROUND_CTS_PREVENT_ESCAPE,
+	ROUND_ESCAPING_TERRORISTS_NEUTRALIZED,
+	ROUND_BOMB_DEFUSED,
+	ROUND_CTS_WIN,
+	ROUND_TERRORISTS_WIN,
+	ROUND_END_DRAW,
+	ROUND_ALL_HOSTAGES_RESCUED,
+	ROUND_TARGET_SAVED,
+	ROUND_HOSTAGE_NOT_RESCUED,
+	ROUND_TERRORISTS_NOT_ESCAPED,
+	ROUND_VIP_NOT_ESCAPED,
+	ROUND_GAME_COMMENCE,
+};
+
+// custom enum
+enum RewardAccount
+{
+	REWARD_TARGET_BOMB		= 3500,
+	REWARD_VIP_ESCAPED		= 3500,
+	REWARD_VIP_ASSASSINATED		= 3250,
+	REWARD_TERRORISTS_ESCAPED	= 3150,
+	REWARD_CTS_PREVENT_ESCAPE	= 3500,
+	REWARD_ESCAPING_TERRORISTS_NEUTRALIZED	= 3250,
+	REWARD_BOMB_DEFUSED		= 3250,
+	REWARD_BOMB_PLANTED		= 800,
+	REWARD_BOMB_EXPLODED		= 3250,
+	REWARD_CTS_WIN			= 3000,
+	REWARD_TERRORISTS_WIN		= 3000,
+	REWARD_ALL_HOSTAGES_RESCUED	= 2500,
+
+	// the end round was by the expiration time
+	REWARD_TARGET_BOMB_SAVED	= 3250,
+	REWARD_HOSTAGE_NOT_RESCUED	= 3250,
+	REWARD_VIP_NOT_ESCAPED		= 3250,
+
+	// loser bonus
+	REWARD_LOSER_BONUS_DEFAULT	= 1400,
+	REWARD_LOSER_BONUS_MIN		= 1500,
+	REWARD_LOSER_BONUS_MAX		= 3000,
+	REWARD_LOSER_BONUS_ADD		= 500,
+
+	REWARD_RESCUED_HOSTAGE		= 750,
+	REWARD_KILLED_ENEMY		= 300,
+	REWARD_KILLED_VIP		= 2500,
+
+};
+
+// custom enum
+enum PaybackForBadThing
+{
+	PAYBACK_FOR_KILLED_TEAMMATES	= -3300,
+};
+
+// custom enum
+enum InfoMapBuyParam
+{
+	BUYING_EVERYONE = 0,
+	BUYING_ONLY_CTS,
+	BUYING_ONLY_TERRORISTS,
+	BUYING_NO_ONE,	
+};
 
 enum
 {
@@ -83,12 +182,12 @@ public:
 	virtual BOOL IsDeathmatch(void) = 0;
 	virtual BOOL IsTeamplay(void)
 	{
-		return FALSE;
+		return IsTeamplay_();
 	}
 	virtual BOOL IsCoOp(void) = 0;
 	virtual const char *GetGameDescription(void)
 	{
-		return "Counter-Strike";
+		return GetGameDescription_();
 	}
 	virtual BOOL ClientConnected(edict_t *pEntity, const char *pszName, const char *pszAddress, char *szRejectReason) = 0;
 	virtual void InitHUD(CBasePlayer *pl) = 0;
@@ -97,34 +196,34 @@ public:
 	virtual float FlPlayerFallDamage(CBasePlayer *pPlayer) = 0;
 	virtual BOOL FPlayerCanTakeDamage(CBasePlayer *pPlayer, CBaseEntity *pAttacker)
 	{
-		return TRUE;
+		return FPlayerCanTakeDamage_(pPlayer, pAttacker);
 	}
 	virtual BOOL ShouldAutoAim(CBasePlayer *pPlayer, edict_t *target)
 	{
-		return TRUE;
+		return ShouldAutoAim_(pPlayer, target);
 	}
 	virtual void PlayerSpawn(CBasePlayer *pPlayer) = 0;
 	virtual void PlayerThink(CBasePlayer *pPlayer) = 0;
 	virtual BOOL FPlayerCanRespawn(CBasePlayer *pPlayer) = 0;
 	virtual float FlPlayerSpawnTime(CBasePlayer *pPlayer) = 0;
-	NOBODY virtual edict_t *GetPlayerSpawnSpot(CBasePlayer *pPlayer);
+	virtual edict_t *GetPlayerSpawnSpot(CBasePlayer *pPlayer);
 	virtual BOOL AllowAutoTargetCrosshair(void)
 	{
-		return TRUE;
+		return AllowAutoTargetCrosshair_();
 	}
 	virtual BOOL ClientCommand_DeadOrAlive(CBasePlayer *pPlayer, const char *pcmd)
 	{
-		return FALSE;
+		return ClientCommand_DeadOrAlive_(pPlayer, pcmd);
 	}
 	virtual BOOL ClientCommand(CBasePlayer *pPlayer, const char *pcmd)
 	{
-		return FALSE;
+		return ClientCommand_(pPlayer, pcmd);
 	}
 	virtual void ClientUserInfoChanged(CBasePlayer *pPlayer, char *infobuffer) {}
 	virtual int IPointsForKill(CBasePlayer *pAttacker, CBasePlayer *pKilled) = 0;
 	virtual void PlayerKilled(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor) = 0;
 	virtual void DeathNotice(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pevInflictor) = 0;
-	NOBODY virtual BOOL CanHavePlayerItem(CBasePlayer *pPlayer, CBasePlayerItem *pItem);
+	virtual BOOL CanHavePlayerItem(CBasePlayer *pPlayer, CBasePlayerItem *pItem);
 	virtual void PlayerGotWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon) = 0;
 	virtual int WeaponShouldRespawn(CBasePlayerItem *pWeapon) = 0;
 	virtual float FlWeaponRespawnTime(CBasePlayerItem *pWeapon) = 0;
@@ -143,7 +242,7 @@ public:
 	virtual float FlHealthChargerRechargeTime(void) = 0;
 	virtual float FlHEVChargerRechargeTime(void)
 	{
-		return 0.0f;
+		return FlHEVChargerRechargeTime_();
 	}
 	virtual int DeadPlayerWeapons(CBasePlayer *pPlayer) = 0;
 	virtual int DeadPlayerAmmo(CBasePlayer *pPlayer) = 0;
@@ -151,40 +250,96 @@ public:
 	virtual int PlayerRelationship(CBasePlayer *pPlayer, CBaseEntity *pTarget) = 0;
 	virtual int GetTeamIndex(const char *pTeamName)
 	{
-		return -1;
+		return GetTeamIndex_(pTeamName);
 	}
 	virtual const char *GetIndexedTeamName(int teamIndex)
 	{
-		return "";
+		return GetIndexedTeamName_(teamIndex);
 	}
 	virtual BOOL IsValidTeam(const char *pTeamName)
 	{
-		return TRUE;
+		return IsValidTeam_(pTeamName);
 	}
 	virtual void ChangePlayerTeam(CBasePlayer *pPlayer, const char *pTeamName, BOOL bKill, BOOL bGib) {}
 	virtual const char *SetDefaultPlayerTeam(CBasePlayer *pPlayer)
 	{
-		return "";
+		return SetDefaultPlayerTeam_(pPlayer);
 	}
 	virtual BOOL PlayTextureSounds(void)
 	{
-		return TRUE;
+		return PlayTextureSounds_();
 	}
 	virtual BOOL FAllowMonsters(void) = 0;
 	virtual void EndMultiplayerGame(void) {}
 	virtual BOOL IsFreezePeriod(void)
 	{
-		return m_bFreezePeriod;
+		return IsFreezePeriod_();
 	}
 	virtual void ServerDeactivate(void) {}
 	virtual void CheckMapConditions(void) {}
 
 #ifdef HOOK_GAMEDLL
 
-	void RefreshSkillData_(void);
+	void RefreshSkillData_(void);
-	NOBODY edict_t *GetPlayerSpawnSpot_(CBasePlayer *pPlayer);
+	BOOL IsTeamplay_(void)
-	NOBODY BOOL CanHavePlayerItem_(CBasePlayer *pPlayer, CBasePlayerItem *pItem);
+	{
-	BOOL CanHaveAmmo_(CBasePlayer *pPlayer, const char *pszAmmoName, int iMaxCarry);
+		return FALSE;
+	}
+	const char *GetGameDescription_(void)
+	{
+		return "Counter-Strike";
+	}
+	BOOL FPlayerCanTakeDamage_(CBasePlayer *pPlayer, CBaseEntity *pAttacker)
+	{
+		return TRUE;
+	}
+	BOOL ShouldAutoAim_(CBasePlayer *pPlayer, edict_t *target)
+	{
+		return TRUE;
+	}
+	edict_t *GetPlayerSpawnSpot_(CBasePlayer *pPlayer);
+	BOOL AllowAutoTargetCrosshair_(void)
+	{
+		return TRUE;
+	}
+	BOOL ClientCommand_DeadOrAlive_(CBasePlayer *pPlayer, const char *pcmd)
+	{
+		return FALSE;
+	}
+	BOOL ClientCommand_(CBasePlayer *pPlayer, const char *pcmd)
+	{
+		return FALSE;
+	}
+	BOOL CanHavePlayerItem_(CBasePlayer *pPlayer, CBasePlayerItem *pItem);
+	BOOL CanHaveAmmo_(CBasePlayer *pPlayer, const char *pszAmmoName, int iMaxCarry);
+	float FlHEVChargerRechargeTime_(void)
+	{
+		return 0.0f;
+	}
+	int GetTeamIndex_(const char *pTeamName)
+	{
+		return -1;
+	}
+	const char *GetIndexedTeamName_(int teamIndex)
+	{
+		return "";
+	}
+	BOOL IsValidTeam_(const char *pTeamName)
+	{
+		return TRUE;
+	}
+	const char *SetDefaultPlayerTeam_(CBasePlayer *pPlayer)
+	{
+		return "";
+	}
+	BOOL PlayTextureSounds_(void)
+	{
+		return TRUE;
+	}
+	BOOL IsFreezePeriod_(void)
+	{
+		return m_bFreezePeriod;
+	}
 
 #endif // HOOK_GAMEDLL
 
@@ -192,12 +347,14 @@ public:
 	//int **_vptr.CGameRules;
 	BOOL m_bFreezePeriod;
 	BOOL m_bBombDropped;
+
 };/* size: 12, cachelines: 1, members: 3 */
 
 class CHalfLifeRules: public CGameRules
 {
 public:
 	CHalfLifeRules(void);
+
 	virtual void Think(void);
 	virtual BOOL IsAllowedToSpawn(CBaseEntity *pEntity);
 	virtual BOOL FAllowFlashlight(void)
@@ -248,7 +405,53 @@ public:
 
 #ifdef HOOK_GAMEDLL
 
-	void PlayerSpawn_(CBasePlayer *pPlayer);
+	void Think_(void);
+	BOOL IsAllowedToSpawn_(CBaseEntity *pEntity);
+	BOOL FAllowFlashlight_(void)
+	{
+		return TRUE;
+	};
+	BOOL FShouldSwitchWeapon_(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon);
+	BOOL GetNextBestWeapon_(CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon);
+	BOOL IsMultiplayer_(void);
+	BOOL IsDeathmatch_(void);
+	BOOL IsCoOp_(void);
+	BOOL ClientConnected_(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[128]);
+	void InitHUD_(CBasePlayer *pl);
+	void ClientDisconnected_(edict_t *pClient);
+	float FlPlayerFallDamage_(CBasePlayer *pPlayer);
+	void PlayerSpawn_(CBasePlayer *pPlayer);
+	void PlayerThink_(CBasePlayer *pPlayer);
+	BOOL FPlayerCanRespawn_(CBasePlayer *pPlayer);
+	float FlPlayerSpawnTime_(CBasePlayer *pPlayer);
+	edict_t *GetPlayerSpawnSpot_(CBasePlayer *pPlayer);
+	BOOL AllowAutoTargetCrosshair_(void);
+	int IPointsForKill_(CBasePlayer *pAttacker, CBasePlayer *pKilled);
+	void PlayerKilled_(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor);
+	void DeathNotice_(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor);
+	void PlayerGotWeapon_(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon);
+	int WeaponShouldRespawn_(CBasePlayerItem *pWeapon);
+	float FlWeaponRespawnTime_(CBasePlayerItem *pWeapon);
+	float FlWeaponTryRespawn_(CBasePlayerItem *pWeapon);
+	Vector VecWeaponRespawnSpot_(CBasePlayerItem *pWeapon);
+	BOOL CanHaveItem_(CBasePlayer *pPlayer, CItem *pItem);
+	void PlayerGotItem_(CBasePlayer *pPlayer, CItem *pItem);
+	int ItemShouldRespawn_(CItem *pItem);
+	float FlItemRespawnTime_(CItem *pItem);
+	Vector VecItemRespawnSpot_(CItem *pItem);
+	void PlayerGotAmmo_(CBasePlayer *pPlayer, char *szName, int iCount);
+	int AmmoShouldRespawn_(CBasePlayerAmmo *pAmmo);
+	float FlAmmoRespawnTime_(CBasePlayerAmmo *pAmmo);
+	Vector VecAmmoRespawnSpot_(CBasePlayerAmmo *pAmmo);
+	float FlHealthChargerRechargeTime_(void);
+	int DeadPlayerWeapons_(CBasePlayer *pPlayer);
+	int DeadPlayerAmmo_(CBasePlayer *pPlayer);
+	const char *GetTeamID_(CBaseEntity *pEntity)
+	{
+		return "";
+	};
+	int PlayerRelationship_(CBasePlayer *pPlayer, CBaseEntity *pTarget);
+	BOOL FAllowMonsters_(void);
 
 #endif // HOOK_GAMEDLL
 
@@ -260,74 +463,74 @@ public:
 	CHalfLifeMultiplay(void);
 public:
 	virtual void RefreshSkillData(void);
-	NOBODY virtual void Think(void);
+	virtual void Think(void);
-	NOBODY virtual BOOL IsAllowedToSpawn(CBaseEntity *pEntity);
+	virtual BOOL IsAllowedToSpawn(CBaseEntity *pEntity);
 	virtual BOOL FAllowFlashlight(void);
 	virtual BOOL FShouldSwitchWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon);
 	virtual BOOL GetNextBestWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon);
 	virtual BOOL IsMultiplayer(void);
 	virtual BOOL IsDeathmatch(void);
 	virtual BOOL IsCoOp(void);
-	NOBODY virtual BOOL ClientConnected(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[128]);
+	virtual BOOL ClientConnected(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[128]);
-	NOBODY virtual void InitHUD(CBasePlayer *pl);
+	virtual void InitHUD(CBasePlayer *pl);
-	NOBODY virtual void ClientDisconnected(edict_t *pClient);
+	virtual void ClientDisconnected(edict_t *pClient);
-	NOBODY virtual void UpdateGameMode(CBasePlayer *pPlayer);
+	virtual void UpdateGameMode(CBasePlayer *pPlayer);
 	virtual float FlPlayerFallDamage(CBasePlayer *pPlayer);
-	NOBODY virtual BOOL FPlayerCanTakeDamage(CBasePlayer *pPlayer, CBaseEntity *pAttacker);
+	virtual BOOL FPlayerCanTakeDamage(CBasePlayer *pPlayer, CBaseEntity *pAttacker);
-	NOBODY virtual void PlayerSpawn(CBasePlayer *pPlayer);
+	virtual void PlayerSpawn(CBasePlayer *pPlayer);
-	NOBODY virtual void PlayerThink(CBasePlayer *pPlayer);
+	virtual void PlayerThink(CBasePlayer *pPlayer);
-	NOBODY virtual BOOL FPlayerCanRespawn(CBasePlayer *pPlayer);
+	virtual BOOL FPlayerCanRespawn(CBasePlayer *pPlayer);
-	NOBODY virtual float FlPlayerSpawnTime(CBasePlayer *pPlayer);
+	virtual float FlPlayerSpawnTime(CBasePlayer *pPlayer);
-	NOBODY virtual edict_t *GetPlayerSpawnSpot(CBasePlayer *pPlayer);
+	virtual edict_t *GetPlayerSpawnSpot(CBasePlayer *pPlayer);
-	NOBODY virtual BOOL AllowAutoTargetCrosshair(void);
+	virtual BOOL AllowAutoTargetCrosshair(void);
-	NOBODY virtual BOOL ClientCommand_DeadOrAlive(CBasePlayer *pPlayer, const char *pcmd);
+	virtual BOOL ClientCommand_DeadOrAlive(CBasePlayer *pPlayer, const char *pcmd);
-	NOBODY virtual BOOL ClientCommand(CBasePlayer *pPlayer, const char *pcmd);
+	virtual BOOL ClientCommand(CBasePlayer *pPlayer, const char *pcmd);
-	NOBODY virtual void ClientUserInfoChanged(CBasePlayer *pPlayer, char *infobuffer);
+	virtual void ClientUserInfoChanged(CBasePlayer *pPlayer, char *infobuffer);
-	NOBODY virtual int IPointsForKill(CBasePlayer *pAttacker, CBasePlayer *pKilled);
+	virtual int IPointsForKill(CBasePlayer *pAttacker, CBasePlayer *pKilled);
-	NOBODY virtual void PlayerKilled(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor);
+	virtual void PlayerKilled(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor);
-	NOBODY virtual void DeathNotice(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor);
+	virtual void DeathNotice(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor);
-	NOBODY virtual BOOL CanHavePlayerItem(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon);
+	virtual BOOL CanHavePlayerItem(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon);
 	virtual void PlayerGotWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon);
 	virtual int WeaponShouldRespawn(CBasePlayerItem *pWeapon);
-	NOBODY virtual float FlWeaponRespawnTime(CBasePlayerItem *pWeapon);
+	virtual float FlWeaponRespawnTime(CBasePlayerItem *pWeapon);
-	NOBODY virtual float FlWeaponTryRespawn(CBasePlayerItem *pWeapon);
+	virtual float FlWeaponTryRespawn(CBasePlayerItem *pWeapon);
-	NOBODY virtual Vector VecWeaponRespawnSpot(CBasePlayerItem *pWeapon);
+	virtual Vector VecWeaponRespawnSpot(CBasePlayerItem *pWeapon);
 	virtual BOOL CanHaveItem(CBasePlayer *pPlayer, CItem *pItem);
 	virtual void PlayerGotItem(CBasePlayer *pPlayer, CItem *pItem);
 	virtual int ItemShouldRespawn(CItem *pItem);
 	virtual float FlItemRespawnTime(CItem *pItem);
 	virtual Vector VecItemRespawnSpot(CItem *pItem);
-	NOBODY virtual void PlayerGotAmmo(CBasePlayer *pPlayer, char *szName, int iCount);
+	virtual void PlayerGotAmmo(CBasePlayer *pPlayer, char *szName, int iCount);
 	virtual int AmmoShouldRespawn(CBasePlayerAmmo *pAmmo);
 	virtual float FlAmmoRespawnTime(CBasePlayerAmmo *pAmmo);
 	virtual Vector VecAmmoRespawnSpot(CBasePlayerAmmo *pAmmo);
-	NOBODY virtual float FlHealthChargerRechargeTime(void);
+	virtual float FlHealthChargerRechargeTime(void);
-	NOBODY virtual float FlHEVChargerRechargeTime(void);
+	virtual float FlHEVChargerRechargeTime(void);
-	NOBODY virtual int DeadPlayerWeapons(CBasePlayer *pPlayer);
+	virtual int DeadPlayerWeapons(CBasePlayer *pPlayer);
-	NOBODY virtual int DeadPlayerAmmo(CBasePlayer *pPlayer);
+	virtual int DeadPlayerAmmo(CBasePlayer *pPlayer);
 	virtual const char *GetTeamID(CBaseEntity *pEntity)
 	{
-		return "";
+		return GetTeamID_(pEntity);
 	}
-	NOBODY virtual int PlayerRelationship(CBasePlayer *pPlayer, CBaseEntity *pTarget);
+	virtual int PlayerRelationship(CBasePlayer *pPlayer, CBaseEntity *pTarget);
 	virtual BOOL PlayTextureSounds(void)
 	{
-		return FALSE;
+		return PlayTextureSounds_();
 	}
-	NOBODY virtual BOOL FAllowMonsters(void);
+	virtual BOOL FAllowMonsters(void);
 	virtual void EndMultiplayerGame(void)
 	{
-		GoToIntermission();
+		EndMultiplayerGame_();
-	};
+	}
-	NOBODY virtual void ServerDeactivate(void);
+	virtual void ServerDeactivate(void);
-	NOBODY virtual void CheckMapConditions(void);
+	virtual void CheckMapConditions(void);
-	NOBODY virtual void CleanUpMap(void);
+	virtual void CleanUpMap(void);
-	NOBODY virtual void RestartRound(void);
+	virtual void RestartRound(void);
-	NOBODY virtual void CheckWinConditions(void);
+	virtual void CheckWinConditions(void);
 	virtual void RemoveGuns(void);
-	NOBODY virtual void GiveC4(void);
+	virtual void GiveC4(void);
-	NOBODY virtual void ChangeLevel(void);
+	virtual void ChangeLevel(void);
-	NOBODY virtual void GoToIntermission(void);
+	virtual void GoToIntermission(void);
 
 #ifdef HOOK_GAMEDLL
 
@@ -377,8 +580,20 @@ public:
 	float FlHEVChargerRechargeTime_(void);
 	int DeadPlayerWeapons_(CBasePlayer *pPlayer);
 	int DeadPlayerAmmo_(CBasePlayer *pPlayer);
+	const char *GetTeamID_(CBaseEntity *pEntity)
+	{
+		return "";
+	}
 	int PlayerRelationship_(CBasePlayer *pPlayer, CBaseEntity *pTarget);
+	BOOL PlayTextureSounds_(void)
+	{
+		return FALSE;
+	}
 	BOOL FAllowMonsters_(void);
+	void EndMultiplayerGame_(void)
+	{
+		GoToIntermission();
+	}
 	void ServerDeactivate_(void);
 	void CheckMapConditions_(void);
 	void CleanUpMap_(void);
@@ -393,10 +608,10 @@ public:
 
 public:
 	BOOL IsCareer(void);
-	NOBODY void QueueCareerRoundEndMenu(float tmDelay, int iWinStatus);
+	void QueueCareerRoundEndMenu(float tmDelay, int iWinStatus);
-	NOBODY void SetCareerMatchLimit(int minWins, int winDifference);
+	void SetCareerMatchLimit(int minWins, int winDifference);
-	NOBODY bool IsInCareerRound(void);
+	bool IsInCareerRound(void);
-	NOBODY void CareerRestart(void);
+	void CareerRestart(void);
 	bool ShouldSkipSpawn(void)
 	{
 		return m_bSkipSpawn;
@@ -405,39 +620,40 @@ public:
 	{
 		m_bSkipSpawn = false;
 	}
-	NOBODY void PlayerJoinedTeam(CBasePlayer *pPlayer);
+	NOXREF void PlayerJoinedTeam(CBasePlayer *pPlayer)
+	{
+		;
+	}
 	float TimeRemaining(void)
 	{
 		return m_iRoundTimeSecs - gpGlobals->time + m_fRoundCount;
 	}
-	NOBODY BOOL TeamFull(int team_id);
+	BOOL TeamFull(int team_id);
 	BOOL TeamStacked(int newTeam_id, int curTeam_id);
-	NOBODY bool IsVIPQueueEmpty(void);
+	bool IsVIPQueueEmpty(void);
-	NOBODY bool AddToVIPQueue(CBasePlayer *toAdd);
+	bool AddToVIPQueue(CBasePlayer *toAdd);
-	NOBODY void PickNextVIP(void);
+	void PickNextVIP(void);
-	NOBODY void StackVIPQueue(void);
+	void StackVIPQueue(void);
-	NOBODY void ResetCurrentVIP(void);
+	void ResetCurrentVIP(void);
-	NOBODY void BalanceTeams(void);
+	void BalanceTeams(void);
-	NOBODY void SwapAllPlayers(void);
+	void SwapAllPlayers(void);
-	NOBODY void UpdateTeamScores(void);
+	void UpdateTeamScores(void);
-	NOBODY void DisplayMaps(CBasePlayer *player, int iVote);
+	void DisplayMaps(CBasePlayer *player, int iVote);
-	NOBODY void ResetAllMapVotes(void);
+	void ResetAllMapVotes(void);
-	NOBODY void ProcessMapVote(CBasePlayer *player, int iVote);
+	void ProcessMapVote(CBasePlayer *player, int iVote);
 	BOOL IsThereABomber(void);
 	BOOL IsThereABomb(void);
-	NOBODY bool IsMatchStarted(void);
+	bool IsMatchStarted(void)
-	NOBODY void SendMOTDToClient(edict_t *client);
-private:
-	NOBODY bool HasRoundTimeExpired(void);
-	NOBODY bool IsBombPlanted(void);
-	NOBODY void MarkLivingPlayersOnTeamAsNotReceivingMoneyNextRound(int iTeam);
-
-	inline void TerminateRound(float tmDelay, int iWinStatus)
 	{
-		m_iRoundWinStatus = iWinStatus;
+		return (m_fTeamCount != 0.0f || m_fCareerRoundMenuTime != 0.0f || m_fCareerMatchMenuTime != 0.0f);
-		m_bRoundTerminating = true;
-		m_fTeamCount = gpGlobals->time + tmDelay;
 	}
+	void SendMOTDToClient(edict_t *client);
+
+private:
+	bool HasRoundTimeExpired(void);
+	bool IsBombPlanted(void);
+	void MarkLivingPlayersOnTeamAsNotReceivingMoneyNextRound(int iTeam);
+
 public:
 	CVoiceGameMgr m_VoiceGameMgr;
 	float m_fTeamCount;
@@ -503,6 +719,7 @@ public:
 	float m_flFadeToBlackValue;
 	CBasePlayer *m_pVIP;
 	CBasePlayer *VIPQueue[ MAX_VIP_QUEUES ];
+
 protected:
 	float m_flIntermissionEndTime;
 	float m_flIntermissionStartTime;
@@ -514,7 +731,7 @@ protected:
 	int m_iCareerMatchWins;
 	int m_iRoundWinDifference;
 	float m_fCareerMatchMenuTime;
-	bool m_bSkipSpawn;
+	bool m_bSkipSpawn;//712
 
 };/* size: 708, cachelines: 12, members: 76 */
 
@@ -532,6 +749,7 @@ typedef struct mapcycle_s
 {
 	struct mapcycle_item_s *items;
 	struct mapcycle_item_s *next_item;
+
 } mapcycle_t;
 /* size: 8, cachelines: 1, members: 2 */
 
@@ -559,37 +777,11 @@ public:
 class CCStrikeGameMgrHelper: public IVoiceGameMgrHelper
 {
 public:
-	virtual bool CanPlayerHearPlayer(CBasePlayer *pListener, CBasePlayer *pSender)
+	virtual bool CanPlayerHearPlayer(CBasePlayer *pListener, CBasePlayer *pSender);
-	{
-		return CanPlayerHearPlayer_(pListener, pSender);
-	}
 
 #ifdef HOOK_GAMEDLL
 
-	bool CanPlayerHearPlayer_(CBasePlayer *pListener, CBasePlayer *pSender)
+	bool CanPlayerHearPlayer_(CBasePlayer *pListener, CBasePlayer *pSender);
-	{
-		if (!pSender->IsPlayer() || pListener->m_iTeam != pSender->m_iTeam)
-			return false;
-
-		BOOL bListenerAlive = pListener->IsAlive();
-		BOOL bSenderAlive = pSender->IsAlive();
-
-		if (pListener->IsObserver())
-			return true;
-
-		if (bListenerAlive)
-		{
-			if (!bSenderAlive)
-				return false;
-		}
-		else
-		{
-			if (bSenderAlive)
-				return true;
-		}
-
-		return (bListenerAlive == bSenderAlive);
-	}
 
 #endif // HOOK_GAMEDLL
 
@@ -617,26 +809,32 @@ CGameRules *InstallGameRules(void);
 * Multiplay gamerules
 */
 
-NOBODY bool IsBotSpeaking(void);
+bool IsBotSpeaking(void);
-NOBODY void SV_Continue_f(void);
+void SV_Continue_f(void);
-NOBODY void SV_Tutor_Toggle_f(void);
+void SV_Tutor_Toggle_f(void);
-NOBODY void SV_Career_Restart_f(void);
+void SV_Career_Restart_f(void);
-NOBODY void SV_Career_EndRound_f(void);
+void SV_Career_EndRound_f(void);
-NOBODY void SV_CareerAddTask_f(void);
+void SV_CareerAddTask_f(void);
-NOBODY void SV_CareerMatchLimit_f(void);
+void SV_CareerMatchLimit_f(void);
 void Broadcast(const char *sentence);
 char *GetTeam(int teamNo);
-NOBODY void EndRoundMessage(const char *sentence, int event);
+void EndRoundMessage(const char *sentence, int event);
-NOBODY void ReadMultiplayCvars(CHalfLifeMultiplay *mp);
+void ReadMultiplayCvars(CHalfLifeMultiplay *mp);
-NOBODY void DestroyMapCycle(mapcycle_t *cycle);
+void DestroyMapCycle(mapcycle_t *cycle);
 
 char *MP_COM_GetToken(void);
 char *MP_COM_Parse(char *data);
-NOXREF int MP_COM_TokenWaiting(char *buffer);
+int MP_COM_TokenWaiting(char *buffer);
 
-NOBODY int ReloadMapCycleFile(char *filename, mapcycle_t *cycle);
+int ReloadMapCycleFile(char *filename, mapcycle_t *cycle);
-NOBODY int CountPlayers(void);
+int CountPlayers(void);
-NOBODY void ExtractCommandString(char *s, char *szCommand);
+void ExtractCommandString(char *s, char *szCommand);
-NOBODY int GetMapCount(void);
+int GetMapCount(void);
+
+// refs
+extern void (*pInstallGameRules)(void);
+
+// linked objects
+C_DLLEXPORT void info_map_parameters(entvars_t *pev);
 
 #endif // GAMERULES_H

regamedll/dlls/ggrenade.cpp

@@ -532,7 +532,7 @@ void CGrenade::SG_Smoke(void)
 }
 
 /* <b8467> ../cstrike/dlls/ggrenade.cpp:664 */
-void CGrenade::Killed_(entvars_t *pevAttacker, int iGib)
+void CGrenade::__MAKE_VHOOK(Killed)(entvars_t *pevAttacker, int iGib)
 {
 	Detonate();
 }
@@ -758,7 +758,7 @@ void CGrenade::SlideTouch(CBaseEntity *pOther)
 }
 
 /* <b7b20> ../cstrike/dlls/ggrenade.cpp:904 */
-void CGrenade::BounceSound_(void)
+void CGrenade::__MAKE_VHOOK(BounceSound)(void)
 {
 	if (pev->dmg > 50)
 	{
@@ -849,7 +849,7 @@ void CGrenade::SG_TumbleThink(void)
 }
 
 /* <b7010> ../cstrike/dlls/ggrenade.cpp:985 */
-void CGrenade::Spawn_(void)
+void CGrenade::__MAKE_VHOOK(Spawn)(void)
 {
 	m_iBounceCount = 0;
 	pev->movetype = MOVETYPE_BOUNCE;
@@ -977,7 +977,7 @@ CGrenade *CGrenade::ShootTimed(entvars_t *pevOwner, Vector vecStart, Vector vecV
 }
 
 /* <ba5be> ../cstrike/dlls/ggrenade.cpp:1113 */
-void CGrenade::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CGrenade::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 	if (!m_bIsC4)
 		return;
@@ -1145,8 +1145,8 @@ void AnnounceFlashInterval(float interval, float offset)
 		WRITE_BYTE(1);
 		WRITE_STRING("bombticking");
 		WRITE_BYTE(255);
-		WRITE_SHORT((short)interval);	// interval
+		WRITE_SHORT((int)interval);	// interval
-		WRITE_SHORT((short)offset);
+		WRITE_SHORT((int)offset);
 	MESSAGE_END();
 }
 

regamedll/dlls/h_battery.cpp

@@ -27,7 +27,7 @@ IMPLEMENT_SAVERESTORE(CRecharge, CBaseEntity);
 LINK_ENTITY_TO_CLASS(func_recharge, CRecharge);
 
 /* <c648b> ../cstrike/dlls/h_battery.cpp:66 */
-void CRecharge::KeyValue_(KeyValueData *pkvd)
+void CRecharge::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 	if (FStrEq(pkvd->szKeyName, "style")
 		|| FStrEq(pkvd->szKeyName, "height")
@@ -39,7 +39,7 @@ void CRecharge::KeyValue_(KeyValueData *pkvd)
 	}
 	else if (FStrEq(pkvd->szKeyName, "dmdelay"))
 	{
-		m_iReactivate = atoi(pkvd->szValue);
+		m_iReactivate = Q_atoi(pkvd->szValue);
 		pkvd->fHandled = TRUE;
 	}
 	else
@@ -47,7 +47,7 @@ void CRecharge::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <c616f> ../cstrike/dlls/h_battery.cpp:85 */
-void CRecharge::Spawn_(void)
+void CRecharge::__MAKE_VHOOK(Spawn)(void)
 {
 	Precache();
 
@@ -63,7 +63,7 @@ void CRecharge::Spawn_(void)
 }
 
 /* <c6122> ../cstrike/dlls/h_battery.cpp:99 */
-void CRecharge::Precache_(void)
+void CRecharge::__MAKE_VHOOK(Precache)(void)
 {
 	PRECACHE_SOUND("items/suitcharge1.wav");
 	PRECACHE_SOUND("items/suitchargeno1.wav");
@@ -71,7 +71,7 @@ void CRecharge::Precache_(void)
 }
 
 /* <c630e> ../cstrike/dlls/h_battery.cpp:107 */
-void CRecharge::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CRecharge::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 	// if it's not a player, ignore
 	if (!FClassnameIs(pActivator->pev, "player"))

regamedll/dlls/h_cycler.cpp

@@ -34,7 +34,7 @@ TYPEDESCRIPTION (*CWreckage::pm_SaveData)[1];
 IMPLEMENT_SAVERESTORE(CCycler, CBaseToggle);
 
 /* <cd01f> ../cstrike/dlls/h_cycler.cpp:70 */
-void CGenericCycler::Spawn_(void)
+void CGenericCycler::__MAKE_VHOOK(Spawn)(void)
 {
 //	Vector(Vector::Spawn(//		float X,
 //		float Y,
@@ -56,7 +56,7 @@ LINK_ENTITY_TO_CLASS(cycler, CGenericCycler);
 LINK_ENTITY_TO_CLASS(cycler_prdroid, CCyclerProbe);
 
 /* <cd16d> ../cstrike/dlls/h_cycler.cpp:86 */
-void CCyclerProbe::Spawn_(void)
+void CCyclerProbe::__MAKE_VHOOK(Spawn)(void)
 {
 //	Vector(Vector::Spawn(//		float X,
 //		float Y,
@@ -81,23 +81,23 @@ void CCycler::GenericCyclerSpawn(char *szModel, Vector vecMin, Vector vecMax)
 }
 
 /* <ccc91> ../cstrike/dlls/h_cycler.cpp:115 */
-void CCycler::Spawn_(void)
+void CCycler::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <ccd3e> ../cstrike/dlls/h_cycler.cpp:151 */
-void CCycler::Think_(void)
+void CCycler::__MAKE_VHOOK(Think)(void)
 {
 //	Think(CCycler *const this);  //   151
 }
 
 /* <cc8bf> ../cstrike/dlls/h_cycler.cpp:176 */
-void CCycler::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CCycler::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 }
 
 /* <ccf43> ../cstrike/dlls/h_cycler.cpp:189 */
-int CCycler::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+int CCycler::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 //	TakeDamage(CCycler *const this,
 //			entvars_t *pevInflictor,
@@ -113,7 +113,7 @@ LINK_ENTITY_TO_CLASS(cycler_sprite, CCyclerSprite);
 IMPLEMENT_SAVERESTORE(CCyclerSprite, CBaseEntity);
 
 /* <cc982> ../cstrike/dlls/h_cycler.cpp:284 */
-void CCyclerSprite::Restart_(void)
+void CCyclerSprite::__MAKE_VHOOK(Restart)(void)
 {
 //	{
 //		int i;                                                //   300
@@ -121,7 +121,7 @@ void CCyclerSprite::Restart_(void)
 }
 
 /* <cc943> ../cstrike/dlls/h_cycler.cpp:258 */
-void CCyclerSprite::Spawn_(void)
+void CCyclerSprite::__MAKE_VHOOK(Spawn)(void)
 {
 //	{
 //		int i;                                                //   279
@@ -129,7 +129,7 @@ void CCyclerSprite::Spawn_(void)
 }
 
 /* <cd0ef> ../cstrike/dlls/h_cycler.cpp:305 */
-void CCyclerSprite::Think_(void)
+void CCyclerSprite::__MAKE_VHOOK(Think)(void)
 {
 //	ShouldAnimate(CCyclerSprite *const this);  //   307
 //	Animate(CCyclerSprite *const this,
@@ -137,12 +137,12 @@ void CCyclerSprite::Think_(void)
 }
 
 /* <cc9c1> ../cstrike/dlls/h_cycler.cpp:315 */
-void CCyclerSprite::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CCyclerSprite::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 }
 
 /* <cd228> ../cstrike/dlls/h_cycler.cpp:322 */
-int CCyclerSprite::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+int CCyclerSprite::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 //	Animate(CCyclerSprite *const this,
 //		float frames);  //   326
@@ -159,7 +159,7 @@ void CCyclerSprite::Animate(float frames)
 LINK_ENTITY_TO_CLASS(cycler_weapon, CWeaponCycler);
 
 /* <ccbf6> ../cstrike/dlls/h_cycler.cpp:361 */
-void CWeaponCycler::Spawn_(void)
+void CWeaponCycler::__MAKE_VHOOK(Spawn)(void)
 {
 //	Vector(Vector::Spawn(//		float X,
 //		float Y,
@@ -171,22 +171,22 @@ void CWeaponCycler::Spawn_(void)
 }
 
 /* <cca7c> ../cstrike/dlls/h_cycler.cpp:378 */
-BOOL CWeaponCycler::Deploy_(void)
+BOOL CWeaponCycler::__MAKE_VHOOK(Deploy)(void)
 {
 }
 
 /* <ccaa3> ../cstrike/dlls/h_cycler.cpp:388 */
-void CWeaponCycler::Holster_(int skiplocal)
+void CWeaponCycler::__MAKE_VHOOK(Holster)(int skiplocal)
 {
 }
 
 /* <ccad8> ../cstrike/dlls/h_cycler.cpp:394 */
-void CWeaponCycler::PrimaryAttack_(void)
+void CWeaponCycler::__MAKE_VHOOK(PrimaryAttack)(void)
 {
 }
 
 /* <ccb97> ../cstrike/dlls/h_cycler.cpp:403 */
-void CWeaponCycler::SecondaryAttack_(void)
+void CWeaponCycler::__MAKE_VHOOK(SecondaryAttack)(void)
 {
 //	{
 //		float flFrameRate;                                    //   405
@@ -202,18 +202,18 @@ IMPLEMENT_SAVERESTORE(CWreckage, CBaseToggle);
 LINK_ENTITY_TO_CLASS(cycler_wreckage, CWreckage);
 
 /* <ccaff> ../cstrike/dlls/h_cycler.cpp:448 */
-void CWreckage::Spawn_(void)
+void CWreckage::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <ccd07> ../cstrike/dlls/h_cycler.cpp:468 */
-void CWreckage::Precache_(void)
+void CWreckage::__MAKE_VHOOK(Precache)(void)
 {
 //	Precache(CWreckage *const this);  //   468
 }
 
 /* <ccb26> ../cstrike/dlls/h_cycler.cpp:474 */
-void CWreckage::Think_(void)
+void CWreckage::__MAKE_VHOOK(Think)(void)
 {
 //	{
 //		Vector VecSrc;                                  //   492

regamedll/dlls/h_export.cpp

@@ -6,7 +6,7 @@ globalvars_t *gpGlobals;
 /* <d0737> ../cstrike/dlls/h_export.cpp:58 */
 C_DLLEXPORT void WINAPI GiveFnptrsToDll(enginefuncs_t *pEnginefuncsTable,globalvars_t *pGlobals)
 {
-	memcpy(&g_engfuncs, pEnginefuncsTable, sizeof(enginefuncs_t));
+	Q_memcpy(&g_engfuncs, pEnginefuncsTable, sizeof(enginefuncs_t));
 	gpGlobals = pGlobals;
 
 #if defined(_WIN32) && !defined(REGAMEDLL_UNIT_TESTS)

regamedll/dlls/healthkit.cpp

@@ -24,7 +24,7 @@ TYPEDESCRIPTION (*CWallHealth::pm_SaveData)[5];
 LINK_ENTITY_TO_CLASS(item_healthkit, CHealthKit);
 
 /* <d5e25> ../cstrike/dlls/healthkit.cpp:55 */
-void CHealthKit::Spawn_(void)
+void CHealthKit::__MAKE_VHOOK(Spawn)(void)
 {
 	Precache();
 	SET_MODEL(ENT(pev), "models/w_medkit.mdl");
@@ -33,14 +33,14 @@ void CHealthKit::Spawn_(void)
 }
 
 /* <d5d8a> ../cstrike/dlls/healthkit.cpp:63 */
-void CHealthKit::Precache_(void)
+void CHealthKit::__MAKE_VHOOK(Precache)(void)
 {
 	PRECACHE_MODEL("models/w_medkit.mdl");
 	PRECACHE_SOUND("items/smallmedkit1.wav");
 }
 
 /* <d5fb9> ../cstrike/dlls/healthkit.cpp:69 */
-BOOL CHealthKit::MyTouch_(CBasePlayer *pPlayer)
+BOOL CHealthKit::__MAKE_VHOOK(MyTouch)(CBasePlayer *pPlayer)
 {
 	if (pPlayer->TakeHealth(gSkillData.healthkitCapacity, DMG_GENERIC))
 	{
@@ -68,7 +68,7 @@ IMPLEMENT_SAVERESTORE(CWallHealth, CBaseEntity);
 LINK_ENTITY_TO_CLASS(func_healthcharger, CWallHealth);
 
 /* <d60ed> ../cstrike/dlls/healthkit.cpp:135 */
-void CWallHealth::KeyValue_(KeyValueData *pkvd)
+void CWallHealth::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 	if (FStrEq(pkvd->szKeyName, "style") || FStrEq(pkvd->szKeyName, "height") || FStrEq(pkvd->szKeyName, "value1") || FStrEq(pkvd->szKeyName, "value2") || FStrEq(pkvd->szKeyName, "value3"))
 	{
@@ -76,7 +76,7 @@ void CWallHealth::KeyValue_(KeyValueData *pkvd)
 	}
 	else if (FStrEq(pkvd->szKeyName, "dmdelay"))
 	{
-		m_iReactivate = atoi(pkvd->szValue);
+		m_iReactivate = Q_atoi(pkvd->szValue);
 		pkvd->fHandled = TRUE;
 	}
 	else
@@ -84,7 +84,7 @@ void CWallHealth::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <d5dfe> ../cstrike/dlls/healthkit.cpp:154 */
-void CWallHealth::Spawn_(void)
+void CWallHealth::__MAKE_VHOOK(Spawn)(void)
 {
 	Precache();
 
@@ -102,7 +102,7 @@ void CWallHealth::Spawn_(void)
 }
 
 /* <d5dd7> ../cstrike/dlls/healthkit.cpp:169 */
-void CWallHealth::Precache_(void)
+void CWallHealth::__MAKE_VHOOK(Precache)(void)
 {
 	PRECACHE_SOUND("items/medshot4.wav");
 	PRECACHE_SOUND("items/medshotno1.wav");
@@ -110,7 +110,7 @@ void CWallHealth::Precache_(void)
 }
 
 /* <d622e> ../cstrike/dlls/healthkit.cpp:177 */
-void CWallHealth::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CWallHealth::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 	// Make sure that we have a caller
 	if (!pActivator)

regamedll/dlls/hostage/hostage.cpp

@@ -5,8 +5,8 @@
 */
 #ifndef HOOK_GAMEDLL
 
-cvar_t cv_hostage_stop = { "hostage_stop", "0", FCVAR_SERVER };
+cvar_t cv_hostage_stop = { "hostage_stop", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_hostage_debug = { "hostage_debug", "0", FCVAR_SERVER };
+cvar_t cv_hostage_debug = { "hostage_debug", "0", FCVAR_SERVER, 0.0f, NULL };
 
 #else
 
@@ -25,7 +25,7 @@ LINK_ENTITY_TO_CLASS(hostage_entity, CHostage);
 LINK_ENTITY_TO_CLASS(monster_scientist, CHostage);
 
 /* <45c228> ../cstrike/dlls/hostage/hostage.cpp:54 */
-NOBODY void CHostage::Spawn_(void)
+NOBODY void CHostage::__MAKE_VHOOK(Spawn)(void)
 {
 //	MAKE_STRING_CLASS(const char *str,
 //				entvars_t *pev);  //    61
@@ -44,7 +44,7 @@ NOBODY void CHostage::Spawn_(void)
 }
 
 /* <45bf91> ../cstrike/dlls/hostage/hostage.cpp:137 */
-NOBODY void CHostage::Precache_(void)
+NOBODY void CHostage::__MAKE_VHOOK(Precache)(void)
 {
 //	{
 //		int which;                                            //   141
@@ -52,18 +52,39 @@ NOBODY void CHostage::Precache_(void)
 }
 
 /* <45c5ac> ../cstrike/dlls/hostage/hostage.cpp:179 */
-NOBODY void CHostage::SetActivity(int act)
+void CHostage::SetActivity(int act)
-{
+{
-//	{
+	if (m_Activity != act)
-//		int sequence;                                         //   181
+	{
-//	}
+		int sequence = LookupActivity(act);
-//	SetActivity(CHostage *const this,
+
-//			int act);  //   179
+		if (sequence != -1)
+		{
+			if (pev->sequence != sequence)
+			{
+				if ((m_Activity != ACT_WALK && m_Activity != ACT_RUN) || (act != ACT_WALK && act != ACT_RUN))
+				{
+					pev->frame = 0;
+				}
+
+				pev->sequence = sequence;
+			}
+
+			m_Activity = act;
+			ResetSequenceInfo();
+		}
+	}
 }
 
+void (*pCHostage__IdleThink)(void);
+
 /* <45f194> ../cstrike/dlls/hostage/hostage.cpp:204 */
-NOBODY void CHostage::IdleThink(void)
+NOBODY void __declspec(naked) CHostage::IdleThink(void)
 {
+	__asm
+	{
+		jmp pCHostage__IdleThink
+	}
 //	{
 //		float const upkeepRate;                                //   220
 //		float flInterval;                                     //   224
@@ -135,22 +156,46 @@ NOBODY void CHostage::Remove(void)
 }
 
 /* <45c624> ../cstrike/dlls/hostage/hostage.cpp:426 */
-NOBODY void CHostage::RePosition(void)
+void CHostage::RePosition(void)
-{
+{
-//	Vector(Vector::RePosition(//		float X,
+	pev->health = pev->max_health;
-//		float Y,
+	pev->movetype = MOVETYPE_STEP;
-//		float Z);  //   449
+	pev->solid = SOLID_SLIDEBOX;
-//	Vector(Vector *const this,
+	pev->takedamage = DAMAGE_YES;
-//		float X,
+	pev->deadflag = DEAD_NO;
-//		float Y,
+	pev->velocity = Vector(0, 0, 0);
-//		float Z);  //   449
+	pev->angles = m_vStartAngles;
-//	edict(CBaseEntity *const this);  //   451
+	pev->effects &= ~EF_NODRAW;
-//	SetActivity(CHostage *const this,
+
-//			int act);  //   453
+	m_hTargetEnt = NULL;
+	m_hStoppedTargetEnt = NULL;
+
+	m_bTouched = FALSE;
+	m_bRescueMe = FALSE;
+
+	m_flNextRadarTime = 0;
+	m_vOldPos = Vector(9999, 9999, 9999);
+
+	UTIL_SetOrigin(pev, m_vStart);
+	UTIL_SetSize(pev, VEC_HOSTAGE_HULL_MIN, VEC_HOSTAGE_HULL_MAX);
+
+	DROP_TO_FLOOR(edict());
+	SetActivity(ACT_IDLE);
+
+	SetThink(&CHostage::IdleThink);
+	pev->nextthink = gpGlobals->time + RANDOM_FLOAT(0.1, 0.2);
+
+	m_fHasPath = FALSE;
+	nTargetNode = -1;
+
+	m_flLastPathCheck = -1;
+	m_flPathAcquired = -1;
+	m_flPathCheckInterval = 0.1f;
+	m_flNextFullThink = gpGlobals->time + RANDOM_FLOAT(0.1, 0.2);
 }
 
 /* <45ee7f> ../cstrike/dlls/hostage/hostage.cpp:469 */
-NOBODY int CHostage::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+NOBODY int CHostage::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 //	{
 //		float flActualDamage;                                 //   471
@@ -240,7 +285,7 @@ NOBODY void CHostage::ApplyHostagePenalty(CBasePlayer *pAttacker)
 }
 
 /* <45cfd6> ../cstrike/dlls/hostage/hostage.cpp:740 */
-NOBODY void CHostage::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CHostage::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		class CBasePlayer *pPlayer;                          //   742
@@ -290,12 +335,12 @@ NOBODY void CHostage::GiveCTTouchBonus(CBasePlayer *pPlayer)
 }
 
 /* <45bf69> ../cstrike/dlls/hostage/hostage.cpp:869 */
-NOBODY int CHostage::ObjectCaps_(void)
+NOBODY int CHostage::__MAKE_VHOOK(ObjectCaps)(void)
 {
 }
 
 /* <45c0e3> ../cstrike/dlls/hostage/hostage.cpp:876 */
-NOBODY void CHostage::Touch_(CBaseEntity *pOther)
+NOBODY void CHostage::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
 //	{
 //		class Vector2D vPush;                                 //   901
@@ -395,67 +440,58 @@ NOBODY BOOL CHostage::IsOnLadder(void)
 }
 
 /* <45d727> ../cstrike/dlls/hostage/hostage.cpp:1106 */
-NOBODY void CHostage::NavReady(void)
+void CHostage::NavReady(void)
 {
-//	{
-//		class CBaseEntity *pFollowing;                       //  1108
-//		Vector vecDest;                                 //  1109
-//		float flRadius;                                       //  1110
-//		node_index_t nindexPath;                              //  1111
-//		GetClassPtr<CBaseEntity>(CBaseEntity *a);  //  1118
-//		{
-//			TraceResult tr;                               //  1123
-//			Vector vecDropDest;                     //  1124
-//			edict(CBaseEntity *const this);  //  1129
-//		}
-//		SetTargetEnt(CLocalNav *const this,
-//				class CBaseEntity *pTarget);  //  1142
-//	}
-
 	CBaseEntity *pFollowing;
 	Vector vecDest;
 	float flRadius = 40.0;
 
-	node_index_t nindexPath;
-
 	if (!m_hTargetEnt)
+	{
 		return;
+	}
 
 	pFollowing = GetClassPtr((CBaseEntity *)m_hTargetEnt->pev);
 	vecDest = pFollowing->pev->origin;
-
+	
 	if (!(pFollowing->pev->flags & FL_ONGROUND))
 	{
 		TraceResult tr;
-		Vector vecDropDest = pFollowing->pev->origin - Vector(0, 0, 300);
+		Vector vecDropDest = (pFollowing->pev->origin - Vector(0, 0, 300));
-
 		UTIL_TraceHull(vecDest, vecDropDest, ignore_monsters, human_hull, pFollowing->edict(), &tr);
 
-		if (tr.fStartSolid || tr.flFraction == 1.0)
+		if (tr.fStartSolid || tr.flFraction == 1.0f)
+		{
 			return;
+		}
 
 		vecDest = tr.vecEndPos;
 	}
 
 	vecDest.z += pFollowing->pev->mins.z;
 	m_LocalNav->SetTargetEnt(pFollowing);
-	nindexPath = m_LocalNav->FindPath(pev->origin, vecDest, flRadius, 1);// TODO: Reverse me
 
-	if (nindexPath != -1)
+	node_index_t nindexPath = m_LocalNav->FindPath(pev->origin, vecDest, flRadius, 1);
+	if (nindexPath == -1)
+	{
+		if (!m_fHasPath)
+		{
+			m_flPathCheckInterval += 0.1;
+
+			if (m_flPathCheckInterval >= 0.5f)
+			{
+				m_flPathCheckInterval = 0.5f;
+			}
+		}
+	}
+	else
 	{
 		m_fHasPath = TRUE;
 		nTargetNode = -1;
+		m_flPathAcquired = gpGlobals->time;
 		m_flPathCheckInterval = 0.5;
 
-		m_flPathAcquired = gpGlobals->time;
+		m_nPathNodes = m_LocalNav->SetupPathNodes(nindexPath, vecNodes, 1);
-		m_nPathNodes = m_LocalNav->SetupPathNodes(nindexPath, vecNodes, 1);// TODO: Reverse me
-	}
-	else if (!m_fHasPath)
-	{
-		m_flPathCheckInterval += 0.1;
-
-		if (m_flPathCheckInterval >= 0.5f)
-			m_flPathCheckInterval = 0.5;
 	}
 }
 
@@ -544,14 +580,20 @@ void CHostage::PreThink(void)
 	float flRaisedDist;
 	float flInterval;
 
-	if (m_improv)
+	if (m_improv != NULL)
+	{
 		return;
+	}
 
 	if (!(pev->flags & FL_ONGROUND))
+	{
 		return;
+	}
 
 	if (pev->velocity.Length2D() < 1)
+	{
 		return;
+	}
 
 	vecSrc = pev->origin;
 
@@ -566,8 +608,10 @@ void CHostage::PreThink(void)
 
 	TRACE_MONSTER_HULL(edict(), vecSrc, vecDest, dont_ignore_monsters, edict(), &tr);
 
-	if (tr.fStartSolid || tr.flFraction == 1.0 || tr.vecPlaneNormal.z > 0.7)
+	if (tr.fStartSolid || tr.flFraction == 1.0f || tr.vecPlaneNormal.z > 0.7f)
+	{
 		return;
+	}
 
 	flOrigDist = (tr.vecEndPos - pev->origin).Length2D();
 	vecSrc.z += flInterval;
@@ -577,7 +621,9 @@ void CHostage::PreThink(void)
 	TRACE_MONSTER_HULL(edict(), vecSrc, vecDest, dont_ignore_monsters, edict(), &tr);
 
 	if (tr.fStartSolid)
+	{
 		return;
+	}
 
 	vecSrc = tr.vecEndPos;
 	vecDest = tr.vecEndPos;
@@ -585,8 +631,10 @@ void CHostage::PreThink(void)
 
 	TRACE_MONSTER_HULL(edict(), vecSrc, vecDest, dont_ignore_monsters, edict(), &tr);
 
-	if (tr.vecPlaneNormal.z < 0.7)
+	if (tr.vecPlaneNormal.z < 0.7f)
+	{
 		return;
+	}
 
 	flRaisedDist = (tr.vecEndPos - pev->origin).Length2D();
 
@@ -618,7 +666,7 @@ NOBODY void InstallHostageManager(void)
 /* <45e375> ../cstrike/dlls/hostage/hostage.cpp:1443 */
 NOBODY CHostageManager::CHostageManager(void)
 {
-	memset(&m_chatter, 0, sizeof(m_chatter));
+	Q_memset(&m_chatter, 0, sizeof(m_chatter));
 	m_hostageCount = 0;
 
 //	SimpleChatter(SimpleChatter *const this);  //  1443
@@ -777,11 +825,15 @@ void CHostageManager::ServerDeactivate(void)
 }
 
 /* <45e3f7> ../cstrike/dlls/hostage/hostage.cpp:1631 */
-NOBODY void CHostageManager::RestartRound(void)
+void CHostageManager::RestartRound(void)
-{
+{
-//	{
+	for (int i = 0; i < m_hostageCount; i++)
-//		int i;                                                //  1634
+	{
-//	}
+		if (m_hostage[ i ]->m_improv != NULL)
+		{
+			m_hostage[ i ]->m_improv->OnReset();
+		}
+	}
 }
 
 /* <45e43d> ../cstrike/dlls/hostage/hostage.cpp:1640 */
@@ -846,8 +898,10 @@ void CHostageManager::OnEvent(GameEventType event, CBaseEntity *entity, CBaseEnt
 	{
 		CHostageImprov *improv = m_hostage[ i ]->m_improv;
 
-		if (improv)
+		if (improv != NULL)
+		{
 			improv->OnGameEvent(event, entity, other);
+		}
 	}
 }
 

regamedll/dlls/hostage/hostage.h

@@ -34,11 +34,16 @@
 
 #include "hostage/hostage_improv.h"
 
-#define MAX_NODES 100
+#define MAX_NODES			100
-#define MAX_HOSTAGES 12
+#define MAX_HOSTAGES			12
-#define MAX_HOSTAGES_NAV 20
+#define MAX_HOSTAGES_NAV		20
 
-#define HOSTAGE_STEPSIZE 26.0
+#define HOSTAGE_STEPSIZE		26.0
+#define HOSTAGE_STEPSIZE_DEFAULT	18.0
+
+#define VEC_HOSTAGE_VIEW		Vector(0, 0, 12)
+#define VEC_HOSTAGE_HULL_MIN		Vector(-10, -10, 0)
+#define VEC_HOSTAGE_HULL_MAX		Vector(10, 10, 62)
 
 class CHostage;
 class CLocalNav;
@@ -106,10 +111,11 @@ public:
 	NOBODY virtual void Touch(CBaseEntity *pOther);
 	NOBODY virtual void Use(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
+public:
 	NOBODY void EXPORT IdleThink(void);
 	NOBODY void Remove(void);
-	NOBODY void RePosition(void);
+	void RePosition(void);
-	NOBODY void SetActivity(int act);
+	void SetActivity(int act);
 	NOBODY int GetActivity(void);
 	NOBODY float GetModifiedDamage(float flDamage, int nHitGroup);
 	NOBODY void SetFlinchActivity(void);
@@ -132,9 +138,18 @@ public:
 	NOBODY bool IsFollowingSomeone(void)
 	{
 		UNTESTED
-		return ((CHostageImprov *)m_improv)->IsFollowing();
+		return m_improv->IsFollowing(NULL);
+	}
+	NOBODY CBaseEntity *GetLeader(void)
+	{
+		UNTESTED
+		if (m_improv != NULL)
+		{
+			return m_improv->GetFollowLeader();
+		}
+
+		return NULL;
 	}
-	NOBODY CBaseEntity *GetLeader(void);//
 	NOBODY bool IsFollowing(const CBaseEntity *entity)
 	{
 		return (entity == m_hTargetEnt && m_State == FOLLOW);
@@ -263,7 +278,7 @@ public:
 	void ServerActivate(void);
 	void ServerDeactivate(void);
 
-	NOBODY void RestartRound(void);
+	void RestartRound(void);
 	void AddHostage(CHostage *hostage);
 	SimpleChatter *GetChatter(void)
 	{
@@ -352,4 +367,7 @@ private:
 void Hostage_RegisterCVars(void);
 NOBODY void InstallHostageManager(void);
 
+// refs
+extern void (*pCHostage__IdleThink)(void);
+
 #endif // HOSTAGE_H

regamedll/dlls/hostage/hostage_improv.cpp

@@ -45,12 +45,12 @@ CHostageImprov::CHostageImprov(CBaseEntity *entity)
 }
 
 /* <470d33> ../cstrike/dlls/hostage/hostage_improv.cpp:52 */
-NOBODY bool CHostageImprov::IsAlive(void) const
+NOBODY bool CHostageImprov::__MAKE_VHOOK(IsAlive)(void) const
 {
 }
 
 /* <474809> ../cstrike/dlls/hostage/hostage_improv.cpp:61 */
-NOBODY void CHostageImprov::MoveTo(const Vector &goal)
+NOBODY void CHostageImprov::__MAKE_VHOOK(MoveTo)(const Vector &goal)
 {
 //	Invalidate(CNavPath *const this);  //    64
 //	MoveTo(CHostageImprov *const this,
@@ -58,7 +58,7 @@ NOBODY void CHostageImprov::MoveTo(const Vector &goal)
 }
 
 /* <4717e4> ../cstrike/dlls/hostage/hostage_improv.cpp:78 */
-NOBODY bool CHostageImprov::GetSimpleGroundHeightWithFloor(const Vector *pos, float *height, Vector *normal)
+NOBODY bool CHostageImprov::__MAKE_VHOOK(GetSimpleGroundHeightWithFloor)(const Vector *pos, float *height, Vector *normal)
 {
 //	GetSimpleGroundHeightWithFloor(CHostageImprov *const this,
 //					const Vector *pos,
@@ -79,22 +79,22 @@ NOBODY bool CHostageImprov::DiscontinuityJump(float ground, bool onlyJumpDown, b
 }
 
 /* <470d5b> ../cstrike/dlls/hostage/hostage_improv.cpp:116 */
-NOBODY void CHostageImprov::LookAt(const Vector &target)
+NOBODY void CHostageImprov::__MAKE_VHOOK(LookAt)(const Vector &target)
 {
 }
 
 /* <470d97> ../cstrike/dlls/hostage/hostage_improv.cpp:126 */
-NOBODY void CHostageImprov::ClearLookAt(void)
+NOBODY void CHostageImprov::__MAKE_VHOOK(ClearLookAt)(void)
 {
 }
 
 /* <470dbf> ../cstrike/dlls/hostage/hostage_improv.cpp:135 */
-NOBODY void CHostageImprov::FaceTo(const Vector &goal)
+NOBODY void CHostageImprov::__MAKE_VHOOK(FaceTo)(const Vector &goal)
 {
 }
 
 /* <470dfb> ../cstrike/dlls/hostage/hostage_improv.cpp:145 */
-NOBODY void CHostageImprov::ClearFaceTo(void)
+NOBODY void CHostageImprov::__MAKE_VHOOK(ClearFaceTo)(void)
 {
 }
 
@@ -214,7 +214,7 @@ NOBODY void CHostageImprov::FaceOutwards(void)
 }
 
 /* <470e23> ../cstrike/dlls/hostage/hostage_improv.cpp:344 */
-NOBODY bool CHostageImprov::IsAtMoveGoal(float error) const
+NOBODY bool CHostageImprov::__MAKE_VHOOK(IsAtMoveGoal)(float error) const
 {
 //	operator-(const Vector *const this,
 //			const Vector &v);  //   346
@@ -223,12 +223,12 @@ NOBODY bool CHostageImprov::IsAtMoveGoal(float error) const
 }
 
 /* <470eab> ../cstrike/dlls/hostage/hostage_improv.cpp:353 */
-NOBODY bool CHostageImprov::IsAtFaceGoal(void) const
+NOBODY bool CHostageImprov::__MAKE_VHOOK(IsAtFaceGoal)(void) const
 {
 }
 
 /* <46fb4b> ../cstrike/dlls/hostage/hostage_improv.cpp:395 */
-NOBODY bool CHostageImprov::IsFriendInTheWay(const Vector &goalPos) const
+NOBODY bool CHostageImprov::__MAKE_VHOOK(IsFriendInTheWay)(const Vector &goalPos) const
 {
 //	{
 //		float const avoidFriendInterval;                       //   403
@@ -248,7 +248,7 @@ NOBODY bool CHostageImprov::IsFriendInTheWay(const Vector &goalPos) const
 }
 
 /* <472b83> ../cstrike/dlls/hostage/hostage_improv.cpp:453 */
-NOBODY bool CHostageImprov::IsFriendInTheWay(CBaseEntity *myFriend, const Vector &goalPos) const
+NOBODY bool CHostageImprov::__MAKE_VHOOK(IsFriendInTheWay)(CBaseEntity *myFriend, const Vector &goalPos) const
 {
 //	{
 //		Vector moveDir;                                 //   460
@@ -302,7 +302,7 @@ NOBODY float CHostageImprov::GetSpeed(void)
 }
 
 /* <46f249> ../cstrike/dlls/hostage/hostage_improv.cpp:592 */
-NOBODY bool CHostageImprov::Jump(void)
+NOBODY bool CHostageImprov::__MAKE_VHOOK(Jump)(void)
 {
 //	IsElapsed(const class CountdownTimer *const this);  //   604
 //	{
@@ -316,42 +316,45 @@ NOBODY bool CHostageImprov::Jump(void)
 }
 
 /* <470ed3> ../cstrike/dlls/hostage/hostage_improv.cpp:632 */
-NOBODY void CHostageImprov::Run(void)
+NOBODY void CHostageImprov::__MAKE_VHOOK(Run)(void)
 {
 }
 
 /* <470efb> ../cstrike/dlls/hostage/hostage_improv.cpp:638 */
-NOBODY void CHostageImprov::Walk(void)
+NOBODY void CHostageImprov::__MAKE_VHOOK(Walk)(void)
 {
 }
 
 /* <470f23> ../cstrike/dlls/hostage/hostage_improv.cpp:644 */
-NOBODY void CHostageImprov::Stop(void)
+NOBODY void CHostageImprov::__MAKE_VHOOK(Stop)(void)
 {
 }
 
 /* <470f4c> ../cstrike/dlls/hostage/hostage_improv.cpp:655 */
-NOBODY const Vector &CHostageImprov::GetFeet(void) const
+const Vector &CHostageImprov::__MAKE_VHOOK(GetFeet)(void) const
 {
+	return m_hostage->pev->origin;
 }
 
 /* <470f74> ../cstrike/dlls/hostage/hostage_improv.cpp:661 */
-NOBODY const Vector &CHostageImprov::GetCentroid(void) const
+NOBODY const Vector &CHostageImprov::__MAKE_VHOOK(GetCentroid)(void)
 {
+	m_centroid = m_hostage->pev->origin + Vector(0, 0, 36);
+	return m_centroid;
 }
 
 /* <470f9c> ../cstrike/dlls/hostage/hostage_improv.cpp:671 */
-NOBODY const Vector &CHostageImprov::GetEyes(void) const
+NOBODY const Vector &CHostageImprov::__MAKE_VHOOK(GetEyes)(void) const
 {
 }
 
 /* <470fc4> ../cstrike/dlls/hostage/hostage_improv.cpp:681 */
-NOBODY bool CHostageImprov::IsOnGround(void) const
+NOBODY bool CHostageImprov::__MAKE_VHOOK(IsOnGround)(void) const
 {
 }
 
 /* <470fec> ../cstrike/dlls/hostage/hostage_improv.cpp:687 */
-NOBODY bool CHostageImprov::IsMoving(void) const
+NOBODY bool CHostageImprov::__MAKE_VHOOK(IsMoving)(void) const
 {
 //	{
 //		float const epsilon;                                   //   689
@@ -361,7 +364,7 @@ NOBODY bool CHostageImprov::IsMoving(void) const
 }
 
 /* <4715d1> ../cstrike/dlls/hostage/hostage_improv.cpp:697 */
-NOBODY bool CHostageImprov::IsVisible(const Vector &pos, bool testFOV) const
+NOBODY bool CHostageImprov::__MAKE_VHOOK(IsVisible)(const Vector &pos, bool testFOV) const
 {
 //	{
 //		class Vectorconst eye;                                //   707
@@ -372,7 +375,7 @@ NOBODY bool CHostageImprov::IsVisible(const Vector &pos, bool testFOV) const
 }
 
 /* <472938> ../cstrike/dlls/hostage/hostage_improv.cpp:728 */
-NOBODY bool CHostageImprov::IsPlayerLookingAtMe(CBasePlayer *other, float cosTolerance) const
+NOBODY bool CHostageImprov::__MAKE_VHOOK(IsPlayerLookingAtMe)(CBasePlayer *other, float cosTolerance) const
 {
 //	{
 //		class Vector2D toOther;                               //   730
@@ -385,7 +388,7 @@ NOBODY bool CHostageImprov::IsPlayerLookingAtMe(CBasePlayer *other, float cosTol
 }
 
 /* <472a9f> ../cstrike/dlls/hostage/hostage_improv.cpp:757 */
-NOBODY CBasePlayer *CHostageImprov::IsAnyPlayerLookingAtMe(int team, float cosTolerance) const
+NOBODY CBasePlayer *CHostageImprov::__MAKE_VHOOK(IsAnyPlayerLookingAtMe)(int team, float cosTolerance) const
 {
 //	{
 //		int i;                                                //   759
@@ -397,7 +400,7 @@ NOBODY CBasePlayer *CHostageImprov::IsAnyPlayerLookingAtMe(int team, float cosTo
 }
 
 /* <472e7b> ../cstrike/dlls/hostage/hostage_improv.cpp:783 */
-NOBODY CBasePlayer *CHostageImprov::GetClosestPlayerByTravelDistance(int team, float *range) const
+NOBODY CBasePlayer *CHostageImprov::__MAKE_VHOOK(GetClosestPlayerByTravelDistance)(int team, float *range) const
 {
 //	{
 //		class CBasePlayer *close;                            //   788
@@ -420,21 +423,60 @@ NOBODY CBasePlayer *CHostageImprov::GetClosestPlayerByTravelDistance(int team, f
 }
 
 /* <47166d> ../cstrike/dlls/hostage/hostage_improv.cpp:822 */
-NOBODY void CHostageImprov::OnReset(void)
+void CHostageImprov::__MAKE_VHOOK(OnReset)(void)
 {
-//	Invalidate(CountdownTimer *const this);  //   833
+	m_moveFlags = 0;
-//	SetMoveAngle(CHostageImprov *const this,
+	m_moveType = Stopped;
-//			float angle);  //   840
+	m_moveLimit = Running;
-//	Invalidate(CountdownTimer *const this);  //   846
+	
-//	Invalidate(CNavPath *const this);  //   856
+	m_vel.x = 0;
-//	Invalidate(CountdownTimer *const this);  //   854
+	m_vel.y = 0;
-//	Start(IntervalTimer *const this);  //   863
+
-//	Start(IntervalTimer *const this);  //   864
+	m_actualVel = Vector(0, 0, 0);
-//	Invalidate(CountdownTimer *const this);  //   866
+	m_checkNearbyTerroristTimer.Invalidate();
-//	Invalidate(CountdownTimer *const this);  //   868
+
-//	Idle(CHostageImprov *const this);  //   879
+	m_lastKnownArea = NULL;
-//	Reset(SimpleStateMachine<CHostageImprov*, HostageState> *const this,
+	m_hasKnownGoodPos = false;
-//		class CHostageImprov *userData);  //   878
+	m_hasPriorKnownGoodPos = false;
+	m_isTerroristNearby = false;
+	m_isCrouching = false;
+
+	SetMoveAngle(m_hostage->pev->angles.y);
+
+	m_moveGoal = m_hostage->m_vStart;
+
+	ClearLookAt();
+	ClearFaceTo();
+
+	m_blinkTimer.Invalidate();
+	m_blinkCounter = 0;
+
+	m_hostage->SetBoneController(2, 0);
+	m_hostage->SetBoneController(3, 0);
+	m_hostage->SetBoneController(4, 0);
+
+	m_path.Invalidate();
+	m_chatterTimer.Invalidate();
+
+	m_visiblePlayerCount = 0;
+	m_isDelayedChatterPending = 0;
+
+	m_animateState.Reset();
+	m_didFidget = 0;
+
+	m_lastSawCT.Start();
+	m_lastSawT.Start();
+
+	m_scaredTimer.Invalidate();
+	m_jumpTimer.Invalidate();
+	m_hasJumped = false;
+
+	m_isFriendInTheWay = false;
+	m_aggression = RANDOM_FLOAT(0, 1);
+
+	StandUp();
+	m_behavior.Reset(this);
+	Idle();
 }
 
 /* <474659> ../cstrike/dlls/hostage/hostage_improv.cpp:886 */
@@ -455,7 +497,7 @@ NOBODY void CHostageImprov::UpdateVision(void)
 }
 
 /* <476e49> ../cstrike/dlls/hostage/hostage_improv.cpp:997 */
-NOBODY void CHostageImprov::TrackPath(const Vector &pathGoal, float deltaT)
+NOBODY void CHostageImprov::__MAKE_VHOOK(TrackPath)(const Vector &pathGoal, float deltaT)
 {
 //	TrackPath(CHostageImprov *const this,
 //			const Vector &pathGoal,
@@ -485,12 +527,12 @@ NOBODY void CHostageImprov::ResetToKnownGoodPosition(void)
 }
 
 /* <47105c> ../cstrike/dlls/hostage/hostage_improv.cpp:1082 */
-NOBODY void CHostageImprov::StartLadder(const class CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos)
+NOBODY void CHostageImprov::__MAKE_VHOOK(StartLadder)(const class CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos)
 {
 }
 
 /* <4710c4> ../cstrike/dlls/hostage/hostage_improv.cpp:1094 */
-NOBODY bool CHostageImprov::TraverseLadder(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos, float deltaT)
+NOBODY bool CHostageImprov::__MAKE_VHOOK(TraverseLadder)(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos, float deltaT)
 {
 //	{
 //		Vector goal;                                    //  1098
@@ -597,7 +639,7 @@ NOBODY void CHostageImprov::UpdatePosition(float deltaT)
 }
 
 /* <47837a> ../cstrike/dlls/hostage/hostage_improv.cpp:1384 */
-NOBODY void CHostageImprov::OnUpkeep(float deltaT)
+NOBODY void CHostageImprov::__MAKE_VHOOK(OnUpkeep)(float deltaT)
 {
 }
 
@@ -649,7 +691,7 @@ NOBODY void CHostageImprov::UpdateGrenadeReactions(void)
 }
 
 /* <475ce3> ../cstrike/dlls/hostage/hostage_improv.cpp:1502 */
-NOBODY void CHostageImprov::OnUpdate(float deltaT)
+NOBODY void CHostageImprov::__MAKE_VHOOK(OnUpdate)(float deltaT)
 {
 //	{
 //		float const runSpeed;                                  //  1553
@@ -668,7 +710,7 @@ NOBODY void CHostageImprov::OnUpdate(float deltaT)
 }
 
 /* <47552a> ../cstrike/dlls/hostage/hostage_improv.cpp:1705 */
-NOBODY void CHostageImprov::OnGameEvent(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+NOBODY void CHostageImprov::__MAKE_VHOOK(OnGameEvent)(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
 {
 //	DelayedChatter(CHostageImprov *const this,
 //			float delayTime,
@@ -729,7 +771,7 @@ NOBODY void CHostageImprov::OnGameEvent(GameEventType event, CBaseEntity *entity
 }
 
 /* <471e27> ../cstrike/dlls/hostage/hostage_improv.cpp:1854 */
-NOBODY void CHostageImprov::OnTouch(CBaseEntity *other)
+NOBODY void CHostageImprov::__MAKE_VHOOK(OnTouch)(CBaseEntity *other)
 {
 //	{
 //		const char *classname;                              //  1856
@@ -991,7 +1033,7 @@ NOBODY void CHostageImprov::Wave(void)
 }
 
 /* <474938> ../cstrike/dlls/hostage/hostage_improv.cpp:2375 */
-NOBODY void CHostageImprov::OnMoveToFailure(const Vector &goal, MoveToFailureType reason)
+NOBODY void CHostageImprov::__MAKE_VHOOK(OnMoveToFailure)(const Vector &goal, MoveToFailureType reason)
 {
 //	OnMoveToFailure(HostageStateMachine *const this,
 //			const Vector &goal,
@@ -1068,7 +1110,7 @@ NOBODY void CHostageImprov::ClearPath(void)
 }
 
 /* <471b3f> ../cstrike/dlls/hostage/hostage_improv.cpp:2497 */
-NOBODY void CHostageImprov::Crouch(void)
+NOBODY void CHostageImprov::__MAKE_VHOOK(Crouch)(void)
 {
 //	{
 //		float const minCrouchTime;                             //  2503
@@ -1077,17 +1119,32 @@ NOBODY void CHostageImprov::Crouch(void)
 }
 
 /* <47195c> ../cstrike/dlls/hostage/hostage_improv.cpp:2516 */
-NOBODY void CHostageImprov::StandUp(void)
+void CHostageImprov::__MAKE_VHOOK(StandUp)(void)
 {
-//	{
+	if (!IsCrouching() || !m_minCrouchTimer.IsElapsed())
-//		TraceResult result;                                   //  2525
+	{
-//		int y;                                        //  2527
+		return;
-//		{
+	}
-//			int x;                                //  2529
+
-//		}
+	int y;
-//		IsElapsed(const class CountdownTimer *const this);  //  2521
+	for (y = -24; y < 36; y += 12)
-//	}
+	{
-//	StandUp(CHostageImprov *const this);  //  2516
+		for (int x = -24; x < 36; x += 12)
+		{
+			TraceResult result;
+			UTIL_TraceLine(GetFeet() + Vector(0, 0, 3), GetFeet() + Vector(x, y, 72), ignore_monsters, ignore_glass, m_hostage->edict(), &result);
+
+			if (result.flFraction < 1.0f)
+				return;
+		}
+	}
+
+	if (y == 36)
+	{
+		m_animateState.Reset();
+		UTIL_SetSize(m_hostage->pev, Vector(-10, -10, 0), Vector(10, 10, 62));
+		m_isCrouching = false;
+	}
 }
 
 /* <477114> ../cstrike/dlls/hostage/hostage_improv.cpp:2558 */
@@ -1095,3 +1152,183 @@ NOBODY void CHostageImprov::UpdateStationaryAnimation(void)
 {
 //	UpdateStationaryAnimation(HostageStateMachine::UpdateStationaryAnimation(//					class CHostageImprov *improv);  //  2560
 }
+
+#ifdef HOOK_GAMEDLL
+
+
+void CHostageImprov::OnMoveToFailure(const Vector &goal, MoveToFailureType reason)
+{
+	OnMoveToFailure_(goal, reason);
+}
+
+bool CHostageImprov::IsAlive(void) const
+{
+	return IsAlive_();
+}
+
+void CHostageImprov::MoveTo(const Vector &goal)
+{
+	MoveTo_(goal);
+}
+
+void CHostageImprov::LookAt(const Vector &target)
+{
+	LookAt_(target);
+}
+
+void CHostageImprov::ClearLookAt(void)
+{
+	ClearLookAt_();
+}
+
+void CHostageImprov::FaceTo(const Vector &goal)
+{
+	FaceTo_(goal);
+}
+
+void CHostageImprov::ClearFaceTo(void)
+{
+	ClearFaceTo_();
+}
+
+bool CHostageImprov::IsAtMoveGoal(float error) const
+{
+	return IsAtMoveGoal_(error);
+}
+
+bool CHostageImprov::IsAtFaceGoal(void) const
+{
+	return IsAtFaceGoal_();
+}
+
+bool CHostageImprov::IsFriendInTheWay(const Vector &goalPos) const
+{
+	return IsFriendInTheWay_(goalPos);
+}
+
+bool CHostageImprov::IsFriendInTheWay(CBaseEntity *myFriend, const Vector &goalPos) const
+{
+	return IsFriendInTheWay_(myFriend, goalPos);
+}
+
+bool CHostageImprov::Jump(void)
+{
+	return Jump_();
+}
+
+void CHostageImprov::Crouch(void)
+{
+	Crouch_();
+}
+
+void CHostageImprov::StandUp(void)
+{
+	StandUp_();
+}
+
+void CHostageImprov::TrackPath(const Vector &pathGoal, float deltaT)
+{
+	TrackPath_(pathGoal, deltaT);
+}
+
+void CHostageImprov::StartLadder(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos)
+{
+	StartLadder_(ladder, how, approachPos, departPos);
+}
+
+bool CHostageImprov::TraverseLadder(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos, float deltaT)
+{
+	return TraverseLadder_(ladder, how, approachPos, departPos, deltaT);
+}
+
+bool CHostageImprov::GetSimpleGroundHeightWithFloor(const Vector *pos, float *height, Vector *normal)
+{
+	return GetSimpleGroundHeightWithFloor_(pos, height, normal);
+}
+
+void CHostageImprov::Run(void)
+{
+	Run_();
+}
+
+void CHostageImprov::Walk(void)
+{
+	Walk_();
+}
+
+void CHostageImprov::Stop(void)
+{
+	Stop_();
+}
+
+const Vector &CHostageImprov::GetFeet(void) const
+{
+	return GetFeet_();
+}
+
+const Vector &CHostageImprov::GetCentroid(void)
+{
+	return GetCentroid_();
+}
+
+const Vector &CHostageImprov::GetEyes(void) const
+{
+	return GetEyes_();
+}
+
+bool CHostageImprov::IsOnGround(void) const
+{
+	return IsOnGround_();
+}
+
+bool CHostageImprov::IsMoving(void) const
+{
+	return IsMoving_();
+}
+
+bool CHostageImprov::IsVisible(const Vector &pos, bool testFOV) const
+{
+	return IsVisible_(pos, testFOV);
+}
+
+bool CHostageImprov::IsPlayerLookingAtMe(CBasePlayer *other, float cosTolerance) const
+{
+	return IsPlayerLookingAtMe_(other, cosTolerance);
+}
+
+CBasePlayer *CHostageImprov::IsAnyPlayerLookingAtMe(int team, float cosTolerance) const
+{
+	return IsAnyPlayerLookingAtMe_(team, cosTolerance);
+}
+
+CBasePlayer *CHostageImprov::GetClosestPlayerByTravelDistance(int team, float *range) const
+{
+	return GetClosestPlayerByTravelDistance_(team, range);
+}
+
+void CHostageImprov::OnUpdate(float deltaT)
+{
+	OnUpdate_(deltaT);
+}
+
+void CHostageImprov::OnUpkeep(float deltaT)
+{
+	OnUpkeep_(deltaT);
+}
+
+void CHostageImprov::OnReset(void)
+{
+	OnReset_();
+}
+
+void CHostageImprov::OnGameEvent(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+{
+	OnGameEvent_(event, entity, other);
+}
+
+void CHostageImprov::OnTouch(CBaseEntity *other)
+{
+	OnTouch_(other);
+}
+
+#endif // HOOK_GAMEDLL

regamedll/dlls/hostage/hostage_improv.h

@@ -51,124 +51,248 @@ public:
 		//~CImprov();			//    49
 	};
 
-	virtual void OnMoveToSuccess(const Vector &goal)
+	NOBODY virtual void OnMoveToSuccess(const Vector &goal)
 	{
 		//if (m_behavior.IsState(NULL))
 		//	IImprovEvent::OnMoveToSuccess(goal);
 	}
-	virtual void OnMoveToFailure(const Vector &goal, MoveToFailureType reason);
+	NOBODY virtual void OnMoveToFailure(const Vector &goal, MoveToFailureType reason);
-	virtual void OnInjury(float amount)
+	NOBODY virtual void OnInjury(float amount)
 	{
 		//m_behavior.Update();
 		//m_lastInjuryTimer.Start();
 	}
-	virtual bool IsAlive(void) const;
+	NOBODY virtual bool IsAlive(void) const;
-	virtual void MoveTo(const Vector &goal);
+	NOBODY virtual void MoveTo(const Vector &goal);
-	virtual void LookAt(const Vector &target);
+	NOBODY virtual void LookAt(const Vector &target);
-	virtual void ClearLookAt(void);
+	NOBODY virtual void ClearLookAt(void);
-	virtual void FaceTo(const Vector &goal);
+	NOBODY virtual void FaceTo(const Vector &goal);
-	virtual void ClearFaceTo(void);
+	NOBODY virtual void ClearFaceTo(void);
-	virtual bool IsAtMoveGoal(float error = 20.0f) const;
+	NOBODY virtual bool IsAtMoveGoal(float error = 20.0f) const;
-	virtual bool HasLookAt(void) const
+	NOBODY virtual bool HasLookAt(void) const
 	{
 		return m_isLookingAt;
 	}
-	virtual bool HasFaceTo(void) const
+	NOBODY virtual bool HasFaceTo(void) const
 	{
 		return m_isFacingTo;
 	}
-	virtual bool IsAtFaceGoal(void) const;
+	NOBODY virtual bool IsAtFaceGoal(void) const;
-	virtual bool IsFriendInTheWay(const Vector &goalPos) const;
+	NOBODY virtual bool IsFriendInTheWay(const Vector &goalPos) const;
-	virtual bool IsFriendInTheWay(CBaseEntity *myFriend, const Vector &goalPos) const;
+	NOBODY virtual bool IsFriendInTheWay(CBaseEntity *myFriend, const Vector &goalPos) const;
-	virtual void MoveForward(void)
+	NOBODY virtual void MoveForward(void)
 	{
 		m_moveFlags |= IN_FORWARD;
 	}
-	virtual void MoveBackward(void)
+	NOBODY virtual void MoveBackward(void)
 	{
 		m_moveFlags |= IN_BACK;
 	}
-	virtual void StrafeLeft(void)
+	NOBODY virtual void StrafeLeft(void)
 	{
 		m_moveFlags |= IN_MOVELEFT;
 	}
-	virtual void StrafeRight(void)
+	NOBODY virtual void StrafeRight(void)
 	{
 		m_moveFlags |= IN_MOVERIGHT;
 	}
-	virtual bool Jump(void);
+	NOBODY virtual bool Jump(void);
-	virtual void Crouch(void);
+	NOBODY virtual void Crouch(void);
 	virtual void StandUp(void);
-	virtual void TrackPath(const Vector &pathGoal, float deltaT);
+	NOBODY virtual void TrackPath(const Vector &pathGoal, float deltaT);
-	virtual void StartLadder(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos);
+	NOBODY virtual void StartLadder(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos);
-	virtual bool TraverseLadder(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos, float deltaT);
+	NOBODY virtual bool TraverseLadder(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos, float deltaT);
-	virtual bool GetSimpleGroundHeightWithFloor(const Vector *pos, float *height, Vector *normal = NULL);
+	NOBODY virtual bool GetSimpleGroundHeightWithFloor(const Vector *pos, float *height, Vector *normal = NULL);
-	virtual void Run(void);
+	NOBODY virtual void Run(void);
-	virtual void Walk(void);
+	NOBODY virtual void Walk(void);
-	virtual void Stop(void);
+	NOBODY virtual void Stop(void);
-	virtual float GetMoveAngle(void) const
+	NOBODY virtual float GetMoveAngle(void) const
 	{
 		return m_moveAngle;
 	}
-	virtual float GetFaceAngle(void) const
+	NOBODY virtual float GetFaceAngle(void) const
 	{
 		return m_moveAngle;
 	}
-	virtual const Vector &GetFeet(void) const;
+	NOBODY virtual const Vector &GetFeet(void) const;
-	virtual const Vector &GetCentroid(void) const;
+	NOBODY virtual const Vector &GetCentroid(void);
-	virtual const Vector &GetEyes(void) const;
+	NOBODY virtual const Vector &GetEyes(void) const;
-	virtual bool IsRunning(void) const
+	NOBODY virtual bool IsRunning(void) const
 	{
 		return (m_moveType == Running);
 	}
-	virtual bool IsWalking(void) const
+	NOBODY virtual bool IsWalking(void) const
 	{
 		return (m_moveType == Walking);
 	}
-	virtual bool IsStopped(void) const
+	NOBODY virtual bool IsStopped(void) const
 	{
 		return (m_moveType == Stopped);
 	}
-	virtual bool IsCrouching(void) const
+	NOBODY virtual bool IsCrouching(void) const
 	{
 		return m_isCrouching;
 	}
-	virtual bool IsJumping(void) const
+	NOBODY virtual bool IsJumping(void) const
 	{
 		UNTESTED
 		return (m_jumpTimer.IsElapsed() == false);
 	}
-	virtual bool IsUsingLadder(void) const
+	NOBODY virtual bool IsUsingLadder(void) const
 	{
 		return false;
 	}
-	virtual bool IsOnGround(void) const;
+	NOBODY virtual bool IsOnGround(void) const;
-	virtual bool IsMoving(void) const;
+	NOBODY virtual bool IsMoving(void) const;
-	virtual bool CanRun(void) const
+	NOBODY virtual bool CanRun(void) const
 	{
 		return true;
 	}
-	virtual bool CanCrouch(void) const
+	NOBODY virtual bool CanCrouch(void) const
 	{
 		return true;
 	}
-	virtual bool CanJump(void) const
+	NOBODY virtual bool CanJump(void) const
 	{
 		return true;
 	}
-	virtual bool IsVisible(const Vector &pos, bool testFOV = false) const;
+	NOBODY virtual bool IsVisible(const Vector &pos, bool testFOV = false) const;
-	virtual bool IsPlayerLookingAtMe(CBasePlayer *other, float cosTolerance = 0.95f) const;
+	NOBODY virtual bool IsPlayerLookingAtMe(CBasePlayer *other, float cosTolerance = 0.95f) const;
-	virtual CBasePlayer *IsAnyPlayerLookingAtMe(int team = 0, float cosTolerance = 0.95f) const;
+	NOBODY virtual CBasePlayer *IsAnyPlayerLookingAtMe(int team = 0, float cosTolerance = 0.95f) const;
-	virtual CBasePlayer *GetClosestPlayerByTravelDistance(int team = 0, float *range = NULL) const;
+	NOBODY virtual CBasePlayer *GetClosestPlayerByTravelDistance(int team = 0, float *range = NULL) const;
-	virtual CNavArea *GetLastKnownArea(void) const
+	NOBODY virtual CNavArea *GetLastKnownArea(void) const
 	{
 		return m_lastKnownArea;
 	}
-	virtual void OnUpdate(float deltaT);
+	NOBODY virtual void OnUpdate(float deltaT);
-	virtual void OnUpkeep(float deltaT);
+	NOBODY virtual void OnUpkeep(float deltaT);
 	virtual void OnReset(void);
-	virtual void OnGameEvent(GameEventType event, CBaseEntity *entity = NULL, CBaseEntity *other = NULL);
+	NOBODY virtual void OnGameEvent(GameEventType event, CBaseEntity *entity = NULL, CBaseEntity *other = NULL);
-	virtual void OnTouch(CBaseEntity *other);
+	NOBODY virtual void OnTouch(CBaseEntity *other);
+
+#ifdef HOOK_GAMEDLL
+
+	void OnMoveToSuccess_(const Vector &goal)
+	{
+		//if (m_behavior.IsState(NULL))
+		//	IImprovEvent::OnMoveToSuccess(goal);
+	}
+	void OnMoveToFailure_(const Vector &goal, MoveToFailureType reason);
+	void OnInjury_(float amount)
+	{
+		//m_behavior.Update();
+		//m_lastInjuryTimer.Start();
+	}
+	bool IsAlive_(void) const;
+	void MoveTo_(const Vector &goal);
+	void LookAt_(const Vector &target);
+	void ClearLookAt_(void);
+	void FaceTo_(const Vector &goal);
+	void ClearFaceTo_(void);
+	bool IsAtMoveGoal_(float error = 20.0f) const;
+	bool HasLookAt_(void) const
+	{
+		return m_isLookingAt;
+	}
+	bool HasFaceTo_(void) const
+	{
+		return m_isFacingTo;
+	}
+	bool IsAtFaceGoal_(void) const;
+	bool IsFriendInTheWay_(const Vector &goalPos) const;
+	bool IsFriendInTheWay_(CBaseEntity *myFriend, const Vector &goalPos) const;
+	void MoveForward_(void)
+	{
+		m_moveFlags |= IN_FORWARD;
+	}
+	void MoveBackward_(void)
+	{
+		m_moveFlags |= IN_BACK;
+	}
+	void StrafeLeft_(void)
+	{
+		m_moveFlags |= IN_MOVELEFT;
+	}
+	void StrafeRight_(void)
+	{
+		m_moveFlags |= IN_MOVERIGHT;
+	}
+	bool Jump_(void);
+	void Crouch_(void);
+	void StandUp_(void);
+	void TrackPath_(const Vector &pathGoal, float deltaT);
+	void StartLadder_(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos);
+	bool TraverseLadder_(const CNavLadder *ladder, NavTraverseType how, const Vector *approachPos, const Vector *departPos, float deltaT);
+	bool GetSimpleGroundHeightWithFloor_(const Vector *pos, float *height, Vector *normal = NULL);
+	void Run_(void);
+	void Walk_(void);
+	void Stop_(void);
+	float GetMoveAngle_(void) const
+	{
+		return m_moveAngle;
+	}
+	float GetFaceAngle_(void) const
+	{
+		return m_moveAngle;
+	}
+	const Vector &GetFeet_(void) const;
+	const Vector &GetCentroid_(void);
+	const Vector &GetEyes_(void) const;
+	bool IsRunning_(void) const
+	{
+		return (m_moveType == Running);
+	}
+	bool IsWalking_(void) const
+	{
+		return (m_moveType == Walking);
+	}
+	bool IsStopped_(void) const
+	{
+		return (m_moveType == Stopped);
+	}
+	bool IsCrouching_(void) const
+	{
+		return m_isCrouching;
+	}
+	bool IsJumping_(void) const
+	{
+		UNTESTED
+		return (m_jumpTimer.IsElapsed() == false);
+	}
+	bool IsUsingLadder_(void) const
+	{
+		return false;
+	}
+	bool IsOnGround_(void) const;
+	bool IsMoving_(void) const;
+	bool CanRun_(void) const
+	{
+		return true;
+	}
+	bool CanCrouch_(void) const
+	{
+		return true;
+	}
+	bool CanJump_(void) const
+	{
+		return true;
+	}
+	bool IsVisible_(const Vector &pos, bool testFOV = false) const;
+	bool IsPlayerLookingAtMe_(CBasePlayer *other, float cosTolerance = 0.95f) const;
+	CBasePlayer *IsAnyPlayerLookingAtMe_(int team = 0, float cosTolerance = 0.95f) const;
+	CBasePlayer *GetClosestPlayerByTravelDistance_(int team = 0, float *range = NULL) const;
+	CNavArea *GetLastKnownArea_(void) const
+	{
+		return m_lastKnownArea;
+	}
+	void OnUpdate_(float deltaT);
+	void OnUpkeep_(float deltaT);
+	void OnReset_(void);
+	void OnGameEvent_(GameEventType event, CBaseEntity *entity = NULL, CBaseEntity *other = NULL);
+	void OnTouch_(CBaseEntity *other);
+
+#endif // HOOK_GAMEDLL
+
 public:
 
 	enum MoveType
@@ -206,7 +330,10 @@ public:
 	}
 	CNavPath *GetPath(void);
 	CNavPathFollower *GetPathFollower(void);
-	void Idle(void);
+	void Idle(void)
+	{
+		m_behavior.SetState(&m_idleState);
+	}
 	bool IsIdle(void)
 	{
 		UNTESTED
@@ -224,7 +351,10 @@ public:
 	bool IsRetreating(void);
 	bool IsAtHome(void);
 	bool CanSeeRescueZone(void);
-	CBaseEntity *GetFollowLeader(void);
+	CBaseEntity *GetFollowLeader(void)
+	{
+		return m_followState.GetLeader();
+	}
 	CBasePlayer *GetClosestVisiblePlayer(int team);
 	float GetTimeSinceLastSawPlayer(int team);
 	float GetTimeSinceLastInjury(void);
@@ -254,7 +384,10 @@ public:
 	void MoveTowards(const Vector &pos, float deltaT);
 	bool FaceTowards(const Vector &target, float deltaT);
 	float GetSpeed(void);
-	void SetMoveAngle(float angle);
+	void SetMoveAngle(float angle)
+	{
+		m_moveAngle = angle;
+	}
 	void Wiggle(void);
 	void ClearPath(void);
 	bool DiscontinuityJump(float ground, bool onlyJumpDown, bool mustJump);

regamedll/dlls/hostage/hostage_localnav.cpp

@@ -41,7 +41,7 @@ NOBODY CLocalNav::~CLocalNav(void)
 }
 
 /* <485b91> ../cstrike/dlls/hostage/hostage_localnav.cpp:74 */
-NOXREF node_index_t CLocalNav::AddNode(node_index_t nindexParent, Vector &vecLoc, int offsetX, int offsetY, byte bDepth)
+node_index_t CLocalNav::AddNode(node_index_t nindexParent, Vector &vecLoc, int offsetX, int offsetY, byte bDepth)
 {
 	localnode_t *nodeNew;
 
@@ -61,101 +61,211 @@ NOXREF node_index_t CLocalNav::AddNode(node_index_t nindexParent, Vector &vecLoc
 }
 
 /* <485570> ../cstrike/dlls/hostage/hostage_localnav.cpp:94 */
-NOXREF localnode_t *CLocalNav::GetNode(node_index_t nindex)
+localnode_t *CLocalNav::GetNode(node_index_t nindex)
 {
 	return &m_nodeArr[ nindex ];
 }
 
 /* <485c01> ../cstrike/dlls/hostage/hostage_localnav.cpp:100 */
-NOXREF node_index_t CLocalNav::NodeExists(int offsetX, int offsetY)
+node_index_t CLocalNav::NodeExists(int offsetX, int offsetY)
 {
-	node_index_t nindexCurrent;
+	node_index_t nindexCurrent = NODE_INVALID_EMPTY;
 	localnode_t *nodeCurrent;
 
-	for (nindexCurrent = m_nindexAvailableNode - 1; nindexCurrent != 0; nindexCurrent--)
+	for (nindexCurrent = m_nindexAvailableNode - 1; nindexCurrent != NODE_INVALID_EMPTY; nindexCurrent--)
 	{
 		nodeCurrent = GetNode(nindexCurrent);
 
 		if (nodeCurrent->offsetX == offsetX && nodeCurrent->offsetY == offsetY)
-			return nindexCurrent;
+		{
+			break;
+		}
 	}
-	return -1;
+
+	return nindexCurrent;
 }
 
 /* <486d46> ../cstrike/dlls/hostage/hostage_localnav.cpp:123 */
-NOBODY void CLocalNav::AddPathNodes(node_index_t nindexSource, int fNoMonsters)
+void CLocalNav::AddPathNodes(node_index_t nindexSource, int fNoMonsters)
 {
+	AddPathNode(nindexSource, 1, 0, fNoMonsters);
+	AddPathNode(nindexSource, -1, 0, fNoMonsters);
+	AddPathNode(nindexSource, 0, 1, fNoMonsters);
+	AddPathNode(nindexSource, 0, -1, fNoMonsters);
+	AddPathNode(nindexSource, 1, 1, fNoMonsters);
+	AddPathNode(nindexSource, 1, -1, fNoMonsters);
+	AddPathNode(nindexSource, -1, 1, fNoMonsters);
+	AddPathNode(nindexSource, -1, -1, fNoMonsters);
 }
 
 /* <486adb> ../cstrike/dlls/hostage/hostage_localnav.cpp:138 */
-NOBODY void CLocalNav::AddPathNode(node_index_t nindexSource, int offsetX, int offsetY, int fNoMonsters)
+void CLocalNav::AddPathNode(node_index_t nindexSource, int offsetX, int offsetY, int fNoMonsters)
 {
-//	{
+	int bDepth;
-//		int bDepth;                                           //   140
+	Vector vecSource, vecDest;
-//		Vector vecSource;                               //   141
+	int offsetXAbs, offsetYAbs;
-//		Vector vecDest;                                 //   142
+
-//		int offsetXAbs;                                       //   143
+	if (nindexSource == -1)
-//		int offsetYAbs;                                       //   144
+	{
-//		{
+		bDepth = 1;
-//			localnode_t *nodeSource;                     //   156
+
-//			localnode_t *nodeCurrent;                    //   157
+		offsetXAbs = offsetX;
-//			node_index_t nindexCurrent;                   //   158
+		offsetYAbs = offsetY;
-//			GetNode(CLocalNav *const this,
+
-//				node_index_t nindex);  //   160
+		vecSource = m_vecStartingLoc;
-//			NodeExists(CLocalNav *const this,
+		vecDest = vecSource + Vector(((float_precision)offsetX * HOSTAGE_STEPSIZE), ((float_precision)offsetY * HOSTAGE_STEPSIZE), 0);
-//					int offsetX,
+	}
-//					int offsetY);  //   166
+	else
-//			operator+(const Vector *const this,
+	{
-//					const Vector &v);  //   170
+		localnode_t *nodeSource;
-//			operator*(const Vector *const this,
+		localnode_t *nodeCurrent;
-//					float fl);  //   170
+		node_index_t nindexCurrent;
-//		}
+
-//		operator+(const Vector *const this,
+		nodeCurrent = GetNode(nindexSource);
-//				const Vector &v);  //   149
+		offsetXAbs = offsetX + nodeCurrent->offsetX;
-//		operator*(const Vector *const this,
+		offsetYAbs = offsetY + nodeCurrent->offsetY;
-//				float fl);  //   149
+		nodeSource = GetNode(m_nindexAvailableNode);
-//		AddNode(CLocalNav *const this,
+
-//			node_index_t nindexParent,
+		// if there exists a node, then to ignore adding a the new node
-//			Vector &vecLoc,
+		if (NodeExists(offsetXAbs, offsetYAbs) != NODE_INVALID_EMPTY)
-//			int offsetX,
+		{
-//			int offsetY,
+			return;
-//			byte bDepth);  //   200
+		}
-//	}
+
+		vecSource = nodeCurrent->vecLoc;
+		vecDest = vecSource + Vector(((float_precision)offsetX * HOSTAGE_STEPSIZE), ((float_precision)offsetY * HOSTAGE_STEPSIZE), 0);
+
+		if (m_nindexAvailableNode)
+		{
+			nindexCurrent = m_nindexAvailableNode;
+
+			do
+			{
+				nodeSource--;
+				nindexCurrent--;
+
+				offsetX = (nodeSource->offsetX - offsetXAbs);
+
+				if (offsetX >= 0)
+				{
+					if (offsetX > 1)
+					{
+						continue;
+					}
+				}
+				else
+				{
+					if (-offsetX > 1)
+					{
+						continue;
+					}
+				}
+
+				offsetY = (nodeSource->offsetY - offsetYAbs);
+
+				if (offsetY >= 0)
+				{
+					if (offsetY > 1)
+					{
+						continue;
+					}
+				}
+				else
+				{
+					if (-offsetY > 1)
+					{
+						continue;
+					}
+				}
+
+				if (PathTraversable(nodeSource->vecLoc, vecDest, fNoMonsters) != PATH_TRAVERSABLE_EMPTY)
+				{
+					nodeCurrent = nodeSource;
+					nindexSource = nindexCurrent;
+				}
+			}
+			while (nindexCurrent);
+		}
+
+		vecSource = nodeCurrent->vecLoc;
+		bDepth = ((int)nodeCurrent->bDepth) + 1;
+	}
+
+	if (PathTraversable(vecSource, vecDest, fNoMonsters) != PATH_TRAVERSABLE_EMPTY)
+	{
+		AddNode(nindexSource, vecDest, offsetXAbs, offsetYAbs, bDepth);
+	}
 }
 
 /* <485c63> ../cstrike/dlls/hostage/hostage_localnav.cpp:205 */
-NOBODY node_index_t CLocalNav::GetBestNode(Vector &vecOrigin, Vector &vecDest)
+node_index_t CLocalNav::GetBestNode(Vector &vecOrigin, Vector &vecDest)
 {
-//	{
+	node_index_t nindexCurrent;
-//		node_index_t nindexCurrent;                           //   207
+	localnode_t *nodeCurrent;
-//		localnode_t *nodeCurrent;                            //   208
+	node_index_t nindexBest;
-//		node_index_t nindexBest;                              //   209
+	float flBestVal;
-//		float flBestVal;                                      //   210
+
-//		{
+	nindexBest = -1;
-//			float flCurrentVal;                           //   220
+	nindexCurrent = 0;
-//			float flDistFromStart;                        //   221
+	flBestVal = 1000000.0;
-//			float flDistToDest;                           //   222
+
-//			float flZDiff;                                //   223
+	while (nindexCurrent < m_nindexAvailableNode)
-//			operator-(const Vector *const this,
+	{
-//					const Vector &v);  //   235
+		nodeCurrent = GetNode(nindexCurrent);
-//			Length(const Vector *const this);  //   235
+
-//		}
+		if (!nodeCurrent->fSearched)
-//	}
+		{
+			float_precision flCurrentVal;
+			float_precision flDistFromStart;
+
+			float flDistToDest;
+			float_precision flZDiff = -1.0;
+
+			flDistFromStart = LenghtSubtract
+				<float_precision, float_precision,
+				float_precision, float_precision>(vecDest, nodeCurrent->vecLoc);
+
+			flDistToDest = nodeCurrent->vecLoc.z - vecDest.z;
+			if (flDistToDest >= 0.0)
+			{
+				flZDiff = 1.0;
+			}
+
+			if ((flDistToDest * flZDiff) <= s_flStepSize)
+				flZDiff = 1.0;
+			else
+				flZDiff = 1.25;
+
+			flCurrentVal = flZDiff * (((float_precision)nodeCurrent->bDepth * HOSTAGE_STEPSIZE) + flDistFromStart);
+			if (flCurrentVal < flBestVal)
+			{
+				flBestVal = flCurrentVal;
+				nindexBest = nindexCurrent;
+			}
+		}
+
+		nindexCurrent++;
+	}
+
+	return nindexBest;
 }
 
 /* <485d79> ../cstrike/dlls/hostage/hostage_localnav.cpp:263 */
-NOBODY int CLocalNav::SetupPathNodes(node_index_t nindex, Vector *vecNodes, int fNoMonsters)
+int CLocalNav::SetupPathNodes(node_index_t nindex, Vector *vecNodes, int fNoMonsters)
-{
+{
-//	{
+	node_index_t nCurrentIndex = nindex;
-//		node_index_t nCurrentIndex;                           //   265
+	int nNodeCount = 0;
-//		int nNodeCount;                                       //   266
+
-//		{
+	while (nCurrentIndex != -1)
-//			localnode_t *nodeCurrent;                    //   273
+	{
-//			Vector vecCurrentLoc;                   //   274
+		localnode_t *nodeCurrent = GetNode(nCurrentIndex);
-//			GetNode(CLocalNav *const this,
+		Vector vecCurrentLoc = nodeCurrent->vecLoc;
-//				node_index_t nindex);  //   276
+		vecNodes[ nNodeCount++ ] = vecCurrentLoc;
-//		}
+
-//	}
+		nCurrentIndex = nodeCurrent->nindexParent;
+	}
+
+	return nNodeCount;
 }
 
 /* <486a56> ../cstrike/dlls/hostage/hostage_localnav.cpp:290 */
@@ -167,44 +277,31 @@ NOBODY int CLocalNav::GetFurthestTraversableNode(Vector &vecStartingLoc, Vector
 }
 
 /* <486d8d> ../cstrike/dlls/hostage/hostage_localnav.cpp:304 */
-NOBODY node_index_t CLocalNav::FindPath(Vector &vecStart, Vector &vecDest, float flTargetRadius, int fNoMonsters)
+node_index_t CLocalNav::FindPath(Vector &vecStart, Vector &vecDest, float flTargetRadius, int fNoMonsters)
-{
+{
-//	{
+	node_index_t nIndexBest = FindDirectPath(vecStart, vecDest, flTargetRadius, fNoMonsters);
-//		node_index_t nIndexBest;                              //   306
-//		{
-//			localnode_t *node;                           //   325
-//			Vector vecNodeLoc;                      //   326
-//			float flDistToDest;                           //   327
-//			GetNode(CLocalNav *const this,
-//				node_index_t nindex);  //   329
-//			operator-(const Vector *const this,
-//					const Vector &v);  //   332
-//			Length2D(const Vector *const this);  //   332
-//		}
-//	}
-
-	int nIndexBest;
-	localnode_t *node;
-	Vector vecNodeLoc;
-	float flDistToDest;
-
-	nIndexBest = FindDirectPath(vecStart, vecDest, flTargetRadius, fNoMonsters); // TODO: Reverse me!
 
 	if (nIndexBest != -1)
+	{
 		return nIndexBest;
+	}
+
+	localnode_t *node;
+	Vector vecNodeLoc;
+	float_precision flDistToDest;
 
 	m_vecStartingLoc = vecStart;
 	m_nindexAvailableNode = 0;
-	AddPathNodes(-1, fNoMonsters);
 
-	vecNodeLoc = vecStart;
+	AddPathNodes(-1, fNoMonsters);
-	nIndexBest = GetBestNode(vecNodeLoc, vecDest); // TODO: Reverse me!
+	nIndexBest = GetBestNode(vecStart, vecDest);
 
 	while (nIndexBest != -1)
 	{
 		node = GetNode(nIndexBest);
-		vecNodeLoc = node->vecLoc;
 		node->fSearched = TRUE;
+
+		vecNodeLoc = node->vecLoc;
 		flDistToDest = (vecDest - node->vecLoc).Length2D();
 
 		if (flDistToDest <= flTargetRadius)
@@ -213,14 +310,15 @@ NOBODY node_index_t CLocalNav::FindPath(Vector &vecStart, Vector &vecDest, float
 		if (flDistToDest <= HOSTAGE_STEPSIZE)
 			break;
 
-		if ((flDistToDest - flTargetRadius) > (MAX_NODES - m_nindexAvailableNode) * HOSTAGE_STEPSIZE || m_nindexAvailableNode == MAX_NODES)
+		if (((flDistToDest - flTargetRadius) > ((MAX_NODES - m_nindexAvailableNode) * HOSTAGE_STEPSIZE))
+			|| m_nindexAvailableNode == MAX_NODES)
 		{
 			nIndexBest = -1;
 			break;
 		}
 
-		AddPathNodes(nIndexBest, fNoMonsters); // TODO: Reverse me!
+		AddPathNodes(nIndexBest, fNoMonsters);
-		nIndexBest = GetBestNode(vecNodeLoc, vecDest); // TODO: Reverse me!
+		nIndexBest = GetBestNode(vecNodeLoc, vecDest);
 	}
 
 	if (m_nindexAvailableNode <= 10)
@@ -277,66 +375,37 @@ NOBODY node_index_t CLocalNav::FindPath(Vector &vecStart, Vector &vecDest, float
 }
 
 /* <4867dc> ../cstrike/dlls/hostage/hostage_localnav.cpp:413 */
-NOBODY node_index_t CLocalNav::FindDirectPath(Vector &vecStart, Vector &vecDest, float flTargetRadius, int fNoMonsters)
+node_index_t CLocalNav::FindDirectPath(Vector &vecStart, Vector &vecDest, float flTargetRadius, int fNoMonsters)
 {
-//	{
-//		Vector vecActualDest;                           //   415
-//		Vector vecPathDir;                              //   416
-//		Vector vecNodeLoc;                              //   417
-//		node_index_t nindexLast;                              //   418
-//		operator-(const Vector *const this,
-//				const Vector &v);  //   420
-//		Normalize(const Vector *const this);  //   420
-//		operator*(const Vector *const this,
-//				float fl);  //   422
-//		operator-(const Vector *const this,
-//				const Vector &v);  //   422
-//		operator-(const Vector *const this,
-//				const Vector &v);  //   432
-//		Length2D(const Vector *const this);  //   432
-//		{
-//			node_index_t nindexCurrent;                   //   434
-//			AddNode(CLocalNav *const this,
-//				node_index_t nindexParent,
-//				Vector &vecLoc,
-//				int offsetX,
-//				int offsetY,
-//				byte bDepth);  //   438
-//			operator*(const Vector *const this,
-//					float fl);  //   436
-//			operator+(const Vector *const this,
-//					const Vector &v);  //   436
-//		}
-//	}
-
 	Vector vecActualDest;
 	Vector vecPathDir;
 	Vector vecNodeLoc;
 	node_index_t nindexLast;
 
-	vecPathDir = (vecDest - vecStart).Normalize();
+	vecPathDir = NormalizeSubtract<float_precision, float, float, float_precision>(vecStart, vecDest);
-	vecActualDest = vecDest - (vecPathDir * flTargetRadius);
+	vecActualDest = vecDest - (vecPathDir * flTargetRadius);
-
+
-	if (!PathTraversable(vecStart, vecActualDest, fNoMonsters)) // TODO: Reverse me!
+	if (PathTraversable(vecStart, vecActualDest, fNoMonsters) == PATH_TRAVERSABLE_EMPTY)
-		return -1;
+	{
-
+		return -1;
-	m_nindexAvailableNode = 0;
+	}
-	nindexLast = -1;
+
-	vecNodeLoc = vecStart;
+	nindexLast = -1;
-
+	vecNodeLoc = vecStart;
+	m_nindexAvailableNode = 0;
+
 	while ((vecNodeLoc - vecActualDest).Length2D() >= HOSTAGE_STEPSIZE)
 	{
+		node_index_t nindexCurrent = nindexLast;
+
 		vecNodeLoc = vecNodeLoc + (vecPathDir * HOSTAGE_STEPSIZE);
-		nindexLast = AddNode(nindexLast, vecNodeLoc, 0, 0, 0); // TODO: Reverse me!
+		nindexLast = AddNode(nindexCurrent, vecNodeLoc);
 
 		if (nindexLast == -1)
 			break;
-	}
+	}
-
+
 	return nindexLast;
-
-
-
 }
 
 /* <485e40> ../cstrike/dlls/hostage/hostage_localnav.cpp:449 */
@@ -347,7 +416,7 @@ BOOL CLocalNav::PathClear(Vector &vecOrigin, Vector &vecDest, int fNoMonsters, T
 	if (tr.fStartSolid)
 		return FALSE;
 
-	if (tr.flFraction == 1.0)
+	if (tr.flFraction == 1.0f)
 		return TRUE;
 
 	if (tr.pHit == m_pTargetEnt)
@@ -365,13 +434,13 @@ int CLocalNav::PathTraversable(Vector &vecSource, Vector &vecDest, int fNoMonste
 	Vector vecSrcTmp;
 	Vector vecDestTmp;
 	Vector vecDir;
-	double flTotal;
+	float_precision flTotal;
 	int retval = PATH_TRAVERSABLE_EMPTY;
 
 	vecSrcTmp = vecSource;
 	vecDestTmp = vecDest - vecSource;
 
-	vecDir = vecDestTmp.Normalize();
+	vecDir = vecDestTmp.NormalizePrecision();
 	vecDir.z = 0;
 
 	flTotal = vecDestTmp.Length2D();
@@ -380,13 +449,14 @@ int CLocalNav::PathTraversable(Vector &vecSource, Vector &vecDest, int fNoMonste
 	{
 		if (flTotal >= s_flStepSize)
 		{
-#ifdef HOOK_GAMEDLL
+#ifndef HOOK_GAMEDLL
-			vecDestTmp.x = vecSrcTmp.x + (vecDir.x * s_flStepSize);
-			vecDestTmp.y = vecSrcTmp.y + (float)(vecDir.y * s_flStepSize);
-			vecDestTmp.z = vecSrcTmp.z + (vecDir.z * s_flStepSize);
-#else
 			vecDestTmp = vecSrcTmp + (vecDir * s_flStepSize);
+#else
+			vecDestTmp[0] = vecSrcTmp[0] + (vecDir[0] * s_flStepSize);
+			vecDestTmp[1] = vecSrcTmp[1] + (float)(vecDir[1] * s_flStepSize);
+			vecDestTmp[2] = vecSrcTmp[2] + (vecDir[2] * s_flStepSize);
 #endif // HOOK_GAMEDLL
+
 		}
 		else
 			vecDestTmp = vecDest;
@@ -398,17 +468,23 @@ int CLocalNav::PathTraversable(Vector &vecSource, Vector &vecDest, int fNoMonste
 			vecDestTmp = tr.vecEndPos;
 
 			if (retval == PATH_TRAVERSABLE_EMPTY)
+			{
 				retval = PATH_TRAVERSABLE_SLOPE;
+			}
 		}
 		else
 		{
 			if (tr.fStartSolid)
+			{
 				return PATH_TRAVERSABLE_EMPTY;
+			}
 
 			if (tr.pHit && !fNoMonsters && tr.pHit->v.classname)
 			{
 				if (FClassnameIs(tr.pHit, "hostage_entity"))
+				{
 					return PATH_TRAVERSABLE_EMPTY;
+				}
 			}
 
 			vecSrcTmp = tr.vecEndPos;
@@ -418,31 +494,43 @@ int CLocalNav::PathTraversable(Vector &vecSource, Vector &vecDest, int fNoMonste
 				if (StepTraversable(vecSrcTmp, vecDestTmp, fNoMonsters, tr))
 				{
 					if (retval == PATH_TRAVERSABLE_EMPTY)
+					{
 						retval = PATH_TRAVERSABLE_STEP;
+					}
 				}
 				else
 				{
 					if (!StepJumpable(vecSrcTmp, vecDestTmp, fNoMonsters, tr))
+					{
 						return PATH_TRAVERSABLE_EMPTY;
+					}
 
 					if (retval == PATH_TRAVERSABLE_EMPTY)
+					{
 						retval = PATH_TRAVERSABLE_STEPJUMPABLE;
+					}
 				}
 			}
 			else
 			{
 				if (!SlopeTraversable(vecSrcTmp, vecDestTmp, fNoMonsters, tr))
+				{
 					return PATH_TRAVERSABLE_EMPTY;
+				}
 
 				if (retval == PATH_TRAVERSABLE_EMPTY)
+				{
 					retval = PATH_TRAVERSABLE_SLOPE;
+				}
 			}
 		}
 
 		Vector vecDropDest = vecDestTmp - Vector(0, 0, 300);
 
 		if (PathClear(vecDestTmp, vecDropDest, fNoMonsters, tr))
+		{
 			return PATH_TRAVERSABLE_EMPTY;
+		}
 
 		if (!tr.fStartSolid)
 			vecDestTmp = tr.vecEndPos;
@@ -474,7 +562,7 @@ BOOL CLocalNav::SlopeTraversable(Vector &vecSource, Vector &vecDest, int fNoMons
 	vecDown = vecDest - vecSource;
 
 	vecAngles = UTIL_VecToAngles(tr.vecPlaneNormal);
-	vecSlopeEnd.z = vecDown.Length2D() * tan((double)((90.0 - vecAngles.x) * (M_PI / 180))) + vecSource.z;
+	vecSlopeEnd.z = vecDown.Length2D() * tan((float_precision)((90.0 - vecAngles.x) * (M_PI / 180))) + vecSource.z;
 
 	if (!PathClear(vecSource, vecSlopeEnd, fNoMonsters, tr))
 	{
@@ -700,36 +788,26 @@ NOBODY BOOL CLocalNav::LadderHit(Vector &vecSource, Vector &vecDest, TraceResult
 /* <487eeb> ../cstrike/dlls/hostage/hostage_localnav.cpp:851 */
 void CLocalNav::Think(void)
 {
-//	{
+	EHANDLE hCallback;
-//		float flElapsedTime;                                  //   853
-//		class EHANDLE hCallback;                              //   854
-//		cvar_t *sv_stepsize;                                 //   855
-//		{
-//			class CHostage *pHostage;                    //   909
-//			GetClassPtr<CHostage>(CHostage *a);  //   911
-//		}
-//	}
-
-	EHANDLE hostage;
 	static cvar_t *sv_stepsize = NULL;
 
-	if (flNextCvarCheck <= gpGlobals->time)
+	if (gpGlobals->time >= flNextCvarCheck)
 	{
-		if (sv_stepsize)
+		if (sv_stepsize != NULL)
-		{
-			flNextCvarCheck = gpGlobals->time + 1;
 			s_flStepSize = sv_stepsize->value;
-		}
 		else
 		{
 			sv_stepsize = CVAR_GET_POINTER("sv_stepsize");
-			flNextCvarCheck = gpGlobals->time + 1;
+			s_flStepSize = s_flStepSize ? sv_stepsize->value : HOSTAGE_STEPSIZE_DEFAULT;
-			s_flStepSize = s_flStepSize ? sv_stepsize->value : 18;
 		}
+
+		flNextCvarCheck = gpGlobals->time + 1;
 	}
 
 	HostagePrethink();
-	nodeval -= (gpGlobals->time - flLastThinkTime) * 250;
+
+	float flElapsedTime = gpGlobals->time - flLastThinkTime;
+	nodeval -= flElapsedTime * 250;
 	flLastThinkTime = gpGlobals->time;
 
 	if (nodeval < 0)
@@ -740,12 +818,9 @@ void CLocalNav::Think(void)
 
 	if (tot_inqueue)
 	{
-#ifndef REGAMEDLL_FIXES
+		hCallback = _queue[ qptr ];
-		hostage = NULL;
-#endif // REGAMEDLL_FIXES
-		hostage = _queue[ qptr ];
 
-		if (!hostage)
+		if (!hCallback)
 		{
 			while (tot_inqueue > 0)
 			{
@@ -755,20 +830,20 @@ void CLocalNav::Think(void)
 				tot_inqueue--;
 				if (!tot_inqueue)
 				{
-					hostage = NULL;
+					hCallback = NULL;
 					break;
 				}
 
-				hostage = _queue[ qptr ];
+				hCallback = _queue[ qptr ];
 
-				if (hostage)
+				if (hCallback)
 					break;
 			}
 		}
 
-		if (hostage)
+		if (hCallback)
 		{
-			CHostage *pHostage = GetClassPtr((CHostage *)hostage->pev);
+			CHostage *pHostage = GetClassPtr((CHostage *)hCallback->pev);
 
 			if (++qptr == MAX_HOSTAGES_NAV)
 				qptr = 0;
@@ -812,6 +887,8 @@ void CLocalNav::HostagePrethink(void)
 	for (int iCount = 0; iCount < tot_hostages; iCount++)
 	{
 		if (hostages[ iCount ] != NULL)
+		{
 			GetClassPtr((CHostage *)hostages[ iCount ]->pev)->PreThink();
+		}
 	}
 }

regamedll/dlls/hostage/hostage_localnav.h

@@ -32,10 +32,12 @@
 #pragma once
 #endif
 
-#define PATH_TRAVERSABLE_EMPTY 0
+#define NODE_INVALID_EMPTY		-1
-#define PATH_TRAVERSABLE_SLOPE 1
+
-#define PATH_TRAVERSABLE_STEP 2
+#define PATH_TRAVERSABLE_EMPTY		0
-#define PATH_TRAVERSABLE_STEPJUMPABLE 3
+#define PATH_TRAVERSABLE_SLOPE		1
+#define PATH_TRAVERSABLE_STEP		2
+#define PATH_TRAVERSABLE_STEPJUMPABLE	3
 
 typedef int node_index_t;
 
@@ -81,8 +83,8 @@ public:
 			m_pTargetEnt = NULL;
 	}
 
-	NOBODY node_index_t FindPath(Vector &vecStart, Vector &vecDest, float flTargetRadius, int fNoMonsters);
+	node_index_t FindPath(Vector &vecStart, Vector &vecDest, float flTargetRadius, int fNoMonsters);
-	NOBODY int SetupPathNodes(node_index_t nindex, Vector *vecNodes, int fNoMonsters);
+	int SetupPathNodes(node_index_t nindex, Vector *vecNodes, int fNoMonsters);
 	NOBODY int GetFurthestTraversableNode(Vector &vecStartingLoc, Vector *vecNodes, int nTotalNodes, int fNoMonsters);
 	int PathTraversable(Vector &vecSource, Vector &vecDest, int fNoMonsters);
 	BOOL PathClear(Vector &vecOrigin, Vector &vecDest, int fNoMonsters, TraceResult &tr);
@@ -91,23 +93,23 @@ public:
 		TraceResult tr;
 		return PathClear(vecSource, vecDest, fNoMonsters, tr);
 	}
-	NOXREF node_index_t AddNode(node_index_t nindexParent, Vector &vecLoc, int offsetX, int offsetY, byte bDepth);
+	node_index_t AddNode(node_index_t nindexParent, Vector &vecLoc, int offsetX = 0, int offsetY = 0, byte bDepth = 0);
-	NOXREF localnode_t *GetNode(node_index_t nindex);
+	localnode_t *GetNode(node_index_t nindex);
-	NOXREF node_index_t NodeExists(int offsetX, int offsetY);
+	node_index_t NodeExists(int offsetX, int offsetY);
-	NOBODY void AddPathNodes(node_index_t nindexSource, int fNoMonsters);
+	void AddPathNodes(node_index_t nindexSource, int fNoMonsters);
-	NOBODY void AddPathNode(node_index_t nindexSource, int offsetX, int offsetY, int fNoMonsters);
+	void AddPathNode(node_index_t nindexSource, int offsetX, int offsetY, int fNoMonsters);
-	NOBODY node_index_t GetBestNode(Vector &vecOrigin, Vector &vecDest);
+	node_index_t GetBestNode(Vector &vecOrigin, Vector &vecDest);
 	BOOL SlopeTraversable(Vector &vecSource, Vector &vecDest, int fNoMonsters, TraceResult &tr);
 	NOBODY BOOL LadderTraversable(Vector &vecSource, Vector &vecDest, int fNoMonsters, TraceResult &tr);
 	BOOL StepTraversable(Vector &vecSource, Vector &vecDest, int fNoMonsters, TraceResult &tr);
 	BOOL StepJumpable(Vector &vecSource, Vector &vecDest, int fNoMonsters, TraceResult &tr);
-	NOBODY node_index_t FindDirectPath(Vector &vecStart, Vector &vecDest, float flTargetRadius, int fNoMonsters);
+	node_index_t FindDirectPath(Vector &vecStart, Vector &vecDest, float flTargetRadius, int fNoMonsters);
 	NOBODY BOOL LadderHit(Vector &vecSource, Vector &vecDest, TraceResult &tr);
 
 	NOBODY static void Think(void);
 	NOBODY static void RequestNav(CHostage *pCaller);
 	static void Reset(void);
-	NOBODY static void HostagePrethink(void);
+	static void HostagePrethink(void);
 
 #ifndef HOOK_GAMEDLL
 private:

regamedll/dlls/hostage/hostage_states.h

@@ -220,8 +220,14 @@ public:
 	}
 	virtual void UpdateStationaryAnimation(CHostageImprov *improv);
 public:
-	void SetLeader(CBaseEntity *leader);
+	void SetLeader(CBaseEntity *leader)
-	CBaseEntity *GetLeader(void);
+	{
+		m_leader = leader;
+	}
+	CBaseEntity *GetLeader(void)
+	{
+		return m_leader;
+	}
 private:
 	EHANDLE m_leader;
 	Vector m_lastLeaderPos;

regamedll/dlls/hostage/states/hostage_animate.cpp

@@ -3,6 +3,8 @@
 /* <4110a1> ../cstrike/dlls/hostage/states/hostage_animate.cpp:13 */
 void HostageAnimateState::Reset(void)
 {
+	m_sequenceCount = 0;
+	m_performance = None;
 }
 
 /* <4110c7> ../cstrike/dlls/hostage/states/hostage_animate.cpp:20 */

regamedll/dlls/items.cpp

@@ -1,74 +1,74 @@
 #include "precompiled.h"
 
-/* <e2209> ../cstrike/dlls/items.cpp:46 */
+/* <e2209> ../cstrike/dlls/items.cpp:46 */
 LINK_ENTITY_TO_CLASS(world_items, CWorldItem);
-
+
-/* <e173b> ../cstrike/dlls/items.cpp:48 */
+/* <e173b> ../cstrike/dlls/items.cpp:48 */
-void CWorldItem::KeyValue_(KeyValueData *pkvd)
+void CWorldItem::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
-{
+{
-	if (FStrEq(pkvd->szKeyName, "type"))
+	if (FStrEq(pkvd->szKeyName, "type"))
-	{
+	{
-		m_iType = atoi(pkvd->szValue);
+		m_iType = Q_atoi(pkvd->szValue);
-		pkvd->fHandled = TRUE;
+		pkvd->fHandled = TRUE;
-	}
+	}
-	else
+	else
-		CBaseEntity::KeyValue(pkvd);
+		CBaseEntity::KeyValue(pkvd);
 }
 
-/* <e163a> ../cstrike/dlls/items.cpp:59 */
+/* <e163a> ../cstrike/dlls/items.cpp:59 */
-void CWorldItem::Spawn_(void)
+void CWorldItem::__MAKE_VHOOK(Spawn)(void)
-{
+{
-	CBaseEntity *pEntity = NULL;
+	CBaseEntity *pEntity = NULL;
-
+
-	switch (m_iType) 
+	switch (m_iType) 
-	{
+	{
-	case 41: // ITEM_HEALTHKIT
+	case 41: // ITEM_HEALTHKIT
-		break;
+		break;
-	case 42: // ITEM_ANTIDOTE
+	case 42: // ITEM_ANTIDOTE
-		pEntity = CBaseEntity::Create("item_antidote", pev->origin, pev->angles);
+		pEntity = CBaseEntity::Create("item_antidote", pev->origin, pev->angles);
-		break;
+		break;
-	case 43: // ITEM_SECURITY
+	case 43: // ITEM_SECURITY
-		pEntity = CBaseEntity::Create("item_security", pev->origin, pev->angles);
+		pEntity = CBaseEntity::Create("item_security", pev->origin, pev->angles);
-		break;
+		break;
-	case 44: // ITEM_BATTERY
+	case 44: // ITEM_BATTERY
-		pEntity = CBaseEntity::Create("item_battery", pev->origin, pev->angles);
+		pEntity = CBaseEntity::Create("item_battery", pev->origin, pev->angles);
-		break;
+		break;
-	case 45: // ITEM_SUIT
+	case 45: // ITEM_SUIT
-		pEntity = CBaseEntity::Create("item_suit", pev->origin, pev->angles);
+		pEntity = CBaseEntity::Create("item_suit", pev->origin, pev->angles);
-		break;
+		break;
-	}
+	}
-
+
-	if (pEntity != NULL)
+	if (pEntity != NULL)
-	{
+	{
-		pEntity->pev->target = pev->target;
+		pEntity->pev->target = pev->target;
-		pEntity->pev->targetname = pev->targetname;
+		pEntity->pev->targetname = pev->targetname;
-		pEntity->pev->spawnflags = pev->spawnflags;
+		pEntity->pev->spawnflags = pev->spawnflags;
-	}
+	}
-
+
-	REMOVE_ENTITY(edict());
+	REMOVE_ENTITY(edict());
 }
 
-/* <e15a6> ../cstrike/dlls/items.cpp:94 */
+/* <e15a6> ../cstrike/dlls/items.cpp:94 */
-void CItem::Spawn_(void)
+void CItem::__MAKE_VHOOK(Spawn)(void)
-{
+{
-	pev->movetype = MOVETYPE_TOSS;
+	pev->movetype = MOVETYPE_TOSS;
-	pev->solid = SOLID_TRIGGER;
+	pev->solid = SOLID_TRIGGER;
-
+
-	UTIL_SetOrigin( pev, pev->origin );
+	UTIL_SetOrigin( pev, pev->origin );
-	UTIL_SetSize(pev, Vector(-16, -16, 0), Vector(16, 16, 16));
+	UTIL_SetSize(pev, Vector(-16, -16, 0), Vector(16, 16, 16));
-
+
-	SetTouch(&CItem::ItemTouch);
+	SetTouch(&CItem::ItemTouch);
-
+
-	if (!DROP_TO_FLOOR(ENT(pev)))
+	if (!DROP_TO_FLOOR(ENT(pev)))
-	{
+	{
-		UTIL_Remove(this);
+		UTIL_Remove(this);
-		return;
+		return;
-	}
+	}
 }
 
-/* <e16d4> ../cstrike/dlls/items.cpp:112 */
+/* <e16d4> ../cstrike/dlls/items.cpp:112 */
-void CItem::ItemTouch(CBaseEntity *pOther)
+void CItem::ItemTouch(CBaseEntity *pOther)
-{
+{
 	if (!pOther->IsPlayer() || pOther->pev->deadflag != DEAD_NO)
 		return;
 
@@ -89,58 +89,58 @@ void CItem::ItemTouch(CBaseEntity *pOther)
 			UTIL_Remove(this);
 	}
 	else if (gEvilImpulse101)
-		UTIL_Remove(this);
+		UTIL_Remove(this);
 }
 
-/* <e1566> ../cstrike/dlls/items.cpp:154 */
+/* <e1566> ../cstrike/dlls/items.cpp:154 */
-CBaseEntity *CItem::Respawn_(void)
+CBaseEntity *CItem::__MAKE_VHOOK(Respawn)(void)
-{
+{
-	SetTouch(NULL);
+	SetTouch(NULL);
-
+
-	pev->effects |= EF_NODRAW;
+	pev->effects |= EF_NODRAW;
-
+
-	// blip to whereever you should respawn.
+	// blip to whereever you should respawn.
-	UTIL_SetOrigin(pev, g_pGameRules->VecItemRespawnSpot(this));
+	UTIL_SetOrigin(pev, g_pGameRules->VecItemRespawnSpot(this));
-
+
-	SetThink(&CItem::Materialize);
+	SetThink(&CItem::Materialize);
-	pev->nextthink = g_pGameRules->FlItemRespawnTime(this);
+	pev->nextthink = g_pGameRules->FlItemRespawnTime(this);
-
+
-	return this;
+	return this;
 }
 
-/* <e1509> ../cstrike/dlls/items.cpp:166 */
+/* <e1509> ../cstrike/dlls/items.cpp:166 */
-void CItem::Materialize(void)
+void CItem::Materialize(void)
-{
+{
-	if (pev->effects & EF_NODRAW)
+	if (pev->effects & EF_NODRAW)
-	{
+	{
-		// changing from invisible state to visible.
+		// changing from invisible state to visible.
-		EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, "items/suitchargeok1.wav", VOL_NORM, ATTN_NORM, 0, 150);
+		EMIT_SOUND_DYN(ENT(pev), CHAN_WEAPON, "items/suitchargeok1.wav", VOL_NORM, ATTN_NORM, 0, 150);
-
+
-		pev->effects &= ~EF_NODRAW;
+		pev->effects &= ~EF_NODRAW;
-		pev->effects |= EF_MUZZLEFLASH;
+		pev->effects |= EF_MUZZLEFLASH;
-	}
+	}
-
+
-	SetTouch(&CItem::ItemTouch);
+	SetTouch(&CItem::ItemTouch);
 }
 
-/* <e2158> ../cstrike/dlls/items.cpp:190 */
+/* <e2158> ../cstrike/dlls/items.cpp:190 */
-void CItemSuit::Spawn_(void)
+void CItemSuit::__MAKE_VHOOK(Spawn)(void)
-{
+{
-	Precache();
+	Precache();
-	SET_MODEL(ENT(pev), "models/w_kevlar.mdl");
+	SET_MODEL(ENT(pev), "models/w_kevlar.mdl");
-	CItem::Spawn();
+	CItem::Spawn();
 }
 
-/* <e13a2> ../cstrike/dlls/items.cpp:196 */
+/* <e13a2> ../cstrike/dlls/items.cpp:196 */
-void CItemSuit::Precache_(void)
+void CItemSuit::__MAKE_VHOOK(Precache)(void)
-{
+{
 	PRECACHE_MODEL("models/w_kevlar.mdl");
-	PRECACHE_SOUND("items/tr_kevlar.wav");
+	PRECACHE_SOUND("items/tr_kevlar.wav");
 }
 
-/* <e1b04> ../cstrike/dlls/items.cpp:201 */
+/* <e1b04> ../cstrike/dlls/items.cpp:201 */
-BOOL CItemSuit::MyTouch_(CBasePlayer *pPlayer)
+BOOL CItemSuit::__MAKE_VHOOK(MyTouch)(CBasePlayer *pPlayer)
-{
+{
 	if (pPlayer->pev->weapons & (1 << WEAPON_SUIT))
 		return FALSE;
 
@@ -149,130 +149,130 @@ BOOL CItemSuit::MyTouch_(CBasePlayer *pPlayer)
 	pPlayer->pev->weapons |= (1 << WEAPON_SUIT);
 	pPlayer->m_iHideHUD &= ~(HIDEHUD_HEALTH | HIDEHUD_MONEY);
 
-	return TRUE;
+	return TRUE;
 }
 
-/* <e22d3> ../cstrike/dlls/items.cpp:216 */
+/* <e22d3> ../cstrike/dlls/items.cpp:216 */
 LINK_ENTITY_TO_CLASS(item_suit, CItemSuit);
 
-/* <e20a7> ../cstrike/dlls/items.cpp:221 */
+/* <e20a7> ../cstrike/dlls/items.cpp:221 */
-void CItemBattery::Spawn_(void)
+void CItemBattery::__MAKE_VHOOK(Spawn)(void)
-{
+{
-	Precache();
+	Precache();
-	SET_MODEL(ENT(pev), "models/w_battery.mdl");
+	SET_MODEL(ENT(pev), "models/w_battery.mdl");
-	CItem::Spawn();
+	CItem::Spawn();
 }
 
-/* <e13c9> ../cstrike/dlls/items.cpp:227 */
+/* <e13c9> ../cstrike/dlls/items.cpp:227 */
-void CItemBattery::Precache_(void)
+void CItemBattery::__MAKE_VHOOK(Precache)(void)
-{
+{
-	PRECACHE_MODEL("models/w_battery.mdl");
+	PRECACHE_MODEL("models/w_battery.mdl");
-	PRECACHE_SOUND("items/gunpickup2.wav");
+	PRECACHE_SOUND("items/gunpickup2.wav");
 }
 
-/* <e1a20> ../cstrike/dlls/items.cpp:232 */
+/* <e1a20> ../cstrike/dlls/items.cpp:232 */
-BOOL CItemBattery::MyTouch_(CBasePlayer *pPlayer)
+BOOL CItemBattery::__MAKE_VHOOK(MyTouch)(CBasePlayer *pPlayer)
-{
+{
-	if (pPlayer->pev->armorvalue < MAX_NORMAL_BATTERY && (pPlayer->pev->weapons & (1 << WEAPON_SUIT)))
+	if (pPlayer->pev->armorvalue < MAX_NORMAL_BATTERY && (pPlayer->pev->weapons & (1 << WEAPON_SUIT)))
-	{
+	{
-		int pct;
+		int pct;
-		char szcharge[64];
+		char szcharge[64];
-
+
-		pPlayer->pev->armorvalue += gSkillData.batteryCapacity;
+		pPlayer->pev->armorvalue += gSkillData.batteryCapacity;
-		pPlayer->pev->armorvalue = min(pPlayer->pev->armorvalue, MAX_NORMAL_BATTERY);
+		pPlayer->pev->armorvalue = _min(pPlayer->pev->armorvalue, MAX_NORMAL_BATTERY);
-
+
-		EMIT_SOUND(pPlayer->edict(), CHAN_ITEM, "items/gunpickup2.wav", VOL_NORM, ATTN_NORM);
+		EMIT_SOUND(pPlayer->edict(), CHAN_ITEM, "items/gunpickup2.wav", VOL_NORM, ATTN_NORM);
-
+
-		MESSAGE_BEGIN(MSG_ONE, gmsgItemPickup, NULL, pPlayer->pev);
+		MESSAGE_BEGIN(MSG_ONE, gmsgItemPickup, NULL, pPlayer->pev);
-			WRITE_STRING(STRING(pev->classname));
+			WRITE_STRING(STRING(pev->classname));
-		MESSAGE_END();
+		MESSAGE_END();
-
+
-		// Suit reports new power level
+		// Suit reports new power level
-		// For some reason this wasn't working in release build -- round it.
+		// For some reason this wasn't working in release build -- round it.
-		pct = (int)((float)(pPlayer->pev->armorvalue * 100.0) * (1.0 / MAX_NORMAL_BATTERY) + 0.5);
+		pct = (int)((float)(pPlayer->pev->armorvalue * 100.0) * (1.0 / MAX_NORMAL_BATTERY) + 0.5);
-		pct = (pct / 5);
+		pct = (pct / 5);
-
+
-		if (pct > 0)
+		if (pct > 0)
-			pct--;
+			pct--;
-		
+		
-		Q_sprintf(szcharge,"!HEV_%1dP", pct);
+		Q_sprintf(szcharge,"!HEV_%1dP", pct);
-		pPlayer->SetSuitUpdate(szcharge, FALSE, SUIT_NEXT_IN_30SEC);
+		pPlayer->SetSuitUpdate(szcharge, FALSE, SUIT_NEXT_IN_30SEC);
-
+
-		return TRUE;		
+		return TRUE;		
-	}
+	}
-	return FALSE;
+	return FALSE;
 }
 
-/* <e239d> ../cstrike/dlls/items.cpp:266 */
+/* <e239d> ../cstrike/dlls/items.cpp:266 */
-LINK_ENTITY_TO_CLASS(item_battery, CItemBattery);
+LINK_ENTITY_TO_CLASS(item_battery, CItemBattery);
 
-/* <e1ff5> ../cstrike/dlls/items.cpp:271 */
+/* <e1ff5> ../cstrike/dlls/items.cpp:271 */
-void CItemAntidote::Spawn_(void)
+void CItemAntidote::__MAKE_VHOOK(Spawn)(void)
-{
+{
 	Precache();
 	SET_MODEL(ENT(pev), "models/w_antidote.mdl");
-	CItem::Spawn();
+	CItem::Spawn();
 }
 
-/* <e13f0> ../cstrike/dlls/items.cpp:277 */
+/* <e13f0> ../cstrike/dlls/items.cpp:277 */
-void CItemAntidote::Precache_(void)
+void CItemAntidote::__MAKE_VHOOK(Precache)(void)
-{
+{
-	PRECACHE_MODEL("models/w_antidote.mdl");
+	PRECACHE_MODEL("models/w_antidote.mdl");
 }
 
-/* <e1530> ../cstrike/dlls/items.cpp:281 */
+/* <e1530> ../cstrike/dlls/items.cpp:281 */
-BOOL CItemAntidote::MyTouch_(CBasePlayer *pPlayer)
+BOOL CItemAntidote::__MAKE_VHOOK(MyTouch)(CBasePlayer *pPlayer)
-{
+{
 	pPlayer->SetSuitUpdate("!HEV_DET4", FALSE, SUIT_NEXT_IN_1MIN);
 	pPlayer->m_rgItems[ ITEM_ANTIDOTE ] += 1;
 
-	return TRUE;
+	return TRUE;
 }
 
-/* <e246a> ../cstrike/dlls/items.cpp:290 */
+/* <e246a> ../cstrike/dlls/items.cpp:290 */
-LINK_ENTITY_TO_CLASS(item_antidote, CItemAntidote);
+LINK_ENTITY_TO_CLASS(item_antidote, CItemAntidote);
 
-/* <e1f43> ../cstrike/dlls/items.cpp:295 */
+/* <e1f43> ../cstrike/dlls/items.cpp:295 */
-void CItemSecurity::Spawn_(void)
+void CItemSecurity::__MAKE_VHOOK(Spawn)(void)
-{
+{
 	Precache();
 	SET_MODEL(ENT(pev), "models/w_security.mdl");
-	CItem::Spawn();
+	CItem::Spawn();
-}
-
-/* <e1416> ../cstrike/dlls/items.cpp:301 */
-void CItemSecurity::Precache_(void)
-{
-	PRECACHE_MODEL("models/w_security.mdl");
 }
 
-/* <e143c> ../cstrike/dlls/items.cpp:305 */
+/* <e1416> ../cstrike/dlls/items.cpp:301 */
-BOOL CItemSecurity::MyTouch_(CBasePlayer *pPlayer)
+void CItemSecurity::__MAKE_VHOOK(Precache)(void)
-{
+{
+	PRECACHE_MODEL("models/w_security.mdl");
+}
+
+/* <e143c> ../cstrike/dlls/items.cpp:305 */
+BOOL CItemSecurity::__MAKE_VHOOK(MyTouch)(CBasePlayer *pPlayer)
+{
 	pPlayer->m_rgItems[ ITEM_SECURITY ] += 1;
-	return TRUE;
+	return TRUE;
 }
 
-/* <e2537> ../cstrike/dlls/items.cpp:312 */
+/* <e2537> ../cstrike/dlls/items.cpp:312 */
-LINK_ENTITY_TO_CLASS(item_security, CItemSecurity);
+LINK_ENTITY_TO_CLASS(item_security, CItemSecurity);
 
-/* <e1e91> ../cstrike/dlls/items.cpp:316 */
+/* <e1e91> ../cstrike/dlls/items.cpp:316 */
-void CItemLongJump::Spawn_(void)
+void CItemLongJump::__MAKE_VHOOK(Spawn)(void)
-{
+{
 	Precache();
 	SET_MODEL(ENT(pev), "models/w_longjump.mdl");
-	CItem::Spawn();
+	CItem::Spawn();
 }
 
-/* <e1471> ../cstrike/dlls/items.cpp:322 */
+/* <e1471> ../cstrike/dlls/items.cpp:322 */
-void CItemLongJump::Precache_(void)
+void CItemLongJump::__MAKE_VHOOK(Precache)(void)
-{
+{
-	PRECACHE_MODEL("models/w_longjump.mdl");
+	PRECACHE_MODEL("models/w_longjump.mdl");
 }
 
-/* <e17e9> ../cstrike/dlls/items.cpp:326 */
+/* <e17e9> ../cstrike/dlls/items.cpp:326 */
-BOOL CItemLongJump::MyTouch_(CBasePlayer *pPlayer)
+BOOL CItemLongJump::__MAKE_VHOOK(MyTouch)(CBasePlayer *pPlayer)
-{
+{
 	if (pPlayer->m_fLongJump)
 		return FALSE;
 
@@ -291,29 +291,29 @@ BOOL CItemLongJump::MyTouch_(CBasePlayer *pPlayer)
 		return TRUE;
 	}
 
-	return FALSE;
+	return FALSE;
 }
 
-/* <e2604> ../cstrike/dlls/items.cpp:350 */
+/* <e2604> ../cstrike/dlls/items.cpp:350 */
-LINK_ENTITY_TO_CLASS(item_longjump, CItemLongJump);
+LINK_ENTITY_TO_CLASS(item_longjump, CItemLongJump);
 
-/* <e1ddf> ../cstrike/dlls/items.cpp:354 */
+/* <e1ddf> ../cstrike/dlls/items.cpp:354 */
-void CItemKevlar::Spawn_(void)
+void CItemKevlar::__MAKE_VHOOK(Spawn)(void)
-{
+{
 	Precache();
 	SET_MODEL(ENT(pev), "models/w_kevlar.mdl");
-	CItem::Spawn();
+	CItem::Spawn();
 }
 
-/* <e1497> ../cstrike/dlls/items.cpp:360 */
+/* <e1497> ../cstrike/dlls/items.cpp:360 */
-void CItemKevlar::Precache_(void)
+void CItemKevlar::__MAKE_VHOOK(Precache)(void)
-{
+{
-	PRECACHE_MODEL("models/w_kevlar.mdl");
+	PRECACHE_MODEL("models/w_kevlar.mdl");
 }
 
-/* <e1b9d> ../cstrike/dlls/items.cpp:364 */
+/* <e1b9d> ../cstrike/dlls/items.cpp:364 */
-BOOL CItemKevlar::MyTouch_(CBasePlayer *pPlayer)
+BOOL CItemKevlar::__MAKE_VHOOK(MyTouch)(CBasePlayer *pPlayer)
-{
+{
 	if (pPlayer->m_iKevlar == ARMOR_TYPE_EMPTY)
 		pPlayer->m_iKevlar = ARMOR_TYPE_KEVLAR;
 
@@ -331,29 +331,29 @@ BOOL CItemKevlar::MyTouch_(CBasePlayer *pPlayer)
 	if (TheTutor)
 		TheTutor->OnEvent(EVENT_PLAYER_BOUGHT_SOMETHING, pPlayer);
 
-	return TRUE;
+	return TRUE;
 }
 
-/* <e26d1> ../cstrike/dlls/items.cpp:390 */
+/* <e26d1> ../cstrike/dlls/items.cpp:390 */
-LINK_ENTITY_TO_CLASS(item_kevlar, CItemKevlar);
+LINK_ENTITY_TO_CLASS(item_kevlar, CItemKevlar);
-
+
-/* <e1d2d> ../cstrike/dlls/items.cpp:395 */
+/* <e1d2d> ../cstrike/dlls/items.cpp:395 */
-void CItemAssaultSuit::Spawn_(void)
+void CItemAssaultSuit::__MAKE_VHOOK(Spawn)(void)
-{
+{
 	Precache();
 	SET_MODEL(ENT(pev), "models/w_assault.mdl");
-	CItem::Spawn();
+	CItem::Spawn();
 }
 
-/* <e14bd> ../cstrike/dlls/items.cpp:401 */
+/* <e14bd> ../cstrike/dlls/items.cpp:401 */
-void CItemAssaultSuit::Precache_(void)
+void CItemAssaultSuit::__MAKE_VHOOK(Precache)(void)
-{
+{
-	PRECACHE_MODEL("models/w_assault.mdl");
+	PRECACHE_MODEL("models/w_assault.mdl");
 }
 
-/* <e1942> ../cstrike/dlls/items.cpp:405 */
+/* <e1942> ../cstrike/dlls/items.cpp:405 */
-BOOL CItemAssaultSuit::MyTouch_(CBasePlayer *pPlayer)
+BOOL CItemAssaultSuit::__MAKE_VHOOK(MyTouch)(CBasePlayer *pPlayer)
-{
+{
 	pPlayer->m_iKevlar = ARMOR_TYPE_HELMET;
 	pPlayer->pev->armorvalue = 100;
 
@@ -370,29 +370,29 @@ BOOL CItemAssaultSuit::MyTouch_(CBasePlayer *pPlayer)
 	if (TheTutor)
 		TheTutor->OnEvent(EVENT_PLAYER_BOUGHT_SOMETHING, pPlayer);
 
-	return TRUE;
+	return TRUE;
 }
 
-/* <e279e> ../cstrike/dlls/items.cpp:429 */
+/* <e279e> ../cstrike/dlls/items.cpp:429 */
-LINK_ENTITY_TO_CLASS(item_assaultsuit, CItemAssaultSuit);
+LINK_ENTITY_TO_CLASS(item_assaultsuit, CItemAssaultSuit);
 
-/* <e1c7b> ../cstrike/dlls/items.cpp:434 */
+/* <e1c7b> ../cstrike/dlls/items.cpp:434 */
-void CItemThighPack::Spawn_(void)
+void CItemThighPack::__MAKE_VHOOK(Spawn)(void)
-{
+{
 	Precache();
 	SET_MODEL(ENT(pev), "models/w_thighpack.mdl");
-	CItem::Spawn();
+	CItem::Spawn();
 }
 
-/* <e14e3> ../cstrike/dlls/items.cpp:440 */
+/* <e14e3> ../cstrike/dlls/items.cpp:440 */
-void CItemThighPack::Precache_(void)
+void CItemThighPack::__MAKE_VHOOK(Precache)(void)
-{
+{
-	PRECACHE_MODEL("models/w_thighpack.mdl");
+	PRECACHE_MODEL("models/w_thighpack.mdl");
 }
 
-/* <e1873> ../cstrike/dlls/items.cpp:444 */
+/* <e1873> ../cstrike/dlls/items.cpp:444 */
-BOOL CItemThighPack::MyTouch_(CBasePlayer *pPlayer)
+BOOL CItemThighPack::__MAKE_VHOOK(MyTouch)(CBasePlayer *pPlayer)
-{
+{
 	if (pPlayer->m_iTeam != CT || pPlayer->m_bHasDefuser)
 		return FALSE;
 
@@ -415,11 +415,11 @@ BOOL CItemThighPack::MyTouch_(CBasePlayer *pPlayer)
 	if (TheTutor)
 		TheTutor->OnEvent(EVENT_PLAYER_BOUGHT_SOMETHING, pPlayer);
 
-	return TRUE;
+	return TRUE;
 }
 
-/* <e286b> ../cstrike/dlls/items.cpp:474 */
+/* <e286b> ../cstrike/dlls/items.cpp:474 */
-LINK_ENTITY_TO_CLASS(item_thighpack, CItemThighPack);
+LINK_ENTITY_TO_CLASS(item_thighpack, CItemThighPack);
 
 #ifdef HOOK_GAMEDLL
 

regamedll/dlls/lights.cpp

@@ -26,16 +26,16 @@ IMPLEMENT_SAVERESTORE(CLight, CPointEntity);
 // Cache user-entity-field values until spawn is called.
 
 /* <e7bef> ../cstrike/dlls/lights.cpp:62 */
-void CLight::KeyValue_(KeyValueData *pkvd)
+void CLight::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 	if (FStrEq(pkvd->szKeyName, "style"))
 	{
-		m_iStyle = atoi(pkvd->szValue);
+		m_iStyle = Q_atoi(pkvd->szValue);
 		pkvd->fHandled = TRUE;
 	}
 	else if (FStrEq(pkvd->szKeyName, "pitch"))
 	{
-		pev->angles.x = atof(pkvd->szValue);
+		pev->angles.x = Q_atof(pkvd->szValue);
 		pkvd->fHandled = TRUE;
 	}
 	else if (FStrEq(pkvd->szKeyName, "pattern"))
@@ -48,7 +48,7 @@ void CLight::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <e7b78> ../cstrike/dlls/lights.cpp:92 */
-void CLight::Spawn_(void)
+void CLight::__MAKE_VHOOK(Spawn)(void)
 {
 	// inert light
 	if (FStringNull(pev->targetname))
@@ -72,7 +72,7 @@ void CLight::Spawn_(void)
 }
 
 /* <e7a30> ../cstrike/dlls/lights.cpp:117 */
-void CLight::Restart_(void)
+void CLight::__MAKE_VHOOK(Restart)(void)
 {
 	if (m_iStyle >= 32)
 	{
@@ -94,7 +94,7 @@ void CLight::Restart_(void)
 }
 
 /* <e7a6b> ../cstrike/dlls/lights.cpp:139 */
-void CLight::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CLight::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 	if (m_iStyle >= 32)
 	{
@@ -125,7 +125,7 @@ LINK_ENTITY_TO_CLASS(light_spot, CLight);
 LINK_ENTITY_TO_CLASS(light_environment, CEnvLight);
 
 /* <e7d08> ../cstrike/dlls/lights.cpp:177 */
-void CEnvLight::KeyValue_(KeyValueData *pkvd)
+void CEnvLight::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 	if (FStrEq(pkvd->szKeyName, "_light"))
 	{
@@ -162,7 +162,7 @@ void CEnvLight::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <e7bb3> ../cstrike/dlls/lights.cpp:215 */
-void CEnvLight::Spawn_(void)
+void CEnvLight::__MAKE_VHOOK(Spawn)(void)
 {
 #if defined(HOOK_GAMEDLL)
 // NOTE: fix negative the values for function sprintf from STD C++:

regamedll/dlls/maprules.cpp

@@ -35,12 +35,12 @@ TYPEDESCRIPTION (*CGamePlayerZone::pm_SaveData)[4];
 IMPLEMENT_SAVERESTORE(CRuleEntity, CBaseEntity);
 
 /* <eed18> ../cstrike/dlls/maprules.cpp:60 */
-NOBODY void CRuleEntity::Spawn_(void)
+NOBODY void CRuleEntity::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <eeff6> ../cstrike/dlls/maprules.cpp:68 */
-NOBODY void CRuleEntity::KeyValue_(KeyValueData *pkvd)
+NOBODY void CRuleEntity::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //    70
@@ -58,13 +58,13 @@ NOBODY BOOL CRuleEntity::CanFireForActivator(CBaseEntity *pActivator)
 }
 
 /* <eed39> ../cstrike/dlls/maprules.cpp:101 */
-NOBODY void CRulePointEntity::Spawn_(void)
+NOBODY void CRulePointEntity::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(CRuleEntity *const this);  //   103
 }
 
 /* <eed72> ../cstrike/dlls/maprules.cpp:120 */
-NOBODY void CRuleBrushEntity::Spawn_(void)
+NOBODY void CRuleBrushEntity::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(CRuleEntity *const this);  //   123
 }
@@ -73,13 +73,13 @@ NOBODY void CRuleBrushEntity::Spawn_(void)
 LINK_ENTITY_TO_CLASS(game_score, CGameScore);
 
 /* <eedb1> ../cstrike/dlls/maprules.cpp:154 */
-NOBODY void CGameScore::Spawn_(void)
+NOBODY void CGameScore::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(CRulePointEntity *const this);  //   156
 }
 
 /* <efc68> ../cstrike/dlls/maprules.cpp:160 */
-NOBODY void CGameScore::KeyValue_(KeyValueData *pkvd)
+NOBODY void CGameScore::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   162
@@ -90,7 +90,7 @@ NOBODY void CGameScore::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <ef54c> ../cstrike/dlls/maprules.cpp:173 */
-NOBODY void CGameScore::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CGameScore::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	CanFireForActivator(CRuleEntity *const this,
 //				class CBaseEntity *pActivator);  //   175
@@ -111,7 +111,7 @@ LINK_ENTITY_TO_CLASS(game_end, CGameEnd);
 LINK_ENTITY_TO_CLASS(game_text, CGameText);
 
 /* <ef497> ../cstrike/dlls/maprules.cpp:205 */
-NOBODY void CGameEnd::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CGameEnd::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	CanFireForActivator(CRuleEntity *const this,
 //				class CBaseEntity *pActivator);  //   207
@@ -126,7 +126,7 @@ NOBODY void CGameEnd::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TY
 IMPLEMENT_SAVERESTORE(CGameText, CRulePointEntity);
 
 /* <f00dd> ../cstrike/dlls/maprules.cpp:254 */
-NOBODY void CGameText::KeyValue_(KeyValueData *pkvd)
+NOBODY void CGameText::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	{
 //		int color;                                            //   278
@@ -145,7 +145,7 @@ NOBODY void CGameText::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <ef655> ../cstrike/dlls/maprules.cpp:321 */
-NOBODY void CGameText::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CGameText::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	CanFireForActivator(CRuleEntity *const this,
 //				class CBaseEntity *pActivator);  //   323
@@ -161,7 +161,7 @@ NOBODY void CGameText::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_T
 LINK_ENTITY_TO_CLASS(game_team_master, CGameTeamMaster);
 
 /* <eff4f> ../cstrike/dlls/maprules.cpp:373 */
-NOBODY void CGameTeamMaster::KeyValue_(KeyValueData *pkvd)
+NOBODY void CGameTeamMaster::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   375
@@ -178,7 +178,7 @@ NOBODY void CGameTeamMaster::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <f0474> ../cstrike/dlls/maprules.cpp:402 */
-void CGameTeamMaster::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CGameTeamMaster::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	CanFireForActivator(CRuleEntity *const this,
 //				class CBaseEntity *pActivator);  //   404
@@ -192,14 +192,14 @@ void CGameTeamMaster::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TY
 }
 
 /* <ef2e0> ../cstrike/dlls/maprules.cpp:429 */
-BOOL CGameTeamMaster::IsTriggered_(CBaseEntity *pActivator)
+BOOL CGameTeamMaster::__MAKE_VHOOK(IsTriggered)(CBaseEntity *pActivator)
 {
 //	TeamMatch(CGameTeamMaster *const this,
 //			class CBaseEntity *pActivator);  //   431
 }
 
 /* <eeeaf> ../cstrike/dlls/maprules.cpp:435 */
-const char *CGameTeamMaster::TeamID_(void)
+const char *CGameTeamMaster::__MAKE_VHOOK(TeamID)(void)
 {
 //	TeamID(CGameTeamMaster *const this);  //   435
 }
@@ -216,7 +216,7 @@ BOOL CGameTeamMaster::TeamMatch(CBaseEntity *pActivator)
 LINK_ENTITY_TO_CLASS(game_team_set, CGameTeamSet);
 
 /* <ef735> ../cstrike/dlls/maprules.cpp:477 */
-void CGameTeamSet::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CGameTeamSet::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	CanFireForActivator(CRuleEntity *const this,
 //				class CBaseEntity *pActivator);  //   479
@@ -227,19 +227,14 @@ void CGameTeamSet::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
 //		float value);  //   477
 }
 
-
-
-
 /* <f0dfd> ../cstrike/dlls/maprules.cpp:519 */
 LINK_ENTITY_TO_CLASS(game_zone_player, CGamePlayerZone);
 
 /* <ef0a2> ../cstrike/dlls/maprules.cpp:528 */
-IMPLEMENT_SAVERESTORE(CGamePlayerZone, CRuleBrushEntity);
+IMPLEMENT_SAVERESTORE(CGamePlayerZone, CRuleBrushEntity);
-
-
 
 /* <efdbc> ../cstrike/dlls/maprules.cpp:530 */
-void CGamePlayerZone::KeyValue_(KeyValueData *pkvd)
+void CGamePlayerZone::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   532
@@ -250,7 +245,7 @@ void CGamePlayerZone::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <ef36e> ../cstrike/dlls/maprules.cpp:556 */
-void CGamePlayerZone::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CGamePlayerZone::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		int playersInCount;                                   //   558
@@ -277,7 +272,7 @@ void CGamePlayerZone::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TY
 LINK_ENTITY_TO_CLASS(game_player_hurt, CGamePlayerHurt);
 
 /* <ef815> ../cstrike/dlls/maprules.cpp:631 */
-void CGamePlayerHurt::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CGamePlayerHurt::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	CanFireForActivator(CRuleEntity *const this,
 //				class CBaseEntity *pActivator);  //   633
@@ -292,7 +287,7 @@ void CGamePlayerHurt::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TY
 LINK_ENTITY_TO_CLASS(game_counter, CGameCounter);
 
 /* <eee2d> ../cstrike/dlls/maprules.cpp:686 */
-void CGameCounter::Spawn_(void)
+void CGameCounter::__MAKE_VHOOK(Spawn)(void)
 {
 //	CountValue(CGameCounter *const this);  //   689
 //	SetInitialValue(CGameCounter *const this,
@@ -301,7 +296,7 @@ void CGameCounter::Spawn_(void)
 }
 
 /* <ef8ef> ../cstrike/dlls/maprules.cpp:694 */
-void CGameCounter::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CGameCounter::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	CanFireForActivator(CRuleEntity *const this,
 //				class CBaseEntity *pActivator);  //   696
@@ -316,7 +311,7 @@ void CGameCounter::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE
 LINK_ENTITY_TO_CLASS(game_counter_set, CGameCounterSet);
 
 /* <efa65> ../cstrike/dlls/maprules.cpp:750 */
-void CGameCounterSet::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CGameCounterSet::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	CanFireForActivator(CRuleEntity *const this,
 //				class CBaseEntity *pActivator);  //   752
@@ -331,7 +326,7 @@ void CGameCounterSet::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TY
 LINK_ENTITY_TO_CLASS(game_player_equip, CGamePlayerEquip);
 
 /* <ed81f> ../cstrike/dlls/maprules.cpp:791 */
-void CGamePlayerEquip::KeyValue_(KeyValueData *pkvd)
+void CGamePlayerEquip::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	{
 //		int i;                                                //   797
@@ -346,7 +341,7 @@ void CGamePlayerEquip::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <f06ad> ../cstrike/dlls/maprules.cpp:816 */
-void CGamePlayerEquip::Touch_(CBaseEntity *pOther)
+void CGamePlayerEquip::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
 //	CanFireForActivator(CRuleEntity *const this,
 //				class CBaseEntity *pActivator);  //   818
@@ -369,7 +364,7 @@ void CGamePlayerEquip::EquipPlayer(CBaseEntity *pEntity)
 }
 
 /* <f05f3> ../cstrike/dlls/maprules.cpp:851 */
-void CGamePlayerEquip::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CGamePlayerEquip::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	EquipPlayer(CGamePlayerEquip *const this,
 //			class CBaseEntity *pEntity);  //   853
@@ -389,7 +384,7 @@ const char *CGamePlayerTeam::TargetTeamName(const char *pszTargetName)
 }
 
 /* <f07df> ../cstrike/dlls/maprules.cpp:898 */
-void CGamePlayerTeam::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CGamePlayerTeam::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		const char *pszTargetTeam;                          //   905

regamedll/dlls/mortar.cpp

@@ -28,84 +28,194 @@ LINK_ENTITY_TO_CLASS(func_mortar_field, CFuncMortarField);
 IMPLEMENT_SAVERESTORE(CFuncMortarField, CBaseToggle);
 
 /* <f6d87> ../cstrike/dlls/mortar.cpp:71 */
-NOBODY void CFuncMortarField::KeyValue_(KeyValueData *pkvd)
+void CFuncMortarField::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
-//	FStrEq(const char *sz1,
+	if (FStrEq(pkvd->szKeyName, "m_iszXController"))
-//		const char *sz2);  //    73
+	{
-//	FStrEq(const char *sz1,
+		m_iszXController = ALLOC_STRING(pkvd->szValue);
-//		const char *sz2);  //    78
+		pkvd->fHandled = TRUE;
-//	KeyValue(CFuncMortarField *const this,
+	}
-//		KeyValueData *pkvd);  //    71
+	else if (FStrEq(pkvd->szKeyName, "m_iszYController"))
+	{
+		m_iszYController = ALLOC_STRING(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "m_flSpread"))
+	{
+		m_flSpread = Q_atof(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "m_fControl"))
+	{
+		m_fControl = Q_atoi(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "m_iCount"))
+	{
+		m_iCount = Q_atoi(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
 }
 
+// Drop bombs from above
+
 /* <f694a> ../cstrike/dlls/mortar.cpp:102 */
-NOBODY void CFuncMortarField::Spawn_(void)
+void CFuncMortarField::__MAKE_VHOOK(Spawn)(void)
 {
+	pev->solid = SOLID_NOT;
+
+	// set size and link into world
+	SET_MODEL(ENT(pev), STRING(pev->model));
+	pev->movetype = MOVETYPE_NONE;
+	pev->effects |= EF_NODRAW;
+
+	SetUse(&CFuncMortarField::FieldUse);
+	Precache();
 }
 
 /* <f6971> ../cstrike/dlls/mortar.cpp:113 */
-NOBODY void CFuncMortarField::Precache_(void)
+void CFuncMortarField::__MAKE_VHOOK(Precache)(void)
 {
+	PRECACHE_SOUND("weapons/mortar.wav");
+	PRECACHE_SOUND("weapons/mortarhit.wav");
+	PRECACHE_MODEL("sprites/lgtning.spr");
 }
 
+// If connected to a table, then use the table controllers, else hit where the trigger is.
+
 /* <f6ae4> ../cstrike/dlls/mortar.cpp:122 */
-NOBODY void CFuncMortarField::FieldUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+void CFuncMortarField::FieldUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
-{
+{
-//	{
+	Vector vecStart;
-//		Vector vecStart;                                //   124
+
-//		int pitch;                                            //   165
+	vecStart.x = RANDOM_FLOAT(pev->mins.x, pev->maxs.x);
-//		float t;                                              //   169
+	vecStart.y = RANDOM_FLOAT(pev->mins.y, pev->maxs.y);
-//		{
+	vecStart.z = pev->maxs.z;
-//			class CBaseEntity *pController;              //   143
+
-//		}
+	switch (m_fControl)
-//		{
+	{
-//			int i;                                        //   170
+		// random
-//			{
+		case 0:
-//				Vector vecSpot;                 //   172
+			break;
-//				TraceResult tr;                       //   176
+		// Trigger Activator
-//				edict_t *pentOwner;                  //   179
+		case 1:
-//				class CBaseEntity *pMortar;          //   182
+		{
-//				Vector(Vector *const this,
+			if (pActivator != NULL)
-//					const Vector &v);  //   172
+			{
-//				operator+(const Vector *const this,
+				vecStart.x = pActivator->pev->origin.x;
-//						const Vector &v);  //   177
+				vecStart.y = pActivator->pev->origin.y;
-//				edict(CBaseEntity *const this);  //   180
+			}
-//				Vector(Vector *const this,
+			break;
-//					float X,
+		}
-//					float Y,
+		// table
-//					float Z);  //   182
+		case 2:
-//			}
+		{
-//		}
+			CBaseEntity *pController;
-//	}
+
+			if (!FStringNull(m_iszXController))
+			{
+				pController = UTIL_FindEntityByTargetname(NULL, STRING(m_iszXController));
+
+				if (pController != NULL)
+				{
+					vecStart.x = pev->mins.x + pController->pev->ideal_yaw * pev->size.x;
+				}
+			}
+			if (!FStringNull(m_iszYController))
+			{
+				pController = UTIL_FindEntityByTargetname(NULL, STRING(m_iszYController));
+
+				if (pController != NULL)
+				{
+					vecStart.y = pev->mins.y + pController->pev->ideal_yaw * pev->size.y;
+				}
+			}
+			break;
+		}
+	}
+
+	int pitch = RANDOM_LONG(95, 124);
+
+	EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "weapons/mortar.wav", VOL_NORM, ATTN_NONE, 0, pitch);
+
+	float t = 2.5;
+	for (int i = 0; i < m_iCount; i++)
+	{
+		Vector vecSpot = vecStart;
+		vecSpot.x += RANDOM_FLOAT(-m_flSpread, m_flSpread);
+		vecSpot.y += RANDOM_FLOAT(-m_flSpread, m_flSpread);
+
+		TraceResult tr;
+		UTIL_TraceLine(vecSpot, vecSpot + Vector(0, 0, -1) * 4096, ignore_monsters, ENT(pev), &tr);
+
+		edict_t *pentOwner = NULL;
+		if (pActivator)
+		{
+			pentOwner = pActivator->edict();
+		}
+
+		CBaseEntity *pMortar = Create("monster_mortar", tr.vecEndPos, Vector(0, 0, 0), pentOwner);
+		pMortar->pev->nextthink = gpGlobals->time + t;
+		t += RANDOM_FLOAT(0.2, 0.5);
+
+		if (i == 0)
+		{
+			CSoundEnt::InsertSound(bits_SOUND_DANGER, tr.vecEndPos, 400, 0.3);
+		}
+	}
 }
 
 /* <f6fb1> ../cstrike/dlls/mortar.cpp:203 */
 LINK_ENTITY_TO_CLASS(monster_mortar, CMortar);
 
 /* <f6998> ../cstrike/dlls/mortar.cpp:205 */
-NOBODY void CMortar::Spawn_(void)
+void CMortar::__MAKE_VHOOK(Spawn)(void)
 {
+	pev->movetype = MOVETYPE_NONE;
+	pev->solid = SOLID_NOT;
+	pev->dmg = 200;
+
+	SetThink(&CMortar::MortarExplode);
+	pev->nextthink = 0;
+	Precache();
 }
 
 /* <f69be> ../cstrike/dlls/mortar.cpp:221 */
-NOBODY void CMortar::Precache_(void)
+void CMortar::__MAKE_VHOOK(Precache)(void)
 {
+	m_spriteTexture = PRECACHE_MODEL("sprites/lgtning.spr");
 }
 
 /* <f69e5> ../cstrike/dlls/mortar.cpp:226 */
-NOBODY void CMortar::MortarExplode(void)
+void CMortar::MortarExplode(void)
 {
-//	{
+	// mortar beam
-//		TraceResult tr;                                       //   250
+	MESSAGE_BEGIN(MSG_BROADCAST, SVC_TEMPENTITY);
-//		MESSAGE_BEGIN(int msg_dest,
+		WRITE_BYTE(TE_BEAMPOINTS);
-//				int msg_type,
+		WRITE_COORD(pev->origin.x);
-//				const float *pOrigin,
+		WRITE_COORD(pev->origin.y);
-//				edict_t *ed);  //   229
+		WRITE_COORD(pev->origin.z);
-//		operator-(const Vector *const this,
+		WRITE_COORD(pev->origin.x);
-//				const Vector &v);  //   251
+		WRITE_COORD(pev->origin.y);
-//		operator+(const Vector *const this,
+		WRITE_COORD(pev->origin.z + 1024);
-//				const Vector &v);  //   251
+		WRITE_SHORT(m_spriteTexture);
-//	}
+		WRITE_BYTE(0); // framerate
+		WRITE_BYTE(0); // framerate
+		WRITE_BYTE(1); // life
+		WRITE_BYTE(40); // width
+		WRITE_BYTE(0); // noise
+		WRITE_BYTE(255); // r, g, b
+		WRITE_BYTE(160); // r, g, b
+		WRITE_BYTE(100); // r, g, b
+		WRITE_BYTE(128); // brightness
+		WRITE_BYTE(0); // speed
+	MESSAGE_END();
+
+	TraceResult tr;
+	UTIL_TraceLine(pev->origin + Vector(0, 0, 1024), pev->origin - Vector(0, 0, 1024), dont_ignore_monsters, ENT(pev), &tr);
+
+	Explode(&tr, (DMG_BLAST | DMG_MORTAR));
+	UTIL_ScreenShake(tr.vecEndPos, 25.0, 150.0, 1.0, 750);
 }
 
 #ifdef HOOK_GAMEDLL

regamedll/dlls/mortar.h

@@ -36,12 +36,14 @@
 class CFuncMortarField: public CBaseToggle
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual int Save(CSave &save);
+	virtual int Save(CSave &save);
-	NOBODY virtual int Restore(CRestore &restore);
+	virtual int Restore(CRestore &restore);
-	NOBODY virtual int ObjectCaps(void)
+
+	// Bmodels don't go across transitions
+	virtual int ObjectCaps(void)
 	{
 		return ObjectCaps_();
 	}
@@ -61,7 +63,7 @@ public:
 #endif // HOOK_GAMEDLL
 
 public:
-	NOBODY void EXPORT FieldUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
+	void EXPORT FieldUse(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value);
 
 public:
 	static TYPEDESCRIPTION IMPLEMENT_ARRAY(m_SaveData)[6];
@@ -80,8 +82,8 @@ public:
 class CMortar: public CGrenade
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void Precache(void);
+	virtual void Precache(void);
 
 #ifdef HOOK_GAMEDLL
 
@@ -90,11 +92,16 @@ public:
 
 #endif // HOOK_GAMEDLL
 
-	NOBODY void EXPORT MortarExplode(void);
+	void EXPORT MortarExplode(void);
 
 public:
 	int m_spriteTexture;
 
 };/* size: 504, cachelines: 8, members: 2 */
 
+
+// linked objects
+C_DLLEXPORT void func_mortar_field(entvars_t *pev);
+C_DLLEXPORT void monster_mortar(entvars_t *pev);
+
 #endif // MORTAR_H

regamedll/dlls/mpstubb.cpp

@@ -5,31 +5,37 @@ CGraph WorldGraph;
 /* <fc409> ../cstrike/dlls/mpstubb.cpp:32 */
 void CGraph::InitGraph(void)
 {
+	;
 }
 
 /* <fc436> ../cstrike/dlls/mpstubb.cpp:33 */
 int CGraph::FLoadGraph(char *szMapName)
 {
+	return 0;
 }
 
 /* <fc46c> ../cstrike/dlls/mpstubb.cpp:34 */
 int CGraph::AllocNodes(void)
 {
+	return 0;
 }
 
 /* <fc494> ../cstrike/dlls/mpstubb.cpp:35 */
 int CGraph::CheckNODFile(char *szMapName)
 {
+	return 0;
 }
 
 /* <fc4ca> ../cstrike/dlls/mpstubb.cpp:36 */
 int CGraph::FSetGraphPointers(void)
 {
+	return 0;
 }
 
 /* <fc4f2> ../cstrike/dlls/mpstubb.cpp:37 */
 void CGraph::ShowNodeConnections(int iNode)
 {
+	;
 }
 
 /* <fc528> ../cstrike/dlls/mpstubb.cpp:38 */
@@ -45,7 +51,7 @@ int CGraph::FindNearestNode(const Vector &vecOrigin, CBaseEntity *pEntity)
 }
 
 /* <fc023> ../cstrike/dlls/mpstubb.cpp:45 */
-float CBaseMonster::ChangeYaw_(int speed)
+float CBaseMonster::__MAKE_VHOOK(ChangeYaw)(int speed)
 {
 	return 0.0f;
 }
@@ -70,7 +76,7 @@ NOBODY void CBaseMonster::CorpseFallThink(void)
 }
 
 /* <fc2a1> ../cstrike/dlls/mpstubb.cpp:62 */
-void CBaseMonster::MonsterInitDead_(void)
+void CBaseMonster::__MAKE_VHOOK(MonsterInitDead)(void)
 {
 	InitBoneControllers();
 
@@ -93,7 +99,7 @@ void CBaseMonster::MonsterInitDead_(void)
 }
 
 /* <fc057> ../cstrike/dlls/mpstubb.cpp:89 */
-BOOL CBaseMonster::ShouldFadeOnDeath_(void)
+BOOL CBaseMonster::__MAKE_VHOOK(ShouldFadeOnDeath)(void)
 {
 	return FALSE;
 }
@@ -105,13 +111,13 @@ BOOL CBaseMonster::FCheckAITrigger(void)
 }
 
 /* <fc26d> ../cstrike/dlls/mpstubb.cpp:99 */
-void CBaseMonster::KeyValue_(KeyValueData *pkvd)
+void CBaseMonster::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 	CBaseToggle::KeyValue(pkvd);
 }
 
 /* <fc07d> ../cstrike/dlls/mpstubb.cpp:104 */
-NOBODY int CBaseMonster::IRelationship_(CBaseEntity *pTarget)
+NOBODY int CBaseMonster::__MAKE_VHOOK(IRelationship)(CBaseEntity *pTarget)
 {
 //	{
 //		int const iEnemy;                                      //   106
@@ -119,7 +125,7 @@ NOBODY int CBaseMonster::IRelationship_(CBaseEntity *pTarget)
 }
 
 /* <fc0e4> ../cstrike/dlls/mpstubb.cpp:140 */
-NOBODY void CBaseMonster::Look_(int iDistance)
+NOBODY void CBaseMonster::__MAKE_VHOOK(Look)(int iDistance)
 {
 //	{
 //		int iSighted;                                         //   142
@@ -142,7 +148,7 @@ NOBODY void CBaseMonster::Look_(int iDistance)
 }
 
 /* <fc317> ../cstrike/dlls/mpstubb.cpp:220 */
-NOBODY CBaseEntity *CBaseMonster::BestVisibleEnemy_(void)
+NOBODY CBaseEntity *CBaseMonster::__MAKE_VHOOK(BestVisibleEnemy)(void)
 {
 //	{
 //		class CBaseEntity *pReturn;                          //   222

regamedll/dlls/nodes.h

@@ -49,14 +49,14 @@ public:
 class CGraph
 {
 public:
-	NOBODY void InitGraph(void);
+	void InitGraph(void);
-	NOBODY int AllocNodes(void);
+	int AllocNodes(void);
-	NOBODY int CheckNODFile(char *szMapName);
+	int CheckNODFile(char *szMapName);
-	NOBODY int FLoadGraph(char *szMapName);
+	int FLoadGraph(char *szMapName);
-	NOBODY int FSetGraphPointers(void);
+	int FSetGraphPointers(void);
 	void ShowNodeConnections(int iNode);
-	NOBODY int FindNearestNode(const Vector &vecOrigin, CBaseEntity *pEntity);
+	int FindNearestNode(const Vector &vecOrigin, CBaseEntity *pEntity);
-	NOBODY int FindNearestNode(const Vector &vecOrigin, int afNodeTypes);
+	int FindNearestNode(const Vector &vecOrigin, int afNodeTypes);
 public:
 	BOOL m_fGraphPresent;
 	BOOL m_fGraphPointersSet;

regamedll/dlls/pathcorner.cpp

@@ -33,7 +33,7 @@ LINK_ENTITY_TO_CLASS(path_corner, CPathCorner);
 IMPLEMENT_SAVERESTORE(CPathCorner, CPointEntity);
 
 /* <122697> ../cstrike/dlls/pathcorner.cpp:54 */
-NOBODY void CPathCorner::KeyValue_(KeyValueData *pkvd)
+NOBODY void CPathCorner::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //    56
@@ -44,7 +44,7 @@ NOBODY void CPathCorner::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <122325> ../cstrike/dlls/pathcorner.cpp:66 */
-NOBODY void CPathCorner::Spawn_(void)
+NOBODY void CPathCorner::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -55,7 +55,7 @@ IMPLEMENT_SAVERESTORE(CPathTrack, CBaseEntity);
 LINK_ENTITY_TO_CLASS(path_track, CPathTrack);
 
 /* <122602> ../cstrike/dlls/pathcorner.cpp:86 */
-NOBODY void CPathTrack::KeyValue_(KeyValueData *pkvd)
+NOBODY void CPathTrack::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //    88
@@ -66,7 +66,7 @@ NOBODY void CPathTrack::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <122433> ../cstrike/dlls/pathcorner.cpp:97 */
-NOBODY void CPathTrack::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CPathTrack::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		int on;                                               //    99
@@ -99,7 +99,7 @@ NOBODY void CPathTrack::Link(void)
 }
 
 /* <12239a> ../cstrike/dlls/pathcorner.cpp:165 */
-NOBODY void CPathTrack::Spawn_(void)
+NOBODY void CPathTrack::__MAKE_VHOOK(Spawn)(void)
 {
 //	Vector(Vector::Spawn(//		float X,
 //		float Y,
@@ -111,7 +111,7 @@ NOBODY void CPathTrack::Spawn_(void)
 }
 
 /* <122c76> ../cstrike/dlls/pathcorner.cpp:180 */
-NOBODY void CPathTrack::Activate_(void)
+NOBODY void CPathTrack::__MAKE_VHOOK(Activate)(void)
 {
 }
 

regamedll/dlls/plane.cpp

@@ -1,29 +1,33 @@
 #include "precompiled.h"
 
 /* <1262b3> ../cstrike/dlls/plane.cpp:24 */
-NOBODY CPlane::CPlane(void)
+CPlane::CPlane(void)
 {
 	m_fInitialized = FALSE;
 }
 
 /* <1262d4> ../cstrike/dlls/plane.cpp:33 */
-NOBODY void CPlane::InitializePlane(const Vector &vecNormal, const Vector &vecPoint)
+NOXREF void CPlane::InitializePlane(const Vector &vecNormal, const Vector &vecPoint)
 {
 	m_vecNormal = vecNormal;
-	m_flDist = DotProduct(m_vecNormal, vecPoint);
 	m_fInitialized = TRUE;
+	m_flDist = DotProduct(m_vecNormal, vecPoint);
 }
 
 /* <126343> ../cstrike/dlls/plane.cpp:45 */
-NOBODY BOOL CPlane::PointInFront(const Vector &vecPoint)
+NOXREF BOOL CPlane::PointInFront(const Vector &vecPoint)
 {
 	if (!m_fInitialized)
+	{
 		return FALSE;
+	}
 
 	float flFace = DotProduct(m_vecNormal, vecPoint) - m_flDist;
 
 	if (flFace >= 0.0f)
+	{
 		return TRUE;
+	}
 
 	return FALSE;
 }

regamedll/dlls/plane.h

@@ -36,11 +36,12 @@
 class CPlane
 {
 public:
-	NOBODY CPlane(void);
+	CPlane(void);
 
-	NOBODY void InitializePlane(const Vector &vecNormal, const Vector &vecPoint);
+	NOXREF void InitializePlane(const Vector &vecNormal, const Vector &vecPoint);
-	NOBODY BOOL PointInFront(const Vector &vecPoint);
+	NOXREF BOOL PointInFront(const Vector &vecPoint);
 
+private:
 	Vector m_vecNormal;
 	float m_flDist;
 	BOOL m_fInitialized;

regamedll/dlls/plats.cpp

@@ -74,7 +74,7 @@ TYPEDESCRIPTION (*CGunTarget::pm_SaveData)[1];
 IMPLEMENT_SAVERESTORE(CBasePlatTrain, CBaseToggle);
 
 /* <12ea9b> ../cstrike/dlls/plats.cpp:61 */
-NOBODY void CBasePlatTrain::KeyValue_(KeyValueData *pkvd)
+NOBODY void CBasePlatTrain::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //    73
@@ -97,7 +97,7 @@ NOBODY void CBasePlatTrain::KeyValue_(KeyValueData *pkvd)
 #define noiseArrived noise1
 
 /* <12d675> ../cstrike/dlls/plats.cpp:105 */
-NOBODY void CBasePlatTrain::Precache_(void)
+NOBODY void CBasePlatTrain::__MAKE_VHOOK(Precache)(void)
 {
 }
 
@@ -131,13 +131,13 @@ NOBODY void CFuncPlat::Setup(void)
 }
 
 /* <13088e> ../cstrike/dlls/plats.cpp:309 */
-NOBODY void CFuncPlat::Precache_(void)
+NOBODY void CFuncPlat::__MAKE_VHOOK(Precache)(void)
 {
 //	PlatSpawnInsideTrigger(entvars_t *pevPlatform);  //   315
 }
 
 /* <130757> ../cstrike/dlls/plats.cpp:319 */
-NOBODY void CFuncPlat::Spawn_(void)
+NOBODY void CFuncPlat::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(CFuncPlat *const this);  //   319
 }
@@ -161,7 +161,7 @@ NOBODY void CPlatTrigger::SpawnInsideTrigger(CFuncPlat *pPlatform)
 }
 
 /* <12e7e7> ../cstrike/dlls/plats.cpp:380 */
-NOBODY void CPlatTrigger::Touch_(CBaseEntity *pOther)
+NOBODY void CPlatTrigger::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
 //	{
 //		entvars_t *pevToucher;                               //   383
@@ -186,7 +186,7 @@ NOBODY void CFuncPlat::PlatUse(CBaseEntity *pActivator, CBaseEntity *pCaller, US
 }
 
 /* <12e49b> ../cstrike/dlls/plats.cpp:431 */
-NOBODY void CFuncPlat::GoDown_(void)
+NOBODY void CFuncPlat::__MAKE_VHOOK(GoDown)(void)
 {
 //	EMIT_SOUND(edict_t *entity,
 //			int channel,
@@ -198,7 +198,7 @@ NOBODY void CFuncPlat::GoDown_(void)
 }
 
 /* <12f381> ../cstrike/dlls/plats.cpp:446 */
-NOBODY void CFuncPlat::HitBottom_(void)
+NOBODY void CFuncPlat::__MAKE_VHOOK(HitBottom)(void)
 {
 //	EMIT_SOUND(edict_t *entity,
 //			int channel,
@@ -211,7 +211,7 @@ NOBODY void CFuncPlat::HitBottom_(void)
 }
 
 /* <12e52d> ../cstrike/dlls/plats.cpp:462 */
-NOBODY void CFuncPlat::GoUp_(void)
+NOBODY void CFuncPlat::__MAKE_VHOOK(GoUp)(void)
 {
 //	EMIT_SOUND(edict_t *entity,
 //			int channel,
@@ -223,7 +223,7 @@ NOBODY void CFuncPlat::GoUp_(void)
 }
 
 /* <12f452> ../cstrike/dlls/plats.cpp:477 */
-NOBODY void CFuncPlat::HitTop_(void)
+NOBODY void CFuncPlat::__MAKE_VHOOK(HitTop)(void)
 {
 //	STOP_SOUND(edict_t *entity,
 //			int channel,
@@ -236,7 +236,7 @@ NOBODY void CFuncPlat::HitTop_(void)
 }
 
 /* <12f524> ../cstrike/dlls/plats.cpp:497 */
-NOBODY void CFuncPlat::Blocked_(CBaseEntity *pOther)
+NOBODY void CFuncPlat::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
 {
 //	STOP_SOUND(edict_t *entity,
 //			int channel,
@@ -258,32 +258,32 @@ NOBODY void CFuncPlatRot::SetupRotation(void)
 }
 
 /* <130bc4> ../cstrike/dlls/plats.cpp:563 */
-NOBODY void CFuncPlatRot::Spawn_(void)
+NOBODY void CFuncPlatRot::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(CFuncPlat *const this);  //   565
 }
 
 /* <12fe63> ../cstrike/dlls/plats.cpp:569 */
-NOBODY void CFuncPlatRot::GoDown_(void)
+NOBODY void CFuncPlatRot::__MAKE_VHOOK(GoDown)(void)
 {
 //	RotMove(CFuncPlatRot::GoDown(//		Vector &destAngle,
 //		float time);  //   572
 }
 
 /* <12f430> ../cstrike/dlls/plats.cpp:579 */
-NOBODY void CFuncPlatRot::HitBottom_(void)
+NOBODY void CFuncPlatRot::__MAKE_VHOOK(HitBottom)(void)
 {
 }
 
 /* <12fdad> ../cstrike/dlls/plats.cpp:590 */
-NOBODY void CFuncPlatRot::GoUp_(void)
+NOBODY void CFuncPlatRot::__MAKE_VHOOK(GoUp)(void)
 {
 //	RotMove(CFuncPlatRot::GoUp(//		Vector &destAngle,
 //		float time);  //   593
 }
 
 /* <12f502> ../cstrike/dlls/plats.cpp:600 */
-NOBODY void CFuncPlatRot::HitTop_(void)
+NOBODY void CFuncPlatRot::__MAKE_VHOOK(HitTop)(void)
 {
 }
 
@@ -306,7 +306,7 @@ LINK_ENTITY_TO_CLASS(func_train, CFuncTrain);
 IMPLEMENT_SAVERESTORE(CFuncTrain, CBasePlatTrain);
 
 /* <130390> ../cstrike/dlls/plats.cpp:668 */
-NOBODY void CFuncTrain::KeyValue_(KeyValueData *pkvd)
+NOBODY void CFuncTrain::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   670
@@ -317,7 +317,7 @@ NOBODY void CFuncTrain::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <12de63> ../cstrike/dlls/plats.cpp:679 */
-NOBODY void CFuncTrain::Blocked_(CBaseEntity *pOther)
+NOBODY void CFuncTrain::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
 {
 //	Blocked(CFuncTrain *const this,
 //		class CBaseEntity *pOther);  //   679
@@ -325,7 +325,7 @@ NOBODY void CFuncTrain::Blocked_(CBaseEntity *pOther)
 
 
 /* <12fa23> ../cstrike/dlls/plats.cpp:691 */
-NOBODY void CFuncTrain::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CFuncTrain::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	EMIT_SOUND(edict_t *entity,
 //			int channel,
@@ -393,7 +393,7 @@ NOBODY void CFuncTrain::Next(void)
 }
 
 /* <12e1fd> ../cstrike/dlls/plats.cpp:818 */
-NOBODY void CFuncTrain::Activate_(void)
+NOBODY void CFuncTrain::__MAKE_VHOOK(Activate)(void)
 {
 //	{
 //		entvars_t *pevTarg;                                  //   824
@@ -402,22 +402,22 @@ NOBODY void CFuncTrain::Activate_(void)
 }
 
 /* <12dcad> ../cstrike/dlls/plats.cpp:852 */
-NOBODY void CFuncTrain::Spawn_(void)
+NOBODY void CFuncTrain::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <12dab7> ../cstrike/dlls/plats.cpp:886 */
-NOBODY void CFuncTrain::Restart_(void)
+NOBODY void CFuncTrain::__MAKE_VHOOK(Restart)(void)
 {
 }
 
 /* <12d734> ../cstrike/dlls/plats.cpp:907 */
-NOBODY void CFuncTrain::Precache_(void)
+NOBODY void CFuncTrain::__MAKE_VHOOK(Precache)(void)
 {
 }
 
 /* <12e166> ../cstrike/dlls/plats.cpp:913 */
-NOBODY void CFuncTrain::OverrideReset_(void)
+NOBODY void CFuncTrain::__MAKE_VHOOK(OverrideReset)(void)
 {
 //	{
 //		class CBaseEntity *pTarg;                            //   915
@@ -434,7 +434,7 @@ IMPLEMENT_SAVERESTORE(CFuncTrackTrain, CBaseEntity);
 LINK_ENTITY_TO_CLASS(func_tracktrain, CFuncTrackTrain);
 
 /* <12e88e> ../cstrike/dlls/plats.cpp:964 */
-NOBODY void CFuncTrackTrain::KeyValue_(KeyValueData *pkvd)
+NOBODY void CFuncTrackTrain::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   966
@@ -452,7 +452,7 @@ NOBODY void CFuncTrackTrain::NextThink(float thinkTime, BOOL alwaysThink)
 }
 
 /* <12ee6d> ../cstrike/dlls/plats.cpp:1013 */
-NOBODY void CFuncTrackTrain::Blocked_(CBaseEntity *pOther)
+NOBODY void CFuncTrackTrain::__MAKE_VHOOK(Blocked)(CBaseEntity *pOther)
 {
 //	{
 //		entvars_t *pevOther;                                 //  1015
@@ -470,7 +470,7 @@ NOBODY void CFuncTrackTrain::Blocked_(CBaseEntity *pOther)
 }
 
 /* <1312c7> ../cstrike/dlls/plats.cpp:1038 */
-NOBODY void CFuncTrackTrain::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CFuncTrackTrain::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		float delta;                                          //  1062
@@ -588,7 +588,7 @@ NOBODY void CFuncTrackTrain::SetControls(entvars_t *pevControls)
 }
 
 /* <12dd23> ../cstrike/dlls/plats.cpp:1363 */
-NOBODY BOOL CFuncTrackTrain::OnControls_(entvars_t *pevTest)
+NOBODY BOOL CFuncTrackTrain::__MAKE_VHOOK(OnControls)(entvars_t *pevTest)
 {
 //	{
 //		Vector offset;                                  //  1365
@@ -654,7 +654,7 @@ NOBODY void CFuncTrackTrain::NearestPath(void)
 }
 
 /* <12d75a> ../cstrike/dlls/plats.cpp:1470 */
-NOBODY void CFuncTrackTrain::OverrideReset_(void)
+NOBODY void CFuncTrackTrain::__MAKE_VHOOK(OverrideReset)(void)
 {
 //	NextThink(CFuncTrackTrain::OverrideReset(//			float thinkTime,
 //			BOOL alwaysThink);  //  1472
@@ -669,21 +669,21 @@ NOBODY CFuncTrackTrain *CFuncTrackTrain::Instance(edict_t *pent)
 }
 
 /* <12dcd4> ../cstrike/dlls/plats.cpp:1495 */
-NOBODY void CFuncTrackTrain::Spawn_(void)
+NOBODY void CFuncTrackTrain::__MAKE_VHOOK(Spawn)(void)
 {
 //	NextThink(CFuncTrackTrain::Spawn(//			float thinkTime,
 //			BOOL alwaysThink);  //  1533
 }
 
 /* <12dbdf> ../cstrike/dlls/plats.cpp:1539 */
-NOBODY void CFuncTrackTrain::Restart_(void)
+NOBODY void CFuncTrackTrain::__MAKE_VHOOK(Restart)(void)
 {
 //	NextThink(CFuncTrackTrain::Restart(//			float thinkTime,
 //			BOOL alwaysThink);  //  1557
 }
 
 /* <12d7a5> ../cstrike/dlls/plats.cpp:1562 */
-NOBODY void CFuncTrackTrain::Precache_(void)
+NOBODY void CFuncTrackTrain::__MAKE_VHOOK(Precache)(void)
 {
 }
 
@@ -709,12 +709,12 @@ NOBODY void CFuncTrainControls::Find(void)
 }
 
 /* <12dc86> ../cstrike/dlls/plats.cpp:1619 */
-NOBODY void CFuncTrainControls::Spawn_(void)
+NOBODY void CFuncTrainControls::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <12d7f2> ../cstrike/dlls/plats.cpp:1673 */
-NOBODY BOOL CFuncTrackChange::IsTogglePlat_(void)
+NOBODY BOOL CFuncTrackChange::__MAKE_VHOOK(IsTogglePlat)(void)
 {
 	return TRUE;
 }
@@ -726,24 +726,24 @@ LINK_ENTITY_TO_CLASS(func_trackchange, CFuncTrackChange);
 IMPLEMENT_SAVERESTORE(CFuncTrackChange, CFuncPlatRot);
 
 /* <130c1d> ../cstrike/dlls/plats.cpp:1715 */
-NOBODY void CFuncTrackChange::Spawn_(void)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(Spawn)(void)
 {
 //	EnableUse(CFuncTrackChange *const this);  //  1738
 }
 
 /* <130a3b> ../cstrike/dlls/plats.cpp:1744 */
-NOBODY void CFuncTrackChange::Precache_(void)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(Precache)(void)
 {
 //	Precache(CFuncPlat *const this);  //  1749
 }
 
 /* <12d818> ../cstrike/dlls/plats.cpp:1753 */
-NOBODY void CFuncTrackChange::Touch_(CBaseEntity *pOther)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
 }
 
 /* <1304ca> ../cstrike/dlls/plats.cpp:1758 */
-NOBODY void CFuncTrackChange::KeyValue_(KeyValueData *pkvd)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //  1760
@@ -754,7 +754,7 @@ NOBODY void CFuncTrackChange::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <12d84d> ../cstrike/dlls/plats.cpp:1782 */
-NOBODY void CFuncTrackChange::OverrideReset_(void)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(OverrideReset)(void)
 {
 }
 
@@ -833,26 +833,26 @@ NOBODY void CFuncTrackChange::UpdateTrain(Vector &dest)
 }
 
 /* <131ade> ../cstrike/dlls/plats.cpp:1883 */
-NOBODY void CFuncTrackChange::GoDown_(void)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(GoDown)(void)
 {
 //	GoDown(CFuncTrackChange *const this);  //  1883
 }
 
 /* <1319f9> ../cstrike/dlls/plats.cpp:1919 */
-NOBODY void CFuncTrackChange::GoUp_(void)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(GoUp)(void)
 {
 //	GoUp(CFuncTrackChange *const this);  //  1919
 }
 
 /* <12deb0> ../cstrike/dlls/plats.cpp:1954 */
-NOBODY void CFuncTrackChange::UpdateAutoTargets_(int toggleState)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(UpdateAutoTargets)(int toggleState)
 {
 //	UpdateAutoTargets(CFuncTrackChange *const this,
 //				int toggleState);  //  1954
 }
 
 /* <131725> ../cstrike/dlls/plats.cpp:1971 */
-NOBODY void CFuncTrackChange::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	Use(CFuncTrackChange *const this,
 //		class CBaseEntity *pActivator,
@@ -867,7 +867,7 @@ NOBODY void CFuncTrackChange::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller
 }
 
 /* <12f618> ../cstrike/dlls/plats.cpp:2005 */
-NOBODY void CFuncTrackChange::HitBottom_(void)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(HitBottom)(void)
 {
 //	HitBottom(CFuncPlatRot *const this);  //  2007
 //	EnableUse(CFuncTrackChange *const this);  //  2018
@@ -876,7 +876,7 @@ NOBODY void CFuncTrackChange::HitBottom_(void)
 }
 
 /* <12f588> ../cstrike/dlls/plats.cpp:2025 */
-NOBODY void CFuncTrackChange::HitTop_(void)
+NOBODY void CFuncTrackChange::__MAKE_VHOOK(HitTop)(void)
 {
 //	HitTop(CFuncPlatRot *const this);  //  2027
 //	EnableUse(CFuncTrackChange *const this);  //  2038
@@ -888,7 +888,7 @@ NOBODY void CFuncTrackChange::HitTop_(void)
 LINK_ENTITY_TO_CLASS(func_trackautochange, CFuncTrackAuto);
 
 /* <12dc2a> ../cstrike/dlls/plats.cpp:2053 */
-NOBODY void CFuncTrackAuto::UpdateAutoTargets_(int toggleState)
+NOBODY void CFuncTrackAuto::__MAKE_VHOOK(UpdateAutoTargets)(int toggleState)
 {
 //	{
 //		class CPathTrack *pTarget;                           //  2055
@@ -897,7 +897,7 @@ NOBODY void CFuncTrackAuto::UpdateAutoTargets_(int toggleState)
 }
 
 /* <1301f9> ../cstrike/dlls/plats.cpp:2083 */
-NOBODY void CFuncTrackAuto::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CFuncTrackAuto::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{
 //		class CPathTrack *pTarget;                           //  2085
@@ -916,12 +916,12 @@ LINK_ENTITY_TO_CLASS(func_guntarget, CGunTarget);
 IMPLEMENT_SAVERESTORE(CGunTarget, CBaseMonster);
 
 /* <12dbb8> ../cstrike/dlls/plats.cpp:2173 */
-NOBODY void CGunTarget::Spawn_(void)
+NOBODY void CGunTarget::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <12dade> ../cstrike/dlls/plats.cpp:2199 */
-NOBODY void CGunTarget::Activate_(void)
+NOBODY void CGunTarget::__MAKE_VHOOK(Activate)(void)
 {
 //	{
 //		class CBaseEntity *pTarg;                            //  2201
@@ -969,7 +969,7 @@ NOBODY void CGunTarget::Stop(void)
 }
 
 /* <12e371> ../cstrike/dlls/plats.cpp:2277 */
-NOBODY int CGunTarget::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
+NOBODY int CGunTarget::__MAKE_VHOOK(TakeDamage)(entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType)
 {
 //	Stop(CGunTarget *const this);  //  2285
 //	TakeDamage(CGunTarget *const this,
@@ -980,7 +980,7 @@ NOBODY int CGunTarget::TakeDamage_(entvars_t *pevInflictor, entvars_t *pevAttack
 }
 
 /* <12e408> ../cstrike/dlls/plats.cpp:2294 */
-NOBODY void CGunTarget::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CGunTarget::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	Stop(CGunTarget *const this);  //  2301
 //	Use(CGunTarget *const this,

regamedll/dlls/player.h

@@ -112,8 +112,8 @@
 
 #define TEAM_NAME_LENGTH		16
 
-#define MAX_ID_RANGE			2048
+#define MAX_ID_RANGE			2048.0f
-#define MAX_SPECTATOR_ID_RANGE		8192
+#define MAX_SPECTATOR_ID_RANGE		8192.0f
 #define SBAR_STRING_SIZE		128
 
 #define SBAR_TARGETTYPE_TEAMMATE	1
@@ -765,22 +765,22 @@ public:
 	void PrioritizeAutoBuyString(char *autobuyString, const char *priorityString);
 	NOBODY const char *PickPrimaryCareerTaskWeapon(void);
 	NOBODY const char *PickSecondaryCareerTaskWeapon(void);
-	NOXREF const char *PickFlashKillWeaponString(void);
+	const char *PickFlashKillWeaponString(void);
-	NOXREF const char *PickGrenadeKillWeaponString(void);
+	const char *PickGrenadeKillWeaponString(void);
-	NOXREF bool ShouldExecuteAutoBuyCommand(AutoBuyInfoStruct *commandInfo, bool boughtPrimary, bool boughtSecondary);
+	bool ShouldExecuteAutoBuyCommand(AutoBuyInfoStruct *commandInfo, bool boughtPrimary, bool boughtSecondary);
 	void PostAutoBuyCommandProcessing(AutoBuyInfoStruct *commandInfo, bool &boughtPrimary, bool &boughtSecondary);
 	void ParseAutoBuyString(const char *string, bool &boughtPrimary, bool &boughtSecondary);
-	NOXREF AutoBuyInfoStruct *GetAutoBuyCommandInfo(const char *command);
+	AutoBuyInfoStruct *GetAutoBuyCommandInfo(const char *command);
 	void InitRebuyData(const char *str);
 	void BuildRebuyStruct(void);
 	void Rebuy(void);
-	NOXREF void RebuyPrimaryWeapon(void);
+	void RebuyPrimaryWeapon(void);
-	NOXREF void RebuyPrimaryAmmo(void);
+	void RebuyPrimaryAmmo(void);
-	NOXREF void RebuySecondaryWeapon(void);
+	void RebuySecondaryWeapon(void);
-	NOXREF void RebuySecondaryAmmo(void);
+	void RebuySecondaryAmmo(void);
-	NOXREF void RebuyHEGrenade(void);
+	void RebuyHEGrenade(void);
-	NOXREF void RebuyFlashbang(void);
+	void RebuyFlashbang(void);
-	NOXREF void RebuySmokeGrenade(void);
+	void RebuySmokeGrenade(void);
 	void RebuyDefuser(void);
 	void RebuyNightVision(void);
 	void RebuyArmor(void);
@@ -1168,17 +1168,17 @@ NOXREF void InitZombieSpawns(void);
 NOXREF CBaseEntity *FindZombieSpawn(CBaseEntity *player, bool forceSpawn);
 edict_t *EntSelectSpawnPoint(CBaseEntity *pPlayer);
 void SetScoreAttrib(CBasePlayer *dest, CBasePlayer *src);
-NOXREF CBaseEntity *FindEntityForward(CBaseEntity *pMe);
+CBaseEntity *FindEntityForward(CBaseEntity *pMe);
 float GetPlayerPitch(const edict_t *pEdict);
 float GetPlayerYaw(const edict_t *pEdict);
 int GetPlayerGaitsequence(const edict_t *pEdict);
-NOXREF const char *GetBuyStringForWeaponClass(int weaponClass);
+const char *GetBuyStringForWeaponClass(int weaponClass);
-NOXREF bool IsPrimaryWeaponClass(int classId);
+bool IsPrimaryWeaponClass(int classId);
-NOXREF bool IsPrimaryWeaponId(int id);
+bool IsPrimaryWeaponId(int id);
-NOXREF bool IsSecondaryWeaponClass(int classId);
+bool IsSecondaryWeaponClass(int classId);
-NOXREF bool IsSecondaryWeaponId(int id);
+bool IsSecondaryWeaponId(int id);
-NOXREF const char *GetWeaponAliasFromName(const char *weaponName);
+const char *GetWeaponAliasFromName(const char *weaponName);
-NOXREF bool CurrentWeaponSatisfies(CBasePlayerWeapon *pWeapon, int id, int classId);
+bool CurrentWeaponSatisfies(CBasePlayerWeapon *pWeapon, int id, int classId);
 
 // refs
 extern void (*pCBasePlayer__PickPrimaryCareerTaskWeapon)(void);

regamedll/dlls/saverestore.h

@@ -32,7 +32,7 @@
 #pragma once
 #endif
 
-#define MAX_ENTITYARRAY 64
+#define MAX_ENTITY_ARRAY	64
 
 #ifndef HOOK_GAMEDLL
 
@@ -71,6 +71,7 @@ typedef enum
 	GLOBAL_OFF,
 	GLOBAL_ON,
 	GLOBAL_DEAD
+
 } GLOBALESTATE;
 
 typedef struct globalentity_s
@@ -79,14 +80,18 @@ typedef struct globalentity_s
 	char levelName[32];
 	GLOBALESTATE state;
 	struct globalentity_s *pNext;
+
 } globalentity_t;
+/* size: 104, cachelines: 2, members: 4 */
 
 typedef struct
 {
 	unsigned short size;
 	unsigned short token;
 	char *pData;
+
 } HEADER;
+/* size: 8, cachelines: 1, members: 3 */
 
 class CBaseEntity;
 
@@ -204,22 +209,23 @@ private:
 class CGlobalState
 {
 public:
-	NOBODY CGlobalState();
+	CGlobalState(void);
-	NOBODY void Reset(void);
+
-	NOBODY void ClearStates(void);
+	void Reset(void);
-	NOBODY void EntityAdd(string_t globalname, string_t mapName, GLOBALESTATE state);
+	void ClearStates(void);
+	void EntityAdd(string_t globalname, string_t mapName, GLOBALESTATE state);
 	void EntitySetState(string_t globalname, GLOBALESTATE state);
-	NOBODY void EntityUpdate(string_t globalname, string_t mapname);
+	void EntityUpdate(string_t globalname, string_t mapname);
-	NOBODY const globalentity_t *EntityFromTable(string_t globalname);
+	const globalentity_t *EntityFromTable(string_t globalname);
-	NOBODY GLOBALESTATE EntityGetState(string_t globalname);
+	GLOBALESTATE EntityGetState(string_t globalname);
 	int EntityInTable(string_t globalname)
 	{
 		if (Find(globalname) != NULL)
 			return 1;
 		return 0;
 	}
-	NOBODY int Save(CSave &save);
+	int Save(CSave &save);
-	NOBODY int Restore(CRestore &restore);
+	int Restore(CRestore &restore);
 	void DumpGlobals(void);
 
 	static TYPEDESCRIPTION IMPLEMENT_ARRAY(m_SaveData)[1];

regamedll/dlls/scriptevent.h

@@ -0,0 +1,47 @@
+/*
+*
+*   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.
+*
+*/
+
+#ifndef SCRIPTEVENT_H
+#define SCRIPTEVENT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#define SCRIPT_EVENT_DEAD		1000 // character is now dead
+#define SCRIPT_EVENT_NOINTERRUPT	1001 // does not allow interrupt
+#define SCRIPT_EVENT_CANINTERRUPT	1002 // will allow interrupt
+#define SCRIPT_EVENT_FIREEVENT		1003 // event now fires
+#define SCRIPT_EVENT_SOUND		1004 // Play named wave file (on CHAN_BODY)
+#define SCRIPT_EVENT_SENTENCE		1005 // Play named sentence
+#define SCRIPT_EVENT_INAIR		1006 // Leave the character in air at the end of the sequence (don't find the floor)
+#define SCRIPT_EVENT_ENDANIMATION	1007 // Set the animation by name after the sequence completes
+#define SCRIPT_EVENT_SOUND_VOICE	1008 // Play named wave file (on CHAN_VOICE)
+#define SCRIPT_EVENT_SENTENCE_RND1	1009 // Play sentence group 25% of the time
+#define SCRIPT_EVENT_NOT_DEAD		1010 // Bring back to life (for life/death sequences)
+
+#endif // SCRIPTEVENT_H

regamedll/dlls/singleplay_gamerules.cpp

@@ -3,81 +3,86 @@
 /* <1676c5> ../cstrike/dlls/singleplay_gamerules.cpp:32 */
 CHalfLifeRules::CHalfLifeRules(void)
 {
+	m_bFreezePeriod = FALSE;
 	RefreshSkillData();
 }
 
 /* <166d5d> ../cstrike/dlls/singleplay_gamerules.cpp:40 */
-void CHalfLifeRules::Think(void)
+void CHalfLifeRules::__MAKE_VHOOK(Think)(void)
 {
 	;
 }
 
 /* <166d83> ../cstrike/dlls/singleplay_gamerules.cpp:46 */
-BOOL CHalfLifeRules::IsMultiplayer(void)
+BOOL CHalfLifeRules::__MAKE_VHOOK(IsMultiplayer)(void)
 {
 	return FALSE;
 }
 
 /* <166da9> ../cstrike/dlls/singleplay_gamerules.cpp:53 */
-BOOL CHalfLifeRules::IsDeathmatch(void)
+BOOL CHalfLifeRules::__MAKE_VHOOK(IsDeathmatch)(void)
 {
 	return FALSE;
 }
 
 /* <166dcf> ../cstrike/dlls/singleplay_gamerules.cpp:60 */
-BOOL CHalfLifeRules::IsCoOp(void)
+BOOL CHalfLifeRules::__MAKE_VHOOK(IsCoOp)(void)
 {
 	return FALSE;
 }
 
 /* <166df5> ../cstrike/dlls/singleplay_gamerules.cpp:68 */
-BOOL CHalfLifeRules::FShouldSwitchWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
+BOOL CHalfLifeRules::__MAKE_VHOOK(FShouldSwitchWeapon)(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
 {
 	if (!pPlayer->m_pActiveItem)
 	{
 		// player doesn't have an active item!
 		return TRUE;
 	}
+
 	if (!pPlayer->m_pActiveItem->CanHolster())
 	{
 		return FALSE;
 	}
+
 	return TRUE;
 }
 
 /* <166e38> ../cstrike/dlls/singleplay_gamerules.cpp:86 */
-BOOL CHalfLifeRules::GetNextBestWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon)
+BOOL CHalfLifeRules::__MAKE_VHOOK(GetNextBestWeapon)(CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon)
 {
 	return FALSE;
 }
 
 /* <166e7a> ../cstrike/dlls/singleplay_gamerules.cpp:93 */
-BOOL CHalfLifeRules::ClientConnected(edict_t *pEntity, const char *pszName, const char *pszAddress, char *szRejectReason)
+BOOL CHalfLifeRules::__MAKE_VHOOK(ClientConnected)(edict_t *pEntity, const char *pszName, const char *pszAddress, char *szRejectReason)
 {
 	return TRUE;
 }
 
 /* <166ed8> ../cstrike/dlls/singleplay_gamerules.cpp:98 */
-void CHalfLifeRules::InitHUD(CBasePlayer *pl)
+void CHalfLifeRules::__MAKE_VHOOK(InitHUD)(CBasePlayer *pl)
 {
 	;
 }
 
 /* <166f0b> ../cstrike/dlls/singleplay_gamerules.cpp:104 */
-void CHalfLifeRules::ClientDisconnected(edict_t *pClient)
+void CHalfLifeRules::__MAKE_VHOOK(ClientDisconnected)(edict_t *pClient)
 {
 	;
 }
 
 /* <166f3f> ../cstrike/dlls/singleplay_gamerules.cpp:110 */
-float CHalfLifeRules::FlPlayerFallDamage(CBasePlayer *pPlayer)
+float CHalfLifeRules::__MAKE_VHOOK(FlPlayerFallDamage)(CBasePlayer *pPlayer)
 {
+	// subtract off the speed at which a player is allowed to fall without being hurt,
+	// so damage will be based on speed beyond that, not the entire fall
 	pPlayer->m_flFallVelocity -= PLAYER_MAX_SAFE_FALL_SPEED;
 	return pPlayer->m_flFallVelocity * DAMAGE_FOR_FALL_SPEED;
 }
 
 /* <167677> ../cstrike/dlls/singleplay_gamerules.cpp:120 */
-void CHalfLifeRules::PlayerSpawn_(CBasePlayer *pPlayer)
+void CHalfLifeRules::__MAKE_VHOOK(PlayerSpawn)(CBasePlayer *pPlayer)
 {
 	pPlayer->pev->weapons |= (1 << WEAPON_SUIT);
 
@@ -91,73 +96,73 @@ void CHalfLifeRules::PlayerSpawn_(CBasePlayer *pPlayer)
 }
 
 /* <166f73> ../cstrike/dlls/singleplay_gamerules.cpp:135 */
-BOOL CHalfLifeRules::AllowAutoTargetCrosshair(void)
+BOOL CHalfLifeRules::__MAKE_VHOOK(AllowAutoTargetCrosshair)(void)
 {
 	return (g_iSkillLevel == SKILL_EASY);
 }
 
 /* <166f99> ../cstrike/dlls/singleplay_gamerules.cpp:142 */
-void CHalfLifeRules::PlayerThink(CBasePlayer *pPlayer)
+void CHalfLifeRules::__MAKE_VHOOK(PlayerThink)(CBasePlayer *pPlayer)
 {
 	;
 }
 
 /* <166fcd> ../cstrike/dlls/singleplay_gamerules.cpp:149 */
-BOOL CHalfLifeRules::FPlayerCanRespawn(CBasePlayer *pPlayer)
+BOOL CHalfLifeRules::__MAKE_VHOOK(FPlayerCanRespawn)(CBasePlayer *pPlayer)
 {
 	return TRUE;
 }
 
 /* <167001> ../cstrike/dlls/singleplay_gamerules.cpp:156 */
-float CHalfLifeRules::FlPlayerSpawnTime(CBasePlayer *pPlayer)
+float CHalfLifeRules::__MAKE_VHOOK(FlPlayerSpawnTime)(CBasePlayer *pPlayer)
 {
 	return gpGlobals->time;
 }
 
 /* <167035> ../cstrike/dlls/singleplay_gamerules.cpp:165 */
-int CHalfLifeRules::IPointsForKill(CBasePlayer *pAttacker, CBasePlayer *pKilled)
+int CHalfLifeRules::__MAKE_VHOOK(IPointsForKill)(CBasePlayer *pAttacker, CBasePlayer *pKilled)
 {
 	return 1;
 }
 
 /* <167077> ../cstrike/dlls/singleplay_gamerules.cpp:173 */
-void CHalfLifeRules::PlayerKilled(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor)
+void CHalfLifeRules::__MAKE_VHOOK(PlayerKilled)(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor)
 {
 	;
 }
 
 /* <1670c7> ../cstrike/dlls/singleplay_gamerules.cpp:180 */
-void CHalfLifeRules::DeathNotice(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor)
+void CHalfLifeRules::__MAKE_VHOOK(DeathNotice)(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor)
 {
 	;
 }
 
 /* <167117> ../cstrike/dlls/singleplay_gamerules.cpp:188 */
-void CHalfLifeRules::PlayerGotWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
+void CHalfLifeRules::__MAKE_VHOOK(PlayerGotWeapon)(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
 {
 	;
 }
 
 /* <167159> ../cstrike/dlls/singleplay_gamerules.cpp:196 */
-float CHalfLifeRules::FlWeaponRespawnTime(CBasePlayerItem *pWeapon)
+float CHalfLifeRules::__MAKE_VHOOK(FlWeaponRespawnTime)(CBasePlayerItem *pWeapon)
 {
 	return -1;
 }
 
 /* <16718d> ../cstrike/dlls/singleplay_gamerules.cpp:206 */
-float CHalfLifeRules::FlWeaponTryRespawn(CBasePlayerItem *pWeapon)
+float CHalfLifeRules::__MAKE_VHOOK(FlWeaponTryRespawn)(CBasePlayerItem *pWeapon)
 {
 	return 0;
 }
 
 /* <1671c1> ../cstrike/dlls/singleplay_gamerules.cpp:215 */
-Vector CHalfLifeRules::VecWeaponRespawnSpot(CBasePlayerItem *pWeapon)
+Vector CHalfLifeRules::__MAKE_VHOOK(VecWeaponRespawnSpot)(CBasePlayerItem *pWeapon)
 {
 	return pWeapon->pev->origin;
 }
 
 /* <1675e6> ../cstrike/dlls/singleplay_gamerules.cpp:220 */
-edict_t *CHalfLifeRules::GetPlayerSpawnSpot(CBasePlayer *pPlayer)
+edict_t *CHalfLifeRules::__MAKE_VHOOK(GetPlayerSpawnSpot)(CBasePlayer *pPlayer)
 {
 	CBaseEntity *pSpot = UTIL_FindEntityByClassname(NULL, "info_player_start");
 
@@ -178,107 +183,297 @@ edict_t *CHalfLifeRules::GetPlayerSpawnSpot(CBasePlayer *pPlayer)
 }
 
 /* <16721c> ../cstrike/dlls/singleplay_gamerules.cpp:243 */
-int CHalfLifeRules::WeaponShouldRespawn(CBasePlayerItem *pWeapon)
+int CHalfLifeRules::__MAKE_VHOOK(WeaponShouldRespawn)(CBasePlayerItem *pWeapon)
 {
 	return GR_WEAPON_RESPAWN_NO;
 }
 
 /* <167250> ../cstrike/dlls/singleplay_gamerules.cpp:250 */
-BOOL CHalfLifeRules::CanHaveItem(CBasePlayer *pPlayer, CItem *pItem)
+BOOL CHalfLifeRules::__MAKE_VHOOK(CanHaveItem)(CBasePlayer *pPlayer, CItem *pItem)
 {
 	return TRUE;
 }
 
 /* <167292> ../cstrike/dlls/singleplay_gamerules.cpp:257 */
-void CHalfLifeRules::PlayerGotItem(CBasePlayer *pPlayer, CItem *pItem)
+void CHalfLifeRules::__MAKE_VHOOK(PlayerGotItem)(CBasePlayer *pPlayer, CItem *pItem)
 {
 	;
 }
 
 /* <1672d6> ../cstrike/dlls/singleplay_gamerules.cpp:263 */
-int CHalfLifeRules::ItemShouldRespawn(CItem *pItem)
+int CHalfLifeRules::__MAKE_VHOOK(ItemShouldRespawn)(CItem *pItem)
 {
 	return GR_ITEM_RESPAWN_NO;
 }
 
 /* <16730b> ../cstrike/dlls/singleplay_gamerules.cpp:272 */
-float CHalfLifeRules::FlItemRespawnTime(CItem *pItem)
+float CHalfLifeRules::__MAKE_VHOOK(FlItemRespawnTime)(CItem *pItem)
 {
 	return -1;
 }
 
 /* <167340> ../cstrike/dlls/singleplay_gamerules.cpp:281 */
-Vector CHalfLifeRules::VecItemRespawnSpot(CItem *pItem)
+Vector CHalfLifeRules::__MAKE_VHOOK(VecItemRespawnSpot)(CItem *pItem)
 {
 	return pItem->pev->origin;
 }
 
 /* <16739d> ../cstrike/dlls/singleplay_gamerules.cpp:288 */
-BOOL CHalfLifeRules::IsAllowedToSpawn(CBaseEntity *pEntity)
+BOOL CHalfLifeRules::__MAKE_VHOOK(IsAllowedToSpawn)(CBaseEntity *pEntity)
 {
 	return TRUE;
 }
 
 /* <1673d2> ../cstrike/dlls/singleplay_gamerules.cpp:295 */
-void CHalfLifeRules::PlayerGotAmmo(CBasePlayer *pPlayer, char *szName, int iCount)
+void CHalfLifeRules::__MAKE_VHOOK(PlayerGotAmmo)(CBasePlayer *pPlayer, char *szName, int iCount)
 {
 	;
 }
 
 /* <167425> ../cstrike/dlls/singleplay_gamerules.cpp:301 */
-int CHalfLifeRules::AmmoShouldRespawn(CBasePlayerAmmo *pAmmo)
+int CHalfLifeRules::__MAKE_VHOOK(AmmoShouldRespawn)(CBasePlayerAmmo *pAmmo)
 {
 	return GR_AMMO_RESPAWN_NO;
 }
 
 /* <16745a> ../cstrike/dlls/singleplay_gamerules.cpp:308 */
-float CHalfLifeRules::FlAmmoRespawnTime(CBasePlayerAmmo *pAmmo)
+float CHalfLifeRules::__MAKE_VHOOK(FlAmmoRespawnTime)(CBasePlayerAmmo *pAmmo)
 {
 	return -1;
 }
 
 /* <16748f> ../cstrike/dlls/singleplay_gamerules.cpp:315 */
-Vector CHalfLifeRules::VecAmmoRespawnSpot(CBasePlayerAmmo *pAmmo)
+Vector CHalfLifeRules::__MAKE_VHOOK(VecAmmoRespawnSpot)(CBasePlayerAmmo *pAmmo)
 {
 	return pAmmo->pev->origin;
 }
 
 /* <1674ec> ../cstrike/dlls/singleplay_gamerules.cpp:322 */
-float CHalfLifeRules::FlHealthChargerRechargeTime(void)
+float CHalfLifeRules::__MAKE_VHOOK(FlHealthChargerRechargeTime)(void)
 {
 	return 0;
 }
 
 /* <167512> ../cstrike/dlls/singleplay_gamerules.cpp:329 */
-int CHalfLifeRules::DeadPlayerWeapons(CBasePlayer *pPlayer)
+int CHalfLifeRules::__MAKE_VHOOK(DeadPlayerWeapons)(CBasePlayer *pPlayer)
 {
 	return GR_PLR_DROP_GUN_NO;
 }
 
 /* <167547> ../cstrike/dlls/singleplay_gamerules.cpp:336 */
-int CHalfLifeRules::DeadPlayerAmmo(CBasePlayer *pPlayer)
+int CHalfLifeRules::__MAKE_VHOOK(DeadPlayerAmmo)(CBasePlayer *pPlayer)
 {
 	return GR_PLR_DROP_AMMO_NO;
 }
 
 /* <16757c> ../cstrike/dlls/singleplay_gamerules.cpp:343 */
-int CHalfLifeRules::PlayerRelationship(CBasePlayer *pPlayer, CBaseEntity *pTarget)
+int CHalfLifeRules::__MAKE_VHOOK(PlayerRelationship)(CBasePlayer *pPlayer, CBaseEntity *pTarget)
 {
 	// why would a single player in half life need this? 
 	return GR_NOTTEAMMATE;
 }
 
 /* <1675c0> ../cstrike/dlls/singleplay_gamerules.cpp:351 */
-BOOL CHalfLifeRules::FAllowMonsters(void)
+BOOL CHalfLifeRules::__MAKE_VHOOK(FAllowMonsters)(void)
 {
 	return TRUE;
 }
 
 #ifdef HOOK_GAMEDLL
 
-void CHalfLifeRules::PlayerSpawn(CBasePlayer *pPlayer)
+void CHalfLifeRules::Think(void)
-{
+{
-	PlayerSpawn_(pPlayer);
+	Think_();
+}
+
+BOOL CHalfLifeRules::IsAllowedToSpawn(CBaseEntity *pEntity)
+{
+	return IsAllowedToSpawn_(pEntity);
+}
+
+BOOL CHalfLifeRules::FShouldSwitchWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
+{
+	return FShouldSwitchWeapon_(pPlayer, pWeapon);
+}
+
+BOOL CHalfLifeRules::GetNextBestWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pCurrentWeapon)
+{
+	return GetNextBestWeapon_(pPlayer, pCurrentWeapon);
+}
+
+BOOL CHalfLifeRules::IsMultiplayer(void)
+{
+	return IsMultiplayer_();
+}
+
+BOOL CHalfLifeRules::IsDeathmatch(void)
+{
+	return IsDeathmatch_();
+}
+
+BOOL CHalfLifeRules::IsCoOp(void)
+{
+	return IsCoOp_();
+}
+
+BOOL CHalfLifeRules::ClientConnected(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[128])
+{
+	return ClientConnected_(pEntity, pszName, pszAddress, szRejectReason);
+}
+
+void CHalfLifeRules::InitHUD(CBasePlayer *pl)
+{
+	InitHUD_(pl);
+}
+
+void CHalfLifeRules::ClientDisconnected(edict_t *pClient)
+{
+	ClientDisconnected_(pClient);
+}
+
+float CHalfLifeRules::FlPlayerFallDamage(CBasePlayer *pPlayer)
+{
+	return FlPlayerFallDamage_(pPlayer);
+}
+
+void CHalfLifeRules::PlayerSpawn(CBasePlayer *pPlayer)
+{
+	PlayerSpawn_(pPlayer);
+}
+
+void CHalfLifeRules::PlayerThink(CBasePlayer *pPlayer)
+{
+	PlayerThink_(pPlayer);
+}
+
+BOOL CHalfLifeRules::FPlayerCanRespawn(CBasePlayer *pPlayer)
+{
+	return FPlayerCanRespawn_(pPlayer);
+}
+
+float CHalfLifeRules::FlPlayerSpawnTime(CBasePlayer *pPlayer)
+{
+	return FlPlayerSpawnTime_(pPlayer);
+}
+
+edict_t *CHalfLifeRules::GetPlayerSpawnSpot(CBasePlayer *pPlayer)
+{
+	return GetPlayerSpawnSpot_(pPlayer);
+}
+
+BOOL CHalfLifeRules::AllowAutoTargetCrosshair(void)
+{
+	return AllowAutoTargetCrosshair_();
+}
+
+int CHalfLifeRules::IPointsForKill(CBasePlayer *pAttacker, CBasePlayer *pKilled)
+{
+	return IPointsForKill_(pAttacker, pKilled);
+}
+
+void CHalfLifeRules::PlayerKilled(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor)
+{
+	PlayerKilled_(pVictim, pKiller, pInflictor);
+}
+
+void CHalfLifeRules::DeathNotice(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor)
+{
+	DeathNotice_(pVictim, pKiller, pInflictor);
+}
+
+void CHalfLifeRules::PlayerGotWeapon(CBasePlayer *pPlayer, CBasePlayerItem *pWeapon)
+{
+	PlayerGotWeapon_(pPlayer, pWeapon);
+}
+
+int CHalfLifeRules::WeaponShouldRespawn(CBasePlayerItem *pWeapon)
+{
+	return WeaponShouldRespawn_(pWeapon);
+}
+
+float CHalfLifeRules::FlWeaponRespawnTime(CBasePlayerItem *pWeapon)
+{
+	return FlWeaponRespawnTime_(pWeapon);
+}
+
+float CHalfLifeRules::FlWeaponTryRespawn(CBasePlayerItem *pWeapon)
+{
+	return FlWeaponTryRespawn_(pWeapon);
+}
+
+Vector CHalfLifeRules::VecWeaponRespawnSpot(CBasePlayerItem *pWeapon)
+{
+	return VecWeaponRespawnSpot_(pWeapon);
+}
+
+BOOL CHalfLifeRules::CanHaveItem(CBasePlayer *pPlayer, CItem *pItem)
+{
+	return CanHaveItem_(pPlayer, pItem);
+}
+
+void CHalfLifeRules::PlayerGotItem(CBasePlayer *pPlayer, CItem *pItem)
+{
+	PlayerGotItem_(pPlayer, pItem);
+}
+
+int CHalfLifeRules::ItemShouldRespawn(CItem *pItem)
+{
+	return ItemShouldRespawn_(pItem);
+}
+
+float CHalfLifeRules::FlItemRespawnTime(CItem *pItem)
+{
+	return FlItemRespawnTime_(pItem);
+}
+
+Vector CHalfLifeRules::VecItemRespawnSpot(CItem *pItem)
+{
+	return VecItemRespawnSpot_(pItem);
+}
+
+void CHalfLifeRules::PlayerGotAmmo(CBasePlayer *pPlayer, char *szName, int iCount)
+{
+	PlayerGotAmmo_(pPlayer, szName, iCount);
+}
+
+int CHalfLifeRules::AmmoShouldRespawn(CBasePlayerAmmo *pAmmo)
+{
+	return AmmoShouldRespawn_(pAmmo);
+}
+
+float CHalfLifeRules::FlAmmoRespawnTime(CBasePlayerAmmo *pAmmo)
+{
+	return FlAmmoRespawnTime_(pAmmo);
+}
+
+Vector CHalfLifeRules::VecAmmoRespawnSpot(CBasePlayerAmmo *pAmmo)
+{
+	return VecAmmoRespawnSpot_(pAmmo);
+}
+
+float CHalfLifeRules::FlHealthChargerRechargeTime(void)
+{
+	return FlHealthChargerRechargeTime_();
+}
+
+int CHalfLifeRules::DeadPlayerWeapons(CBasePlayer *pPlayer)
+{
+	return DeadPlayerWeapons_(pPlayer);
+}
+
+int CHalfLifeRules::DeadPlayerAmmo(CBasePlayer *pPlayer)
+{
+	return DeadPlayerAmmo_(pPlayer);
+}
+
+int CHalfLifeRules::PlayerRelationship(CBasePlayer *pPlayer, CBaseEntity *pTarget)
+{
+	return PlayerRelationship_(pPlayer, pTarget);
+}
+
+BOOL CHalfLifeRules::FAllowMonsters(void)
+{
+	return FAllowMonsters_();
 }
 
 #endif // HOOK_GAMEDLL

regamedll/dlls/skill.cpp

@@ -2,19 +2,23 @@
 
 skilldata_t gSkillData;
 
+// take the name of a cvar, tack a digit for the skill level
+// on, and return the value.of that Cvar 
+
 /* <16a558> ../cstrike/dlls/skill.cpp:30 */
 NOXREF float GetSkillCvar(char *pName)
 {
-	//int iCount; //unused
+	int iCount;
-
 	float flValue;
 	char szBuffer[64];
 
-	Q_sprintf(szBuffer, "%s%d", pName, gSkillData.iSkillLevel);
+	iCount = Q_sprintf(szBuffer, "%s%d", pName, gSkillData.iSkillLevel);
 	flValue = CVAR_GET_FLOAT(szBuffer);
 
 	if (flValue <= 0.0f)
+	{
 		ALERT(at_console, "\n\n** GetSkillCVar Got a zero for %s **\n\n",szBuffer);
+	}
 
 	return flValue;
 }

regamedll/dlls/sound.cpp

@@ -257,7 +257,7 @@ NOBODY void CEnvSound::Spawn(void)
 // randomize list of sentence name indices
 
 /* <17093f> ../cstrike/dlls/sound.cpp:1084 */
-NOXREF void USENTENCEG_InitLRU(unsigned char *plru, int count)
+void USENTENCEG_InitLRU(unsigned char *plru, int count)
 {
 	int i, j, k;
 	unsigned char temp;
@@ -343,7 +343,7 @@ int USENTENCEG_Pick(int isentenceg, char *szfound)
 	unsigned char i;
 	unsigned char count;
 	char sznum[8];
-	unsigned char ipick;
+	unsigned char ipick = 0xFF;
 	BOOL ffound = FALSE;
 	
 	if (!fSentencesInit)
@@ -351,7 +351,7 @@ int USENTENCEG_Pick(int isentenceg, char *szfound)
 
 	if (isentenceg < 0)
 		return -1;
-
+	
 	szgroupname = rgsentenceg[isentenceg].szgroupname;
 	count = rgsentenceg[isentenceg].count;
 	plru = rgsentenceg[isentenceg].rgblru;
@@ -359,6 +359,7 @@ int USENTENCEG_Pick(int isentenceg, char *szfound)
 	while (!ffound)
 	{
 		for (i = 0; i < count; i++)
+		{
 			if (plru[i] != 0xFF)
 			{
 				ipick = plru[i];
@@ -366,18 +367,21 @@ int USENTENCEG_Pick(int isentenceg, char *szfound)
 				ffound = TRUE;
 				break;
 			}
+		}
 
-		if (!ffound)
+		if (ffound)
-			USENTENCEG_InitLRU(plru, count);
-		else
 		{
 			Q_strcpy(szfound, "!");
 			Q_strcat(szfound, szgroupname);
 			Q_sprintf(sznum, "%d", ipick);
 			Q_strcat(szfound, sznum);
+
 			return ipick;
 		}
+		else
+			USENTENCEG_InitLRU(plru, count);
 	}
+
 	return -1;
 }
 
@@ -565,8 +569,10 @@ void SENTENCEG_Init(void)
 		buffer[j] = 0;
 		const char *pString = buffer + i;
 
-		if (Q_strlen( pString ) >= CBSENTENCENAME_MAX)
+		if (Q_strlen(pString) >= CBSENTENCENAME_MAX)
-			ALERT( at_warning, "Sentence %s longer than %d letters\n", pString, CBSENTENCENAME_MAX - 1);
+		{
+			ALERT(at_warning, "Sentence %s longer than %d letters\n", pString, CBSENTENCENAME_MAX - 1);
+		}
 
 		Q_strcpy(gszallsentencenames[gcallsentences++], pString);
 
@@ -825,7 +831,7 @@ void TEXTURETYPE_Init(void)
 			continue;
 
 		// null-terminate name and save in sentences array
-		j = min(j, CBTEXTURENAMEMAX - 1 + i);
+		j = _min(j, CBTEXTURENAMEMAX - 1 + i);
 		buffer[j] = 0;
 		Q_strcpy(&(grgszTextureName[gcTextures++][0]), &(buffer[i]));
 	}
@@ -1034,7 +1040,6 @@ float TEXTURETYPE_PlaySound(TraceResult *ptr, Vector vecSrc, Vector vecEnd, int
 	else if (chTextureType == CHAR_TEX_COMPUTER)
 	{
 		// play random spark if computer
-
 		if (ptr->flFraction != 1.0 && RANDOM_LONG(0, 1))
 		{
 			UTIL_Sparks(ptr->vecEndPos);
@@ -1044,12 +1049,12 @@ float TEXTURETYPE_PlaySound(TraceResult *ptr, Vector vecSrc, Vector vecEnd, int
 
 			switch (RANDOM_LONG(0, 1))
 			{
-				case 0:
+			case 0:
-					UTIL_EmitAmbientSound(ENT(0), ptr->vecEndPos, "buttons/spark5.wav", flVolume, ATTN_NORM, 0, 100);
+				UTIL_EmitAmbientSound(ENT(0), ptr->vecEndPos, "buttons/spark5.wav", flVolume, ATTN_NORM, 0, 100);
-					break;
+				break;
-				case 1:
+			case 1:
-					UTIL_EmitAmbientSound(ENT(0), ptr->vecEndPos, "buttons/spark6.wav", flVolume, ATTN_NORM, 0, 100);
+				UTIL_EmitAmbientSound(ENT(0), ptr->vecEndPos, "buttons/spark6.wav", flVolume, ATTN_NORM, 0, 100);
-					break;
+				break;
 			}
 		}
 	}

regamedll/dlls/sound.h

@@ -45,7 +45,7 @@ typedef struct
 /* size: 52, cachelines: 1, members: 3 */
 
 NOBODY BOOL FEnvSoundInRange(entvars_t *pev, entvars_t *pevTarget, float *pflRange);
-NOXREF void USENTENCEG_InitLRU(unsigned char *plru, int count);
+void USENTENCEG_InitLRU(unsigned char *plru, int count);
 int USENTENCEG_PickSequential(int isentenceg, char *szfound, int ipick, int freset);
 int USENTENCEG_Pick(int isentenceg, char *szfound);
 NOXREF int SENTENCEG_GetIndex(const char *szgroupname);

regamedll/dlls/soundent.cpp

@@ -33,12 +33,12 @@ NOBODY BOOL CSound::FIsScent(void)
 }
 
 /* <17900a> ../cstrike/dlls/soundent.cpp:80 */
-NOBODY void CSoundEnt::Spawn_(void)
+NOBODY void CSoundEnt::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <178b0c> ../cstrike/dlls/soundent.cpp:93 */
-NOBODY void CSoundEnt::Think_(void)
+NOBODY void CSoundEnt::__MAKE_VHOOK(Think)(void)
 {
 //	{
 //		int iSound;                                           //    95
@@ -53,7 +53,7 @@ NOBODY void CSoundEnt::Think_(void)
 }
 
 /* <178a76> ../cstrike/dlls/soundent.cpp:132 */
-NOBODY void CSoundEnt::Precache_(void)
+NOBODY void CSoundEnt::__MAKE_VHOOK(Precache)(void)
 {
 }
 

regamedll/dlls/spectator.cpp

@@ -1,6 +1,6 @@
 #include "precompiled.h"
 
-NOXREF void CBaseSpectator::SpectatorConnect(void)
+void CBaseSpectator::SpectatorConnect(void)
 {
 	pev->flags = FL_SPECTATOR;
 	pev->solid = SOLID_NOT;
@@ -74,20 +74,24 @@ void CBaseSpectator::SpectatorImpulseCommand(void)
 	pev->impulse = 0;
 }
 
-NOXREF void CBaseSpectator::SpectatorThink(void)
+void CBaseSpectator::SpectatorThink(void)
 {
 	if (!(pev->flags & FL_SPECTATOR))
+	{
 		pev->flags = FL_SPECTATOR;
+	}
 
 	pev->solid = SOLID_NOT;
 	pev->movetype = MOVETYPE_NOCLIP;
 
 	if (pev->impulse)
+	{
 		SpectatorImpulseCommand();
+	}
 }
 
 /* <17d297> ../cstrike/dlls/spectator.cpp:142 */
-NOXREF void CBaseSpectator::Spawn_(void)
+void CBaseSpectator::__MAKE_VHOOK(Spawn)(void)
 {
 	pev->flags = FL_SPECTATOR;
 	pev->solid = SOLID_NOT;

regamedll/dlls/subs.cpp

@@ -42,12 +42,12 @@ TYPEDESCRIPTION (*CBaseToggle::pm_SaveData)[19];
 #endif // HOOK_GAMEDLL
 
 /* <1832bc> ../cstrike/dlls/subs.cpp:38 */
-NOBODY void CPointEntity::Spawn_(void)
+NOBODY void CPointEntity::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <183417> ../cstrike/dlls/subs.cpp:53 */
-NOBODY void CNullEntity::Spawn_(void)
+NOBODY void CNullEntity::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -73,7 +73,7 @@ LINK_ENTITY_TO_CLASS(info_hostage_rescue, CPointEntity);
 LINK_ENTITY_TO_CLASS(info_bomb_target, CPointEntity);
 
 /* <183647> ../cstrike/dlls/subs.cpp:79 */
-NOBODY void CBaseDMStart::KeyValue_(KeyValueData *pkvd)
+NOBODY void CBaseDMStart::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //    81
@@ -84,7 +84,7 @@ NOBODY void CBaseDMStart::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <18331c> ../cstrike/dlls/subs.cpp:90 */
-NOBODY BOOL CBaseDMStart::IsTriggered_(CBaseEntity *pEntity)
+NOBODY BOOL CBaseDMStart::__MAKE_VHOOK(IsTriggered)(CBaseEntity *pEntity)
 {
 //	{
 //		BOOL master;                                          //    92
@@ -94,7 +94,7 @@ NOBODY BOOL CBaseDMStart::IsTriggered_(CBaseEntity *pEntity)
 /* <183f03> ../cstrike/dlls/subs.cpp:98 */
 void CBaseEntity::UpdateOnRemove(void)
 {
-	if (pev->flags & FL_GRAPHED) // NOXREF
+	if (pev->flags & FL_GRAPHED)
 	{
 		for (int i = 0; i < WorldGraph.m_cLinks; i++)
 		{
@@ -102,8 +102,11 @@ void CBaseEntity::UpdateOnRemove(void)
 				WorldGraph.m_pLinkPool[i].m_pLinkEnt = NULL;
 		}
 	}
+
 	if (pev->globalname)
+	{
 		gGlobalState.EntitySetState(pev->globalname, GLOBAL_DEAD);
+	}
 }
 
 /* <183f38> ../cstrike/dlls/subs.cpp:120 */
@@ -115,6 +118,7 @@ void CBaseEntity::SUB_Remove(void)
 		pev->health = 0;
 		ALERT(at_aiconsole, "SUB_Remove called on entity with health > 0\n");
 	}
+
 	REMOVE_ENTITY(ENT(pev));
 }
 
@@ -128,11 +132,11 @@ void CBaseEntity::SUB_DoNothing(void)
 IMPLEMENT_SAVERESTORE(CBaseDelay, CBaseEntity);
 
 /* <18356f> ../cstrike/dlls/subs.cpp:149 */
-void CBaseDelay::KeyValue_(KeyValueData *pkvd)
+void CBaseDelay::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 	if (FStrEq(pkvd->szKeyName, "delay"))
 	{
-		m_flDelay = atof(pkvd->szValue);
+		m_flDelay = Q_atof(pkvd->szValue);
 		pkvd->fHandled = TRUE;
 	}
 	else if (FStrEq(pkvd->szKeyName, "killtarget"))
@@ -254,16 +258,16 @@ void CBaseDelay::DelayThink(void)
 IMPLEMENT_SAVERESTORE(CBaseToggle, CBaseAnimating);
 
 /* <1836dc> ../cstrike/dlls/subs.cpp:397 */
-void CBaseToggle::KeyValue_(KeyValueData *pkvd)
+void CBaseToggle::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 	if (FStrEq(pkvd->szKeyName, "lip"))
 	{
-		m_flLip = atof(pkvd->szValue);
+		m_flLip = Q_atof(pkvd->szValue);
 		pkvd->fHandled = TRUE;
 	}
 	else if (FStrEq(pkvd->szKeyName, "wait"))
 	{
-		m_flWait = atof(pkvd->szValue);
+		m_flWait = Q_atof(pkvd->szValue);
 		pkvd->fHandled = TRUE;
 	}
 	else if (FStrEq(pkvd->szKeyName, "master"))
@@ -273,7 +277,7 @@ void CBaseToggle::KeyValue_(KeyValueData *pkvd)
 	}
 	else if (FStrEq(pkvd->szKeyName, "distance"))
 	{
-		m_flMoveDistance = atof(pkvd->szValue);
+		m_flMoveDistance = Q_atof(pkvd->szValue);
 		pkvd->fHandled = TRUE;
 	}
 	else

regamedll/dlls/training_gamerules.cpp

@@ -26,25 +26,25 @@ TYPEDESCRIPTION CBaseGrenCatch::m_SaveData[] =
 
 #else
 
-TYPEDESCRIPTION (*CFuncWeaponCheck::pm_SaveData)[6];
+TYPEDESCRIPTION IMPLEMENT_ARRAY_CLASS(CFuncWeaponCheck, m_SaveData)[6];
-TYPEDESCRIPTION (*CBaseGrenCatch::pm_SaveData)[5];
+TYPEDESCRIPTION IMPLEMENT_ARRAY_CLASS(CBaseGrenCatch, m_SaveData)[5];
 
 #endif // HOOK_GAMEDLL
 
 /* <18bcc4> ../cstrike/dlls/training_gamerules.cpp:23 */
-NOBODY CHalfLifeTraining::CHalfLifeTraining(void)
+CHalfLifeTraining::CHalfLifeTraining(void)
 {
 	PRECACHE_MODEL("models/w_weaponbox.mdl");
 }
 
 /* <18ae1b> ../cstrike/dlls/training_gamerules.cpp:27 */
-BOOL CHalfLifeTraining::IsDeathmatch_(void)
+BOOL CHalfLifeTraining::__MAKE_VHOOK(IsDeathmatch)(void)
 {
 	return FALSE;
 }
 
 /* <18ae41> ../cstrike/dlls/training_gamerules.cpp:28 */
-void CHalfLifeTraining::InitHUD_(CBasePlayer *pl)
+void CHalfLifeTraining::__MAKE_VHOOK(InitHUD)(CBasePlayer *pl)
 {
 	;
 }
@@ -55,11 +55,13 @@ void CHalfLifeTraining::HostageDied(void)
 	CBasePlayer *pPlayer = (CBasePlayer *)UTIL_PlayerByIndex(1);
 
 	if (pPlayer)
+	{
 		pPlayer->pev->radsuit_finished = gpGlobals->time + 3;
+	}
 }
 
 /* <18b005> ../cstrike/dlls/training_gamerules.cpp:34 */
-edict_t *CHalfLifeTraining::GetPlayerSpawnSpot_(CBasePlayer *pPlayer)
+edict_t *CHalfLifeTraining::__MAKE_VHOOK(GetPlayerSpawnSpot)(CBasePlayer *pPlayer)
 {
 	CBaseEntity *pSpot = UTIL_FindEntityByClassname(NULL, "info_player_start");
 
@@ -80,32 +82,134 @@ edict_t *CHalfLifeTraining::GetPlayerSpawnSpot_(CBasePlayer *pPlayer)
 }
 
 /* <18b4aa> ../cstrike/dlls/training_gamerules.cpp:52 */
-NOBODY void CHalfLifeTraining::PlayerThink_(CBasePlayer *pPlayer)
+void CHalfLifeTraining::__MAKE_VHOOK(PlayerThink)(CBasePlayer *pPlayer)
 {
-//	{
+	if (pPlayer->pev->radsuit_finished && gpGlobals->time > pPlayer->pev->radsuit_finished)
-//		class CGrenade *pBomb;                               //    94
+	{
-//		FClassnameIs(entvars_t *pev,
+		SERVER_COMMAND("reload\n");
-//				const char *szClassname);  //    81
+	}
-//		{ 
+
-//			class CBasePlayerWeapon *pWeapon;            //    82
+	if (!pPlayer->m_iAccount)
-//		} 
+	{
-//		MESSAGE_BEGIN(int msg_dest,
+		if (pPlayer->pev->scale)
-//				int msg_type,
+		{
-//				const float *pOrigin,
+			pPlayer->m_iAccount = (int)pPlayer->pev->scale;
-//				entvars_t *ent);  //   124
+		}
-//		MESSAGE_BEGIN(int msg_dest,
+	}
-//				int msg_type,
+
-//				const float *pOrigin,
+	if (pPlayer->m_iTeam == UNASSIGNED)
-//				entvars_t *ent);  //   127
+	{
-//		MESSAGE_BEGIN(int msg_dest,
+		pPlayer->SetProgressBarTime(0);
-//				int msg_type,
+		pPlayer->m_bHasDefuser = pPlayer->pev->ideal_yaw != 0;
-//				const float *pOrigin,
+	}
-//				entvars_t *ent);  //   105
+
-//	} 
+	m_iHostagesRescued = 0;
+	m_iRoundTimeSecs = (int)(gpGlobals->time + 1.0f);
+	m_bFreezePeriod = FALSE;
+	g_fGameOver = FALSE;
+
+	pPlayer->m_iTeam = CT;
+	pPlayer->m_bCanShoot = true;
+	pPlayer->m_fLastMovement = gpGlobals->time;
+	
+	if (pPlayer->m_pActiveItem)
+		pPlayer->m_iHideHUD &= ~HIDEHUD_WEAPONS;
+	else
+		pPlayer->m_iHideHUD |= HIDEHUD_WEAPONS;
+
+	if (pPlayer->HasNamedPlayerItem("weapon_c4"))
+	{
+		if (pPlayer->m_rgAmmo[ pPlayer->GetAmmoIndex("C4") ] <= 0)
+		{
+			pPlayer->m_bHasC4 = false;
+
+			CBasePlayerWeapon *pWeapon = (CBasePlayerWeapon *)pPlayer->m_pActiveItem;
+
+			if (FClassnameIs(pWeapon->pev, "weapon_c4"))
+			{
+				pPlayer->pev->weapons &= ~(1 << pWeapon->m_iId);
+				pPlayer->RemovePlayerItem(pWeapon);
+				pWeapon->Drop();
+			}
+		}
+		else
+			pPlayer->m_bHasC4 = true;
+	}
+
+	if (!pPlayer->m_bVGUIMenus)
+	{
+		if (fVGUIMenus)
+		{
+			pPlayer->m_bVGUIMenus = fVGUIMenus;
+		}
+	}
+
+	CGrenade *pBomb = NULL;
+	while ((pBomb = (CGrenade *)UTIL_FindEntityByClassname(pBomb, "grenade")) != NULL)
+	{
+		if (pBomb->m_pentCurBombTarget != NULL)
+			pBomb->m_bStartDefuse = true;
+	}
+
+	if (pPlayer->m_signals.GetState() & SIGNAL_BUY)
+	{
+		if (!fInBuyArea)
+		{
+			FillAccountTime = 1;
+
+			if (!fVisitedBuyArea)
+			{
+				MESSAGE_BEGIN(MSG_ONE, gmsgStatusIcon, NULL, pPlayer->pev);
+					WRITE_BYTE(STATUSICON_FLASH);
+					WRITE_STRING("buyzone");
+					WRITE_BYTE(0);
+					WRITE_BYTE(160);
+					WRITE_BYTE(0);
+				MESSAGE_END();
+			}
+		}
+
+		fInBuyArea = TRUE;
+
+		if (pPlayer->m_iAccount < 16000 && FillAccountTime == 0.0f)
+			FillAccountTime = gpGlobals->time + 5;
+
+		if (FillAccountTime != 0.0f && gpGlobals->time > FillAccountTime)
+		{
+			if (!fVisitedBuyArea)
+			{
+				MESSAGE_BEGIN(MSG_ONE, gmsgBlinkAcct, NULL, pPlayer->pev);
+					WRITE_BYTE(3);
+				MESSAGE_END();
+
+				MESSAGE_BEGIN(MSG_ONE, gmsgStatusIcon, NULL, pPlayer->pev);
+					WRITE_BYTE(STATUSICON_SHOW);
+					WRITE_STRING("buyzone");
+					WRITE_BYTE(0);
+					WRITE_BYTE(160);
+					WRITE_BYTE(0);
+				MESSAGE_END();
+
+				fVisitedBuyArea = TRUE;
+			}
+
+			pPlayer->AddAccount(16000 - pPlayer->m_iAccount);
+			FillAccountTime = 0;
+		}
+	}
+	else if (fInBuyArea && fVisitedBuyArea)
+	{
+		fInBuyArea = FALSE;
+	}
+
+	pPlayer->pev->scale = pPlayer->m_iAccount;
+	pPlayer->pev->ideal_yaw = pPlayer->m_bHasDefuser;
+
+	TheBots->OnEvent(EVENT_PLAYER_CHANGED_TEAM, pPlayer);
 }
 
 /* <18b79c> ../cstrike/dlls/training_gamerules.cpp:151 */
-void CHalfLifeTraining::PlayerSpawn_(CBasePlayer *pPlayer)
+void CHalfLifeTraining::__MAKE_VHOOK(PlayerSpawn)(CBasePlayer *pPlayer)
 {
 	if (pPlayer->m_bNotKilled)
 		return;
@@ -126,7 +230,9 @@ void CHalfLifeTraining::PlayerSpawn_(CBasePlayer *pPlayer)
 	CBaseEntity *pWeaponEntity = NULL;
 
 	while ((pWeaponEntity = UTIL_FindEntityByClassname(pWeaponEntity, "game_player_equip")) != NULL)
+	{
 		pWeaponEntity->Touch(pPlayer);
+	}
 
 	pPlayer->SetPlayerModel(false);
 	pPlayer->Spawn();
@@ -134,61 +240,106 @@ void CHalfLifeTraining::PlayerSpawn_(CBasePlayer *pPlayer)
 }
 
 /* <18ae74> ../cstrike/dlls/training_gamerules.cpp:182 */
-NOBODY int CHalfLifeTraining::ItemShouldRespawn_(CItem *pItem)
+int CHalfLifeTraining::__MAKE_VHOOK(ItemShouldRespawn)(CItem *pItem)
 {
+	return GR_ITEM_RESPAWN_NO;
 }
 
 /* <18aea8> ../cstrike/dlls/training_gamerules.cpp:186 */
-NOBODY BOOL CHalfLifeTraining::FPlayerCanRespawn_(CBasePlayer *pPlayer)
+BOOL CHalfLifeTraining::__MAKE_VHOOK(FPlayerCanRespawn)(CBasePlayer *pPlayer)
 {
+	return TRUE;
 }
 
 /* <18bd40> ../cstrike/dlls/training_gamerules.cpp:190 */
 bool CHalfLifeTraining::PlayerCanBuy(CBasePlayer *pPlayer)
 {
-	return pPlayer->m_signals.GetState() & SIGNAL_BUY;
+	return (pPlayer->m_signals.GetState() & SIGNAL_BUY) != 0;
 }
 
 /* <18afa5> ../cstrike/dlls/training_gamerules.cpp:195 */
-NOBODY void CHalfLifeTraining::PlayerKilled_(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor)
+void CHalfLifeTraining::__MAKE_VHOOK(PlayerKilled)(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor)
 {
-//	edict(CBaseEntity *const this);  //   198
+	SET_VIEW(pVictim->edict(), pVictim->edict());
+	FireTargets("game_playerdie", pVictim, pVictim, USE_TOGGLE, 0);
 }
 
 /* <18b0fb> ../cstrike/dlls/training_gamerules.cpp:202 */
-NOBODY void CHalfLifeTraining::CheckWinConditions_(void)
+void CHalfLifeTraining::__MAKE_VHOOK(CheckWinConditions)(void)
 {
-//	{
+	CBaseEntity *pHostage = NULL;
-//		class CBaseEntity *pHostage;                         //   229
+
-//		{
+	if (m_bBombDefused)
-//			class CGrenade *pBomb;                       //   217
+	{
-//			Instance(edict_t *pent);  //   225
+		CGrenade *pBomb = NULL;
-//			Instance(edict_t *pent);  //   225
+
-//		} 
+		while ((pBomb = (CGrenade *)UTIL_FindEntityByClassname(pBomb, "grenade")) != NULL)
-//		{
+		{
-//			class CGrenade *pBomb;                       //   205
+			if (!pBomb->m_bIsC4 || !pBomb->m_bJustBlew)
-//			Instance(edict_t *pent);  //   213
+				continue;
-//			Instance(edict_t *pent);  //   213
+
-//		} 
+			pBomb->m_bJustBlew = false;
-//		FIND_ENTITY_BY_CLASSNAME(edict_t *entStart,
+			m_bBombDefused = false;
-//					const char *pszName);  //   229
+			FireTargets(STRING(pBomb->pev->target), CBaseEntity::Instance(pBomb->pev->owner), CBaseEntity::Instance(pBomb->pev->owner), USE_TOGGLE, 0);
-//		Instance(edict_t *pent);  //   229
+			break;
-//		{
+		}
-//			class CBaseEntity *pRescueArea;              //   236
+	}
-//			class CBaseEntity *pFirstRescueArea;         //   237
+	else if (m_bTargetBombed)
-//			FIND_ENTITY_BY_CLASSNAME(edict_t *entStart,
+	{
-//						const char *pszName);  //   236
+		CGrenade *pBomb = NULL;
-//			Vector(Vector *const this,
+
-//				float X,
+		while ((pBomb = (CGrenade *)UTIL_FindEntityByClassname(pBomb, "grenade")) != NULL)
-//				float Y,
+		{
-//				float Z);  //   235
+			if (!pBomb->m_bIsC4 || !pBomb->m_bJustBlew)
-//			Vector(Vector *const this,
+				continue;
-//				float X,
+
-//				float Y,
+			if (FStringNull(pBomb->pev->noise1))
-//				float Z);  //   235
+				continue;
-//			Instance(edict_t *pent);  //   236
+
-//		} 
+			pBomb->m_bJustBlew = false;
-//	} 
+			m_bTargetBombed = false;
+			FireTargets(STRING(pBomb->pev->noise1), CBaseEntity::Instance(pBomb->pev->owner), CBaseEntity::Instance(pBomb->pev->owner), USE_TOGGLE, 0);
+			break;
+		}
+	}
+
+	pHostage = CBaseEntity::Instance(FIND_ENTITY_BY_CLASSNAME(NULL, "hostage_entity"));
+
+	while (pHostage != NULL)
+	{
+		if (pHostage->pev->deadflag != DEAD_RESPAWNABLE || !FStringNull(pHostage->pev->noise1))
+			continue;
+
+		UTIL_SetSize(pHostage->pev, Vector(-16, -16, 0), Vector(16, 16, 72));
+
+		CBaseEntity *pRescueArea;
+		CBaseEntity *pFirstRescueArea;
+		
+		pFirstRescueArea = CBaseEntity::Instance(FIND_ENTITY_BY_CLASSNAME(NULL, "func_hostage_rescue"));
+		pRescueArea = pFirstRescueArea;
+
+		if (pFirstRescueArea != NULL)
+		{
+			while (pRescueArea != pFirstRescueArea)
+			{
+				if (!pRescueArea->Intersects(pHostage))
+					break;
+
+				pRescueArea = UTIL_FindEntityByClassname(pRescueArea, "func_hostage_rescue");
+
+				if (!pRescueArea)
+					break;
+			}
+
+			if (pRescueArea != NULL)
+			{
+				pHostage->pev->noise1 = 1;
+				FireTargets(STRING(pRescueArea->pev->target), NULL, NULL, USE_TOGGLE, 0);
+			}
+		}
+
+		pHostage = UTIL_FindEntityByClassname(pHostage, "hostage_entity");
+	}
 }
 
 /* <18b74f> ../cstrike/dlls/training_gamerules.cpp:280 */
@@ -197,67 +348,135 @@ IMPLEMENT_SAVERESTORE(CBaseGrenCatch, CBaseEntity);
 /* <18bd74> ../cstrike/dlls/training_gamerules.cpp:282 */
 LINK_ENTITY_TO_CLASS(func_grencatch, CBaseGrenCatch);
 
-/* <18af50> ../cstrike/dlls/training_gamerules.cpp:293 */
+/* <18af02> ../cstrike/dlls/training_gamerules.cpp:284 */
-NOBODY void CBaseGrenCatch::Touch_(CBaseEntity *pOther)
+void CBaseGrenCatch::__MAKE_VHOOK(Spawn)(void)
 {
-//	strstr(const char *__haystack,
+	pev->solid = SOLID_TRIGGER;
-//		const char *__needle);  //   297
+	pev->flags |= FL_WORLDBRUSH;
+	pev->effects |= EF_NODRAW;
+
+	SET_MODEL(ENT(pev), STRING(pev->model));
+	pev->nextthink = gpGlobals->time + 0.1f;
 }
 
-/* <18af02> ../cstrike/dlls/training_gamerules.cpp:284 */
+/* <18af50> ../cstrike/dlls/training_gamerules.cpp:293 */
-NOBODY void CBaseGrenCatch::Spawn_(void)
+void CBaseGrenCatch::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
+	if (!pOther)
+	{
+		return;
+	}
+
+	if (Q_strstr(STRING(pev->model), "flash") != NULL)
+	{
+		m_fFlashTouched = true;
+	}
 }
 
 /* <18b835> ../cstrike/dlls/training_gamerules.cpp:300 */
-NOBODY void CBaseGrenCatch::Think_(void)
+void CBaseGrenCatch::__MAKE_VHOOK(Think)(void)
 {
-//	{
+	CGrenade *pGrenade;
-//		class CGrenade *pGrenade;                            //   302
+	bool m_fSmokeTouchingLastFrame;
-//		BOOL m_fSmokeTouchingLastFrame;                       //   304
+	CBaseEntity *pTrigger;
-//		class CBaseEntity *pTrigger;                         //   320
+	Vector vMax, vMin;
-//		{
+
-//			class Vector vMax;                            //   311
+	m_fSmokeTouchingLastFrame = m_fSmokeTouching;
-//			class Vector vMin;                            //   311
+	m_fSmokeTouching = false;
-//			Vector(Vector *const this,
+	pGrenade = NULL;
-//				float X,
+
-//				float Y,
+	while (pGrenade = (CGrenade *)UTIL_FindEntityByClassname(pGrenade, "grenade"))
-//				float Z);  //   312
+	{
-//			Vector(Vector *const this,
+		vMin = pGrenade->pev->mins;
-//				float X,
+		vMax = pGrenade->pev->maxs;
-//				float Y,
+
-//				float Z);  //   312
+		UTIL_SetSize(pGrenade->pev, Vector(-8, -8, 0), Vector(8, 8, 0));
-//			Vector(Vector *const this,
+
-//				const class Vector  &const v);  //   311
+		if (pGrenade->Intersects(this) && Q_strstr(STRING(pGrenade->pev->model), "smoke") != NULL)
-//			Vector(Vector *const this,
+		{
-//				const class Vector  &const v);  //   311
+			if (pGrenade->pev->velocity.Length() == 0)
-//			strstr(const char *__haystack,
+				m_fSmokeTouching = true;
-//				const char *__needle);  //   314
+		}
-//			Length(const class Vector *const this);  //   315
+
-//		} 
+		pGrenade->pev->mins = vMin;
-//	} 
+		pGrenade->pev->maxs = vMax;
+	}
+
+	if ((m_NeedGrenadeType == GRENADETYPE_SMOKE && m_fSmokeTouching && !m_fSmokeTouchingLastFrame)
+		|| (m_NeedGrenadeType == GRENADETYPE_FLASH && m_fFlashTouched))
+	{
+		FireTargets(STRING(sTriggerOnGrenade), this, this, USE_TOGGLE, 0);
+
+		if (m_NeedGrenadeType == GRENADETYPE_SMOKE)
+		{
+			pTrigger = NULL;
+
+			while ((pTrigger = UTIL_FindEntityByTargetname(pTrigger, STRING(sDisableOnGrenade))) != NULL)
+			{
+				// save solid
+				pTrigger->pev->team = pTrigger->pev->solid;
+				pTrigger->pev->solid = SOLID_NOT;
+			}
+		}
+		else if (m_NeedGrenadeType == GRENADETYPE_FLASH)
+			pev->flags |= FL_KILLME;
+	}
+
+	if (m_fSmokeTouchingLastFrame && !m_fSmokeTouching)
+	{
+		pTrigger = NULL;
+
+		while (pTrigger = UTIL_FindEntityByTargetname(pTrigger, STRING(sDisableOnGrenade)))
+		{
+			// restore solid
+			pTrigger->pev->solid = pTrigger->pev->team;
+			pTrigger->pev->team = 0;
+			UTIL_SetOrigin(pTrigger->pev, pTrigger->pev->origin);
+		}
+	}
+
+	pev->nextthink = gpGlobals->time + 0.1f;
 }
 
 /* <18ba09> ../cstrike/dlls/training_gamerules.cpp:358 */
-NOBODY void CBaseGrenCatch::KeyValue_(KeyValueData *pkvd)
+void CBaseGrenCatch::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
-//	FStrEq(const char *sz1,
+	if (FStrEq(pkvd->szKeyName, "triggerongrenade"))
-//		const char *sz2);  //   360
+	{
-//	FStrEq(const char *sz1,
+		sTriggerOnGrenade = ALLOC_STRING(pkvd->szValue);
-//		const char *sz2);  //   365
+		pkvd->fHandled = TRUE;
-//	FStrEq(const char *sz1,
+	}
-//		const char *sz2);  //   370
+	else if (FStrEq(pkvd->szKeyName, "disableongrenade"))
-//	FStrEq(const char *sz1,
+	{
-//		const char *sz2);  //   372
+		sDisableOnGrenade = ALLOC_STRING(pkvd->szValue);
-//	KeyValue(CBaseEntity *const this,
+		pkvd->fHandled = TRUE;
-//		KeyValueData *pkvd);  //   376
+	}
-//	FStrEq(const char *sz1,
+	else if (FStrEq(pkvd->szKeyName, "grenadetype"))
-//		const char *sz2);  //   373
+	{
+		if (FStrEq(pkvd->szValue, "smoke"))
+		{
+			m_NeedGrenadeType = GRENADETYPE_SMOKE;
+			pkvd->fHandled = TRUE;
+		}
+		else if (FStrEq(pkvd->szValue, "flash"))
+		{
+			m_NeedGrenadeType = GRENADETYPE_FLASH;
+			pkvd->fHandled = TRUE;
+		}
+	}
+	else
+		CBaseEntity::KeyValue(pkvd);
 }
 
 /* <18af29> ../cstrike/dlls/training_gamerules.cpp:400 */
-NOBODY void CFuncWeaponCheck::Spawn_(void)
+void CFuncWeaponCheck::__MAKE_VHOOK(Spawn)(void)
 {
+	pev->dmgtime = 0;
+	pev->solid = SOLID_TRIGGER;
+	pev->flags |= FL_WORLDBRUSH;
+	pev->solid |= EF_NODRAW;
+
+	SET_MODEL(ENT(pev), STRING(pev->model));
 }
 
 /* <18b702> ../cstrike/dlls/training_gamerules.cpp:420 */
@@ -267,24 +486,91 @@ IMPLEMENT_SAVERESTORE(CFuncWeaponCheck, CBaseEntity);
 LINK_ENTITY_TO_CLASS(func_weaponcheck, CFuncWeaponCheck);
 
 /* <18b5f6> ../cstrike/dlls/training_gamerules.cpp:424 */
-NOBODY void CFuncWeaponCheck::Touch_(CBaseEntity *pOther)
+void CFuncWeaponCheck::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
-//	{ 
+	if (!UTIL_IsMasterTriggered(sMaster, pOther))
-//		class CBasePlayer *pPlayer;                          //   430
+		return;
-//	} 
+
-//	Touch(CFuncWeaponCheck *const this,
+	if (!pOther)
-//		class CBaseEntity *pOther);  //   424
+		return;
+
+	if (!pOther->IsPlayer())
+		return;
+
+	CBasePlayer *pPlayer = (CBasePlayer *)pOther;
+	for (int i = 1; i <= iItemCount; i++)
+	{
+		if (iAnyWeapon)
+		{
+			if (pPlayer->HasNamedPlayerItem(STRING(sItemName[i])))
+			{
+				break;
+			}
+		}
+		else
+		{
+			if (!pPlayer->HasNamedPlayerItem(STRING(sItemName[i])))
+			{
+				if (pev->dmgtime < gpGlobals->time)
+				{
+					if (pev->speed > -1.0f)
+					{
+						FireTargets(STRING(sTriggerNoItems), pOther, pOther, USE_TOGGLE, 0);
+						pev->dmgtime = pev->speed + gpGlobals->time;
+
+						if (!pev->speed)
+							pev->speed = -1;
+					}
+				}
+
+				return;
+			}
+		}
+	}
+
+	FireTargets(STRING(sTriggerWithItems), pOther, pOther, USE_TOGGLE, 0);
+	SUB_Remove();
 }
 
 /* <18bb28> ../cstrike/dlls/training_gamerules.cpp:462 */
-NOBODY void CFuncWeaponCheck::KeyValue_(KeyValueData *pkvd)
+void CFuncWeaponCheck::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
-//	FStrEq(const char *sz1,
+	if (FStrEq(pkvd->szKeyName, "trigger_items"))
-//		const char *sz2);  //   464
+	{
-//	FStrEq(const char *sz1,
+		sTriggerWithItems = ALLOC_STRING(pkvd->szValue);
-//		const char *sz2);  //   469
+		pkvd->fHandled = TRUE;
-//	KeyValue(CFuncWeaponCheck *const this,
+	}
-//		KeyValueData *pkvd);  //   462
+	else if (FStrEq(pkvd->szKeyName, "trigger_noitems"))
+	{
+		sTriggerNoItems = ALLOC_STRING(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "trigger_noitems_delay"))
+	{
+		pev->speed = Q_atof(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (Q_strstr(pkvd->szKeyName, "item") != NULL)
+	{
+		if (iItemCount < MAX_ITEM_COUNTS)
+		{
+			sItemName[ iItemCount++ ] = ALLOC_STRING(pkvd->szValue);
+		}
+
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "master"))
+	{
+		sMaster = ALLOC_STRING(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else if (FStrEq(pkvd->szKeyName, "any_weapon"))
+	{
+		iAnyWeapon = Q_atoi(pkvd->szValue);
+		pkvd->fHandled = TRUE;
+	}
+	else
+		CBaseEntity::KeyValue(pkvd);
 }
 
 #ifdef HOOK_GAMEDLL

regamedll/dlls/training_gamerules.h

@@ -40,22 +40,25 @@ public:
 public:
 	virtual BOOL IsMultiplayer(void)
 	{
-		return FALSE;
+		return IsMultiplayer_();
 	}
-	NOBODY virtual BOOL IsDeathmatch(void);
+	virtual BOOL IsDeathmatch(void);
 	virtual void InitHUD(CBasePlayer *pl);
 	virtual void PlayerSpawn(CBasePlayer *pPlayer);
-	NOBODY virtual void PlayerThink(CBasePlayer *pPlayer);
+	virtual void PlayerThink(CBasePlayer *pPlayer);
-	NOBODY virtual BOOL FPlayerCanRespawn(CBasePlayer *pPlayer);
+	virtual BOOL FPlayerCanRespawn(CBasePlayer *pPlayer);
 	virtual edict_t *GetPlayerSpawnSpot(CBasePlayer *pPlayer);
-	NOBODY virtual void PlayerKilled(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor);
+	virtual void PlayerKilled(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor);
-	NOBODY virtual int ItemShouldRespawn(CItem *pItem);
+	virtual int ItemShouldRespawn(CItem *pItem);
-	NOBODY virtual void CheckMapConditions(void) {}
+	virtual void CheckMapConditions(void) { }
-	NOBODY virtual void CheckWinConditions(void);
+	virtual void CheckWinConditions(void);
 
 #ifdef HOOK_GAMEDLL
 
-	//BOOL IsMultiplayer_(void);
+	BOOL IsMultiplayer_(void)
+	{
+		return FALSE;
+	}
 	BOOL IsDeathmatch_(void);
 	void InitHUD_(CBasePlayer *pl);
 	void PlayerSpawn_(CBasePlayer *pPlayer);
@@ -64,7 +67,6 @@ public:
 	edict_t *GetPlayerSpawnSpot_(CBasePlayer *pPlayer);
 	void PlayerKilled_(CBasePlayer *pVictim, entvars_t *pKiller, entvars_t *pInflictor);
 	int ItemShouldRespawn_(CItem *pItem);
-	//void CheckMapConditions_(void) {}
 	void CheckWinConditions_(void);
 
 #endif // HOOK_GAMEDLL
@@ -72,7 +74,8 @@ public:
 public:
 	static void HostageDied(void);
 	static bool PlayerCanBuy(CBasePlayer *pPlayer);
-private:
+
+//private:
 	float FillAccountTime;
 	float ServerRestartTime;
 	BOOL fInBuyArea;
@@ -85,16 +88,16 @@ private:
 class CBaseGrenCatch: public CBaseEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual int Save(CSave &save);
+	virtual int Save(CSave &save);
-	NOBODY virtual int Restore(CRestore &restore);
+	virtual int Restore(CRestore &restore);
-	NOBODY virtual int ObjectCaps(void)
+	virtual int ObjectCaps(void)
 	{
 		return ObjectCaps_();
 	}
-	NOBODY virtual void Think(void);
+	virtual void Think(void);
-	NOBODY virtual void Touch(CBaseEntity *pOther);
+	virtual void Touch(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
 
@@ -126,11 +129,11 @@ public:
 class CFuncWeaponCheck: public CBaseEntity
 {
 public:
-	NOBODY virtual void Spawn(void);
+	virtual void Spawn(void);
-	NOBODY virtual void KeyValue(KeyValueData *pkvd);
+	virtual void KeyValue(KeyValueData *pkvd);
-	NOBODY virtual int Save(CSave &save);
+	virtual int Save(CSave &save);
-	NOBODY virtual int Restore(CRestore &restore);
+	virtual int Restore(CRestore &restore);
-	NOBODY virtual void Touch(CBaseEntity *pOther);
+	virtual void Touch(CBaseEntity *pOther);
 
 #ifdef HOOK_GAMEDLL
 
@@ -155,4 +158,8 @@ private:
 
 };/* size: 300, cachelines: 5, members: 8 */
 
+// linked objects
+C_DLLEXPORT void func_grencatch(entvars_t *pev);
+C_DLLEXPORT void func_weaponcheck(entvars_t *pev);
+
 #endif // TRAINING_GAMERULES_H

regamedll/dlls/triggers.cpp

@@ -78,7 +78,7 @@ LINK_ENTITY_TO_CLASS(func_friction, CFrictionModifier);
 IMPLEMENT_SAVERESTORE(CFrictionModifier, CBaseEntity);
 
 /* <19fa7d> ../cstrike/dlls/triggers.cpp:72 */
-NOBODY void CFrictionModifier::Spawn_(void)
+NOBODY void CFrictionModifier::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -88,7 +88,7 @@ NOBODY void CFrictionModifier::ChangeFriction(CBaseEntity *pOther)
 }
 
 /* <1a1c39> ../cstrike/dlls/triggers.cpp:91 */
-NOBODY void CFrictionModifier::KeyValue_(KeyValueData *pkvd)
+NOBODY void CFrictionModifier::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 }
 
@@ -99,7 +99,7 @@ LINK_ENTITY_TO_CLASS(trigger_auto, CAutoTrigger);
 IMPLEMENT_SAVERESTORE(CAutoTrigger, CBaseDelay);
 
 /* <1a1b64> ../cstrike/dlls/triggers.cpp:136 */
-NOBODY void CAutoTrigger::KeyValue_(KeyValueData *pkvd)
+NOBODY void CAutoTrigger::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   138
@@ -114,17 +114,17 @@ NOBODY void CAutoTrigger::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <19fb05> ../cstrike/dlls/triggers.cpp:165 */
-NOBODY void CAutoTrigger::Spawn_(void)
+NOBODY void CAutoTrigger::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <19fb2d> ../cstrike/dlls/triggers.cpp:171 */
-NOBODY void CAutoTrigger::Precache_(void)
+NOBODY void CAutoTrigger::__MAKE_VHOOK(Precache)(void)
 {
 }
 
 /* <19d48c> ../cstrike/dlls/triggers.cpp:177 */
-NOBODY void CAutoTrigger::Think_(void)
+NOBODY void CAutoTrigger::__MAKE_VHOOK(Think)(void)
 {
 }
 
@@ -135,7 +135,7 @@ LINK_ENTITY_TO_CLASS(trigger_relay, CTriggerRelay);
 IMPLEMENT_SAVERESTORE(CTriggerRelay, CBaseDelay);
 
 /* <1a1abc> ../cstrike/dlls/triggers.cpp:216 */
-NOBODY void CTriggerRelay::KeyValue_(KeyValueData *pkvd)
+NOBODY void CTriggerRelay::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   218
@@ -144,12 +144,12 @@ NOBODY void CTriggerRelay::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <19fb7e> ../cstrike/dlls/triggers.cpp:240 */
-NOBODY void CTriggerRelay::Spawn_(void)
+NOBODY void CTriggerRelay::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <1a01d7> ../cstrike/dlls/triggers.cpp:247 */
-NOBODY void CTriggerRelay::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CTriggerRelay::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 }
 
@@ -160,7 +160,7 @@ LINK_ENTITY_TO_CLASS(multi_manager, CMultiManager);
 IMPLEMENT_SAVERESTORE(CMultiManager, CBaseToggle);
 
 /* <1a19ed> ../cstrike/dlls/triggers.cpp:318 */
-NOBODY void CMultiManager::KeyValue_(KeyValueData *pkvd)
+NOBODY void CMultiManager::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   325
@@ -173,7 +173,7 @@ NOBODY void CMultiManager::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <19fbce> ../cstrike/dlls/triggers.cpp:347 */
-NOBODY void CMultiManager::Spawn_(void)
+NOBODY void CMultiManager::__MAKE_VHOOK(Spawn)(void)
 {
 //	{
 //		int swapped;                                          //   355
@@ -188,7 +188,7 @@ NOBODY void CMultiManager::Spawn_(void)
 }
 
 /* <1a03e5> ../cstrike/dlls/triggers.cpp:377 */
-NOBODY void CMultiManager::Restart_(void)
+NOBODY void CMultiManager::__MAKE_VHOOK(Restart)(void)
 {
 //	{
 //		int i;                                                //   379
@@ -206,7 +206,7 @@ NOBODY void CMultiManager::Restart_(void)
 }
 
 /* <1a1402> ../cstrike/dlls/triggers.cpp:420 */
-NOBODY BOOL CMultiManager::HasTarget_(string_t targetname)
+NOBODY BOOL CMultiManager::__MAKE_VHOOK(HasTarget)(string_t targetname)
 {
 //	{
 //		int i;                                                //   422
@@ -230,12 +230,12 @@ NOBODY CMultiManager *CMultiManager::Clone(void)
 	CMultiManager *pMulti = GetClassPtr((CMultiManager *)NULL);
 	edict_t *pEdict = pMulti->pev->pContainingEntity;
 
-	memcpy(pMulti->pev, pev, sizeof(*pev));
+	Q_memcpy(pMulti->pev, pev, sizeof(*pev));
 	pMulti->pev->pContainingEntity = pEdict;
 	pMulti->pev->spawnflags |= SF_MULTIMAN_CLONE;
 	pMulti->m_cTargets = m_cTargets;
-	memcpy(pMulti->m_iTargetName, m_iTargetName, sizeof(m_iTargetName));
+	Q_memcpy(pMulti->m_iTargetName, m_iTargetName, sizeof(m_iTargetName));
-	memcpy(pMulti->m_flTargetDelay, m_flTargetDelay, sizeof(m_flTargetDelay));
+	Q_memcpy(pMulti->m_flTargetDelay, m_flTargetDelay, sizeof(m_flTargetDelay));
 	return pMulti;
 }
 
@@ -252,12 +252,12 @@ NOBODY void CMultiManager::ManagerUse(CBaseEntity *pActivator, CBaseEntity *pCal
 LINK_ENTITY_TO_CLASS(env_render, CRenderFxManager);
 
 /* <19fc52> ../cstrike/dlls/triggers.cpp:535 */
-NOBODY void CRenderFxManager::Spawn_(void)
+NOBODY void CRenderFxManager::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <1a0c95> ../cstrike/dlls/triggers.cpp:540 */
-NOBODY void CRenderFxManager::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CRenderFxManager::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	Use(class CRenderFxManager *const this,
 //		class CBaseEntity *pActivator,
@@ -277,7 +277,7 @@ NOBODY void CBaseTrigger::InitTrigger(void)
 }
 
 /* <1a17cf> ../cstrike/dlls/triggers.cpp:608 */
-NOBODY void CBaseTrigger::KeyValue_(KeyValueData *pkvd)
+NOBODY void CBaseTrigger::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   610
@@ -296,18 +296,18 @@ LINK_ENTITY_TO_CLASS(trigger_hurt, CTriggerHurt);
 LINK_ENTITY_TO_CLASS(trigger_monsterjump, CTriggerMonsterJump);
 
 /* <1a2fdc> ../cstrike/dlls/triggers.cpp:652 */
-NOBODY void CTriggerMonsterJump::Spawn_(void)
+NOBODY void CTriggerMonsterJump::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(class CTriggerMonsterJump *const this);  //   652
 }
 
 /* <1a00e4> ../cstrike/dlls/triggers.cpp:671 */
-NOBODY void CTriggerMonsterJump::Think_(void)
+NOBODY void CTriggerMonsterJump::__MAKE_VHOOK(Think)(void)
 {
 }
 
 /* <19fca2> ../cstrike/dlls/triggers.cpp:678 */
-NOBODY void CTriggerMonsterJump::Touch_(CBaseEntity *pOther)
+NOBODY void CTriggerMonsterJump::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
 //	{
 //		entvars_t *pevOther;                                 //   680
@@ -320,18 +320,18 @@ NOBODY void CTriggerMonsterJump::Touch_(CBaseEntity *pOther)
 LINK_ENTITY_TO_CLASS(trigger_cdaudio, CTriggerCDAudio);
 
 /* <1a2382> ../cstrike/dlls/triggers.cpp:721 */
-NOBODY void CTriggerCDAudio::Touch_(CBaseEntity *pOther)
+NOBODY void CTriggerCDAudio::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
 //	PlayTrack(class CTriggerCDAudio *const this);  //   728
 }
 
 /* <1a2fb4> ../cstrike/dlls/triggers.cpp:731 */
-NOBODY void CTriggerCDAudio::Spawn_(void)
+NOBODY void CTriggerCDAudio::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <1a2288> ../cstrike/dlls/triggers.cpp:736 */
-NOBODY void CTriggerCDAudio::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CTriggerCDAudio::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	PlayTrack(class CTriggerCDAudio *const this);  //   738
 }
@@ -357,7 +357,7 @@ NOBODY void CTriggerCDAudio::PlayTrack(void)
 LINK_ENTITY_TO_CLASS(target_cdaudio, CTargetCDAudio);
 
 /* <1a170f> ../cstrike/dlls/triggers.cpp:796 */
-NOBODY void CTargetCDAudio::KeyValue_(KeyValueData *pkvd)
+NOBODY void CTargetCDAudio::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //   798
@@ -368,19 +368,19 @@ NOBODY void CTargetCDAudio::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <1a066a> ../cstrike/dlls/triggers.cpp:807 */
-NOBODY void CTargetCDAudio::Spawn_(void)
+NOBODY void CTargetCDAudio::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(class CTargetCDAudio *const this);  //   807
 }
 
 /* <1a2175> ../cstrike/dlls/triggers.cpp:816 */
-NOBODY void CTargetCDAudio::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CTargetCDAudio::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	Play(class CTargetCDAudio *const this);  //   818
 }
 
 /* <1a2465> ../cstrike/dlls/triggers.cpp:822 */
-NOBODY void CTargetCDAudio::Think_(void)
+NOBODY void CTargetCDAudio::__MAKE_VHOOK(Think)(void)
 {
 //	{
 //		edict_t *pClient;                                    //   824
@@ -398,7 +398,7 @@ NOBODY void CTargetCDAudio::Play(void)
 }
 
 /* <1a2f8b> ../cstrike/dlls/triggers.cpp:853 */
-NOBODY void CTriggerHurt::Spawn_(void)
+NOBODY void CTriggerHurt::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -427,7 +427,7 @@ NOBODY void CBaseTrigger::HurtTouch(CBaseEntity *pOther)
 LINK_ENTITY_TO_CLASS(trigger_multiple, CTriggerMultiple);
 
 /* <1a2f67> ../cstrike/dlls/triggers.cpp:1089 */
-NOBODY void CTriggerMultiple::Spawn_(void)
+NOBODY void CTriggerMultiple::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -435,7 +435,7 @@ NOBODY void CTriggerMultiple::Spawn_(void)
 LINK_ENTITY_TO_CLASS(trigger_once, CTriggerOnce);
 
 /* <1a301c> ../cstrike/dlls/triggers.cpp:1136 */
-NOBODY void CTriggerOnce::Spawn_(void)
+NOBODY void CTriggerOnce::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(class CTriggerMultiple *const this);  //  1140
 }
@@ -479,7 +479,7 @@ NOBODY void CBaseTrigger::CounterUse(CBaseEntity *pActivator, CBaseEntity *pCall
 LINK_ENTITY_TO_CLASS(trigger_counter, CTriggerCounter);
 
 /* <19fd42> ../cstrike/dlls/triggers.cpp:1280 */
-NOBODY void CTriggerCounter::Spawn_(void)
+NOBODY void CTriggerCounter::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -487,7 +487,7 @@ NOBODY void CTriggerCounter::Spawn_(void)
 LINK_ENTITY_TO_CLASS(trigger_transition, CTriggerVolume);
 
 /* <19fd6a> ../cstrike/dlls/triggers.cpp:1302 */
-NOBODY void CTriggerVolume::Spawn_(void)
+NOBODY void CTriggerVolume::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -495,19 +495,19 @@ NOBODY void CTriggerVolume::Spawn_(void)
 LINK_ENTITY_TO_CLASS(fireanddie, CFireAndDie);
 
 /* <1a0618> ../cstrike/dlls/triggers.cpp:1323 */
-NOBODY void CFireAndDie::Spawn_(void)
+NOBODY void CFireAndDie::__MAKE_VHOOK(Spawn)(void)
 {
 //	MAKE_STRING_CLASS(const char *str,
 //				entvars_t *pev);  //  1325
 }
 
 /* <19fdbb> ../cstrike/dlls/triggers.cpp:1330 */
-NOBODY void CFireAndDie::Precache_(void)
+NOBODY void CFireAndDie::__MAKE_VHOOK(Precache)(void)
 {
 }
 
 /* <1a01ae> ../cstrike/dlls/triggers.cpp:1337 */
-NOBODY void CFireAndDie::Think_(void)
+NOBODY void CFireAndDie::__MAKE_VHOOK(Think)(void)
 {
 }
 
@@ -518,7 +518,7 @@ LINK_ENTITY_TO_CLASS(trigger_changelevel, CChangeLevel);
 IMPLEMENT_SAVERESTORE(CChangeLevel, CBaseTrigger);
 
 /* <1a1d4a> ../cstrike/dlls/triggers.cpp:1388 */
-NOBODY void CChangeLevel::KeyValue_(KeyValueData *pkvd)
+NOBODY void CChangeLevel::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //  1390
@@ -527,7 +527,7 @@ NOBODY void CChangeLevel::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <1a2f25> ../cstrike/dlls/triggers.cpp:1423 */
-NOBODY void CChangeLevel::Spawn_(void)
+NOBODY void CChangeLevel::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -545,7 +545,7 @@ NOBODY void CChangeLevel::ExecuteChangeLevel(void)
 }
 
 /* <1a3b43> ../cstrike/dlls/triggers.cpp:1456 */
-NOXREF edict_t *CChangeLevel::FindLandmark(const char *pLandmarkName)
+edict_t *CChangeLevel::FindLandmark(const char *pLandmarkName)
 {
 	edict_t	*pentLandmark = FIND_ENTITY_BY_STRING(NULL, "targetname", pLandmarkName);
 	while (!FNullEnt(pentLandmark))
@@ -556,6 +556,7 @@ NOXREF edict_t *CChangeLevel::FindLandmark(const char *pLandmarkName)
 		else
 			pentLandmark = FIND_ENTITY_BY_STRING(pentLandmark, "targetname", pLandmarkName);
 	}
+
 	ALERT(at_error, "Can't find landmark %s\n", pLandmarkName);
 	return NULL;
 }
@@ -595,12 +596,34 @@ NOBODY void CChangeLevel::TouchChangeLevel(CBaseEntity *pOther)
 //			class CBaseEntity *pActivator);  //  1550
 }
 
+// Add a transition to the list, but ignore duplicates 
+// (a designer may have placed multiple trigger_changelevels with the same landmark)
+
 /* <1a3ff8> ../cstrike/dlls/triggers.cpp:1556 */
-NOBODY int CChangeLevel::AddTransitionToList(LEVELLIST *pLevelList, int listCount, const char *pMapName, const char *pLandmarkName, edict_t *pentLandmark)
+int CChangeLevel::AddTransitionToList(LEVELLIST *pLevelList, int listCount, const char *pMapName, const char *pLandmarkName, edict_t *pentLandmark)
 {
-//	{
+	int i;
-//		int i;                                                //  1558
+
-//	} 
+	if (!pLevelList || !pMapName || !pLandmarkName || !pentLandmark)
+	{
+		return 0;
+	}
+
+	for (i = 0; i < listCount; i++)
+	{
+		if (pLevelList[i].pentLandmark == pentLandmark && Q_strcmp(pLevelList[i].mapName, pMapName) == 0)
+		{
+			return 0;
+		}
+	}
+
+	Q_strcpy(pLevelList[ listCount ].mapName, pMapName);
+	Q_strcpy(pLevelList[ listCount ].landmarkName, pLandmarkName);
+
+	pLevelList[ listCount ].pentLandmark = pentLandmark;
+	pLevelList[ listCount ].vecLandmarkOrigin = VARS(pentLandmark)->origin;
+
+	return 1;
 }
 
 /* <1a44ba> ../cstrike/dlls/triggers.cpp:1576 */
@@ -610,16 +633,57 @@ NOBODY int BuildChangeList(LEVELLIST *pLevelList, int maxList)
 }
 
 /* <1a4075> ../cstrike/dlls/triggers.cpp:1582 */
-NOBODY int CChangeLevel::InTransitionVolume(CBaseEntity *pEntity, char *pVolumeName)
+int CChangeLevel::InTransitionVolume(CBaseEntity *pEntity, char *pVolumeName)
 {
-//	{
+	edict_t	*pentVolume;
-//		edict_t *pentVolume;                                 //  1584
+
-//		int inVolume;                                         //  1597
+	if (pEntity->ObjectCaps() & FCAP_FORCE_TRANSITION)
-//	} 
+	{
+		return 1;
+	}
+
+	// If you're following another entity, follow it through the transition (weapons follow the player)
+	if (pEntity->pev->movetype == MOVETYPE_FOLLOW)
+	{
+		if (pEntity->pev->aiment != NULL)
+		{
+			pEntity = CBaseEntity::Instance(pEntity->pev->aiment);
+		}
+	}
+
+	// Unless we find a trigger_transition, everything is in the volume
+	int inVolume = 1;
+
+	pentVolume = FIND_ENTITY_BY_TARGETNAME(NULL, pVolumeName);
+	while (!FNullEnt(pentVolume))
+	{
+		CBaseEntity *pVolume = CBaseEntity::Instance(pentVolume);
+
+		if (pVolume && FClassnameIs(pVolume->pev, "trigger_transition"))
+		{
+			// It touches one, it's in the volume
+			if (pVolume->Intersects(pEntity))
+				return 1;
+			else
+			{
+				// Found a trigger_transition, but I don't intersect it -- if I don't find another, don't go!
+				inVolume = 0;
+			}
+		}
+
+		pentVolume = FIND_ENTITY_BY_TARGETNAME(pentVolume, pVolumeName);
+	}
+
+	return inVolume;
 }
 
+// This has grown into a complicated beast
+// Can we make this more elegant?
+// This builds the list of all transitions on this level and which entities are in their PVS's and can / should
+// be moved across.
+
 /* <1a40b1> ../cstrike/dlls/triggers.cpp:1625 */
-NOBODY int CChangeLevel::ChangeList(LEVELLIST *pLevelList, int maxList)
+int CChangeLevel::ChangeList(LEVELLIST *pLevelList, int maxList)
 {
 	edict_t	*pentChangelevel, *pentLandmark;
 	int i, count = 0;
@@ -634,7 +698,7 @@ NOBODY int CChangeLevel::ChangeList(LEVELLIST *pLevelList, int maxList)
 	{
 		CChangeLevel *pTrigger = GetClassPtr((CChangeLevel *)VARS(pentChangelevel));
 
-		if (pTrigger)
+		if (pTrigger != NULL)
 		{
 			// Find the corresponding landmark
 			pentLandmark = FindLandmark(pTrigger->m_szLandmarkName);
@@ -645,11 +709,13 @@ NOBODY int CChangeLevel::ChangeList(LEVELLIST *pLevelList, int maxList)
 				{
 					count++;
 
+					// FULL!!
 					if (count >= maxList)
 						break;
 				}
 			}
 		}
+
 		pentChangelevel = FIND_ENTITY_BY_STRING(pentChangelevel, "classname", "trigger_changelevel");
 	}
 
@@ -692,7 +758,9 @@ NOBODY int CChangeLevel::ChangeList(LEVELLIST *pLevelList, int maxList)
 							entityCount++;
 
 							if (entityCount > MAX_ENTITY)
+							{
 								ALERT( at_error, "Too many entities across a transition!" );
+							}
 						}
 					}
 				}
@@ -735,17 +803,17 @@ NOBODY void NextLevel(void)
 LINK_ENTITY_TO_CLASS(func_ladder, CLadder);
 
 /* <1a1937> ../cstrike/dlls/triggers.cpp:1763 */
-NOBODY void CLadder::KeyValue_(KeyValueData *pkvd)
+NOBODY void CLadder::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 }
 
 /* <19fe6c> ../cstrike/dlls/triggers.cpp:1772 */
-NOBODY void CLadder::Precache_(void)
+NOBODY void CLadder::__MAKE_VHOOK(Precache)(void)
 {
 }
 
 /* <19fe95> ../cstrike/dlls/triggers.cpp:1786 */
-NOBODY void CLadder::Spawn_(void)
+NOBODY void CLadder::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -753,19 +821,19 @@ NOBODY void CLadder::Spawn_(void)
 LINK_ENTITY_TO_CLASS(trigger_push, CTriggerPush);
 
 /* <1a18ff> ../cstrike/dlls/triggers.cpp:1807 */
-NOBODY void CTriggerPush::KeyValue_(KeyValueData *pkvd)
+NOBODY void CTriggerPush::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 }
 
 /* <1a2eda> ../cstrike/dlls/triggers.cpp:1817 */
-NOBODY void CTriggerPush::Spawn_(void)
+NOBODY void CTriggerPush::__MAKE_VHOOK(Spawn)(void)
 {
 //	operator==(const class Vector *const this,
 //			const class Vector  &const v);  //  1819
 }
 
 /* <1a023c> ../cstrike/dlls/triggers.cpp:1835 */
-NOBODY void CTriggerPush::Touch_(CBaseEntity *pOther)
+NOBODY void CTriggerPush::__MAKE_VHOOK(Touch)(CBaseEntity *pOther)
 {
 //	{
 //		entvars_t *pevToucher;                               //  1837
@@ -802,7 +870,7 @@ NOBODY void CBaseTrigger::TeleportTouch(CBaseEntity *pOther)
 LINK_ENTITY_TO_CLASS(trigger_teleport, CTriggerTeleport);
 
 /* <1a2eb1> ../cstrike/dlls/triggers.cpp:1942 */
-NOBODY void CTriggerTeleport::Spawn_(void)
+NOBODY void CTriggerTeleport::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -813,7 +881,7 @@ LINK_ENTITY_TO_CLASS(info_teleport_destination, CPointEntity);
 LINK_ENTITY_TO_CLASS(func_buyzone, CBuyZone);
 
 /* <1a2e71> ../cstrike/dlls/triggers.cpp:1973 */
-NOBODY void CBuyZone::Spawn_(void)
+NOBODY void CBuyZone::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(class CBuyZone *const this);  //  1973
 }
@@ -832,7 +900,7 @@ NOBODY void CBuyZone::BuyTouch(CBaseEntity *pOther)
 LINK_ENTITY_TO_CLASS(func_bomb_target, CBombTarget);
 
 /* <1a2e48> ../cstrike/dlls/triggers.cpp:2019 */
-NOBODY void CBombTarget::Spawn_(void)
+NOBODY void CBombTarget::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -855,7 +923,7 @@ NOBODY void CBombTarget::BombTargetUse(CBaseEntity *pActivator, CBaseEntity *pCa
 LINK_ENTITY_TO_CLASS(func_hostage_rescue, CHostageRescue);
 
 /* <1a2e1f> ../cstrike/dlls/triggers.cpp:2067 */
-NOBODY void CHostageRescue::Spawn_(void)
+NOBODY void CHostageRescue::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -870,7 +938,7 @@ NOBODY void CHostageRescue::HostageRescueTouch(CBaseEntity *pOther)
 LINK_ENTITY_TO_CLASS(func_escapezone, CEscapeZone);
 
 /* <1a2df6> ../cstrike/dlls/triggers.cpp:2108 */
-NOBODY void CEscapeZone::Spawn_(void)
+NOBODY void CEscapeZone::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -890,7 +958,7 @@ NOBODY void CEscapeZone::EscapeTouch(CBaseEntity *pOther)
 LINK_ENTITY_TO_CLASS(func_vip_safetyzone, CVIP_SafetyZone);
 
 /* <1a2dcd> ../cstrike/dlls/triggers.cpp:2166 */
-NOBODY void CVIP_SafetyZone::Spawn_(void)
+NOBODY void CVIP_SafetyZone::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -910,7 +978,7 @@ NOBODY void CVIP_SafetyZone::VIP_SafetyTouch(CBaseEntity *pOther)
 LINK_ENTITY_TO_CLASS(trigger_autosave, CTriggerSave);
 
 /* <1a2d8e> ../cstrike/dlls/triggers.cpp:2206 */
-NOBODY void CTriggerSave::Spawn_(void)
+NOBODY void CTriggerSave::__MAKE_VHOOK(Spawn)(void)
 {
 	//Spawn(class CTriggerSave *const this);  //  2206
 }
@@ -936,7 +1004,7 @@ NOBODY void CTriggerEndSection::EndSectionUse(CBaseEntity *pActivator, CBaseEnti
 }
 
 /* <1a2d4f> ../cstrike/dlls/triggers.cpp:2260 */
-NOBODY void CTriggerEndSection::Spawn_(void)
+NOBODY void CTriggerEndSection::__MAKE_VHOOK(Spawn)(void)
 {
 //	Spawn(class CTriggerEndSection *const this);  //  2260
 }
@@ -949,7 +1017,7 @@ NOBODY void CTriggerEndSection::EndSectionTouch(CBaseEntity *pOther)
 }
 
 /* <1a196f> ../cstrike/dlls/triggers.cpp:2291 */
-NOBODY void CTriggerEndSection::KeyValue_(KeyValueData *pkvd)
+NOBODY void CTriggerEndSection::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //  2293
@@ -961,7 +1029,7 @@ NOBODY void CTriggerEndSection::KeyValue_(KeyValueData *pkvd)
 LINK_ENTITY_TO_CLASS(trigger_gravity, CTriggerGravity);
 
 /* <1a2d26> ../cstrike/dlls/triggers.cpp:2313 */
-NOBODY void CTriggerGravity::Spawn_(void)
+NOBODY void CTriggerGravity::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
@@ -977,7 +1045,7 @@ LINK_ENTITY_TO_CLASS(trigger_changetarget, CTriggerChangeTarget);
 IMPLEMENT_SAVERESTORE(CTriggerChangeTarget, CBaseDelay);
 
 /* <1a1691> ../cstrike/dlls/triggers.cpp:2360 */
-NOBODY void CTriggerChangeTarget::KeyValue_(KeyValueData *pkvd)
+NOBODY void CTriggerChangeTarget::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //  2362
@@ -986,12 +1054,12 @@ NOBODY void CTriggerChangeTarget::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <19ff1f> ../cstrike/dlls/triggers.cpp:2371 */
-NOBODY void CTriggerChangeTarget::Spawn_(void)
+NOBODY void CTriggerChangeTarget::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <1a010d> ../cstrike/dlls/triggers.cpp:2376 */
-NOBODY void CTriggerChangeTarget::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CTriggerChangeTarget::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	{ 
 //		class CBaseEntity *pTarget;                          //  2378
@@ -1008,12 +1076,12 @@ LINK_ENTITY_TO_CLASS(trigger_camera, CTriggerCamera);
 IMPLEMENT_SAVERESTORE(CTriggerCamera, CBaseDelay);
 
 /* <19ff6f> ../cstrike/dlls/triggers.cpp:2447 */
-NOBODY void CTriggerCamera::Spawn_(void)
+NOBODY void CTriggerCamera::__MAKE_VHOOK(Spawn)(void)
 {
 }
 
 /* <1a1537> ../cstrike/dlls/triggers.cpp:2462 */
-NOBODY void CTriggerCamera::KeyValue_(KeyValueData *pkvd)
+NOBODY void CTriggerCamera::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //  2464
@@ -1025,7 +1093,7 @@ NOBODY void CTriggerCamera::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <1a55e4> ../cstrike/dlls/triggers.cpp:2490 */
-NOBODY void CTriggerCamera::Use_(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
+NOBODY void CTriggerCamera::__MAKE_VHOOK(Use)(CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value)
 {
 //	Use(CTriggerCamera *const this,
 //		class CBaseEntity *pActivator,
@@ -1081,7 +1149,7 @@ LINK_ENTITY_TO_CLASS(env_rain, CWeather);
 LINK_ENTITY_TO_CLASS(func_rain, CWeather);
 
 /* <1a1477> ../cstrike/dlls/triggers.cpp:2716 */
-NOBODY void CClientFog::KeyValue_(KeyValueData *pkvd)
+NOBODY void CClientFog::__MAKE_VHOOK(KeyValue)(KeyValueData *pkvd)
 {
 //	FStrEq(const char *sz1,
 //		const char *sz2);  //  2718
@@ -1092,7 +1160,7 @@ NOBODY void CClientFog::KeyValue_(KeyValueData *pkvd)
 }
 
 /* <19ff97> ../cstrike/dlls/triggers.cpp:2735 */
-NOBODY void CClientFog::Spawn_(void)
+NOBODY void CClientFog::__MAKE_VHOOK(Spawn)(void)
 {
 }
 

regamedll/dlls/triggers.h

@@ -32,33 +32,29 @@
 #pragma once
 #endif
 
-#define savesolid team
+#define GRENADETYPE_SMOKE			1
+#define GRENADETYPE_FLASH			2
 
-#define GRENADETYPE_SMOKE 1
+#define MAX_ITEM_COUNTS				32
-#define GRENADETYPE_FLASH 2
+#define MAX_ENTITY				512	// We can only ever move 512 entities across a transition
 
-#define MAX_ITEM_COUNTS 32
+#define SF_TRIGGER_PUSH_START_OFF		2
+#define SF_TRIGGER_HURT_TARGETONCE		1
+#define SF_TRIGGER_HURT_START_OFF		2
+#define SF_TRIGGER_HURT_NO_CLIENTS		8
+#define SF_TRIGGER_HURT_CLIENTONLYFIRE		16
+#define SF_TRIGGER_HURT_CLIENTONLYTOUCH		32
 
-#define SF_TRIGGER_PUSH_START_OFF 2
+#define SF_AUTO_FIREONCE			0x0001
-#define SF_TRIGGER_HURT_TARGETONCE 1
+#define SF_RELAY_FIREONCE			0x0001
-#define SF_TRIGGER_HURT_START_OFF 2
-#define SF_TRIGGER_HURT_NO_CLIENTS 8
-#define SF_TRIGGER_HURT_CLIENTONLYFIRE 16
-#define SF_TRIGGER_HURT_CLIENTONLYTOUCH 32
 
-#define SF_AUTO_FIREONCE 0x0001
+#define SF_MULTIMAN_CLONE			0x80000000
-#define SF_RELAY_FIREONCE 0x0001
+#define SF_MULTIMAN_THREAD			0x00000001
 
-#define SF_MULTIMAN_CLONE 0x80000000
+#define SF_CHANGELEVEL_USEONLY			0x0002
-#define SF_MULTIMAN_THREAD 0x00000001
+#define SF_CAMERA_PLAYER_POSITION		1
-
+#define SF_CAMERA_PLAYER_TARGET			2
-#define SF_CHANGELEVEL_USEONLY 0x0002
+#define SF_CAMERA_PLAYER_TAKECONTROL		4
-
-#define MAX_ENTITY 512
-
-#define SF_CAMERA_PLAYER_POSITION 1
-#define SF_CAMERA_PLAYER_TARGET 2
-#define SF_CAMERA_PLAYER_TAKECONTROL 4
 
 class CFrictionModifier: public CBaseEntity
 {
@@ -469,10 +465,10 @@ public:
 
 	NOBODY void ChangeLevelNow(CBaseEntity *pActivator);
 
-	NOXREF static edict_t *FindLandmark(const char *pLandmarkName);
+	static edict_t *FindLandmark(const char *pLandmarkName);
-	NOBODY static int ChangeList(LEVELLIST *pLevelList, int maxList);
+	static int ChangeList(LEVELLIST *pLevelList, int maxList);
-	NOBODY static int AddTransitionToList(LEVELLIST *pLevelList, int listCount, const char *pMapName, const char *pLandmarkName, edict_t *pentLandmark);
+	static int AddTransitionToList(LEVELLIST *pLevelList, int listCount, const char *pMapName, const char *pLandmarkName, edict_t *pentLandmark);
-	NOBODY static int InTransitionVolume(CBaseEntity *pEntity, char *pVolumeName);
+	static int InTransitionVolume(CBaseEntity *pEntity, char *pVolumeName);
 
 public:
 	static TYPEDESCRIPTION IMPLEMENT_ARRAY(m_SaveData)[4];

regamedll/dlls/tutor.cpp

@@ -5,16 +5,16 @@
 */
 #ifndef HOOK_GAMEDLL
 
-cvar_t cv_tutor_message_repeats = { "_tutor_message_repeats", "5", FCVAR_SERVER };
+cvar_t cv_tutor_message_repeats = { "_tutor_message_repeats", "5", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_tutor_debug_level = { "_tutor_debug_level", "0", FCVAR_SERVER };
+cvar_t cv_tutor_debug_level = { "_tutor_debug_level", "0", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_tutor_view_distance = { "_tutor_view_distance", "1000", FCVAR_SERVER };
+cvar_t cv_tutor_view_distance = { "_tutor_view_distance", "1000", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_tutor_viewable_check_interval = { "_tutor_bomb_viewable_check_interval", "0.5", FCVAR_SERVER };
+cvar_t cv_tutor_viewable_check_interval = { "_tutor_bomb_viewable_check_interval", "0.5", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_tutor_look_distance = { "_tutor_look_distance", "200", FCVAR_SERVER };
+cvar_t cv_tutor_look_distance = { "_tutor_look_distance", "200", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_tutor_look_angle = { "_tutor_look_angle", "10", FCVAR_SERVER };
+cvar_t cv_tutor_look_angle = { "_tutor_look_angle", "10", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_tutor_examine_time = { "_tutor_examine_time", "0.5", FCVAR_SERVER };
+cvar_t cv_tutor_examine_time = { "_tutor_examine_time", "0.5", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_tutor_message_minimum_display_time = { "_tutor_message_minimum_display_time", "1", FCVAR_SERVER };
+cvar_t cv_tutor_message_minimum_display_time = { "_tutor_message_minimum_display_time", "1", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_tutor_message_character_display_time_coefficient = { "_tutor_message_character_display_time_coefficient", "0.07", FCVAR_SERVER };
+cvar_t cv_tutor_message_character_display_time_coefficient = { "_tutor_message_character_display_time_coefficient", "0.07", FCVAR_SERVER, 0.0f, NULL };
-cvar_t cv_tutor_hint_interval_time = { "_tutor_hint_interval_time", "10.0", FCVAR_SERVER };
+cvar_t cv_tutor_hint_interval_time = { "_tutor_hint_interval_time", "10.0", FCVAR_SERVER, 0.0f, NULL };
 
 #else
 
@@ -35,26 +35,18 @@ bool s_tutorDisabledThisGame;
 float s_nextCvarCheckTime;
 
 /* <1dfdbc> ../cstrike/dlls/tutor.cpp:32 */
-NOBODY void InstallTutor(bool start)
+void InstallTutor(bool start)
 {
-	// TODO: check out!
-	//if (TheTutor)
-	//{
-	//	(*((void (__cdecl **)(_DWORD))TheTutor->_vptr.CBaseTutor + 1))(TheTutor);
-	//	TheTutor = 0;
-	//}
-
 	if (TheTutor)
 	{
 		delete TheTutor;
-
+		TheTutor = NULL;
-
-		//TheTutor->~CBaseTutor();
-		//TheTutor = NULL;
 	}
 
 	if (start)
+	{
 		TheTutor = new CCSTutor;
+	}
 
 	s_tutorDisabledThisGame = false;
 	s_nextCvarCheckTime = gpGlobals->time;
@@ -76,24 +68,73 @@ void Tutor_RegisterCVars(void)
 }
 
 /* <1dfdff> ../cstrike/dlls/tutor.cpp:66 */
-NOBODY void MonitorTutorStatus(void)
+void MonitorTutorStatus(void)
 {
-//	{
+	static cvar_t *tutor_enable = NULL;
-//		cvar_t *tutor_enable;                                //    68
+	static bool tutor_enableCvarExists = true;
-//		bool tutor_enableCvarExists;                          //    69
+
-//		bool shouldTutorBeOn;                                 //    82
+	bool shouldTutorBeOn = false;
-//		int numHumans;                                        //    96
+	int numHumans = 0;
-//		{
+
-//			int i;                                        //    97
+	if (!tutor_enableCvarExists || s_nextCvarCheckTime > gpGlobals->time)
-//			{
+	{
-//				class CBasePlayer *pPlayer;          //    99
+		return;
-//			}
+	}
-//		}
+
-//		{
+	if (tutor_enable != NULL || (tutor_enable = CVAR_GET_POINTER("tutor_enable")) != NULL)
-//			class CBasePlayer *localPlayer;              //   125
+	{
-//		}
+		if (!s_tutorDisabledThisGame && tutor_enable->value > 0.0f)
-//		{
+		{
-//			class CBasePlayer *localPlayer;              //   113
+			shouldTutorBeOn = true;
-//		}
+		}
-//	}
+	}
+	else
+		tutor_enableCvarExists = false;
+	
+	for (int i = 1; i <= gpGlobals->maxClients; i++)
+	{
+		CBasePlayer *pPlayer = reinterpret_cast<CBasePlayer *>(UTIL_PlayerByIndex(i));
+
+		if (pPlayer && !pPlayer->IsBot())
+		{
+			++numHumans;
+		}
+	}
+
+	if (shouldTutorBeOn)
+	{
+		if (numHumans <= 1)
+		{
+			if (TheTutor == NULL)
+			{
+				CBasePlayer *localPlayer = UTIL_GetLocalPlayer();
+
+				if (localPlayer != NULL)
+				{
+					ClientPrint(localPlayer->pev, HUD_PRINTCENTER, "#CZero_Tutor_Turned_On");
+				}
+
+				TheTutor = new CCSTutor;
+			}
+		}
+		else
+			s_tutorDisabledThisGame = true;
+	}
+	else
+	{
+		if (TheTutor != NULL)
+		{
+			CBasePlayer *localPlayer = UTIL_GetLocalPlayer();
+
+			if (localPlayer != NULL)
+			{
+				ClientPrint(localPlayer->pev, HUD_PRINTCENTER, "#CZero_Tutor_Turned_Off");
+			}
+
+			delete TheTutor;
+			TheTutor = NULL;
+		}
+	}
+
+	s_nextCvarCheckTime = gpGlobals->time + 1.0f;
 }

regamedll/dlls/tutor.h

@@ -60,8 +60,8 @@ extern cvar_t cv_tutor_message_minimum_display_time;
 extern cvar_t cv_tutor_message_character_display_time_coefficient;
 extern cvar_t cv_tutor_hint_interval_time;
 
-NOBODY void InstallTutor(bool start);
+void InstallTutor(bool start);
 void Tutor_RegisterCVars(void);
-NOBODY void MonitorTutorStatus(void);
+void MonitorTutorStatus(void);
 
 #endif // TUTOR_H

regamedll/dlls/tutor_base_states.cpp

@@ -1,32 +1,42 @@
 #include "precompiled.h"
 
 /* <21bf94> ../cstrike/dlls/tutor_base_states.cpp:6 */
-NOBODY CBaseTutorStateSystem::CBaseTutorStateSystem(void)
+CBaseTutorStateSystem::CBaseTutorStateSystem(void)
 {
+	;
 }
 
 /* <21bec7> ../cstrike/dlls/tutor_base_states.cpp:10 */
-NOBODY CBaseTutorStateSystem::~CBaseTutorStateSystem(void)
+CBaseTutorStateSystem::~CBaseTutorStateSystem(void)
 {
+	;
 }
 
 /* <21bfb5> ../cstrike/dlls/tutor_base_states.cpp:14 */
-NOBODY int CBaseTutorStateSystem::GetCurrentStateType(void)
+int CBaseTutorStateSystem::GetCurrentStateType(void)
 {
-//	GetType(CBaseTutorState *const this);  //    20
+	if (m_currentState != NULL)
+	{
+		return m_currentState->GetType();
+	}
+
+	return 0;
 }
 
 /* <21c00d> ../cstrike/dlls/tutor_base_states.cpp:28 */
-NOBODY CBaseTutorState::CBaseTutorState(void)
+CBaseTutorState::CBaseTutorState(void)
 {
+	;
 }
 
 /* <21bcc6> ../cstrike/dlls/tutor_base_states.cpp:32 */
-NOBODY CBaseTutorState::~CBaseTutorState(void)
+CBaseTutorState::~CBaseTutorState(void)
 {
+	;
 }
 
 /* <21c02e> ../cstrike/dlls/tutor_base_states.cpp:36 */
-NOBODY int CBaseTutorState::GetType(void)
+int CBaseTutorState::GetType(void)
 {
+	return m_type;
 }

regamedll/dlls/tutor_base_states.h

@@ -36,28 +36,33 @@ class CBaseTutorState
 {
 public:
 	CBaseTutorState(void);
-	virtual ~CBaseTutorState(void);
 
+	virtual ~CBaseTutorState(void);
 	virtual int CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other) = 0;
 	virtual char *GetStateString(void) = 0;
+
 public:
 	int GetType(void);
-private:
+
+protected:
 	int m_type;
+
 };/* size: 8, cachelines: 1, members: 2 */
 
 class CBaseTutorStateSystem
 {
 public:
 	CBaseTutorStateSystem(void);
-	virtual ~CBaseTutorStateSystem(void);
 
+	virtual ~CBaseTutorStateSystem(void);
 	virtual bool UpdateState(GameEventType event, CBaseEntity *entity, CBaseEntity *other) = 0;
 	virtual char *GetCurrentStateString(void) = 0;
 	virtual CBaseTutorState *ConstructNewState(int stateType) = 0;
 	
+public:
 	int GetCurrentStateType(void);
-private:
+
+protected:
 	CBaseTutorState *m_currentState;
 
 };/* size: 8, cachelines: 1, members: 2 */

regamedll/dlls/tutor_base_tutor.cpp

@@ -3,79 +3,137 @@
 CBaseTutor *TheTutor;
 
 /* <1f545d> ../cstrike/dlls/tutor_base_tutor.cpp:22 */
-NOBODY TutorMessageEvent::TutorMessageEvent(int mid, int duplicateID, float time, float lifetime, int priority)
+TutorMessageEvent::TutorMessageEvent(int mid, int duplicateID, float time, float lifetime, int priority)
 {
+	m_messageID = mid;
+	m_duplicateID = duplicateID;
+	m_activationTime = time;
+	m_lifetime = lifetime;
+	m_priority = priority;
+
+	m_paramList = NULL;
+	m_numParameters = 0;
+	m_next = NULL;
 }
 
 /* <1f4d07> ../cstrike/dlls/tutor_base_tutor.cpp:34 */
-//NOBODY void TutorMessageEvent::~TutorMessageEvent(void)
+TutorMessageEvent::~TutorMessageEvent(void)
-//{
+{
-//}
+	;
+}
 
 /* <1f54a6> ../cstrike/dlls/tutor_base_tutor.cpp:38 */
-NOBODY bool TutorMessageEvent::IsActive(float time)
+bool TutorMessageEvent::IsActive(float time)
 {
+	return (m_lifetime + m_activationTime >= time);
 }
 
 /* <1f54da> ../cstrike/dlls/tutor_base_tutor.cpp:48 */
-NOBODY int TutorMessageEvent::GetPriority(void)
+int TutorMessageEvent::GetPriority(void)
 {
+	return m_priority;
 }
 
 /* <1f5500> ../cstrike/dlls/tutor_base_tutor.cpp:53 */
-NOBODY float TutorMessageEvent::GetTimeActive(float time)
+float TutorMessageEvent::GetTimeActive(float time)
 {
+	return (time - m_activationTime);
 }
 
 /* <1f5534> ../cstrike/dlls/tutor_base_tutor.cpp:58 */
-NOBODY void TutorMessageEvent::SetActivationTime(float time)
+void TutorMessageEvent::SetActivationTime(float time)
 {
+	m_activationTime = time;
 }
 
 /* <1f5568> ../cstrike/dlls/tutor_base_tutor.cpp:63 */
-NOBODY int TutorMessageEvent::GetID(void)
+int TutorMessageEvent::GetID(void)
 {
+	return m_messageID;
 }
 
 /* <1f5589> ../cstrike/dlls/tutor_base_tutor.cpp:68 */
-NOBODY int TutorMessageEvent::GetDuplicateID(void)
+int TutorMessageEvent::GetDuplicateID(void)
 {
+	return m_duplicateID;
 }
 
 /* <1f55af> ../cstrike/dlls/tutor_base_tutor.cpp:73 */
-NOBODY void TutorMessageEvent::SetNext(TutorMessageEvent *next)
+void TutorMessageEvent::SetNext(TutorMessageEvent *next)
 {
+	m_next = next;
 }
 
 /* <1f55e3> ../cstrike/dlls/tutor_base_tutor.cpp:78 */
-NOBODY TutorMessageEvent *TutorMessageEvent::GetNext(void)
+TutorMessageEvent *TutorMessageEvent::GetNext(void)
 {
+	return m_next;
 }
 
 /* <1f5604> ../cstrike/dlls/tutor_base_tutor.cpp:83 */
-NOBODY void TutorMessageEvent::AddParameter(char *str)
+void TutorMessageEvent::AddParameter(char *str)
 {
-//	{
+	if (str == NULL)
-//		class TutorMessageEventParam *param;                 //    88
+	{
-//		class TutorMessageEventParam *temp;                  //   101
+		return;
-//	}
+	}
+
+	TutorMessageEventParam *param = new TutorMessageEventParam;
+
+	param->m_next = NULL;
+	param->m_data = new char[Q_strlen(str) + 1];
+
+	if (param->m_data != NULL)
+	{
+		Q_strcpy(param->m_data, str);
+		param->m_data[Q_strlen(str)] = '\0';
+		++m_numParameters;
+
+		if (m_paramList != NULL)
+		{
+			TutorMessageEventParam *temp = m_paramList;
+
+			while (temp->m_next)
+				temp = temp->m_next;
+
+			temp->m_next = param;
+		}
+		else
+			m_paramList = param;
+	}
 }
 
 /* <1f565d> ../cstrike/dlls/tutor_base_tutor.cpp:117 */
-NOBODY char *TutorMessageEvent::GetNextParameter(char *buf, int buflen)
+char *TutorMessageEvent::GetNextParameter(char *buf, int buflen)
 {
-//	{
+	TutorMessageEventParam *param = m_paramList;
-//		class TutorMessageEventParam *param;                 //   119
+
-//	}
+	if (param == NULL)
+	{
+		return NULL;
+	}
+
+	m_numParameters--;
+	m_paramList = param->m_next;
+
+	Q_strncpy(buf, param->m_data, buflen);
+
+#ifdef REGAMEDLL_FIXES
+	buf[buflen] = '\0';
+#endif // REGAMEDLL_FIXES
+
+	delete param;
+	return buf;
 }
 
 /* <1f569e> ../cstrike/dlls/tutor_base_tutor.cpp:136 */
-NOBODY int TutorMessageEvent::GetNumParameters(void)
+int TutorMessageEvent::GetNumParameters(void)
 {
+	return m_numParameters;
 }
 
 /* <1f56d8> ../cstrike/dlls/tutor_base_tutor.cpp:144 */
-NOBODY CBaseTutor::CBaseTutor(void)
+CBaseTutor::CBaseTutor(void)
 {
 	m_eventList = NULL;
 	m_deadAirStartTime = 0;
@@ -83,15 +141,17 @@ NOBODY CBaseTutor::CBaseTutor(void)
 }
 
 /* <1f4d28> ../cstrike/dlls/tutor_base_tutor.cpp:152 */
-NOBODY CBaseTutor::~CBaseTutor(void)
+CBaseTutor::~CBaseTutor(void)
 {
-//	{
+	TutorMessageEvent *event = m_eventList;
-//		class TutorMessageEvent *event;				//   154
+
-//		{
+	while (event != NULL)
-//			class TutorMessageEvent *temp;			//   157
+	{
-//			GetNext(TutorMessageEvent *const this);		//   158
+		TutorMessageEvent *temp = event;
-//		}
+		event = event->GetNext();
-//	}
+
+		delete temp;
+	}
 }
 
 /* <1f5766> ../cstrike/dlls/tutor_base_tutor.cpp:163 */
@@ -102,52 +162,88 @@ void CBaseTutor::OnEvent(GameEventType event, CBaseEntity *entity, CBaseEntity *
 }
 
 /* <1f5842> ../cstrike/dlls/tutor_base_tutor.cpp:172 */
-NOBODY void CBaseTutor::ShotFired(Vector source, Vector target)
+void CBaseTutor::ShotFired(Vector source, Vector target)
 {
-//	Vector(Vector *const this,
+	HandleShotFired(source, target);
-//		const Vector &v);  //   175
-//	Vector(Vector *const this,
-//		const Vector &v);  //   175
 }
 
 /* <1f58ca> ../cstrike/dlls/tutor_base_tutor.cpp:178 */
-NOXREF void CBaseTutor::CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+void CBaseTutor::CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
 {
 	if (m_stateSystem->UpdateState(event, entity, other))
+	{
 		DisplayNewStateDescriptionToPlayer();
+	}
 }
 
 /* <1f58f5> ../cstrike/dlls/tutor_base_tutor.cpp:189 */
-NOBODY void CBaseTutor::StartFrame(float time)
+void CBaseTutor::StartFrame(float time)
 {
 	TutorThink(time);
 }
 
 /* <1f5993> ../cstrike/dlls/tutor_base_tutor.cpp:192 */
-NOBODY void CBaseTutor::DisplayMessageToPlayer(CBasePlayer *player, int id, const char *szMessage, TutorMessageEvent *event)
+void CBaseTutor::DisplayMessageToPlayer(CBasePlayer *player, int id, const char *szMessage, TutorMessageEvent *event)
 {
-//	{
+	TutorMessage *definition;
-//		class TutorMessage *definition;                      //   196
+	int numArgs;
-//		unsigned char numArgs;                                //   202
+	char param[512];
-//		char param;                                           //   207
+
-//		MESSAGE_BEGIN(int msg_dest,
+	numArgs = event->GetNumParameters();
-//				int msg_type,
+	definition = GetTutorMessageDefinition(event->GetID());
-//				const float *pOrigin,
+
-//				entvars_t *ent);  //   198
+	MESSAGE_BEGIN(MSG_ONE, gmsgTutorText, NULL, player->pev);
-//		{
+		WRITE_STRING(szMessage);
-//			int arg;                                      //   210
+		WRITE_BYTE(numArgs);
-//			{
+
-//				char *str;                           //   212
+		for (int arg = 0; arg < numArgs; arg++)
-//				GetNextParameter(TutorMessageEvent *const this,
+		{
-//						char *buf,
+			char *str = event->GetNextParameter(param, sizeof(param));
-//						int buflen);  //   212
+
-//			}
+			if (str != NULL)
-//		}
+				WRITE_STRING(str);
-//	}
+			else
+				WRITE_STRING("");
+		}
+
+		WRITE_SHORT(id);
+		WRITE_SHORT(player->IsAlive() == FALSE);
+
+		if (definition != NULL)
+			WRITE_SHORT(definition->m_type);
+		else
+			WRITE_SHORT(TUTORMESSAGETYPE_DEFAULT);
+	MESSAGE_END();
+
+	m_deadAirStartTime = -1.0f;
+
+	if (definition != NULL)
+	{
+		if (gpGlobals->time - m_roundStartTime > 1.0f)
+		{
+			switch (definition->m_type)
+			{
+			case TUTORMESSAGETYPE_FRIEND_DEATH:
+				EMIT_SOUND_DYN(ENT(player->pev), CHAN_ITEM, "events/friend_died.wav", VOL_NORM, ATTN_NORM, 0, 120);
+				break;
+			case TUTORMESSAGETYPE_ENEMY_DEATH:
+				EMIT_SOUND_DYN(ENT(player->pev), CHAN_ITEM, "events/enemy_died.wav", VOL_NORM, ATTN_NORM, 0, 85);
+				break;
+			default:
+				EMIT_SOUND_DYN(ENT(player->pev), CHAN_ITEM, "events/tutor_msg.wav", VOL_NORM, ATTN_NORM, 0, 100);
+				break;
+			}
+		}
+
+		if (definition->m_decay)
+		{
+			REGISTER_TUTOR_MESSAGE_SHOWN(id);
+		}
+	}
 }
 
 /* <1f5ad1> ../cstrike/dlls/tutor_base_tutor.cpp:264 */
-NOBODY void CBaseTutor::DrawLineToEntity(CBasePlayer *player, int entindex, int id)
+NOXREF void CBaseTutor::DrawLineToEntity(CBasePlayer *player, int entindex, int id)
 {
 	MESSAGE_BEGIN(MSG_ONE, gmsgTutorLine, NULL, player->pev);
 		WRITE_SHORT(entindex);
@@ -156,15 +252,16 @@ NOBODY void CBaseTutor::DrawLineToEntity(CBasePlayer *player, int entindex, int
 }
 
 /* <1f5b4f> ../cstrike/dlls/tutor_base_tutor.cpp:275 */
-NOXREF void CBaseTutor::DisplayNewStateDescriptionToPlayer(void)
+void CBaseTutor::DisplayNewStateDescriptionToPlayer(void)
 {
-	char *desc;
 	CBasePlayer *localPlayer = UTIL_GetLocalPlayer();
 
 	if (localPlayer == NULL)
+	{
 		return;
+	}
 
-	desc = m_stateSystem->GetCurrentStateString();
+	char *desc = m_stateSystem->GetCurrentStateString();
 
 	if (!desc)
 	{
@@ -189,79 +286,195 @@ void CBaseTutor::CloseCurrentWindow(void)
 }
 
 /* <1f5c26> ../cstrike/dlls/tutor_base_tutor.cpp:307 */
-NOBODY void CBaseTutor::CalculatePathForObjective(CBaseEntity *player)
+void CBaseTutor::CalculatePathForObjective(CBaseEntity *player)
 {
+	;
 }
 
 /* <1f52e6> ../cstrike/dlls/tutor_base_tutor.cpp:312 */
-NOBODY bool CBaseTutor::IsEntityInViewOfPlayer(CBaseEntity *entity, CBasePlayer *player)
+bool CBaseTutor::__MAKE_VHOOK(IsEntityInViewOfPlayer)(CBaseEntity *entity, CBasePlayer *player)
 {
-//	{
+	if (entity == NULL || player == NULL)
-//		Vector eye;                                     //   332
+	{
-//		TraceResult result;                                   //   334
+		return false;
-//		operator-(const Vector *const this,
+	}
-//				const Vector &v);  //   320
+
-//		Length(const Vector *const this);  //   320
+	if (cv_tutor_view_distance.value < (entity->pev->origin - player->pev->origin).Length())
-//	}
+	{
-//	IsEntityInViewOfPlayer(CBaseTutor *const this,
+		return false;
-//				class CBaseEntity *entity,
+	}
-//				class CBasePlayer *player);  //   312
+
+	if (player->FInViewCone(entity))
+	{
+		TraceResult result;
+		Vector eye = player->pev->view_ofs + player->pev->origin;
+
+		UTIL_TraceLine(eye, entity->pev->origin, ignore_monsters, ignore_glass, player->pev->pContainingEntity, &result);
+
+		if (result.flFraction == 1.0f)
+		{
+			return true;
+		}
+	}
+
+	return false;
 }
 
 /* <1f508a> ../cstrike/dlls/tutor_base_tutor.cpp:343 */
-NOBODY bool CBaseTutor::IsPlayerLookingAtPosition(Vector *origin, CBasePlayer *player)
+bool CBaseTutor::__MAKE_VHOOK(IsPlayerLookingAtPosition)(Vector *origin, CBasePlayer *player)
 {
-//	{
+	if (origin == NULL || player == NULL)
-//		Vector eye;                                     //   363
+	{
-//		TraceResult result;                                   //   364
+		return false;
-//		operator-(const Vector *const this,
+	}
-//				const Vector &v);  //   351
+
-//		Length(const Vector *const this);  //   351
+	if (cv_tutor_look_distance.value < (*origin - player->pev->origin).Length())
-//	}
+	{
-//	IsPlayerLookingAtPosition(CBaseTutor *const this,
+		return false;
-//					Vector *origin,
+	}
-//					class CBasePlayer *player);  //   343
+
+	if (player->IsLookingAtPosition(origin, cv_tutor_look_angle.value))
+	{
+		TraceResult result;
+		Vector eye = player->pev->origin + player->pev->view_ofs;
+
+		UTIL_TraceLine(eye, *origin, ignore_monsters, ignore_glass, ENT(player->pev), &result);
+
+		if (result.flFraction == 1.0f)
+			return true;
+	}
+
+	return false;
 }
 
 /* <1f4e92> ../cstrike/dlls/tutor_base_tutor.cpp:373 */
-NOBODY bool CBaseTutor::IsPlayerLookingAtEntity(CBaseEntity *entity, CBasePlayer *player)
+bool CBaseTutor::__MAKE_VHOOK(IsPlayerLookingAtEntity)(CBaseEntity *entity, CBasePlayer *player)
 {
-//	{
+	if (entity == NULL || player == NULL)
-//		Vector srcVec;                                  //   380
+	{
-//		Vector destVec;                                 //   386
+		return false;
-//		TraceResult result;                                   //   389
+	}
-//	}
+
-//	IsPlayerLookingAtEntity(CBaseTutor *const this,
+	UTIL_MakeVectors(player->pev->v_angle);
-//				class CBaseEntity *entity,
+
-//				class CBasePlayer *player);  //   373
+	Vector srcVec = player->pev->view_ofs + player->pev->origin;
+	Vector destVec = gpGlobals->v_forward * cv_tutor_look_distance.value + srcVec;
+
+	TraceResult result;
+	UTIL_TraceLine(srcVec, destVec, dont_ignore_monsters, ignore_glass, ENT(player->pev), &result);
+
+	if (result.pHit != NULL)
+	{
+		if (!FNullEnt(result.pHit) && CBaseEntity::Instance(result.pHit) == entity)
+		{
+			return true;
+		}
+	}
+
+	return false;
 }
 
 /* <1f51b0> ../cstrike/dlls/tutor_base_tutor.cpp:402 */
-NOBODY bool CBaseTutor::IsBombsiteInViewOfPlayer(CBaseEntity *entity, CBasePlayer *player)
+bool CBaseTutor::__MAKE_VHOOK(IsBombsiteInViewOfPlayer)(CBaseEntity *entity, CBasePlayer *player)
 {
-//	{
+	if (entity == NULL || player == NULL)
-//		Vector bombSiteCenter;                          //   410
+	{
-//		Vector eye;                                     //   426
+		return false;
-//		TraceResult result;                                   //   428
+	}
-//	}
+
-//	IsBombsiteInViewOfPlayer(CBaseTutor *const this,
+	Vector bombSiteCenter = (entity->pev->absmax + entity->pev->absmin) * 0.5;
-//				class CBaseEntity *entity,
+
-//				class CBasePlayer *player);  //   402
+	if (cv_tutor_view_distance.value < (bombSiteCenter - player->pev->origin).Length())
+	{
+		return false;
+	}
+
+	if (player->FInViewCone(entity))
+	{
+		TraceResult result;
+		Vector eye = player->pev->origin + player->pev->view_ofs;
+
+		UTIL_TraceLine(eye, bombSiteCenter, ignore_monsters, ignore_glass, ENT(player->pev), &result);
+
+		if (result.flFraction == 1.0f)
+		{
+			return true;
+		}
+	}
+
+	return false;
 }
 
 /* <1f4e37> ../cstrike/dlls/tutor_base_tutor.cpp:436 */
-NOBODY bool CBaseTutor::IsEntityInBombsite(CBaseEntity *bombsite, CBaseEntity *entity)
+bool CBaseTutor::__MAKE_VHOOK(IsEntityInBombsite)(CBaseEntity *bombsite, CBaseEntity *entity)
 {
-//	IsEntityInBombsite(CBaseTutor *const this,
+	if (bombsite == NULL || entity == NULL)
-//				class CBaseEntity *bombsite,
+	{
-//				class CBaseEntity *entity);  //   436
+		return false;
+	}
+
+	if (entity->pev->origin.x <= bombsite->pev->absmax.x
+		&& entity->pev->origin.y <= bombsite->pev->absmax.y
+		&& entity->pev->origin.z <= bombsite->pev->absmax.z
+		&& entity->pev->origin.x >= bombsite->pev->absmin.x
+		&& entity->pev->origin.y >= bombsite->pev->absmin.y
+		&& entity->pev->origin.z >= bombsite->pev->absmin.z)
+	{
+		return true;
+	}
+
+	return false;
 }
 
 /* <1f5c5b> ../cstrike/dlls/tutor_base_tutor.cpp:457 */
-NOBODY bool CBaseTutor::DoMessagesHaveSameID(int id1, int id2)
+bool CBaseTutor::DoMessagesHaveSameID(int id1, int id2)
 {
-//	{
+	if (id1 == id2)
-//		class TutorMessage *message1;                        //   464
+	{
-//		class TutorMessage *message2;                        //   465
+		return true;
-//	}
+	}
+
+	TutorMessage *message1 = GetTutorMessageDefinition(id1);
+	TutorMessage *message2 = GetTutorMessageDefinition(id2);
+
+	if (message1 == NULL || message2 == NULL)
+	{
+		return false;
+	}
+
+	if (message1->m_duplicateID && message2->m_duplicateID)
+	{
+		return true;
+	}
+
+	return false;
 }
+
+#ifdef HOOK_GAMEDLL
+
+bool CBaseTutor::IsEntityInViewOfPlayer(CBaseEntity *entity, CBasePlayer *player)
+{
+	return IsEntityInViewOfPlayer_(entity, player);
+}
+
+bool CBaseTutor::IsBombsiteInViewOfPlayer(CBaseEntity *entity, CBasePlayer *player)
+{
+	return IsBombsiteInViewOfPlayer_(entity, player);
+}
+
+bool CBaseTutor::IsEntityInBombsite(CBaseEntity *bombsite, CBaseEntity *entity)
+{
+	return IsEntityInBombsite_(bombsite, entity);
+}
+
+bool CBaseTutor::IsPlayerLookingAtPosition(Vector *origin, CBasePlayer *player)
+{
+	return IsPlayerLookingAtPosition_(origin, player);
+}
+
+bool CBaseTutor::IsPlayerLookingAtEntity(CBaseEntity *entity, CBasePlayer *player)
+{
+	return IsPlayerLookingAtEntity_(entity, player);
+}
+
+#endif // HOOK_GAMEDLL

regamedll/dlls/tutor_base_tutor.h

@@ -36,7 +36,7 @@ class TutorMessageEvent
 {
 public:
 	TutorMessageEvent(int mid, int duplicateID, float time, float lifetime, int priority);
-	//virtual ~TutorMessageEvent(void);
+	virtual ~TutorMessageEvent(void);
 
 	bool IsActive(float time);
 	int GetPriority(void);
@@ -62,7 +62,6 @@ private:
 
 };/* size: 36, cachelines: 1, members: 9 */
 
-
 class CBaseTutor
 {
 public:
@@ -82,6 +81,17 @@ public:
 
 	virtual void HandleShotFired(Vector source, Vector target) = 0;
 	virtual struct TutorMessage *GetTutorMessageDefinition(int messageID) = 0;
+
+#ifdef HOOK_GAMEDLL
+
+	bool IsEntityInViewOfPlayer_(CBaseEntity *entity, CBasePlayer *player);
+	bool IsBombsiteInViewOfPlayer_(CBaseEntity *entity, CBasePlayer *player);
+	bool IsEntityInBombsite_(CBaseEntity *bombsite, CBaseEntity *entity);
+	bool IsPlayerLookingAtPosition_(Vector *origin, CBasePlayer *player);
+	bool IsPlayerLookingAtEntity_(CBaseEntity *entity, CBasePlayer *player);
+
+#endif // HOOK_GAMEDLL
+
 public:
 	void StartFrame(float time);
 	void OnEvent(GameEventType event, CBaseEntity *entity = NULL, CBaseEntity *other = NULL);
@@ -89,17 +99,18 @@ public:
 	void ShotFired(Vector source, Vector target);
 	void DisplayMessageToPlayer(CBasePlayer *player, int id, const char *szMessage, TutorMessageEvent *event);
 	NOXREF void DrawLineToEntity(CBasePlayer *player, int entindex, int id);
-	NOXREF void DisplayNewStateDescriptionToPlayer(void);
+	void DisplayNewStateDescriptionToPlayer(void);
 	void CloseCurrentWindow(void);
-	NOXREF void CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
+	void CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
 	void CalculatePathForObjective(CBaseEntity *player);
 	bool DoMessagesHaveSameID(int id1, int id2);
 
-private:
+protected:
 	CBaseTutorStateSystem *m_stateSystem;
 	TutorMessageEvent *m_eventList;
 	float m_deadAirStartTime;
 	float m_roundStartTime;
+
 };/* size: 20, cachelines: 1, members: 5 */
 
 #ifdef HOOK_GAMEDLL

regamedll/dlls/tutor_cs_states.cpp

@@ -1,164 +1,310 @@
 #include "precompiled.h"
 
-enum TutorStateType
+/*
-{
+* Globals initialization
-	TUTORSTATE_UNDEFINED = 0,
+*/
-	TUTORSTATE_LOOKING_FOR_HOSTAGE,
+#ifndef HOOK_GAMEDLL
-	TUTORSTATE_ESCORTING_HOSTAGE,
+
-	TUTORSTATE_LOOKING_FOR_LOST_HOSTAGE,
+char *const g_TutorStateStrings[20] = 
-	TUTORSTATE_FOLLOWING_HOSTAGE_ESCORT,
+{
-	TUTORSTATE_MOVING_TO_BOMBSITE,
+	"#Cstrike_TutorState_Undefined",
-	TUTORSTATE_LOOKING_FOR_BOMB_CARRIER,
+	"#Cstrike_TutorState_Looking_For_Hostage",
-	TUTORSTATE_GUARDING_LOOSE_BOMB,
+	"#Cstrike_TutorState_Escorting_Hostage",
-	TUTORSTATE_DEFUSING_BOMB,
+	"#Cstrike_TutorState_Following_Hostage_Escort",
-	TUTORSTATE_GUARDING_HOSTAGE,
+	"#Cstrike_TutorState_Moving_To_Bombsite",
-	TUTORSTATE_MOVING_TO_INTERCEPT_ENEMY,
+	"#Cstrike_TutorState_Looking_For_Bomb_Carrier",
-	TUTORSTATE_LOOKING_FOR_HOSTAGE_ESCORT,
+	"#Cstrike_TutorState_Guarding_Loose_Bomb",
-	TUTORSTATE_ATTACKING_HOSTAGE_ESCORT,
+	"#Cstrike_TutorState_Defusing_Bomb",
-	TUTORSTATE_ESCORTING_BOMB_CARRIER,
+	"#Cstrike_TutorState_Guarding_Hostage",
-	TUTORSTATE_MOVING_TO_BOMB_SITE,
+	"#Cstrike_TutorState_Moving_To_Intercept_Enemy",
-	TUTORSTATE_PLANTING_BOMB,
+	"#Cstrike_TutorState_Looking_For_Hostage_Escort",
-	TUTORSTATE_GUARDING_BOMB,
+	"#Cstrike_TutorState_Attacking_Hostage_Escort",
-	TUTORSTATE_LOOKING_FOR_LOOSE_BOMB,
+	"#Cstrike_TutorState_Escorting_Bomb_Carrier",
-	TUTORSTATE_RUNNING_AWAY_FROM_TICKING_BOMB,
+	"#Cstrike_TutorState_Moving_To_Bomb_Site",
-	TUTORSTATE_BUYTIME,
+	"#Cstrike_TutorState_Planting_Bomb",
-	TUTORSTATE_WAITING_FOR_START,
+	"#Cstrike_TutorState_Guarding_Bomb",
+	"#Cstrike_TutorState_Looking_For_Loose_Bomb",
+	"#Cstrike_TutorState_Running_Away_From_Ticking_Bomb",
+	"#Cstrike_TutorState_Buy_Time",
+	"#Cstrike_TutorState_Waiting_For_Start"
 };
+#else
+
+char *const g_TutorStateStrings[20];
+
+#endif // HOOK_GAMEDLL
 
 /* <22bf8e> ../cstrike/dlls/tutor_cs_states.cpp:53 */
-NOBODY CCSTutorStateSystem::CCSTutorStateSystem(void)
+CCSTutorStateSystem::CCSTutorStateSystem(void)
 {
-//	CCSTutorUndefinedState(CCSTutorUndefinedState *const this);  //    55
+	m_currentState = new CCSTutorUndefinedState;
 }
 
 /* <22bd56> ../cstrike/dlls/tutor_cs_states.cpp:58 */
-NOBODY CCSTutorStateSystem::~CCSTutorStateSystem(void)
+CCSTutorStateSystem::~CCSTutorStateSystem(void)
 {
+	if (m_currentState != NULL)
+	{
+		delete m_currentState;
+		m_currentState = NULL;
+	}
 }
 
 /* <22bccf> ../cstrike/dlls/tutor_cs_states.cpp:68 */
-NOBODY bool CCSTutorStateSystem::UpdateState(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+bool CCSTutorStateSystem::__MAKE_VHOOK(UpdateState)(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
 {
-//	{
+	if (m_currentState == NULL)
-//		enum TutorStateType nextStateType;                    //    70
+	{
-//		CCSTutorUndefinedState(CCSTutorUndefinedState *const this);  //    76
+		m_currentState = new CCSTutorUndefinedState;
-//	}
+	}
+
+	if (m_currentState != NULL)
+	{
+		TutorStateType nextStateType = static_cast<TutorStateType>(m_currentState->CheckForStateTransition(event, entity, other));
+
+		if (nextStateType != TUTORSTATE_UNDEFINED)
+		{
+			if (m_currentState != NULL)
+			{
+				delete m_currentState;
+			}
+
+			m_currentState = NULL;
+			m_currentState = ConstructNewState(nextStateType);
+
+			return true;
+		}
+	}
+
+	return false;
 }
 
 /* <22b96f> ../cstrike/dlls/tutor_cs_states.cpp:108 */
-NOBODY char *CCSTutorStateSystem::GetCurrentStateString(void)
+char *CCSTutorStateSystem::__MAKE_VHOOK(GetCurrentStateString)(void)
 {
+	if (m_currentState != NULL)
+	{
+		return m_currentState->GetStateString();
+	}
+
+	return NULL;
 }
 
 /* <22bbfe> ../cstrike/dlls/tutor_cs_states.cpp:118 */
-NOBODY CBaseTutorState *CCSTutorStateSystem::ConstructNewState(int stateType)
+CBaseTutorState *CCSTutorStateSystem::__MAKE_VHOOK(ConstructNewState)(int stateType)
 {
-//	{
+	CBaseTutorState *ret = NULL;
-//		class CBaseTutorState *ret;                          //   120
+
-//		CCSTutorWaitingForStartState(CCSTutorWaitingForStartState *const this);  //   128
+	if (stateType != TUTORSTATE_UNDEFINED)
-//		CCSTutorBuyMenuState(CCSTutorBuyMenuState *const this);  //   132
+	{
-//	}
+		if (stateType == TUTORSTATE_BUYTIME)
-//	ConstructNewState(CCSTutorStateSystem *const this,
+		{
-//				int stateType);  //   118
+			ret = new CCSTutorBuyMenuState;
+		}
+		else if (stateType == TUTORSTATE_WAITING_FOR_START)
+		{
+			ret = new CCSTutorWaitingForStartState;
+		}
+	}
+	else
+	{
+		ret = new CCSTutorUndefinedState;
+	}
+
+	return ret;
 }
 
 /* <22bfcb> ../cstrike/dlls/tutor_cs_states.cpp:141 */
-NOBODY CCSTutorUndefinedState::CCSTutorUndefinedState(void)
+CCSTutorUndefinedState::CCSTutorUndefinedState(void)
 {
+	m_type = 0;
 }
 
 /* <22bb33> ../cstrike/dlls/tutor_cs_states.cpp:146 */
-NOBODY CCSTutorUndefinedState::~CCSTutorUndefinedState(void)
+CCSTutorUndefinedState::~CCSTutorUndefinedState(void)
 {
-//	~CCSTutorUndefinedState(CCSTutorUndefinedState::~CCSTutorUndefinedState();  //   148
+	;
 }
 
 /* <22bdd8> ../cstrike/dlls/tutor_cs_states.cpp:150 */
-NOBODY int CCSTutorUndefinedState::CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+int CCSTutorUndefinedState::__MAKE_VHOOK(CheckForStateTransition)(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
 {
-//	{
+	int ret = 0;
-//		int ret;                                              //   152
+
-//		HandlePlayerSpawned(CCSTutorUndefinedState *const this,
+	if (event == EVENT_PLAYER_SPAWNED)
-//					class CBaseEntity *entity,
+	{
-//					class CBaseEntity *other);  //   156
+		ret = HandlePlayerSpawned(entity, other);
-//	}
+	}
+
+	return ret;
 }
 
 /* <22bfed> ../cstrike/dlls/tutor_cs_states.cpp:163 */
-NOBODY int CCSTutorUndefinedState::HandlePlayerSpawned(CBaseEntity *entity, CBaseEntity *other)
+int CCSTutorUndefinedState::HandlePlayerSpawned(CBaseEntity *entity, CBaseEntity *other)
 {
-//	{
+	CBasePlayer *localPlayer = UTIL_GetLocalPlayer();
-//		class CBasePlayer *localPlayer;                      //   171
+
-//		class CBasePlayer *player;                           //   178
+	if (localPlayer != NULL)
-//	}
+	{
+		CBasePlayer *player = reinterpret_cast<CBasePlayer *>(entity);
+
+		if (player != NULL && player->IsPlayer() && player == localPlayer)
+		{
+			// flags
+			return TUTOR_STATE_FLAG_1;
+		}
+	}
+
+	return 0;
 }
 
 /* <22b995> ../cstrike/dlls/tutor_cs_states.cpp:190 */
-NOBODY char *CCSTutorUndefinedState::GetStateString(void)
+char *CCSTutorUndefinedState::__MAKE_VHOOK(GetStateString)(void)
 {
+	return NULL;
 }
 
 /* <22c03e> ../cstrike/dlls/tutor_cs_states.cpp:198 */
-NOBODY CCSTutorWaitingForStartState::CCSTutorWaitingForStartState(void)
+CCSTutorWaitingForStartState::CCSTutorWaitingForStartState(void)
 {
+	m_type = (TUTORMESSAGETYPE_ENEMY_DEATH | TUTORMESSAGETYPE_BUY);
 }
 
 /* <22bab6> ../cstrike/dlls/tutor_cs_states.cpp:203 */
-NOBODY CCSTutorWaitingForStartState::~CCSTutorWaitingForStartState(void)
+CCSTutorWaitingForStartState::~CCSTutorWaitingForStartState(void)
 {
+	;
 }
 
 /* <22beca> ../cstrike/dlls/tutor_cs_states.cpp:207 */
-NOBODY int CCSTutorWaitingForStartState::CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+int CCSTutorWaitingForStartState::__MAKE_VHOOK(CheckForStateTransition)(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
 {
-//	{
+	int ret = 0;
-//		int ret;                                              //   209
+
-//		HandlePlayerSpawned(CCSTutorWaitingForStartState *const this,
+	switch (event)
-//					class CBaseEntity *entity,
+	{
-//					class CBaseEntity *other);  //   214
+	case EVENT_PLAYER_SPAWNED:
-//	}
+		ret = HandlePlayerSpawned(entity, other);
+		break;
+	case EVENT_BUY_TIME_START:
+		ret = HandleBuyTimeStart(entity, other);
+		break;
+	}
+
+	return ret;
 }
 
 /* <22b9bb> ../cstrike/dlls/tutor_cs_states.cpp:224 */
-NOBODY char *CCSTutorWaitingForStartState::GetStateString(void)
+char *CCSTutorWaitingForStartState::__MAKE_VHOOK(GetStateString)(void)
 {
+	return g_TutorStateStrings[m_type];
 }
 
 /* <22c060> ../cstrike/dlls/tutor_cs_states.cpp:230 */
-NOBODY int CCSTutorWaitingForStartState::HandlePlayerSpawned(CBaseEntity *entity, CBaseEntity *other)
+int CCSTutorWaitingForStartState::HandlePlayerSpawned(CBaseEntity *entity, CBaseEntity *other)
 {
-//	{
+	CBasePlayer *localPlayer = UTIL_GetLocalPlayer();
-//		class CBasePlayer *localPlayer;                      //   238
+
-//		class CBasePlayer *player;                           //   245
+	if (localPlayer != NULL)
-//	}
+	{
+		CBasePlayer *player = reinterpret_cast<CBasePlayer *>(entity);
+
+		if (player != NULL && player->IsPlayer() && player == localPlayer)
+		{
+			// flags
+			return TUTOR_STATE_FLAG_1;
+		}
+	}
+
+	return 0;
 }
 
 /* <22c0b1> ../cstrike/dlls/tutor_cs_states.cpp:257 */
-NOBODY int CCSTutorWaitingForStartState::HandleBuyTimeStart(CBaseEntity *entity, CBaseEntity *other)
+int CCSTutorWaitingForStartState::HandleBuyTimeStart(CBaseEntity *entity, CBaseEntity *other)
 {
+	return TUTOR_STATE_FLAG_2;
 }
 
 /* <22c0e2> ../cstrike/dlls/tutor_cs_states.cpp:266 */
-NOBODY CCSTutorBuyMenuState::CCSTutorBuyMenuState(void)
+CCSTutorBuyMenuState::CCSTutorBuyMenuState(void)
 {
+	m_type = (TUTORMESSAGETYPE_DEFAULT | TUTORMESSAGETYPE_FRIEND_DEATH | TUTORMESSAGETYPE_BUY);
 }
 
 /* <22ba5a> ../cstrike/dlls/tutor_cs_states.cpp:271 */
-NOBODY CCSTutorBuyMenuState::~CCSTutorBuyMenuState(void)
+CCSTutorBuyMenuState::~CCSTutorBuyMenuState(void)
 {
+	;
 }
 
 /* <22b9e1> ../cstrike/dlls/tutor_cs_states.cpp:275 */
-NOBODY int CCSTutorBuyMenuState::CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+int CCSTutorBuyMenuState::__MAKE_VHOOK(CheckForStateTransition)(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
 {
+	if (event == EVENT_ROUND_START)
+	{
+		return HandleRoundStart(entity, other);
+	}
+
+	return 0;
 }
 
 /* <22ba34> ../cstrike/dlls/tutor_cs_states.cpp:288 */
-NOBODY char *CCSTutorBuyMenuState::GetStateString(void)
+char *CCSTutorBuyMenuState::__MAKE_VHOOK(GetStateString)(void)
 {
+	return g_TutorStateStrings[m_type];
 }
 
 /* <22c104> ../cstrike/dlls/tutor_cs_states.cpp:293 */
-NOBODY int CCSTutorBuyMenuState::HandleRoundStart(CBaseEntity *entity, CBaseEntity *other)
+int CCSTutorBuyMenuState::HandleRoundStart(CBaseEntity *entity, CBaseEntity *other)
 {
+	return TUTOR_STATE_FLAG_1;
 }
+
+#ifdef HOOK_GAMEDLL
+
+bool CCSTutorStateSystem::UpdateState(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+{
+	return UpdateState_(event, entity, other);
+}
+
+char *CCSTutorStateSystem::GetCurrentStateString(void)
+{
+	return GetCurrentStateString_();
+}
+
+CBaseTutorState *CCSTutorStateSystem::ConstructNewState(int stateType)
+{
+	return ConstructNewState_(stateType);
+}
+
+int CCSTutorUndefinedState::CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+{
+	return CheckForStateTransition_(event, entity, other);
+}
+
+char *CCSTutorUndefinedState::GetStateString(void)
+{
+	return GetStateString_();
+}
+
+int CCSTutorWaitingForStartState::CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+{
+	return CheckForStateTransition_(event, entity, other);
+}
+
+char *CCSTutorWaitingForStartState::GetStateString(void)
+{
+	return GetStateString_();
+}
+
+int CCSTutorBuyMenuState::CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other)
+{
+	return CheckForStateTransition_(event, entity, other);
+}
+
+char *CCSTutorBuyMenuState::GetStateString(void)
+{
+	return GetStateString_();
+}
+
+#endif // HOOK_GAMEDLL

regamedll/dlls/tutor_cs_states.h

@@ -32,6 +32,35 @@
 #pragma once
 #endif
 
+// unknown flags
+#define TUTOR_STATE_FLAG_1		0x00000014
+#define TUTOR_STATE_FLAG_2		0x00000013
+
+enum TutorStateType
+{
+	TUTORSTATE_UNDEFINED = 0,
+	TUTORSTATE_LOOKING_FOR_HOSTAGE,
+	TUTORSTATE_ESCORTING_HOSTAGE,
+	TUTORSTATE_LOOKING_FOR_LOST_HOSTAGE,
+	TUTORSTATE_FOLLOWING_HOSTAGE_ESCORT,
+	TUTORSTATE_MOVING_TO_BOMBSITE,
+	TUTORSTATE_LOOKING_FOR_BOMB_CARRIER,
+	TUTORSTATE_GUARDING_LOOSE_BOMB,
+	TUTORSTATE_DEFUSING_BOMB,
+	TUTORSTATE_GUARDING_HOSTAGE,
+	TUTORSTATE_MOVING_TO_INTERCEPT_ENEMY,
+	TUTORSTATE_LOOKING_FOR_HOSTAGE_ESCORT,
+	TUTORSTATE_ATTACKING_HOSTAGE_ESCORT,
+	TUTORSTATE_ESCORTING_BOMB_CARRIER,
+	TUTORSTATE_MOVING_TO_BOMB_SITE,
+	TUTORSTATE_PLANTING_BOMB,
+	TUTORSTATE_GUARDING_BOMB,
+	TUTORSTATE_LOOKING_FOR_LOOSE_BOMB,
+	TUTORSTATE_RUNNING_AWAY_FROM_TICKING_BOMB,
+	TUTORSTATE_BUYTIME,
+	TUTORSTATE_WAITING_FOR_START,
+};
+
 /* <22bf75> ../cstrike/dlls/tutor_cs_states.cpp:53 */
 class CCSTutorStateSystem: public CBaseTutorStateSystem
 {
@@ -40,9 +69,23 @@ public:
 
 	virtual ~CCSTutorStateSystem(void);
 	virtual bool UpdateState(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
-	virtual char *GetCurrentStateString(void);
+	virtual char *GetCurrentStateString(void);
+
+#ifndef HOOK_GAMEDLL
 protected:
-	virtual CBaseTutorState *ConstructNewState(int stateType);
+#endif // HOOK_GAMEDLL
+
+	virtual CBaseTutorState *ConstructNewState(int stateType);
+
+#ifdef HOOK_GAMEDLL
+public:
+
+	bool UpdateState_(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
+	char *GetCurrentStateString_(void);
+	CBaseTutorState *ConstructNewState_(int stateType);
+
+#endif // HOOK_GAMEDLL
+
 };/* size: 8, cachelines: 1, members: 1 */
 
 /* <22bfcb> ../cstrike/dlls/tutor_cs_states.cpp:141 */
@@ -55,8 +98,16 @@ public:
 	virtual int CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
 	virtual char *GetStateString(void);
 
+#ifdef HOOK_GAMEDLL
+
+	int CheckForStateTransition_(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
+	char *GetStateString_(void);
+
+#endif // HOOK_GAMEDLL
+
 protected:
 	int HandlePlayerSpawned(CBaseEntity *entity, CBaseEntity *other);
+
 };/* size: 8, cachelines: 1, members: 1 */
 
 /* <22c03e> ../cstrike/dlls/tutor_cs_states.cpp:198 */
@@ -69,6 +120,13 @@ public:
 	virtual int CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
 	virtual char *GetStateString(void);
 
+#ifdef HOOK_GAMEDLL
+
+	int CheckForStateTransition_(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
+	char *GetStateString_(void);
+
+#endif // HOOK_GAMEDLL
+
 protected:
 
 	int HandlePlayerSpawned(CBaseEntity *entity, CBaseEntity *other);
@@ -86,9 +144,22 @@ public:
 	virtual int CheckForStateTransition(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
 	virtual char *GetStateString(void);
 
+#ifdef HOOK_GAMEDLL
+
+	int CheckForStateTransition_(GameEventType event, CBaseEntity *entity, CBaseEntity *other);
+	char *GetStateString_(void);
+
+#endif // HOOK_GAMEDLL
+
 protected:
 	int HandleRoundStart(CBaseEntity *entity, CBaseEntity *other);
 
 };/* size: 8, cachelines: 1, members: 1 */
 
+#ifdef HOOK_GAMEDLL
+#define g_TutorStateStrings (*pg_TutorStateStrings)
+#endif // HOOK_GAMEDLL
+
+extern char *const g_TutorStateStrings[20];
+
 #endif // TUTOR_CS_STATES_H

regamedll/dlls/tutor_cs_tutor.h

@@ -43,17 +43,18 @@ enum TutorMessageClass
 
 enum TutorMessageType
 {
-	TUTORMESSAGETYPE_DEFAULT = (1<<0),
+	TUTORMESSAGETYPE_DEFAULT	= (1 << 0),	// icon info  | color green
-	TUTORMESSAGETYPE_FRIEND_DEATH = (1<<1),
+	TUTORMESSAGETYPE_FRIEND_DEATH	= (1 << 1),	// icon skull | color red
-	TUTORMESSAGETYPE_ENEMY_DEATH = (1<<2),
+	TUTORMESSAGETYPE_ENEMY_DEATH	= (1 << 2),	// icon skull | color blue
-	TUTORMESSAGETYPE_SCENARIO = (1<<3),
+	TUTORMESSAGETYPE_SCENARIO	= (1 << 3),	// icon info  | color yellow
-	TUTORMESSAGETYPE_BUY = (1<<4),
+	TUTORMESSAGETYPE_BUY		= (1 << 4),	// icon info  | color green
-	TUTORMESSAGETYPE_CAREER = (1<<5),
+	TUTORMESSAGETYPE_CAREER		= (1 << 5),	// icon info  | color green
-	TUTORMESSAGETYPE_HINT = (1<<6),
+	TUTORMESSAGETYPE_HINT		= (1 << 6),	// icon info  | color green
-	TUTORMESSAGETYPE_INGAME_HINT = (1<<7),
+	TUTORMESSAGETYPE_INGAME_HINT	= (1 << 7),	// icon info  | color green
-	TUTORMESSAGETYPE_END_GAME = (1<<8),
+	TUTORMESSAGETYPE_END_GAME	= (1 << 8),	// icon info  | color yellow
+
 	TUTORMESSAGETYPE_LAST,
-	TUTORMESSAGETYPE_ALL = 511
+	TUTORMESSAGETYPE_ALL		= (1 << 9) - 1
 };
 
 enum TutorMessageInterruptFlag
@@ -237,15 +238,15 @@ enum TutorMessageID
 	HINT_51,
 	HINT_52,
 	HINT_53,
-	HINT_BOMB_START,
+	HINT_BOMB_START	= 139,
-	HINT_60 = 139,
+	HINT_60	= 139,
-	HINT_61,
+	HINT_61 = 140,
 	HINT_BOMB_END = 140,
-	HINT_HOSTAGE_START,
+	HINT_HOSTAGE_START = 141,
 	HINT_70 = 141,
 	HINT_71,
 	HINT_72,
-	HINT_73,
+	HINT_73 = 144,
 	HINT_HOSTAGE_END = 144,
 	HINT_END,
 	INGAME_HINT_BEGIN,
@@ -256,7 +257,8 @@ enum TutorMessageID
 };
 
 //typedef map<std::basic_string<char, std::char_traits<char>, std::allocator<char> >, TutorMessage*, std::less<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<const std::basic_string<char, std::char_traits<char>, std::allocator<char> >, TutorMessage*> > > TutorMessageMap;
-typedef std::map<TutorMessage *, TutorMessage *> TutorMessageMap;
+typedef std::map<std::string, TutorMessage *> TutorMessageMap;
+typedef TutorMessageMap::iterator TutorMessageMapIter;
 
 struct ClientCorpseStruct
 {
@@ -266,6 +268,7 @@ struct ClientCorpseStruct
 };/* size: 16, cachelines: 1, members: 2 */
 
 typedef std::vector<ClientCorpseStruct *> ClientCorpseList;
+typedef ClientCorpseList::iterator ClientCorpseListIter;
 
 class CCSTutor: public CBaseTutor
 {
@@ -287,19 +290,19 @@ public:
 	virtual void HandleShotFired(Vector source, Vector target);
 	virtual TutorMessage *GetTutorMessageDefinition(int messageID);
 
-	void CreateAndAddEventToList(TutorMessageID mid, CBaseEntity *entity, CBaseEntity *other);
+	void CreateAndAddEventToList(TutorMessageID mid, CBaseEntity *entity = NULL, CBaseEntity *other = NULL);
-	TutorMessageEvent *CreateTutorMessageEvent(TutorMessageID mid, CBaseEntity *entity, CBaseEntity *other);
+	TutorMessageEvent *CreateTutorMessageEvent(TutorMessageID mid, CBaseEntity *entity = NULL, CBaseEntity *other = NULL);
 	void AddToEventList(TutorMessageEvent *event);
 	void DeleteEventFromEventList(TutorMessageEvent *event);
 	void ClearEventList(void);
-	void ClearCurrentEvent(bool closeWindow, bool processDeathsForEvent);
+	void ClearCurrentEvent(bool closeWindow = true, bool processDeathsForEvent = true);
 	void DeleteEvent(TutorMessageEvent *event);
 	bool ShouldShowMessageEvent(TutorMessageEvent *event, float time);
-	bool ShouldUpdateCurrentMessage(TutorMessageID messageID);
+	NOXREF bool ShouldUpdateCurrentMessage(TutorMessageID messageID);
 	void ComputeDisplayTimesForMessage(void);
 	void UpdateCurrentMessage(TutorMessageEvent *event);
 	void ConstructMessageAndDisplay(void);
-	void LookupHotKey(TutorMessageID mid, int paramNum, wchar_t *buf, int buflen);
+	NOXREF void LookupHotKey(TutorMessageID mid, int paramNum, wchar_t *buf, int buflen);
 	void CheckForWindowClose(float time);
 	void CheckForContentUpdate(void);
 	bool HasCurrentWindowBeenActiveLongEnough(float time);
@@ -309,7 +312,7 @@ public:
 	void ProcessShownDeathsForEvent(TutorMessageEvent *event);
 	void TransferDeathEvents(TutorMessageEvent *oldEvent, TutorMessageEvent *newEvent);
 	TutorMessageEvent *GetTutorMessageUpdateEvent(void);
-	bool GetDuplicateMessagesFromEventList(const TutorMessageEvent *&event1, const TutorMessageEvent *&event2);
+	bool GetDuplicateMessagesFromEventList(TutorMessageEvent *&event1, TutorMessageEvent *&event2);
 	bool IsBombMap(void);
 	bool IsHostageMap(void);
 public:
@@ -318,10 +321,10 @@ public:
 	void HandleWeaponReloaded(CBaseEntity *entity, CBaseEntity *other);
 	void HandlePlayerDied(CBaseEntity *entity, CBaseEntity *other);
 	void HandlePlayerSpawned(CBaseEntity *entity, CBaseEntity *other);
-	void HandleClientCorpseSpawned(CBaseEntity *entity, CBaseEntity *other);
+	NOXREF void HandleClientCorpseSpawned(CBaseEntity *entity, CBaseEntity *other);
 	void HandlePlayerTookDamage(CBaseEntity *entity, CBaseEntity *other);
 	void HandlePlayerBlindedByFlashbang(CBaseEntity *entity, CBaseEntity *other);
-	void HandleBuyTimeStart(CBaseEntity *entity, CBaseEntity *other);
+	NOXREF void HandleBuyTimeStart(CBaseEntity *entity, CBaseEntity *other);
 	void HandlePlayerLeftBuyZone(CBaseEntity *entity, CBaseEntity *other);
 	void HandleBombPlanted(CBaseEntity *entity, CBaseEntity *other);
 	void HandleRoundStart(CBaseEntity *entity, CBaseEntity *other);
@@ -383,13 +386,13 @@ public:
 	void CheckHintMessages(float time);
 	void CheckInGameHintMessages(float time);
 	void CheckExamineMessages(float time);
-	void CheckForNeedToReload(bool isPassiveCheck);
+	void CheckForNeedToReload(bool isPassiveCheck = false);
 	bool CanLocalPlayerBuyStuff(void);
 	void CheckBuyZoneMessages(void);
 	bool IsBombPlantedInBombsite(CBaseEntity *bombTarget);
 	void ReadTutorMessageFile(void);
 	void ApplyPersistentDecay(void);
-	CBaseEntity *GetEntityForMessageID(int messageID, CBaseEntity *last);
+	CBaseEntity *GetEntityForMessageID(int messageID, CBaseEntity *last = NULL);
 	void ResetPlayerDeathInfo(void);
 	void ConstructRecentDeathsList(TeamName team, char *buf, int buflen, TutorMessageEvent *event);
 
@@ -406,16 +409,7 @@ public:
 
 private:
 	float m_nextViewableCheckTime;
-	TutorMessageMap m_messageMap;			// Win: 16 | Lin - 20
+	TutorMessageMap m_messageMap;
-
-#ifdef HOOK_GAMEDLL
-#ifdef _WIN32
-	int padding1[2];
-#else
-	int padding1[4];
-#endif // _WIN32
-#endif // HOOK_GAMEDLL
-
 	TutorMessageID m_currentlyShownMessageID;
 	float m_currentlyShownMessageCloseTime;
 	float m_currentlyShownMessageStartTime;
@@ -424,13 +418,7 @@ private:
 	TutorMessageEvent *m_lastScenarioEvent;
 	TutorMessageID m_lastHintShown;
 	TutorMessageID m_lastInGameHintShown;
-
+	ClientCorpseList m_clientCorpseList;
-	ClientCorpseList m_clientCorpseList;		// Win: 16 | Lin - 12
-
-#if defined(HOOK_GAMEDLL) && defined(_WIN32)
-	int padding2;
-#endif // HOOK_GAMEDLL
-
 	int m_messageTypeMask;
 	bool m_haveSpawned;
 	PlayerDeathStruct m_playerDeathInfo[32];
@@ -443,10 +431,22 @@ private:
 
 #endif // HOOK_GAMEDLL
 
-extern const char *TutorIdentifierList[150];
+extern const char *TutorIdentifierList[ TUTOR_NUM_MESSAGES ];
 
-NOBODY void ParseMessageParameters(const char *&messageData, TutorMessage *ret);
+void ParseMessageParameters(char *&messageData, TutorMessage *ret);
-NOBODY TutorMessage *ConstructTutorMessage(const char *&messageData, TutorMessage *defaults);
+TutorMessage *ConstructTutorMessage(char *&messageData, TutorMessage *defaults);
-NOBODY void ReadDefaultValues(const char *&messageData, TutorMessage *defaults);
+void ReadDefaultValues(char *&messageData, TutorMessage *defaults);
+
+// custom operator
+inline TutorMessageID operator++(TutorMessageID &e, int)
+{
+	if (e == TUTOR_NUM_MESSAGES)
+	{
+		return YOU_FIRED_A_SHOT;
+	}
+
+	const int i = static_cast<int>(e);
+	return e = static_cast<TutorMessageID>(i + 1);
+}
 
 #endif // TUTOR_CS_TUTOR_H

regamedll/dlls/util.cpp

@@ -1,6 +1,6 @@
 #include "precompiled.h"
 
-#if 1
+#if 0
 
 void *addr_orig;
 char patchByte[5];
@@ -175,6 +175,7 @@ int UTIL_SharedRandomLong(unsigned int seed, int low, int high)
 		int offset = rnum % range;
 		return (low + offset);
 	}
+
 	return low;
 }
 
@@ -193,6 +194,7 @@ float UTIL_SharedRandomFloat(unsigned int seed, float low, float high)
 		float offset = (float)tensixrand / 0x10000u;
 		return (low + offset * range);
 	}
+
 	return low;
 }
 
@@ -341,6 +343,7 @@ int UTIL_EntitiesInBox(CBaseEntity **pList, int listMax, const Vector &mins, con
 		if (count >= listMax)
 			break;
 	}
+
 	return count;
 }
 
@@ -399,6 +402,7 @@ NOXREF int UTIL_MonstersInSphere(CBaseEntity ** pList, int listMax, const Vector
 		if (count >= listMax)
 			return count;
 	}
+
 	return count;
 }
 
@@ -413,7 +417,10 @@ CBaseEntity *UTIL_FindEntityInSphere(CBaseEntity *pStartEntity, const Vector &ve
 
 	pentEntity = FIND_ENTITY_IN_SPHERE(pentEntity, vecCenter, flRadius);
 	if (!FNullEnt(pentEntity))
+	{
 		return CBaseEntity::Instance(pentEntity);
+	}
+
 	return NULL;
 }
 
@@ -428,7 +435,10 @@ CBaseEntity *UTIL_FindEntityByString_Old(CBaseEntity *pStartEntity, const char *
 
 	pentEntity = FIND_ENTITY_BY_STRING(pentEntity, szKeyword, szValue);
 	if (!FNullEnt(pentEntity))
+	{
 		return CBaseEntity::Instance(pentEntity);
+	}
+
 	return NULL;
 }
 
@@ -454,52 +464,63 @@ CBaseEntity *UTIL_FindEntityByString(CBaseEntity *pStartEntity, const char *szKe
 
 		hash = CaseInsensitiveHash(szValue, stringsHashTable.Count());
 		count = stringsHashTable.Count();
-		item = &stringsHashTable[hash];
+		item = &stringsHashTable[ hash ];
 
-		while (item->pev)
-		{
-			if (!strcmp(STRING(item->pev->classname), szValue))
-				break;
-
-			hash = (hash + 1) % count;
-			item = &stringsHashTable[hash];
-		}
 		if (!item->pev)
 		{
 			item->lastHash = NULL;
 			return NULL;
 		}
-		if (pStartEntity)
+
+		while (item->pev != NULL)
+		{
+			if (!Q_strcmp(STRING(item->pev->classname), szValue))
+				break;
+
+			hash = (hash + 1) % count;
+			item = &stringsHashTable[ hash ];
+		}
+
+		if (!item->pev)
+		{
+			item->lastHash = NULL;
+			return NULL;
+		}
+
+		if (pStartEntity != NULL)
 		{
 			if (item->lastHash && item->lastHash->pevIndex <= startEntityIndex)
 				item = item->lastHash;
 
-			while (item->pevIndex <= startEntityIndex)
+			if (item->pevIndex <= startEntityIndex)
 			{
-				if (!item->next)
+				while (item->pevIndex <= startEntityIndex)
-					break;
+				{
+					if (!item->next)
+						break;
 
-				item = item->next;
+					item = item->next;
+				}
 
-				if (!(item->pevIndex <= startEntityIndex))
+				if (item->pevIndex == startEntityIndex)
-					break;
+				{
-			}
+					stringsHashTable[ hash ].lastHash = NULL;
-
+					return NULL;
-			if (item->pevIndex == startEntityIndex)
+				}
-			{
-				stringsHashTable[hash].lastHash = NULL;
-				return NULL;
 			}
 		}
 
-		stringsHashTable[hash].lastHash = item;
+		stringsHashTable[ hash ].lastHash = item;
 		pentEntity = ENT(item->pev);
 	}
 	else
 		pentEntity = FIND_ENTITY_BY_STRING(pentEntity, szKeyword, szValue);
 
 	if (!FNullEnt(pentEntity))
+	{
 		return CBaseEntity::Instance(pentEntity);
+	}
+
 	return NULL;
 }
 
@@ -1052,11 +1073,7 @@ char *UTIL_VarArgs(char *format, ...)
 	static char string[1024];
 
 	va_start(argptr, format);
-#ifdef REGAMEDLL_FIXES
-	Q_vsnprintf(string, sizeof(string), format, argptr);
-#else
 	vsprintf(string, format, argptr);
-#endif // REGAMEDLL_FIXES
 	va_end(argptr);
 
 	return string;
@@ -1084,6 +1101,7 @@ int UTIL_IsMasterTriggered(string_t sMaster, CBaseEntity *pActivator)
 		}
 		ALERT(at_console, "Master was null or not a master!\n");
 	}
+
 	return 1;
 }
 
@@ -1130,7 +1148,7 @@ void UTIL_BloodStream(const Vector &origin, const Vector &direction, int color,
 		WRITE_COORD(direction.y);
 		WRITE_COORD(direction.z);
 		WRITE_BYTE(color);
-		WRITE_BYTE(min( amount, 255 ));
+		WRITE_BYTE(_min( amount, 255 ));
 	MESSAGE_END();
 }
 
@@ -1160,7 +1178,7 @@ void UTIL_BloodDrips(const Vector &origin, const Vector &direction, int color, i
 		WRITE_SHORT(g_sModelIndexBloodSpray);
 		WRITE_SHORT(g_sModelIndexBloodDrop);
 		WRITE_BYTE(color);
-		WRITE_BYTE(min( max( 3, amount / 10 ), 16 ));
+		WRITE_BYTE(_min( _max( 3, amount / 10 ), 16 ));
 	MESSAGE_END();
 }
 
@@ -1264,7 +1282,7 @@ void UTIL_PlayerDecalTrace(TraceResult *pTrace, int playernum, int decalNumber,
 			WRITE_COORD(pTrace->vecEndPos.x);
 			WRITE_COORD(pTrace->vecEndPos.y);
 			WRITE_COORD(pTrace->vecEndPos.z);
-			WRITE_SHORT((short)ENTINDEX(pTrace->pHit));
+			WRITE_SHORT((int)ENTINDEX(pTrace->pHit));
 			WRITE_BYTE(index);
 		MESSAGE_END();
 	}
@@ -1286,11 +1304,11 @@ void UTIL_GunshotDecalTrace(TraceResult *pTrace, int decalNumber, bool ClientOnl
 		MESSAGE_BEGIN(MSG_PAS, SVC_TEMPENTITY, pTrace->vecEndPos);
 
 	WRITE_BYTE(TE_GUNSHOTDECAL);
-	WRITE_COORD(pTrace->vecEndPos.x);
+		WRITE_COORD(pTrace->vecEndPos.x);
-	WRITE_COORD(pTrace->vecEndPos.y);
+		WRITE_COORD(pTrace->vecEndPos.y);
-	WRITE_COORD(pTrace->vecEndPos.z);
+		WRITE_COORD(pTrace->vecEndPos.z);
-	WRITE_SHORT((short)ENTINDEX(pTrace->pHit));
+		WRITE_SHORT((int)ENTINDEX(pTrace->pHit));
-	WRITE_BYTE(index);
+		WRITE_BYTE(index);
 	MESSAGE_END();
 }
 
@@ -1350,7 +1368,7 @@ void UTIL_StringToVector(float *pVector, const char *pString)
 
 	for (j = 0; j < 3; j++)
 	{
-		pVector[j] = atof(pfront);
+		pVector[j] = Q_atof(pfront);
 
 		while (*pstr && *pstr != ' ')
 			pstr++;
@@ -1381,7 +1399,7 @@ void UTIL_StringToIntArray(int *pVector, int count, const char *pString)
 
 	for (j = 0; j < count; j++)
 	{
-		pVector[j] = atoi(pfront);
+		pVector[j] = Q_atoi(pfront);
 
 		while (*pstr && *pstr != ' ')
 			pstr++;
@@ -1537,7 +1555,9 @@ void UTIL_PrecacheOther(const char *szClassname)
 
 	CBaseEntity *pEntity = CBaseEntity::Instance(VARS(pent));
 	if (pEntity)
+	{
 		pEntity->Precache();
+	}
 
 	REMOVE_ENTITY(pent);
 }
@@ -1549,13 +1569,7 @@ void UTIL_LogPrintf(char *fmt, ...)
 	static char string[1024];
 
 	va_start(argptr, fmt);
-
-#ifdef REGAMEDLL_FIXES
-	Q_vsnprintf(string, sizeof(string), fmt, argptr);
-#else
 	vsprintf(string, fmt, argptr);
-#endif // REGAMEDLL_FIXES
-
 	va_end(argptr);
 
 	ALERT(at_logged, "%s", string);
@@ -1662,8 +1676,8 @@ int CSaveRestoreBuffer::EntityFlagsSet(int entityIndex, int flags)
 	if (!m_pdata || entityIndex < 0 || entityIndex > m_pdata->tableCount)
 		return 0;
 
-	m_pdata->pTable[entityIndex].flags |= flags;
+	m_pdata->pTable[ entityIndex ].flags |= flags;
-	return m_pdata->pTable[entityIndex].flags;
+	return m_pdata->pTable[ entityIndex ].flags;
 }
 
 /* <1b0445> ../cstrike/dlls/util.cpp:1933 */
@@ -1866,10 +1880,10 @@ void EntvarsKeyvalue(entvars_t *pev, KeyValueData *pkvd)
 				break;
 			case FIELD_FLOAT:
 			case FIELD_TIME:
-				*(float *)((char *)pev + pField->fieldOffset) = atof(pkvd->szValue);
+				*(float *)((char *)pev + pField->fieldOffset) = Q_atof(pkvd->szValue);
 				break;
 			case FIELD_INTEGER:
-				*(string_t *)((char *)pev + pField->fieldOffset) = atoi(pkvd->szValue);
+				*(string_t *)((char *)pev + pField->fieldOffset) = Q_atoi(pkvd->szValue);
 				break;
 			case FIELD_VECTOR:
 			case FIELD_POSITION_VECTOR:
@@ -1910,7 +1924,7 @@ int CSave::WriteFields(const char *pname, void *pBaseData, TYPEDESCRIPTION *pFie
 			emptyCount++;
 	}
 
-	int entityArray[MAX_ENTITYARRAY];
+	int entityArray[ MAX_ENTITY_ARRAY ];
 	int actualCount = fieldCount - emptyCount;
 
 	WriteInt(pname, &actualCount, 1);
@@ -1944,8 +1958,8 @@ int CSave::WriteFields(const char *pname, void *pBaseData, TYPEDESCRIPTION *pFie
 			case FIELD_ENTITY:
 			case FIELD_EHANDLE:
 			{
-				if (pTest->fieldSize > MAX_ENTITYARRAY)
+				if (pTest->fieldSize > MAX_ENTITY_ARRAY)
-					ALERT(at_error, "Can't save more than %d entities in an array!!!\n", MAX_ENTITYARRAY);
+					ALERT(at_error, "Can't save more than %d entities in an array!!!\n", MAX_ENTITY_ARRAY);
 
 				for (int j = 0; j < pTest->fieldSize; j++)
 				{
@@ -2032,7 +2046,7 @@ void CSave::BufferField(const char *pname, int size, const char *pdata)
 void CSave::BufferHeader(const char *pname, int size)
 {
 	short hashvalue = TokenHash(pname);
-	if (size > (1<<(sizeof(short) * 8)))
+	if (size > (1 << (sizeof(short) * 8)))
 		ALERT(at_error, "CSave :: BufferHeader() size parameter exceeds 'short'!");
 
 	BufferData((const char *)&size, sizeof(short));