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

#include "amxmodx.h"
#include "fakemeta.h"

#ifndef FAKEMETA
int LoadMetamodPlugin(const char *path, void **handle, PLUG_LOADTIME now)
{
	if (gpMetaPExtFuncs)
	{
		if(PEXT_LOAD_PLUGIN_BY_NAME(PLID, path, now, handle) || !*handle)
		{
			LOG_MESSAGE(PLID, "Can't Attach metamod-module \"%s\".", path);
			return 0;
		}
		return 1;
	} else if (g_IsNewMM) {
		int err = 0;
		if ( (err = LOAD_PLUGIN(PLID, path, now, handle)) || !*handle)
		{
			LOG_MESSAGE(PLID, "Can't Attach Module \"%s\".", path);
			return 0;
		}
		return 1;
	}
	return 0;
}
int UnloadMetamodPlugin(void *handle)
{
	if (gpMetaPExtFuncs)
	{
		if(PEXT_UNLOAD_PLUGIN_BY_HANDLE(PLID, (void*)handle, PT_ANYTIME, PNL_PLUGIN)) {
			return 0;
		}
		return 1;
	} else if (g_IsNewMM) {
		if (UNLOAD_PLUGIN_BY_HANDLE(PLID, (void *)handle, PT_ANYTIME, PNL_PLUGIN))
		{
			return 0;
		}
		return 1;
	}

	return 0;
}
#else

// Fake metamod api

// for varargs
#define MAX_STRBUF_LEN 512


// Engine normal
#define FAKEMETA_ENGINE_HANDLE_void(pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetEngineFuncTable().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			(*iter).GetEngineFuncTable().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META(status);

#define FAKEMETA_ENGINE_HANDLE(ret_type, ret_init, pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	ret_type returnValue = ret_init;  /* value that will be returned */ \
	ret_type curRet = ret_init; /* current return value */ \
	bool mayOverride = true; /* if this is false, overried will be ignored */ \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetEngineFuncTable().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			curRet = (*iter).GetEngineFuncTable().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres >= MRES_OVERRIDE && mayOverride) \
			{ \
				mayOverride = false; \
				returnValue = curRet; \
			} \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META_VALUE(status, returnValue);

#define FAKEMETA_ENGINE_HANDLE_void_varargs(pfnName, pfnArg, fmtArg) \
	char buf[MAX_STRBUF_LEN]; \
	va_list ap; \
	va_start(ap, fmtArg); \
	vsprintf(buf, fmtArg, ap); \
	va_end(ap); \
	FAKEMETA_ENGINE_HANDLE_void(pfnName, (pfnArg, "%s", buf));

// Engine post
#define FAKEMETA_ENGINE_HANDLE_POST_void(pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetEngineFuncTable_Post().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			(*iter).GetEngineFuncTable_Post().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
			if (mres == MRES_SUPERCEDE) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has set meta result in \"%s\" to supercede", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META(status);


#define FAKEMETA_ENGINE_HANDLE_POST(ret_type, ret_init, pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	ret_type returnValue = ret_init;  /* value that will be returned */ \
	ret_type curRet = ret_init; /* current return value */ \
	bool mayOverride = true; /* if this is false, overried will be ignored */ \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetEngineFuncTable_Post().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			curRet = (*iter).GetEngineFuncTable_Post().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres >= MRES_OVERRIDE && mayOverride) \
			{ \
				mayOverride = false; \
				returnValue = curRet; \
			} \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
			if (mres == MRES_SUPERCEDE) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has set meta result in \"%s\" to supercede", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META_VALUE(status, returnValue);

#define FAKEMETA_ENGINE_HANLDE_POST_void_varargs(pfnName, pfnArg, fmtArg) \
	char buf[MAX_STRBUF_LEN]; \
	va_list ap; \
	va_start(ap, fmtArg); \
	vsprintf(buf, fmtArg, ap); \
	va_end(ap); \
	FAKEMETA_ENGINE_HANDLE_POST_void(pfnName, (pfnArg, "%s", buf));



// Dll normal
#define FAKEMETA_DLL_HANDLE_void(pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetDllFuncTable().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			(*iter).GetDllFuncTable().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META(status);

#define FAKEMETA_DLL_HANDLE(ret_type, ret_init, pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	ret_type returnValue = ret_init;  /* value that will be returned */ \
	ret_type curRet = ret_init; /* current return value */ \
	bool mayOverride = true; /* if this is false, overried will be ignored */ \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetDllFuncTable().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			curRet = (*iter).GetDllFuncTable().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres >= MRES_OVERRIDE && mayOverride) \
			{ \
				mayOverride = false; \
				returnValue = curRet; \
			} \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META_VALUE(status, returnValue);

// Dll post
#define FAKEMETA_DLL_HANDLE_POST_void(pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetDllFuncTable_Post().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			(*iter).GetDllFuncTable_Post().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META(status);

#define FAKEMETA_DLL_HANDLE_POST(ret_type, ret_init, pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	ret_type returnValue = ret_init;  /* value that will be returned */ \
	ret_type curRet = ret_init; /* current return value */ \
	bool mayOverride = true; /* if this is false, overried will be ignored */ \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetDllFuncTable_Post().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			curRet = (*iter).GetDllFuncTable_Post().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres >= MRES_OVERRIDE && mayOverride) \
			{ \
				mayOverride = false; \
				returnValue = curRet; \
			} \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
			if (mres == MRES_SUPERCEDE) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has set meta result in \"%s\" to supercede", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META_VALUE(status, returnValue);

// New Dll normal
#define FAKEMETA_NEWDLL_HANDLE_void(pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetNewDllFuncTable().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			(*iter).GetNewDllFuncTable().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META(status);

#define FAKEMETA_NEWDLL_HANDLE(ret_type, ret_init, pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	ret_type returnValue = ret_init;  /* value that will be returned */ \
	ret_type curRet = ret_init; /* current return value */ \
	bool mayOverride = true; /* if this is false, overried will be ignored */ \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetNewDllFuncTable().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			curRet = (*iter).GetNewDllFuncTable().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres >= MRES_OVERRIDE && mayOverride) \
			{ \
				mayOverride = false; \
				returnValue = curRet; \
			} \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META_VALUE(status, returnValue);

// Dll post
#define FAKEMETA_NEWDLL_HANDLE_POST_void(pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetNewDllFuncTable_Post().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			(*iter).GetNewDllFuncTable_Post().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META(status);

#define FAKEMETA_NEWDLL_HANDLE_POST(ret_type, ret_init, pfnName, pfnArgs) \
	META_RES mres = MRES_IGNORED, status = MRES_IGNORED, prev_mres = MRES_UNSET; \
	ret_type returnValue = ret_init;  /* value that will be returned */ \
	ret_type curRet = ret_init; /* current return value */ \
	bool mayOverride = true; /* if this is false, overried will be ignored */ \
	for (CList<CFakeMeta::CFakeMetaPlugin>::iterator iter = g_FakeMeta.m_Plugins.begin(); iter; ++iter) \
	{ \
		if ((*iter).GetStatus() == PL_RUNNING && (*iter).GetNewDllFuncTable_Post().pfn##pfnName) \
		{ \
			/* Initialize meta globals */ \
			gpMetaGlobals->mres = MRES_UNSET; \
			gpMetaGlobals->prev_mres = prev_mres; \
			gpMetaGlobals->status = status; \
			/* Actual call */ \
			curRet = (*iter).GetNewDllFuncTable_Post().pfn##pfnName pfnArgs; \
			/* Process return value */ \
			mres = gpMetaGlobals->mres; \
			if (mres >= MRES_OVERRIDE && mayOverride) \
			{ \
				mayOverride = false; \
				returnValue = curRet; \
			} \
			if (mres > status) \
				status = mres; \
			prev_mres = mres; \
			if (mres == MRES_UNSET) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has not set meta result in \"%s\"", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
			if (mres == MRES_SUPERCEDE) \
				AMXXLOG_Log("[AMXX] Module \"%s\" (\"%s\") has set meta result in \"%s\" to supercede", \
				(*iter).GetInfo()->name, (*iter).GetPath(), #pfnName); \
		} \
	} \
	/* Set meta result to the highest value */ \
	RETURN_META_VALUE(status, returnValue);


// ****** Meta hooks ******
//   **** Engine api

int PrecacheModel(char *s) {
	FAKEMETA_ENGINE_HANDLE(int, 0, PrecacheModel, (s));
}
int PrecacheSound(char *s) {
	FAKEMETA_ENGINE_HANDLE(int, 0, PrecacheSound, (s));
}
void SetModel(edict_t *e, const char *m) {
	FAKEMETA_ENGINE_HANDLE_void(SetModel, (e,m));
}

int ModelIndex(const char *m) {
	FAKEMETA_ENGINE_HANDLE(int, 0, ModelIndex, (m));
}
int ModelFrames(int modelIndex) {
	FAKEMETA_ENGINE_HANDLE(int, 0, ModelFrames, (modelIndex));
}

void SetSize(edict_t *e, const float *rgflMin, const float *rgflMax) {
	FAKEMETA_ENGINE_HANDLE_void(SetSize, (e,rgflMin,rgflMax));
}
void ChangeLevel(char *s1, char *s2) {
	FAKEMETA_ENGINE_HANDLE_void(ChangeLevel, (s1,s2));
}
void GetSpawnParms(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_void(GetSpawnParms, (ent));
}
void SaveSpawnParms(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_void(SaveSpawnParms, (ent));
}

float VecToYaw(const float *rgflVector) {
	FAKEMETA_ENGINE_HANDLE(float, 0, VecToYaw, (rgflVector));
}
void VecToAngles(const float *rgflVectorIn, float *rgflVectorOut) {
	FAKEMETA_ENGINE_HANDLE_void(VecToAngles, (rgflVectorIn,rgflVectorOut));
}
void MoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType) {
	FAKEMETA_ENGINE_HANDLE_void(MoveToOrigin, (ent,pflGoal,dist,iMoveType));
}
void ChangeYaw(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_void(ChangeYaw, (ent));
}
void ChangePitch(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_void(ChangePitch, (ent));
}

edict_t *FindEntityByString(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, FindEntityByString, (pEdictStartSearchAfter, pszField, pszValue));
}
int GetEntityIllum(edict_t *pEnt) {
	FAKEMETA_ENGINE_HANDLE(int, 0, GetEntityIllum, (pEnt));
}
edict_t *FindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, FindEntityInSphere, (pEdictStartSearchAfter,org,rad));
}
edict_t *FindClientInPVS(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, FindClientInPVS, (pEdict));
}
edict_t *EntitiesInPVS(edict_t *pplayer) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, EntitiesInPVS, (pplayer));
}

void MakeVectors(const float *rgflVector) {
	FAKEMETA_ENGINE_HANDLE_void(MakeVectors, (rgflVector));
}
void AngleVectors(const float *rgflVector, float *forward, float *right, float *up) {
	FAKEMETA_ENGINE_HANDLE_void(AngleVectors, (rgflVector,forward,right,up));
}

edict_t *CreateEntity(void) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, CreateEntity, ());
}
void RemoveEntity(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE_void(RemoveEntity, (e));
}
edict_t *CreateNamedEntity(int className) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, CreateNamedEntity, (className));
}

void MakeStatic(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_void(MakeStatic, (ent));
}
int EntIsOnFloor(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE(int, 0, EntIsOnFloor, (e));
}
int DropToFloor(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE(int, 0, DropToFloor, (e));
}

int WalkMove(edict_t *ent, float yaw, float dist, int iMode) {
	FAKEMETA_ENGINE_HANDLE(int, 0, WalkMove, (ent, yaw, dist, iMode));
}
void SetOrigin(edict_t *e, const float *rgflOrigin) {
	FAKEMETA_ENGINE_HANDLE_void(SetOrigin, (e,rgflOrigin));
}

void EmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch) {
	FAKEMETA_ENGINE_HANDLE_void(EmitSound, (entity,channel,sample,volume,attenuation,fFlags,pitch));
}
void EmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch) {
	FAKEMETA_ENGINE_HANDLE_void(EmitAmbientSound, (entity,pos,samp,vol,attenuation,fFlags,pitch));
}

void TraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_void(TraceLine, (v1,v2,fNoMonsters,pentToSkip,ptr));
}
void TraceToss(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_void(TraceToss, (pent,pentToIgnore,ptr));
}
int TraceMonsterHull(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE(int, 0, TraceMonsterHull, (pEdict, v1, v2, fNoMonsters, pentToSkip, ptr));
}
void TraceHull(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_void(TraceHull, (v1,v2,fNoMonsters,hullNumber,pentToSkip,ptr));
}
void TraceModel(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_void(TraceModel, (v1,v2,hullNumber,pent,ptr));
}
const char *TraceTexture(edict_t *pTextureEntity, const float *v1, const float *v2 ) {
	FAKEMETA_ENGINE_HANDLE(const char*, 0, TraceTexture, (pTextureEntity,v1,v2));
}
void TraceSphere(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_void(TraceSphere, (v1,v2,fNoMonsters,radius,pentToSkip,ptr));
}
void GetAimVector(edict_t *ent, float speed, float *rgflReturn) {
	FAKEMETA_ENGINE_HANDLE_void(GetAimVector, (ent,speed,rgflReturn));
}

void ServerCommand(char *str) {
	FAKEMETA_ENGINE_HANDLE_void(ServerCommand, (str));
}
void ServerExecute(void) {
	FAKEMETA_ENGINE_HANDLE_void(ServerExecute, ());
}
void engClientCommand(edict_t *pEdict, char *szFmt, ...) {
	FAKEMETA_ENGINE_HANDLE_void_varargs(ClientCommand, pEdict, szFmt);
}

void ParticleEffect(const float *org, const float *dir, float color, float count) {
	FAKEMETA_ENGINE_HANDLE_void(ParticleEffect, (org,dir,color,count));
}
void LightStyle(int style, char *val) {
	FAKEMETA_ENGINE_HANDLE_void(LightStyle, (style,val));
}
int DecalIndex(const char *name) {
	FAKEMETA_ENGINE_HANDLE(int, 0, DecalIndex, (name));
}
int PointContents(const float *rgflVector) {
	FAKEMETA_ENGINE_HANDLE(int, 0, PointContents, (rgflVector));
}

void MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed) {
	FAKEMETA_ENGINE_HANDLE_void(MessageBegin, (msg_dest,msg_type,pOrigin,ed));
}
void MessageEnd(void) {
	FAKEMETA_ENGINE_HANDLE_void(MessageEnd, ());
}

void WriteByte(int iValue) {
	FAKEMETA_ENGINE_HANDLE_void(WriteByte, (iValue));
}
void WriteChar(int iValue) {
	FAKEMETA_ENGINE_HANDLE_void(WriteChar, (iValue));
}
void WriteShort(int iValue) {
	FAKEMETA_ENGINE_HANDLE_void(WriteShort, (iValue));
}
void WriteLong(int iValue) {
	FAKEMETA_ENGINE_HANDLE_void(WriteLong, (iValue));
}
void WriteAngle(float flValue) {
	FAKEMETA_ENGINE_HANDLE_void(WriteAngle, (flValue));
}
void WriteCoord(float flValue) {
	FAKEMETA_ENGINE_HANDLE_void(WriteCoord, (flValue));
}
void WriteString(const char *sz) {
	FAKEMETA_ENGINE_HANDLE_void(WriteString, (sz));
}
void WriteEntity(int iValue) {
	FAKEMETA_ENGINE_HANDLE_void(WriteEntity, (iValue));
}

void CVarRegister(cvar_t *pCvar) {
	FAKEMETA_ENGINE_HANDLE_void(CVarRegister, (pCvar));
}
float CVarGetFloat(const char *szVarName) {
	FAKEMETA_ENGINE_HANDLE(float, 0, CVarGetFloat, (szVarName));
}
const char* CVarGetString(const char *szVarName) {
	FAKEMETA_ENGINE_HANDLE(const char*, 0, CVarGetString, (szVarName));
}
void CVarSetFloat(const char *szVarName, float flValue) {
	FAKEMETA_ENGINE_HANDLE_void(CVarSetFloat, (szVarName, flValue));
}
void CVarSetString(const char *szVarName, const char *szValue) {
	FAKEMETA_ENGINE_HANDLE_void(CVarSetString, (szVarName, szValue));
}

void AlertMessage(ALERT_TYPE atype, char *szFmt, ...) {
	FAKEMETA_ENGINE_HANDLE_void_varargs(AlertMessage, atype, szFmt);
}

#ifdef HLSDK_2_3_OLD_EIFACE
void EngineFprintf(FILE *pfile, char *szFmt, ...) {
#else
void EngineFprintf(void *pfile, char *szFmt, ...) {
#endif
	FAKEMETA_ENGINE_HANDLE_void_varargs(EngineFprintf, pfile, szFmt);
}

#ifdef HLSDK_2_3_OLD_EIFACE
void *PvAllocEntPrivateData(edict_t *pEdict, long cb) {
#else
void *PvAllocEntPrivateData(edict_t *pEdict, int cb) {
#endif
	FAKEMETA_ENGINE_HANDLE(void*, 0, PvAllocEntPrivateData, (pEdict, cb));
}
void *PvEntPrivateData(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE(void*, 0, PvEntPrivateData, (pEdict));
}
void FreeEntPrivateData(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE_void(FreeEntPrivateData, (pEdict));
}

const char *SzFromIndex(int iString) {
	FAKEMETA_ENGINE_HANDLE(const char*, 0, SzFromIndex, (iString));
}
int AllocString(const char *szValue) {
	FAKEMETA_ENGINE_HANDLE(int, 0, AllocString, (szValue));
}

struct entvars_s *GetVarsOfEnt(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE(struct entvars_s*, 0, GetVarsOfEnt, (pEdict));
}
edict_t *PEntityOfEntOffset(int iEntOffset) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, PEntityOfEntOffset, (iEntOffset));
}
int EntOffsetOfPEntity(const edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE(int, 0, EntOffsetOfPEntity, (pEdict));
}
int IndexOfEdict(const edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE(int, 0, IndexOfEdict, (pEdict));
}
edict_t *PEntityOfEntIndex(int iEntIndex) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, PEntityOfEntIndex, (iEntIndex));
}
edict_t *FindEntityByVars(struct entvars_s *pvars) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, FindEntityByVars, (pvars));
}
void *GetModelPtr(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE(void*, 0, GetModelPtr, (pEdict));
}

int RegUserMsg(const char *pszName, int iSize) {
	FAKEMETA_ENGINE_HANDLE(int, 0, RegUserMsg, (pszName, iSize));
}

void AnimationAutomove(const edict_t *pEdict, float flTime) {
	FAKEMETA_ENGINE_HANDLE_void(AnimationAutomove, (pEdict, flTime));
}
void GetBonePosition(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles ) {
	FAKEMETA_ENGINE_HANDLE_void(GetBonePosition, (pEdict, iBone, rgflOrigin, rgflAngles));
}

#ifdef HLSDK_2_3_OLD_EIFACE
unsigned long FunctionFromName( const char *pName ) {
	FAKEMETA_ENGINE_HANDLE(unsigned long, 0, FunctionFromName, (pName));
#else
unsigned int FunctionFromName( const char *pName ) {
	FAKEMETA_ENGINE_HANDLE(unsigned int, 0, FunctionFromName, (pName));
#endif
}

#ifdef HLSDK_2_3_OLD_EIFACE
const char *NameForFunction( unsigned long function ) {
#else
const char *NameForFunction( unsigned int function ) {
#endif
	FAKEMETA_ENGINE_HANDLE(const char*, 0, NameForFunction, (function));
}

void ClientPrintf( edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg ) {
	FAKEMETA_ENGINE_HANDLE_void(ClientPrintf, (pEdict,ptype,szMsg));
}

void ServerPrint( const char *szMsg ) {
	FAKEMETA_ENGINE_HANDLE_void(ServerPrint, (szMsg));
}

const char *Cmd_Args( void ) {
	FAKEMETA_ENGINE_HANDLE(const char*, 0, Cmd_Args, ());
}

const char *Cmd_Argv( int argc )
{
	FAKEMETA_ENGINE_HANDLE(const char*, 0, Cmd_Argv, (argc));
}

int Cmd_Argc( void ) {
	FAKEMETA_ENGINE_HANDLE(int, 0, Cmd_Argc, ());
}

void GetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ) {
	FAKEMETA_ENGINE_HANDLE_void(GetAttachment, (pEdict,iAttachment,rgflOrigin,rgflAngles));
}

void CRC32_Init(CRC32_t *pulCRC) {
	FAKEMETA_ENGINE_HANDLE_void(CRC32_Init, (pulCRC));
}
void CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len) {
	FAKEMETA_ENGINE_HANDLE_void(CRC32_ProcessBuffer, (pulCRC,p,len));
}
void CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch) {
	FAKEMETA_ENGINE_HANDLE_void(CRC32_ProcessByte, (pulCRC,ch));
}
CRC32_t CRC32_Final(CRC32_t pulCRC) {
	FAKEMETA_ENGINE_HANDLE(CRC32_t, 0, CRC32_Final, (pulCRC));
}

#ifdef HLSDK_2_3_OLD_EIFACE
long RandomLong(long lLow, long lHigh) {
	FAKEMETA_ENGINE_HANDLE(long, 0, RandomLong, (lLow, lHigh));
#else
int RandomLong(int lLow, int lHigh) {
	FAKEMETA_ENGINE_HANDLE(int, 0, RandomLong, (lLow, lHigh));
#endif
}
float RandomFloat(float flLow, float flHigh) {
	FAKEMETA_ENGINE_HANDLE(float, 0, RandomFloat, (flLow, flHigh));
}

void SetView(const edict_t *pClient, const edict_t *pViewent ) {
	FAKEMETA_ENGINE_HANDLE_void(SetView, (pClient,pViewent));
}
float Time( void ) {
	FAKEMETA_ENGINE_HANDLE(float, 0, Time, ());
}
void CrosshairAngle(const edict_t *pClient, float pitch, float yaw) {
	FAKEMETA_ENGINE_HANDLE_void(CrosshairAngle, (pClient,pitch,yaw));
}

byte * LoadFileForMe(char *filename, int *pLength) {
	FAKEMETA_ENGINE_HANDLE(byte *, 0, LoadFileForMe, (filename, pLength));
}
void FreeFile(void *buffer) {
	FAKEMETA_ENGINE_HANDLE_void(FreeFile, (buffer));
}

void EndSection(const char *pszSectionName) {
	FAKEMETA_ENGINE_HANDLE_void(EndSection, (pszSectionName));
}
int CompareFileTime(char *filename1, char *filename2, int *iCompare) {
	FAKEMETA_ENGINE_HANDLE(int, 0, CompareFileTime, (filename1, filename2, iCompare));
}
void GetGameDir(char *szGetGameDir) {
	FAKEMETA_ENGINE_HANDLE_void(GetGameDir, (szGetGameDir));
}
void Cvar_RegisterVariable(cvar_t *variable) {
	FAKEMETA_ENGINE_HANDLE_void(Cvar_RegisterVariable, (variable));
}
void FadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds) {
	FAKEMETA_ENGINE_HANDLE_void(FadeClientVolume, (pEdict, fadePercent, fadeOutSeconds, holdTime, fadeInSeconds));
}
void SetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed) {
	FAKEMETA_ENGINE_HANDLE_void(SetClientMaxspeed, (pEdict,fNewMaxspeed));
}
edict_t * CreateFakeClient(const char *netname) {
	FAKEMETA_ENGINE_HANDLE(edict_t*, 0, CreateFakeClient, (netname));
}
void RunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec ) {
	FAKEMETA_ENGINE_HANDLE_void(RunPlayerMove, (fakeclient,viewangles,forwardmove,sidemove,upmove,buttons,impulse,msec));
}
int NumberOfEntities(void) {
	FAKEMETA_ENGINE_HANDLE(int, 0, NumberOfEntities, ());
}

char *GetInfoKeyBuffer(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE(char*, 0, GetInfoKeyBuffer, (e));
}
char *InfoKeyValue(char *infobuffer, char *key) {
	FAKEMETA_ENGINE_HANDLE(char*, 0, InfoKeyValue, (infobuffer, key));
}
void SetKeyValue(char *infobuffer, char *key, char *value) {
	FAKEMETA_ENGINE_HANDLE_void(SetKeyValue, (infobuffer,key,value));
}
void SetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value) {
	FAKEMETA_ENGINE_HANDLE_void(SetClientKeyValue, (clientIndex,infobuffer,key,value));
}

int IsMapValid(char *filename) {
	FAKEMETA_ENGINE_HANDLE(int, 0, IsMapValid, (filename));
}
void StaticDecal( const float *origin, int decalIndex, int entityIndex, int modelIndex ) {
	FAKEMETA_ENGINE_HANDLE_void(StaticDecal, (origin,decalIndex,entityIndex,modelIndex));
}
int PrecacheGeneric(char *s) {
	FAKEMETA_ENGINE_HANDLE(int, 0, PrecacheGeneric, (s));
}
int GetPlayerUserId(edict_t *e ) {
	FAKEMETA_ENGINE_HANDLE(int, 0, GetPlayerUserId, (e));
}
void BuildSoundMsg(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed) {
	FAKEMETA_ENGINE_HANDLE_void(BuildSoundMsg, (entity,channel,sample,volume,attenuation,fFlags,pitch,msg_dest,msg_type,pOrigin,ed));
}
int IsDedicatedServer(void) {
	FAKEMETA_ENGINE_HANDLE(int, 0, IsDedicatedServer, ());
}
cvar_t *CVarGetPointer(const char *szVarName) {
	FAKEMETA_ENGINE_HANDLE(cvar_t*, 0, CVarGetPointer, (szVarName));
}
unsigned int GetPlayerWONId(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE(unsigned int, 0, GetPlayerWONId, (e));
}

//! YWB 8/1/99 TFF Physics additions
void Info_RemoveKey( char *s, const char *key ) {
	FAKEMETA_ENGINE_HANDLE_void(Info_RemoveKey, (s,key));
}
const char *GetPhysicsKeyValue( const edict_t *pClient, const char *key ) {
	FAKEMETA_ENGINE_HANDLE(const char*, 0, GetPhysicsKeyValue, (pClient, key));
}
void SetPhysicsKeyValue( const edict_t *pClient, const char *key, const char *value ) {
	FAKEMETA_ENGINE_HANDLE_void(SetPhysicsKeyValue, (pClient,key,value));
}
const char *GetPhysicsInfoString( const edict_t *pClient ) {
	FAKEMETA_ENGINE_HANDLE(const char*, 0, GetPhysicsInfoString, (pClient));
}
unsigned short PrecacheEvent( int type, const char *psz ) {
	FAKEMETA_ENGINE_HANDLE(unsigned short, 0, PrecacheEvent, (type, psz));
}
void PlaybackEvent( int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 ) {
	FAKEMETA_ENGINE_HANDLE_void(PlaybackEvent, (flags,pInvoker,eventindex,delay,origin,angles,fparam1,fparam2,iparam1,iparam2,bparam1,bparam2));
}

unsigned char *SetFatPVS( float *org ) {
	FAKEMETA_ENGINE_HANDLE(unsigned char*, 0, SetFatPVS, (org));
}
unsigned char *SetFatPAS( float *org ) {
	FAKEMETA_ENGINE_HANDLE(unsigned char*, 0, SetFatPAS, (org));
}

int CheckVisibility( const edict_t *entity, unsigned char *pset ) {
	FAKEMETA_ENGINE_HANDLE(int, 0, CheckVisibility, (entity, pset));
}

void DeltaSetField( struct delta_s *pFields, const char *fieldname ) {
	FAKEMETA_ENGINE_HANDLE_void(DeltaSetField, (pFields,fieldname));
}
void DeltaUnsetField( struct delta_s *pFields, const char *fieldname ) {
	FAKEMETA_ENGINE_HANDLE_void(DeltaUnsetField, (pFields,fieldname));
}
void DeltaAddEncoder( char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ) {
	FAKEMETA_ENGINE_HANDLE_void(DeltaAddEncoder, (name,conditionalencode));
}
int GetCurrentPlayer( void ) {
	FAKEMETA_ENGINE_HANDLE(int, 0, GetCurrentPlayer, ());
}
int CanSkipPlayer( const edict_t *player ) {
	FAKEMETA_ENGINE_HANDLE(int, 0, CanSkipPlayer, (player));
}
int DeltaFindField( struct delta_s *pFields, const char *fieldname ) {
	FAKEMETA_ENGINE_HANDLE(int, 0, DeltaFindField, (pFields, fieldname));
}
void DeltaSetFieldByIndex( struct delta_s *pFields, int fieldNumber ) {
	FAKEMETA_ENGINE_HANDLE_void(DeltaSetFieldByIndex, (pFields,fieldNumber));
}
void DeltaUnsetFieldByIndex( struct delta_s *pFields, int fieldNumber ) {
	FAKEMETA_ENGINE_HANDLE_void(DeltaUnsetFieldByIndex, (pFields,fieldNumber));
}

void SetGroupMask( int mask, int op ) {
	FAKEMETA_ENGINE_HANDLE_void(SetGroupMask, (mask,op));
}

int engCreateInstancedBaseline( int classname, struct entity_state_s *baseline ) {
	FAKEMETA_ENGINE_HANDLE(int, 0, CreateInstancedBaseline, (classname, baseline));
}
void Cvar_DirectSet( struct cvar_s *var, char *value ) {
	FAKEMETA_ENGINE_HANDLE_void(Cvar_DirectSet, (var,value));
}

//! Forces the client and server to be running with the same version of the specified file
//!( e.g., a player model ).
//! Calling this has no effect in single player
void ForceUnmodified( FORCE_TYPE type, float *mins, float *maxs, const char *filename ) {
	FAKEMETA_ENGINE_HANDLE_void(ForceUnmodified, (type,mins,maxs,filename));
}

void GetPlayerStats( const edict_t *pClient, int *ping, int *packet_loss ) {
	FAKEMETA_ENGINE_HANDLE_void(GetPlayerStats, (pClient,ping,packet_loss));
}

void AddServerCommand( char *cmd_name, void (*function) (void) ) {
	FAKEMETA_ENGINE_HANDLE_void(AddServerCommand, (cmd_name,function));
}
// Added in SDK 2.2:
qboolean Voice_GetClientListening(int iReceiver, int iSender) {
	FAKEMETA_ENGINE_HANDLE(qboolean, 0, Voice_GetClientListening, (iReceiver,iSender));
}
qboolean Voice_SetClientListening(int iReceiver, int iSender, qboolean bListen) {
	FAKEMETA_ENGINE_HANDLE(qboolean, 0, Voice_SetClientListening, (iReceiver, iSender, bListen));
}

// Added for HL 1109 (no SDK update):
const char *GetPlayerAuthId(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE(const char*, 0, GetPlayerAuthId, (e));
}

//   **** Engine api Post

int PrecacheModel_Post(char *s) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, PrecacheModel, (s));
}
int PrecacheSound_Post(char *s) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, PrecacheSound, (s));
}
void SetModel_Post(edict_t *e, const char *m) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SetModel, (e,m));
}

int ModelIndex_Post(const char *m) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, ModelIndex, (m));
}
int ModelFrames_Post(int modelIndex) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, ModelFrames, (modelIndex));
}

void SetSize_Post(edict_t *e, const float *rgflMin, const float *rgflMax) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SetSize, (e,rgflMin,rgflMax));
}
void ChangeLevel_Post(char *s1, char *s2) {
	FAKEMETA_ENGINE_HANDLE_POST_void(ChangeLevel, (s1,s2));
}
void GetSpawnParms_Post(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_POST_void(GetSpawnParms, (ent));
}
void SaveSpawnParms_Post(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SaveSpawnParms, (ent));
}

float VecToYaw_Post(const float *rgflVector) {
	FAKEMETA_ENGINE_HANDLE_POST(float, 0, VecToYaw, (rgflVector));
}
void VecToAngles_Post(const float *rgflVectorIn, float *rgflVectorOut) {
	FAKEMETA_ENGINE_HANDLE_POST_void(VecToAngles, (rgflVectorIn,rgflVectorOut));
}
void MoveToOrigin_Post(edict_t *ent, const float *pflGoal, float dist, int iMoveType) {
	FAKEMETA_ENGINE_HANDLE_POST_void(MoveToOrigin, (ent,pflGoal,dist,iMoveType));
}
void ChangeYaw_Post(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_POST_void(ChangeYaw, (ent));
}
void ChangePitch_Post(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_POST_void(ChangePitch, (ent));
}

edict_t *FindEntityByString_Post(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, FindEntityByString, (pEdictStartSearchAfter, pszField, pszValue));
}
int GetEntityIllum_Post(edict_t *pEnt) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, GetEntityIllum, (pEnt));
}
edict_t *FindEntityInSphere_Post(edict_t *pEdictStartSearchAfter, const float *org, float rad) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, FindEntityInSphere, (pEdictStartSearchAfter,org,rad));
}
edict_t *FindClientInPVS_Post(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, FindClientInPVS, (pEdict));
}
edict_t *EntitiesInPVS_Post(edict_t *pplayer) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, EntitiesInPVS, (pplayer));
}

void MakeVectors_Post(const float *rgflVector) {
	FAKEMETA_ENGINE_HANDLE_POST_void(MakeVectors, (rgflVector));
}
void AngleVectors_Post(const float *rgflVector, float *forward, float *right, float *up) {
	FAKEMETA_ENGINE_HANDLE_POST_void(AngleVectors, (rgflVector,forward,right,up));
}

edict_t *CreateEntity_Post(void) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, CreateEntity, ());
}
void RemoveEntity_Post(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE_POST_void(RemoveEntity, (e));
}
edict_t *CreateNamedEntity_Post(int className) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, CreateNamedEntity, (className));
}

void MakeStatic_Post(edict_t *ent) {
	FAKEMETA_ENGINE_HANDLE_POST_void(MakeStatic, (ent));
}
int EntIsOnFloor_Post(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, EntIsOnFloor, (e));
}
int DropToFloor_Post(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, DropToFloor, (e));
}

int WalkMove_Post(edict_t *ent, float yaw, float dist, int iMode) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, WalkMove, (ent, yaw, dist, iMode));
}
void SetOrigin_Post(edict_t *e, const float *rgflOrigin) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SetOrigin, (e,rgflOrigin));
}

void EmitSound_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch) {
	FAKEMETA_ENGINE_HANDLE_POST_void(EmitSound, (entity,channel,sample,volume,attenuation,fFlags,pitch));
}
void EmitAmbientSound_Post(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch) {
	FAKEMETA_ENGINE_HANDLE_POST_void(EmitAmbientSound, (entity,pos,samp,vol,attenuation,fFlags,pitch));
}

void TraceLine_Post(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_POST_void(TraceLine, (v1,v2,fNoMonsters,pentToSkip,ptr));
}
void TraceToss_Post(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_POST_void(TraceToss, (pent,pentToIgnore,ptr));
}
int TraceMonsterHull_Post(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, TraceMonsterHull, (pEdict, v1, v2, fNoMonsters, pentToSkip, ptr));
}
void TraceHull_Post(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_POST_void(TraceHull, (v1,v2,fNoMonsters,hullNumber,pentToSkip,ptr));
}
void TraceModel_Post(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_POST_void(TraceModel, (v1,v2,hullNumber,pent,ptr));
}
const char *TraceTexture_Post(edict_t *pTextureEntity, const float *v1, const float *v2 ) {
	FAKEMETA_ENGINE_HANDLE_POST(const char*, 0, TraceTexture, (pTextureEntity,v1,v2));
}
void TraceSphere_Post(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr) {
	FAKEMETA_ENGINE_HANDLE_POST_void(TraceSphere, (v1,v2,fNoMonsters,radius,pentToSkip,ptr));
}
void GetAimVector_Post(edict_t *ent, float speed, float *rgflReturn) {
	FAKEMETA_ENGINE_HANDLE_POST_void(GetAimVector, (ent,speed,rgflReturn));
}

void ServerCommand_Post(char *str) {
	FAKEMETA_ENGINE_HANDLE_POST_void(ServerCommand, (str));
}
void ServerExecute_Post(void) {
	FAKEMETA_ENGINE_HANDLE_POST_void(ServerExecute, ());
}
void engClientCommand_Post(edict_t *pEdict, char *szFmt, ...) {
	FAKEMETA_ENGINE_HANLDE_POST_void_varargs(ClientCommand, pEdict, szFmt);
}

void ParticleEffect_Post(const float *org, const float *dir, float color, float count) {
	FAKEMETA_ENGINE_HANDLE_POST_void(ParticleEffect, (org,dir,color,count));
}
void LightStyle_Post(int style, char *val) {
	FAKEMETA_ENGINE_HANDLE_POST_void(LightStyle, (style,val));
}
int DecalIndex_Post(const char *name) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, DecalIndex, (name));
}
int PointContents_Post(const float *rgflVector) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, PointContents, (rgflVector));
}

void MessageBegin_Post(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed) {
	FAKEMETA_ENGINE_HANDLE_POST_void(MessageBegin, (msg_dest,msg_type,pOrigin,ed));
}
void MessageEnd_Post(void) {
	FAKEMETA_ENGINE_HANDLE_POST_void(MessageEnd, ());
}

void WriteByte_Post(int iValue) {
	FAKEMETA_ENGINE_HANDLE_POST_void(WriteByte, (iValue));
}
void WriteChar_Post(int iValue) {
	FAKEMETA_ENGINE_HANDLE_POST_void(WriteChar, (iValue));
}
void WriteShort_Post(int iValue) {
	FAKEMETA_ENGINE_HANDLE_POST_void(WriteShort, (iValue));
}
void WriteLong_Post(int iValue) {
	FAKEMETA_ENGINE_HANDLE_POST_void(WriteLong, (iValue));
}
void WriteAngle_Post(float flValue) {
	FAKEMETA_ENGINE_HANDLE_POST_void(WriteAngle, (flValue));
}
void WriteCoord_Post(float flValue) {
	FAKEMETA_ENGINE_HANDLE_POST_void(WriteCoord, (flValue));
}
void WriteString_Post(const char *sz) {
	FAKEMETA_ENGINE_HANDLE_POST_void(WriteString, (sz));
}
void WriteEntity_Post(int iValue) {
	FAKEMETA_ENGINE_HANDLE_POST_void(WriteEntity, (iValue));
}

void CVarRegister_Post(cvar_t *pCvar) {
	FAKEMETA_ENGINE_HANDLE_POST_void(CVarRegister, (pCvar));
}
float CVarGetFloat_Post(const char *szVarName) {
	FAKEMETA_ENGINE_HANDLE_POST(float, 0, CVarGetFloat, (szVarName));
}
const char* CVarGetString_Post(const char *szVarName) {
	FAKEMETA_ENGINE_HANDLE_POST(const char*, 0, CVarGetString, (szVarName));
}
void CVarSetFloat_Post(const char *szVarName, float flValue) {
	FAKEMETA_ENGINE_HANDLE_POST_void(CVarSetFloat, (szVarName, flValue));
}
void CVarSetString_Post(const char *szVarName, const char *szValue) {
	FAKEMETA_ENGINE_HANDLE_POST_void(CVarSetString, (szVarName, szValue));
}

void AlertMessage_Post(ALERT_TYPE atype, char *szFmt, ...) {
	FAKEMETA_ENGINE_HANLDE_POST_void_varargs(AlertMessage, atype, szFmt);
}

#ifdef HLSDK_2_3_OLD_EIFACE
void EngineFprintf_Post(FILE *pfile, char *szFmt, ...) {
#else
void EngineFprintf_Post(void *pfile, char *szFmt, ...) {
#endif
	FAKEMETA_ENGINE_HANLDE_POST_void_varargs(EngineFprintf, pfile, szFmt);
}

#ifdef HLSDK_2_3_OLD_EIFACE
void *PvAllocEntPrivateData_Post(edict_t *pEdict, long cb) {
#else
void *PvAllocEntPrivateData_Post(edict_t *pEdict, int cb) {
#endif
	FAKEMETA_ENGINE_HANDLE_POST(void*, 0, PvAllocEntPrivateData, (pEdict, cb));
}
void *PvEntPrivateData_Post(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE_POST(void*, 0, PvEntPrivateData, (pEdict));
}
void FreeEntPrivateData_Post(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE_POST_void(FreeEntPrivateData, (pEdict));
}

const char *SzFromIndex_Post(int iString) {
	FAKEMETA_ENGINE_HANDLE_POST(const char*, 0, SzFromIndex, (iString));
}
int AllocString_Post(const char *szValue) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, AllocString, (szValue));
}

struct entvars_s *GetVarsOfEnt_Post(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE_POST(struct entvars_s*, 0, GetVarsOfEnt, (pEdict));
}
edict_t *PEntityOfEntOffset_Post(int iEntOffset) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, PEntityOfEntOffset, (iEntOffset));
}
int EntOffsetOfPEntity_Post(const edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, EntOffsetOfPEntity, (pEdict));
}
int IndexOfEdict_Post(const edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, IndexOfEdict, (pEdict));
}
edict_t *PEntityOfEntIndex_Post(int iEntIndex) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, PEntityOfEntIndex, (iEntIndex));
}
edict_t *FindEntityByVars_Post(struct entvars_s *pvars) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, FindEntityByVars, (pvars));
}
void *GetModelPtr_Post(edict_t *pEdict) {
	FAKEMETA_ENGINE_HANDLE_POST(void*, 0, GetModelPtr, (pEdict));
}

int RegUserMsg_Post(const char *pszName, int iSize) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, RegUserMsg, (pszName, iSize));
}

void AnimationAutomove_Post(const edict_t *pEdict, float flTime) {
	FAKEMETA_ENGINE_HANDLE_POST_void(AnimationAutomove, (pEdict, flTime));
}
void GetBonePosition_Post(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(GetBonePosition, (pEdict, iBone, rgflOrigin, rgflAngles));
}

#ifdef HLSDK_2_3_OLD_EIFACE
unsigned long FunctionFromName_Post( const char *pName ) {
	FAKEMETA_ENGINE_HANDLE_POST(unsigned long, 0, FunctionFromName, (pName));
#else
unsigned int FunctionFromName_Post( const char *pName ) {
	FAKEMETA_ENGINE_HANDLE_POST(unsigned int, 0, FunctionFromName, (pName));
#endif
}

#ifdef HLSDK_2_3_OLD_EIFACE
const char *NameForFunction_Post( unsigned long function ) {
#else
const char *NameForFunction_Post( unsigned int function ) {
#endif
	FAKEMETA_ENGINE_HANDLE_POST(const char*, 0, NameForFunction, (function));
}

void ClientPrintf_Post( edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(ClientPrintf, (pEdict,ptype,szMsg));
}

void ServerPrint_Post( const char *szMsg ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(ServerPrint, (szMsg));
}

const char *Cmd_Args_Post( void ) {
	FAKEMETA_ENGINE_HANDLE_POST(const char*, 0, Cmd_Args, ());
}

const char *Cmd_Argv_Post( int argc ) {
	FAKEMETA_ENGINE_HANDLE_POST(const char*, 0, Cmd_Argv, (argc));
}

int Cmd_Argc_Post( void ) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, Cmd_Argc, ());
}

void GetAttachment_Post(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(GetAttachment, (pEdict,iAttachment,rgflOrigin,rgflAngles));
}

void CRC32_Init_Post(CRC32_t *pulCRC) {
	FAKEMETA_ENGINE_HANDLE_POST_void(CRC32_Init, (pulCRC));
}
void CRC32_ProcessBuffer_Post(CRC32_t *pulCRC, void *p, int len) {
	FAKEMETA_ENGINE_HANDLE_POST_void(CRC32_ProcessBuffer, (pulCRC,p,len));
}
void CRC32_ProcessByte_Post(CRC32_t *pulCRC, unsigned char ch) {
	FAKEMETA_ENGINE_HANDLE_POST_void(CRC32_ProcessByte, (pulCRC,ch));
}
CRC32_t CRC32_Final_Post(CRC32_t pulCRC) {
	FAKEMETA_ENGINE_HANDLE_POST(CRC32_t, 0, CRC32_Final, (pulCRC));
}

#ifdef HLSDK_2_3_OLD_EIFACE
long RandomLong_Post(long lLow, long lHigh) {
	FAKEMETA_ENGINE_HANDLE_POST(long, 0, RandomLong, (lLow, lHigh));
#else
int RandomLong_Post(int lLow, int lHigh) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, RandomLong, (lLow, lHigh));
#endif
}
float RandomFloat_Post(float flLow, float flHigh) {
	FAKEMETA_ENGINE_HANDLE_POST(float, 0, RandomFloat, (flLow, flHigh));
}

void SetView_Post(const edict_t *pClient, const edict_t *pViewent ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SetView, (pClient,pViewent));
}
float Time_Post( void ) {
	FAKEMETA_ENGINE_HANDLE_POST(float, 0, Time, ());
}
void CrosshairAngle_Post(const edict_t *pClient, float pitch, float yaw) {
	FAKEMETA_ENGINE_HANDLE_POST_void(CrosshairAngle, (pClient,pitch,yaw));
}

byte * LoadFileForMe_Post(char *filename, int *pLength) {
	FAKEMETA_ENGINE_HANDLE_POST(byte *, 0, LoadFileForMe, (filename, pLength));
}
void FreeFile_Post(void *buffer) {
	FAKEMETA_ENGINE_HANDLE_POST_void(FreeFile, (buffer));
}

void EndSection_Post(const char *pszSectionName) {
	FAKEMETA_ENGINE_HANDLE_POST_void(EndSection, (pszSectionName));
}
int CompareFileTime_Post(char *filename1, char *filename2, int *iCompare) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, CompareFileTime, (filename1, filename2, iCompare));
}
void GetGameDir_Post(char *szGetGameDir) {
	FAKEMETA_ENGINE_HANDLE_POST_void(GetGameDir, (szGetGameDir));
}
void Cvar_RegisterVariable_Post(cvar_t *variable) {
	FAKEMETA_ENGINE_HANDLE_POST_void(Cvar_RegisterVariable, (variable));
}
void FadeClientVolume_Post(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds) {
	FAKEMETA_ENGINE_HANDLE_POST_void(FadeClientVolume, (pEdict, fadePercent, fadeOutSeconds, holdTime, fadeInSeconds));
}
void SetClientMaxspeed_Post(const edict_t *pEdict, float fNewMaxspeed) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SetClientMaxspeed, (pEdict,fNewMaxspeed));
}
edict_t * CreateFakeClient_Post(const char *netname) {
	FAKEMETA_ENGINE_HANDLE_POST(edict_t*, 0, CreateFakeClient, (netname));
}
void RunPlayerMove_Post(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(RunPlayerMove, (fakeclient,viewangles,forwardmove,sidemove,upmove,buttons,impulse,msec));
}
int NumberOfEntities_Post(void) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, NumberOfEntities, ());
}

char *GetInfoKeyBuffer_Post(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE_POST(char*, 0, GetInfoKeyBuffer, (e));
}
char *InfoKeyValue_Post(char *infobuffer, char *key) {
	FAKEMETA_ENGINE_HANDLE_POST(char*, 0, InfoKeyValue, (infobuffer, key));
}
void SetKeyValue_Post(char *infobuffer, char *key, char *value) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SetKeyValue, (infobuffer,key,value));
}
void SetClientKeyValue_Post(int clientIndex, char *infobuffer, char *key, char *value) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SetClientKeyValue, (clientIndex,infobuffer,key,value));
}

int IsMapValid_Post(char *filename) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, IsMapValid, (filename));
}
void StaticDecal_Post( const float *origin, int decalIndex, int entityIndex, int modelIndex ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(StaticDecal, (origin,decalIndex,entityIndex,modelIndex));
}
int PrecacheGeneric_Post(char *s) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, PrecacheGeneric, (s));
}
int GetPlayerUserId_Post(edict_t *e ) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, GetPlayerUserId, (e));
}
void BuildSoundMsg_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed) {
	FAKEMETA_ENGINE_HANDLE_POST_void(BuildSoundMsg, (entity,channel,sample,volume,attenuation,fFlags,pitch,msg_dest,msg_type,pOrigin,ed));
}
int IsDedicatedServer_Post(void) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, IsDedicatedServer, ());
}
cvar_t *CVarGetPointer_Post(const char *szVarName) {
	FAKEMETA_ENGINE_HANDLE_POST(cvar_t*, 0, CVarGetPointer, (szVarName));
}
unsigned int GetPlayerWONId_Post(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE_POST(unsigned int, 0, GetPlayerWONId, (e));
}

//! YWB 8/1/99 TFF Physics additions
void Info_RemoveKey_Post( char *s, const char *key ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(Info_RemoveKey, (s,key));
}
const char *GetPhysicsKeyValue_Post( const edict_t *pClient, const char *key ) {
	FAKEMETA_ENGINE_HANDLE_POST(const char*, 0, GetPhysicsKeyValue, (pClient, key));
}
void SetPhysicsKeyValue_Post( const edict_t *pClient, const char *key, const char *value ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SetPhysicsKeyValue, (pClient,key,value));
}
const char *GetPhysicsInfoString_Post( const edict_t *pClient ) {
	FAKEMETA_ENGINE_HANDLE_POST(const char*, 0, GetPhysicsInfoString, (pClient));
}
unsigned short PrecacheEvent_Post( int type, const char *psz ) {
	FAKEMETA_ENGINE_HANDLE_POST(unsigned short, 0, PrecacheEvent, (type, psz));
}
void PlaybackEvent_Post( int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2 ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(PlaybackEvent, (flags,pInvoker,eventindex,delay,origin,angles,fparam1,fparam2,iparam1,iparam2,bparam1,bparam2));
}

unsigned char *SetFatPVS_Post( float *org ) {
	FAKEMETA_ENGINE_HANDLE_POST(unsigned char*, 0, SetFatPVS, (org));
}
unsigned char *SetFatPAS_Post( float *org ) {
	FAKEMETA_ENGINE_HANDLE_POST(unsigned char*, 0, SetFatPAS, (org));
}

int CheckVisibility_Post( const edict_t *entity, unsigned char *pset ) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, CheckVisibility, (entity, pset));
}

void DeltaSetField_Post( struct delta_s *pFields, const char *fieldname ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(DeltaSetField, (pFields,fieldname));
}
void DeltaUnsetField_Post( struct delta_s *pFields, const char *fieldname ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(DeltaUnsetField, (pFields,fieldname));
}
void DeltaAddEncoder_Post( char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(DeltaAddEncoder, (name,conditionalencode));
}
int GetCurrentPlayer_Post( void ) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, GetCurrentPlayer, ());
}
int CanSkipPlayer_Post( const edict_t *player ) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, CanSkipPlayer, (player));
}
int DeltaFindField_Post( struct delta_s *pFields, const char *fieldname ) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, DeltaFindField, (pFields, fieldname));
}
void DeltaSetFieldByIndex_Post( struct delta_s *pFields, int fieldNumber ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(DeltaSetFieldByIndex, (pFields,fieldNumber));
}
void DeltaUnsetFieldByIndex_Post( struct delta_s *pFields, int fieldNumber ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(DeltaUnsetFieldByIndex, (pFields,fieldNumber));
}

void SetGroupMask_Post( int mask, int op ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(SetGroupMask, (mask,op));
}

int engCreateInstancedBaseline_Post( int classname, struct entity_state_s *baseline ) {
	FAKEMETA_ENGINE_HANDLE_POST(int, 0, CreateInstancedBaseline, (classname, baseline));
}
void Cvar_DirectSet_Post( struct cvar_s *var, char *value ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(Cvar_DirectSet, (var,value));
}

//! Forces the client and server to be running with the same version of the specified file
//!( e.g., a player model ).
//! Calling this has no effect in single player
void ForceUnmodified_Post( FORCE_TYPE type, float *mins, float *maxs, const char *filename ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(ForceUnmodified, (type,mins,maxs,filename));
}

void GetPlayerStats_Post( const edict_t *pClient, int *ping, int *packet_loss ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(GetPlayerStats, (pClient,ping,packet_loss));
}

void AddServerCommand_Post( char *cmd_name, void (*function)(void) ) {
	FAKEMETA_ENGINE_HANDLE_POST_void(AddServerCommand, (cmd_name,function));
}
// Added in SDK 2.2:
qboolean Voice_GetClientListening_Post(int iReceiver, int iSender) {
	FAKEMETA_ENGINE_HANDLE_POST(qboolean, 0, Voice_GetClientListening, (iReceiver,iSender));
}
qboolean Voice_SetClientListening_Post(int iReceiver, int iSender, qboolean bListen) {
	FAKEMETA_ENGINE_HANDLE_POST(qboolean, 0, Voice_SetClientListening, (iReceiver, iSender, bListen));
}

// Added for HL 1109 (no SDK update):
const char *GetPlayerAuthId_Post(edict_t *e) {
	FAKEMETA_ENGINE_HANDLE_POST(const char*, 0, GetPlayerAuthId, (e));
}

//   **** dllapi

// from SDK dlls/cbase.h:
void GameDLLInit(void) {
	FAKEMETA_DLL_HANDLE_void(GameInit, ());
}
int DispatchSpawn( edict_t *pent ) {
	FAKEMETA_DLL_HANDLE(int, 0, Spawn, (pent));
}
void DispatchThink( edict_t *pent ) {
	FAKEMETA_DLL_HANDLE_void(Think, (pent));
}
void DispatchUse( edict_t *pentUsed, edict_t *pentOther ) {
	FAKEMETA_DLL_HANDLE_void(Use, (pentUsed, pentOther));
}
void DispatchTouch( edict_t *pentTouched, edict_t *pentOther ) {
	FAKEMETA_DLL_HANDLE_void(Touch, (pentTouched, pentOther));
}
void DispatchBlocked( edict_t *pentBlocked, edict_t *pentOther ) {
	FAKEMETA_DLL_HANDLE_void(Blocked, (pentBlocked, pentOther));
}
void DispatchKeyValue( edict_t *pentKeyvalue, KeyValueData *pkvd ) {
	FAKEMETA_DLL_HANDLE_void(KeyValue, (pentKeyvalue, pkvd));
}
void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData ) {
	FAKEMETA_DLL_HANDLE_void(Save, (pent, pSaveData));
}
int  DispatchRestore( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity ) {
	FAKEMETA_DLL_HANDLE(int , 0, Restore, (pent,pSaveData,globalEntity));
}
void DispatchObjectCollsionBox( edict_t *pent ) {
	FAKEMETA_DLL_HANDLE_void(SetAbsBox, (pent));
}
void SaveWriteFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount ) {
	FAKEMETA_DLL_HANDLE_void(SaveWriteFields, (pSaveData,pname,pBaseData,pFields,fieldCount));
}
void SaveReadFields( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount ) {
	FAKEMETA_DLL_HANDLE_void(SaveReadFields, (pSaveData,pname,pBaseData,pFields,fieldCount));
}
void SaveGlobalState( SAVERESTOREDATA *pSaveData ) {
	FAKEMETA_DLL_HANDLE_void(SaveGlobalState, (pSaveData));
}
void RestoreGlobalState( SAVERESTOREDATA *pSaveData ) {
	FAKEMETA_DLL_HANDLE_void(RestoreGlobalState, (pSaveData));
}
void ResetGlobalState( void ) {
	FAKEMETA_DLL_HANDLE_void(ResetGlobalState, ());
}

// from SDK dlls/client.h:
BOOL ClientConnect( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] ) {
	FAKEMETA_DLL_HANDLE(BOOL, 0, ClientConnect, (pEntity,pszName,pszAddress,szRejectReason));
}
void ClientDisconnect( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_void(ClientDisconnect, (pEntity));
}
void ClientKill( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_void(ClientKill, (pEntity));
}
void ClientPutInServer( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_void(ClientPutInServer, (pEntity));
}
void ClientCommand( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_void(ClientCommand, (pEntity));
}
void ClientUserInfoChanged( edict_t *pEntity, char *infobuffer ) {
	FAKEMETA_DLL_HANDLE_void(ClientUserInfoChanged, (pEntity,infobuffer));
}
void ServerActivate( edict_t *pEdictList, int edictCount, int clientMax ) {
	FAKEMETA_DLL_HANDLE_void(ServerActivate, (pEdictList,edictCount,clientMax));
}
void ServerDeactivate( void ) {
	FAKEMETA_DLL_HANDLE_void(ServerDeactivate, ());
}
void PlayerPreThink( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_void(PlayerPreThink, (pEntity));
}
void PlayerPostThink( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_void(PlayerPostThink, (pEntity));
}
void StartFrame( void ) {
	FAKEMETA_DLL_HANDLE_void(StartFrame, ());
}
void ParmsNewLevel( void ) {
	FAKEMETA_DLL_HANDLE_void(ParmsNewLevel, ());
}
void ParmsChangeLevel( void ) {
	FAKEMETA_DLL_HANDLE_void(ParmsChangeLevel, ());
}
const char *GetGameDescription( void ) {
	FAKEMETA_DLL_HANDLE(const char*, 0, GetGameDescription, ());
}
void PlayerCustomization( edict_t *pEntity, customization_t *pCust ) {
	FAKEMETA_DLL_HANDLE_void(PlayerCustomization, (pEntity,pCust));
}
void SpectatorConnect( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_void(SpectatorConnect, (pEntity));
}
void SpectatorDisconnect( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_void(SpectatorDisconnect, (pEntity));
}
void SpectatorThink( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_void(SpectatorThink, (pEntity));
}
void Sys_Error( const char *error_string ) {
	FAKEMETA_DLL_HANDLE_void(Sys_Error, (error_string));
}

// from SDK pm_shared/pm_shared.h:
void PM_Move( struct playermove_s *ppmove, int server ) {
	FAKEMETA_DLL_HANDLE_void(PM_Move, (ppmove,server));
}
void PM_Init( struct playermove_s *ppmove ) {
	FAKEMETA_DLL_HANDLE_void(PM_Init, (ppmove));
}

char PM_FindTextureType( char *name ) {
	FAKEMETA_DLL_HANDLE(char, 0, PM_FindTextureType, (name));
}

// from SDK dlls/client.h:
void SetupVisibility( edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas ) {
	FAKEMETA_DLL_HANDLE_void(SetupVisibility, (pViewEntity,pClient,pvs,pas));
}
void UpdateClientData( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd ) {
	FAKEMETA_DLL_HANDLE_void(UpdateClientData, (ent,sendweapons,cd));
}
int AddToFullPack( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet ) {
	FAKEMETA_DLL_HANDLE(int, 0, AddToFullPack, (state,e,ent,host,hostflags,player,pSet));
}
void CreateBaseline( int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs ) {
	FAKEMETA_DLL_HANDLE_void(CreateBaseline, (player,eindex,baseline,entity,playermodelindex,player_mins,player_maxs));
}
void RegisterEncoders( void ) {
	FAKEMETA_DLL_HANDLE_void(RegisterEncoders, ());
}
int GetWeaponData( struct edict_s *player, struct weapon_data_s *info ) {
	FAKEMETA_DLL_HANDLE(int, 0, GetWeaponData, (player,info));
}
void CmdStart( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed ) {
	FAKEMETA_DLL_HANDLE_void(CmdStart, (player,cmd,random_seed));
}
void CmdEnd( const edict_t *player ) {
	FAKEMETA_DLL_HANDLE_void(CmdEnd, (player));
}
int ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size ) {
	FAKEMETA_DLL_HANDLE(int, 0, ConnectionlessPacket, (net_from,args,response_buffer,response_buffer_size));
}
int GetHullBounds( int hullnumber, float *mins, float *maxs ) {
	FAKEMETA_DLL_HANDLE(int, 0, GetHullBounds, (hullnumber,mins,maxs));
}
void CreateInstancedBaselines( void ) {
	FAKEMETA_DLL_HANDLE_void(CreateInstancedBaselines, ());
}
int InconsistentFile( const edict_t *player, const char *filename, char *disconnect_message ) {
	FAKEMETA_DLL_HANDLE(int, 0, InconsistentFile, (player,filename,disconnect_message));
}
int AllowLagCompensation( void )
{
	FAKEMETA_DLL_HANDLE(int, 0, AllowLagCompensation, ());
}

//    **** dllapi post

// from SDK dlls/cbase.h:
void GameDLLInit_Post(void) {
	FAKEMETA_DLL_HANDLE_POST_void(GameInit, ());
}
int DispatchSpawn_Post( edict_t *pent ) {
	FAKEMETA_DLL_HANDLE_POST(int, 0, Spawn, (pent));
}
void DispatchThink_Post( edict_t *pent ) {
	FAKEMETA_DLL_HANDLE_POST_void(Think, (pent));
}
void DispatchUse_Post( edict_t *pentUsed, edict_t *pentOther ) {
	FAKEMETA_DLL_HANDLE_POST_void(Use, (pentUsed, pentOther));
}
void DispatchTouch_Post( edict_t *pentTouched, edict_t *pentOther ) {
	FAKEMETA_DLL_HANDLE_POST_void(Touch, (pentTouched, pentOther));
}
void DispatchBlocked_Post( edict_t *pentBlocked, edict_t *pentOther ) {
	FAKEMETA_DLL_HANDLE_POST_void(Blocked, (pentBlocked, pentOther));
}
void DispatchKeyValue_Post( edict_t *pentKeyvalue, KeyValueData *pkvd ) {
	FAKEMETA_DLL_HANDLE_POST_void(KeyValue, (pentKeyvalue, pkvd));
}
void DispatchSave_Post( edict_t *pent, SAVERESTOREDATA *pSaveData ) {
	FAKEMETA_DLL_HANDLE_POST_void(Save, (pent, pSaveData));
}
int  DispatchRestore_Post( edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity ) {
	FAKEMETA_DLL_HANDLE_POST(int , 0, Restore, (pent,pSaveData,globalEntity));
}
void DispatchObjectCollsionBox_Post( edict_t *pent ) {
	FAKEMETA_DLL_HANDLE_POST_void(SetAbsBox, (pent));
}
void SaveWriteFields_Post( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount ) {
	FAKEMETA_DLL_HANDLE_POST_void(SaveWriteFields, (pSaveData,pname,pBaseData,pFields,fieldCount));
}
void SaveReadFields_Post( SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount ) {
	FAKEMETA_DLL_HANDLE_POST_void(SaveReadFields, (pSaveData,pname,pBaseData,pFields,fieldCount));
}
void SaveGlobalState_Post( SAVERESTOREDATA *pSaveData ) {
	FAKEMETA_DLL_HANDLE_POST_void(SaveGlobalState, (pSaveData));
}
void RestoreGlobalState_Post( SAVERESTOREDATA *pSaveData ) {
	FAKEMETA_DLL_HANDLE_POST_void(RestoreGlobalState, (pSaveData));
}
void ResetGlobalState_Post( void ) {
	FAKEMETA_DLL_HANDLE_POST_void(ResetGlobalState, ());
}

// from SDK dlls/client.h:
BOOL ClientConnect_Post( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ] ) {
	FAKEMETA_DLL_HANDLE_POST(BOOL, 0, ClientConnect, (pEntity,pszName,pszAddress,szRejectReason));
}
void ClientDisconnect_Post( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_POST_void(ClientDisconnect, (pEntity));
}
void ClientKill_Post( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_POST_void(ClientKill, (pEntity));
}
void ClientPutInServer_Post( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_POST_void(ClientPutInServer, (pEntity));
}
void ClientCommand_Post( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_POST_void(ClientCommand, (pEntity));
}
void ClientUserInfoChanged_Post( edict_t *pEntity, char *infobuffer ) {
	FAKEMETA_DLL_HANDLE_POST_void(ClientUserInfoChanged, (pEntity,infobuffer));
}
void ServerActivate_Post( edict_t *pEdictList, int edictCount, int clientMax ) {
	FAKEMETA_DLL_HANDLE_POST_void(ServerActivate, (pEdictList,edictCount,clientMax));
}
void ServerDeactivate_Post( void ) {
	FAKEMETA_DLL_HANDLE_POST_void(ServerDeactivate, ());
}
void PlayerPreThink_Post( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_POST_void(PlayerPreThink, (pEntity));
}
void PlayerPostThink_Post( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_POST_void(PlayerPostThink, (pEntity));
}
void StartFrame_Post( void ) {
	FAKEMETA_DLL_HANDLE_POST_void(StartFrame, ());
}
void ParmsNewLevel_Post( void ) {
	FAKEMETA_DLL_HANDLE_POST_void(ParmsNewLevel, ());
}
void ParmsChangeLevel_Post( void ) {
	FAKEMETA_DLL_HANDLE_POST_void(ParmsChangeLevel, ());
}
const char *GetGameDescription_Post( void ) {
	FAKEMETA_DLL_HANDLE_POST(const char*, 0, GetGameDescription, ());
}
void PlayerCustomization_Post( edict_t *pEntity, customization_t *pCust ) {
	FAKEMETA_DLL_HANDLE_POST_void(PlayerCustomization, (pEntity,pCust));
}
void SpectatorConnect_Post( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_POST_void(SpectatorConnect, (pEntity));
}
void SpectatorDisconnect_Post( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_POST_void(SpectatorDisconnect, (pEntity));
}
void SpectatorThink_Post( edict_t *pEntity ) {
	FAKEMETA_DLL_HANDLE_POST_void(SpectatorThink, (pEntity));
}
void Sys_Error_Post( const char *error_string ) {
	FAKEMETA_DLL_HANDLE_POST_void(Sys_Error, (error_string));
}

// from SDK pm_shared/pm_shared.h:
void PM_Move_Post( struct playermove_s *ppmove, int server ) {
	FAKEMETA_DLL_HANDLE_POST_void(PM_Move, (ppmove,server));
}
void PM_Init_Post( struct playermove_s *ppmove ) {
	FAKEMETA_DLL_HANDLE_POST_void(PM_Init, (ppmove));
}

char PM_FindTextureType_Post( char *name ) {
	FAKEMETA_DLL_HANDLE_POST(char, 0, PM_FindTextureType, (name));
}

// from SDK dlls/client.h:
void SetupVisibility_Post( edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas ) {
	FAKEMETA_DLL_HANDLE_POST_void(SetupVisibility, (pViewEntity,pClient,pvs,pas));
}
void UpdateClientData_Post( const struct edict_s *ent, int sendweapons, struct clientdata_s *cd ) {
	FAKEMETA_DLL_HANDLE_POST_void(UpdateClientData, (ent,sendweapons,cd));
}
int AddToFullPack_Post( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet ) {
	FAKEMETA_DLL_HANDLE_POST(int, 0, AddToFullPack, (state,e,ent,host,hostflags,player,pSet));
}
void CreateBaseline_Post( int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs ) {
	FAKEMETA_DLL_HANDLE_POST_void(CreateBaseline, (player,eindex,baseline,entity,playermodelindex,player_mins,player_maxs));
}
void RegisterEncoders_Post( void ) {
	FAKEMETA_DLL_HANDLE_POST_void(RegisterEncoders, ());
}
int GetWeaponData_Post( struct edict_s *player, struct weapon_data_s *info ) {
	FAKEMETA_DLL_HANDLE_POST(int, 0, GetWeaponData, (player,info));
}
void CmdStart_Post( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed ) {
	FAKEMETA_DLL_HANDLE_POST_void(CmdStart, (player,cmd,random_seed));
}
void CmdEnd_Post( const edict_t *player ) {
	FAKEMETA_DLL_HANDLE_POST_void(CmdEnd, (player));
}
int ConnectionlessPacket_Post( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size ) {
	FAKEMETA_DLL_HANDLE_POST(int, 0, ConnectionlessPacket, (net_from,args,response_buffer,response_buffer_size));
}
int GetHullBounds_Post( int hullnumber, float *mins, float *maxs ) {
	FAKEMETA_DLL_HANDLE_POST(int, 0, GetHullBounds, (hullnumber,mins,maxs));
}
void CreateInstancedBaselines_Post( void ) {
	FAKEMETA_DLL_HANDLE_POST_void(CreateInstancedBaselines, ());
}
int InconsistentFile_Post( const edict_t *player, const char *filename, char *disconnect_message ) {
	FAKEMETA_DLL_HANDLE_POST(int, 0, InconsistentFile, (player,filename,disconnect_message));
}
int AllowLagCompensation_Post( void ) {
	FAKEMETA_DLL_HANDLE(int, 0, AllowLagCompensation, ());
}

// *** newdllapi
void OnFreeEntPrivateData(edict_t *pEnt) {
	FAKEMETA_NEWDLL_HANDLE_void(OnFreeEntPrivateData, (pEnt));
}
void GameShutdown(void) {
	FAKEMETA_NEWDLL_HANDLE_void(GameShutdown, ());
}
int ShouldCollide(edict_t *pentTouched, edict_t *pentOther) {
	FAKEMETA_NEWDLL_HANDLE(int, 0, ShouldCollide, (pentTouched,pentOther));
}

// *** newdllapi post
void OnFreeEntPrivateData_Post(edict_t *pEnt) {
	FAKEMETA_NEWDLL_HANDLE_POST_void(OnFreeEntPrivateData, (pEnt));
}
void GameShutdown_Post(void) {
	FAKEMETA_NEWDLL_HANDLE_POST_void(GameShutdown, ());
}
int ShouldCollide_Post(edict_t *pentTouched, edict_t *pentOther)
{	FAKEMETA_NEWDLL_HANDLE_POST(int, 0, ShouldCollide, (pentTouched,pentOther));

}

// ***** Global function tables
DLL_FUNCTIONS g_DllFunctionTable = 
{
	GameDLLInit,
	DispatchSpawn,
	DispatchThink,
	DispatchUse,
	DispatchTouch,
	DispatchBlocked,
	DispatchKeyValue,
	DispatchSave,
	DispatchRestore,
	DispatchObjectCollsionBox,

	SaveWriteFields,
	SaveReadFields,

	SaveGlobalState,
	RestoreGlobalState,
	ResetGlobalState,

	ClientConnect,
	ClientDisconnect,
	ClientKill,
	ClientPutInServer,
	ClientCommand,
	ClientUserInfoChanged,
	ServerActivate,
	ServerDeactivate,

	PlayerPreThink,
	PlayerPostThink,

	StartFrame,
	ParmsNewLevel,
	ParmsChangeLevel,

	GetGameDescription,
	PlayerCustomization,

	SpectatorConnect,
	SpectatorDisconnect,
	SpectatorThink,
	
	Sys_Error,

	PM_Move,
	PM_Init,
	PM_FindTextureType,
	
	SetupVisibility,
	UpdateClientData,
	AddToFullPack,
	CreateBaseline,
	RegisterEncoders,
	GetWeaponData,
	CmdStart,
	CmdEnd,
	ConnectionlessPacket,
	GetHullBounds,
	CreateInstancedBaselines,
	InconsistentFile,
	AllowLagCompensation,
};

DLL_FUNCTIONS g_DllFunctionTable_Post = 
{
	GameDLLInit_Post,
	DispatchSpawn_Post,
	DispatchThink_Post,
	DispatchUse_Post,
	DispatchTouch_Post,
	DispatchBlocked_Post,
	DispatchKeyValue_Post,
	DispatchSave_Post,
	DispatchRestore_Post,
	DispatchObjectCollsionBox_Post,

	SaveWriteFields_Post,
	SaveReadFields_Post,

	SaveGlobalState_Post,
	RestoreGlobalState_Post,
	ResetGlobalState_Post,

	ClientConnect_Post,
	ClientDisconnect_Post,
	ClientKill_Post,
	ClientPutInServer_Post,
	ClientCommand_Post,
	ClientUserInfoChanged_Post,
	ServerActivate_Post,
	ServerDeactivate_Post,

	PlayerPreThink_Post,
	PlayerPostThink_Post,

	StartFrame_Post,
	ParmsNewLevel_Post,
	ParmsChangeLevel_Post,

	GetGameDescription_Post,
	PlayerCustomization_Post,

	SpectatorConnect_Post,
	SpectatorDisconnect_Post,
	SpectatorThink_Post,
	
	Sys_Error_Post,

	PM_Move_Post,
	PM_Init_Post,
	PM_FindTextureType_Post,
	
	SetupVisibility_Post,
	UpdateClientData_Post,
	AddToFullPack_Post,
	CreateBaseline_Post,
	RegisterEncoders_Post,
	GetWeaponData_Post,
	CmdStart_Post,
	CmdEnd_Post,
	ConnectionlessPacket_Post,
	GetHullBounds_Post,
	CreateInstancedBaselines_Post,
	InconsistentFile_Post,
	AllowLagCompensation_Post
};

NEW_DLL_FUNCTIONS g_NewDllFunctionTable = 
{
	OnFreeEntPrivateData,
	GameShutdown,
	ShouldCollide
};

NEW_DLL_FUNCTIONS g_NewDllFunctionTable_Post = 
{
	OnFreeEntPrivateData_Post,
	GameShutdown_Post,
	ShouldCollide_Post
};

enginefuncs_t g_EngineFunctionTable = 
{
	PrecacheModel,
	PrecacheSound,
	SetModel,
	ModelIndex,
	ModelFrames,

	SetSize,
	ChangeLevel,
	GetSpawnParms,
	SaveSpawnParms,

	VecToYaw,
	VecToAngles,
	MoveToOrigin,
	ChangeYaw,
	ChangePitch,

	FindEntityByString,
	GetEntityIllum,
	FindEntityInSphere,
	FindClientInPVS,
	EntitiesInPVS,

	MakeVectors,
	AngleVectors,

	CreateEntity,
	RemoveEntity,
	CreateNamedEntity,

	MakeStatic,
	EntIsOnFloor,
	DropToFloor,

	WalkMove,
	SetOrigin,

	EmitSound,
	EmitAmbientSound,

	TraceLine,
	TraceToss,
	TraceMonsterHull,
	TraceHull,
	TraceModel,
	TraceTexture,
	TraceSphere,
	GetAimVector,

	ServerCommand,
	ServerExecute,
	engClientCommand,

	ParticleEffect,
	LightStyle,
	DecalIndex,
	PointContents,

	MessageBegin,
	MessageEnd,

	WriteByte,
	WriteChar,
	WriteShort,
	WriteLong,
	WriteAngle,
	WriteCoord,
	WriteString,
	WriteEntity,

	CVarRegister,
	CVarGetFloat,
	CVarGetString,
	CVarSetFloat,
	CVarSetString,

	AlertMessage,
	EngineFprintf,

	PvAllocEntPrivateData,
	PvEntPrivateData,
	FreeEntPrivateData,

	SzFromIndex,
	AllocString,

	GetVarsOfEnt, 			
	PEntityOfEntOffset,
	EntOffsetOfPEntity,
	IndexOfEdict,
	PEntityOfEntIndex,
	FindEntityByVars,
	GetModelPtr,

	RegUserMsg,

	AnimationAutomove,
	GetBonePosition,

	FunctionFromName,
	NameForFunction,

	ClientPrintf,
	ServerPrint,

	Cmd_Args,
	Cmd_Argv,
	Cmd_Argc,

	GetAttachment,

	CRC32_Init,
	CRC32_ProcessBuffer,
	CRC32_ProcessByte,
	CRC32_Final,

	RandomLong,
	RandomFloat,

	SetView,
	Time,
	CrosshairAngle,

	LoadFileForMe,
	FreeFile,

	EndSection,
	CompareFileTime,
	GetGameDir,
	Cvar_RegisterVariable,
	FadeClientVolume,
	SetClientMaxspeed,
	CreateFakeClient,
	RunPlayerMove,
	NumberOfEntities,

	GetInfoKeyBuffer,
	InfoKeyValue,
	SetKeyValue,
	SetClientKeyValue,

	IsMapValid,
	StaticDecal,
	PrecacheGeneric,
	GetPlayerUserId, 		
	BuildSoundMsg,
	IsDedicatedServer,
	CVarGetPointer,
	GetPlayerWONId,

	
	Info_RemoveKey,
	GetPhysicsKeyValue,
	SetPhysicsKeyValue,
	GetPhysicsInfoString,
	PrecacheEvent,
	PlaybackEvent,

	SetFatPVS,
	SetFatPAS,

	CheckVisibility,

	DeltaSetField,
	DeltaUnsetField,
	DeltaAddEncoder,
	GetCurrentPlayer,
	CanSkipPlayer,
	DeltaFindField,
	DeltaSetFieldByIndex,
	DeltaUnsetFieldByIndex,

	SetGroupMask,

	engCreateInstancedBaseline, 
	Cvar_DirectSet,

	ForceUnmodified,

	GetPlayerStats,

	AddServerCommand,

	
	Voice_GetClientListening,
	Voice_SetClientListening,

	
	GetPlayerAuthId,
};

enginefuncs_t g_EngineFunctionTable_Post = 
{
	PrecacheModel_Post,
	PrecacheSound_Post,
	SetModel_Post,
	ModelIndex_Post,
	ModelFrames_Post,

	SetSize_Post,
	ChangeLevel_Post,
	GetSpawnParms_Post,
	SaveSpawnParms_Post,

	VecToYaw_Post,
	VecToAngles_Post,
	MoveToOrigin_Post,
	ChangeYaw_Post,
	ChangePitch_Post,

	FindEntityByString_Post,
	GetEntityIllum_Post,
	FindEntityInSphere_Post,
	FindClientInPVS_Post,
	EntitiesInPVS_Post,

	MakeVectors_Post,
	AngleVectors_Post,

	CreateEntity_Post,
	RemoveEntity_Post,
	CreateNamedEntity_Post,

	MakeStatic_Post,
	EntIsOnFloor_Post,
	DropToFloor_Post,

	WalkMove_Post,
	SetOrigin_Post,

	EmitSound_Post,
	EmitAmbientSound_Post,

	TraceLine_Post,
	TraceToss_Post,
	TraceMonsterHull_Post,
	TraceHull_Post,
	TraceModel_Post,
	TraceTexture_Post,
	TraceSphere_Post,
	GetAimVector_Post,

	ServerCommand_Post,
	ServerExecute_Post,
	engClientCommand_Post,

	ParticleEffect_Post,
	LightStyle_Post,
	DecalIndex_Post,
	PointContents_Post,

	MessageBegin_Post,
	MessageEnd_Post,

	WriteByte_Post,
	WriteChar_Post,
	WriteShort_Post,
	WriteLong_Post,
	WriteAngle_Post,
	WriteCoord_Post,
	WriteString_Post,
	WriteEntity_Post,

	CVarRegister_Post,
	CVarGetFloat_Post,
	CVarGetString_Post,
	CVarSetFloat_Post,
	CVarSetString_Post,

	AlertMessage_Post,
	EngineFprintf_Post,

	PvAllocEntPrivateData_Post,
	PvEntPrivateData_Post,
	FreeEntPrivateData_Post,

	SzFromIndex_Post,
	AllocString_Post,

	GetVarsOfEnt_Post, 			
	PEntityOfEntOffset_Post,
	EntOffsetOfPEntity_Post,
	IndexOfEdict_Post,
	PEntityOfEntIndex_Post,
	FindEntityByVars_Post,
	GetModelPtr_Post,

	RegUserMsg_Post,

	AnimationAutomove_Post,
	GetBonePosition_Post,

	FunctionFromName_Post,
	NameForFunction_Post,

	ClientPrintf_Post,
	ServerPrint_Post,

	Cmd_Args_Post,
	Cmd_Argv_Post,
	Cmd_Argc_Post,

	GetAttachment_Post,

	CRC32_Init_Post,
	CRC32_ProcessBuffer_Post,
	CRC32_ProcessByte_Post,
	CRC32_Final_Post,

	RandomLong_Post,
	RandomFloat_Post,

	SetView_Post,
	Time_Post,
	CrosshairAngle_Post,

	LoadFileForMe_Post,
	FreeFile_Post,

	EndSection_Post,
	CompareFileTime_Post,
	GetGameDir_Post,
	Cvar_RegisterVariable_Post,
	FadeClientVolume_Post,
	SetClientMaxspeed_Post,
	CreateFakeClient_Post,
	RunPlayerMove_Post,
	NumberOfEntities_Post,

	GetInfoKeyBuffer_Post,
	InfoKeyValue_Post,
	SetKeyValue_Post,
	SetClientKeyValue_Post,

	IsMapValid_Post,
	StaticDecal_Post,
	PrecacheGeneric_Post,
	GetPlayerUserId_Post, 		
	BuildSoundMsg_Post,
	IsDedicatedServer_Post,
	CVarGetPointer_Post,
	GetPlayerWONId_Post,

	
	Info_RemoveKey_Post,
	GetPhysicsKeyValue_Post,
	SetPhysicsKeyValue_Post,
	GetPhysicsInfoString_Post,
	PrecacheEvent_Post,
	PlaybackEvent_Post,

	SetFatPVS_Post,
	SetFatPAS_Post,

	CheckVisibility_Post,

	DeltaSetField_Post,
	DeltaUnsetField_Post,
	DeltaAddEncoder_Post,
	GetCurrentPlayer_Post,
	CanSkipPlayer_Post,
	DeltaFindField_Post,
	DeltaSetFieldByIndex_Post,
	DeltaUnsetFieldByIndex_Post,

	SetGroupMask_Post,

	engCreateInstancedBaseline_Post, 
	Cvar_DirectSet_Post,

	ForceUnmodified_Post,

	GetPlayerStats_Post,

	AddServerCommand_Post,

	
	Voice_GetClientListening_Post,
	Voice_SetClientListening_Post,

	
	GetPlayerAuthId_Post,
};

// ***** CFakeMetaPlugin
CFakeMeta::CFakeMetaPlugin::CFakeMetaPlugin(const char *path)
{
	m_Path.assign(path);
	m_Status = PL_EMPTY;
	m_Info = NULL;
	memset((void *)&m_DllFuncTable, 0, sizeof(DLL_FUNCTIONS));
	memset((void *)&m_EngineFuncTable, 0, sizeof(enginefuncs_t));
	memset((void *)&m_NewDllFuncTable, 0, sizeof(NEW_DLL_FUNCTIONS));
	memset((void *)&m_DllFuncTable_Post, 0, sizeof(DLL_FUNCTIONS));
	memset((void *)&m_EngineFuncTable_Post, 0, sizeof(enginefuncs_t));
	memset((void *)&m_NewDllFuncTable_Post, 0, sizeof(NEW_DLL_FUNCTIONS));
	memset((void *)&m_MetaFuncTable, 0, sizeof(META_FUNCTIONS));
	m_Handle = NULL;
}

CFakeMeta::CFakeMetaPlugin::~CFakeMetaPlugin()
{
	if (m_Handle)
	{
		DLCLOSE(m_Handle);
		m_Handle = NULL;
	}
}

// ghost_of_evilspy's "could not find memloc for cvar" fix
void FakeMeta_New_CVarRegister(cvar_t *pCVar)
{
	static cvar_t tmpvar;
	tmpvar = *pCVar;
	CVAR_REGISTER(&tmpvar);
}

int CFakeMeta::CFakeMetaPlugin::Query(mutil_funcs_t *pMetaUtilFuncs)
{
	//using metamod p-extensions?
	if(gpMetaPExtFuncs || g_IsNewMM)
	{
		//load plugins in meta_attach
		m_Status = PL_OPENED;
		return 1;
	}
	
	// Load the library
	// We don't have to DLCLOSE here.
	m_Handle = DLOPEN(build_pathname("%s", m_Path.c_str()));
	if (!m_Handle)
	{
		m_Status = PL_BADFILE;
		return 0;
	}


	META_QUERY_FN queryFn = (META_QUERY_FN)DLSYM(m_Handle, "Meta_Query");
	GIVE_ENGINE_FUNCTIONS_FN giveEngFuncsFn = (GIVE_ENGINE_FUNCTIONS_FN)DLSYM(m_Handle, "GiveFnptrsToDll");

	// So we can print all problems before quitting the function
	bool missingFunc = false;
	if (!queryFn)
	{
		AMXXLOG_Log("[AMXX] Module \"%s\" doesn't provide a Query function.", m_Path.c_str());
		missingFunc = true;
	}

	if (!giveEngFuncsFn)
	{
		AMXXLOG_Log("[AMXX] Module \"%s\" doesn't provide a GiveFnptrsToDll function.", m_Path.c_str());
		missingFunc = true;
	}

	// Also check for Attach and Detach
	if (DLSYM(m_Handle, "Meta_Attach") == NULL)
	{
		AMXXLOG_Log("[AMXX] Module \"%s\" doesn't provide a Meta_Attach function.", m_Path.c_str());
		missingFunc = true;
	}
	if (DLSYM(m_Handle, "Meta_Detach") == NULL)
	{
		AMXXLOG_Log("[AMXX] Module \"%s\" doesn't provide a Meta_Detach function.", m_Path.c_str());
		missingFunc = true;
	}

	if (missingFunc)
	{
		m_Status = PL_BADFILE;
		return 0;
	}
	
	// ghost_of_evilspy's "Could not find memloc for cvar" fix
	static enginefuncs_t fakemeta_engfuncs;
	memcpy(&fakemeta_engfuncs, &g_engfuncs, sizeof(enginefuncs_t));
	// Override cvar register to our own function
	fakemeta_engfuncs.pfnCVarRegister = FakeMeta_New_CVarRegister;
	giveEngFuncsFn(&fakemeta_engfuncs, gpGlobals);

	if (queryFn(META_INTERFACE_VERSION, &m_Info, pMetaUtilFuncs) != 1)
	{
		AMXXLOG_Log("[AMXX] Query Module \"%s\" failed.", m_Path.c_str());
		m_Status = PL_BADFILE;
		return 0;
	}

	m_Status = PL_OPENED;
	return 1;
}

int CFakeMeta::CFakeMetaPlugin::Attach(PLUG_LOADTIME now, meta_globals_t *pMGlobals, gamedll_funcs_t *pGameDllFuncs)
{
	// evilspy's patch:
	//using metamod p-extensions?
	if (gpMetaPExtFuncs)
	{
		if(PEXT_LOAD_PLUGIN_BY_NAME(PLID, m_Path.c_str(), now, (void**)&m_Handle) || !m_Handle)
		{
			LOG_MESSAGE(PLID, "Can't Attach Module \"%s\".", m_Path.c_str());
			m_Status = PL_FAILED;
			return 0;
		}
		
		m_Status = PL_RUNNING;
		return 1;
	} else if (g_IsNewMM) {
		int err = 0;
		if ( (err = LOAD_PLUGIN(PLID, m_Path.c_str(), now, (void **)&m_Handle)) || !m_Handle)
		{
			LOG_MESSAGE(PLID, "Can't Attach Module \"%s\".", m_Path.c_str());
			m_Status = PL_FAILED;
			return 0;
		}

		m_Status = PL_RUNNING;
		return 1;
	}
	
	if (!m_Handle)
		return 0;

	META_ATTACH_FN attachFn = (META_ATTACH_FN)DLSYM(m_Handle, "Meta_Attach");
	if (!attachFn)
	{
		// Should not be possible tho
		m_Status = PL_BADFILE;
		return 0;
	}
	if (attachFn(now, &m_MetaFuncTable, pMGlobals, pGameDllFuncs) != 1)
	{
		LOG_MESSAGE(PLID, "Can't Attach Module \"%s\".", m_Path.c_str());
		m_Status = PL_FAILED;
		return 0;
	}

	m_Status = PL_RUNNING;
	return 1;
}

int CFakeMeta::CFakeMetaPlugin::Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason)
{
	if (!m_Handle)
		return 0;

	// evilspy's patch:
	//using metamod p-extensions?
	if (gpMetaPExtFuncs)
	{
		if(PEXT_UNLOAD_PLUGIN_BY_HANDLE(PLID, (void*)m_Handle, now, reason)) {
			m_Status = PL_FAILED;
			return 0;
		}
		m_Status = PL_OPENED;
		m_Handle = NULL;
		return 1;
	} else if (g_IsNewMM) {
		if (UNLOAD_PLUGIN_BY_HANDLE(PLID, (void *)m_Handle, now, reason))
		{
			m_Status = PL_FAILED;
			return 0;
		}
		m_Status = PL_OPENED;
		m_Handle = NULL;
		return 1;
	}
	
	META_DETACH_FN detachFn = (META_DETACH_FN)DLSYM(m_Handle, "Meta_Detach");
	if (!detachFn)
	{
		// Should not be possible tho
		m_Status = PL_BADFILE;
		return 0;
	}
	if (detachFn(now, reason) != 1)
	{
		AMXXLOG_Log("[AMXX] Can't Detach Module \"%s\" (\"%s\").", m_Info->name, m_Path.c_str());
		m_Status = PL_FAILED;
		return 0;
	}

	m_Status = PL_OPENED;
	return 1;
}

#define FAKEMETA_GET_FUNCTABLE(getFunc, interfaceVersion, table) \
	if (!m_Handle) \
		return 0; \
	int ifVers = interfaceVersion; \
	if (m_MetaFuncTable.pfn##getFunc) \
	{ \
		if (!m_MetaFuncTable.pfn##getFunc(&table, &ifVers)) \
		{ \
			AMXXLOG_Log("[AMXX] Failed calling \"%s\" in module \"%s\" (\"%s\")", #getFunc, m_Info->name, m_Path.c_str()); \
			return 0; \
		} \
	} \
	return 1;

int CFakeMeta::CFakeMetaPlugin::GetEntityAPI2(int interfaceVersion)
{
	FAKEMETA_GET_FUNCTABLE(GetEntityAPI2, interfaceVersion, m_DllFuncTable);
}

int CFakeMeta::CFakeMetaPlugin::GetEntityAPI2_Post(int interfaceVersion)
{
	FAKEMETA_GET_FUNCTABLE(GetEntityAPI2_Post, interfaceVersion, m_DllFuncTable_Post);
}

int CFakeMeta::CFakeMetaPlugin::GetEngineFunctions(int interfaceVersion)
{
	FAKEMETA_GET_FUNCTABLE(GetEngineFunctions, interfaceVersion, m_EngineFuncTable);
}

int CFakeMeta::CFakeMetaPlugin::GetEngineFunctions_Post(int interfaceVersion)
{
	FAKEMETA_GET_FUNCTABLE(GetEngineFunctions_Post, interfaceVersion, m_EngineFuncTable_Post);
}

int CFakeMeta::CFakeMetaPlugin::GetNewDLLFunctions(int interfaceVersion)
{
	FAKEMETA_GET_FUNCTABLE(GetNewDLLFunctions, interfaceVersion, m_NewDllFuncTable);
}

int CFakeMeta::CFakeMetaPlugin::GetNewDLLFunctions_Post(int interfaceVersion)
{
	FAKEMETA_GET_FUNCTABLE(GetNewDLLFunctions_Post, interfaceVersion, m_NewDllFuncTable_Post);
}

// ***** CFakeMeta

CFakeMeta::CFakeMeta()
{
	// We don't call AddCorePlugin here because CList adds the elements to the front...
}

CFakeMeta::~CFakeMeta()
{
	ReleasePlugins();
}

bool CFakeMeta::AddPlugin(const char *path)
{
	CFakeMetaPlugin *pPlugin = new CFakeMetaPlugin(path);
	if (!pPlugin)
		return true;
	m_Plugins.put(pPlugin);
	return false;
}

void CFakeMeta::ReleasePlugins()
{
	m_Plugins.clear();
}

bool CFakeMeta::AddCorePlugin()
{
	// evilspy:
	// not needed when using metamod p-extensions
	if(gpMetaPExtFuncs || g_IsNewMM)
		return true;

	// Check whether there already is a core plugin
	if (m_Plugins.begin() && strcmp((*m_Plugins.begin()).GetPath(), "[AMXX Core]") == 0)
		return true;

	// make a fake plugin for the core
	CFakeMetaPlugin *pPlugin = new CFakeMetaPlugin("[AMXX Core]");
	if (!pPlugin)
		return false;
	m_Plugins.put_front(pPlugin);
	// Set its status to running so functions are called in it
	pPlugin->SetStatus(PL_RUNNING);
	return true;
}

// Query all added plugins
void CFakeMeta::Meta_Query(mutil_funcs_t *pMetaUtilFuncs)
{
	AddCorePlugin();

	// Query all plugins except core
	CList<CFakeMetaPlugin>::iterator iter = m_Plugins.begin();

	// evilspy:
	//  using metamod p-extensions?
	if(!gpMetaPExtFuncs && !g_IsNewMM)
		++iter;         // Skip core

	for (; iter; ++iter)
	{
		(*iter).Query(pMetaUtilFuncs);
	}
}

// Attach all added plugins
void CFakeMeta::Meta_Attach(PLUG_LOADTIME now, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs)
{
	AddCorePlugin();

	// Attach all plugins except core
	CList<CFakeMetaPlugin>::iterator iter = m_Plugins.begin();
	// evilspy:
	//  using metamod p-extensions?
	if(!gpMetaPExtFuncs && !g_IsNewMM)
		++iter;         // Skip core

	for (; iter; ++iter)
	{
		(*iter).Attach(now, pMGlobals, pGamedllFuncs);
	}
}

// Detach all added plugins
void CFakeMeta::Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason)
{
	// Detach all plugins except core
	CList<CFakeMetaPlugin>::iterator iter = m_Plugins.begin();
	// evilspy:
	//  using metamod p-extensions?
	if(!gpMetaPExtFuncs && !g_IsNewMM)
		++iter;         // Skip core

	for (; iter; ++iter)
	{
		(*iter).Detach(now, reason);
	}
}

int CFakeMeta::GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable /*from metamod*/, int *interfaceVersion /*from metamod*/,
	DLL_FUNCTIONS *pAMXXFunctionTable /*Functions amxx needs*/)
{
 	if(*interfaceVersion!=INTERFACE_VERSION)
	{
		LOG_ERROR(PLID,	"GetEntityAPI2 version mismatch; requested=%d ours=%d",	*interfaceVersion, INTERFACE_VERSION);
		*interfaceVersion =	INTERFACE_VERSION;
		return(FALSE);
	}

	// evilspy:
	//using metamod p-extensions?
	if(gpMetaPExtFuncs || g_IsNewMM)
	{
		memcpy( pFunctionTable, pAMXXFunctionTable, sizeof( DLL_FUNCTIONS ) );
		return TRUE;
	}
	
	memcpy( pFunctionTable, &g_DllFunctionTable, sizeof( DLL_FUNCTIONS ) );

	// Make sure there is a core plugin
	AddCorePlugin();

	// Copy Core Function table
	CList<CFakeMetaPlugin>::iterator iter = m_Plugins.begin();
	memcpy(&((*iter).GetDllFuncTable()), pAMXXFunctionTable, sizeof(DLL_FUNCTIONS));

	// Call in all attached plugins except core
	++iter;			// Skip core
	for (; iter; ++iter)
	{
		if ((*iter).GetStatus() == PL_RUNNING)
			(*iter).GetEntityAPI2(*interfaceVersion);
	}

	return TRUE;
}

int CFakeMeta::GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable /*from metamod*/, int *interfaceVersion /*from metamod*/,
	DLL_FUNCTIONS *pAMXXFunctionTable /*Functions amxx needs*/)
{
	if(*interfaceVersion!=INTERFACE_VERSION)
	{
		LOG_ERROR(PLID,	"GetEntityAPI2_Post version mismatch; requested=%d ours=%d",	*interfaceVersion, INTERFACE_VERSION);
		*interfaceVersion =	INTERFACE_VERSION;
		return(FALSE);
	}
	
	// evilspy
	//using metamod p-extensions?
	if(gpMetaPExtFuncs || g_IsNewMM)
	{
		memcpy( pFunctionTable, pAMXXFunctionTable, sizeof( DLL_FUNCTIONS ) );
		return TRUE;
	}
	
	memcpy( pFunctionTable, &g_DllFunctionTable_Post, sizeof( DLL_FUNCTIONS ) );

	// Make sure there is a core plugin
	AddCorePlugin();

	// Copy Core Function table
	CList<CFakeMetaPlugin>::iterator iter = m_Plugins.begin();
	memcpy(&((*iter).GetDllFuncTable_Post()), pAMXXFunctionTable, sizeof(DLL_FUNCTIONS));

	// Call in all attached plugins excpet core
	++iter;			// Skip core
	for (; iter; ++iter)
	{
		if ((*iter).GetStatus() == PL_RUNNING)
			(*iter).GetEntityAPI2_Post(*interfaceVersion);
	}

	return TRUE;
}

int CFakeMeta::GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion,
	enginefuncs_t *pAMXXFunctionTable /*Fucntions amxx needs*/)
{
	if(*interfaceVersion!=ENGINE_INTERFACE_VERSION)
	{
		LOG_ERROR(PLID,	"GetEngineFunctions version mismatch; requested=%d ours=%d",	*interfaceVersion, INTERFACE_VERSION);
		*interfaceVersion =	ENGINE_INTERFACE_VERSION;
		return FALSE;
	}
	
	// evilspy:
	//using metamod p-extensions?
	if(gpMetaPExtFuncs || g_IsNewMM)
	{
		memcpy( pengfuncsFromEngine, pAMXXFunctionTable, sizeof( enginefuncs_t ) );
		return TRUE;
	}
	
	memcpy( pengfuncsFromEngine, &g_EngineFunctionTable, sizeof( enginefuncs_t ) );

	// Make sure there is a core plugin
	AddCorePlugin();

	// Copy Core Function table
	CList<CFakeMetaPlugin>::iterator iter = m_Plugins.begin();
	memcpy(&((*iter).GetEngineFuncTable()), pAMXXFunctionTable, sizeof(enginefuncs_t));

	// Call in all attached plugins
	++iter;			// Skip core
	for (; iter; ++iter)
	{
		if ((*iter).GetStatus() == PL_RUNNING)
			(*iter).GetEngineFunctions(*interfaceVersion);
	}
	return TRUE;
}

int CFakeMeta::GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion,
	enginefuncs_t *pAMXXFunctionTable /*Fucntions amxx needs*/)
{
	if(*interfaceVersion!=ENGINE_INTERFACE_VERSION)
	{
		LOG_ERROR(PLID,	"GetEngineFunctions_Post version mismatch; requested=%d ours=%d",	*interfaceVersion, INTERFACE_VERSION);
		*interfaceVersion =	ENGINE_INTERFACE_VERSION;
		return FALSE;
	}
	
	// evilspy:
	//using metamod p-extensions?
	if(gpMetaPExtFuncs || g_IsNewMM)
	{
		memcpy( pengfuncsFromEngine, pAMXXFunctionTable, sizeof( enginefuncs_t ) );
		return TRUE;
	}
	
	memcpy( pengfuncsFromEngine, &g_EngineFunctionTable_Post, sizeof( enginefuncs_t ) );

	// Make sure there is a core plugin
	AddCorePlugin();

	// Copy Core Function table
	CList<CFakeMetaPlugin>::iterator iter = m_Plugins.begin();
	memcpy(&((*iter).GetEngineFuncTable_Post()), pAMXXFunctionTable, sizeof(enginefuncs_t));

	// Call in all attached plugins
	++iter;			// skip core
	for (; iter; ++iter)
	{
		if ((*iter).GetStatus() == PL_RUNNING)
			(*iter).GetEngineFunctions_Post(*interfaceVersion);
	}

	return TRUE;
}

int CFakeMeta::GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion,
	NEW_DLL_FUNCTIONS *pAMXXFunctionTable)
{
	if(!pNewFunctionTable)
	{
		LOG_ERROR(PLID, "GetNewDLLFunctions called with null pNewFunctionTable");
		return(FALSE);
	}

	if(*interfaceVersion!=NEW_DLL_FUNCTIONS_VERSION)
	{
		LOG_ERROR(PLID,	"GetNewDllFunctions version mismatch; requested=%d ours=%d",	*interfaceVersion, INTERFACE_VERSION);
		*interfaceVersion =	NEW_DLL_FUNCTIONS_VERSION;
		return(FALSE);
	}
	
	// evilspy:
	//using metamod p-extensions?
	if(gpMetaPExtFuncs || g_IsNewMM)
	{
		memcpy( pNewFunctionTable, pAMXXFunctionTable, sizeof( NEW_DLL_FUNCTIONS ) );
		return TRUE;
	}
	
	memcpy( pNewFunctionTable, &g_NewDllFunctionTable, sizeof( NEW_DLL_FUNCTIONS ) );

	// Make sure there is a core plugin
	AddCorePlugin();

	// Copy Core Function table
	CList<CFakeMetaPlugin>::iterator iter = m_Plugins.begin();
	memcpy(&((*iter).GetNewDllFuncTable()), pAMXXFunctionTable, sizeof(NEW_DLL_FUNCTIONS));

	// Call in all attached plugins
	++iter;			// Skip core
	for (; iter; ++iter)
	{
		if ((*iter).GetStatus() == PL_RUNNING)
			(*iter).GetNewDLLFunctions(*interfaceVersion);
	}

	return TRUE;
}

int CFakeMeta::GetNewDLLFunctions_Post(NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion,
	NEW_DLL_FUNCTIONS *pAMXXFunctionTable)
{
	if(!pNewFunctionTable)
	{
		LOG_ERROR(PLID, "GetNewDLLFunctions_Post called with null pNewFunctionTable");
		return(FALSE);
	}

	if(*interfaceVersion!=NEW_DLL_FUNCTIONS_VERSION)
	{
		LOG_ERROR(PLID,	"GetNewDllFunctions_Post version mismatch; requested=%d ours=%d",	*interfaceVersion, INTERFACE_VERSION);
		*interfaceVersion =	NEW_DLL_FUNCTIONS_VERSION;
		return(FALSE);
	}
	
	// evilspy:
	//using metamod p-extensions?
	if(gpMetaPExtFuncs || g_IsNewMM)
	{
		memcpy( pNewFunctionTable, pAMXXFunctionTable, sizeof( NEW_DLL_FUNCTIONS ) );
		return TRUE;
	}
	
	memcpy( pNewFunctionTable, &g_NewDllFunctionTable_Post, sizeof( NEW_DLL_FUNCTIONS ) );

	// Make sure there is a core plugin
	AddCorePlugin();

	// Copy Core Function table
	CList<CFakeMetaPlugin>::iterator iter = m_Plugins.begin();
	memcpy(&((*iter).GetNewDllFuncTable_Post()), pAMXXFunctionTable, sizeof(NEW_DLL_FUNCTIONS));

	// Call in all attached plugins
	++iter;			// Skip core
	for (; iter; ++iter)
	{
		if ((*iter).GetStatus() == PL_RUNNING)
			(*iter).GetNewDLLFunctions_Post(*interfaceVersion);
	}

	return TRUE;
}

#endif //FAKEMETA
