csstats with <mod>x functions

dlls/csstats2/amxx_package/csstats.inc

@@ -0,0 +1,80 @@
+
+
+#if defined _csstats_included
+  #endinput
+#endif
+#define _csstats_included
+
+/* Gets stats from given weapon index. If wpnindex is 0
+* then the stats are from all weapons. If weapon has not been used function
+* returns 0 in other case 1. Fields in stats are:
+* 0 - kills
+* 1 - deaths
+* 2 - headshots
+* 3 - teamkilling
+* 4 - shots
+* 5 - hits
+* 6 - damage
+* 7 - defusions
+* 8 - bomb defused
+* 9 - bomb plants
+* 10 - bomb explosions
+* For body hits fields see amxconst.inc. */
+native get_user_wstats(index,wpnindex,stats[8],bodyhits[8]);
+
+/* Gets round stats from given weapon index.*/
+native get_user_wrstats(index,wpnindex,stats[8],bodyhits[8]);
+
+/* Gets overall stats which are stored in file on server
+* and updated on every respawn or user disconnect.
+* Function returns the position in stats by diff. kills to deaths. */
+native get_user_stats(index,stats[8],bodyhits[8]);
+
+/* Gets round stats of player. */
+native get_user_rstats(index,stats[8],bodyhits[8]);
+
+/* Gets stats with which user have killed/hurt his victim. If victim is 0
+* then stats are from all victims. If victim has not been hurt, function
+* returns 0 in other case 1. User stats are reset on his respawn. */
+native get_user_vstats(index,victim,stats[8],bodyhits[8],wpnname[]="",len=0);
+
+/* Gets stats with which user have been killed/hurt. If killer is 0
+* then stats are from all attacks. If killer has not hurt user, function
+* returns 0 in other case 1. User stats are reset on his respawn. */
+native get_user_astats(index,wpnindex,stats[8],bodyhits[8],wpnname[]="",len=0);
+
+/* Resets life, weapon, victims and attackers user stats. */
+native reset_user_wstats(index);
+
+/* Gets overall stats which stored in stats.dat file in amx folder
+* and updated on every mapchange or user disconnect.
+* Function returns next index of stats entry or 0 if no more exists. */
+native get_stats(index,stats[8],bodyhits[8],name[],len);
+
+/* Returns number of all entries in stats. */
+native get_statsnum();
+
+/*
+* new stats:
+* 0 - total defusions
+* 1 - bomb defused
+* 2 - bomb plants
+* 3 - bomb explosions
+*/
+native get_user_stats2(index,stats[4]);
+native get_stats2(index,stats[4]);
+
+/*
+* Custom weapons support ( like: gasnades, lasers )
+*/
+native register_cwpn( name[] );
+native custom_wpn_dmg( wId,att,vic,dmg,hitplace=0 );
+native custom_wpn_shot( index,wid );
+native get_custom_wpnname( wId,name[],len );
+
+/*
+* Usefull forwards
+*/
+forward client_damage( attacker,victim,damage,wpnindex,hitplace,TA );
+forward client_death( killer,victim,wpnindex,hitplace,TK );
+forward grenade_throw( index,greindex,wId );

dlls/csstats2/amxx_package/stats_test.sma

@@ -0,0 +1,17 @@
+#include <amxmodx>
+
+public plugin_init() {
+	register_plugin("Stats Test","0.1","SidLuke")
+}
+
+public client_damage( attacker,victim,damage,wpnindex,hitplace,TA ){
+	client_print(0 /*attacker*/,print_console,"DAMAGE: att:%d vic:%d dmg:%d wpn:%d aim:%d TA:%d",
+			attacker,victim,damage,wpnindex,hitplace,TA)
+	return PLUGIN_CONTINUE
+}
+
+public client_death( killer,victim,wpnindex,hitplace,TK ){
+	client_print(0 /*killer*/,print_console,"DEATH: att:%d vic:%d wpn:%d aim:%d TK:%d",
+			killer,victim,wpnindex,hitplace,TK)
+	return PLUGIN_CONTINUE
+}

dlls/csstats2/csstats/CMisc.cpp

@@ -0,0 +1,256 @@
+
+
+#include "CMisc.h"
+#include "rank.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 = 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(){
+
+	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(){
+
+	if ( ignoreBots(pEdict) )
+		return;
+
+	restartStats();
+	const char* name = STRING(pEdict->v.netname);
+	const char* unique = name;
+	switch((int)csstats_rank->value) {
+	case 1: 
+		if ( (unique = GETPLAYERAUTHID(pEdict)) == 0 )
+			unique = name; // failed to get authid
+		break;
+	case 2:
+		unique = ip;
+	}
+	rank = g_rank.findEntryInRank( unique , name );
+}
+
+void CPlayer::Connect(const char* address ){
+	bot = IsBot();
+	strcpy(ip,address);
+	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;
+}
+
+void CPlayer::saveKill(CPlayer* pVictim, int wweapon, int hhs, int ttk){
+
+	if ( ignoreBots(pEdict,pVictim->pEdict) )
+		return;
+
+	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 ( ignoreBots(pEdict,pVictim->pEdict) )
+		return;
+
+	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 ( ignoreBots(pEdict) )
+		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::saveBPlant(){
+	life.bPlants++;
+}
+
+void CPlayer::saveBExplode(){
+	life.bExplosions++;
+}
+
+void CPlayer::saveBDefusing(){
+	life.bDefusions++;
+}
+
+void CPlayer::saveBDefused(){
+	life.bDefused++;
+}
+
+
+bool ignoreBots (edict_t *pEnt, edict_t *pOther){
+	if ( !rankBots && ( pEnt->v.flags & FL_FAKECLIENT || ( pOther && pOther->v.flags & FL_FAKECLIENT ) ) )
+		return true;
+	return false;
+}
+
+bool isModuleActive(){
+	if ( !(int)CVAR_GET_FLOAT("csstats_pause") )
+		return true;
+	return false;
+}

dlls/csstats2/csstats/CMisc.h

@@ -0,0 +1,93 @@
+
+
+#ifndef CMISC_H
+#define CMISC_H
+
+#include "amxxmodule.h"
+#include "CRank.h"
+
+#define MAX_CWEAPONS		6
+
+#define CSW_HEGRENADE      4
+#define CSW_SMOKEGRENADE   9
+#define CSW_FLASHBANG     25
+
+// *****************************************************
+// class CPlayer
+// *****************************************************
+
+struct CPlayer {
+	edict_t* pEdict;
+	char ip[32];
+	int index;
+	int aiming;
+	int current;
+	bool bot;
+	float clearStats;
+	RankSystem::RankStats*	rank;
+
+	struct PlayerWeapon : Stats {
+		const char* name;
+		int	ammo;
+		int	clip;
+	};
+
+	PlayerWeapon	weapons[MAX_WEAPONS+MAX_CWEAPONS];
+	PlayerWeapon	attackers[33];
+	PlayerWeapon	victims[33];
+	Stats			weaponsRnd[MAX_WEAPONS+MAX_CWEAPONS]; // DEC-Weapon (Round) stats
+	Stats			life;
+
+	int teamId;
+
+	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 saveBPlant();
+	void saveBExplode();
+	void saveBDefusing();
+	void saveBDefused();
+
+	void restartStats(bool all = true);
+	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
+
+
+

dlls/csstats2/csstats/CRank.cpp

@@ -0,0 +1,308 @@
+
+
+#include "amxxmodule.h"
+#include "CRank.h"
+#include "rank.h"
+
+// *****************************************************
+// class Stats
+// *****************************************************
+Stats::Stats(){
+	hits = shots = damage = hs = tks = kills = deaths = bDefusions = bDefused = bPlants = bExplosions = 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;
+
+	bDefusions += a->bDefusions;
+	bDefused += a->bDefused;
+	bPlants += a->bPlants;
+	bExplosions += a->bExplosions;
+
+	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)!=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)){
+		LOG_CONSOLE( PLID, "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 )
+{
+	RankStats* a = head;
+	
+	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;
+
+		calc.physAddr1[7] = rr->bDefusions;
+		calc.physAddr1[8] = rr->bDefused;
+		calc.physAddr1[9] = rr->bPlants;
+		calc.physAddr1[10] = rr->bExplosions;
+
+		for(int i = 1; i < 8; ++i)
+			calc.physAddr2[i] = rr->bodyHits[i];
+		cell result = 0;
+		int err;
+		if ((err = MF_AmxExec(&calc.amx,&result, calc.func ,2,calc.amxAddr1,calc.amxAddr2 )) != AMX_ERR_NONE)
+			LOG_CONSOLE( PLID, "Run time error %d on line %ld (plugin \"%s\")",	err,calc.amx.curline,LOCALINFO("csstats_score"));
+		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 );
+		}
+	}
+
+}
+
+void RankSystem::loadRank( const char* filename )
+{
+	FILE *bfp = fopen( filename , "rb" );
+	
+	if ( !bfp ) return;
+	
+	short int i = 0;
+	fread(&i, 1 , sizeof(short int) , bfp);
+	
+	if (i == RANK_VERSION)
+	{
+		Stats d;
+		char unique[64], name[64];
+		fread(&i , 1, sizeof(short int), bfp);
+
+		while( i )
+		{
+			fread(name , i,sizeof(char) , bfp);
+			fread(&i , 1, sizeof(short int), bfp);
+			fread(unique , i,sizeof(char) , bfp);
+			fread(&d.tks, 1,sizeof(int), bfp);
+			fread(&d.damage, 1,sizeof(int), bfp);
+			fread(&d.deaths, 1,sizeof(int), bfp);
+			fread(&d.kills, 1,sizeof(int), bfp);
+			fread(&d.shots, 1,sizeof(int), bfp);
+			fread(&d.hits, 1,sizeof(int), bfp);
+			fread(&d.hs, 1,sizeof(int), bfp);
+
+			fread(&d.bDefusions, 1,sizeof(int), bfp);
+			fread(&d.bDefused, 1,sizeof(int), bfp);
+			fread(&d.bPlants, 1,sizeof(int), bfp);
+			fread(&d.bExplosions, 1,sizeof(int), bfp);
+
+			fread(d.bodyHits, 1,sizeof(d.bodyHits), bfp);
+			fread(&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).bDefusions, 1, sizeof(int), bfp);
+			fwrite( &(*a).bDefused, 1, sizeof(int), bfp);
+			fwrite( &(*a).bPlants, 1, sizeof(int), bfp);
+			fwrite( &(*a).bExplosions, 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);
+}

dlls/csstats2/csstats/CRank.h

@@ -0,0 +1,122 @@
+
+
+#ifndef CRANK_H
+#define CRANK_H
+
+#define RANK_VERSION 11
+
+#include "amxxmodule.h"
+
+// *****************************************************
+// class Stats
+// *****************************************************
+
+struct Stats {
+	int hits;
+	int shots;
+	int damage;
+	int hs;
+	int tks;
+	int kills;
+	int deaths;
+	int bodyHits[9]; ////////////////////
+	
+	// SiDLuke start
+	int bPlants;
+	int bExplosions;
+	int bDefusions;
+	int bDefused;
+	// SiDLuke end :D
+
+	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 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

dlls/csstats2/csstats/Makefile

@@ -0,0 +1,102 @@
+MODNAME = csstats_amxx
+SRCFILES = amxxmodule.cpp CMisc.cpp CRank.cpp meta_api.cpp rank.cpp usermsg.cpp
+
+EXTRA_LIBS_LINUX =
+EXTRA_LIBS_WIN32 =
+EXTRA_LIBDIRS_LINUX = -Lextra/lib_linux
+EXTRA_LIBDIRS_WIN32 = -Lextra/lib_win32
+
+EXTRA_INCLUDEDIRS = -Iextra/include -I../amx
+
+EXTRA_FLAGS = -Dstrcmpi=strcasecmp
+
+AMXDIR=../amx
+SDKSRC=../sdk
+METADIR=../metamod
+
+OBJDIR_LINUX=obj.linux
+OBJDIR_WIN32=obj.win32
+SRCDIR=.
+
+ifdef windir
+	OS=WIN32
+else
+	OS=LINUX
+endif
+
+CC_LINUX=gcc
+ifeq "$(OS)" "WIN32"
+	CC_WIN32=gcc
+	LD_WINDLL=dllwrap
+	DEFAULT=win32
+	CLEAN=clean_win32
+else
+	CC_WIN32=/usr/local/cross-tools/i386-mingw32msvc/bin/gcc
+	LD_WINDLL=/usr/local/cross-tools/bin/i386-mingw32msvc-dllwrap
+	DEFAULT=linux win32
+	CLEAN=clean_both
+endif
+
+
+LIBFILE_LINUX = $(MODNAME)_i386.so
+LIBFILE_WIN32 = $(MODNAME).dll
+TARGET_LINUX = $(OBJDIR_LINUX)/$(LIBFILE_LINUX)
+TARGET_WIN32 = $(OBJDIR_WIN32)/$(LIBFILE_WIN32)
+
+FILES_ALL = *.cpp *.h [A-Z]* *.rc
+ifeq "$(OS)" "LINUX"
+	ASRCFILES := $(shell ls -t $(SRCFILES))
+else
+	ASRCFILES := $(shell dir /b)
+endif
+OBJ_LINUX := $(SRCFILES:%.cpp=$(OBJDIR_LINUX)/%.o)
+OBJ_WIN32 := $(SRCFILES:%.cpp=$(OBJDIR_WIN32)/%.o)
+
+CCOPT = -march=i586 -O6 -ffast-math -funroll-loops \
+	-fomit-frame-pointer -fexpensive-optimizations -malign-loops=2 \
+	-malign-jumps=2 -malign-functions=2 -s -DNDEBUG
+
+INCLUDEDIRS=-I../curl/include -I$(SRCDIR) -I$(AMXDIR) -I$(METADIR) -I$(SDKSRC)/engine -I$(SDKSRC)/common -I$(SDKSRC)/dlls -I$(SDKSRC) $(EXTRA_INCLUDEDIRS)
+CFLAGS=-Wall -Wno-unknown-pragmas
+ODEF = -DOPT_TYPE=\"optimized\"
+CFLAGS:=$(CCOPT) $(CFLAGS) $(ODEF) $(EXTRA_FLAGS)
+
+DO_CC_LINUX=$(CC_LINUX) $(CFLAGS) -fPIC $(INCLUDEDIRS) -o $@ -c $<
+DO_CC_WIN32=$(CC_WIN32) $(CFLAGS) $(INCLUDEDIRS) -o $@ -c $<
+LINK_LINUX=$(CC_LINUX) $(CFLAGS) -shared -ldl -lm $(OBJ_LINUX) $(EXTRA_LIBDIRS_LINUX) $(EXTRA_LIBS_LINUX) -o $@
+LINK_WIN32=$(LD_WINDLL) -mwindows --add-stdcall-alias $(OBJ_WIN32) $(EXTRA_LIBDIRS_WIN32) $(EXTRA_LIBS_WIN32) -o $@
+
+$(OBJDIR_LINUX)/%.o: $(SRCDIR)/%.cpp
+	$(DO_CC_LINUX)
+
+$(OBJDIR_WIN32)/%.o: $(SRCDIR)/%.cpp
+	$(DO_CC_WIN32)
+
+default: $(DEFAULT)
+
+$(TARGET_LINUX): $(OBJDIR_LINUX) $(OBJ_LINUX)
+	$(LINK_LINUX)
+
+$(TARGET_WIN32): $(OBJDIR_WIN32) $(OBJ_WIN32)
+	$(LINK_WIN32)
+
+$(OBJDIR_LINUX):
+	mkdir $@
+
+$(OBJDIR_WIN32):
+	mkdir $@
+
+win32: $(TARGET_WIN32)
+
+linux: $(TARGET_LINUX)
+
+clean: $(CLEAN)
+
+clean_both:
+	-rm -f $(OBJDIR_LINUX)/*
+	-rm -f $(OBJDIR_WIN32)/*
+
+clean_win32:
+	del /q $(OBJDIR_WIN32)
+
+

dlls/csstats2/csstats/compile.bat

@@ -0,0 +1,6 @@
+@echo off
+PATH=C:\gcc\bin;%PATH%
+
+make
+
+pause

dlls/csstats2/csstats/meta_api.cpp

@@ -0,0 +1,333 @@
+
+
+#include "amxxmodule.h"
+#include "rank.h"
+
+
+funEventCall modMsgsEnd[MAX_REG_MSGS];
+funEventCall modMsgs[MAX_REG_MSGS];
+
+void (*function)(void*);
+void (*endfunction)(void*);
+
+CPlayer players[33];
+
+CPlayer* mPlayer;
+
+int mPlayerIndex;
+int mState;
+
+RankSystem g_rank;
+
+Grenades g_grenades;
+
+int iFDeath;
+int iFDamage;
+int iFGrenade;
+
+bool rankBots;
+
+int gmsgCurWeapon;
+int gmsgDeathMsg;
+int gmsgDamage;
+int gmsgDamageEnd;
+int gmsgWeaponList;
+int gmsgResetHUD;
+int gmsgAmmoX;
+int gmsgScoreInfo;
+int gmsgAmmoPickup;
+
+int gmsgSendAudio;
+int gmsgTextMsg;
+int gmsgBarTime;
+
+cvar_t init_csstats_maxsize ={"csstats_maxsize","3500", 0 , 3500.0 };
+cvar_t init_csstats_reset ={"csstats_reset","0"};
+cvar_t init_csstats_rank ={"csstats_rank","0"};
+cvar_t *csstats_maxsize;
+cvar_t *csstats_reset;
+cvar_t *csstats_rank;
+
+cvar_t* csstats_rankbots;
+cvar_t* csstats_pause;
+cvar_t init_csstats_rankbots ={"csstats_rankbots","1"};
+cvar_t init_csstats_pause = {"csstats_pause","0"};
+
+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" , &gmsgDamageEnd, 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 },
+
+	{ "SendAudio" , &gmsgSendAudio , Client_SendAudio , false },
+	{ "TextMsg" , &gmsgTextMsg , Client_TextMsg , false },
+	{ "BarTime" , &gmsgBarTime , Client_BarTime , false },
+
+	{ 0 , 0,0,false }
+};
+
+
+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);
+}
+
+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;
+}
+
+void ServerActivate_Post( edict_t *pEdictList, int edictCount, int clientMax ){
+
+	rankBots = (int)csstats_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 ) {
+    if ( !isModuleActive() )
+		return;
+
+	CPlayer *pPlayer = GET_PLAYER_POINTER(pEntity);
+	if (pPlayer->clearStats && pPlayer->clearStats < gpGlobals->time ){
+
+		if ( !ignoreBots(pEntity) ){
+			pPlayer->clearStats = 0.0f;
+			if (pPlayer->rank)
+				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)csstats_maxsize->value) || ((int)csstats_reset->value == 1 ) ) {
+		CVAR_SET_FLOAT("csstats_reset",0.0);
+		g_rank.clear(); // clear before save to file
+	}
+	g_rank.saveRank( MF_BuildPathname("%s",get_localinfo("csstats")) );	
+	// clear custom weapons info
+	for ( i=MAX_WEAPONS;i<MAX_WEAPONS+MAX_CWEAPONS;i++)
+		weaponData[i].ammoSlot = 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)csstats_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 = 0;
+	}
+	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 ( !isModuleActive() )
+		return;
+
+	if ( e->v.owner && m[7]=='w' && m[8]=='_' ){
+		int w_id = 0;
+		CPlayer *pPlayer = GET_PLAYER_POINTER(e->v.owner);
+		switch(m[9]){
+		case 'h':
+			w_id = CSW_HEGRENADE;
+			g_grenades.put(e, 1.75, 4, pPlayer);
+			pPlayer->saveShot(4);
+			break;
+		case 'f':
+			if (m[10]=='l') w_id = CSW_FLASHBANG;
+			break;
+		case 's':
+			if (m[10]=='m') w_id = CSW_SMOKEGRENADE;
+			break;
+		}
+		if ( w_id )	
+			MF_ExecuteForward( iFGrenade, pPlayer->index, ENTINDEX(e) ,w_id );
+	}
+
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void EmitSound_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch) {
+	if (sample[0]=='w'&&sample[1]=='e'&&sample[8]=='k'&&sample[9]=='n'&&sample[14]!='d'){
+		CPlayer*pPlayer = GET_PLAYER_POINTER(entity);
+		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 (ptr->pHit&&(ptr->pHit->v.flags& (FL_CLIENT | FL_FAKECLIENT) )&&
+		e&&(e->v.flags& (FL_CLIENT | FL_FAKECLIENT) )&&ptr->iHitgroup)
+		GET_PLAYER_POINTER(e)->aiming = ptr->iHitgroup;
+	RETURN_META(MRES_IGNORED);
+}
+
+void FN_META_ATTACH() {
+
+	CVAR_REGISTER (&init_csstats_maxsize);
+	CVAR_REGISTER (&init_csstats_reset);
+	CVAR_REGISTER (&init_csstats_rank);
+	csstats_maxsize=CVAR_GET_POINTER(init_csstats_maxsize.name);
+	csstats_reset=CVAR_GET_POINTER(init_csstats_reset.name);
+	csstats_rank=CVAR_GET_POINTER(init_csstats_rank.name);
+
+	CVAR_REGISTER (&init_csstats_rankbots);
+	CVAR_REGISTER (&init_csstats_pause);
+	csstats_rankbots = CVAR_GET_POINTER(init_csstats_rankbots.name);
+	csstats_pause = CVAR_GET_POINTER(init_csstats_pause.name);
+}
+
+void FN_AMXX_ATTACH(){
+	MF_AddNatives(stats_Natives);
+	const char* path =  get_localinfo("csstats_score");
+	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("csstats") ) );
+	}
+}
+
+void FN_AMXX_Detach() {
+	g_grenades.clear();
+	g_rank.clear();
+	g_rank.unloadCalc();
+}
+
+void FN_AMXX_PLUGINSLOADED(){
+	iFDamage = MF_RegisterForward("client_damage",ET_IGNORE,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_DONE);
+	iFDeath = MF_RegisterForward("client_death",ET_IGNORE,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_CELL,FP_DONE);
+	iFGrenade = MF_RegisterForward("grenade_throw",ET_IGNORE,FP_CELL,FP_CELL,FP_CELL,FP_DONE);
+}

dlls/csstats2/csstats/moduleconfig.h

@@ -0,0 +1,462 @@
+// Configuration
+
+#ifndef __MODULECONFIG_H__
+#define __MODULECONFIG_H__
+
+// Module info
+#define MODULE_NAME "CS Stats"
+#define MODULE_VERSION "0.1"
+#define MODULE_AUTHOR ""
+#define MODULE_URL "www.amxmodx.org"
+#define MODULE_LOGTAG "CSSTATS"
+// 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
+
+// - AMXX Init functions
+// Also consider using FN_META_*
+// AMXX query
+//#define FN_AMXX_QUERY OnAmxxQuery
+// AMXX attach
+//   Do native functions init here (MF_AddNatives)
+#define FN_AMXX_ATTACH OnAmxxAttach
+// AMXX dettach
+#define FN_AMXX_DETTACH OnAmxxDettach
+// All plugins loaded
+//   Do forward functions init here (MF_RegisterForward)
+#define FN_AMXX_PLUGINSLOADED OnPluginsLoaded
+
+/**** 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 dettach
+#define FN_META_DETTACH OnMetaDettach
+
+// (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__

dlls/csstats2/csstats/msvc/csstats.dsp

@@ -0,0 +1,149 @@
+# Microsoft Developer Studio Project File - Name="csstats" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=csstats - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "csstats.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "csstats.mak" CFG="csstats - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "csstats - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "csstats - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "csstats - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "release"
+# PROP Intermediate_Dir "release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "csstats_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /Zp4 /MT /W3 /GX /O2 /I "..\..\metamod" /I "..\..\sdk\common" /I "..\..\sdk\engine" /I "..\..\sdk\dlls" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "csstats_EXPORTS" /D "JIT" /FR /YX /FD /c
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"release/csstats_amxx.dll"
+# SUBTRACT LINK32 /pdb:none
+
+!ELSEIF  "$(CFG)" == "csstats - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "debug"
+# PROP Intermediate_Dir "debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "csstats_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /I "..\..\metamod" /I "..\..\sdk\common" /I "..\..\sdk\engine" /I "..\..\sdk\dlls" /I "..\..\hlsdk\sourcecode\pm_shared" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "csstats_EXPORTS" /FR /YX /FD /GZ /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"debug/csstats_amxx.dll" /pdbtype:sept
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF 
+
+# Begin Target
+
+# Name "csstats - Win32 Release"
+# Name "csstats - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\amxxmodule.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\CMisc.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\CRank.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\meta_api.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\rank.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\usermsg.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\amxxmodule.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\CMisc.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\CRank.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\moduleconfig.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\rank.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

dlls/csstats2/csstats/rank.cpp

@@ -0,0 +1,406 @@
+
+
+#include "amxxmodule.h"
+#include "rank.h"
+
+
+static cell AMX_NATIVE_CALL get_user_astats(AMX *amx, cell *params) /* 6 param */
+{
+	int index = params[1];
+	if (index<1||index>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	int attacker = params[2];
+	if (attacker<0||attacker>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	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];
+	if (index<1||index>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	int victim = params[2];
+	if (victim<0||victim>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	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];
+	if (index<1||index>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	int weapon = params[2];
+	if (weapon<0||weapon>=MAX_WEAPONS){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		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];
+	if (index<1||index>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	int weapon = params[2];
+	if (weapon<0||weapon>=MAX_WEAPONS){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		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];
+	if (index<1||index>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	GET_PLAYER_POINTER_I(index)->restartStats();
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_user_rstats(AMX *amx, cell *params) /* 3 param */
+{
+	int index = params[1];
+	if (index<1||index>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	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_user_stats(AMX *amx, cell *params) /* 3 param */
+{
+	int index = params[1];
+	if (index<1||index>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	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_stats2(AMX *amx, cell *params) /* 3 param */
+{
+	int index = params[1];
+	if (index<1||index>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	if ( pPlayer->rank ){
+		cell *cpStats = MF_GetAmxAddr(amx,params[2]);
+
+		cpStats[0] = pPlayer->rank->bDefusions;
+		cpStats[1] = pPlayer->rank->bDefused;
+		cpStats[2] = pPlayer->rank->bPlants;
+		cpStats[3] = pPlayer->rank->bExplosions;
+
+		return pPlayer->rank->getPosition();
+	}
+	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_stats2(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]);
+
+			cpStats[0] = (*a).bDefusions;
+			cpStats[1] = (*a).bDefused;
+			cpStats[2] = (*a).bPlants;
+			cpStats[3] = (*a).bExplosions;
+
+			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=MAX_WEAPONS;i<MAX_WEAPONS+MAX_CWEAPONS;i++){
+		if ( !weaponData[i].ammoSlot ){
+			bFree = true;
+			break;
+		}
+	}
+
+	if ( !bFree ){
+		MF_PrintSrvConsole("No More Custom Weapon Slots!\n");
+		return 0;
+	}
+
+	int iLen;
+	char *szName = MF_GetAmxString(amx, params[1], 0, &iLen);
+
+	strcpy(weaponData[i].name,szName);
+	weaponData[i].ammoSlot = 1;
+
+	return i;
+}
+
+static cell AMX_NATIVE_CALL custom_wpn_dmg(AMX *amx, cell *params){ // wid,att,vic,dmg,hp=0
+	int weapon = params[1];
+	if (  weapon < MAX_WEAPONS || weapon >= MAX_WEAPONS+MAX_CWEAPONS ||  !weaponData[weapon].ammoSlot ){ // only for custom weapons
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		MF_PrintSrvConsole("Weapon ID Is Not Valid!\n");
+		return 0;
+	}
+
+	int att = params[2];
+	if (att<1||att>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+
+	int vic = params[3];
+	if (vic<1||vic>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	
+	int dmg = params[4];
+	if ( dmg<1 ){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+	
+	int aim = params[5];
+	if ( aim < 0 || aim > 7 ){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		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->teamId == pAtt->teamId) && ( pVic != pAtt) )
+		TA = 1;
+	MF_ExecuteForward( iFDamage, pAtt->index, pVic->index, dmg, weapon, aim, TA );
+	
+	if ( pVic->IsAlive() )
+		return 1;
+
+	pAtt->saveKill(pVic,weapon,( aim == 1 ) ? 1:0 ,TA);
+	MF_ExecuteForward( iFDeath, pAtt->index, pVic->index, weapon, aim, TA );
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL custom_wpn_shot(AMX *amx, cell *params){ // player,wid
+	int index = params[1];
+	if (index<1||index>gpGlobals->maxClients){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		return 0;
+	}
+
+	int weapon = params[2];
+	if (  weapon < MAX_WEAPONS  || weapon >= MAX_WEAPONS+MAX_CWEAPONS ||  !weaponData[weapon].ammoSlot ){
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		MF_PrintSrvConsole("Weapon ID Is Not Valid!\n");
+		return 0;
+	}
+
+	CPlayer* pPlayer = GET_PLAYER_POINTER_I(index);
+	pPlayer->saveShot(weapon);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL get_custom_wpnname(AMX *amx, cell *params){ 
+	int id = params[1];
+	if (id<MAX_WEAPONS || id>=MAX_WEAPONS+MAX_CWEAPONS ){ 
+		MF_RaiseAmxError(amx,AMX_ERR_NATIVE);
+		MF_PrintSrvConsole("Weapon ID Is Not Valid!\n");
+		return 0;
+	}
+	return MF_SetAmxString(amx,params[2],weaponData[id].name,params[3]);
+}
+
+AMX_NATIVE_INFO stats_Natives[] = {
+	{ "get_stats",      get_stats},
+	{ "get_stats2",      get_stats2},
+	{ "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_stats2",   get_user_stats2 },
+	{ "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
+	{ "register_cwpn", register_cwpn },
+	{ "custom_wpn_dmg", custom_wpn_dmg },
+	{ "custom_wpn_shot", custom_wpn_shot },
+	{ "get_custom_wpnname", get_custom_wpnname },
+
+	///*******************
+	{ NULL, NULL }
+};
+

dlls/csstats2/csstats/rank.h

@@ -0,0 +1,90 @@
+
+
+
+#ifndef RANK_H
+#define RANK_H
+
+#include "amxxmodule.h"
+#include "CMisc.h"
+#include "CRank.h"
+
+#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[];
+
+struct weaponsVault {
+  char* name;
+  short int ammoSlot;
+};
+
+extern bool rankBots;
+extern cvar_t* csstats_rankbots;
+extern cvar_t* csstats_pause;
+
+extern int iFDeath;
+extern int iFDamage;
+extern int iFGrenade;
+
+extern weaponsVault weaponData[MAX_WEAPONS+MAX_CWEAPONS];
+
+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 cvar_t *csstats_maxsize;
+extern cvar_t* csstats_rank;
+extern cvar_t* csstats_reset;
+
+extern Grenades g_grenades;
+
+extern RankSystem g_rank;
+
+extern CPlayer players[33];
+
+extern CPlayer* mPlayer;
+
+extern int mPlayerIndex;
+
+extern int mState;
+
+extern int gmsgCurWeapon;
+extern int gmsgDamageEnd;
+extern int gmsgDamage;
+extern int gmsgWeaponList;
+extern int gmsgResetHUD;
+extern int gmsgAmmoX;
+extern int gmsgScoreInfo;
+extern int gmsgAmmoPickup;
+
+extern int gmsgSendAudio;
+extern int gmsgTextMsg;
+extern int gmsgBarTime;
+
+void Client_AmmoX(void*);
+void Client_CurWeapon(void*);
+void Client_Damage(void*);
+void Client_WeaponList(void*);
+void Client_AmmoPickup(void*);
+void Client_Damage_End(void*);
+void Client_ScoreInfo(void*);
+void Client_ResetHUD(void*);
+
+void Client_SendAudio(void*);
+void Client_TextMsg(void*);
+void Client_BarTime(void*);
+
+bool ignoreBots (edict_t *pEnt, edict_t *pOther = NULL );
+bool isModuleActive();
+
+#endif // RANK_H
+
+
+

dlls/csstats2/csstats/usermsg.cpp

@@ -0,0 +1,200 @@
+
+
+#include "amxxmodule.h"
+#include "rank.h"
+
+weaponsVault weaponData[MAX_WEAPONS+MAX_CWEAPONS];
+
+int damage;
+int TA;
+int weapon;
+int aim;
+CPlayer *pAttacker;
+
+int g_Planter;
+int g_Defuser;
+
+void Client_ResetHUD(void* mValue){
+	if ( mPlayer && mPlayer->IsAlive() ) 
+		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;
+
+	char* wpnPrefix = strstr( wpnName,"weapon_");
+
+	if ( wpnPrefix )
+	{
+		weaponData[iId].name = wpnPrefix + 7;
+		if ( strcmp( weaponData[iId].name, "hegrenade" ) == 0 )
+			weaponData[iId].name += 2;
+	}
+  } 
+}
+
+void Client_Damage(void* mValue){
+  static int bits;
+  switch (mState++) {
+  case 1: 
+    damage = *(int*)mValue;
+    break;
+  case 2:
+    bits = *(int*)mValue;
+    break;
+  case 3:
+    if (!mPlayer || !damage || !*(float*)mValue || bits)  break;
+    edict_t *enemy;
+	enemy = mPlayer->pEdict->v.dmg_inflictor;
+    
+	if ( FNullEnt( enemy ) )
+		break;
+	aim = 0;
+	weapon = 0;
+	pAttacker = NULL;
+    
+	if (enemy->v.flags & (FL_CLIENT | FL_FAKECLIENT) ) {
+		pAttacker = GET_PLAYER_POINTER(enemy);
+		aim = pAttacker->aiming;
+		weapon = pAttacker->current;
+		pAttacker->saveHit( mPlayer , weapon , damage, aim);
+		break;
+	}
+    if( g_grenades.find(enemy , &pAttacker , &weapon ) )
+        pAttacker->saveHit( mPlayer , weapon , damage, aim );
+  }
+}
+
+void Client_Damage_End(void* mValue){
+	if ( !mPlayer || !damage )
+		return;
+
+	if ( !pAttacker ) pAttacker = mPlayer;
+		TA = 0;
+	if ( (mPlayer->teamId == pAttacker->teamId) && (mPlayer != pAttacker) )
+		TA = 1;
+	MF_ExecuteForward( iFDamage, pAttacker->index, mPlayer->index, damage, weapon, aim, TA );
+	 
+	if ( !mPlayer->IsAlive() ){
+		pAttacker->saveKill(mPlayer,weapon,( aim == 1 ) ? 1:0 ,TA);
+		MF_ExecuteForward( iFDeath, pAttacker->index, mPlayer->index, weapon, aim, TA );
+	}
+}
+
+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;
+    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 index;
+  switch (mState++){
+  case 0:
+    index = *(int*)mValue;
+    break;
+  case 4:
+	if ( index > 0 && index <= gpGlobals->maxClients )
+		GET_PLAYER_POINTER_I( index )->teamId = *(int*)mValue;
+  }
+}
+
+void Client_SendAudio(void* mValue){
+	static const char* szText;
+	if ( mState == 1 ){
+		szText = (const char*)mValue;
+		if ( !mPlayer && szText[7]=='B' ) {
+			if ( szText[11]=='P' && g_Planter )
+				GET_PLAYER_POINTER_I(g_Planter)->saveBPlant();
+			else if ( szText[11]=='D' && g_Defuser )
+				GET_PLAYER_POINTER_I(g_Defuser)->saveBDefused();
+
+		}
+	}
+	mState++;
+}
+
+void Client_TextMsg(void* mValue){
+	static const char* szText;
+	if ( !mPlayer && mState==1 ){
+		szText = (const char*)mValue;
+		if ( szText[1]=='T' && szText[8]=='B' && g_Planter )
+			GET_PLAYER_POINTER_I(g_Planter)->saveBExplode();
+	}
+	mState++;
+}
+
+void Client_BarTime(void* mValue){
+	int iTime = *(int*)mValue;
+	if ( !iTime || !mPlayer->IsAlive() ) return;
+	if ( iTime == 3 ){
+		g_Planter = mPlayerIndex;
+		g_Defuser = 0;
+	}
+	else {
+		mPlayer->saveBDefusing();
+		g_Defuser = mPlayerIndex;
+	}
+}