diff -ur hpb_bot/dlls/bot.cpp mm_hpb_bot/dlls/bot.cpp
--- hpb_bot/dlls/bot.cpp	Sat Dec 16 11:48:26 2000
+++ mm_hpb_bot/dlls/bot.cpp	Sat Mar 31 01:10:17 2001
@@ -10,6 +10,11 @@
 #include "util.h"
 #include "cbase.h"
 
+#ifdef USE_METAMOD
+#define SDK_UTIL_H	// util.h already included
+#include "meta_api.h"
+#endif /* USE_METAMOD */
+
 #include "bot.h"
 #include "bot_func.h"
 #include "waypoint.h"
@@ -619,10 +624,15 @@
          SET_CLIENT_KEY_VALUE( clientIndex, infobuffer, "ah", "1");
       }
 
+#ifdef USE_METAMOD
+      MDLL_ClientConnect( BotEnt, c_name, "127.0.0.1", ptr );
+      MDLL_ClientPutInServer( BotEnt );
+#else /* not USE_METAMOD */
       ClientConnect( BotEnt, c_name, "127.0.0.1", ptr );
 
       // Pieter van Dijk - use instead of DispatchSpawn() - Hip Hip Hurray!
       ClientPutInServer( BotEnt );
+#endif /* USE_METAMOD */
 
       BotEnt->v.flags |= FL_FAKECLIENT;
 
diff -ur hpb_bot/dlls/dll.cpp mm_hpb_bot/dlls/dll.cpp
--- hpb_bot/dlls/dll.cpp	Wed Feb 21 08:18:50 2001
+++ mm_hpb_bot/dlls/dll.cpp	Sun Apr  1 19:12:19 2001
@@ -12,6 +12,11 @@
 #include "cbase.h"
 #include "entity_state.h"
 
+#ifdef USE_METAMOD
+#define SDK_UTIL_H	// util.h already included
+#include "meta_api.h"
+#endif /* USE_METAMOD */
+
 #include "bot.h"
 #include "bot_func.h"
 #include "waypoint.h"
@@ -22,8 +27,10 @@
 #define MENU_2     2
 #define MENU_3     3
 
+#ifndef USE_METAMOD
 extern GETENTITYAPI other_GetEntityAPI;
 extern GETNEWDLLFUNCTIONS other_GetNewDLLFunctions;
+#endif /* not USE_METAMOD */
 extern enginefuncs_t g_engfuncs;
 extern int debug_engine;
 extern globalvars_t  *gpGlobals;
@@ -37,11 +44,86 @@
 extern bot_t bots[32];
 extern bool b_observer_mode;
 extern bool b_botdontshoot;
+
+#ifdef USE_METAMOD
+
+// Must provide at least one of these..
+static META_FUNCTIONS gMetaFunctionTable = {
+	GetEntityAPI,		// pfnGetEntityAPI		HL SDK; called before game DLL
+	NULL,			// pfnGetEntityAPI_Post		META; called after game DLL
+	NULL,			// pfnGetEntityAPI2		HL SDK2; called before game DLL
+	NULL,			// pfnGetEntityAPI2_Post	META; called after game DLL
+	NULL,			// pfnGetNewDLLFunctions	HL SDK2; called before game DLL
+	NULL,			// pfnGetNewDLLFunctions_Post	META; called after game DLL
+	GetEngineFunctions,	// pfnGetEngineFunctions	META; called before HL engine
+	GetEngineFunctions_Post, // pfnGetEngineFunctions_Post	META; called after HL engine
+};
+
+// Description of plugin
+plugin_info_t Plugin_info = {
+	META_INTERFACE_VERSION,	// ifvers
+	"HPB bot",	// name
+	"1.2 #3",	// version
+	"2001/04/01",	// date
+	"botman <botman@mailandnews.com>",	// author
+	"http://planethalflife.com/botman/",	// url
+	"HPB_bot",	// logtag
+	PT_STARTUP,	// (when) loadable
+	PT_ANYPAUSE,	// (when) unloadable
+};
+
+// Global vars from metamod
+meta_globals_t *gpMetaGlobals;
+gamedll_funcs_t *gpGamedllFuncs;
+
+// Metamod requesting info about this plugin
+//  ifvers			(given) interface_version metamod is using
+//  pPlugInfo		(requested) struct with info about plugin
+int Meta_Query(char *ifvers, plugin_info_t **pPlugInfo) {
+	if(ifvers);	// to satisfy gcc -Wunused
+	// Give metamod our plugin_info struct
+	*pPlugInfo=&Plugin_info;
+	return(TRUE);
+}
+
+// Metamod attaching plugin to the server.
+//  now				(given) current phase, ie during map, during changelevel, or at startup
+//  pFunctionTable	(requested) table of function tables this plugin catches
+//  pMGlobals		(given) global vars from metamod
+//  pGamedllFuncs	(given) copy of function tables from game dll
+int Meta_Attach(PLUG_LOADTIME now, META_FUNCTIONS *pFunctionTable, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs) {
+	if(now);	// to satisfy gcc -Wunused
+	if(!pMGlobals) {
+		UTIL_LogPrintf("%s: Meta_Attach called with null pMGlobals\n", Plugin_info.logtag);
+		return(FALSE);
+	}
+	else if(!pFunctionTable) {
+		UTIL_LogPrintf("%s: Meta_Attach called with null pFunctionTable\n", Plugin_info.logtag);
+		return(FALSE);
+	}
+	gpMetaGlobals=pMGlobals;
+	gpGamedllFuncs=pGamedllFuncs;
+	memcpy(pFunctionTable, &gMetaFunctionTable, sizeof(META_FUNCTIONS));
+	return(TRUE);
+}
+
+// Metamod detaching plugin from the server.
+// now		(given) current phase, ie during map, etc
+// reason	(given) why detaching (refresh, console unload, forced unload, etc)
+int Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason) {
+	if(now && reason);	// to satisfy gcc -Wunused
+	return(TRUE);
+}
+#endif /* USE_METAMOD */
+
+
 char welcome_msg[] = "HPB bot - http://planethalflife.com/botman";
 
 static FILE *fp;
 
+#ifndef USE_METAMOD
 DLL_FUNCTIONS other_gFunctionTable;
+#endif /* not USE_METAMOD */
 DLL_GLOBAL const Vector g_vecZero = Vector(0,0,0);
 
 int mod_id = 0;
@@ -106,7 +188,9 @@
 
 
 void BotNameInit(void);
+#ifndef USE_METAMOD
 void UpdateClientData(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd);
+#endif /* USE_METAMOD */
 void ProcessBotCfgFile(void);
 
 
@@ -166,7 +250,11 @@
       fclose(bfp);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*other_gFunctionTable.pfnGameInit)();
+#endif /* USE_METAMOD */
 }
 
 int DispatchSpawn( edict_t *pent )
@@ -238,9 +326,14 @@
       }
    }
 
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*other_gFunctionTable.pfnSpawn)(pent);
+#endif /* USE_METAMOD */
 }
 
+#ifndef USE_METAMOD
 void DispatchThink( edict_t *pent )
 {
    (*other_gFunctionTable.pfnThink)(pent);
@@ -260,6 +353,7 @@
 {
    (*other_gFunctionTable.pfnBlocked)(pentBlocked, pentOther);
 }
+#endif /* not USE_METAMOD */
 
 void DispatchKeyValue( edict_t *pentKeyvalue, KeyValueData *pkvd )
 {
@@ -373,9 +467,14 @@
       }
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*other_gFunctionTable.pfnKeyValue)(pentKeyvalue, pkvd);
+#endif /* USE_METAMOD */
 }
 
+#ifndef USE_METAMOD
 void DispatchSave( edict_t *pent, SAVERESTOREDATA *pSaveData )
 {
    (*other_gFunctionTable.pfnSave)(pent, pSaveData);
@@ -415,6 +514,7 @@
 {
    (*other_gFunctionTable.pfnResetGlobalState)();
 }
+#endif /* not USE_METAMOD */
 
 BOOL ClientConnect( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]  )
 { 
@@ -465,7 +565,11 @@
       }
    }
 
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, TRUE);
+#else /* not USE_METAMOD */
    return (*other_gFunctionTable.pfnClientConnect)(pEntity, pszName, pszAddress, szRejectReason);
+#endif /* USE_METAMOD */
 }
 
 void ClientDisconnect( edict_t *pEntity )
@@ -499,13 +603,21 @@
       }
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*other_gFunctionTable.pfnClientDisconnect)(pEntity);
+#endif /* USE_METAMOD */
 }
 
 void ClientKill( edict_t *pEntity )
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp, "ClientKill: %x\n",pEntity); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*other_gFunctionTable.pfnClientKill)(pEntity);
+#endif /* USE_METAMOD */
 }
 
 void ClientPutInServer( edict_t *pEntity )
@@ -520,7 +632,11 @@
    if (i < 32)
       clients[i] = pEntity;  // store this clients edict in the clients array
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*other_gFunctionTable.pfnClientPutInServer)(pEntity);
+#endif /* USE_METAMOD */
 }
 
 void ClientCommand( edict_t *pEntity )
@@ -531,11 +647,11 @@
    if ((gpGlobals->deathmatch) && (!IS_DEDICATED_SERVER()) &&
        (pEntity == listenserver_edict))
    {
-      const char *pcmd = Cmd_Argv(0);
-      const char *arg1 = Cmd_Argv(1);
-      const char *arg2 = Cmd_Argv(2);
-      const char *arg3 = Cmd_Argv(3);
-      const char *arg4 = Cmd_Argv(4);
+      const char *pcmd = CMD_ARGV(0);
+      const char *arg1 = CMD_ARGV(1);
+      const char *arg2 = CMD_ARGV(2);
+      const char *arg3 = CMD_ARGV(3);
+      const char *arg4 = CMD_ARGV(4);
       char msg[80];
 
       if (debug_engine)
@@ -559,7 +675,11 @@
 
          bot_check_time = gpGlobals->time + 5.0;
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
       else if (FStrEq(pcmd, "observer"))
       {
@@ -577,7 +697,11 @@
          else
             ClientPrint(pEntity, HUD_PRINTNOTIFY, "observer mode DISABLED\n");
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
       else if (FStrEq(pcmd, "botskill"))
       {
@@ -594,7 +718,11 @@
          sprintf(msg, "botskill is %d\n", default_bot_skill);
          ClientPrint(pEntity, HUD_PRINTNOTIFY, msg);
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
       else if (FStrEq(pcmd, "botdontshoot"))
       {
@@ -612,7 +740,11 @@
          else
             ClientPrint(pEntity, HUD_PRINTNOTIFY, "botdontshoot DISABLED\n");
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
       else if (FStrEq(pcmd, "debug_engine"))
       {
@@ -620,7 +752,11 @@
 
          ClientPrint(pEntity, HUD_PRINTNOTIFY, "debug_engine enabled!\n");
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
       else if (FStrEq(pcmd, "waypoint"))
       {
@@ -666,12 +802,20 @@
             int index;
 
             if (num_waypoints < 1)
+#ifdef USE_METAMOD
+               RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
                return;
+#endif /* USE_METAMOD */
 
             index = WaypointFindNearest(pEntity, 50.0, -1);
 
             if (index == -1)
+#ifdef USE_METAMOD
+               RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
                return;
+#endif /* USE_METAMOD */
 
             g_menu_waypoint = index;
             g_menu_state = MENU_1;
@@ -690,7 +834,11 @@
                ClientPrint(pEntity, HUD_PRINTNOTIFY, "waypoints are OFF\n");
          }
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
       else if (FStrEq(pcmd, "autowaypoint"))
       {
@@ -711,7 +859,11 @@
 
          ClientPrint(pEntity, HUD_PRINTNOTIFY, msg);
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
       else if (FStrEq(pcmd, "pathwaypoint"))
       {
@@ -745,7 +897,11 @@
             WaypointRemovePath(pEntity, 2);
          }
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
       else if (FStrEq(pcmd, "menuselect") && (g_menu_state != MENU_NONE))
       {
@@ -760,7 +916,11 @@
                else
                   UTIL_ShowMenu(pEntity, 0x1F, -1, FALSE, show_menu_2);
 
+#ifdef USE_METAMOD
+               RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
                return;
+#endif /* USE_METAMOD */
             }
             else if (FStrEq(arg1, "2"))  // wait for lift...
             {
@@ -798,7 +958,11 @@
                else
                   UTIL_ShowMenu(pEntity, 0x13, -1, FALSE, show_menu_3);
 
+#ifdef USE_METAMOD
+               RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
                return;
+#endif /* USE_METAMOD */
             }
          }
          else if (g_menu_state == MENU_2)  // team specific menu
@@ -872,7 +1036,11 @@
 
          g_menu_state = MENU_NONE;
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
       else if (FStrEq(pcmd, "search"))
       {
@@ -895,20 +1063,33 @@
             fclose(fp);
          }
 
+#ifdef USE_METAMOD
+         RETURN_META(MRES_SUPERCEDE);
+#else /* not USE_METAMOD */
          return;
+#endif /* USE_METAMOD */
       }
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*other_gFunctionTable.pfnClientCommand)(pEntity);
+#endif /* USE_METAMOD */
 }
 
 void ClientUserInfoChanged( edict_t *pEntity, char *infobuffer )
 {
    if (debug_engine) { fp=fopen("bot.txt", "a"); fprintf(fp, "ClientUserInfoChanged: pEntity=%x infobuffer=%s\n", pEntity, infobuffer); fclose(fp); }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*other_gFunctionTable.pfnClientUserInfoChanged)(pEntity, infobuffer);
+#endif /* USE_METAMOD */
 }
 
+#ifndef USE_METAMOD
 void ServerActivate( edict_t *pEdictList, int edictCount, int clientMax )
 {
    (*other_gFunctionTable.pfnServerActivate)(pEdictList, edictCount, clientMax);
@@ -928,6 +1109,7 @@
 {
    (*other_gFunctionTable.pfnPlayerPostThink)(pEntity);
 }
+#endif /* not USE_METAMOD */
 
 void StartFrame( void )
 {
@@ -1046,7 +1228,11 @@
             {
                memset(&cd, 0, sizeof(cd));
 
+#ifdef USE_METAMOD
+               MDLL_UpdateClientData( bots[i].pEdict, 1, &cd );
+#else /* not USE_METAMOD */
                UpdateClientData( bots[i].pEdict, 1, &cd );
+#endif /* USE_METAMOD */
 
                // see if a weapon was dropped...
                if (bots[i].bot_weapons != cd.weapons)
@@ -1348,9 +1534,14 @@
       previous_time = gpGlobals->time;
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*other_gFunctionTable.pfnStartFrame)();
+#endif /* USE_METAMOD */
 }
 
+#ifndef USE_METAMOD
 void ParmsNewLevel( void )
 {
    (*other_gFunctionTable.pfnParmsNewLevel)();
@@ -1365,14 +1556,20 @@
 {
    return (*other_gFunctionTable.pfnGetGameDescription)();
 }
+#endif /* not USE_METAMOD */
 
 void PlayerCustomization( edict_t *pEntity, customization_t *pCust )
 {
    if (debug_engine) { fp=fopen("bot.txt", "a"); fprintf(fp, "PlayerCustomization: %x\n",pEntity); fclose(fp); }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*other_gFunctionTable.pfnPlayerCustomization)(pEntity, pCust);
+#endif /* USE_METAMOD */
 }
 
+#ifndef USE_METAMOD
 void SpectatorConnect( edict_t *pEntity )
 {
    (*other_gFunctionTable.pfnSpectatorConnect)(pEntity);
@@ -1462,20 +1659,91 @@
 {
    (*other_gFunctionTable.pfnCreateInstancedBaselines)();
 }
+#endif /* not USE_METAMOD */
 
 int InconsistentFile( const edict_t *player, const char *filename, char *disconnect_message )
 {
    if (debug_engine) { fp=fopen("bot.txt", "a"); fprintf(fp, "InconsistentFile: %x filename=%s\n",player,filename); fclose(fp); }
 
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*other_gFunctionTable.pfnInconsistentFile)(player, filename, disconnect_message);
+#endif /* USE_METAMOD */
 }
 
+#ifndef USE_METAMOD
 int AllowLagCompensation( void )
 {
    return (*other_gFunctionTable.pfnAllowLagCompensation)();
 }
+#endif /* not USE_METAMOD */
 
+#ifdef USE_METAMOD
+DLL_FUNCTIONS gFunctionTable =
+{
+   GameDLLInit,               //pfnGameInit
+   DispatchSpawn,             //pfnSpawn
+   NULL,             //pfnThink
+   NULL,               //pfnUse
+   NULL,             //pfnTouch
+   NULL,           //pfnBlocked
+   DispatchKeyValue,          //pfnKeyValue
+   NULL,              //pfnSave
+   NULL,           //pfnRestore
+   NULL, //pfnAbsBox
+
+   NULL,           //pfnSaveWriteFields
+   NULL,            //pfnSaveReadFields
+
+   NULL,           //pfnSaveGlobalState
+   NULL,        //pfnRestoreGlobalState
+   NULL,          //pfnResetGlobalState
 
+   ClientConnect,             //pfnClientConnect
+   ClientDisconnect,          //pfnClientDisconnect
+   ClientKill,                //pfnClientKill
+   ClientPutInServer,         //pfnClientPutInServer
+   ClientCommand,             //pfnClientCommand
+   ClientUserInfoChanged,     //pfnClientUserInfoChanged
+   NULL,            //pfnServerActivate
+   NULL,          //pfnServerDeactivate
+
+   NULL,            //pfnPlayerPreThink
+   NULL,           //pfnPlayerPostThink
+
+   StartFrame,                //pfnStartFrame
+   NULL,             //pfnParmsNewLevel
+   NULL,          //pfnParmsChangeLevel
+
+   NULL,        //pfnGetGameDescription    Returns string describing current .dll game.
+   PlayerCustomization,       //pfnPlayerCustomization   Notifies .dll of new customization for player.
+
+   NULL,          //pfnSpectatorConnect      Called when spectator joins server
+   NULL,       //pfnSpectatorDisconnect   Called when spectator leaves the server
+   NULL,            //pfnSpectatorThink        Called when spectator sends a command packet (usercmd_t)
+
+   NULL,                 //pfnSys_Error          Called when engine has encountered an error
+
+   NULL,                   //pfnPM_Move
+   NULL,                   //pfnPM_Init            Server version of player movement initialization
+   NULL,        //pfnPM_FindTextureType
+
+   NULL,           //pfnSetupVisibility        Set up PVS and PAS for networking for this client
+   NULL,          //pfnUpdateClientData       Set up data sent only to specific client
+   NULL,             //pfnAddToFullPack
+   NULL,            //pfnCreateBaseline        Tweak entity baseline for network encoding, allows setup of player baselines, too.
+   NULL,          //pfnRegisterEncoders      Callbacks for network encoding
+   NULL,             //pfnGetWeaponData
+   NULL,                  //pfnCmdStart
+   NULL,                    //pfnCmdEnd
+   NULL,      //pfnConnectionlessPacket
+   NULL,             //pfnGetHullBounds
+   NULL,  //pfnCreateInstancedBaselines
+   InconsistentFile,          //pfnInconsistentFile
+   NULL,      //pfnAllowLagCompensation
+};
+#else /* not USE_METAMOD */
 DLL_FUNCTIONS gFunctionTable =
 {
    GameDLLInit,               //pfnGameInit
@@ -1539,6 +1807,7 @@
    InconsistentFile,          //pfnInconsistentFile
    AllowLagCompensation,      //pfnAllowLagCompensation
 };
+#endif /* USE_METAMOD */
 
 #ifdef __BORLANDC__
 int EXPORT GetEntityAPI( DLL_FUNCTIONS *pFunctionTable, int interfaceVersion )
@@ -1554,16 +1823,19 @@
    // pass engine callback function table to engine...
    memcpy( pFunctionTable, &gFunctionTable, sizeof( DLL_FUNCTIONS ) );
 
+#ifndef USE_METAMOD
    // pass other DLLs engine callbacks to function table...
    if (!(*other_GetEntityAPI)(&other_gFunctionTable, INTERFACE_VERSION))
    {
       return FALSE;  // error initializing function table!!!
    }
+#endif /* not USE_METAMOD */
 
    return TRUE;
 }
 
 
+#ifndef USE_METAMOD
 #ifdef __BORLANDC__
 int EXPORT GetNewDLLFunctions( NEW_DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion )
 #else
@@ -1581,6 +1853,7 @@
 
    return TRUE;
 }
+#endif /* not USE_METAMOD */
 
 
 void FakeClientCommand(edict_t *pBot, char *arg1, char *arg2, char *arg3)
@@ -1621,7 +1894,11 @@
       strcpy(&g_argv[192], arg3);
 
    // allow the MOD DLL to execute the ClientCommand...
+#ifdef USE_METAMOD
+   MDLL_ClientCommand(pBot);
+#else /* not USE_METAMOD */
    ClientCommand(pBot);
+#endif /* USE_METAMOD */
 
    isFakeClientCommand = 0;
 }
@@ -1631,11 +1908,19 @@
 {
    if (isFakeClientCommand)
    {
+#ifdef USE_METAMOD
+      RETURN_META_VALUE(MRES_SUPERCEDE, &g_argv[0]);
+#else /* not USE_METAMOD */
       return &g_argv[0];
+#endif /* USE_METAMOD */
    }
    else
    {
+#ifdef USE_METAMOD
+      RETURN_META_VALUE(MRES_IGNORED, NULL);
+#else /* not USE_METAMOD */
       return (*g_engfuncs.pfnCmd_Args)();
+#endif /* USE_METAMOD */
    }
 }
 
@@ -1646,24 +1931,44 @@
    {
       if (argc == 0)
       {
+#ifdef USE_METAMOD
+         RETURN_META_VALUE(MRES_SUPERCEDE, &g_argv[64]);
+#else /* not USE_METAMOD */
          return &g_argv[64];
+#endif /* USE_METAMOD */
       }
       else if (argc == 1)
       {
+#ifdef USE_METAMOD
+         RETURN_META_VALUE(MRES_SUPERCEDE, &g_argv[128]);
+#else /* not USE_METAMOD */
          return &g_argv[128];
+#endif /* USE_METAMOD */
       }
       else if (argc == 2)
       {
+#ifdef USE_METAMOD
+         RETURN_META_VALUE(MRES_SUPERCEDE, &g_argv[192]);
+#else /* not USE_METAMOD */
          return &g_argv[192];
+#endif /* USE_METAMOD */
       }
       else
       {
+#ifdef USE_METAMOD
+         RETURN_META_VALUE(MRES_SUPERCEDE, NULL);
+#else /* not USE_METAMOD */
          return NULL;
+#endif /* USE_METAMOD */
       }
    }
    else
    {
+#ifdef USE_METAMOD
+      RETURN_META_VALUE(MRES_IGNORED, NULL);
+#else /* not USE_METAMOD */
       return (*g_engfuncs.pfnCmd_Argv)(argc);
+#endif /* USE_METAMOD */
    }
 }
 
@@ -1672,11 +1977,19 @@
 {
    if (isFakeClientCommand)
    {
+#ifdef USE_METAMOD
+      RETURN_META_VALUE(MRES_SUPERCEDE, fake_arg_count);
+#else /* not USE_METAMOD */
       return fake_arg_count;
+#endif /* USE_METAMOD */
    }
    else
    {
+#ifdef USE_METAMOD
+      RETURN_META_VALUE(MRES_IGNORED, 0);
+#else /* not USE_METAMOD */
       return (*g_engfuncs.pfnCmd_Argc)();
+#endif /* USE_METAMOD */
    }
 }
 
diff -ur hpb_bot/dlls/engine.cpp mm_hpb_bot/dlls/engine.cpp
--- hpb_bot/dlls/engine.cpp	Sat Feb 24 11:37:02 2001
+++ mm_hpb_bot/dlls/engine.cpp	Sun Apr  1 19:10:00 2001
@@ -9,6 +9,11 @@
 #include "extdll.h"
 #include "util.h"
 
+#ifdef USE_METAMOD
+#define SDK_UTIL_H	// util.h already included
+#include "meta_api.h"
+#endif /* USE_METAMOD */
+
 #include "bot.h"
 #include "bot_client.h"
 #include "engine.h"
@@ -50,32 +55,54 @@
 int pfnPrecacheModel(char* s)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnPrecacheModel: %s\n",s); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnPrecacheModel)(s);
+#endif /* USE_METAMOD */
 }
 int pfnPrecacheSound(char* s)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnPrecacheSound: %s\n",s); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnPrecacheSound)(s);
+#endif /* USE_METAMOD */
 }
 void pfnSetModel(edict_t *e, const char *m)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetModel: edict=%x %s\n",e,m); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSetModel)(e, m);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 int pfnModelIndex(const char *m)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnModelIndex: %s\n",m); fclose(fp); }
    return (*g_engfuncs.pfnModelIndex)(m);
 }
+#endif /* not USE_METAMOD */
 int pfnModelFrames(int modelIndex)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnModelFrames:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnModelFrames)(modelIndex);
+#endif /* USE_METAMOD */
 }
 void pfnSetSize(edict_t *e, const float *rgflMin, const float *rgflMax)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetSize: %x\n",e); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSetSize)(e, rgflMin, rgflMax);
+#endif /* USE_METAMOD */
 }
 void pfnChangeLevel(char* s1, char* s2)
 {
@@ -96,18 +123,31 @@
       }
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnChangeLevel)(s1, s2);
+#endif /* USE_METAMOD */
 }
 void pfnGetSpawnParms(edict_t *ent)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetSpawnParms:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnGetSpawnParms)(ent);
+#endif /* USE_METAMOD */
 }
 void pfnSaveSpawnParms(edict_t *ent)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSaveSpawnParms:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSaveSpawnParms)(ent);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 float pfnVecToYaw(const float *rgflVector)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnVecToYaw:\n"); fclose(fp); }
@@ -118,11 +158,17 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnVecToAngles:\n"); fclose(fp); }
    (*g_engfuncs.pfnVecToAngles)(rgflVectorIn, rgflVectorOut);
 }
+#endif /* not USE_METAMOD */
 void pfnMoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnMoveToOrigin:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnMoveToOrigin)(ent, pflGoal, dist, iMoveType);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 void pfnChangeYaw(edict_t* ent)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnChangeYaw:\n"); fclose(fp); }
@@ -138,26 +184,44 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnFindEntityByString: %s\n",pszValue); fclose(fp); }
    return (*g_engfuncs.pfnFindEntityByString)(pEdictStartSearchAfter, pszField, pszValue);
 }
+#endif /* not USE_METAMOD */
 int pfnGetEntityIllum(edict_t* pEnt)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetEntityIllum:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnGetEntityIllum)(pEnt);
+#endif /* USE_METAMOD */
 }
 edict_t* pfnFindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnFindEntityInSphere:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnFindEntityInSphere)(pEdictStartSearchAfter, org, rad);
+#endif /* USE_METAMOD */
 }
 edict_t* pfnFindClientInPVS(edict_t *pEdict)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnFindClientInPVS:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnFindClientInPVS)(pEdict);
+#endif /* USE_METAMOD */
 }
 edict_t* pfnEntitiesInPVS(edict_t *pplayer)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnEntitiesInPVS:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnEntitiesInPVS)(pplayer);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 void pfnMakeVectors(const float *rgflVector)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnMakeVectors:\n"); fclose(fp); }
@@ -168,12 +232,22 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnAngleVectors:\n"); fclose(fp); }
    (*g_engfuncs.pfnAngleVectors)(rgflVector, forward, right, up);
 }
+#endif /* not USE_METAMOD */
+#ifdef USE_METAMOD
+edict_t* pfnCreateEntity_Post(void)
+{
+   edict_t *pent = META_RESULT_ORIG_RET(edict_t *);
+   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCreateEntity: %x\n",pent); fclose(fp); }
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+}
+#else /* not USE_METAMOD */
 edict_t* pfnCreateEntity(void)
 {
    edict_t *pent = (*g_engfuncs.pfnCreateEntity)();
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCreateEntity: %x\n",pent); fclose(fp); }
    return pent;
 }
+#endif /* USE_METAMOD */
 void pfnRemoveEntity(edict_t* e)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnRemoveEntity: %x\n",e); fclose(fp); }
@@ -186,49 +260,91 @@
       fclose(fp);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnRemoveEntity)(e);
+#endif /* USE_METAMOD */
 }
+#ifdef USE_METAMOD
+edict_t* pfnCreateNamedEntity_Post(int className)
+{
+   edict_t *pent = META_RESULT_ORIG_RET(edict_t *);
+   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCreateNamedEntity: edict=%x name=%s\n",pent,STRING(className)); fclose(fp); }
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+}
+#else /* not USE_METAMOD */
 edict_t* pfnCreateNamedEntity(int className)
 {
    edict_t *pent = (*g_engfuncs.pfnCreateNamedEntity)(className);
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCreateNamedEntity: edict=%x name=%s\n",pent,STRING(className)); fclose(fp); }
    return pent;
 }
+#endif /* USE_METAMOD */
 void pfnMakeStatic(edict_t *ent)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnMakeStatic:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnMakeStatic)(ent);
+#endif /* USE_METAMOD */
 }
 int pfnEntIsOnFloor(edict_t *e)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnEntIsOnFloor:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnEntIsOnFloor)(e);
+#endif /* USE_METAMOD */
 }
 int pfnDropToFloor(edict_t* e)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnDropToFloor:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnDropToFloor)(e);
+#endif /* USE_METAMOD */
 }
 int pfnWalkMove(edict_t *ent, float yaw, float dist, int iMode)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnWalkMove:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnWalkMove)(ent, yaw, dist, iMode);
+#endif /* USE_METAMOD */
 }
 void pfnSetOrigin(edict_t *e, const float *rgflOrigin)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetOrigin:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSetOrigin)(e, rgflOrigin);
+#endif /* USE_METAMOD */
 }
 void pfnEmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnEmitSound:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnEmitSound)(entity, channel, sample, volume, attenuation, fFlags, pitch);
+#endif /* USE_METAMOD */
 }
 void pfnEmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnEmitAmbientSound:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnEmitAmbientSound)(entity, pos, samp, vol, attenuation, fFlags, pitch);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 void pfnTraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnTraceLine:\n"); fclose(fp); }
@@ -269,21 +385,35 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetAimVector:\n"); fclose(fp); }
    (*g_engfuncs.pfnGetAimVector)(ent, speed, rgflReturn);
 }
+#endif /* not USE_METAMOD */
 void pfnServerCommand(char* str)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnServerCommand: %s\n",str); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnServerCommand)(str);
+#endif /* USE_METAMOD */
 }
 void pfnServerExecute(void)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnServerExecute:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnServerExecute)();
+#endif /* USE_METAMOD */
 }
 void pfnClientCommand(edict_t* pEdict, char* szFmt, ...)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnClientCommand=%s\n",szFmt); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    return;
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 void pfnParticleEffect(const float *org, const float *dir, float color, float count)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnParticleEffect:\n"); fclose(fp); }
@@ -304,6 +434,7 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnPointContents:\n"); fclose(fp); }
    return (*g_engfuncs.pfnPointContents)(rgflVector);
 }
+#endif /* not USE_METAMOD */
 void pfnMessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed)
 {
    if (gpGlobals->deathmatch)
@@ -498,7 +629,11 @@
       }
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnMessageBegin)(msg_dest, msg_type, pOrigin, ed);
+#endif /* USE_METAMOD */
 }
 void pfnMessageEnd(void)
 {
@@ -514,7 +649,11 @@
       botMsgEndFunction = NULL;
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnMessageEnd)();
+#endif /* USE_METAMOD */
 }
 void pfnWriteByte(int iValue)
 {
@@ -527,7 +666,11 @@
          (*botMsgFunction)((void *)&iValue, botMsgIndex);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnWriteByte)(iValue);
+#endif /* USE_METAMOD */
 }
 void pfnWriteChar(int iValue)
 {
@@ -540,7 +683,11 @@
          (*botMsgFunction)((void *)&iValue, botMsgIndex);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnWriteChar)(iValue);
+#endif /* USE_METAMOD */
 }
 void pfnWriteShort(int iValue)
 {
@@ -553,7 +700,11 @@
          (*botMsgFunction)((void *)&iValue, botMsgIndex);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnWriteShort)(iValue);
+#endif /* USE_METAMOD */
 }
 void pfnWriteLong(int iValue)
 {
@@ -566,7 +717,11 @@
          (*botMsgFunction)((void *)&iValue, botMsgIndex);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnWriteLong)(iValue);
+#endif /* USE_METAMOD */
 }
 void pfnWriteAngle(float flValue)
 {
@@ -579,7 +734,11 @@
          (*botMsgFunction)((void *)&flValue, botMsgIndex);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnWriteAngle)(flValue);
+#endif /* USE_METAMOD */
 }
 void pfnWriteCoord(float flValue)
 {
@@ -592,7 +751,11 @@
          (*botMsgFunction)((void *)&flValue, botMsgIndex);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnWriteCoord)(flValue);
+#endif /* USE_METAMOD */
 }
 void pfnWriteString(const char *sz)
 {
@@ -605,7 +768,11 @@
          (*botMsgFunction)((void *)sz, botMsgIndex);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnWriteString)(sz);
+#endif /* USE_METAMOD */
 }
 void pfnWriteEntity(int iValue)
 {
@@ -618,13 +785,22 @@
          (*botMsgFunction)((void *)&iValue, botMsgIndex);
    }
 
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnWriteEntity)(iValue);
+#endif /* USE_METAMOD */
 }
 void pfnCVarRegister(cvar_t *pCvar)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCVarRegister:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnCVarRegister)(pCvar);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 float pfnCVarGetFloat(const char *szVarName)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCVarGetFloat: %s\n",szVarName); fclose(fp); }
@@ -645,36 +821,62 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCVarSetString:\n"); fclose(fp); }
    (*g_engfuncs.pfnCVarSetString)(szVarName, szValue);
 }
+#endif /* not USE_METAMOD */
 void* pfnPvAllocEntPrivateData(edict_t *pEdict, long cb)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnPvAllocEntPrivateData:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnPvAllocEntPrivateData)(pEdict, cb);
+#endif /* USE_METAMOD */
 }
 void* pfnPvEntPrivateData(edict_t *pEdict)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnPvEntPrivateData:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnPvEntPrivateData)(pEdict);
+#endif /* USE_METAMOD */
 }
 void pfnFreeEntPrivateData(edict_t *pEdict)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnFreeEntPrivateData:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnFreeEntPrivateData)(pEdict);
+#endif /* USE_METAMOD */
 }
 const char* pfnSzFromIndex(int iString)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSzFromIndex:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnSzFromIndex)(iString);
+#endif /* USE_METAMOD */
 }
 int pfnAllocString(const char *szValue)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnAllocString:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnAllocString)(szValue);
+#endif /* USE_METAMOD */
 }
 entvars_t* pfnGetVarsOfEnt(edict_t *pEdict)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetVarsOfEnt:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnGetVarsOfEnt)(pEdict);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 edict_t* pfnPEntityOfEntOffset(int iEntOffset)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnPEntityOfEntOffset:\n"); fclose(fp); }
@@ -705,11 +907,20 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetModelPtr: %x\n",pEdict); fclose(fp); }
    return (*g_engfuncs.pfnGetModelPtr)(pEdict);
 }
+#endif /* not USE_METAMOD */
+#ifdef USE_METAMOD
+int pfnRegUserMsg_Post(const char *pszName, int iSize)
+#else /* not USE_METAMOD */
 int pfnRegUserMsg(const char *pszName, int iSize)
+#endif /* USE_METMOD */
 {
    int msg;
 
+#ifdef USE_METAMOD
+   msg = META_RESULT_ORIG_RET(int);
+#else /* not USE_METAMOD */
    msg = (*g_engfuncs.pfnRegUserMsg)(pszName, iSize);
+#endif /* USE_METAMOD */
 
    if (gpGlobals->deathmatch)
    {
@@ -862,8 +1073,13 @@
       }
    }
 
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return msg;
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 void pfnAnimationAutomove(const edict_t* pEdict, float flTime)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnAnimationAutomove:\n"); fclose(fp); }
@@ -874,51 +1090,87 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetBonePosition:\n"); fclose(fp); }
    (*g_engfuncs.pfnGetBonePosition)(pEdict, iBone, rgflOrigin, rgflAngles);
 }
+#endif /* not USE_METAMOD */
 unsigned long pfnFunctionFromName( const char *pName )
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnFunctionFromName:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnFunctionFromName)(pName);
+#endif /* USE_METAMOD */
 }
 const char *pfnNameForFunction( unsigned long function )
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnNameForFunction:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnNameForFunction)(function);
+#endif /* USE_METAMOD */
 }
 void pfnClientPrintf( edict_t* pEdict, PRINT_TYPE ptype, const char *szMsg )
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnClientPrintf:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnClientPrintf)(pEdict, ptype, szMsg);
+#endif /* USE_METAMOD */
 }
 void pfnServerPrint( const char *szMsg )
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnServerPrint: %s\n",szMsg); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnServerPrint)(szMsg);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 void pfnGetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles )
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetAttachment:\n"); fclose(fp); }
    (*g_engfuncs.pfnGetAttachment)(pEdict, iAttachment, rgflOrigin, rgflAngles);
 }
+#endif /* not USE_METAMOD */
 void pfnCRC32_Init(CRC32_t *pulCRC)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCRC32_Init:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnCRC32_Init)(pulCRC);
+#endif /* USE_METAMOD */
 }
 void pfnCRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCRC32_ProcessBuffer:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnCRC32_ProcessBuffer)(pulCRC, p, len);
+#endif /* USE_METAMOD */
 }
 void pfnCRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCRC32_ProcessByte:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnCRC32_ProcessByte)(pulCRC, ch);
+#endif /* USE_METAMOD */
 }
 CRC32_t pfnCRC32_Final(CRC32_t pulCRC)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCRC32_Final:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnCRC32_Final)(pulCRC);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 long pfnRandomLong(long lLow, long lHigh)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnRandomLong: lLow=%d lHigh=%d\n",lLow,lHigh); fclose(fp); }
@@ -929,110 +1181,195 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnRandomFloat:\n"); fclose(fp); }
    return (*g_engfuncs.pfnRandomFloat)(flLow, flHigh);
 }
+#endif /* not USE_METAMOD */
 void pfnSetView(const edict_t *pClient, const edict_t *pViewent )
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetView:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSetView)(pClient, pViewent);
+#endif /* USE_METAMOD */
 }
 float pfnTime( void )
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnTime:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0.0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnTime)();
+#endif /* USE_METAMOD */
 }
 void pfnCrosshairAngle(const edict_t *pClient, float pitch, float yaw)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCrosshairAngle:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnCrosshairAngle)(pClient, pitch, yaw);
+#endif /* USE_METAMOD */
 }
 byte *pfnLoadFileForMe(char *filename, int *pLength)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnLoadFileForMe: filename=%s\n",filename); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnLoadFileForMe)(filename, pLength);
+#endif /* USE_METAMOD */
 }
 void pfnFreeFile(void *buffer)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnFreeFile:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnFreeFile)(buffer);
+#endif /* USE_METAMOD */
 }
 void pfnEndSection(const char *pszSectionName)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnEndSection:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnEndSection)(pszSectionName);
+#endif /* USE_METAMOD */
 }
 int pfnCompareFileTime(char *filename1, char *filename2, int *iCompare)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCompareFileTime:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnCompareFileTime)(filename1, filename2, iCompare);
+#endif /* USE_METAMOD */
 }
 void pfnGetGameDir(char *szGetGameDir)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetGameDir:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnGetGameDir)(szGetGameDir);
+#endif /* USE_METAMOD */
 }
 void pfnCvar_RegisterVariable(cvar_t *variable)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCvar_RegisterVariable:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnCvar_RegisterVariable)(variable);
+#endif /* USE_METAMOD */
 }
 void pfnFadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnFadeClientVolume:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnFadeClientVolume)(pEdict, fadePercent, fadeOutSeconds, holdTime, fadeInSeconds);
+#endif /* USE_METAMOD */
 }
 void pfnSetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetClientMaxspeed: edict=%x %f\n",pEdict,fNewMaxspeed); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSetClientMaxspeed)(pEdict, fNewMaxspeed);
+#endif /* USE_METAMOD */
 }
 edict_t * pfnCreateFakeClient(const char *netname)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCreateFakeClient:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnCreateFakeClient)(netname);
+#endif /* USE_METAMOD */
 }
 void pfnRunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec )
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnRunPlayerMove:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnRunPlayerMove)(fakeclient, viewangles, forwardmove, sidemove, upmove, buttons, impulse, msec);
+#endif /* USE_METAMOD */
 }
 int pfnNumberOfEntities(void)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnNumberOfEntities:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnNumberOfEntities)();
+#endif /* USE_METAMOD */
 }
 char* pfnGetInfoKeyBuffer(edict_t *e)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetInfoKeyBuffer:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnGetInfoKeyBuffer)(e);
+#endif /* USE_METAMOD */
 }
 char* pfnInfoKeyValue(char *infobuffer, char *key)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnInfoKeyValue: %s %s\n",infobuffer,key); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnInfoKeyValue)(infobuffer, key);
+#endif /* USE_METAMOD */
 }
 void pfnSetKeyValue(char *infobuffer, char *key, char *value)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetKeyValue: %s %s\n",key,value); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSetKeyValue)(infobuffer, key, value);
+#endif /* USE_METAMOD */
 }
 void pfnSetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetClientKeyValue: %s %s\n",key,value); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSetClientKeyValue)(clientIndex, infobuffer, key, value);
+#endif /* USE_METAMOD */
 }
 int pfnIsMapValid(char *filename)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnIsMapValid:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnIsMapValid)(filename);
+#endif /* USE_METAMOD */
 }
 void pfnStaticDecal( const float *origin, int decalIndex, int entityIndex, int modelIndex )
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnStaticDecal:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnStaticDecal)(origin, decalIndex, entityIndex, modelIndex);
+#endif /* USE_METAMOD */
 }
 int pfnPrecacheGeneric(char* s)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnPrecacheGeneric: %s\n",s); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnPrecacheGeneric)(s);
+#endif /* USE_METAMOD */
 }
 int pfnGetPlayerUserId(edict_t *e )
 {
@@ -1044,31 +1381,55 @@
       {
          // is this edict a bot?
          if (UTIL_GetBotPointer( e ))
+#ifdef USE_METAMOD
+            RETURN_META_VALUE(MRES_SUPERCEDE, 0);
+#else /* not USE_METAMOD */
             return 0;  // don't return a valid index (so bot won't get kicked)
+#endif /* USE_METAMOD */
       }
    }
 
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnGetPlayerUserId)(e);
+#endif /* USE_METAMOD */
 }
 void pfnBuildSoundMsg(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)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnBuildSoundMsg:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnBuildSoundMsg)(entity, channel, sample, volume, attenuation, fFlags, pitch, msg_dest, msg_type, pOrigin, ed);
+#endif /* USE_METAMOD */
 }
 int pfnIsDedicatedServer(void)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnIsDedicatedServer:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnIsDedicatedServer)();
+#endif /* USE_METAMOD */
 }
 cvar_t* pfnCVarGetPointer(const char *szVarName)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCVarGetPointer: %s\n",szVarName); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnCVarGetPointer)(szVarName);
+#endif /* USE_METAMOD */
 }
 unsigned int pfnGetPlayerWONId(edict_t *e)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetPlayerWONId: %x\n",e); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnGetPlayerWONId)(e);
+#endif /* USE_METAMOD */
 }
 
 
@@ -1077,44 +1438,77 @@
 void pfnInfo_RemoveKey(char *s, const char *key)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnInfo_RemoveKey:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnInfo_RemoveKey)(s, key);
+#endif /* USE_METAMOD */
 }
 const char *pfnGetPhysicsKeyValue(const edict_t *pClient, const char *key)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetPhysicsKeyValue:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnGetPhysicsKeyValue)(pClient, key);
+#endif /* USE_METAMOD */
 }
 void pfnSetPhysicsKeyValue(const edict_t *pClient, const char *key, const char *value)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetPhysicsKeyValue:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSetPhysicsKeyValue)(pClient, key, value);
+#endif /* USE_METAMOD */
 }
 const char *pfnGetPhysicsInfoString(const edict_t *pClient)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetPhysicsInfoString:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnGetPhysicsInfoString)(pClient);
+#endif /* USE_METAMOD */
 }
 unsigned short pfnPrecacheEvent(int type, const char *psz)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnPrecacheEvent:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnPrecacheEvent)(type, psz);
+#endif /* USE_METAMOD */
 }
 void pfnPlaybackEvent(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)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnPlaybackEvent:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnPlaybackEvent)(flags, pInvoker, eventindex, delay, origin, angles, fparam1, fparam2, iparam1, iparam2, bparam1, bparam2);
+#endif /* USE_METAMOD */
 }
 unsigned char *pfnSetFatPVS(float *org)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetFatPVS:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnSetFatPVS)(org);
+#endif /* USE_METAMOD */
 }
 unsigned char *pfnSetFatPAS(float *org)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetFatPAS:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, NULL);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnSetFatPAS)(org);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 int pfnCheckVisibility(const edict_t *entity, unsigned char *pset)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCheckVisibility:\n"); fclose(fp); }
@@ -1135,54 +1529,495 @@
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnDeltaAddEncoder:\n"); fclose(fp); }
    (*g_engfuncs.pfnDeltaAddEncoder)(name, conditionalencode);
 }
+#endif /* not USE_METAMOD */
 int pfnGetCurrentPlayer(void)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetCurrentPlayer:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnGetCurrentPlayer)();
+#endif /* USE_METAMOD */
 }
 int pfnCanSkipPlayer(const edict_t *player)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCanSkipPlayer:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnCanSkipPlayer)(player);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 int pfnDeltaFindField(struct delta_s *pFields, const char *fieldname)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnDeltaFindField:\n"); fclose(fp); }
    return (*g_engfuncs.pfnDeltaFindField)(pFields, fieldname);
 }
+#endif /* not USE_METAMOD */
 void pfnDeltaSetFieldByIndex(struct delta_s *pFields, int fieldNumber)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnDeltaSetFieldByIndex:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnDeltaSetFieldByIndex)(pFields, fieldNumber);
+#endif /* USE_METAMOD */
 }
+#ifndef USE_METAMOD
 void pfnDeltaUnsetFieldByIndex(struct delta_s *pFields, int fieldNumber)
 {
 //   if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnDeltaUnsetFieldByIndex:\n"); fclose(fp); }
    (*g_engfuncs.pfnDeltaUnsetFieldByIndex)(pFields, fieldNumber);
 }
+#endif /* not USE_METAMOD */
 void pfnSetGroupMask(int mask, int op)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnSetGroupMask:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnSetGroupMask)(mask, op);
+#endif /* USE_METAMOD */
 }
 int pfnCreateInstancedBaseline(int classname, struct entity_state_s *baseline)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCreateInstancedBaseline:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META_VALUE(MRES_HANDLED, 0);
+#else /* not USE_METAMOD */
    return (*g_engfuncs.pfnCreateInstancedBaseline)(classname, baseline);
+#endif /* USE_METAMOD */
 }
 void pfnCvar_DirectSet(struct cvar_s *var, char *value)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnCvar_DirectSet:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnCvar_DirectSet)(var, value);
+#endif /* USE_METAMOD */
 }
 void pfnForceUnmodified(FORCE_TYPE type, float *mins, float *maxs, const char *filename)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnForceUnmodified:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnForceUnmodified)(type, mins, maxs, filename);
+#endif /* USE_METAMOD */
 }
 void pfnGetPlayerStats(const edict_t *pClient, int *ping, int *packet_loss)
 {
    if (debug_engine) { fp=fopen("bot.txt","a"); fprintf(fp,"pfnGetPlayerStats:\n"); fclose(fp); }
+#ifdef USE_METAMOD
+   RETURN_META(MRES_HANDLED);
+#else /* not USE_METAMOD */
    (*g_engfuncs.pfnGetPlayerStats)(pClient, ping, packet_loss);
+#endif /* USE_METAMOD */
 }
 
+#ifdef USE_METAMOD
+enginefuncs_t meta_engfuncs = {
+	pfnPrecacheModel,			// pfnPrecacheModel()
+	pfnPrecacheSound,			// pfnPrecacheSound()
+	pfnSetModel,				// pfnSetModel()
+	NULL,				// pfnModelIndex()
+	pfnModelFrames,			// pfnModelFrames()
+
+	pfnSetSize,				// pfnSetSize()
+	pfnChangeLevel,			// pfnChangeLevel()
+	pfnGetSpawnParms,			// pfnGetSpawnParms()
+	pfnSaveSpawnParms,			// pfnSaveSpawnParms()
+
+	NULL,				// pfnVecToYaw()
+	NULL,			// pfnVecToAngles()
+	pfnMoveToOrigin,			// pfnMoveToOrigin()
+	NULL,				// pfnChangeYaw()
+	NULL,			// pfnChangePitch()
+
+	NULL,		// pfnFindEntityByString()
+	pfnGetEntityIllum,			// pfnGetEntityIllum()
+	pfnFindEntityInSphere,		// pfnFindEntityInSphere()
+	pfnFindClientInPVS,		// pfnFindClientInPVS()
+	pfnEntitiesInPVS,			// pfnEntitiesInPVS()
+
+	NULL,			// pfnMakeVectors()
+	NULL,			// pfnAngleVectors()
+
+	NULL,			// pfnCreateEntity()
+	pfnRemoveEntity,			// pfnRemoveEntity()
+	NULL,		// pfnCreateNamedEntity()
+
+	pfnMakeStatic,				// pfnMakeStatic()
+	pfnEntIsOnFloor,			// pfnEntIsOnFloor()
+	pfnDropToFloor,			// pfnDropToFloor()
+
+	pfnWalkMove,				// pfnWalkMove()
+	pfnSetOrigin,				// pfnSetOrigin()
+
+	pfnEmitSound,				// pfnEmitSound()
+	pfnEmitAmbientSound,		// pfnEmitAmbientSound()
+
+	NULL,				// pfnTraceLine()
+	NULL,				// pfnTraceToss()
+	NULL,		// pfnTraceMonsterHull()
+	NULL,				// pfnTraceHull()
+	NULL,				// pfnTraceModel()
+	NULL,			// pfnTraceTexture()
+	NULL,			// pfnTraceSphere()
+	NULL,			// pfnGetAimVector()
+
+	pfnServerCommand,			// pfnServerCommand()
+	pfnServerExecute,			// pfnServerExecute()
+	pfnClientCommand,		// pfnClientCommand()
+
+	NULL,			// pfnParticleEffect()
+	NULL,				// pfnLightStyle()
+	NULL,				// pfnDecalIndex()
+	NULL,			// pfnPointContents()
+
+	pfnMessageBegin,			// pfnMessageBegin()
+	pfnMessageEnd,				// pfnMessageEnd()
+
+	pfnWriteByte,				// pfnWriteByte()
+	pfnWriteChar,				// pfnWriteChar()
+	pfnWriteShort,				// pfnWriteShort()
+	pfnWriteLong,				// pfnWriteLong()
+	pfnWriteAngle,				// pfnWriteAngle()
+	pfnWriteCoord,				// pfnWriteCoord()
+	pfnWriteString,			// pfnWriteString()
+	pfnWriteEntity,			// pfnWriteEntity()
+
+	pfnCVarRegister,			// pfnCVarRegister()
+	NULL,			// pfnCVarGetFloat()
+	NULL,			// pfnCVarGetString()
+	NULL,			// pfnCVarSetFloat()
+	NULL,			// pfnCVarSetString()
+
+	NULL,			// pfnAlertMessage()
+	NULL,			// pfnEngineFprintf()
+
+	pfnPvAllocEntPrivateData,	// pfnPvAllocEntPrivateData()
+	pfnPvEntPrivateData,		// pfnPvEntPrivateData()
+	pfnFreeEntPrivateData,		// pfnFreeEntPrivateData()
+
+	pfnSzFromIndex,			// pfnSzFromIndex()
+	pfnAllocString,			// pfnAllocString()
+
+	pfnGetVarsOfEnt, 			// pfnGetVarsOfEnt()
+	NULL,		// pfnPEntityOfEntOffset()
+	NULL,		// pfnEntOffsetOfPEntity()
+	NULL,			// pfnIndexOfEdict()
+	NULL,		// pfnPEntityOfEntIndex()
+	NULL,		// pfnFindEntityByVars()
+	NULL,			// pfnGetModelPtr()
+
+	NULL,				// pfnRegUserMsg()
+
+	NULL,		// pfnAnimationAutomove()
+	NULL,		// pfnGetBonePosition()
+
+	pfnFunctionFromName,		// pfnFunctionFromName()
+	pfnNameForFunction,		// pfnNameForFunction()
+
+	pfnClientPrintf,			// pfnClientPrintf()			//! JOHN: engine callbacks so game DLL can print messages to individual clients
+	pfnServerPrint,			// pfnServerPrint()
+
+	Cmd_Args,			// pfnCmd_Args()	//! these 3 added 
+	Cmd_Argv,			// pfnCmd_Argv()	//! so game DLL can easily 
+	Cmd_Argc,			// pfnCmd_Argc()	//! access client 'cmd' strings
+
+	NULL,			// pfnGetAttachment()
+
+	pfnCRC32_Init,				// pfnCRC32_Init()
+	pfnCRC32_ProcessBuffer,	// pfnCRC32_ProcessBuffer()
+	pfnCRC32_ProcessByte,		// pfnCRC32_ProcessByte()
+	pfnCRC32_Final,			// pfnCRC32_Final()
+
+	NULL,				// pfnRandomLong()
+	NULL,			// pfnRandomFloat()
+
+	pfnSetView,				// pfnSetView()
+	pfnTime,					// pfnTime()
+	pfnCrosshairAngle,			// pfnCrosshairAngle()
+
+	pfnLoadFileForMe,			// pfnLoadFileForMe()
+	pfnFreeFile,				// pfnFreeFile()
+
+	pfnEndSection,				// pfnEndSection()				//! trigger_endsection
+	pfnCompareFileTime,		// pfnCompareFileTime()
+	pfnGetGameDir,				// pfnGetGameDir()
+	pfnCvar_RegisterVariable,	// pfnCvar_RegisterVariable()
+	pfnFadeClientVolume,		// pfnFadeClientVolume()
+	pfnSetClientMaxspeed,		// pfnSetClientMaxspeed()
+	pfnCreateFakeClient,		// pfnCreateFakeClient() 		//! returns NULL if fake client can't be created
+	pfnRunPlayerMove,			// pfnRunPlayerMove()
+	pfnNumberOfEntities,		// pfnNumberOfEntities()
+
+	pfnGetInfoKeyBuffer,		// pfnGetInfoKeyBuffer()		//! passing in NULL gets the serverinfo
+	pfnInfoKeyValue,			// pfnInfoKeyValue()
+	pfnSetKeyValue,			// pfnSetKeyValue()
+	pfnSetClientKeyValue,		// pfnSetClientKeyValue()
+
+	pfnIsMapValid,				// pfnIsMapValid()
+	pfnStaticDecal,			// pfnStaticDecal()
+	pfnPrecacheGeneric,		// pfnPrecacheGeneric()
+	pfnGetPlayerUserId, 		// pfnGetPlayerUserId()			//! returns the server assigned userid for this player.
+	pfnBuildSoundMsg,			// pfnBuildSoundMsg()
+	pfnIsDedicatedServer,		// pfnIsDedicatedServer()		//! is this a dedicated server?
+	pfnCVarGetPointer,			// pfnCVarGetPointer()
+	pfnGetPlayerWONId,			// pfnGetPlayerWONId()			//! returns the server assigned WONid for this player.
+
+	//! YWB 8/1/99 TFF Physics additions
+	pfnInfo_RemoveKey,			// pfnInfo_RemoveKey()
+	pfnGetPhysicsKeyValue,		// pfnGetPhysicsKeyValue()
+	pfnSetPhysicsKeyValue,		// pfnSetPhysicsKeyValue()
+	pfnGetPhysicsInfoString,	// pfnGetPhysicsInfoString()
+	pfnPrecacheEvent,			// pfnPrecacheEvent()
+	pfnPlaybackEvent,			// pfnPlaybackEvent()
+
+	pfnSetFatPVS,				// pfnSetFatPVS()
+	pfnSetFatPAS,				// pfnSetFatPAS()
+
+	NULL,		// pfnCheckVisibility()
+
+	NULL,			// pfnDeltaSetField()
+	NULL,		// pfnDeltaUnsetField()
+	NULL,		// pfnDeltaAddEncoder()
+	pfnGetCurrentPlayer,		// pfnGetCurrentPlayer()
+	pfnCanSkipPlayer,			// pfnCanSkipPlayer()
+	NULL,			// pfnDeltaFindField()
+	pfnDeltaSetFieldByIndex,	// pfnDeltaSetFieldByIndex()
+	NULL,	// pfnDeltaUnsetFieldByIndex()
+
+	pfnSetGroupMask,			// pfnSetGroupMask()
+
+	pfnCreateInstancedBaseline, // pfnCreateInstancedBaseline()		// d'oh, CreateInstancedBaseline in dllapi too
+	pfnCvar_DirectSet,			// pfnCvar_DirectSet()
+
+	pfnForceUnmodified,		// pfnForceUnmodified()
+
+	pfnGetPlayerStats,			// pfnGetPlayerStats()
+
+	NULL,		// pfnAddServerCommand()
+};
+
+int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion ) 
+{
+	if(!pengfuncsFromEngine) {
+		UTIL_LogPrintf("%s: GetEngineFunctions called with null pengfuncsFromEngine", Plugin_info.logtag);
+		return(FALSE);
+	}
+	else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) {
+		UTIL_LogPrintf("%s: GetEngineFunctions version mismatch; requested=%d ours=%d", Plugin_info.logtag, *interfaceVersion, ENGINE_INTERFACE_VERSION);
+		// Tell metamod what version we had, so it can figure out who is out of date.
+		*interfaceVersion = ENGINE_INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy(pengfuncsFromEngine, &meta_engfuncs, sizeof(enginefuncs_t));
+	return TRUE;
+}
+
+
+enginefuncs_t meta_engfuncs_post = {
+	NULL,			// pfnPrecacheModel()
+	NULL,			// pfnPrecacheSound()
+	NULL,				// pfnSetModel()
+	NULL,				// pfnModelIndex()
+	NULL,			// pfnModelFrames()
+
+	NULL,				// pfnSetSize()
+	NULL,			// pfnChangeLevel()
+	NULL,			// pfnGetSpawnParms()
+	NULL,			// pfnSaveSpawnParms()
+
+	NULL,				// pfnVecToYaw()
+	NULL,			// pfnVecToAngles()
+	NULL,			// pfnMoveToOrigin()
+	NULL,				// pfnChangeYaw()
+	NULL,			// pfnChangePitch()
+
+	NULL,		// pfnFindEntityByString()
+	NULL,			// pfnGetEntityIllum()
+	NULL,		// pfnFindEntityInSphere()
+	NULL,		// pfnFindClientInPVS()
+	NULL,			// pfnEntitiesInPVS()
+
+	NULL,			// pfnMakeVectors()
+	NULL,			// pfnAngleVectors()
+
+	pfnCreateEntity_Post,			// pfnCreateEntity()
+	NULL,			// pfnRemoveEntity()
+	pfnCreateNamedEntity_Post,		// pfnCreateNamedEntity()
+
+	NULL,				// pfnMakeStatic()
+	NULL,			// pfnEntIsOnFloor()
+	NULL,			// pfnDropToFloor()
+
+	NULL,				// pfnWalkMove()
+	NULL,				// pfnSetOrigin()
+
+	NULL,				// pfnEmitSound()
+	NULL,		// pfnEmitAmbientSound()
+
+	NULL,				// pfnTraceLine()
+	NULL,				// pfnTraceToss()
+	NULL,		// pfnTraceMonsterHull()
+	NULL,				// pfnTraceHull()
+	NULL,				// pfnTraceModel()
+	NULL,			// pfnTraceTexture()
+	NULL,			// pfnTraceSphere()
+	NULL,			// pfnGetAimVector()
+
+	NULL,			// pfnServerCommand()
+	NULL,			// pfnServerExecute()
+	NULL,		// pfnClientCommand()
+
+	NULL,			// pfnParticleEffect()
+	NULL,				// pfnLightStyle()
+	NULL,				// pfnDecalIndex()
+	NULL,			// pfnPointContents()
+
+	NULL,			// pfnMessageBegin()
+	NULL,				// pfnMessageEnd()
+
+	NULL,				// pfnWriteByte()
+	NULL,				// pfnWriteChar()
+	NULL,				// pfnWriteShort()
+	NULL,				// pfnWriteLong()
+	NULL,				// pfnWriteAngle()
+	NULL,				// pfnWriteCoord()
+	NULL,			// pfnWriteString()
+	NULL,			// pfnWriteEntity()
+
+	NULL,			// pfnCVarRegister()
+	NULL,			// pfnCVarGetFloat()
+	NULL,			// pfnCVarGetString()
+	NULL,			// pfnCVarSetFloat()
+	NULL,			// pfnCVarSetString()
+
+	NULL,			// pfnAlertMessage()
+	NULL,			// pfnEngineFprintf()
+
+	NULL,	// pfnPvAllocEntPrivateData()
+	NULL,		// pfnPvEntPrivateData()
+	NULL,		// pfnFreeEntPrivateData()
+
+	NULL,			// pfnSzFromIndex()
+	NULL,			// pfnAllocString()
+
+	NULL, 			// pfnGetVarsOfEnt()
+	NULL,		// pfnPEntityOfEntOffset()
+	NULL,		// pfnEntOffsetOfPEntity()
+	NULL,			// pfnIndexOfEdict()
+	NULL,		// pfnPEntityOfEntIndex()
+	NULL,		// pfnFindEntityByVars()
+	NULL,			// pfnGetModelPtr()
+
+	pfnRegUserMsg_Post,				// pfnRegUserMsg()
+
+	NULL,		// pfnAnimationAutomove()
+	NULL,		// pfnGetBonePosition()
+
+	NULL,		// pfnFunctionFromName()
+	NULL,		// pfnNameForFunction()
+
+	NULL,			// pfnClientPrintf()			//! JOHN: engine callbacks so game DLL can print messages to individual clients
+	NULL,			// pfnServerPrint()
+
+	NULL,			// pfnCmd_Args()	//! these 3 added 
+	NULL,			// pfnCmd_Argv()	//! so game DLL can easily 
+	NULL,			// pfnCmd_Argc()	//! access client 'cmd' strings
+
+	NULL,			// pfnGetAttachment()
+
+	NULL,				// pfnCRC32_Init()
+	NULL,	// pfnCRC32_ProcessBuffer()
+	NULL,		// pfnCRC32_ProcessByte()
+	NULL,			// pfnCRC32_Final()
+
+	NULL,				// pfnRandomLong()
+	NULL,			// pfnRandomFloat()
+
+	NULL,				// pfnSetView()
+	NULL,					// pfnTime()
+	NULL,			// pfnCrosshairAngle()
+
+	NULL,			// pfnLoadFileForMe()
+	NULL,				// pfnFreeFile()
+
+	NULL,				// pfnEndSection()				//! trigger_endsection
+	NULL,		// pfnCompareFileTime()
+	NULL,				// pfnGetGameDir()
+	NULL,	// pfnCvar_RegisterVariable()
+	NULL,		// pfnFadeClientVolume()
+	NULL,		// pfnSetClientMaxspeed()
+	NULL,		// pfnCreateFakeClient() 		//! returns NULL if fake client can't be created
+	NULL,			// pfnRunPlayerMove()
+	NULL,		// pfnNumberOfEntities()
+
+	NULL,		// pfnGetInfoKeyBuffer()		//! passing in NULL gets the serverinfo
+	NULL,			// pfnInfoKeyValue()
+	NULL,			// pfnSetKeyValue()
+	NULL,		// pfnSetClientKeyValue()
+
+	NULL,				// pfnIsMapValid()
+	NULL,			// pfnStaticDecal()
+	NULL,		// pfnPrecacheGeneric()
+	NULL, 		// pfnGetPlayerUserId()			//! returns the server assigned userid for this player.
+	NULL,			// pfnBuildSoundMsg()
+	NULL,		// pfnIsDedicatedServer()		//! is this a dedicated server?
+	NULL,			// pfnCVarGetPointer()
+	NULL,			// pfnGetPlayerWONId()			//! returns the server assigned WONid for this player.
+
+	//! YWB 8/1/99 TFF Physics additions
+	NULL,			// pfnInfo_RemoveKey()
+	NULL,		// pfnGetPhysicsKeyValue()
+	NULL,		// pfnSetPhysicsKeyValue()
+	NULL,	// pfnGetPhysicsInfoString()
+	NULL,			// pfnPrecacheEvent()
+	NULL,			// pfnPlaybackEvent()
+
+	NULL,				// pfnSetFatPVS()
+	NULL,				// pfnSetFatPAS()
+
+	NULL,		// pfnCheckVisibility()
+
+	NULL,			// pfnDeltaSetField()
+	NULL,		// pfnDeltaUnsetField()
+	NULL,		// pfnDeltaAddEncoder()
+	NULL,		// pfnGetCurrentPlayer()
+	NULL,			// pfnCanSkipPlayer()
+	NULL,			// pfnDeltaFindField()
+	NULL,	// pfnDeltaSetFieldByIndex()
+	NULL,	// pfnDeltaUnsetFieldByIndex()
+
+	NULL,			// pfnSetGroupMask()
+
+	NULL, // pfnCreateInstancedBaseline()		// d'oh, CreateInstancedBaseline in dllapi too
+	NULL,			// pfnCvar_DirectSet()
+
+	NULL,		// pfnForceUnmodified()
+
+	NULL,			// pfnGetPlayerStats()
+
+	NULL,		// pfnAddServerCommand()
+};
+
+int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion ) 
+{
+	if(!pengfuncsFromEngine) {
+		UTIL_LogPrintf("%s: GetEngineFunctions called with null pengfuncsFromEngine", Plugin_info.logtag);
+		return(FALSE);
+	}
+	else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) {
+		UTIL_LogPrintf("%s: GetEngineFunctions version mismatch; requested=%d ours=%d", Plugin_info.logtag, *interfaceVersion, ENGINE_INTERFACE_VERSION);
+		// Tell metamod what version we had, so it can figure out who is out of date.
+		*interfaceVersion = ENGINE_INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy(pengfuncsFromEngine, &meta_engfuncs_post, sizeof(enginefuncs_t));
+	return TRUE;
+}
+#endif /* USE_METAMOD */
diff -ur hpb_bot/dlls/enginecallback.h mm_hpb_bot/dlls/enginecallback.h
--- hpb_bot/dlls/enginecallback.h	Mon May  1 10:26:56 2000
+++ mm_hpb_bot/dlls/enginecallback.h	Sat Mar 31 00:41:21 2001
@@ -155,4 +155,4 @@
 
 #define PLAYER_CNX_STATS		( *g_engfuncs.pfnGetPlayerStats )
 
-#endif		//ENGINECALLBACK_H
\ No newline at end of file
+#endif		//ENGINECALLBACK_H
diff -ur hpb_bot/dlls/h_export.cpp mm_hpb_bot/dlls/h_export.cpp
--- hpb_bot/dlls/h_export.cpp	Sun Dec 17 15:24:28 2000
+++ mm_hpb_bot/dlls/h_export.cpp	Sat Mar 31 02:51:15 2001
@@ -72,7 +72,7 @@
 void DLLEXPORT GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
 #endif
 #else
-extern "C" DLLEXPORT GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
+extern "C" DLLEXPORT void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
 #endif
 {
    int pos;
@@ -164,6 +164,7 @@
    g_argv = (char *)h_global_argv;
 #endif
 
+#ifndef USE_METAMOD
    other_GetEntityAPI = (GETENTITYAPI)GetProcAddress(h_Library, "GetEntityAPI");
 
    if (other_GetEntityAPI == NULL)
@@ -313,5 +314,6 @@
 
    // give the engine functions to the other DLL...
    (*other_GiveFnptrsToDll)(pengfuncsFromEngine, pGlobals);
+#endif /* not USE_METAMOD */
 }
 
diff -ur hpb_bot/dlls/linkfunc.cpp mm_hpb_bot/dlls/linkfunc.cpp
--- hpb_bot/dlls/linkfunc.cpp	Sat Dec 16 14:27:38 2000
+++ mm_hpb_bot/dlls/linkfunc.cpp	Sat Mar 31 01:14:51 2001
@@ -6,6 +6,8 @@
 // linkfunc.cpp
 //
 
+#ifndef USE_METAMOD
+
 #include "extdll.h"
 #include "util.h"
 #include "cbase.h"
@@ -569,3 +571,4 @@
 LINK_ENTITY_TO_FUNC(weapon_spas12);
 
 
+#endif /* not USE_METAMOD */
diff -ur hpb_bot/dlls/waypoint.cpp mm_hpb_bot/dlls/waypoint.cpp
--- hpb_bot/dlls/waypoint.cpp	Sun Dec 17 15:44:40 2000
+++ mm_hpb_bot/dlls/waypoint.cpp	Thu Mar 29 19:05:24 2001
@@ -13,6 +13,7 @@
 #include <sys\stat.h>
 #else
 #include <sys/stat.h>
+#include <unistd.h>
 #endif
 
 #include "extdll.h"
diff -ur hpb_bot/readme.txt mm_hpb_bot/readme.txt
--- hpb_bot/readme.txt	Sat Feb 24 13:55:18 2001
+++ mm_hpb_bot/readme.txt	Fri Mar 30 16:51:06 2001
@@ -1056,6 +1056,8 @@
 pfnWriteByte: 0                     // state = 8
 pfnMessageEnd:
 
+XXX
+
 Once the pfnMessageBegin() function has been called, and the botMsgFunction
 variable has been initialized, I will call this "botMsgFunction" function
 each time pfnWriteByte(), pfnWriteChar(), pfnWriteShort(), pfnWriteLong(),
@@ -1296,4 +1298,4 @@
 working on won't be created in a single day either.  Take things slow, try
 to learn as you go and HAVE FUN!!!
 
-botman
\ No newline at end of file
+botman