Move dlls/ to modules/

modules/tfcx/AMBuilder

@@ -0,0 +1,20 @@
+# vim: set sts=2 ts=8 sw=2 tw=99 et ft=python:
+import os.path
+
+binary = AMXX.MetaModule(builder, 'tfcx')
+
+binary.sources = [
+  '../../public/sdk/amxxmodule.cpp',
+  'CRank.cpp',
+  'CMisc.cpp',
+  'NBase.cpp',
+  'NRank.cpp',
+  'usermsg.cpp',
+  'Utils.cpp',
+  'moduleconfig.cpp',
+]
+
+if builder.target_platform == 'windows':
+  binary.sources += ['version.rc']
+  
+AMXX.modules += [builder.Add(binary)]

modules/tfcx/CMisc.cpp

@@ -0,0 +1,283 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#include "amxxmodule.h"
+#include "CMisc.h"
+#include "tfcx.h"
+
+
+// *****************************************************
+// class Grenades
+// *****************************************************
+void Grenades::put( edict_t* grenade, float time, int type, CPlayer* player  )
+{
+  Obj* a = new Obj;
+  if ( a == 0 ) return;
+  a->player = player;
+  a->grenade = grenade;
+  a->time = gpGlobals->time + time;
+  a->type = type;
+  a->prev = 0;
+  a->next = head;
+  if ( head ) head->prev = a;
+  head = a;
+}
+
+bool Grenades::find( edict_t* enemy, CPlayer** p, int* type )
+{
+  bool found = false;
+  Obj* a = head;
+  while ( a ){
+    if ( a->time > gpGlobals->time ) {
+      if ( a->grenade == enemy && !found ) {
+        found = true;
+        *p = a->player;
+        *type = a->type;
+      }
+    }
+    else {
+      Obj* next = a->next;
+      if (a->prev)  a->prev->next = next;
+      else  head = next;
+      if (next) next->prev = a->prev;
+      delete a;
+      a = next;
+      continue;
+    }
+    a = a->next;
+  }
+  return found;
+}
+
+void Grenades::clear()
+{
+  while(head){
+    Obj* a = head->next;
+    delete head;
+    head = a;
+  }
+}
+
+// *****************************************************
+// class CPlayer
+// *****************************************************
+
+void CPlayer::Disconnect(){
+	
+	ingame = false;
+	bot = false;
+
+	if ( ignoreBots(pEdict) || !isModuleActive() ) // ignore if he is bot and bots rank is disabled or module is paused
+		return;
+
+	rank->updatePosition( &life );
+	rank = 0;
+}
+
+void CPlayer::PutInServer(){
+
+	ingame = true;
+
+	if ((int)tfcstats_rankbots->value == 0 && IsBot()) // ignoreBots() can't be used as bot's flags are not set yet.
+		return;
+
+	restartStats();
+
+	const char* name = STRING(pEdict->v.netname);
+	const char* unique = name;
+	bool isip = false;
+	switch((int)tfcstats_rank->value) {
+	case 1: 
+		if ( (unique = GETPLAYERAUTHID(pEdict)) == 0 )
+			unique = name; // failed to get authid
+		break;
+	case 2:
+		unique = ip;
+		isip = true;
+	}
+	rank = g_rank.findEntryInRank( unique , name , isip);
+}
+void CPlayer::Connect(const char* address ){
+	bot = IsBot();
+	strcpy(ip,address);
+	// Strip the port from the ip
+	for (size_t i = 0; i < sizeof(ip); i++)
+	{
+		if (ip[i] == ':')
+		{
+			ip[i] = '\0';
+			break;
+		}
+	}
+	rank = 0;
+	clearStats = 0.0f;
+}
+
+void CPlayer::restartStats(bool all)
+{
+	if ( all ) memset(weapons,0,sizeof(weapons));
+	memset(weaponsRnd,0,sizeof(weaponsRnd));   //DEC-Weapon (Round) stats
+	memset(attackers,0,sizeof(attackers));
+	memset(victims,0,sizeof(victims));
+	memset(&life,0,sizeof(life));
+}
+
+void CPlayer::Init( int pi, edict_t* pe )
+{
+    pEdict = pe;
+    index = pi;
+	current = 0;
+	clearStats = 0.0f;
+	rank = 0;
+	ingame = false;
+	bot = false;
+}
+
+void CPlayer::saveKill(CPlayer* pVictim, int wweapon, int hhs, int ttk)
+{
+	if (!isModuleActive())
+		return;
+
+	if ( ignoreBots(pEdict,pVictim->pEdict) )
+		return;
+
+	//PRINT_CONSOLE("Death! Killer:%d Victim:%d weapon:%d hs:%d tk:%d\n",index,pVictim->index,wweapon,hhs,ttk);
+
+	if ( pVictim->index == index ){ // killed self
+		pVictim->weapons[0].deaths++;
+		pVictim->life.deaths++;
+		pVictim->weaponsRnd[0].deaths++;       // DEC-Weapon (round) stats
+		return;
+	}
+
+	pVictim->attackers[index].name = weaponData[wweapon].name;
+	pVictim->attackers[index].kills++;
+	pVictim->attackers[index].hs += hhs;
+	pVictim->attackers[index].tks += ttk;
+	pVictim->attackers[0].kills++;
+	pVictim->attackers[0].hs += hhs;
+	pVictim->attackers[0].tks += ttk;
+	pVictim->weapons[pVictim->current].deaths++;
+	pVictim->weapons[0].deaths++;
+	pVictim->life.deaths++;
+	
+	
+	pVictim->weaponsRnd[pVictim->current].deaths++; // DEC-Weapon (round) stats
+	pVictim->weaponsRnd[0].deaths++;                   // DEC-Weapon (round) stats
+	
+	int vi = pVictim->index;
+	victims[vi].name = weaponData[wweapon].name;
+	victims[vi].deaths++;
+	victims[vi].hs += hhs;
+	victims[vi].tks += ttk;
+	victims[0].deaths++;
+	victims[0].hs += hhs;
+	victims[0].tks += ttk;
+	
+	
+	weaponsRnd[wweapon].kills++;                // DEC-Weapon (round) stats
+	weaponsRnd[wweapon].hs += hhs;         // DEC-Weapon (round) stats
+	weaponsRnd[wweapon].tks += ttk;     // DEC-Weapon (round) stats
+	weaponsRnd[0].kills++;                     // DEC-Weapon (round) stats
+	weaponsRnd[0].hs += hhs;              // DEC-Weapon (round) stats
+	weaponsRnd[0].tks += ttk;          // DEC-Weapon (round) stats
+	
+	weapons[wweapon].kills++;
+	weapons[wweapon].hs += hhs;
+	weapons[wweapon].tks += ttk;
+	weapons[0].kills++;
+	weapons[0].hs += hhs;
+	weapons[0].tks += ttk;
+	life.kills++;
+	life.hs += hhs;
+	life.tks += ttk;
+}
+
+void CPlayer::saveHit(CPlayer* pVictim, int wweapon, int ddamage, int bbody)
+{
+	if (!isModuleActive())
+		return;
+
+	if ( ignoreBots(pEdict,pVictim->pEdict) )
+		return;
+
+	if ( ignoreDamage )
+		return;
+
+	//PRINT_CONSOLE("Hit! Attacker:%d Victim:%d weapon:%d damage:%d body:%d\n",index,pVictim->index,wweapon,ddamage,bbody);
+
+	if ( index == pVictim->index ) return;
+
+	pVictim->attackers[index].hits++;
+	pVictim->attackers[index].damage += ddamage;
+	pVictim->attackers[index].bodyHits[bbody]++;
+	pVictim->attackers[0].hits++;
+	pVictim->attackers[0].damage += ddamage;
+	pVictim->attackers[0].bodyHits[bbody]++;
+
+	int vi = pVictim->index;
+	victims[vi].hits++;
+	victims[vi].damage += ddamage;
+	victims[vi].bodyHits[bbody]++;
+	victims[0].hits++;
+	victims[0].damage += ddamage;
+	victims[0].bodyHits[bbody]++;
+
+	weaponsRnd[wweapon].hits++;              // DEC-Weapon (round) stats
+	weaponsRnd[wweapon].damage += ddamage;    // DEC-Weapon (round) stats
+	weaponsRnd[wweapon].bodyHits[bbody]++;   // DEC-Weapon (round) stats
+	weaponsRnd[0].hits++;                   // DEC-Weapon (round) stats
+	weaponsRnd[0].damage += ddamage;         // DEC-Weapon (round) stats
+	weaponsRnd[0].bodyHits[bbody]++;        // DEC-Weapon (round) stats
+
+	weapons[wweapon].hits++;
+	weapons[wweapon].damage += ddamage;
+	weapons[wweapon].bodyHits[bbody]++;
+	weapons[0].hits++;
+	weapons[0].damage += ddamage;
+	weapons[0].bodyHits[bbody]++;
+
+	life.hits++;
+	life.damage += ddamage;
+	life.bodyHits[bbody]++;
+}
+
+void CPlayer::saveShot(int weapon)
+{
+	if (!isModuleActive())
+		return;
+
+	//PRINT_CONSOLE("Shot! Weapon:%d\n",weapon);
+
+	if ( ignoreBots(pEdict) )
+		return;
+
+	if ( ignoreDamage )
+		return;
+
+	victims[0].shots++;
+	weapons[weapon].shots++;
+	weapons[0].shots++;
+	life.shots++;
+	weaponsRnd[weapon].shots++;       // DEC-Weapon (round) stats
+	weaponsRnd[0].shots++;            // DEC-Weapon (round) stats
+}
+
+void CPlayer::killPlayer(){
+	pEdict->v.dmg_inflictor = NULL;
+	pEdict->v.health = 0;
+	pEdict->v.deadflag = DEAD_RESPAWNABLE;
+	pEdict->v.weaponmodel = 0;
+	pEdict->v.weapons = 0;
+}

modules/tfcx/CMisc.h

@@ -0,0 +1,215 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#ifndef CMISC_H
+#define CMISC_H
+
+#include "amxxmodule.h"
+#include "CRank.h"
+
+#if defined(_WIN32)
+	#define LINUXOFFSET		0
+	#define CLIP_LINUXOFFSET	0
+#else
+	#define LINUXOFFSET		4
+	#define CLIP_LINUXOFFSET	4
+#endif
+
+#define TFCMAX_CUSTOMWPNS	5
+#define TFCMAX_WEAPONS		MAX_WEAPONS + TFCMAX_CUSTOMWPNS
+
+#define PD_HAS_GOALITEM		26  + LINUXOFFSET
+#define PD_GOALITEM_TEAM	36  + LINUXOFFSET
+#define PD_SENTRY_OWNER		83	+ LINUXOFFSET
+#define PD_TIMER_OWNER		932	+ LINUXOFFSET
+
+// If somehow TFC updates, the following two offsets can be updated by
+// disassembling CBaseEntity::KeyValuePartThree(KeyValueData_s *)
+#define PD_REPLACE_MODEL	170 + LINUXOFFSET
+#define PD_REPLACE_SKIN		172 + LINUXOFFSET
+
+
+#define MAX_TRACE		13
+//#define NADE_OFFSET		24
+
+#define ACT_NADE_NONE		0
+#define ACT_NADE_SHOT		1<<0
+#define ACT_NADE_PUT		1<<1
+
+#define PD_AMMO_SHELLS		53	+ LINUXOFFSET
+#define PD_AMMO_BULLETS		55	+ LINUXOFFSET
+#define PD_AMMO_CELLS		57	+ LINUXOFFSET
+#define PD_AMMO_ROCKETS		59	+ LINUXOFFSET
+#define PD_AMMO_NADE1		14	+ LINUXOFFSET
+#define PD_AMMO_NADE2		15	+ LINUXOFFSET
+
+#define PD_WEAPON_AMMO		307 + CLIP_LINUXOFFSET
+
+// For tfc_get_user_goalitem
+#define CARRYING_GOALITEM (1<<0)
+
+enum {
+	TFC_AMMO_SHELLS = 0,
+	TFC_AMMO_BULLETS,
+	TFC_AMMO_CELLS,
+	TFC_AMMO_ROCKETS,
+	TFC_AMMO_NADE1,
+	TFC_AMMO_NADE2,
+};
+
+enum {
+	TFC_WPN_NONE = 0,
+	TFC_WPN_TIMER, // TFC_UNK_1,
+	TFC_WPN_SENTRYGUN, //TFC_WPN_UNK2,
+	TFC_WPN_MEDIKIT,
+	TFC_WPN_SPANNER,
+	TFC_WPN_AXE,
+	TFC_WPN_SNIPERRIFLE,
+	TFC_WPN_AUTORIFLE,
+	TFC_WPN_SHOTGUN,
+	TFC_WPN_SUPERSHOTGUN,
+	TFC_WPN_NG,
+	TFC_WPN_SUPERNG,
+	TFC_WPN_GL,
+	TFC_WPN_FLAMETHROWER,
+	TFC_WPN_RPG,
+	TFC_WPN_IC,
+	TFC_WPN_FLAMES,//TFC_WPN_UNK16,
+	TFC_WPN_AC,
+	TFC_WPN_UNK18,
+	TFC_WPN_UNK19,
+	TFC_WPN_TRANQ,
+	TFC_WPN_RAILGUN,
+	TFC_WPN_PL,
+	TFC_WPN_KNIFE,
+	TFC_WPN_CALTROP, // 24
+	TFC_WPN_CONCUSSIONGRENADE,
+	TFC_WPN_NORMALGRENADE,
+	TFC_WPN_NAILGRENADE,
+	TFC_WPN_MIRVGRENADE,
+	TFC_WPN_NAPALMGRENADE,
+	TFC_WPN_GASGRENADE,
+	TFC_WPN_EMPGRENADE,
+};
+
+enum {
+	TFC_PC_SCOUT = 1,
+	TFC_PC_SNIPER,
+	TFC_PC_SOLDIER,
+	TFC_PC_DEMOMAN,
+	TFC_PC_MEDIC,
+	TFC_PC_HWGUY,
+	TFC_PC_PYRO,
+	TFC_PC_SPY,
+	TFC_PC_ENGENEER,	// Typo; preserved for backward compatibility
+	TFC_PC_ENGINEER = 9,
+	TFC_PC_CIVILIAN = 11,
+};
+
+struct weaponsVault {
+  char name[32];
+  char logName[32];
+  short int ammoSlot;
+  bool melee;
+};
+
+struct traceVault {
+	const char* szName;
+	char szTag[6];
+	int iId;
+	int iAction;
+	float fDel;
+	int start;
+	int stop;
+};
+
+
+
+// *****************************************************
+// class CPlayer
+// *****************************************************
+
+struct CPlayer {
+
+	edict_t* pEdict;
+	char ip[32];
+	int index;
+	int aiming;
+	int current;
+
+	bool ingame;
+	bool bot;
+	float clearStats;
+	RankSystem::RankStats*	rank;
+
+	struct PlayerWeapon : Stats {
+		const char* name;
+		int	ammo;
+		int	clip;
+	};
+
+	PlayerWeapon	weapons[MAX_WEAPONS];
+	PlayerWeapon	attackers[33];
+	PlayerWeapon	victims[33];
+	Stats			weaponsRnd[MAX_WEAPONS]; // DEC-Weapon (Round) stats
+	Stats			life;
+
+	int teamId;
+	int classId;
+
+	void Init(  int pi, edict_t* pe );
+	void Connect(const char* ip );
+	void PutInServer();
+	void Disconnect();
+	void saveKill(CPlayer* pVictim, int weapon, int hs, int tk);
+	void saveHit(CPlayer* pVictim, int weapon, int damage, int aiming);
+	void saveShot(int weapon);
+	void restartStats(bool all = true);
+	void killPlayer();
+	inline bool IsBot(){
+		const char* auth= (*g_engfuncs.pfnGetPlayerAuthId)(pEdict);
+		return ( auth && !strcmp( auth , "BOT" ) );
+	}
+	inline bool IsAlive(){
+		return ((pEdict->v.deadflag==DEAD_NO)&&(pEdict->v.health>0));
+	}
+};
+
+// *****************************************************
+// class Grenades
+// *****************************************************
+
+class Grenades
+{
+  struct Obj
+  {
+    CPlayer* player;
+    edict_t* grenade;
+    float time;
+    int type;
+    Obj* next;
+    Obj* prev;
+  } *head;
+
+
+public:
+  Grenades() { head = 0; }
+  ~Grenades() { clear(); }
+  void put( edict_t* grenade, float time, int type, CPlayer* player  );
+  bool find( edict_t* enemy, CPlayer** p, int* type );
+  void clear();
+};
+
+#endif // CMISC_H
+

modules/tfcx/CRank.cpp

@@ -0,0 +1,345 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#include "amxxmodule.h"
+#include "CRank.h"
+#include "tfcx.h"
+
+// *****************************************************
+// class Stats
+// *****************************************************
+Stats::Stats(){
+	hits = shots = damage = hs = tks = kills = deaths = 0;
+	memset( bodyHits , 0 ,sizeof( bodyHits ) );
+}
+void Stats::commit(Stats* a){
+	hits += a->hits;
+	shots += a->shots;
+	damage += a->damage;
+	hs += a->hs;
+	tks += a->tks;
+	kills += a->kills;
+	deaths += a->deaths;
+	for(int i = 1; i < 8; ++i)
+		bodyHits[i] += a->bodyHits[i];
+}
+
+// *****************************************************
+// class RankSystem
+// *****************************************************
+RankSystem::RankStats::RankStats( const char* uu, const char* nn, RankSystem* pp ) {
+	name = 0;
+	namelen = 0;
+	unique = 0;
+	uniquelen = 0;
+	score = 0;
+	parent = pp;
+	id = ++parent->rankNum;
+	next = prev = 0;
+	setName( nn );
+	setUnique( uu );
+}
+RankSystem::RankStats::~RankStats() {
+	delete[] name;
+	delete[] unique;
+	--parent->rankNum;
+}
+void RankSystem::RankStats::setName( const char* nn  )	{
+	delete[] name;
+	namelen = strlen(nn) + 1;
+	name = new char[namelen];
+	if ( name )
+		strcpy( name , nn );
+	else
+		namelen = 0;
+}
+void RankSystem::RankStats::setUnique( const char* nn  )	{
+	delete[] unique;
+	uniquelen = strlen(nn) + 1;
+	unique = new char[uniquelen];
+	if ( unique )
+		strcpy( unique , nn );	
+	else
+		uniquelen = 0;
+}
+
+RankSystem::RankSystem() { 
+	head = 0; 
+	tail = 0; 
+	rankNum = 0;
+	calc.code = 0;
+}
+
+RankSystem::~RankSystem() {
+	clear();
+}
+
+void RankSystem::put_before( RankStats* a, RankStats* ptr ){
+	a->next = ptr;
+	if ( ptr ){
+		a->prev = ptr->prev;
+		ptr->prev = a;
+	}
+	else{
+		a->prev = head;
+		head = a;
+	}
+	if ( a->prev )	a->prev->next = a;
+	else tail = a;
+}
+void  RankSystem::put_after( RankStats* a, RankStats* ptr ) {
+	a->prev = ptr;
+	if ( ptr ){
+		a->next = ptr->next;
+		ptr->next = a;
+	}
+	else{
+		a->next = tail;
+		tail = a;
+	}
+	if ( a->next )	a->next->prev = a;
+	else head = a;
+}
+
+void RankSystem::unlink( RankStats* ptr ){
+	if (ptr->prev) ptr->prev->next = ptr->next;
+	else tail = ptr->next;
+	if (ptr->next) ptr->next->prev = ptr->prev;
+	else head = ptr->prev;
+}
+
+void RankSystem::clear(){
+	while( tail ){
+		head = tail->next;
+		delete tail;
+		tail = head;
+	}
+}
+
+bool RankSystem::loadCalc(const char* filename, char* error)
+{
+	if ((MF_LoadAmxScript(&calc.amx,&calc.code,filename,error,0)!=AMX_ERR_NONE)||
+		(MF_AmxAllot(&calc.amx, 8 , &calc.amxAddr1, &calc.physAddr1)!=AMX_ERR_NONE)||
+		(MF_AmxAllot(&calc.amx, 8 , &calc.amxAddr2, &calc.physAddr2)!=AMX_ERR_NONE)||
+		(MF_AmxFindPublic(&calc.amx,"get_score",&calc.func)!=AMX_ERR_NONE)){
+		MF_PrintSrvConsole("Couldn't load plugin (file \"%s\")",filename);
+		MF_UnloadAmxScript(&calc.amx, &calc.code);
+		return false;
+	}
+	return true;
+}
+void RankSystem::unloadCalc()
+{
+	MF_UnloadAmxScript(&calc.amx , &calc.code);
+}
+
+RankSystem::RankStats* RankSystem::findEntryInRank(const char* unique, const char* name, bool isip)
+{
+	RankStats* a = head;
+	
+	if (isip) // IP lookups need to strip the port from already saved instances.
+	{         // Otherwise the stats file would be essentially reset.
+	
+		// The IP passed does not contain the port any more for unique
+		size_t iplen = strlen(unique);
+		
+		
+		while ( a )
+		{
+			const char* targetUnique = a->getUnique();
+			if ( strncmp( targetUnique, unique, iplen) == 0 )
+			{
+				// It mostly matches, make sure this isn't a false match
+				// eg: checking 4.2.2.2 would match 4.2.2.24 here.
+				
+				// Get the next character stored in targetUnique
+				char c = targetUnique[iplen];
+				
+				// If c is either a colon or end of line, then this
+				// is a valid match.
+				if (c == ':' ||
+					c == '\0')
+				{
+					// Yes, this is a match.
+					return a;
+				}
+				// Any other case was a false match.
+				a = a->prev;
+			}
+		}
+	}
+	else // No special case
+	{
+		while ( a )
+		{
+			if (  strcmp( a->getUnique() ,unique ) == 0 )
+				return a;
+
+			a = a->prev;
+		}
+	}
+	a = new RankStats( unique ,name,this );
+	if ( a == 0 ) return 0;
+	put_after( a  , 0 );
+	return a;
+}
+
+void RankSystem::updatePos(  RankStats* rr ,  Stats* s )
+{
+	rr->addStats( s );
+
+	if ( calc.code ) {
+		calc.physAddr1[0] = rr->kills;
+		calc.physAddr1[1] = rr->deaths;
+		calc.physAddr1[2] = rr->hs;
+		calc.physAddr1[3] = rr->tks;
+		calc.physAddr1[4] = rr->shots;
+		calc.physAddr1[5] = rr->hits;
+		calc.physAddr1[6] = rr->damage;
+		for(int i = 1; i < 8; ++i)
+			calc.physAddr2[i] = rr->bodyHits[i];
+		cell result = 0;
+		int err;
+		MF_AmxPush(&calc.amx, calc.amxAddr2);
+		MF_AmxPush(&calc.amx, calc.amxAddr1);
+		if ((err = MF_AmxExec(&calc.amx,&result, calc.func)) != AMX_ERR_NONE)
+			MF_LogError(&calc.amx, err, "Fatal error calculating stats");
+		rr->score = result;
+	}
+	else rr->score = rr->kills - rr->deaths;
+
+	RankStats* aa = rr->next;
+	while ( aa && (aa->score <= rr->score) ) { // try to nominate
+		rr->goUp();
+		aa->goDown();
+		aa = aa->next;		// go to next rank
+	}
+	if ( aa != rr->next )
+	{
+		unlink( rr );
+		put_before( rr, aa );
+	}
+	else
+	{
+		aa = rr->prev;
+		while ( aa && (aa->score > rr->score) ) { // go down
+			rr->goDown();
+			aa->goUp();
+			aa = aa->prev;	// go to prev rank
+		}
+		if ( aa != rr->prev ){
+			unlink( rr );
+			put_after( rr, aa );
+		}
+	}
+
+}
+
+
+/** 
+ * Who put these backwards...
+ */
+#define TRYREAD(t_var, t_num, t_size, t_file) \
+	if (fread(t_var, t_size, t_num, t_file) != static_cast<size_t>(t_num)) { \
+		break; \
+	}
+
+void RankSystem::loadRank(const char* filename)
+{
+	FILE *bfp = fopen(filename , "rb");
+	
+	if (!bfp)
+	{
+		MF_Log("Could not load stats file: %s", filename);
+		return;
+	}
+	
+	short int i = 0;
+	if (fread(&i, sizeof(short int), 1, bfp) != 1)
+	{
+		fclose(bfp);
+		return;
+	}
+	
+	if (i == RANK_VERSION)
+	{
+		Stats d;
+		char unique[64], name[64];
+		if (fread(&i, sizeof(short int), 1, bfp) != 1)
+		{
+			fclose(bfp);
+			return;
+		}
+
+		while(i && !feof(bfp))
+		{
+			TRYREAD(name, i, sizeof(char), bfp);
+			TRYREAD(&i, 1, sizeof(short int), bfp);
+			TRYREAD(unique, i, sizeof(char), bfp);
+			TRYREAD(&d.tks, 1, sizeof(int), bfp);
+			TRYREAD(&d.damage, 1, sizeof(int), bfp);
+			TRYREAD(&d.deaths, 1, sizeof(int), bfp);
+			TRYREAD(&d.kills, 1, sizeof(int), bfp);
+			TRYREAD(&d.shots, 1, sizeof(int), bfp);
+			TRYREAD(&d.hits, 1, sizeof(int), bfp);
+			TRYREAD(&d.hs, 1, sizeof(int), bfp);
+			TRYREAD(d.bodyHits, 1, sizeof(d.bodyHits), bfp);
+			TRYREAD(&i, 1, sizeof(short int), bfp);
+
+			RankSystem::RankStats* a = findEntryInRank( unique , name );
+			if ( a ) a->updatePosition( &d );
+		}
+	}
+	
+	fclose(bfp);
+}
+
+void RankSystem::saveRank( const char* filename )
+{
+	FILE *bfp = fopen(filename, "wb");
+	
+	if ( !bfp ) return;
+			
+	short int i = RANK_VERSION;
+	
+	fwrite(&i, 1, sizeof(short int) , bfp);
+	
+	RankSystem::iterator a = front();
+	
+	while ( a )
+	{
+		if ( (*a).score != (1<<31) ) // score must be different than mincell
+		{
+			fwrite( &(*a).namelen , 1, sizeof(short int), bfp);
+			fwrite( (*a).name , (*a).namelen , sizeof(char) , bfp);
+			fwrite( &(*a).uniquelen , 1, sizeof(short int), bfp);
+			fwrite( (*a).unique ,  (*a).uniquelen , sizeof(char) , bfp);
+			fwrite( &(*a).tks, 1, sizeof(int), bfp);
+			fwrite( &(*a).damage, 1, sizeof(int), bfp);
+			fwrite( &(*a).deaths, 1, sizeof(int), bfp);
+			fwrite( &(*a).kills, 1, sizeof(int), bfp);
+			fwrite( &(*a).shots, 1, sizeof(int), bfp);
+			fwrite( &(*a).hits, 1, sizeof(int), bfp);
+			fwrite( &(*a).hs, 1, sizeof(int), bfp);
+			fwrite( (*a).bodyHits, 1, sizeof((*a).bodyHits), bfp);
+		}
+		
+		--a;
+	}
+
+	i = 0;
+	fwrite( &i , 1, sizeof(short int), bfp); // null terminator
+	
+	fclose(bfp);
+}

modules/tfcx/CRank.h

@@ -0,0 +1,126 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#ifndef CRANK_H
+#define CRANK_H
+
+#define RANK_VERSION 5
+
+
+// *****************************************************
+// class Stats
+// *****************************************************
+
+struct Stats {
+	int hits;
+	int shots;
+	int damage;
+	int hs;
+	int tks;
+	int kills;
+	int deaths;
+	int bodyHits[8];
+	Stats();
+	void commit(Stats* a);
+};
+
+// *****************************************************
+// class RankSystem
+// *****************************************************
+
+class RankSystem
+{
+public:
+	class RankStats;
+	friend class RankStats;
+	class iterator;
+
+	class RankStats : public Stats {
+		friend class RankSystem;
+		friend class iterator;
+		RankSystem*	parent;
+		RankStats*	next;
+		RankStats*	prev;
+		char*		unique;
+		short int	uniquelen;
+		char*		name;
+		short int	namelen;
+		int			score;
+		int			id;
+		RankStats( const char* uu, const char* nn,  RankSystem* pp );
+		~RankStats();
+		void setUnique( const char* nn  );
+		inline void goDown() {++id;}
+		inline void goUp() {--id;}
+		inline void addStats(Stats* a) { commit( a ); }
+	public:
+		void setName( const char* nn  );
+		inline const char* getName() const { return name ? name : ""; }
+		inline const char* getUnique() const { return unique ? unique : ""; }
+		inline int getPosition() const { return id; }
+		inline void updatePosition( Stats* points ) {
+			parent->updatePos( this , points );
+		}
+	};
+
+private:
+	RankStats* head;
+	RankStats* tail;
+	int rankNum;
+
+	struct scoreCalc{
+		AMX amx;
+		void* code;
+		int func;
+		cell amxAddr1;
+		cell amxAddr2;
+		cell *physAddr1;
+		cell *physAddr2;
+	} calc;
+
+	void put_before( RankStats* a, RankStats* ptr );
+	void put_after( RankStats* a, RankStats* ptr );
+	void unlink( RankStats* ptr );
+	void updatePos( RankStats* r ,  Stats* s );
+	
+public:
+
+	RankSystem();
+	~RankSystem();
+
+	void saveRank( const char* filename );
+	void loadRank( const char* filename );
+	RankStats* findEntryInRank(const char* unique, const char* name , bool isip = false);
+	bool loadCalc(const char* filename, char* error);
+	inline int getRankNum( ) const { return rankNum; }
+	void clear();
+	void unloadCalc();
+
+	class iterator {
+		RankStats* ptr;
+	public:
+		iterator(RankStats* a): ptr(a){}
+		inline iterator& operator--() { ptr = ptr->prev; return *this;}
+		inline iterator& operator++() {	ptr = ptr->next; return *this; }
+		inline RankStats& operator*() {	return *ptr;}
+		operator bool () { return (ptr != 0); }
+	};
+
+	inline iterator front() {  return iterator(head);  }
+	inline iterator begin() {  return iterator(tail);  }
+};
+
+
+#endif
+

modules/tfcx/Makefile

@@ -0,0 +1,125 @@
+# (C)2004-2013 AMX Mod X Development Team
+# Makefile written by David "BAILOPAN" Anderson
+
+###########################################
+### EDIT THESE PATHS FOR YOUR OWN SETUP ###
+###########################################
+
+HLSDK = ../../../hlsdk
+MM_ROOT = ../../../metamod/metamod
+PUBLIC_ROOT = ../../public
+
+#####################################
+### EDIT BELOW FOR OTHER PROJECTS ###
+#####################################
+
+PROJECT = tfcx
+
+OBJECTS = amxxmodule.cpp CRank.cpp CMisc.cpp NBase.cpp NRank.cpp usermsg.cpp Utils.cpp \
+	  moduleconfig.cpp
+
+##############################################
+### CONFIGURE ANY OTHER FLAGS/OPTIONS HERE ###
+##############################################
+
+C_OPT_FLAGS = -DNDEBUG -O3 -funroll-loops -fomit-frame-pointer -pipe
+C_DEBUG_FLAGS = -D_DEBUG -DDEBUG -g -ggdb3
+C_GCC4_FLAGS = -fvisibility=hidden
+CPP_GCC4_FLAGS = -fvisibility-inlines-hidden
+CPP = gcc
+CPP_OSX = clang
+
+LINK =
+
+INCLUDE = -I. -I$(PUBLIC_ROOT) -I$(PUBLIC_ROOT)/sdk -I$(PUBLIC_ROOT)/amtl \
+			  -I$(HLSDK) -I$(HLSDK)/public -I$(HLSDK)/common -I$(HLSDK)/dlls -I$(HLSDK)/engine -I$(HLSDK)/game_shared -I$(HLSDK)/pm_shared\
+			  -I$(MM_ROOT)
+
+################################################
+### DO NOT EDIT BELOW HERE FOR MOST PROJECTS ###
+################################################
+
+OS := $(shell uname -s)
+
+ifeq "$(OS)" "Darwin"
+	CPP = $(CPP_OSX)
+	LIB_EXT = dylib
+	LIB_SUFFIX = _amxx
+	CFLAGS += -DOSX
+	LINK += -dynamiclib -lstdc++ -mmacosx-version-min=10.5
+else
+	LIB_EXT = so
+	LIB_SUFFIX = _amxx_i386
+	CFLAGS += -DLINUX
+	LINK += -shared
+endif
+
+LINK += -m32 -lm -ldl
+
+CFLAGS += -DPAWN_CELL_SIZE=32 -DJIT -DASM32 -DHAVE_STDINT_H -fno-strict-aliasing -m32 -Wall -Werror
+CPPFLAGS += -fno-exceptions -fno-rtti
+
+BINARY = $(PROJECT)$(LIB_SUFFIX).$(LIB_EXT)
+
+ifeq "$(DEBUG)" "true"
+	BIN_DIR = Debug
+	CFLAGS += $(C_DEBUG_FLAGS)
+else
+	BIN_DIR = Release
+	CFLAGS += $(C_OPT_FLAGS)
+	LINK += -s
+endif
+
+IS_CLANG := $(shell $(CPP) --version | head -1 | grep clang > /dev/null && echo "1" || echo "0")
+
+ifeq "$(IS_CLANG)" "1"
+	CPP_MAJOR := $(shell $(CPP) --version | grep clang | sed "s/.*version \([0-9]\)*\.[0-9]*.*/\1/")
+	CPP_MINOR := $(shell $(CPP) --version | grep clang | sed "s/.*version [0-9]*\.\([0-9]\)*.*/\1/")
+else
+	CPP_MAJOR := $(shell $(CPP) -dumpversion >&1 | cut -b1)
+	CPP_MINOR := $(shell $(CPP) -dumpversion >&1 | cut -b3)
+endif
+
+# Clang || GCC >= 4
+ifeq "$(shell expr $(IS_CLANG) \| $(CPP_MAJOR) \>= 4)" "1"
+	CFLAGS += $(C_GCC4_FLAGS)
+	CPPFLAGS += $(CPP_GCC4_FLAGS)
+endif
+
+# Clang >= 3 || GCC >= 4.7
+ifeq "$(shell expr $(IS_CLANG) \& $(CPP_MAJOR) \>= 3 \| $(CPP_MAJOR) \>= 4 \& $(CPP_MINOR) \>= 7)" "1"
+	CPPFLAGS += -Wno-delete-non-virtual-dtor
+endif
+
+# OS is Linux and not using clang
+ifeq "$(shell expr $(OS) \= Linux \& $(IS_CLANG) \= 0)" "1"
+	LINK += -static-libgcc
+endif
+
+OBJ_BIN := $(OBJECTS:%.cpp=$(BIN_DIR)/%.o)
+
+# This will break if we include other Makefiles, but is fine for now. It allows
+#  us to make a copy of this file that uses altered paths (ie. Makefile.mine)
+#  or other changes without mucking up the original.
+MAKEFILE_NAME := $(CURDIR)/$(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST))
+
+$(BIN_DIR)/%.o: %.cpp
+	$(CPP) $(INCLUDE) $(CFLAGS) $(CPPFLAGS) -o $@ -c $<
+
+all:
+	mkdir -p $(BIN_DIR)
+	ln -sf $(PUBLIC_ROOT)/sdk/amxxmodule.cpp
+	$(MAKE) -f $(MAKEFILE_NAME) $(PROJECT)
+
+$(PROJECT): $(OBJ_BIN)
+	$(CPP) $(INCLUDE) $(OBJ_BIN) $(LINK) -o $(BIN_DIR)/$(BINARY)
+
+debug:
+	$(MAKE) -f $(MAKEFILE_NAME) all DEBUG=true
+
+default: all
+
+clean:
+	rm -rf $(BIN_DIR)/*.o
+	rm -f $(BIN_DIR)/$(BINARY)
+

modules/tfcx/NBase.cpp

@@ -0,0 +1,532 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#include "amxxmodule.h"
+#include "tfcx.h"
+
+extern int g_AlliesFlags[4];
+
+// Vexd start
+
+// Set A TFC Player's model. This works differently then CS.
+static cell AMX_NATIVE_CALL TFC_SetModel(AMX *amx, cell *params) { 
+	int iIndex = params[1];
+	// Make sure its a player.
+	CHECK_PLAYER(iIndex);
+
+	int iLen;
+
+	char *szSkin = MF_GetAmxString(amx, params[3],0, &iLen);
+	char *szModel = MF_GetAmxString(amx, params[2],0, &iLen);
+
+	// Get Player's edict pointer
+	edict_t* pPlayer = INDEXENT(iIndex);
+
+	// Set key on client, replacement_model is for the model we want.
+	KeyValueData pkvd;
+	pkvd.szClassName = "player";
+	pkvd.szKeyName = "replacement_model";
+	pkvd.szValue = szModel;
+	pkvd.fHandled = FALSE;
+	(gpGamedllFuncs->dllapi_table->pfnKeyValue)(pPlayer, &pkvd);
+
+	// Set key on client, replacement_model_skin is for what skin we want.
+	KeyValueData pkvd2;
+	pkvd2.szClassName = "player";
+	pkvd2.szKeyName = "replacement_model_skin";
+	pkvd2.szValue = szSkin;
+	pkvd2.fHandled = FALSE;
+	(gpGamedllFuncs->dllapi_table->pfnKeyValue)(pPlayer, &pkvd2);
+
+	// and, like CS, set model in the infobuffer.
+	(g_engfuncs.pfnSetClientKeyValue)(iIndex, (g_engfuncs.pfnGetInfoKeyBuffer)(pPlayer), "model", szModel);
+
+	return 1;
+}
+
+// Clear's a TFC player's model... Almost the same as setting the model.
+// HACKHACK: Is there a better way of doing this? what if the player is random?
+static cell AMX_NATIVE_CALL TFC_ClearModel(AMX *amx, cell *params) { 
+	int iIndex = params[1];
+  
+	CHECK_PLAYER(iIndex)
+
+	edict_t* pPlayer = INDEXENT(iIndex);
+	
+	if (pPlayer->pvPrivateData == NULL)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Player has no private data, cannot clear model!");
+		return 0;
+	}
+
+	// PD_REPLACE_MODEL is the string_t for the replacement model
+	// setting it to 0 will reset the model properly
+	*( (int*)pPlayer->pvPrivateData + PD_REPLACE_MODEL) = 0;
+
+	// PD_REPLACE_SKIN is the integer setting for the skin, by default
+	// it is 0.
+	*( (int*)pPlayer->pvPrivateData + PD_REPLACE_SKIN) = 0;
+
+	return 1;
+	
+	/*
+	// the old, buggy method here
+	int iIndex = params[1];
+  
+	CHECK_PLAYER(iIndex)
+
+	edict_t* pPlayer = INDEXENT(iIndex);
+	
+	char szModel[32];
+	memset(szModel, 0x0, strlen(szModel));
+
+	switch(pPlayer->v.playerclass) {
+		case 1:	//Scout
+			memcpy(szModel, "Scout", strlen("Scout"));
+			break;
+		case 2:	//Sniper
+			memcpy(szModel, "Sniper", strlen("Sniper"));
+			break;
+		case 3:	//Soldier
+			memcpy(szModel, "Soldier", strlen("Soldier"));
+			break;
+		case 4:	//demoman
+			memcpy(szModel, "Demo", strlen("Demo"));
+			//(char *)szModel = "Demo";
+			break;
+		case 5:	//Medic
+			memcpy(szModel, "Medic", strlen("Medic"));
+			break;
+		case 6:	//HWGuy
+			memcpy(szModel, "HvyWeapon", strlen("HvyWeapon"));
+			break;
+		case 7:	//Pyro
+			memcpy(szModel, "Pyro", strlen("Pyro"));
+			break;
+		case 8:	//Spy
+			memcpy(szModel, "Spy", strlen("Spy"));
+			break;
+		case 9:	//Engineer
+			memcpy(szModel, "Engineer", strlen("Engineer"));
+			break;
+		case 11: //Hunted
+			memcpy(szModel, "Civilian", strlen("Civilian"));
+			break;
+		default:
+			break;
+	}
+
+	KeyValueData pkvd;
+	pkvd.szClassName = "player";
+	pkvd.szKeyName = "replacement_model";
+	pkvd.szValue = szModel;
+	pkvd.fHandled = FALSE;
+	(gpGamedllFuncs->dllapi_table->pfnKeyValue)(pPlayer, &pkvd);
+
+	KeyValueData pkvd2;
+	pkvd2.szClassName = "player";
+	pkvd2.szKeyName = "replacement_model_skin";
+	pkvd2.szValue = "0";
+	pkvd2.fHandled = FALSE;
+	(gpGamedllFuncs->dllapi_table->pfnKeyValue)(pPlayer, &pkvd2);
+
+	(g_engfuncs.pfnSetClientKeyValue)(iIndex, (g_engfuncs.pfnGetInfoKeyBuffer)(pPlayer), "model", szModel);
+	
+	return 1;
+	*/
+}
+// Vexd end :)
+
+// AssKicR start
+static cell AMX_NATIVE_CALL TFC_SetBAmmo(AMX *amx, cell *params) { 
+	int iIndex = params[1];
+  
+	CHECK_PLAYER(iIndex);
+	int iValue = params[3];
+		
+	if (iValue < 0 )  {
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid ammo amount %d", iValue);
+		return 0;
+	}
+
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(iIndex);
+
+	switch(params[2]){ // ammo
+	case TFC_AMMO_SHELLS:
+		*( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_SHELLS]) = iValue;
+		break;
+	case TFC_AMMO_BULLETS:
+		*( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_BULLETS]) = iValue;
+		break;
+	case TFC_AMMO_CELLS:
+		*( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_CELLS]) = iValue;
+		break;
+	case TFC_AMMO_ROCKETS:
+		*( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_ROCKETS]) = iValue;
+		break;
+	case TFC_AMMO_NADE1:
+		*( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_NADE1]) = iValue;
+		break;
+	case TFC_AMMO_NADE2:
+		*( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_NADE2]) = iValue;
+		break;
+	default : 
+		return 0;
+		break;
+	}
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL TFC_GetBAmmo(AMX *amx, cell *params) { 
+	int iIndex = params[1];
+  
+	CHECK_PLAYER(iIndex);
+
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(iIndex);
+	
+	switch(params[2]){ // ammo
+	case TFC_AMMO_SHELLS:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_SHELLS]);
+		break;
+	case TFC_AMMO_BULLETS:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_BULLETS]);
+		break;
+	case TFC_AMMO_CELLS:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_CELLS]);
+		break;
+	case TFC_AMMO_ROCKETS:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_ROCKETS]);
+		break;
+	case TFC_AMMO_NADE1:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_NADE1]);
+		break;
+	case TFC_AMMO_NADE2:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + pdAmmo[TFC_AMMO_NADE2]);
+		break;
+	default : 
+		return 0;
+		break;
+	}
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL TFC_GetWeaponBAmmo(AMX *amx, cell *params) { 
+	int iIndex = params[1];
+  
+	CHECK_PLAYER(iIndex);
+
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(iIndex);
+
+	switch(params[2]){ // weapon
+	case TFC_WPN_SNIPERRIFLE:
+	case TFC_WPN_AUTORIFLE:
+	case TFC_WPN_SHOTGUN:
+	case TFC_WPN_SUPERSHOTGUN:
+	case TFC_WPN_TRANQ:
+	case TFC_WPN_AC:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_SHELLS);
+		break;
+	case TFC_WPN_NG:
+	case TFC_WPN_SUPERNG:
+	case TFC_WPN_RAILGUN:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_BULLETS);
+		break;
+	case TFC_WPN_FLAMETHROWER:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_CELLS);
+		break;
+	case TFC_WPN_GL:
+	case TFC_WPN_RPG:
+	case TFC_WPN_IC:
+	case TFC_WPN_PL:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_ROCKETS);
+		break;
+	case TFC_WPN_CALTROP:
+	case TFC_WPN_NORMALGRENADE:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_NADE1);
+		break;
+	case TFC_WPN_CONCUSSIONGRENADE: 
+	case TFC_WPN_NAILGRENADE: 
+	case TFC_WPN_MIRVGRENADE:
+	case TFC_WPN_NAPALMGRENADE:
+	case TFC_WPN_GASGRENADE:
+	case TFC_WPN_EMPGRENADE:
+		return *( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_NADE2);
+
+
+		break;
+	default : 
+		return 0;
+		break;
+	}
+	return 1;
+
+}
+
+static cell AMX_NATIVE_CALL TFC_SetWeaponBAmmo(AMX *amx, cell *params) { 
+	int iIndex = params[1];
+  
+	CHECK_PLAYER(iIndex);
+	
+	int iValue = params[3];
+		
+	if (iValue < 0 )  {
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid ammo amount %d", iValue);
+		return 0;
+	}
+
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(iIndex);
+
+	switch(params[2]){ // weapon
+	case TFC_WPN_SNIPERRIFLE:
+	case TFC_WPN_AUTORIFLE:
+	case TFC_WPN_SHOTGUN:
+	case TFC_WPN_SUPERSHOTGUN:
+	case TFC_WPN_TRANQ:
+	case TFC_WPN_AC:
+		*( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_SHELLS) = iValue;
+		break;
+	case TFC_WPN_NG:
+	case TFC_WPN_SUPERNG:
+	case TFC_WPN_RAILGUN:
+		*( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_BULLETS) = iValue;
+		break;
+	case TFC_WPN_FLAMETHROWER:
+		*( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_CELLS) = iValue;
+		break;
+	case TFC_WPN_GL:
+	case TFC_WPN_RPG:
+	case TFC_WPN_IC:
+	case TFC_WPN_PL:
+		*( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_ROCKETS) = iValue;
+		break;
+	case TFC_WPN_CALTROP:
+	case TFC_WPN_NORMALGRENADE:
+		*( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_NADE1) = iValue;
+		break;
+	case TFC_WPN_CONCUSSIONGRENADE: 
+	case TFC_WPN_NAILGRENADE: 
+	case TFC_WPN_MIRVGRENADE:
+	case TFC_WPN_NAPALMGRENADE:
+	case TFC_WPN_GASGRENADE:
+	case TFC_WPN_EMPGRENADE:
+		*( (int*)pPlayer->pEdict->pvPrivateData + PD_AMMO_NADE2) = iValue;
+		break;
+	default : 
+		return 0;
+		break;
+	}
+	return 1;
+}
+// AssKicR end :)
+
+static cell AMX_NATIVE_CALL TFC_GetWeaponAmmo(AMX *amx, cell *params)
+{
+	int index = params[1];
+
+	CHECK_NONPLAYER(index);
+	edict_t *weapon = INDEXENT(index);
+
+	return *((int *)weapon->pvPrivateData + PD_WEAPON_AMMO);
+}
+
+static cell AMX_NATIVE_CALL TFC_SetWeaponAmmo(AMX *amx, cell *params)
+{
+	int index = params[1];
+
+	CHECK_NONPLAYER(index);
+	edict_t *weapon = INDEXENT(index);
+
+	*((int *)weapon->pvPrivateData + PD_WEAPON_AMMO) = params[2];
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL TFC_GetUserGoalItem(AMX *amx, cell *params)
+{
+	int index = params[1];
+	
+	CHECK_PLAYER(index);
+
+	edict_t *pPlayer = MF_GetPlayerEdict(index);
+	cell *team = MF_GetAmxAddr(amx, params[2]);
+
+	*team = *((int *)pPlayer->pvPrivateData + PD_GOALITEM_TEAM);
+
+	return *((int *)pPlayer->pvPrivateData + PD_HAS_GOALITEM) & CARRYING_GOALITEM;
+}
+
+static cell AMX_NATIVE_CALL TFC_GetWpnName(AMX *amx, cell *params) { 
+	int iIndex = params[1];
+	if ( iIndex < 1 || iIndex > TFCMAX_WEAPONS ){
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", iIndex);
+		return 0;
+	}
+	return MF_SetAmxString(amx,params[2],weaponData[iIndex].name,params[3]);
+}
+
+static cell AMX_NATIVE_CALL TFC_GetWpnLogName(AMX *amx, cell *params) { 
+	int iIndex = params[1];
+	if ( iIndex < 1 || iIndex > TFCMAX_WEAPONS ){
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", iIndex);
+		return 0;
+	}
+	return MF_SetAmxString(amx,params[2],weaponData[iIndex].logName,params[3]);
+}
+
+static cell AMX_NATIVE_CALL TFC_SetPDdata(AMX *amx, cell *params) { 
+
+	pdTimerOwner  = params[1];
+	pdSentryGunOwner  = params[2];
+
+	pdAmmo[TFC_AMMO_SHELLS] = params[3];
+	pdAmmo[TFC_AMMO_BULLETS] = params[4];
+	pdAmmo[TFC_AMMO_CELLS] = params[5];
+	pdAmmo[TFC_AMMO_ROCKETS] = params[6]; 
+	pdAmmo[TFC_AMMO_NADE1] = params[7];
+	pdAmmo[TFC_AMMO_NADE2] = params[8];
+
+	return 1;
+
+}
+
+static cell AMX_NATIVE_CALL TFC_IsMelee(AMX *amx, cell *params){ // player,wid
+	int weapon = params[1];
+	if (  weapon < 1 || weapon >= TFCMAX_WEAPONS  ){
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", weapon);
+		return 0;
+	}
+	return weaponData[weapon].melee;
+}
+
+static cell AMX_NATIVE_CALL TFC_UserKill(AMX *amx, cell *params){ // player,wid
+	int index = params[1];
+	CHECK_PLAYER(index);
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	pPlayer->killPlayer();
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_maxweapons(AMX *amx, cell *params){
+	return TFCMAX_WEAPONS;
+}
+
+static cell AMX_NATIVE_CALL get_stats_size(AMX *amx, cell *params){
+	return 8;
+}
+
+static cell AMX_NATIVE_CALL is_custom(AMX *amx, cell *params){
+	int weapon = params[1];
+	if (  weapon < TFCMAX_WEAPONS-TFCMAX_CUSTOMWPNS ){
+		return 0;
+	}
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL register_forward(AMX *amx, cell *params)
+{
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL TFC_IsFeigning(AMX *amx, cell *params)
+{
+	int index = params[1];
+	CHECK_PLAYER(index);
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	
+	return (pPlayer->pEdict->v.playerclass == TFC_PC_SPY && pPlayer->pEdict->v.deadflag == 5);
+};
+cvar_t *mp_teamplay=NULL;
+static cell AMX_NATIVE_CALL TFC_IsTeamAlly(AMX *amx, cell *params)
+{
+	if (mp_teamplay==NULL)
+	{
+		mp_teamplay=CVAR_GET_POINTER("mp_teamplay");
+	}
+
+	if (mp_teamplay && mp_teamplay->value != 0.0)
+	{
+		return 0;
+	}
+	int TeamA=params[1];
+	int TeamB=params[2];
+	if (TeamA==TeamB) // same team, yes these are allies
+	{
+		return 1;
+	}
+
+	if (TeamA==0 || TeamB==0) // spectators
+	{
+		return 0;
+	}
+
+
+
+	if (TeamA < 1 || TeamA > 4) // out of bounds?
+	{
+		MF_LogError(amx,AMX_ERR_NATIVE,"Team A is out of bounds (got %d, expected 0 through 4)",TeamA);
+		return 0;
+	}
+	if (TeamB < 1 || TeamB > 4) // out of bounds?
+	{
+		MF_LogError(amx,AMX_ERR_NATIVE,"Team B is out of bounds (got %d, expected 0 through 4)",TeamA);
+		return 0;
+	}
+
+	if (g_AlliesFlags[--TeamA] & (1<<(--TeamB)))
+	{
+		return 1;
+	}
+
+
+	return 0;
+};
+
+// Native list.
+AMX_NATIVE_INFO base_Natives[] = {
+	{"tfc_setmodel", TFC_SetModel},
+	{"tfc_clearmodel", TFC_ClearModel},
+	{"tfc_setbammo", TFC_SetBAmmo},
+	{"tfc_getbammo", TFC_GetBAmmo},
+	{"tfc_getweaponbammo", TFC_GetWeaponBAmmo},
+	{"tfc_setweaponbammo", TFC_SetWeaponBAmmo},
+	{"tfc_getweaponammo", TFC_GetWeaponAmmo},
+	{"tfc_setweaponammo", TFC_SetWeaponAmmo},
+
+	{"tfc_is_user_feigning", TFC_IsFeigning},
+
+	{"tfc_is_team_ally", TFC_IsTeamAlly},
+
+	{"tfc_get_user_goalitem", TFC_GetUserGoalItem},
+
+	{"xmod_get_wpnname", TFC_GetWpnName},
+	{"xmod_get_wpnlogname", TFC_GetWpnLogName},
+	{"xmod_is_melee_wpn", TFC_IsMelee},
+	{"xmod_get_maxweapons", get_maxweapons},
+	{"xmod_get_stats_size", get_stats_size},
+	{"xmod_is_custom_wpn", is_custom},
+
+	{"tfc_userkill" , TFC_UserKill},
+	
+	{"tfc_setpddata", TFC_SetPDdata },
+
+	{"register_statsfwd",register_forward },
+
+	//*****************************************
+
+	{"get_weaponname", TFC_GetWpnName},
+
+	//******************* 19 :)
+	{NULL,			NULL} 
+};

modules/tfcx/NRank.cpp

@@ -0,0 +1,318 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#include "amxxmodule.h"
+#include "tfcx.h"
+
+static cell AMX_NATIVE_CALL get_user_astats(AMX *amx, cell *params) /* 6 param */
+{
+	int index = params[1];
+	CHECK_PLAYERRANGE(index);
+	int attacker = params[2];
+	CHECK_PLAYERRANGE(attacker);
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	if (pPlayer->attackers[attacker].hits){
+		cell *cpStats = MF_GetAmxAddr(amx,params[3]);
+		cell *cpBodyHits = MF_GetAmxAddr(amx,params[4]);
+		CPlayer::PlayerWeapon* stats = &pPlayer->attackers[attacker];
+		cpStats[0] = stats->kills;
+		cpStats[1] = stats->deaths;
+		cpStats[2] = stats->hs;
+		cpStats[3] = stats->tks;
+		cpStats[4] = stats->shots;
+		cpStats[5] = stats->hits;
+		cpStats[6] = stats->damage;
+		for(int i = 1; i < 8; ++i)
+			cpBodyHits[i] = stats->bodyHits[i];
+		if (params[6] && attacker && stats->name )
+			MF_SetAmxString(amx,params[5],stats->name,params[6]);
+		return 1;
+	}
+	return 0;
+}
+
+static cell AMX_NATIVE_CALL get_user_vstats(AMX *amx, cell *params) /* 6 param */
+{
+	int index = params[1];
+	CHECK_PLAYERRANGE(index);
+	int victim = params[2];
+	CHECK_PLAYERRANGE(victim);
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	if (pPlayer->victims[victim].hits){
+		cell *cpStats = MF_GetAmxAddr(amx,params[3]);
+		cell *cpBodyHits = MF_GetAmxAddr(amx,params[4]);
+		CPlayer::PlayerWeapon* stats = &pPlayer->victims[victim];
+		cpStats[0] = stats->kills;
+		cpStats[1] = stats->deaths;
+		cpStats[2] = stats->hs;
+		cpStats[3] = stats->tks;
+		cpStats[4] = stats->shots;
+		cpStats[5] = stats->hits;
+		cpStats[6] = stats->damage;
+		for(int i = 1; i < 8; ++i)
+			cpBodyHits[i] = stats->bodyHits[i];
+		if (params[6] && victim && stats->name)
+			MF_SetAmxString(amx,params[5],stats->name,params[6]);
+		return 1;
+	}
+	return 0;
+}
+
+static cell AMX_NATIVE_CALL get_user_wrstats(AMX *amx, cell *params) /* 4 param */ // DEC-Weapon (round) stats (end)
+{
+	int index = params[1];
+	CHECK_PLAYERRANGE(index);
+	int weapon = params[2];
+	if (weapon<0||weapon>=TFCMAX_WEAPONS){
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", weapon);
+		return 0;
+	}
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	if (pPlayer->weaponsRnd[weapon].shots){
+		cell *cpStats = MF_GetAmxAddr(amx,params[3]);
+		cell *cpBodyHits = MF_GetAmxAddr(amx,params[4]);
+		Stats* stats = &pPlayer->weaponsRnd[weapon];
+		cpStats[0] = stats->kills;
+		cpStats[1] = stats->deaths;
+		cpStats[2] = stats->hs;
+		cpStats[3] = stats->tks;
+		cpStats[4] = stats->shots;
+		cpStats[5] = stats->hits;
+		cpStats[6] = stats->damage;
+		for(int i = 1; i < 8; ++i)
+			cpBodyHits[i] = stats->bodyHits[i];
+		return 1;
+	}
+	return 0;
+}
+
+static cell AMX_NATIVE_CALL get_user_wstats(AMX *amx, cell *params) /* 4 param */
+{
+	int index = params[1];
+	CHECK_PLAYERRANGE(index);
+	int weapon = params[2];
+	if (weapon<0||weapon>=TFCMAX_WEAPONS){
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid weapon id %d", weapon);
+		return 0;
+	}
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	if (pPlayer->weapons[weapon].shots){
+		cell *cpStats = MF_GetAmxAddr(amx,params[3]);
+		cell *cpBodyHits = MF_GetAmxAddr(amx,params[4]);
+		CPlayer::PlayerWeapon* stats = &pPlayer->weapons[weapon];
+		cpStats[0] = stats->kills;
+		cpStats[1] = stats->deaths;
+		cpStats[2] = stats->hs;
+		cpStats[3] = stats->tks;
+		cpStats[4] = stats->shots;
+		cpStats[5] = stats->hits;
+		cpStats[6] = stats->damage;
+		for(int i = 1; i < 8; ++i)
+			cpBodyHits[i] = stats->bodyHits[i];
+		return 1;
+	}
+	return 0;
+}
+
+static cell AMX_NATIVE_CALL reset_user_wstats(AMX *amx, cell *params) /* 6 param */
+{
+	int index = params[1];
+	CHECK_PLAYERRANGE(index);
+	GET_PLAYER_POINTER_I(index)->restartStats();
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_user_stats(AMX *amx, cell *params) /* 3 param */
+{
+	int index = params[1];
+	CHECK_PLAYERRANGE(index);
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	if ( pPlayer->rank ){
+		cell *cpStats = MF_GetAmxAddr(amx,params[2]);
+		cell *cpBodyHits = MF_GetAmxAddr(amx,params[3]);
+		cpStats[0] = pPlayer->rank->kills;
+		cpStats[1] = pPlayer->rank->deaths;
+		cpStats[2] = pPlayer->rank->hs;
+		cpStats[3] = pPlayer->rank->tks;
+		cpStats[4] = pPlayer->rank->shots;
+		cpStats[5] = pPlayer->rank->hits;
+		cpStats[6] = pPlayer->rank->damage;
+		cpStats[7] = pPlayer->rank->getPosition();
+		for(int i = 1; i < 8; ++i)
+			cpBodyHits[i] = pPlayer->rank->bodyHits[i];
+		return pPlayer->rank->getPosition();
+	}
+	return 0;
+	
+}
+
+static cell AMX_NATIVE_CALL get_user_rstats(AMX *amx, cell *params) /* 3 param */
+{
+	int index = params[1];
+	CHECK_PLAYERRANGE(index);
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	if (pPlayer->rank){
+		cell *cpStats = MF_GetAmxAddr(amx,params[2]);
+		cell *cpBodyHits = MF_GetAmxAddr(amx,params[3]);
+		cpStats[0] = pPlayer->life.kills;
+		cpStats[1] = pPlayer->life.deaths;
+		cpStats[2] = pPlayer->life.hs;
+		cpStats[3] = pPlayer->life.tks;
+		cpStats[4] = pPlayer->life.shots;
+		cpStats[5] = pPlayer->life.hits;
+		cpStats[6] = pPlayer->life.damage;
+		for(int i = 1; i < 8; ++i)
+			cpBodyHits[i] = pPlayer->life.bodyHits[i];
+		return 1;
+	}
+	return 0;
+}
+
+static cell AMX_NATIVE_CALL get_stats(AMX *amx, cell *params) /* 3 param */
+{
+	
+	int index = params[1] + 1;
+
+	for(RankSystem::iterator a = g_rank.front(); a ;--a){
+		if ((*a).getPosition() == index)  {
+			cell *cpStats = MF_GetAmxAddr(amx,params[2]);
+			cell *cpBodyHits = MF_GetAmxAddr(amx,params[3]);
+			cpStats[0] = (*a).kills;
+			cpStats[1] = (*a).deaths;
+			cpStats[2] = (*a).hs;
+			cpStats[3] = (*a).tks;
+			cpStats[4] = (*a).shots;
+			cpStats[5] = (*a).hits;
+			cpStats[6] = (*a).damage;
+			cpStats[7] = (*a).getPosition();
+			MF_SetAmxString(amx,params[4],(*a).getName(),params[5]);
+			for(int i = 1; i < 8; ++i)
+				cpBodyHits[i] = (*a).bodyHits[i];
+			return --a ? index : 0;
+		}	
+	}
+	
+	return 0;
+}
+
+static cell AMX_NATIVE_CALL get_statsnum(AMX *amx, cell *params)
+{
+	return g_rank.getRankNum();
+}
+
+
+static cell AMX_NATIVE_CALL register_cwpn(AMX *amx, cell *params){ // name,logname,melee=0 
+	int i;
+	bool bFree = false;
+	for ( i=TFCMAX_WEAPONS-TFCMAX_CUSTOMWPNS;i<TFCMAX_WEAPONS;i++){
+		if ( !weaponData[i].ammoSlot ){
+			bFree = true;
+			break;
+		}
+	}
+
+	if ( !bFree )
+		return 0;
+
+	int iLen;
+	char *szName = MF_GetAmxString(amx, params[1], 0, &iLen);
+
+	strcpy(weaponData[i].name,szName);
+	weaponData[i].ammoSlot = true;
+	weaponData[i].melee = params[2] ? true:false;
+	return i;
+}
+
+static cell AMX_NATIVE_CALL cwpn_dmg(AMX *amx, cell *params){ // wid,att,vic,dmg,hp=0
+	int weapon = params[1];
+	if (  weapon < TFCMAX_WEAPONS-TFCMAX_CUSTOMWPNS ){ // only for custom weapons
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid custom weapon id %d", weapon);
+		return 0;
+	}
+
+	int att = params[2];
+	CHECK_PLAYERRANGE(att);
+
+	int vic = params[3];
+	CHECK_PLAYERRANGE(vic);
+	
+	int dmg = params[4];
+	if ( dmg<1 ){
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid damage amount %d", dmg);
+		return 0;
+	}
+	
+	int aim = params[5];
+	if ( aim < 0 || aim > 7 ){
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid aim %d", aim);
+		return 0;
+	}
+
+	CPlayer* pAtt = GET_PLAYER_POINTER_I(att);
+	CPlayer* pVic = GET_PLAYER_POINTER_I(vic);
+
+	pVic->pEdict->v.dmg_inflictor = NULL;
+	pAtt->saveHit( pVic , weapon , dmg, aim );
+
+	if ( !pAtt ) pAtt = pVic;
+	int TA = 0;
+	if ( (pVic->pEdict->v.team == pAtt->pEdict->v.team ) && ( pVic != pAtt) )
+		TA = 1;
+	MF_ExecuteForward(g_damage_info, pAtt->index, pVic->index, dmg, weapon, aim, TA);
+	
+	if ( pVic->IsAlive() )
+		return 1;
+
+	pAtt->saveKill(pVic,weapon,( aim == 1 ) ? 1:0 ,TA);
+	MF_ExecuteForward(g_death_info, pAtt->index, pVic->index, weapon, aim, TA);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL cwpn_shot(AMX *amx, cell *params){ // player,wid
+	int index = params[2];
+	CHECK_PLAYERRANGE(index);
+
+	int weapon = params[1];
+	if (  weapon < TFCMAX_WEAPONS-TFCMAX_CUSTOMWPNS ){
+		MF_LogError(amx,AMX_ERR_NATIVE, "Invalid custom weapon id %d", weapon);
+		return 0;
+	}
+
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	pPlayer->saveShot(weapon);
+
+	return 1;
+}
+
+AMX_NATIVE_INFO stats_Natives[] = {
+	{ "get_stats",      get_stats},
+	{ "get_statsnum",   get_statsnum},
+	{ "get_user_astats",  get_user_astats },
+	{ "get_user_rstats",  get_user_rstats },
+	{ "get_user_lstats",  get_user_rstats }, // for backward compatibility
+	{ "get_user_stats",   get_user_stats },
+	{ "get_user_vstats",  get_user_vstats },
+	{ "get_user_wrstats",  get_user_wrstats},             // DEC-Weapon(Round) Stats
+	{ "get_user_wstats",  get_user_wstats},
+	{ "reset_user_wstats",  reset_user_wstats },
+
+	// Custom Weapon Support
+	{ "custom_weapon_add", register_cwpn },
+	{ "custom_weapon_dmg", cwpn_dmg },
+	{ "custom_weapon_shot", cwpn_shot },
+
+	{ NULL, NULL }
+};
+

modules/tfcx/Utils.cpp

@@ -0,0 +1,111 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#include "amxxmodule.h"
+#include "tfcx.h"
+
+traceVault traceData[] = {
+	{ "timer","ti", TFC_WPN_TIMER,ACT_NADE_NONE, 2.0 , 0 , 2 },
+	{ "caltrop","ca", TFC_WPN_CALTROP, ACT_NADE_SHOT,0.0 , 0 , 2 },
+	{ "tf_rpg_rocket","roc", TFC_WPN_RPG,ACT_NADE_PUT, 2.0 , 7 , 3 },
+	{ "tf_gl_grenade","gl_g", TFC_WPN_GL, ACT_NADE_PUT, 2.0 , 3 , 4 },
+	{ "tf_gl_pipebomb","gl_p", TFC_WPN_PL, ACT_NADE_PUT, 2.0 , 3 , 4 }, 
+	{ "tf_weapon_gasgrenade","ga", TFC_WPN_GASGRENADE, ACT_NADE_SHOT, 0.0 , 10 , 2 },
+	{ "tf_weapon_empgrenade","em", TFC_WPN_EMPGRENADE, ACT_NADE_SHOT, 0.0 , 10 , 2 },
+	{ "tf_weapon_mirvbomblet","mirvb", TFC_WPN_MIRVGRENADE,ACT_NADE_PUT, 2.0 , 10 , 5 },
+	{ "tf_weapon_nailgrenade","nai", TFC_WPN_NAILGRENADE, ACT_NADE_SHOT|ACT_NADE_PUT, 2.0 , 10 , 3 },
+	{ "tf_weapon_mirvgrenade","mirvg", TFC_WPN_MIRVGRENADE, ACT_NADE_SHOT|ACT_NADE_PUT, 2.0 , 10 , 5 },
+	{ "tf_weapon_napalmgrenade","nap", TFC_WPN_NAPALMGRENADE, ACT_NADE_SHOT, 0.0 , 10 , 3 },
+	{ "tf_weapon_normalgrenade","no", TFC_WPN_NORMALGRENADE, ACT_NADE_SHOT|ACT_NADE_PUT, 2.0 , 10 , 2 },
+	{ "tf_weapon_concussiongrenade","co", TFC_WPN_CONCUSSIONGRENADE, ACT_NADE_NONE, 0.0 , 10 , 2 },
+};
+
+bool ignoreBots (edict_t *pEnt, edict_t *pOther)
+{
+	rankBots = (int)tfcstats_rankbots->value ? true : false;
+	if ( !rankBots && ( pEnt->v.flags & FL_FAKECLIENT || ( pOther && pOther->v.flags & FL_FAKECLIENT ) ) )
+		return true;
+	return false;
+}
+
+bool isModuleActive(){
+	if (!(int)tfcstats_pause->value)
+		return true;
+	return false;
+}
+
+bool util_strncmp( const char *sz1, const char *sz2, int size){
+	int i = 0;
+	while( sz1[i] && i<=size){
+		if ( sz1[i] != sz2[i] )
+			return false;
+		i++;
+	}
+	return true;
+}
+
+/*
+medikit,iSlot:-1,iId:3
+spanner,iSlot:2,iId:4
+axe,iSlot:-1,iId:5
+sniperrifle,iSlot:1,iId:6
+autorifle,iSlot:1,iId:7
+shotgun,iSlot:1,iId:8
+supershotgun,iSlot:1,iId:9
+ng,iSlot:3,iId:10
+superng,iSlot:3,iId:11
+gl,iSlot:4,iId:12
+flamethrower,iSlot:2,iId:13
+rpg,iSlot:4,iId:14
+ic,iSlot:4,iId:15
+ac,iSlot:1,iId:17
+tranq,iSlot:1,iId:20
+railgun,iSlot:3,iId:21
+pl,iSlot:4,iId:22
+knife,iSlot:-1,iId:23
+*/
+weaponsVault weaponData[] = {
+	{ "", "", -1 }, // 0
+	{ "timer", "infection", -1 }, // 1
+	{ "sentrygun", "sentrygun", -1 }, // 2
+	{ "medikit", "medikit", -1 , true},
+	{ "spanner", "spanner", 2 , true },
+	{ "axe", "axe", -1 , true },
+	{ "sniperrifle", "sniperrifle", 1 },
+	{ "autorifle", "autorifle", 1 },
+	{ "shotgun", "shotgun", 1 },
+	{ "supershotgun", "supershotgun", 1 },
+	{ "ng", "nails", 3 },
+	{ "superng", "supernails", 3 },
+	{ "gl", "gl_grenade", 4 },
+	{ "flamethrower", "flamethrower", 2 },
+	{ "rpg", "rocket", 4 },
+	{ "ic", "ic", 4 },
+	{ "flames", "flames", -1 }, // 16
+	{ "ac", "ac", 1 },
+	{ "", "", -1 }, // 18
+	{ "", "", -1 }, // 19
+	{ "tranq", "tranq", 1 },
+	{ "railgun", "railgun", 3 },
+	{ "pl", "pipebomb", 4 },
+	{ "knife", "knife", -1 , true },
+	{ "caltrop", "caltrop", -1 }, // 24
+	{ "concussion", "concussiongrenade", -1 },
+	{ "grenade", "normalgrenade", -1 },
+	{ "nailgrenade", "nailgrenade", -1 },
+	{ "mirvgrenade", "mirvgrenade", -1 },
+	{ "napalm", "napalmgrenade", -1 },
+	{ "gas", "gasgrenade", -1 },
+	{ "emp", "empgrenade", -1 },
+};

modules/tfcx/moduleconfig.cpp

@@ -0,0 +1,395 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#include "tfcx.h"
+
+funEventCall modMsgsEnd[MAX_REG_MSGS];
+funEventCall modMsgs[MAX_REG_MSGS];
+void (*function)(void*);
+void (*endfunction)(void*);
+CPlayer* mPlayer;
+CPlayer players[33];
+
+bool rankBots;
+int pdTimerOwner;
+int pdSentryGunOwner;
+int pdAmmo[6];
+
+int gmsgCurWeapon;
+int gmsgDamage;
+int gmsgDamage2;
+int gmsgWeaponList;
+int gmsgResetHUD;
+int gmsgAmmoX;
+int gmsgScoreInfo;
+int gmsgAmmoPickup;
+
+int mState;
+int mPlayerIndex;
+
+int g_death_info = -1;
+int g_damage_info = -1;
+
+int g_AlliesFlags[4];
+
+RankSystem g_rank;
+Grenades g_grenades;
+
+cvar_t init_tfcstats_maxsize ={"tfcstats_maxsize","3500", 0 , 3500.0 };
+cvar_t init_tfcstats_reset ={"tfcstats_reset","0"};
+cvar_t init_tfcstats_rank ={"tfcstats_rank","0"};
+cvar_t *tfcstats_rankbots;
+cvar_t *tfcstats_pause;
+
+cvar_t init_tfcstats_rankbots ={"tfcstats_rankbots","1"};
+cvar_t init_tfcstats_pause = {"tfcstats_pause","0"};
+cvar_t *tfcstats_maxsize;
+cvar_t *tfcstats_reset;
+cvar_t *tfcstats_rank;
+
+struct sUserMsg {
+	const char* name;
+	int* id;
+	funEventCall func;
+	bool endmsg;
+} g_user_msg[] = {
+	{ "CurWeapon" , &gmsgCurWeapon , Client_CurWeapon, false },
+	{ "Damage" , &gmsgDamage,Client_Damage, false  },
+	{ "Damage" , &gmsgDamage2,Client_Damage_End, true  },
+	//{ "WeaponList" , &gmsgWeaponList, Client_WeaponList, false},
+	{ "ResetHUD" , &gmsgResetHUD,Client_ResetHUD, true },
+	{ "AmmoX" , &gmsgAmmoX, Client_AmmoX , false },
+	{ "ScoreInfo" , &gmsgScoreInfo, Client_ScoreInfo, false},
+	{ "AmmoPickup" , &gmsgAmmoPickup, Client_AmmoPickup , false },
+	{ 0 , 0,0,false }
+};
+
+const char* get_localinfo( const char* name , const char* def = 0 )
+{
+	const char* b = LOCALINFO( (char*)name );
+	if (((b==0)||(*b==0)) && def )
+		SET_LOCALINFO((char*)name,(char*)(b = def) );
+	return b;
+}
+
+int RegUserMsg_Post(const char *pszName, int iSize)
+{
+	for (int i = 0; g_user_msg[ i ].name; ++i )
+	{
+		if ( !*g_user_msg[i].id && strcmp( g_user_msg[ i ].name , pszName  ) == 0 )
+		{
+			int id = META_RESULT_ORIG_RET( int );
+
+			*g_user_msg[ i ].id = id;
+		
+			if ( g_user_msg[ i ].endmsg )
+				modMsgsEnd[ id  ] = g_user_msg[ i ].func;
+			else
+				modMsgs[ id  ] = g_user_msg[ i ].func;
+
+			//break;
+		}
+	}
+
+	RETURN_META_VALUE(MRES_IGNORED, 0);
+}
+
+void ServerActivate_Post( edict_t *pEdictList, int edictCount, int clientMax ){
+	
+	rankBots = (int)tfcstats_rankbots->value ? true:false;
+
+	for( int i = 1; i <= gpGlobals->maxClients; ++i )
+		GET_PLAYER_POINTER_I(i)->Init( i , pEdictList + i );
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void PlayerPreThink_Post( edict_t *pEntity ) {
+	CPlayer *pPlayer = GET_PLAYER_POINTER(pEntity);
+    if (!isModuleActive()) // stats only
+		RETURN_META(MRES_IGNORED);
+
+	if (pPlayer->clearStats && pPlayer->clearStats < gpGlobals->time && pPlayer->ingame){
+
+		if ( !ignoreBots(pEntity,NULL) ){
+			pPlayer->clearStats = 0.0f;
+			pPlayer->rank->updatePosition( &pPlayer->life );
+			pPlayer->restartStats(false);
+		}
+
+	}
+	RETURN_META(MRES_IGNORED);
+}
+
+void ServerDeactivate() {
+	int i;
+	for(i = 1;i<=gpGlobals->maxClients; ++i){
+		CPlayer *pPlayer = GET_PLAYER_POINTER_I(i);
+		if (pPlayer->rank) pPlayer->Disconnect();
+	}
+
+	if ( (g_rank.getRankNum() >= (int)tfcstats_maxsize->value) || ((int)tfcstats_reset->value == 1) ) {
+		CVAR_SET_FLOAT("tfcstats_reset",0.0);
+		g_rank.clear();
+	}
+	
+	g_rank.saveRank( MF_BuildPathname("%s",get_localinfo("tfcstats") ) );
+
+	// clear custom weapons info
+	for ( i=TFCMAX_WEAPONS-TFCMAX_CUSTOMWPNS;i<TFCMAX_WEAPONS;i++)
+		weaponData[i].ammoSlot = false;
+	
+	g_grenades.clear();
+
+	g_AlliesFlags[0]=0;
+	g_AlliesFlags[1]=0;
+	g_AlliesFlags[2]=0;
+	g_AlliesFlags[3]=0;
+
+
+	RETURN_META(MRES_IGNORED);
+}
+
+BOOL ClientConnect_Post( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]  ){
+	GET_PLAYER_POINTER(pEntity)->Connect(pszAddress);
+	RETURN_META_VALUE(MRES_IGNORED, TRUE);
+}
+
+void ClientDisconnect( edict_t *pEntity ) {
+	CPlayer *pPlayer = GET_PLAYER_POINTER(pEntity);
+	if (pPlayer->rank) pPlayer->Disconnect();
+	RETURN_META(MRES_IGNORED);
+}
+
+void ClientPutInServer_Post( edict_t *pEntity ) {
+	GET_PLAYER_POINTER(pEntity)->PutInServer();
+	RETURN_META(MRES_IGNORED);
+}
+
+void ClientUserInfoChanged_Post( edict_t *pEntity, char *infobuffer ) {
+	CPlayer *pPlayer = GET_PLAYER_POINTER(pEntity);
+	const char* name = INFOKEY_VALUE(infobuffer,"name");
+	const char* oldname = STRING(pEntity->v.netname);
+
+	if ( pPlayer->rank ){
+		if ( strcmp(oldname,name) != 0 ) {
+			if ((int)tfcstats_rank->value == 0)
+				pPlayer->rank = g_rank.findEntryInRank( name, name );
+			else
+				pPlayer->rank->setName( name );
+		}
+	}
+	else if ( pPlayer->IsBot() ) {
+		pPlayer->Connect( "127.0.0.1" );
+		pPlayer->PutInServer();
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void MessageBegin_Post(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed) {
+	if (ed){
+		mPlayerIndex = ENTINDEX(ed);
+		mPlayer = GET_PLAYER_POINTER_I(mPlayerIndex);
+	} else {
+		mPlayerIndex = 0;
+		mPlayer = NULL;
+	}
+	mState = 0;
+	if ( msg_type < 0 || msg_type >= MAX_REG_MSGS )
+		msg_type = 0;
+	function=modMsgs[msg_type];
+	endfunction=modMsgsEnd[msg_type];
+	RETURN_META(MRES_IGNORED);
+}
+
+void MessageEnd_Post(void) {
+	if (endfunction) (*endfunction)(NULL);
+	RETURN_META(MRES_IGNORED);
+}
+
+void WriteByte_Post(int iValue) {
+	if (function) (*function)((void *)&iValue);
+	RETURN_META(MRES_IGNORED);
+}
+
+void WriteChar_Post(int iValue) {
+	if (function) (*function)((void *)&iValue);
+	RETURN_META(MRES_IGNORED);
+}
+
+void WriteShort_Post(int iValue) {
+	if (function) (*function)((void *)&iValue);
+	RETURN_META(MRES_IGNORED);
+}
+
+void WriteLong_Post(int iValue) {
+	if (function) (*function)((void *)&iValue);
+	RETURN_META(MRES_IGNORED);
+}
+
+void WriteAngle_Post(float flValue) {
+	if (function) (*function)((void *)&flValue);
+	RETURN_META(MRES_IGNORED);
+}
+
+void WriteCoord_Post(float flValue) {
+	if (function) (*function)((void *)&flValue);
+	RETURN_META(MRES_IGNORED);
+}
+
+void WriteString_Post(const char *sz) {
+	if (function) (*function)((void *)sz);
+	RETURN_META(MRES_IGNORED);
+}
+
+void WriteEntity_Post(int iValue) {
+	if (function) (*function)((void *)&iValue);
+	RETURN_META(MRES_IGNORED);
+}
+
+void SetModel_Post(edict_t *e, const char *m){
+	if(e->v.owner && e->v.owner->v.flags&(FL_CLIENT | FL_FAKECLIENT)){
+		CPlayer *pPlayer =  GET_PLAYER_POINTER(e->v.owner);
+		if ( !STRING(e->v.classname)[0] ){ // current weapon shot
+			if ( pPlayer->classId != TFC_PC_SOLDIER )
+				pPlayer->saveShot(pPlayer->current);
+		}
+	}
+	RETURN_META(MRES_IGNORED);
+}
+
+void TraceLine_Post(const float *v1, const float *v2, int fNoMonsters, edict_t *e, TraceResult *ptr) {
+	if ( !e )
+		RETURN_META(MRES_IGNORED);
+
+	if (ptr->pHit&&(ptr->pHit->v.flags& (FL_CLIENT | FL_FAKECLIENT) )&&
+		(e->v.flags& (FL_CLIENT | FL_FAKECLIENT) )){
+		GET_PLAYER_POINTER(e)->aiming = ptr->iHitgroup;
+	}
+	else{
+		if ( e->v.owner && e->v.owner->v.flags& (FL_CLIENT | FL_FAKECLIENT) ){
+			CPlayer *pPlayer = GET_PLAYER_POINTER(e->v.owner);
+			int i;
+			for ( i=0;i<MAX_TRACE;i++){
+				if ( util_strncmp( traceData[i].szTag,traceData[i].start ? STRING(e->v.classname)+traceData[i].start :  STRING(e->v.classname) ,traceData[i].stop) ){
+					if ( traceData[i].iAction & ACT_NADE_SHOT  ){
+						pPlayer->saveShot(traceData[i].iId);
+					}
+					if ( traceData[i].iAction & ACT_NADE_PUT ){
+						g_grenades.put(e,traceData[i].fDel,traceData[i].iId,pPlayer);
+					}
+					break;
+				}
+			}
+		}
+	}
+	RETURN_META(MRES_IGNORED);
+}
+
+void OnMetaAttach() {
+	
+	CVAR_REGISTER (&init_tfcstats_maxsize);
+	CVAR_REGISTER (&init_tfcstats_reset);
+	CVAR_REGISTER (&init_tfcstats_rank);
+	tfcstats_maxsize=CVAR_GET_POINTER(init_tfcstats_maxsize.name);
+	tfcstats_reset=CVAR_GET_POINTER(init_tfcstats_reset.name);
+	tfcstats_rank=CVAR_GET_POINTER(init_tfcstats_rank.name);
+
+	CVAR_REGISTER (&init_tfcstats_rankbots);
+	CVAR_REGISTER (&init_tfcstats_pause);
+	tfcstats_rankbots = CVAR_GET_POINTER(init_tfcstats_rankbots.name);
+	tfcstats_pause = CVAR_GET_POINTER(init_tfcstats_pause.name);
+
+}
+
+int AmxxCheckGame(const char *game)
+{
+	if (strcasecmp(game, "tfc") == 0)
+		return AMXX_GAME_OK;
+
+	return AMXX_GAME_BAD;
+}
+void OnAmxxAttach() {
+
+	MF_AddNatives( stats_Natives );
+	MF_AddNatives( base_Natives );
+
+	const char* path =  get_localinfo("tfcstats_score","addons/amxmodx/data/tfcstats.amxx");
+	if ( path && *path ) 
+	{
+		char error[128];
+		g_rank.loadCalc( MF_BuildPathname("%s",path) , error  );
+	}
+	if ( !g_rank.begin() )
+	{		
+		g_rank.loadRank( MF_BuildPathname("%s",get_localinfo("tfcstats","addons/amxmodx/data/tfcstats.dat") ) );
+	}
+
+	// set default PrivateData offsets
+	pdTimerOwner = PD_TIMER_OWNER;
+	pdSentryGunOwner = PD_SENTRY_OWNER;
+	pdAmmo[TFC_AMMO_SHELLS] = PD_AMMO_SHELLS;
+	pdAmmo[TFC_AMMO_BULLETS] = PD_AMMO_BULLETS;
+	pdAmmo[TFC_AMMO_CELLS] = PD_AMMO_CELLS;
+	pdAmmo[TFC_AMMO_ROCKETS] = PD_AMMO_ROCKETS; 
+	pdAmmo[TFC_AMMO_NADE1] = PD_AMMO_NADE1;
+	pdAmmo[TFC_AMMO_NADE2] = PD_AMMO_NADE2;
+	
+	g_AlliesFlags[0]=0;
+	g_AlliesFlags[1]=0;
+	g_AlliesFlags[2]=0;
+	g_AlliesFlags[3]=0;
+}
+
+void OnPluginsLoaded()
+{
+	g_damage_info = MF_RegisterForward("client_damage", ET_IGNORE, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+	g_death_info = MF_RegisterForward("client_death", ET_IGNORE, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+}
+
+void DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd)
+{
+	if (pkvd->szClassName && strcmp(pkvd->szClassName,"info_tfdetect")==0)
+	{
+		if (pkvd->szKeyName && strncmp(pkvd->szKeyName,"team",4)==0)
+		{
+			if (strcmp(pkvd->szKeyName,"team1_allies")==0 && pkvd->szValue!=NULL)
+			{
+				g_AlliesFlags[0]=atoi(pkvd->szValue);
+
+				RETURN_META(MRES_IGNORED);
+			}
+			else if (strcmp(pkvd->szKeyName,"team2_allies")==0 && pkvd->szValue!=NULL)
+			{
+				g_AlliesFlags[1]=atoi(pkvd->szValue);
+
+				RETURN_META(MRES_IGNORED);
+			}
+			else if (strcmp(pkvd->szKeyName,"team3_allies")==0 && pkvd->szValue!=NULL)
+			{
+				g_AlliesFlags[2]=atoi(pkvd->szValue);
+
+				RETURN_META(MRES_IGNORED);
+			}
+			else if (strcmp(pkvd->szKeyName,"team4_allies")==0 && pkvd->szValue!=NULL)
+			{
+				g_AlliesFlags[3]=atoi(pkvd->szValue);
+
+				RETURN_META(MRES_IGNORED);
+			}
+		}
+	}
+	RETURN_META(MRES_IGNORED);
+}

modules/tfcx/moduleconfig.h

@@ -0,0 +1,512 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// Module Config
+//
+
+#ifndef __MODULECONFIG_H__
+#define __MODULECONFIG_H__
+
+#include <amxmodx_version.h>
+
+// Module info
+#define MODULE_NAME "TfcX"
+#define MODULE_VERSION AMXX_VERSION
+#define MODULE_AUTHOR "AMX Mod X Dev Team"
+#define MODULE_URL "http://www.amxmodx.org"
+#define MODULE_LOGTAG "TFCX"
+#define MODULE_LIBRARY "tfcx"
+#define MODULE_LIBCLASS "xstats"
+// If you want the module not to be reloaded on mapchange, remove / comment out the next line
+#define MODULE_RELOAD_ON_MAPCHANGE
+
+#ifdef __DATE__
+#define MODULE_DATE __DATE__
+#else // __DATE__
+#define MODULE_DATE "Unknown"
+#endif // __DATE__
+
+// metamod plugin?
+#define USE_METAMOD
+
+// use memory manager/tester?
+// note that if you use this, you cannot construct/allocate 
+// anything before the module attached (OnAmxxAttach).
+// be careful of default constructors using new/malloc!
+// #define MEMORY_TEST
+
+// Unless you use STL or exceptions, keep this commented.
+// It allows you to compile without libstdc++.so as a dependency
+// #define NO_ALLOC_OVERRIDES
+
+// Uncomment this if you are using MSVC8 or greater and want to fix some of the compatibility issues yourself 
+// #define NO_MSVC8_AUTO_COMPAT
+
+/** 
+* AMXX Init functions
+* Also consider using FN_META_*
+*/
+
+/** AMXX query */
+//#define FN_AMXX_QUERY OnAmxxQuery
+
+/** AMXX Check Game - module API is NOT available here.
+ * Return AMXX_GAME_OK if this module can load on the game, AMXX_GAME_BAD if it cannot.
+ * syntax: int AmxxCheckGame(const char *game)
+ */
+#define FN_AMXX_CHECKGAME AmxxCheckGame
+
+
+/** AMXX attach
+* Do native functions init here (MF_AddNatives)
+*/
+#define FN_AMXX_ATTACH OnAmxxAttach
+
+/** AMXX Detach (unload) */
+//#define FN_AMXX_DETACH OnAmxxDetach
+
+/** All plugins loaded
+* Do forward functions init here (MF_RegisterForward)
+*/
+#define FN_AMXX_PLUGINSLOADED OnPluginsLoaded
+
+/** All plugins are about to be unloaded */
+//#define FN_AMXX_PLUGINSUNLOADING OnPluginsUnloading
+
+/** All plugins are now unloaded */
+//#define FN_AMXX_PLUGINSUNLOADED OnPluginsUnloaded
+
+/**** METAMOD ****/
+// If your module doesn't use metamod, you may close the file now :)
+#ifdef USE_METAMOD
+// ----
+// Hook Functions
+// Uncomment these to be called
+// You can also change the function name
+
+// - Metamod init functions
+// Also consider using FN_AMXX_*
+// Meta query
+//#define FN_META_QUERY OnMetaQuery
+// Meta attach
+#define FN_META_ATTACH OnMetaAttach
+// Meta detach
+//#define FN_META_DETACH OnMetaDetach
+
+// (wd) are Will Day's notes
+// - GetEntityAPI2 functions
+// #define FN_GameDLLInit				GameDLLInit					/* pfnGameInit() */
+// #define FN_DispatchSpawn				DispatchSpawn				/* pfnSpawn() */
+// #define FN_DispatchThink				DispatchThink				/* pfnThink() */
+// #define FN_DispatchUse				DispatchUse					/* pfnUse() */
+// #define FN_DispatchTouch				DispatchTouch				/* pfnTouch() */
+// #define FN_DispatchBlocked			DispatchBlocked				/* pfnBlocked() */
+#define FN_DispatchKeyValue				DispatchKeyValue			/* pfnKeyValue() */
+// #define FN_DispatchSave				DispatchSave				/* pfnSave() */
+// #define FN_DispatchRestore			DispatchRestore				/* pfnRestore() */
+// #define FN_DispatchObjectCollsionBox	DispatchObjectCollsionBox	/* pfnSetAbsBox() */
+// #define FN_SaveWriteFields			SaveWriteFields				/* pfnSaveWriteFields() */
+// #define FN_SaveReadFields			SaveReadFields				/* pfnSaveReadFields() */
+// #define FN_SaveGlobalState			SaveGlobalState				/* pfnSaveGlobalState() */
+// #define FN_RestoreGlobalState		RestoreGlobalState			/* pfnRestoreGlobalState() */
+// #define FN_ResetGlobalState			ResetGlobalState			/* pfnResetGlobalState() */
+// #define FN_ClientConnect				ClientConnect				/* pfnClientConnect()			(wd) Client has connected */
+#define FN_ClientDisconnect				ClientDisconnect			/* pfnClientDisconnect()		(wd) Player has left the game */
+// #define FN_ClientKill				ClientKill					/* pfnClientKill()				(wd) Player has typed "kill" */
+// #define FN_ClientPutInServer			ClientPutInServer			/* pfnClientPutInServer()		(wd) Client is entering the game */
+// #define FN_ClientCommand				ClientCommand				/* pfnClientCommand()			(wd) Player has sent a command (typed or from a bind) */
+// #define FN_ClientUserInfoChanged		ClientUserInfoChanged		/* pfnClientUserInfoChanged()	(wd) Client has updated their setinfo structure */
+// #define FN_ServerActivate			ServerActivate				/* pfnServerActivate()			(wd) Server is starting a new map */
+#define FN_ServerDeactivate				ServerDeactivate			/* pfnServerDeactivate()		(wd) Server is leaving the map (shutdown or changelevel); SDK2 */
+// #define FN_PlayerPreThink			PlayerPreThink				/* pfnPlayerPreThink() */
+// #define FN_PlayerPostThink			PlayerPostThink				/* pfnPlayerPostThink() */
+// #define FN_StartFrame				StartFrame					/* pfnStartFrame() */
+// #define FN_ParmsNewLevel				ParmsNewLevel				/* pfnParmsNewLevel() */
+// #define FN_ParmsChangeLevel			ParmsChangeLevel			/* pfnParmsChangeLevel() */
+// #define FN_GetGameDescription		GetGameDescription			/* pfnGetGameDescription()		Returns string describing current .dll.  E.g. "TeamFotrress 2" "Half-Life" */
+// #define FN_PlayerCustomization		PlayerCustomization			/* pfnPlayerCustomization()	Notifies .dll of new customization for player. */
+// #define FN_SpectatorConnect			SpectatorConnect			/* pfnSpectatorConnect()		Called when spectator joins server */
+// #define FN_SpectatorDisconnect		SpectatorDisconnect			/* pfnSpectatorDisconnect()	Called when spectator leaves the server */
+// #define FN_SpectatorThink			SpectatorThink				/* pfnSpectatorThink()			Called when spectator sends a command packet (usercmd_t) */
+// #define FN_Sys_Error					Sys_Error					/* pfnSys_Error()				Notify game .dll that engine is going to shut down.  Allows mod authors to set a breakpoint.  SDK2 */
+// #define FN_PM_Move					PM_Move						/* pfnPM_Move()				(wd) SDK2 */
+// #define FN_PM_Init					PM_Init						/* pfnPM_Init()				Server version of player movement initialization; (wd) SDK2 */
+// #define FN_PM_FindTextureType		PM_FindTextureType			/* pfnPM_FindTextureType()		(wd) SDK2 */
+// #define FN_SetupVisibility			SetupVisibility				/* pfnSetupVisibility()		Set up PVS and PAS for networking for this client; (wd) SDK2 */
+// #define FN_UpdateClientData			UpdateClientData			/* pfnUpdateClientData()		Set up data sent only to specific client; (wd) SDK2 */
+// #define FN_AddToFullPack				AddToFullPack				/* pfnAddToFullPack()			(wd) SDK2 */
+// #define FN_CreateBaseline			CreateBaseline				/* pfnCreateBaseline()			Tweak entity baseline for network encoding allows setup of player baselines too.; (wd) SDK2 */
+// #define FN_RegisterEncoders			RegisterEncoders			/* pfnRegisterEncoders()		Callbacks for network encoding; (wd) SDK2 */
+// #define FN_GetWeaponData				GetWeaponData				/* pfnGetWeaponData()			(wd) SDK2 */
+// #define FN_CmdStart					CmdStart					/* pfnCmdStart()				(wd) SDK2 */
+// #define FN_CmdEnd					CmdEnd						/* pfnCmdEnd()					(wd) SDK2 */
+// #define FN_ConnectionlessPacket		ConnectionlessPacket		/* pfnConnectionlessPacket()	(wd) SDK2 */
+// #define FN_GetHullBounds				GetHullBounds				/* pfnGetHullBounds()			(wd) SDK2 */
+// #define FN_CreateInstancedBaselines	CreateInstancedBaselines	/* pfnCreateInstancedBaselines()	(wd) SDK2 */
+// #define FN_InconsistentFile			InconsistentFile			/* pfnInconsistentFile()		(wd) SDK2 */
+// #define FN_AllowLagCompensation		AllowLagCompensation		/* pfnAllowLagCompensation()	(wd) SDK2 */
+
+// - GetEntityAPI2_Post functions
+// #define FN_GameDLLInit_Post					GameDLLInit_Post
+// #define FN_DispatchSpawn_Post				DispatchSpawn_Post
+// #define FN_DispatchThink_Post				DispatchThink_Post
+// #define FN_DispatchUse_Post					DispatchUse_Post
+// #define FN_DispatchTouch_Post				DispatchTouch_Post
+// #define FN_DispatchBlocked_Post				DispatchBlocked_Post
+// #define FN_DispatchKeyValue_Post				DispatchKeyValue_Post
+// #define FN_DispatchSave_Post					DispatchSave_Post
+// #define FN_DispatchRestore_Post				DispatchRestore_Post
+// #define FN_DispatchObjectCollsionBox_Post	DispatchObjectCollsionBox_Post
+// #define FN_SaveWriteFields_Post				SaveWriteFields_Post
+// #define FN_SaveReadFields_Post				SaveReadFields_Post
+// #define FN_SaveGlobalState_Post				SaveGlobalState_Post
+// #define FN_RestoreGlobalState_Post			RestoreGlobalState_Post
+// #define FN_ResetGlobalState_Post				ResetGlobalState_Post
+#define FN_ClientConnect_Post					ClientConnect_Post
+// #define FN_ClientDisconnect_Post				ClientDisconnect_Post
+// #define FN_ClientKill_Post					ClientKill_Post
+#define FN_ClientPutInServer_Post				ClientPutInServer_Post
+// #define FN_ClientCommand_Post				ClientCommand_Post
+#define FN_ClientUserInfoChanged_Post			ClientUserInfoChanged_Post
+#define FN_ServerActivate_Post					ServerActivate_Post
+// #define FN_ServerDeactivate_Post				ServerDeactivate_Post
+#define FN_PlayerPreThink_Post					PlayerPreThink_Post
+// #define FN_PlayerPostThink_Post				PlayerPostThink_Post
+// #define FN_StartFrame_Post					StartFrame_Post
+// #define FN_ParmsNewLevel_Post				ParmsNewLevel_Post
+// #define FN_ParmsChangeLevel_Post				ParmsChangeLevel_Post
+// #define FN_GetGameDescription_Post			GetGameDescription_Post
+// #define FN_PlayerCustomization_Post			PlayerCustomization_Post
+// #define FN_SpectatorConnect_Post				SpectatorConnect_Post
+// #define FN_SpectatorDisconnect_Post			SpectatorDisconnect_Post
+// #define FN_SpectatorThink_Post				SpectatorThink_Post
+// #define FN_Sys_Error_Post					Sys_Error_Post
+// #define FN_PM_Move_Post						PM_Move_Post
+// #define FN_PM_Init_Post						PM_Init_Post
+// #define FN_PM_FindTextureType_Post			PM_FindTextureType_Post
+// #define FN_SetupVisibility_Post				SetupVisibility_Post
+// #define FN_UpdateClientData_Post				UpdateClientData_Post
+// #define FN_AddToFullPack_Post				AddToFullPack_Post
+// #define FN_CreateBaseline_Post				CreateBaseline_Post
+// #define FN_RegisterEncoders_Post				RegisterEncoders_Post
+// #define FN_GetWeaponData_Post				GetWeaponData_Post
+// #define FN_CmdStart_Post						CmdStart_Post
+// #define FN_CmdEnd_Post						CmdEnd_Post
+// #define FN_ConnectionlessPacket_Post			ConnectionlessPacket_Post
+// #define FN_GetHullBounds_Post				GetHullBounds_Post
+// #define FN_CreateInstancedBaselines_Post		CreateInstancedBaselines_Post
+// #define FN_InconsistentFile_Post				InconsistentFile_Post
+// #define FN_AllowLagCompensation_Post			AllowLagCompensation_Post
+
+// - GetEngineAPI functions
+// #define FN_PrecacheModel						PrecacheModel
+// #define FN_PrecacheSound						PrecacheSound
+// #define FN_SetModel							SetModel
+// #define FN_ModelIndex						ModelIndex
+// #define FN_ModelFrames						ModelFrames
+// #define FN_SetSize							SetSize
+// #define FN_ChangeLevel						ChangeLevel
+// #define FN_GetSpawnParms						GetSpawnParms
+// #define FN_SaveSpawnParms					SaveSpawnParms
+// #define FN_VecToYaw							VecToYaw
+// #define FN_VecToAngles						VecToAngles
+// #define FN_MoveToOrigin						MoveToOrigin
+// #define FN_ChangeYaw							ChangeYaw
+// #define FN_ChangePitch						ChangePitch
+// #define FN_FindEntityByString				FindEntityByString
+// #define FN_GetEntityIllum					GetEntityIllum
+// #define FN_FindEntityInSphere				FindEntityInSphere
+// #define FN_FindClientInPVS					FindClientInPVS
+// #define FN_EntitiesInPVS						EntitiesInPVS
+// #define FN_MakeVectors						MakeVectors
+// #define FN_AngleVectors						AngleVectors
+// #define FN_CreateEntity						CreateEntity
+// #define FN_RemoveEntity						RemoveEntity
+// #define FN_CreateNamedEntity					CreateNamedEntity
+// #define FN_MakeStatic						MakeStatic
+// #define FN_EntIsOnFloor						EntIsOnFloor
+// #define FN_DropToFloor						DropToFloor
+// #define FN_WalkMove							WalkMove
+// #define FN_SetOrigin							SetOrigin
+// #define FN_EmitSound							EmitSound
+// #define FN_EmitAmbientSound					EmitAmbientSound
+// #define FN_TraceLine							TraceLine
+// #define FN_TraceToss							TraceToss
+// #define FN_TraceMonsterHull					TraceMonsterHull
+// #define FN_TraceHull							TraceHull
+// #define FN_TraceModel						TraceModel
+// #define FN_TraceTexture						TraceTexture
+// #define FN_TraceSphere						TraceSphere
+// #define FN_GetAimVector						GetAimVector
+// #define FN_ServerCommand						ServerCommand
+// #define FN_ServerExecute						ServerExecute
+// #define FN_engClientCommand					engClientCommand
+// #define FN_ParticleEffect					ParticleEffect
+// #define FN_LightStyle						LightStyle
+// #define FN_DecalIndex						DecalIndex
+// #define FN_PointContents						PointContents
+// #define FN_MessageBegin						MessageBegin
+// #define FN_MessageEnd						MessageEnd
+// #define FN_WriteByte							WriteByte
+// #define FN_WriteChar							WriteChar
+// #define FN_WriteShort						WriteShort
+// #define FN_WriteLong							WriteLong
+// #define FN_WriteAngle						WriteAngle
+// #define FN_WriteCoord						WriteCoord
+// #define FN_WriteString						WriteString
+// #define FN_WriteEntity						WriteEntity
+// #define FN_CVarRegister						CVarRegister
+// #define FN_CVarGetFloat						CVarGetFloat
+// #define FN_CVarGetString						CVarGetString
+// #define FN_CVarSetFloat						CVarSetFloat
+// #define FN_CVarSetString						CVarSetString
+// #define FN_AlertMessage						AlertMessage
+// #define FN_EngineFprintf						EngineFprintf
+// #define FN_PvAllocEntPrivateData				PvAllocEntPrivateData
+// #define FN_PvEntPrivateData					PvEntPrivateData
+// #define FN_FreeEntPrivateData				FreeEntPrivateData
+// #define FN_SzFromIndex						SzFromIndex
+// #define FN_AllocString						AllocString
+// #define FN_GetVarsOfEnt						GetVarsOfEnt
+// #define FN_PEntityOfEntOffset				PEntityOfEntOffset
+// #define FN_EntOffsetOfPEntity				EntOffsetOfPEntity
+// #define FN_IndexOfEdict						IndexOfEdict
+// #define FN_PEntityOfEntIndex					PEntityOfEntIndex
+// #define FN_FindEntityByVars					FindEntityByVars
+// #define FN_GetModelPtr						GetModelPtr
+// #define FN_RegUserMsg						RegUserMsg
+// #define FN_AnimationAutomove					AnimationAutomove
+// #define FN_GetBonePosition					GetBonePosition
+// #define FN_FunctionFromName					FunctionFromName
+// #define FN_NameForFunction					NameForFunction
+// #define FN_ClientPrintf						ClientPrintf
+// #define FN_ServerPrint						ServerPrint
+// #define FN_Cmd_Args							Cmd_Args
+// #define FN_Cmd_Argv							Cmd_Argv
+// #define FN_Cmd_Argc							Cmd_Argc
+// #define FN_GetAttachment						GetAttachment
+// #define FN_CRC32_Init						CRC32_Init
+// #define FN_CRC32_ProcessBuffer				CRC32_ProcessBuffer
+// #define FN_CRC32_ProcessByte					CRC32_ProcessByte
+// #define FN_CRC32_Final						CRC32_Final
+// #define FN_RandomLong						RandomLong
+// #define FN_RandomFloat						RandomFloat
+// #define FN_SetView							SetView
+// #define FN_Time								Time
+// #define FN_CrosshairAngle					CrosshairAngle
+// #define FN_LoadFileForMe						LoadFileForMe
+// #define FN_FreeFile							FreeFile
+// #define FN_EndSection						EndSection
+// #define FN_CompareFileTime					CompareFileTime
+// #define FN_GetGameDir						GetGameDir
+// #define FN_Cvar_RegisterVariable				Cvar_RegisterVariable
+// #define FN_FadeClientVolume					FadeClientVolume
+// #define FN_SetClientMaxspeed					SetClientMaxspeed
+// #define FN_CreateFakeClient					CreateFakeClient
+// #define FN_RunPlayerMove						RunPlayerMove
+// #define FN_NumberOfEntities					NumberOfEntities
+// #define FN_GetInfoKeyBuffer					GetInfoKeyBuffer
+// #define FN_InfoKeyValue						InfoKeyValue
+// #define FN_SetKeyValue						SetKeyValue
+// #define FN_SetClientKeyValue					SetClientKeyValue
+// #define FN_IsMapValid						IsMapValid
+// #define FN_StaticDecal						StaticDecal
+// #define FN_PrecacheGeneric					PrecacheGeneric
+// #define FN_GetPlayerUserId					GetPlayerUserId
+// #define FN_BuildSoundMsg						BuildSoundMsg
+// #define FN_IsDedicatedServer					IsDedicatedServer
+// #define FN_CVarGetPointer					CVarGetPointer
+// #define FN_GetPlayerWONId					GetPlayerWONId
+// #define FN_Info_RemoveKey					Info_RemoveKey
+// #define FN_GetPhysicsKeyValue				GetPhysicsKeyValue
+// #define FN_SetPhysicsKeyValue				SetPhysicsKeyValue
+// #define FN_GetPhysicsInfoString				GetPhysicsInfoString
+// #define FN_PrecacheEvent						PrecacheEvent
+// #define FN_PlaybackEvent						PlaybackEvent
+// #define FN_SetFatPVS							SetFatPVS
+// #define FN_SetFatPAS							SetFatPAS
+// #define FN_CheckVisibility					CheckVisibility
+// #define FN_DeltaSetField						DeltaSetField
+// #define FN_DeltaUnsetField					DeltaUnsetField
+// #define FN_DeltaAddEncoder					DeltaAddEncoder
+// #define FN_GetCurrentPlayer					GetCurrentPlayer
+// #define FN_CanSkipPlayer						CanSkipPlayer
+// #define FN_DeltaFindField					DeltaFindField
+// #define FN_DeltaSetFieldByIndex				DeltaSetFieldByIndex
+// #define FN_DeltaUnsetFieldByIndex			DeltaUnsetFieldByIndex
+// #define FN_SetGroupMask						SetGroupMask
+// #define FN_engCreateInstancedBaseline		engCreateInstancedBaseline
+// #define FN_Cvar_DirectSet					Cvar_DirectSet
+// #define FN_ForceUnmodified					ForceUnmodified
+// #define FN_GetPlayerStats					GetPlayerStats
+// #define FN_AddServerCommand					AddServerCommand
+// #define FN_Voice_GetClientListening			Voice_GetClientListening
+// #define FN_Voice_SetClientListening			Voice_SetClientListening
+// #define FN_GetPlayerAuthId					GetPlayerAuthId
+
+// - GetEngineAPI_Post functions
+// #define FN_PrecacheModel_Post				PrecacheModel_Post
+// #define FN_PrecacheSound_Post				PrecacheSound_Post
+#define FN_SetModel_Post						SetModel_Post
+// #define FN_ModelIndex_Post					ModelIndex_Post
+// #define FN_ModelFrames_Post					ModelFrames_Post
+// #define FN_SetSize_Post						SetSize_Post
+// #define FN_ChangeLevel_Post					ChangeLevel_Post
+// #define FN_GetSpawnParms_Post				GetSpawnParms_Post
+// #define FN_SaveSpawnParms_Post				SaveSpawnParms_Post
+// #define FN_VecToYaw_Post						VecToYaw_Post
+// #define FN_VecToAngles_Post					VecToAngles_Post
+// #define FN_MoveToOrigin_Post					MoveToOrigin_Post
+// #define FN_ChangeYaw_Post					ChangeYaw_Post
+// #define FN_ChangePitch_Post					ChangePitch_Post
+// #define FN_FindEntityByString_Post			FindEntityByString_Post
+// #define FN_GetEntityIllum_Post				GetEntityIllum_Post
+// #define FN_FindEntityInSphere_Post			FindEntityInSphere_Post
+// #define FN_FindClientInPVS_Post				FindClientInPVS_Post
+// #define FN_EntitiesInPVS_Post				EntitiesInPVS_Post
+// #define FN_MakeVectors_Post					MakeVectors_Post
+// #define FN_AngleVectors_Post					AngleVectors_Post
+// #define FN_CreateEntity_Post					CreateEntity_Post
+// #define FN_RemoveEntity_Post					RemoveEntity_Post
+// #define FN_CreateNamedEntity_Post			CreateNamedEntity_Post
+// #define FN_MakeStatic_Post					MakeStatic_Post
+// #define FN_EntIsOnFloor_Post					EntIsOnFloor_Post
+// #define FN_DropToFloor_Post					DropToFloor_Post
+// #define FN_WalkMove_Post						WalkMove_Post
+// #define FN_SetOrigin_Post					SetOrigin_Post
+// #define FN_EmitSound_Post					EmitSound_Post
+// #define FN_EmitAmbientSound_Post				EmitAmbientSound_Post
+#define FN_TraceLine_Post						TraceLine_Post
+// #define FN_TraceToss_Post					TraceToss_Post
+// #define FN_TraceMonsterHull_Post				TraceMonsterHull_Post
+// #define FN_TraceHull_Post					TraceHull_Post
+// #define FN_TraceModel_Post					TraceModel_Post
+// #define FN_TraceTexture_Post					TraceTexture_Post
+// #define FN_TraceSphere_Post					TraceSphere_Post
+// #define FN_GetAimVector_Post					GetAimVector_Post
+// #define FN_ServerCommand_Post				ServerCommand_Post
+// #define FN_ServerExecute_Post				ServerExecute_Post
+// #define FN_engClientCommand_Post				engClientCommand_Post
+// #define FN_ParticleEffect_Post				ParticleEffect_Post
+// #define FN_LightStyle_Post					LightStyle_Post
+// #define FN_DecalIndex_Post					DecalIndex_Post
+// #define FN_PointContents_Post				PointContents_Post
+#define FN_MessageBegin_Post					MessageBegin_Post
+#define FN_MessageEnd_Post						MessageEnd_Post
+#define FN_WriteByte_Post						WriteByte_Post
+#define FN_WriteChar_Post						WriteChar_Post
+#define FN_WriteShort_Post						WriteShort_Post
+#define FN_WriteLong_Post						WriteLong_Post
+#define FN_WriteAngle_Post						WriteAngle_Post
+#define FN_WriteCoord_Post						WriteCoord_Post
+#define FN_WriteString_Post						WriteString_Post
+#define FN_WriteEntity_Post						WriteEntity_Post
+// #define FN_CVarRegister_Post					CVarRegister_Post
+// #define FN_CVarGetFloat_Post					CVarGetFloat_Post
+// #define FN_CVarGetString_Post				CVarGetString_Post
+// #define FN_CVarSetFloat_Post					CVarSetFloat_Post
+// #define FN_CVarSetString_Post				CVarSetString_Post
+// #define FN_AlertMessage_Post					AlertMessage_Post
+// #define FN_EngineFprintf_Post				EngineFprintf_Post
+// #define FN_PvAllocEntPrivateData_Post		PvAllocEntPrivateData_Post
+// #define FN_PvEntPrivateData_Post				PvEntPrivateData_Post
+// #define FN_FreeEntPrivateData_Post			FreeEntPrivateData_Post
+// #define FN_SzFromIndex_Post					SzFromIndex_Post
+// #define FN_AllocString_Post					AllocString_Post
+// #define FN_GetVarsOfEnt_Post					GetVarsOfEnt_Post
+// #define FN_PEntityOfEntOffset_Post			PEntityOfEntOffset_Post
+// #define FN_EntOffsetOfPEntity_Post			EntOffsetOfPEntity_Post
+// #define FN_IndexOfEdict_Post					IndexOfEdict_Post
+// #define FN_PEntityOfEntIndex_Post			PEntityOfEntIndex_Post
+// #define FN_FindEntityByVars_Post				FindEntityByVars_Post
+// #define FN_GetModelPtr_Post					GetModelPtr_Post
+#define FN_RegUserMsg_Post						RegUserMsg_Post
+// #define FN_AnimationAutomove_Post			AnimationAutomove_Post
+// #define FN_GetBonePosition_Post				GetBonePosition_Post
+// #define FN_FunctionFromName_Post				FunctionFromName_Post
+// #define FN_NameForFunction_Post				NameForFunction_Post
+// #define FN_ClientPrintf_Post					ClientPrintf_Post
+// #define FN_ServerPrint_Post					ServerPrint_Post
+// #define FN_Cmd_Args_Post						Cmd_Args_Post
+// #define FN_Cmd_Argv_Post						Cmd_Argv_Post
+// #define FN_Cmd_Argc_Post						Cmd_Argc_Post
+// #define FN_GetAttachment_Post				GetAttachment_Post
+// #define FN_CRC32_Init_Post					CRC32_Init_Post
+// #define FN_CRC32_ProcessBuffer_Post			CRC32_ProcessBuffer_Post
+// #define FN_CRC32_ProcessByte_Post			CRC32_ProcessByte_Post
+// #define FN_CRC32_Final_Post					CRC32_Final_Post
+// #define FN_RandomLong_Post					RandomLong_Post
+// #define FN_RandomFloat_Post					RandomFloat_Post
+// #define FN_SetView_Post						SetView_Post
+// #define FN_Time_Post							Time_Post
+// #define FN_CrosshairAngle_Post				CrosshairAngle_Post
+// #define FN_LoadFileForMe_Post				LoadFileForMe_Post
+// #define FN_FreeFile_Post						FreeFile_Post
+// #define FN_EndSection_Post					EndSection_Post
+// #define FN_CompareFileTime_Post				CompareFileTime_Post
+// #define FN_GetGameDir_Post					GetGameDir_Post
+// #define FN_Cvar_RegisterVariable_Post		Cvar_RegisterVariable_Post
+// #define FN_FadeClientVolume_Post				FadeClientVolume_Post
+// #define FN_SetClientMaxspeed_Post			SetClientMaxspeed_Post
+// #define FN_CreateFakeClient_Post				CreateFakeClient_Post
+// #define FN_RunPlayerMove_Post				RunPlayerMove_Post
+// #define FN_NumberOfEntities_Post				NumberOfEntities_Post
+// #define FN_GetInfoKeyBuffer_Post				GetInfoKeyBuffer_Post
+// #define FN_InfoKeyValue_Post					InfoKeyValue_Post
+// #define FN_SetKeyValue_Post					SetKeyValue_Post
+// #define FN_SetClientKeyValue_Post			SetClientKeyValue_Post
+// #define FN_IsMapValid_Post					IsMapValid_Post
+// #define FN_StaticDecal_Post					StaticDecal_Post
+// #define FN_PrecacheGeneric_Post				PrecacheGeneric_Post
+// #define FN_GetPlayerUserId_Post				GetPlayerUserId_Post
+// #define FN_BuildSoundMsg_Post				BuildSoundMsg_Post
+// #define FN_IsDedicatedServer_Post			IsDedicatedServer_Post
+// #define FN_CVarGetPointer_Post				CVarGetPointer_Post
+// #define FN_GetPlayerWONId_Post				GetPlayerWONId_Post
+// #define FN_Info_RemoveKey_Post				Info_RemoveKey_Post
+// #define FN_GetPhysicsKeyValue_Post			GetPhysicsKeyValue_Post
+// #define FN_SetPhysicsKeyValue_Post			SetPhysicsKeyValue_Post
+// #define FN_GetPhysicsInfoString_Post			GetPhysicsInfoString_Post
+// #define FN_PrecacheEvent_Post				PrecacheEvent_Post
+// #define FN_PlaybackEvent_Post				PlaybackEvent_Post
+// #define FN_SetFatPVS_Post					SetFatPVS_Post
+// #define FN_SetFatPAS_Post					SetFatPAS_Post
+// #define FN_CheckVisibility_Post				CheckVisibility_Post
+// #define FN_DeltaSetField_Post				DeltaSetField_Post
+// #define FN_DeltaUnsetField_Post				DeltaUnsetField_Post
+// #define FN_DeltaAddEncoder_Post				DeltaAddEncoder_Post
+// #define FN_GetCurrentPlayer_Post				GetCurrentPlayer_Post
+// #define FN_CanSkipPlayer_Post				CanSkipPlayer_Post
+// #define FN_DeltaFindField_Post				DeltaFindField_Post
+// #define FN_DeltaSetFieldByIndex_Post			DeltaSetFieldByIndex_Post
+// #define FN_DeltaUnsetFieldByIndex_Post		DeltaUnsetFieldByIndex_Post
+// #define FN_SetGroupMask_Post					SetGroupMask_Post
+// #define FN_engCreateInstancedBaseline_Post	engCreateInstancedBaseline_Post
+// #define FN_Cvar_DirectSet_Post				Cvar_DirectSet_Post
+// #define FN_ForceUnmodified_Post				ForceUnmodified_Post
+// #define FN_GetPlayerStats_Post				GetPlayerStats_Post
+// #define FN_AddServerCommand_Post				AddServerCommand_Post
+// #define FN_Voice_GetClientListening_Post		Voice_GetClientListening_Post
+// #define FN_Voice_SetClientListening_Post		Voice_SetClientListening_Post
+// #define FN_GetPlayerAuthId_Post				GetPlayerAuthId_Post
+
+// #define FN_OnFreeEntPrivateData				OnFreeEntPrivateData				
+// #define FN_GameShutdown						GameShutdown
+// #define FN_ShouldCollide						ShouldCollide
+
+// #define FN_OnFreeEntPrivateData_Post			OnFreeEntPrivateData_Post
+// #define FN_GameShutdown_Post					GameShutdown_Post
+// #define FN_ShouldCollide_Post				ShouldCollide_Post
+
+
+#endif // USE_METAMOD
+
+#endif // __MODULECONFIG_H__

modules/tfcx/msvc12/tfcx.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 11.00
+# Visual Studio 2010
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "tfcx", "tfcx.vcxproj", "{87519113-8E9D-4C6F-BA1F-55F4D8829E83}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{87519113-8E9D-4C6F-BA1F-55F4D8829E83}.Debug|Win32.ActiveCfg = Debug|Win32
+		{87519113-8E9D-4C6F-BA1F-55F4D8829E83}.Debug|Win32.Build.0 = Debug|Win32
+		{87519113-8E9D-4C6F-BA1F-55F4D8829E83}.Release|Win32.ActiveCfg = Release|Win32
+		{87519113-8E9D-4C6F-BA1F-55F4D8829E83}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

modules/tfcx/msvc12/tfcx.vcxproj

@@ -0,0 +1,166 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{87519113-8E9D-4C6F-BA1F-55F4D8829E83}</ProjectGuid>
+    <RootNamespace>tfcx</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseOfMfc>false</UseOfMfc>
+    <PlatformToolset>v120_xp</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseOfMfc>false</UseOfMfc>
+    <CharacterSet>MultiByte</CharacterSet>
+    <PlatformToolset>v120_xp</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</LinkIncremental>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
+    <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
+    <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(ProjectName)_amxx</TargetName>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(ProjectName)_amxx</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\Debug/tfcx.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>..\;..\..\..\public;..\..\..\public\sdk; ..\..\..\public\amtl\include;..\..\third_party;..\..\third_party\hashing;$(METAMOD)\metamod;$(HLSDK)\common;$(HLSDK)\engine;$(HLSDK)\dlls;$(HLSDK)\pm_shared;$(HLSDK)\public;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;tfcx_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <PrecompiledHeaderOutputFile>.\Debug/tfcx.pch</PrecompiledHeaderOutputFile>
+      <AssemblerListingLocation>.\Debug/</AssemblerListingLocation>
+      <ObjectFileName>.\Debug/</ObjectFileName>
+      <ProgramDataBaseFileName>.\Debug/</ProgramDataBaseFileName>
+      <BrowseInformation>true</BrowseInformation>
+      <WarningLevel>Level3</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <CompileAs>Default</CompileAs>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <ProgramDatabaseFile>.\Debug/tfcx_amxx.pdb</ProgramDatabaseFile>
+      <ImportLibrary>.\Debug/tfcx_amxx.lib</ImportLibrary>
+      <TargetMachine>MachineX86</TargetMachine>
+      <SubSystem>Windows</SubSystem>
+      <IgnoreSpecificDefaultLibraries>LIBCMT;</IgnoreSpecificDefaultLibraries>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Midl>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MkTypLibCompatible>true</MkTypLibCompatible>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <TargetEnvironment>Win32</TargetEnvironment>
+      <TypeLibraryName>.\Release/tfcx.tlb</TypeLibraryName>
+      <HeaderFileName>
+      </HeaderFileName>
+    </Midl>
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
+      <AdditionalIncludeDirectories>..\;..\..\..\public;..\..\..\public\sdk; ..\..\..\public\amtl\include;..\..\third_party;..\..\third_party\hashing;$(METAMOD)\metamod;$(HLSDK)\common;$(HLSDK)\engine;$(HLSDK)\dlls;$(HLSDK)\pm_shared;$(HLSDK)\public;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;tfcx_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <StringPooling>true</StringPooling>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StructMemberAlignment>4Bytes</StructMemberAlignment>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <PrecompiledHeaderOutputFile>.\Release/tfcx.pch</PrecompiledHeaderOutputFile>
+      <AssemblerListingLocation>.\Release/</AssemblerListingLocation>
+      <ObjectFileName>.\Release/</ObjectFileName>
+      <ProgramDataBaseFileName>.\Release/</ProgramDataBaseFileName>
+      <BrowseInformation>true</BrowseInformation>
+      <WarningLevel>Level3</WarningLevel>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <CompileAs>Default</CompileAs>
+    </ClCompile>
+    <ResourceCompile>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <Culture>0x0409</Culture>
+    </ResourceCompile>
+    <Link>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <ProgramDatabaseFile>.\Release/tfcx_amxx.pdb</ProgramDatabaseFile>
+      <ImportLibrary>.\Release/tfcx_amxx.lib</ImportLibrary>
+      <TargetMachine>MachineX86</TargetMachine>
+      <SubSystem>Windows</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\CMisc.cpp" />
+    <ClCompile Include="..\CRank.cpp" />
+    <ClCompile Include="..\moduleconfig.cpp" />
+    <ClCompile Include="..\NBase.cpp" />
+    <ClCompile Include="..\NRank.cpp" />
+    <ClCompile Include="..\usermsg.cpp" />
+    <ClCompile Include="..\Utils.cpp" />
+    <ClCompile Include="..\..\..\public\sdk\amxxmodule.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\CMisc.h" />
+    <ClInclude Include="..\CRank.h" />
+    <ClInclude Include="..\tfcx.h" />
+    <ClInclude Include="..\moduleconfig.h" />
+    <ClInclude Include="..\..\..\public\sdk\amxxmodule.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\..\plugins\include\tfcconst.inc" />
+    <None Include="..\..\..\plugins\include\tfcstats.inc" />
+    <None Include="..\..\..\plugins\include\tfcx.inc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

modules/tfcx/msvc12/tfcx.vcxproj.filters

@@ -0,0 +1,76 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{974f188b-0375-4d77-b547-9ea1727b8e01}</UniqueIdentifier>
+      <Extensions>cpp;c;cxx;rc;def;r;odl;idl;hpj;bat</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{fe7e90d8-5155-4305-8cbf-9b6f6c9e4751}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl</Extensions>
+    </Filter>
+    <Filter Include="Module SDK">
+      <UniqueIdentifier>{039dc358-7087-419d-ba27-b3460249297a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Module SDK\Base SDK">
+      <UniqueIdentifier>{6d090cd6-dd08-48df-8f62-d7ad9b16a151}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Pawn Includes">
+      <UniqueIdentifier>{be880015-6e29-4a0b-8301-e79f2e8231f6}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\CMisc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\CRank.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\moduleconfig.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\NBase.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\NRank.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\usermsg.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Utils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\..\public\sdk\amxxmodule.cpp">
+      <Filter>Module SDK\Base SDK</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\CMisc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\CRank.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\tfcx.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\..\public\sdk\amxxmodule.h">
+      <Filter>Module SDK\Base SDK</Filter>
+    </ClInclude>
+    <ClInclude Include="..\moduleconfig.h">
+      <Filter>Module SDK</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\..\..\plugins\include\tfcconst.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\..\plugins\include\tfcstats.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+    <None Include="..\..\..\plugins\include\tfcx.inc">
+      <Filter>Pawn Includes</Filter>
+    </None>
+  </ItemGroup>
+</Project>

modules/tfcx/tfcx.h

@@ -0,0 +1,142 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#ifndef RANK_H
+#define RANK_H
+
+#include "amxxmodule.h"
+#include "CMisc.h"
+#include "CRank.h"
+
+#define RANK_SVERSION "0.1"
+
+#define GET_PLAYER_POINTER(e)   (&players[ENTINDEX(e)])
+#define GET_PLAYER_POINTER_I(i) (&players[i])
+
+#ifndef GETPLAYERAUTHID
+#define GETPLAYERAUTHID   (*g_engfuncs.pfnGetPlayerAuthId)
+#endif
+
+
+extern AMX_NATIVE_INFO stats_Natives[];
+extern AMX_NATIVE_INFO base_Natives[];
+
+extern weaponsVault weaponData[TFCMAX_WEAPONS];
+extern traceVault traceData[MAX_TRACE];
+
+typedef void (*funEventCall)(void*);
+extern funEventCall modMsgsEnd[MAX_REG_MSGS];
+extern funEventCall modMsgs[MAX_REG_MSGS];
+extern void (*function)(void*);
+extern void (*endfunction)(void*);
+
+extern bool rankBots;
+
+extern bool ignoreDamage;
+
+extern int pdTimerOwner;
+extern int pdSentryGunOwner;
+extern int pdAmmo[6];
+
+extern cvar_t *tfcstats_maxsize;
+extern cvar_t* tfcstats_rank;
+extern cvar_t* tfcstats_reset;
+
+extern cvar_t* tfcstats_rankbots;
+extern cvar_t* tfcstats_pause;
+
+extern Grenades g_grenades;
+
+extern RankSystem g_rank;
+extern CPlayer players[33];
+extern CPlayer* mPlayer;
+extern int mPlayerIndex;
+extern int mState;
+
+extern int g_death_info;
+extern int g_damage_info;
+
+//extern int gmsgCurWeapon;
+//extern int gmsgDamage;
+//extern int gmsgWeaponList;
+//extern int gmsgResetHUD;
+//extern int gmsgAmmoX;
+//extern int gmsgScoreInfo;
+//extern int gmsgAmmoPickup;
+
+void Client_AmmoX(void*);
+void Client_CurWeapon(void*);
+void Client_Damage(void*);
+void Client_Damage_End(void*);
+//void Client_WeaponList(void*);
+void Client_AmmoPickup(void*);
+void Client_ScoreInfo(void*);
+void Client_ResetHUD(void*);
+
+bool ignoreBots (edict_t *pEnt, edict_t *pOther = NULL );
+bool isModuleActive();
+bool util_strncmp( const char *sz1, const char *sz2, int size);
+
+#define CHECK_ENTITY(x) \
+	if (x < 0 || x > gpGlobals->maxEntities) { \
+		MF_LogError(amx, AMX_ERR_NATIVE, "Entity out of range (%d)", x); \
+		return 0; \
+	} else { \
+		if (x <= gpGlobals->maxClients) { \
+			if (!MF_IsPlayerIngame(x)) { \
+				MF_LogError(amx, AMX_ERR_NATIVE, "Invalid player %d (not in-game)", x); \
+				return 0; \
+			} \
+		} else { \
+			if (x != 0 && FNullEnt(INDEXENT(x))) { \
+				MF_LogError(amx, AMX_ERR_NATIVE, "Invalid entity %d", x); \
+				return 0; \
+			} \
+		} \
+	}
+
+#define CHECK_PLAYER(x) \
+	if (x < 1 || x > gpGlobals->maxClients) { \
+		MF_LogError(amx, AMX_ERR_NATIVE, "Player out of range (%d)", x); \
+		return 0; \
+	} else { \
+		if (!MF_IsPlayerIngame(x) || FNullEnt(MF_GetPlayerEdict(x))) { \
+			MF_LogError(amx, AMX_ERR_NATIVE, "Invalid player %d", x); \
+			return 0; \
+		} \
+	}
+
+#define CHECK_PLAYERRANGE(x) \
+	if (x > gpGlobals->maxClients || x < 0) \
+	{ \
+		MF_LogError(amx, AMX_ERR_NATIVE, "Player out of range (%d)", x); \
+		return 0; \
+	}
+
+#define CHECK_NONPLAYER(x) \
+	if (x < 1 || x <= gpGlobals->maxClients || x > gpGlobals->maxEntities) { \
+		MF_LogError(amx, AMX_ERR_NATIVE, "Non-player entity %d out of range", x); \
+		return 0; \
+	} else { \
+		if (FNullEnt(INDEXENT(x))) { \
+			MF_LogError(amx, AMX_ERR_NATIVE, "Invalid non-player entity %d", x); \
+			return 0; \
+		} \
+	}
+
+#define GETEDICT(n) \
+	((n >= 1 && n <= gpGlobals->maxClients) ? MF_GetPlayerEdict(n) : INDEXENT(n))
+
+#endif // TFCX_H
+

modules/tfcx/usermsg.cpp

@@ -0,0 +1,316 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+// Copyright (C) 2004 Lukasz Wlasinski.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+//
+// TFCX Module
+//
+
+#include "amxxmodule.h"
+#include "tfcx.h"
+
+
+int damage;
+int TA;
+int weapon;
+int aim;
+CPlayer *pAttacker;
+edict_t* tempEnt;
+int tempInt;
+bool ignoreDamage = false;
+
+void Client_ResetHUD(void* mValue){
+	if ( mPlayer ){
+		mPlayer->clearStats = gpGlobals->time + 0.25f;
+	}
+}
+
+/*
+void Client_WeaponList(void* mValue){
+  static int wpnList;
+  static int iSlot;
+  static const char* wpnName;
+
+  switch (mState++) {
+  case 0:
+    wpnName = (const char*)mValue;
+    break;
+  case 1:
+    iSlot = *(int*)mValue;
+    break;
+  case 7:
+    int iId = *(int*)mValue;
+    if ( (iId < 0 || iId >= MAX_WEAPONS ) || ( wpnList & (1<<iId) ) )
+      break;
+
+    wpnList |= (1<<iId);
+    weaponData[iId].ammoSlot = iSlot;
+    strcpy(weaponData[iId].fullName, wpnName );
+	weaponData[iId].name = weaponData[iId].fullName;
+
+	char* wpnPrefix = strstr( weaponData[iId].fullName ,"tf_weapon_");
+
+	if ( wpnPrefix )
+		weaponData[iId].name = wpnPrefix + 10;
+  } 
+}
+*/
+
+void Client_Damage(void* mValue){
+  switch (mState++) {
+  case 1: 
+    damage = *(int*)mValue;
+    break;
+
+  case 2:
+	edict_t* enemy;
+    if ( !mPlayer || !damage )  
+		break;
+
+	enemy = mPlayer->pEdict->v.dmg_inflictor;
+
+	if ( FNullEnt( enemy ) )
+		break;
+
+	if (enemy->v.flags & (FL_CLIENT | FL_FAKECLIENT) ) { // attacker is player and his active weapon
+
+		pAttacker = GET_PLAYER_POINTER(enemy);
+		
+		aim = pAttacker->aiming;
+		weapon = pAttacker->current;
+
+		switch(weapon){
+		case TFC_WPN_SPANNER:
+		case TFC_WPN_AXE:
+		case TFC_WPN_KNIFE:
+			pAttacker->saveShot(weapon); // melee , save shot too
+			break;
+
+		case TFC_WPN_MEDIKIT:
+			if ( pAttacker->teamId == mPlayer->teamId ) // ???
+				ignoreDamage = true;
+			pAttacker->saveShot(weapon); // melee , save shot too
+			break;
+		}
+	
+		pAttacker->saveHit( mPlayer , weapon , damage, aim);
+
+	}
+	else if ( !FNullEnt( enemy->v.owner ) ){
+		if ( enemy->v.owner->v.flags & (FL_CLIENT | FL_FAKECLIENT)  ){ // caltrop, empgrenade, gasgrenade, napalmgrenade
+
+			pAttacker = GET_PLAYER_POINTER(enemy->v.owner);
+
+			const char *szClass = STRING(enemy->v.classname);
+			
+			switch(szClass[10]){
+				case 'c':
+					weapon = TFC_WPN_CALTROP;
+					break;
+				case 'e':
+					weapon = TFC_WPN_EMPGRENADE;
+					break;
+				case 'g':
+					weapon = TFC_WPN_GASGRENADE;
+					break;
+				case 'm':
+					weapon = TFC_WPN_MEDIKIT;
+					if ( pAttacker->teamId == mPlayer->teamId ) // ???
+						ignoreDamage = true;
+					pAttacker->saveShot(weapon);
+					break;
+				case 'n':
+					weapon = TFC_WPN_NAPALMGRENADE;
+					break;
+				case 'a':
+				case 's':
+				case '_': // hmm...nailgun_nail, fastswitch and this one may not be true...
+					//PRINT_CONSOLE("Nail! Class:%d wpn:%d\n",pAttacker->classId,pAttacker->current);
+					weapon = pAttacker->current;
+					aim = pAttacker->aiming;
+					break;
+				case 'r':
+					weapon = TFC_WPN_FLAMETHROWER;
+					break;
+			}
+			if ( !weapon ) {
+				switch(szClass[3]){
+				case 'e':
+					weapon = TFC_WPN_TIMER; // TFC_WPN_MEDKIT ??
+
+					tempInt = *( (int*)mPlayer->pEdict->pvPrivateData + pdTimerOwner );
+					if (!tempInt)
+						break;
+					tempEnt = (edict_t*)tempInt;
+					pAttacker = GET_PLAYER_POINTER(tempEnt);
+					
+					if ( pAttacker->teamId == mPlayer->teamId ) // ???
+						ignoreDamage = true;
+					
+					pAttacker->saveShot(weapon); // ??? save shot too
+					break;
+				case 'f':
+					weapon = TFC_WPN_FLAMES; // tf_fire
+					break;
+				}
+			}
+
+			if ( weapon )
+				pAttacker->saveHit( mPlayer , weapon , damage, aim );
+			//else 
+			//	PRINT_CONSOLE("*** DMG! Att:%d Vic:%d unknown weapon %s\n",pAttacker->index,mPlayer->index,STRING(enemy->v.classname));
+		}
+		// nailgrenadenail->nailgrenade->player :))) I'm the best !
+		else if ( !FNullEnt(enemy->v.owner->v.owner) && enemy->v.owner->v.owner->v.flags & (FL_CLIENT | FL_FAKECLIENT ) ){
+			pAttacker = GET_PLAYER_POINTER(enemy->v.owner->v.owner);
+			weapon = TFC_WPN_NAILGRENADE;
+			pAttacker->saveHit( mPlayer , weapon , damage, aim );
+		}
+	}
+    else { // nailgrenade , mirvgrenade , normalgrenade , rockets
+		if ( strstr("sentrygun",STRING(enemy->v.classname)) ){
+			tempInt = *( (int*)enemy->pvPrivateData + pdSentryGunOwner );
+			if ( !tempInt )
+				break;
+			tempEnt = (edict_t*)tempInt;
+			pAttacker = GET_PLAYER_POINTER(tempEnt);
+			weapon = TFC_WPN_SENTRYGUN;
+			pAttacker->saveShot(weapon); // save shot too
+			pAttacker->saveHit( mPlayer , weapon , damage, aim );
+		}
+		else if( g_grenades.find(enemy , &pAttacker , &weapon ) ){
+			if ( weapon == TFC_WPN_RPG && pAttacker->classId == TFC_PC_PYRO ){
+				weapon = TFC_WPN_IC;
+				pAttacker->saveShot(weapon);
+			}
+			
+			pAttacker->saveHit( mPlayer , weapon , damage, aim );
+		}
+	}
+	break;
+  }
+  
+}
+
+void Client_Damage_End(void* mValue){
+	if ( !damage )
+		return;
+
+	if ( !pAttacker )
+		pAttacker = mPlayer;
+
+	if ( !ignoreDamage ){
+		TA = 0;
+		if ( (mPlayer->teamId == pAttacker->teamId) && (mPlayer != pAttacker) )
+			TA = 1;
+		if (g_damage_info > 0)
+			MF_ExecuteForward(g_damage_info, pAttacker->index, mPlayer->index, damage, weapon, aim, TA);
+	
+		if( !mPlayer->IsAlive() ){
+			pAttacker->saveKill(mPlayer,weapon,( aim == 1 ) ? 1:0 ,TA);
+			
+			if (g_death_info > 0)
+				MF_ExecuteForward(g_death_info, pAttacker->index, mPlayer->index, weapon, aim, TA);
+		}
+	}
+
+	damage = 0;
+	aim = 0;
+	weapon = 0;
+	pAttacker = NULL;
+	ignoreDamage = false;
+
+}
+
+void Client_CurWeapon(void* mValue){
+  
+  static int iState;
+  static int iId;
+  switch (mState++){
+  case 0: 
+    iState = *(int*)mValue;
+    break;
+  case 1:
+    if (!iState) break; 
+    iId = *(int*)mValue;
+    break;
+  case 2:
+	if (!mPlayer || !iState ) break;
+    int iClip = *(int*)mValue;
+    
+	if ((iClip > -1) && (iClip < mPlayer->weapons[iId].clip)){
+		mPlayer->saveShot(iId);
+	}
+	
+    mPlayer->weapons[iId].clip = iClip;
+	mPlayer->current = iId;
+  }
+}
+
+void Client_AmmoX(void* mValue){
+  
+  static int iAmmo;
+  switch (mState++){
+  case 0:
+    iAmmo = *(int*)mValue;
+    break;
+  case 1:
+	if (!mPlayer ) break;
+
+	// SniperRifle, AC and AutoRifle ...
+	if ( mPlayer->classId == TFC_PC_HWGUY ){
+		if ( mPlayer->current == TFC_WPN_AC && mPlayer->weapons[mPlayer->current].ammo > *(int*)mValue  && iAmmo == weaponData[mPlayer->current].ammoSlot )
+			mPlayer->saveShot(mPlayer->current);
+	}
+	else if ( mPlayer->classId == TFC_PC_SNIPER ){
+		if ( (mPlayer->current == TFC_WPN_SNIPERRIFLE || mPlayer->current == TFC_WPN_AUTORIFLE) && mPlayer->weapons[mPlayer->current].ammo > *(int*)mValue && iAmmo == weaponData[mPlayer->current].ammoSlot )
+			mPlayer->saveShot(mPlayer->current);
+	}
+	//
+
+    for(int i = 1; i < MAX_WEAPONS ; ++i) 
+      if (iAmmo == weaponData[i].ammoSlot)
+        mPlayer->weapons[i].ammo = *(int*)mValue;
+  }
+}
+
+void Client_AmmoPickup(void* mValue){
+  
+  static int iSlot;
+  switch (mState++){
+  case 0:
+    iSlot = *(int*)mValue;
+    break;
+  case 1:
+	if (!mPlayer ) break;
+    for(int i = 1; i < MAX_WEAPONS ; ++i)
+      if (weaponData[i].ammoSlot == iSlot)
+        mPlayer->weapons[i].ammo += *(int*)mValue;
+  }
+}
+
+void Client_ScoreInfo(void* mValue){
+  static int iIndex;
+  static int iClass;
+  switch (mState++){
+  case 0:
+    iIndex = *(int*)mValue;
+    break;
+  case 3:
+	  iClass = *(int*)mValue;
+	  break;
+  case 4:
+	  if ( iIndex > 0 && iIndex <= gpGlobals->maxClients ){
+		  GET_PLAYER_POINTER_I( iIndex )->teamId = *(int*)mValue;
+		  GET_PLAYER_POINTER_I( iIndex )->classId = iClass;
+	  }
+
+  }
+}
+

modules/tfcx/version.rc

@@ -0,0 +1,101 @@
+// Microsoft Visual C++ generated resource script.
+//
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include <winresrc.h>
+#include <moduleconfig.h>
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION AMXX_VERSION_FILE
+ PRODUCTVERSION AMXX_VERSION_FILE
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "000004b0"
+        BEGIN
+            VALUE "Comments", "AMX Mod X"
+            VALUE "FileDescription", "AMX Mod X"
+            VALUE "FileVersion", AMXX_VERSION
+            VALUE "InternalName", MODULE_LIBRARY
+            VALUE "LegalCopyright", "Copyright (c) AMX Mod X Dev Team"
+            VALUE "OriginalFilename", MODULE_LIBRARY "_amxx.dll"
+            VALUE "ProductName", MODULE_NAME
+            VALUE "ProductVersion", AMXX_VERSION
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x0, 1200
+    END
+END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""winres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+