trace_plugin/engine_api.cpp
author darope
Tue Aug 23 20:31:28 2005 +0000 (2005-08-23)
changeset 248 f72386298cba
parent 236 2c14a498e4a7
child 185 a48b3f190639
permissions -rw-r--r--
Merged with working branch (bt-release-1_17_4) for release 1.18
     1 // vi: set ts=4 sw=4 :
     2 // vim: set tw=75 :
     3 
     4 // engine_api.cpp - implementation of Half-Life engine functions
     5 
     6 /*
     7  * Copyright (c) 2001-2003 Will Day <[email protected]>
     8  *
     9  *    This file is part of Metamod.
    10  *
    11  *    Metamod is free software; you can redistribute it and/or modify it
    12  *    under the terms of the GNU General Public License as published by the
    13  *    Free Software Foundation; either version 2 of the License, or (at
    14  *    your option) any later version.
    15  *
    16  *    Metamod is distributed in the hope that it will be useful, but
    17  *    WITHOUT ANY WARRANTY; without even the implied warranty of
    18  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    19  *    General Public License for more details.
    20  *
    21  *    You should have received a copy of the GNU General Public License
    22  *    along with Metamod; if not, write to the Free Software Foundation,
    23  *    Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    24  *
    25  *    In addition, as a special exception, the author gives permission to
    26  *    link the code of this program with the Half-Life Game Engine ("HL
    27  *    Engine") and Modified Game Libraries ("MODs") developed by Valve,
    28  *    L.L.C ("Valve").  You must obey the GNU General Public License in all
    29  *    respects for all of the code used other than the HL Engine and MODs
    30  *    from Valve.  If you modify this file, you may extend this exception
    31  *    to your version of the file, but you are not obligated to do so.  If
    32  *    you do not wish to do so, delete this exception statement from your
    33  *    version.
    34  *
    35  */
    36 
    37 #include <stdio.h>
    38 #include <stdarg.h>
    39 
    40 #include <extdll.h>
    41 
    42 #include "engine_api.h"
    43 #include "meta_api.h"
    44 #include "trace_api.h"
    45 #include "support_meta.h"		// MAX_STRBUF_LEN
    46 #include "log_plugin.h"
    47 
    48 int PrecacheModel(char *s) {
    49 	ENGINE_TRACE(pfnPrecacheModel, P_PRE, ("model=%s", s));
    50 	RETURN_META_VALUE(MRES_IGNORED, 0);
    51 }
    52 int PrecacheSound(char *s) {
    53 	ENGINE_TRACE(pfnPrecacheSound, P_PRE, ("sound=%s", s));
    54 	RETURN_META_VALUE(MRES_IGNORED, 0);
    55 }
    56 void SetModel(edict_t *e, const char *m) {
    57 	edict_t *ed = e;
    58 	ENGINE_TRACE(pfnSetModel, P_PRE, ("classname=%s netname=%s model=%s", 
    59 				ed ? STRING(ed->v.classname) : "nil",
    60 				ed ? STRING(ed->v.netname) : "nil",
    61 				m));
    62 	RETURN_META(MRES_IGNORED);
    63 }
    64 int ModelIndex(const char *m) {
    65 	ENGINE_TRACE(pfnModelIndex, P_PRE, ("model=%s", m));
    66 	RETURN_META_VALUE(MRES_IGNORED, 0);
    67 }
    68 int ModelFrames(int modelIndex) {
    69 	ENGINE_TRACE(pfnModelFrames, P_PRE, ("index=%d", modelIndex));
    70 	RETURN_META_VALUE(MRES_IGNORED, 0);
    71 }
    72 
    73 void SetSize(edict_t *e, const float *rgflMin, const float *rgflMax) {
    74 	ENGINE_TRACE(pfnSetSize, P_PRE, (""));
    75 	RETURN_META(MRES_IGNORED);
    76 }
    77 void ChangeLevel(char *s1, char *s2) {
    78 	ENGINE_TRACE(pfnChangeLevel, P_PRE, ("s1=%s, s2=%s", s1, s2));
    79 	RETURN_META(MRES_IGNORED);
    80 }
    81 void GetSpawnParms(edict_t *ent) {
    82 	ENGINE_TRACE(pfnGetSpawnParms, P_PRE, (""));
    83 	RETURN_META(MRES_IGNORED);
    84 }
    85 void SaveSpawnParms(edict_t *ent) {
    86 	ENGINE_TRACE(pfnSaveSpawnParms, P_PRE, (""));
    87 	RETURN_META(MRES_IGNORED);
    88 }
    89 
    90 float VecToYaw(const float *rgflVector) {
    91 	ENGINE_TRACE(pfnVecToYaw, P_PRE, (""));
    92 	RETURN_META_VALUE(MRES_IGNORED, 0.0);
    93 }
    94 void VecToAngles(const float *rgflVectorIn, float *rgflVectorOut) {
    95 	ENGINE_TRACE(pfnVecToAngles, P_PRE, (""));
    96 	RETURN_META(MRES_IGNORED);
    97 }
    98 void MoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType) {
    99 	ENGINE_TRACE(pfnMoveToOrigin, P_PRE, (""));
   100 	RETURN_META(MRES_IGNORED);
   101 }
   102 void ChangeYaw(edict_t *ent) {
   103 	ENGINE_TRACE(pfnChangeYaw, P_PRE, (""));
   104 	RETURN_META(MRES_IGNORED);
   105 }
   106 void ChangePitch(edict_t *ent) {
   107 	ENGINE_TRACE(pfnChangePitch, P_PRE, (""));
   108 	RETURN_META(MRES_IGNORED);
   109 }
   110 
   111 edict_t *FindEntityByString(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue) {
   112 	edict_t *ed=pEdictStartSearchAfter;
   113 	ENGINE_TRACE(pfnFindEntityByString, P_PRE, ("start=%s field=%s value=%s", 
   114 				ed ? STRING(ed->v.classname) : "nil", pszField, pszValue));
   115 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   116 }
   117 int GetEntityIllum(edict_t *pEnt) {
   118 	ENGINE_TRACE(pfnGetEntityIllum, P_PRE, (""));
   119 	RETURN_META_VALUE(MRES_IGNORED, 0);
   120 }
   121 edict_t *FindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad) {
   122 	ENGINE_TRACE(pfnFindEntityInSphere, P_PRE, (""));
   123 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   124 }
   125 edict_t *FindClientInPVS(edict_t *pEdict) {
   126 	ENGINE_TRACE(pfnFindClientInPVS, P_PRE, (""));
   127 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   128 }
   129 edict_t *EntitiesInPVS(edict_t *pplayer) {
   130 	ENGINE_TRACE(pfnEntitiesInPVS, P_PRE, (""));
   131 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   132 }
   133 
   134 void MakeVectors(const float *rgflVector) {
   135 	ENGINE_TRACE(pfnMakeVectors, P_PRE, (""));
   136 	RETURN_META(MRES_IGNORED);
   137 }
   138 void AngleVectors(const float *rgflVector, float *forward, float *right, float *up) {
   139 	ENGINE_TRACE(pfnAngleVectors, P_PRE, (""));
   140 	RETURN_META(MRES_IGNORED);
   141 }
   142 
   143 edict_t *CreateEntity(void) {
   144 	ENGINE_TRACE(pfnCreateEntity, P_PRE, (""));
   145 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   146 }
   147 void RemoveEntity(edict_t *e) {
   148 	ENGINE_TRACE(pfnRemoveEntity, P_PRE, ("name=%s", STRING(e->v.classname)));
   149 	RETURN_META(MRES_IGNORED);
   150 }
   151 edict_t *CreateNamedEntity(int className) {
   152 	ENGINE_TRACE(pfnCreateNamedEntity, P_PRE, ("name=%s", STRING(className)));
   153 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   154 }
   155 
   156 void MakeStatic(edict_t *ent) {
   157 	ENGINE_TRACE(pfnMakeStatic, P_PRE, (""));
   158 	RETURN_META(MRES_IGNORED);
   159 }
   160 int EntIsOnFloor(edict_t *e) {
   161 	ENGINE_TRACE(pfnEntIsOnFloor, P_PRE, (""));
   162 	RETURN_META_VALUE(MRES_IGNORED, 0);
   163 }
   164 int DropToFloor(edict_t *e) {
   165 	ENGINE_TRACE(pfnDropToFloor, P_PRE, (""));
   166 	RETURN_META_VALUE(MRES_IGNORED, 0);
   167 }
   168 
   169 int WalkMove(edict_t *ent, float yaw, float dist, int iMode) {
   170 	ENGINE_TRACE(pfnWalkMove, P_PRE, (""));
   171 	RETURN_META_VALUE(MRES_IGNORED, 0);
   172 }
   173 void SetOrigin(edict_t *e, const float *rgflOrigin) {
   174 	edict_t *ed = e;
   175 	ENGINE_TRACE(pfnSetOrigin, P_PRE, ("classname=%s netname=%s",
   176 				ed ? STRING(ed->v.classname) : "nil",
   177 				ed ? STRING(ed->v.netname) : "nil"));
   178 	RETURN_META(MRES_IGNORED);
   179 }
   180 
   181 void EmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch) {
   182 	ENGINE_TRACE(pfnEmitSound, P_PRE, ("sample=%s", sample));
   183 	RETURN_META(MRES_IGNORED);
   184 }
   185 void EmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch) {
   186 	ENGINE_TRACE(pfnEmitAmbientSound, P_PRE, ("sample=%s", samp));
   187 	RETURN_META(MRES_IGNORED);
   188 }
   189 
   190 void TraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr) {
   191 	ENGINE_TRACE(pfnTraceLine, P_PRE, (""));
   192 	RETURN_META(MRES_IGNORED);
   193 }
   194 void TraceToss(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr) {
   195 	ENGINE_TRACE(pfnTraceToss, P_PRE, (""));
   196 	RETURN_META(MRES_IGNORED);
   197 }
   198 int TraceMonsterHull(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr) {
   199 	ENGINE_TRACE(pfnTraceMonsterHull, P_PRE, (""));
   200 	RETURN_META_VALUE(MRES_IGNORED, 0);
   201 }
   202 void TraceHull(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr) {
   203 	ENGINE_TRACE(pfnTraceHull, P_PRE, (""));
   204 	RETURN_META(MRES_IGNORED);
   205 }
   206 void TraceModel(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr) {
   207 	ENGINE_TRACE(pfnTraceModel, P_PRE, (""));
   208 	RETURN_META(MRES_IGNORED);
   209 }
   210 const char *TraceTexture(edict_t *pTextureEntity, const float *v1, const float *v2 ) {
   211 	ENGINE_TRACE(pfnTraceTexture, P_PRE, (""));
   212 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   213 }
   214 void TraceSphere(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr) {
   215 	ENGINE_TRACE(pfnTraceSphere, P_PRE, (""));
   216 	RETURN_META(MRES_IGNORED);
   217 }
   218 void GetAimVector(edict_t *ent, float speed, float *rgflReturn) {
   219 	ENGINE_TRACE(pfnGetAimVector, P_PRE, (""));
   220 	RETURN_META(MRES_IGNORED);
   221 }
   222 
   223 void ServerCommand(char *str) {
   224 	ENGINE_TRACE(pfnServerCommand, P_PRE, ("cmd=%s", str));
   225 	RETURN_META(MRES_IGNORED);
   226 }
   227 void ServerExecute(void) {
   228 	ENGINE_TRACE(pfnServerExecute, P_PRE, (""));
   229 	RETURN_META(MRES_IGNORED);
   230 }
   231 void engClientCommand(edict_t *pEdict, char *szFmt, ...) {
   232 	va_list ap;
   233 	char buf[1024];
   234 	char *cp;
   235 	va_start(ap, szFmt);
   236 	vsnprintf(buf, sizeof(buf), szFmt, ap);
   237 	va_end(ap);
   238 	cp=buf+strlen(buf)-1;
   239 	if(*cp=='\n') *cp='\0';
   240 	ENGINE_TRACE(pfnClientCommand, P_PRE, ("cmd='%s'", buf));
   241 	RETURN_META(MRES_IGNORED);
   242 }
   243 
   244 void ParticleEffect(const float *org, const float *dir, float color, float count) {
   245 	ENGINE_TRACE(pfnParticleEffect, P_PRE, (""));
   246 	RETURN_META(MRES_IGNORED);
   247 }
   248 void LightStyle(int style, char *val) {
   249 	ENGINE_TRACE(pfnLightStyle, P_PRE, (""));
   250 	RETURN_META(MRES_IGNORED);
   251 }
   252 int DecalIndex(const char *name) {
   253 	ENGINE_TRACE(pfnDecalIndex, P_PRE, (""));
   254 	RETURN_META_VALUE(MRES_IGNORED, 0);
   255 }
   256 int PointContents(const float *rgflVector) {
   257 	ENGINE_TRACE(pfnPointContents, P_PRE, (""));
   258 	RETURN_META_VALUE(MRES_IGNORED, 0);
   259 }
   260 
   261 void MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed) {
   262 	const char *name, *dest;
   263 	name=GET_USER_MSG_NAME(PLID, msg_type, NULL);
   264 	if(!name) name="unknown";
   265 	dest=msg_dest_types[msg_dest];
   266 	if(!dest) dest="unknown";
   267 	ENGINE_TRACE(pfnMessageBegin, P_PRE, ("type=%s(%d), dest=%s(%d), classname=%s netname=%s", name, msg_type, dest, msg_dest,
   268 				ed ? STRING(ed->v.classname) : "nil",
   269 				ed ? STRING(ed->v.netname) : "nil"));
   270 	RETURN_META(MRES_IGNORED);
   271 }
   272 void MessageEnd(void) {
   273 	ENGINE_TRACE(pfnMessageEnd, P_PRE, (""));
   274 	RETURN_META(MRES_IGNORED);
   275 }
   276 
   277 void WriteByte(int iValue) {
   278 	ENGINE_TRACE(pfnWriteByte, P_PRE, (""));
   279 	RETURN_META(MRES_IGNORED);
   280 }
   281 void WriteChar(int iValue) {
   282 	ENGINE_TRACE(pfnWriteChar, P_PRE, (""));
   283 	RETURN_META(MRES_IGNORED);
   284 }
   285 void WriteShort(int iValue) {
   286 	ENGINE_TRACE(pfnWriteShort, P_PRE, (""));
   287 	RETURN_META(MRES_IGNORED);
   288 }
   289 void WriteLong(int iValue) {
   290 	ENGINE_TRACE(pfnWriteLong, P_PRE, (""));
   291 	RETURN_META(MRES_IGNORED);
   292 }
   293 void WriteAngle(float flValue) {
   294 	ENGINE_TRACE(pfnWriteAngle, P_PRE, (""));
   295 	RETURN_META(MRES_IGNORED);
   296 }
   297 void WriteCoord(float flValue) {
   298 	ENGINE_TRACE(pfnWriteCoord, P_PRE, (""));
   299 	RETURN_META(MRES_IGNORED);
   300 }
   301 void WriteString(const char *sz) {
   302 	ENGINE_TRACE(pfnWriteString, P_PRE, ("string=%s", sz));
   303 	RETURN_META(MRES_IGNORED);
   304 }
   305 void WriteEntity(int iValue) {
   306 	ENGINE_TRACE(pfnWriteEntity, P_PRE, (""));
   307 	RETURN_META(MRES_IGNORED);
   308 }
   309 
   310 void CVarRegister(cvar_t *pCvar) {
   311 	ENGINE_TRACE(pfnCVarRegister, P_PRE, ("cvar=%s", pCvar->name));
   312 	RETURN_META(MRES_IGNORED);
   313 }
   314 float CVarGetFloat(const char *szVarName) {
   315 	// more trace output in Post
   316 	ENGINE_TRACE(pfnCVarGetFloat, P_PRE, ("cvar=%s", szVarName));
   317 	RETURN_META_VALUE(MRES_IGNORED, 0.0);
   318 }
   319 const char *CVarGetString(const char *szVarName) {
   320 	// more trace output in Post
   321 	ENGINE_TRACE(pfnCVarGetString, P_PRE, ("cvar=%s", szVarName));
   322 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   323 }
   324 void CVarSetFloat(const char *szVarName, float flValue) {
   325 	ENGINE_TRACE(pfnCVarSetFloat, P_PRE, ("cvar=%s, val=%f", szVarName, flValue));
   326 	RETURN_META(MRES_IGNORED);
   327 }
   328 void CVarSetString(const char *szVarName, const char *szValue) {
   329 	ENGINE_TRACE(pfnCVarSetString, P_PRE, ("cvar=%s, val=%s", szVarName, szValue));
   330 	RETURN_META(MRES_IGNORED);
   331 }
   332 
   333 void AlertMessage(ALERT_TYPE atype, char *szFmt, ...) {
   334 	char *astr;
   335 	va_list ap;
   336 	char buf[MAX_STRBUF_LEN];
   337 	switch(atype) {
   338 		case at_notice:
   339 			astr="at_notice";
   340 			break;
   341 		case at_console:
   342 			astr="at_console";
   343 			break;
   344 		case at_aiconsole:
   345 			astr="at_aiconsole";
   346 			break;
   347 		case at_warning:
   348 			astr="at_warning";
   349 			break;
   350 		case at_error:
   351 			astr="at_error";
   352 			break;
   353 		case at_logged:
   354 			astr="at_logged";
   355 			break;
   356 		default:
   357 			astr="unknown";
   358 			break;
   359 	}
   360 	va_start(ap, szFmt);
   361 	vsnprintf(buf, sizeof(buf), szFmt, ap);
   362 	va_end(ap);
   363 	ENGINE_TRACE(pfnAlertMessage, P_PRE, ("atype=%s(%d) msg=%s", astr, 
   364 				atype, buf));
   365 	RETURN_META(MRES_IGNORED);
   366 }
   367 #ifdef HLSDK_3_2_OLD_EIFACE
   368 void EngineFprintf(FILE *pfile, char *szFmt, ...) {
   369 #else
   370 void EngineFprintf(void *pfile, char *szFmt, ...) {
   371 #endif
   372 	va_list ap;
   373 	char buf[1024];
   374 	va_start(ap, szFmt);
   375 	vsnprintf(buf, sizeof(buf), szFmt, ap);
   376 	va_end(ap);
   377 	ENGINE_TRACE(pfnEngineFprintf, P_PRE, ("line=%s", buf));
   378 	RETURN_META(MRES_IGNORED);
   379 }
   380 
   381 #ifdef HLSDK_3_2_OLD_EIFACE
   382 void *PvAllocEntPrivateData(edict_t *pEdict, long cb) {
   383 #else
   384 void *PvAllocEntPrivateData(edict_t *pEdict, int32 cb) {
   385 #endif
   386 	ENGINE_TRACE(pfnPvAllocEntPrivateData, P_PRE, (""));
   387 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   388 }
   389 void *PvEntPrivateData(edict_t *pEdict) {
   390 	ENGINE_TRACE(pfnPvEntPrivateData, P_PRE, (""));
   391 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   392 }
   393 void FreeEntPrivateData(edict_t *pEdict) {
   394 	ENGINE_TRACE(pfnFreeEntPrivateData, P_PRE, (""));
   395 	RETURN_META(MRES_IGNORED);
   396 }
   397 
   398 const char *SzFromIndex(int iString) {
   399 	ENGINE_TRACE(pfnSzFromIndex, P_PRE, (""));
   400 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   401 }
   402 int AllocString(const char *szValue) {
   403 	// more trace output in Post
   404 	ENGINE_TRACE(pfnAllocString, P_PRE, ("str=%s", szValue));
   405 	RETURN_META_VALUE(MRES_IGNORED, 0);
   406 }
   407 
   408 struct entvars_s *GetVarsOfEnt(edict_t *pEdict) {
   409 	ENGINE_TRACE(pfnGetVarsOfEnt, P_PRE, (""));
   410 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   411 }
   412 edict_t *PEntityOfEntOffset(int iEntOffset) {
   413 	ENGINE_TRACE(pfnPEntityOfEntOffset, P_PRE, (""));
   414 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   415 }
   416 int EntOffsetOfPEntity(const edict_t *pEdict) {
   417 	const edict_t *ed=pEdict;
   418 	ENGINE_TRACE(pfnEntOffsetOfPEntity, P_PRE, ("classname=%s netname=%s",
   419 				ed ? STRING(ed->v.classname) : "nil",
   420 				ed ? STRING(ed->v.netname) : "nil"));
   421 	RETURN_META_VALUE(MRES_IGNORED, 0);
   422 }
   423 int IndexOfEdict(const edict_t *pEdict) {
   424 	ENGINE_TRACE(pfnIndexOfEdict, P_PRE, (""));
   425 	RETURN_META_VALUE(MRES_IGNORED, 0);
   426 }
   427 edict_t *PEntityOfEntIndex(int iEntIndex) {
   428 	ENGINE_TRACE(pfnPEntityOfEntIndex, P_PRE, ("index=%d", iEntIndex));
   429 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   430 }
   431 edict_t *FindEntityByVars(struct entvars_s *pvars) {
   432 	ENGINE_TRACE(pfnFindEntityByVars, P_PRE, (""));
   433 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   434 }
   435 void *GetModelPtr(edict_t *pEdict) {
   436 	ENGINE_TRACE(pfnGetModelPtr, P_PRE, (""));
   437 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   438 }
   439 
   440 int RegUserMsg(const char *pszName, int iSize) {
   441 	// more trace output in Post
   442 	ENGINE_TRACE(pfnRegUserMsg, P_PRE, ("msg=%s size=%d", pszName, iSize));
   443 	RETURN_META_VALUE(MRES_IGNORED, 0);
   444 }
   445 
   446 void AnimationAutomove(const edict_t *pEdict, float flTime) {
   447 	ENGINE_TRACE(pfnAnimationAutomove, P_PRE, (""));
   448 	RETURN_META(MRES_IGNORED);
   449 }
   450 void GetBonePosition(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles ) {
   451 	ENGINE_TRACE(pfnGetBonePosition, P_PRE, (""));
   452 	RETURN_META(MRES_IGNORED);
   453 }
   454 
   455 #ifdef HLSDK_3_2_OLD_EIFACE
   456 unsigned long FunctionFromName( const char *pName ) {
   457 #else
   458 uint32 FunctionFromName( const char *pName ) {
   459 #endif
   460 	ENGINE_TRACE(pfnFunctionFromName, P_PRE, ("name=%s", pName));
   461 	RETURN_META_VALUE(MRES_IGNORED, 0UL);
   462 }
   463 #ifdef HLSDK_3_2_OLD_EIFACE
   464 const char *NameForFunction( unsigned long function ) {
   465 #else
   466 const char *NameForFunction( uint32 function ) {
   467 #endif
   468 	ENGINE_TRACE(pfnNameForFunction, P_PRE, (""));
   469 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   470 }
   471 
   472 //! JOHN: engine callbacks so game DLL can print messages to individual clients
   473 void ClientPrintf( edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg ) {
   474 	ENGINE_TRACE(pfnClientPrintf, P_PRE, ("msg=%s", szMsg));
   475 	RETURN_META(MRES_IGNORED);
   476 }
   477 void ServerPrint( const char *szMsg ) {
   478 	ENGINE_TRACE(pfnServerPrint, P_PRE, ("msg=%s", szMsg));
   479 	RETURN_META(MRES_IGNORED);
   480 }
   481 
   482 //! these 3 added so game DLL can easily access client 'cmd' strings
   483 const char *Cmd_Args( void ) {
   484 	// trace output in Post
   485 	ENGINE_TRACE(pfnCmd_Args, P_PRE, (""));
   486 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   487 }
   488 const char *Cmd_Argv( int argc ) {
   489 	// more trace output in Post
   490 	ENGINE_TRACE(pfnCmd_Argv, P_PRE, ("argc=%d", argc));
   491 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   492 }
   493 int Cmd_Argc( void ) {
   494 	// trace output in Post
   495 	ENGINE_TRACE(pfnCmd_Argc, P_PRE, (""));
   496 	RETURN_META_VALUE(MRES_IGNORED, 0);
   497 }
   498 
   499 void GetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ) {
   500 	ENGINE_TRACE(pfnGetAttachment, P_PRE, (""));
   501 	RETURN_META(MRES_IGNORED);
   502 }
   503 
   504 void CRC32_Init(CRC32_t *pulCRC) {
   505 	ENGINE_TRACE(pfnCRC32_Init, P_PRE, (""));
   506 	RETURN_META(MRES_IGNORED);
   507 }
   508 void CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len) {
   509 	ENGINE_TRACE(pfnCRC32_ProcessBuffer, P_PRE, (""));
   510 	RETURN_META(MRES_IGNORED);
   511 }
   512 void CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch) {
   513 	ENGINE_TRACE(pfnCRC32_ProcessByte, P_PRE, (""));
   514 	RETURN_META(MRES_IGNORED);
   515 }
   516 CRC32_t CRC32_Final(CRC32_t pulCRC) {
   517 	ENGINE_TRACE(pfnCRC32_Final, P_PRE, (""));
   518 	RETURN_META_VALUE(MRES_IGNORED, 0);
   519 }
   520 
   521 #ifdef HLSDK_3_2_OLD_EIFACE
   522 long RandomLong(long lLow, long lHigh) {
   523 #else
   524 int32 RandomLong(int32 lLow, int32 lHigh) {
   525 #endif
   526 	// more output in Post
   527 	ENGINE_TRACE(pfnRandomLong, P_PRE, ("low=%ld, high=%ld", lLow, lHigh));
   528 	RETURN_META_VALUE(MRES_IGNORED, 0L);
   529 }
   530 float RandomFloat(float flLow, float flHigh) {
   531 	// more output in Post
   532 	ENGINE_TRACE(pfnRandomFloat, P_PRE, ("low=%f, high=%f", flLow, flHigh));
   533 	RETURN_META_VALUE(MRES_IGNORED, 0.0);
   534 }
   535 
   536 void SetView(const edict_t *pClient, const edict_t *pViewent ) {
   537 	ENGINE_TRACE(pfnSetView, P_PRE, (""));
   538 	RETURN_META(MRES_IGNORED);
   539 }
   540 float Time( void ) {
   541 	// trace output in Post
   542 	ENGINE_TRACE(pfnTime, P_PRE, (""));
   543 	RETURN_META_VALUE(MRES_IGNORED, 0.0);
   544 }
   545 void CrosshairAngle(const edict_t *pClient, float pitch, float yaw) {
   546 	ENGINE_TRACE(pfnCrosshairAngle, P_PRE, (""));
   547 	RETURN_META(MRES_IGNORED);
   548 }
   549 
   550 byte *LoadFileForMe(char *filename, int *pLength) {
   551 	ENGINE_TRACE(pfnLoadFileForMe, P_PRE, ("file=%s", filename));
   552 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   553 }
   554 void FreeFile(void *buffer) {
   555 	ENGINE_TRACE(pfnFreeFile, P_PRE, (""));
   556 	RETURN_META(MRES_IGNORED);
   557 }
   558 
   559 //! trigger_endsection
   560 void EndSection(const char *pszSectionName) {
   561 	ENGINE_TRACE(pfnEndSection, P_PRE, ("section=%s", pszSectionName));
   562 	RETURN_META(MRES_IGNORED);
   563 }
   564 int CompareFileTime(char *filename1, char *filename2, int *iCompare) {
   565 	ENGINE_TRACE(pfnCompareFileTime, P_PRE, ("file1=%s, file2=%s", filename1, filename2));
   566 	RETURN_META_VALUE(MRES_IGNORED, 0);
   567 }
   568 void GetGameDir(char *szGetGameDir) {
   569 	// trace output in Post
   570 	ENGINE_TRACE(pfnGetGameDir, P_PRE, (""));
   571 	RETURN_META(MRES_IGNORED);
   572 }
   573 void Cvar_RegisterVariable(cvar_t *variable) {
   574 	ENGINE_TRACE(pfnCvar_RegisterVariable, P_PRE, ("cvar=%s", variable->name));
   575 	RETURN_META(MRES_IGNORED);
   576 }
   577 void FadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds) {
   578 	ENGINE_TRACE(pfnFadeClientVolume, P_PRE, (""));
   579 	RETURN_META(MRES_IGNORED);
   580 }
   581 void SetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed) {
   582 	ENGINE_TRACE(pfnSetClientMaxspeed, P_PRE, (""));
   583 	RETURN_META(MRES_IGNORED);
   584 }
   585 //! returns NULL if fake client can't be created
   586 edict_t * CreateFakeClient(const char *netname) {
   587 	ENGINE_TRACE(pfnCreateFakeClient, P_PRE, ("name=%s", netname));
   588 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   589 }
   590 void RunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec ) {
   591 	ENGINE_TRACE(pfnRunPlayerMove, P_PRE, (""));
   592 	RETURN_META(MRES_IGNORED);
   593 }
   594 int NumberOfEntities(void) {
   595 	// trace output in Post
   596 	ENGINE_TRACE(pfnNumberOfEntities, P_PRE, (""));
   597 	RETURN_META_VALUE(MRES_IGNORED, 0);
   598 }
   599 
   600 //! passing in NULL gets the serverinfo
   601 char *GetInfoKeyBuffer(edict_t *e) {
   602 	ENGINE_TRACE(pfnGetInfoKeyBuffer, P_PRE, (""));
   603 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   604 }
   605 char *InfoKeyValue(char *infobuffer, char *key) {
   606 	ENGINE_TRACE(pfnInfoKeyValue, P_PRE, ("key=%s", key));
   607 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   608 }
   609 void SetKeyValue(char *infobuffer, char *key, char *value) {
   610 	ENGINE_TRACE(pfnSetKeyValue, P_PRE, ("key=%s, value=%s", key, value));
   611 	RETURN_META(MRES_IGNORED);
   612 }
   613 void SetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value) {
   614 	ENGINE_TRACE(pfnSetClientKeyValue, P_PRE, ("index=%d, key=%s, value=%s", clientIndex, key, value));
   615 	RETURN_META(MRES_IGNORED);
   616 }
   617 
   618 int IsMapValid(char *filename) {
   619 	// more trace output in Post
   620 	ENGINE_TRACE(pfnIsMapValid, P_PRE, ("filename=%s", filename));
   621 	RETURN_META_VALUE(MRES_IGNORED, 0);
   622 }
   623 void StaticDecal( const float *origin, int decalIndex, int entityIndex, int modelIndex ) {
   624 	ENGINE_TRACE(pfnStaticDecal, P_PRE, (""));
   625 	RETURN_META(MRES_IGNORED);
   626 }
   627 int PrecacheGeneric(char *s) {
   628 	ENGINE_TRACE(pfnPrecacheGeneric, P_PRE, ("name=%s", s));
   629 	RETURN_META_VALUE(MRES_IGNORED, 0);
   630 }
   631 //! returns the server assigned userid for this player. useful for logging frags, etc. returns -1 if the edict couldn't be found in the list of clients
   632 int GetPlayerUserId(edict_t *e ) {
   633 	// more trace output in Post
   634 	edict_t *ed = e;
   635 	ENGINE_TRACE(pfnGetPlayerUserId, P_PRE, ("netname=%s",
   636 				ed ? STRING(ed->v.netname) : "nil"));
   637 	RETURN_META_VALUE(MRES_IGNORED, 0);
   638 }
   639 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) 
   640 {
   641 	ENGINE_TRACE(pfnBuildSoundMsg, P_PRE, ("sample=%s", sample));
   642 	RETURN_META(MRES_IGNORED);
   643 }
   644 //! is this a dedicated server?
   645 int IsDedicatedServer(void) {
   646 	ENGINE_TRACE(pfnIsDedicatedServer, P_PRE, (""));
   647 	RETURN_META_VALUE(MRES_IGNORED, 0);
   648 }
   649 cvar_t *CVarGetPointer(const char *szVarName) {
   650 	ENGINE_TRACE(pfnCVarGetPointer, P_PRE, ("cvar=%s", szVarName));
   651 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   652 }
   653 //! returns the server assigned WONid for this player. useful for logging frags, etc. returns -1 if the edict couldn't be found in the list of clients
   654 unsigned int GetPlayerWONId(edict_t *e) {
   655 	// more output in Post
   656 	edict_t *ed = e;
   657 	ENGINE_TRACE(pfnGetPlayerWONId, P_PRE, ("netname=%s",
   658 				ed ? STRING(ed->v.netname) : "nil"));
   659 	RETURN_META_VALUE(MRES_IGNORED, 0U);
   660 }
   661 
   662 //! YWB 8/1/99 TFF Physics additions
   663 void Info_RemoveKey( char *s, const char *key ) {
   664 	ENGINE_TRACE(pfnInfo_RemoveKey, P_PRE, ("key=%s", key));
   665 	RETURN_META(MRES_IGNORED);
   666 }
   667 const char *GetPhysicsKeyValue( const edict_t *pClient, const char *key ) {
   668 	ENGINE_TRACE(pfnGetPhysicsKeyValue, P_PRE, ("key=%s", key));
   669 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   670 }
   671 void SetPhysicsKeyValue( const edict_t *pClient, const char *key, const char *value ) {
   672 	ENGINE_TRACE(pfnSetPhysicsKeyValue, P_PRE, ("key=%s, value=%s", key, value));
   673 	RETURN_META(MRES_IGNORED);
   674 }
   675 const char *GetPhysicsInfoString( const edict_t *pClient ) {
   676 	ENGINE_TRACE(pfnGetPhysicsInfoString, P_PRE, (""));
   677 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   678 }
   679 unsigned short PrecacheEvent( int type, const char *psz ) {
   680 	ENGINE_TRACE(pfnPrecacheEvent, P_PRE, ("event=%s", psz));
   681 	RETURN_META_VALUE(MRES_IGNORED, 0U);
   682 }
   683 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 ) 
   684 {
   685 	ENGINE_TRACE(pfnPlaybackEvent, P_PRE, (""));
   686 	RETURN_META(MRES_IGNORED);
   687 }
   688 
   689 unsigned char *SetFatPVS( float *org ) {
   690 	ENGINE_TRACE(pfnSetFatPVS, P_PRE, (""));
   691 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   692 }
   693 unsigned char *SetFatPAS( float *org ) {
   694 	ENGINE_TRACE(pfnSetFatPAS, P_PRE, (""));
   695 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   696 }
   697 
   698 int CheckVisibility( const edict_t *entity, unsigned char *pset ) {
   699 	ENGINE_TRACE(pfnCheckVisibility, P_PRE, (""));
   700 	RETURN_META_VALUE(MRES_IGNORED, 0);
   701 }
   702 
   703 void DeltaSetField( struct delta_s *pFields, const char *fieldname ) {
   704 	ENGINE_TRACE(pfnDeltaSetField, P_PRE, ("field=%s", fieldname));
   705 	RETURN_META(MRES_IGNORED);
   706 }
   707 void DeltaUnsetField( struct delta_s *pFields, const char *fieldname ) {
   708 	ENGINE_TRACE(pfnDeltaUnsetField, P_PRE, ("field=%s", fieldname));
   709 	RETURN_META(MRES_IGNORED);
   710 }
   711 void DeltaAddEncoder( char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ) {
   712 	ENGINE_TRACE(pfnDeltaAddEncoder, P_PRE, (""));
   713 	RETURN_META(MRES_IGNORED);
   714 }
   715 int GetCurrentPlayer( void ) {
   716 	// trace output in Post
   717 	ENGINE_TRACE(pfnGetCurrentPlayer, P_PRE, (""));
   718 	RETURN_META_VALUE(MRES_IGNORED, 0);
   719 }
   720 int CanSkipPlayer( const edict_t *player ) {
   721 	ENGINE_TRACE(pfnCanSkipPlayer, P_PRE, (""));
   722 	RETURN_META_VALUE(MRES_IGNORED, 0);
   723 }
   724 int DeltaFindField( struct delta_s *pFields, const char *fieldname ) {
   725 	ENGINE_TRACE(pfnDeltaFindField, P_PRE, (""));
   726 	RETURN_META_VALUE(MRES_IGNORED, 0);
   727 }
   728 void DeltaSetFieldByIndex( struct delta_s *pFields, int fieldNumber ) {
   729 	ENGINE_TRACE(pfnDeltaSetFieldByIndex, P_PRE, (""));
   730 	RETURN_META(MRES_IGNORED);
   731 }
   732 void DeltaUnsetFieldByIndex( struct delta_s *pFields, int fieldNumber ) {
   733 	ENGINE_TRACE(pfnDeltaUnsetFieldByIndex, P_PRE, (""));
   734 	RETURN_META(MRES_IGNORED);
   735 }
   736 
   737 void SetGroupMask( int mask, int op ) {
   738 	ENGINE_TRACE(pfnSetGroupMask, P_PRE, (""));
   739 	RETURN_META(MRES_IGNORED);
   740 }
   741 
   742 int engCreateInstancedBaseline( int classname, struct entity_state_s *baseline ) {
   743 	ENGINE_TRACE(pfnCreateInstancedBaseline, P_PRE, (""));
   744 	RETURN_META_VALUE(MRES_IGNORED, 0);
   745 }
   746 void Cvar_DirectSet( struct cvar_s *var, char *value ) {
   747 	ENGINE_TRACE(pfnCvar_DirectSet, P_PRE, ("cvar=%s", var->name));
   748 	RETURN_META(MRES_IGNORED);
   749 }
   750 
   751 //! Forces the client and server to be running with the same version of the specified file
   752 //!( e.g., a player model ).
   753 //! Calling this has no effect in single player
   754 void ForceUnmodified( FORCE_TYPE type, float *mins, float *maxs, const char *filename ) {
   755 	ENGINE_TRACE(pfnForceUnmodified, P_PRE, ("file=%s", filename));
   756 	RETURN_META(MRES_IGNORED);
   757 }
   758 
   759 void GetPlayerStats( const edict_t *pClient, int *ping, int *packet_loss ) {
   760 	ENGINE_TRACE(pfnGetPlayerStats, P_PRE, ("name=%s", STRING(pClient->v.netname)));
   761 	RETURN_META(MRES_IGNORED);
   762 }
   763 
   764 void AddServerCommand( char *cmd_name, void (*function) (void) ) {
   765 	ENGINE_TRACE(pfnAddServerCommand, P_PRE, ("cmd=%s", cmd_name));
   766 	RETURN_META(MRES_IGNORED);
   767 }
   768 
   769 // Added in SDK 2.2:
   770 
   771 //! For voice communications, set which clients hear eachother.
   772 //! NOTE: these functions take player entity indices (starting at 1).
   773 qboolean Voice_GetClientListening(int iReceiver, int iSender) {
   774 	ENGINE_TRACE(pfnVoice_GetClientListening, P_PRE, (""));
   775 	RETURN_META_VALUE(MRES_IGNORED, false);
   776 }
   777 qboolean Voice_SetClientListening(int iReceiver, int iSender, qboolean bListen) {
   778 	ENGINE_TRACE(pfnVoice_SetClientListening, P_PRE, (""));
   779 	RETURN_META_VALUE(MRES_IGNORED, false);
   780 }
   781 
   782 // Added for HL 1109 (no SDK update):
   783 
   784 const char *GetPlayerAuthId(edict_t *e) {
   785 	// trace output in Post
   786 	ENGINE_TRACE(pfnGetPlayerAuthId, P_PRE, (""));
   787 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   788 }
   789 
   790 // Added 2003/11/10 (no SDK update):
   791 
   792 sequenceEntry_s*SequenceGet(const char* fileName, const char* entryName) {
   793 	ENGINE_TRACE(pfnSequenceGet, P_PRE, (""));
   794 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   795 }
   796 
   797 sentenceEntry_s *SequencePickSentence(const char* groupName, int pickMethod, int *picked) {
   798 	ENGINE_TRACE(pfnSequencePickSentence, P_PRE, (""));
   799 	RETURN_META_VALUE(MRES_IGNORED, NULL);
   800 }
   801 
   802 int GetFileSize(char *filename) {
   803 	ENGINE_TRACE(pfnGetFileSize, P_PRE, (""));
   804 	RETURN_META_VALUE(MRES_IGNORED, 0);
   805 }
   806 
   807 unsigned int GetApproxWavePlayLen(const char *filepath) {
   808 	ENGINE_TRACE(pfnGetApproxWavePlayLen, P_PRE, (""));
   809 	RETURN_META_VALUE(MRES_IGNORED, 0);
   810 }
   811 
   812 int IsCareerMatch(void) {
   813 	ENGINE_TRACE(pfnIsCareerMatch, P_PRE, (""));
   814 	RETURN_META_VALUE(MRES_IGNORED, 0);
   815 }
   816 
   817 int GetLocalizedStringLength(const char *label) {
   818 	ENGINE_TRACE(pfnGetLocalizedStringLength, P_PRE, (""));
   819 	RETURN_META_VALUE(MRES_IGNORED, 0);
   820 }
   821 
   822 void RegisterTutorMessageShown(int mid) {
   823 	ENGINE_TRACE(pfnRegisterTutorMessageShown, P_PRE, (""));
   824 	RETURN_META(MRES_IGNORED);
   825 }
   826 
   827 int GetTimesTutorMessageShown(int mid) {
   828 	ENGINE_TRACE(pfnGetTimesTutorMessageShown, P_PRE, (""));
   829 	RETURN_META_VALUE(MRES_IGNORED, 0);
   830 }
   831 
   832 void ProcessTutorMessageDecayBuffer(int *buffer, int bufferLength) {
   833 	ENGINE_TRACE(pfnProcessTutorMessageDecayBuffer, P_PRE, (""));
   834 	RETURN_META(MRES_IGNORED);
   835 }
   836 
   837 void ConstructTutorMessageDecayBuffer(int *buffer, int bufferLength) {
   838 	ENGINE_TRACE(pfnConstructTutorMessageDecayBuffer, P_PRE, (""));
   839 	RETURN_META(MRES_IGNORED);
   840 }
   841 
   842 void ResetTutorMessageDecayData(void) {
   843 	ENGINE_TRACE(pfnResetTutorMessageDecayData, P_PRE, (""));
   844 	RETURN_META(MRES_IGNORED);
   845 }
   846 
   847 void QueryClientCvarValue(const edict_t *pEdict, const char *cvarName)
   848 {
   849 	ENGINE_TRACE(pfnQueryClientCvarValue, P_PRE, ("queried=%s",cvarName?cvarName:"nil"));
   850 	RETURN_META(MRES_IGNORED);
   851 }
   852 
   853 enginefuncs_t meta_engfuncs = {
   854 	PrecacheModel,			// pfnPrecacheModel()
   855 	PrecacheSound,			// pfnPrecacheSound()
   856 	SetModel,				// pfnSetModel()
   857 	ModelIndex,				// pfnModelIndex()
   858 	ModelFrames,			// pfnModelFrames()
   859 
   860 	SetSize,				// pfnSetSize()
   861 	ChangeLevel,			// pfnChangeLevel()
   862 	GetSpawnParms,			// pfnGetSpawnParms()
   863 	SaveSpawnParms,			// pfnSaveSpawnParms()
   864 
   865 	VecToYaw,				// pfnVecToYaw()
   866 	VecToAngles,			// pfnVecToAngles()
   867 	MoveToOrigin,			// pfnMoveToOrigin()
   868 	ChangeYaw,				// pfnChangeYaw()
   869 	ChangePitch,			// pfnChangePitch()
   870 
   871 	FindEntityByString,		// pfnFindEntityByString()
   872 	GetEntityIllum,			// pfnGetEntityIllum()
   873 	FindEntityInSphere,		// pfnFindEntityInSphere()
   874 	FindClientInPVS,		// pfnFindClientInPVS()
   875 	EntitiesInPVS,			// pfnEntitiesInPVS()
   876 
   877 	MakeVectors,			// pfnMakeVectors()
   878 	AngleVectors,			// pfnAngleVectors()
   879 
   880 	CreateEntity,			// pfnCreateEntity()
   881 	RemoveEntity,			// pfnRemoveEntity()
   882 	CreateNamedEntity,		// pfnCreateNamedEntity()
   883 
   884 	MakeStatic,				// pfnMakeStatic()
   885 	EntIsOnFloor,			// pfnEntIsOnFloor()
   886 	DropToFloor,			// pfnDropToFloor()
   887 
   888 	WalkMove,				// pfnWalkMove()
   889 	SetOrigin,				// pfnSetOrigin()
   890 
   891 	EmitSound,				// pfnEmitSound()
   892 	EmitAmbientSound,		// pfnEmitAmbientSound()
   893 
   894 	TraceLine,				// pfnTraceLine()
   895 	TraceToss,				// pfnTraceToss()
   896 	TraceMonsterHull,		// pfnTraceMonsterHull()
   897 	TraceHull,				// pfnTraceHull()
   898 	TraceModel,				// pfnTraceModel()
   899 	TraceTexture,			// pfnTraceTexture()
   900 	TraceSphere,			// pfnTraceSphere()
   901 	GetAimVector,			// pfnGetAimVector()
   902 
   903 	ServerCommand,			// pfnServerCommand()
   904 	ServerExecute,			// pfnServerExecute()
   905 	engClientCommand,		// pfnClientCommand()	// d'oh, ClientCommand in dllapi too
   906 
   907 	ParticleEffect,			// pfnParticleEffect()
   908 	LightStyle,				// pfnLightStyle()
   909 	DecalIndex,				// pfnDecalIndex()
   910 	PointContents,			// pfnPointContents()
   911 
   912 	MessageBegin,			// pfnMessageBegin()
   913 	MessageEnd,				// pfnMessageEnd()
   914 
   915 	WriteByte,				// pfnWriteByte()
   916 	WriteChar,				// pfnWriteChar()
   917 	WriteShort,				// pfnWriteShort()
   918 	WriteLong,				// pfnWriteLong()
   919 	WriteAngle,				// pfnWriteAngle()
   920 	WriteCoord,				// pfnWriteCoord()
   921 	WriteString,			// pfnWriteString()
   922 	WriteEntity,			// pfnWriteEntity()
   923 
   924 	CVarRegister,			// pfnCVarRegister()
   925 	CVarGetFloat,			// pfnCVarGetFloat()
   926 	CVarGetString,			// pfnCVarGetString()
   927 	CVarSetFloat,			// pfnCVarSetFloat()
   928 	CVarSetString,			// pfnCVarSetString()
   929 
   930 	AlertMessage,			// pfnAlertMessage()
   931 	EngineFprintf,			// pfnEngineFprintf()
   932 
   933 	PvAllocEntPrivateData,	// pfnPvAllocEntPrivateData()
   934 	PvEntPrivateData,		// pfnPvEntPrivateData()
   935 	FreeEntPrivateData,		// pfnFreeEntPrivateData()
   936 
   937 	SzFromIndex,			// pfnSzFromIndex()
   938 	AllocString,			// pfnAllocString()
   939 
   940 	GetVarsOfEnt, 			// pfnGetVarsOfEnt()
   941 	PEntityOfEntOffset,		// pfnPEntityOfEntOffset()
   942 	EntOffsetOfPEntity,		// pfnEntOffsetOfPEntity()
   943 	IndexOfEdict,			// pfnIndexOfEdict()
   944 	PEntityOfEntIndex,		// pfnPEntityOfEntIndex()
   945 	FindEntityByVars,		// pfnFindEntityByVars()
   946 	GetModelPtr,			// pfnGetModelPtr()
   947 
   948 	RegUserMsg,				// pfnRegUserMsg()
   949 
   950 	AnimationAutomove,		// pfnAnimationAutomove()
   951 	GetBonePosition,		// pfnGetBonePosition()
   952 
   953 	FunctionFromName,		// pfnFunctionFromName()
   954 	NameForFunction,		// pfnNameForFunction()
   955 
   956 	ClientPrintf,			// pfnClientPrintf()			//! JOHN: engine callbacks so game DLL can print messages to individual clients
   957 	ServerPrint,			// pfnServerPrint()
   958 
   959 	Cmd_Args,				// pfnCmd_Args()				//! these 3 added 
   960 	Cmd_Argv,				// pfnCmd_Argv()				//! so game DLL can easily 
   961 	Cmd_Argc,				// pfnCmd_Argc()				//! access client 'cmd' strings
   962 
   963 	GetAttachment,			// pfnGetAttachment()
   964 
   965 	CRC32_Init,				// pfnCRC32_Init()
   966 	CRC32_ProcessBuffer,	// pfnCRC32_ProcessBuffer()
   967 	CRC32_ProcessByte,		// pfnCRC32_ProcessByte()
   968 	CRC32_Final,			// pfnCRC32_Final()
   969 
   970 	RandomLong,				// pfnRandomLong()
   971 	RandomFloat,			// pfnRandomFloat()
   972 
   973 	SetView,				// pfnSetView()
   974 	Time,					// pfnTime()
   975 	CrosshairAngle,			// pfnCrosshairAngle()
   976 
   977 	LoadFileForMe,			// pfnLoadFileForMe()
   978 	FreeFile,				// pfnFreeFile()
   979 
   980 	EndSection,				// pfnEndSection()				//! trigger_endsection
   981 	CompareFileTime,		// pfnCompareFileTime()
   982 	GetGameDir,				// pfnGetGameDir()
   983 	Cvar_RegisterVariable,	// pfnCvar_RegisterVariable()
   984 	FadeClientVolume,		// pfnFadeClientVolume()
   985 	SetClientMaxspeed,		// pfnSetClientMaxspeed()
   986 	CreateFakeClient,		// pfnCreateFakeClient() 		//! returns NULL if fake client can't be created
   987 	RunPlayerMove,			// pfnRunPlayerMove()
   988 	NumberOfEntities,		// pfnNumberOfEntities()
   989 
   990 	GetInfoKeyBuffer,		// pfnGetInfoKeyBuffer()		//! passing in NULL gets the serverinfo
   991 	InfoKeyValue,			// pfnInfoKeyValue()
   992 	SetKeyValue,			// pfnSetKeyValue()
   993 	SetClientKeyValue,		// pfnSetClientKeyValue()
   994 
   995 	IsMapValid,				// pfnIsMapValid()
   996 	StaticDecal,			// pfnStaticDecal()
   997 	PrecacheGeneric,		// pfnPrecacheGeneric()
   998 	GetPlayerUserId, 		// pfnGetPlayerUserId()			//! returns the server assigned userid for this player.
   999 	BuildSoundMsg,			// pfnBuildSoundMsg()
  1000 	IsDedicatedServer,		// pfnIsDedicatedServer()		//! is this a dedicated server?
  1001 	CVarGetPointer,			// pfnCVarGetPointer()
  1002 	GetPlayerWONId,			// pfnGetPlayerWONId()			//! returns the server assigned WONid for this player.
  1003 
  1004 	//! YWB 8/1/99 TFF Physics additions
  1005 	Info_RemoveKey,			// pfnInfo_RemoveKey()
  1006 	GetPhysicsKeyValue,		// pfnGetPhysicsKeyValue()
  1007 	SetPhysicsKeyValue,		// pfnSetPhysicsKeyValue()
  1008 	GetPhysicsInfoString,	// pfnGetPhysicsInfoString()
  1009 	PrecacheEvent,			// pfnPrecacheEvent()
  1010 	PlaybackEvent,			// pfnPlaybackEvent()
  1011 
  1012 	SetFatPVS,				// pfnSetFatPVS()
  1013 	SetFatPAS,				// pfnSetFatPAS()
  1014 
  1015 	CheckVisibility,		// pfnCheckVisibility()
  1016 
  1017 	DeltaSetField,			// pfnDeltaSetField()
  1018 	DeltaUnsetField,		// pfnDeltaUnsetField()
  1019 	DeltaAddEncoder,		// pfnDeltaAddEncoder()
  1020 	GetCurrentPlayer,		// pfnGetCurrentPlayer()
  1021 	CanSkipPlayer,			// pfnCanSkipPlayer()
  1022 	DeltaFindField,			// pfnDeltaFindField()
  1023 	DeltaSetFieldByIndex,	// pfnDeltaSetFieldByIndex()
  1024 	DeltaUnsetFieldByIndex,	// pfnDeltaUnsetFieldByIndex()
  1025 
  1026 	SetGroupMask,			// pfnSetGroupMask()
  1027 
  1028 	engCreateInstancedBaseline, // pfnCreateInstancedBaseline()		// d'oh, CreateInstancedBaseline in dllapi too
  1029 	Cvar_DirectSet,			// pfnCvar_DirectSet()
  1030 
  1031 	ForceUnmodified,		// pfnForceUnmodified()
  1032 
  1033 	GetPlayerStats,			// pfnGetPlayerStats()
  1034 
  1035 	AddServerCommand,		// pfnAddServerCommand()
  1036 
  1037 	// Added in SDK 2.2:
  1038 	Voice_GetClientListening,	// pfnVoice_GetClientListening()
  1039 	Voice_SetClientListening,	// pfnVoice_SetClientListening()
  1040 
  1041 	// Added for HL 1109 (no SDK update):
  1042 	GetPlayerAuthId,		// pfnGetPlayerAuthId()
  1043 
  1044 	// Added 2003/11/10 (no SDK update):
  1045 	SequenceGet,					// pfnSequenceGet()
  1046 	SequencePickSentence,			// pfnSequencePickSentence()
  1047 	GetFileSize,					// pfnGetFileSize()
  1048 	GetApproxWavePlayLen,			// pfnGetApproxWavePlayLen()
  1049 	IsCareerMatch,					// pfnIsCareerMatch()
  1050 	GetLocalizedStringLength,		// pfnGetLocalizedStringLength()
  1051 	RegisterTutorMessageShown,		// pfnRegisterTutorMessageShown()
  1052 	GetTimesTutorMessageShown,		// pfnGetTimesTutorMessageShown()
  1053 	ProcessTutorMessageDecayBuffer,	// pfnProcessTutorMessageDecayBuffer()
  1054 	ConstructTutorMessageDecayBuffer,	// pfnConstructTutorMessageDecayBuffer()
  1055 	ResetTutorMessageDecayData,		// pfnResetTutorMessageDecayData()
  1056 	QueryClientCvarValue,			// pfnQueryClientCvarValue()
  1057 };
  1058 
  1059 C_DLLEXPORT int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, 
  1060 		int *interfaceVersion) 
  1061 {
  1062 	LOG_DEVELOPER(PLID, "called: GetEngineFunctions; version=%d", 
  1063 			*interfaceVersion);
  1064 	if(!pengfuncsFromEngine) {
  1065 		LOG_ERROR(PLID, 
  1066 				"GetEngineFunctions called with null pengfuncsFromEngine");
  1067 		return(FALSE);
  1068 	}
  1069 	else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) {
  1070 		LOG_ERROR(PLID, 
  1071 				"GetEngineFunctions version mismatch; requested=%d ours=%d", 
  1072 				*interfaceVersion, ENGINE_INTERFACE_VERSION);
  1073 		// Tell metamod what version we had, so it can figure out who is 
  1074 		// out of date.
  1075 		*interfaceVersion = ENGINE_INTERFACE_VERSION;
  1076 		return(FALSE);
  1077 	}
  1078 	memcpy(pengfuncsFromEngine, &meta_engfuncs, sizeof(enginefuncs_t));
  1079 	return TRUE;
  1080 }