From d55bffede6547ffe92b409104606aebc57787599 Mon Sep 17 00:00:00 2001 From: Twilight Suzuka Date: Tue, 6 Dec 2005 22:47:02 +0000 Subject: [PATCH] *** empty log message *** --- dlls/BB/amxxmodule.cpp | 3051 ++++++++++++++++++++++++++++++++++++++++ dlls/BB/amxxmodule.h | 2239 +++++++++++++++++++++++++++++ dlls/BB/bb.cpp | 139 ++ dlls/BB/bb.h | 115 ++ dlls/BB/bb.inc | 47 + dlls/BB/bb.ncb | Bin 0 -> 191488 bytes dlls/BB/bb.sln | 21 + dlls/BB/bb.vcproj | 180 +++ dlls/BB/bb_const.h | 12 + dlls/BB/bb_const.inc | 26 + dlls/BB/bb_stocks.inc | 112 ++ dlls/BB/moduleconfig.h | 462 ++++++ dlls/BB/pdata.h | 29 + 13 files changed, 6433 insertions(+) create mode 100644 dlls/BB/amxxmodule.cpp create mode 100644 dlls/BB/amxxmodule.h create mode 100644 dlls/BB/bb.cpp create mode 100644 dlls/BB/bb.h create mode 100644 dlls/BB/bb.inc create mode 100644 dlls/BB/bb.ncb create mode 100644 dlls/BB/bb.sln create mode 100644 dlls/BB/bb.vcproj create mode 100644 dlls/BB/bb_const.h create mode 100644 dlls/BB/bb_const.inc create mode 100644 dlls/BB/bb_stocks.inc create mode 100644 dlls/BB/moduleconfig.h create mode 100644 dlls/BB/pdata.h diff --git a/dlls/BB/amxxmodule.cpp b/dlls/BB/amxxmodule.cpp new file mode 100644 index 00000000..c38a396b --- /dev/null +++ b/dlls/BB/amxxmodule.cpp @@ -0,0 +1,3051 @@ +/* AMX Mod X +* +* by the AMX Mod X Development Team +* originally developed by OLO +* +* Parts Copyright (C) 2001-2003 Will Day +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License as published by the +* Free Software Foundation; either version 2 of the License, or (at +* your option) any later version. +* +* This program is distributed in the hope that it will be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +* General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software Foundation, +* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +* +* In addition, as a special exception, the author gives permission to +* link the code of this program with the Half-Life Game Engine ("HL +* Engine") and Modified Game Libraries ("MODs") developed by Valve, +* L.L.C ("Valve"). You must obey the GNU General Public License in all +* respects for all of the code used other than the HL Engine and MODs +* from Valve. If you modify this file, you may extend this exception +* to your version of the file, but you are not obligated to do so. If +* you do not wish to do so, delete this exception statement from your +* version. +* +* Description: AMX Mod X Module Interface Functions +*/ + +#include +#include +#include +#include +#include +#include "amxxmodule.h" + +/************* METAMOD SUPPORT *************/ +#ifdef USE_METAMOD + +enginefuncs_t g_engfuncs; +globalvars_t *gpGlobals; + + + +DLL_FUNCTIONS *g_pFunctionTable; +DLL_FUNCTIONS *g_pFunctionTable_Post; +enginefuncs_t *g_pengfuncsTable; +enginefuncs_t *g_pengfuncsTable_Post; +NEW_DLL_FUNCTIONS *g_pNewFunctionsTable; +NEW_DLL_FUNCTIONS *g_pNewFunctionsTable_Post; + + +// GetEntityAPI2 functions +static DLL_FUNCTIONS g_EntityAPI_Table = +{ +#ifdef FN_GameDLLInit + FN_GameDLLInit, +#else + NULL, +#endif +#ifdef FN_DispatchSpawn + FN_DispatchSpawn, +#else + NULL, +#endif +#ifdef FN_DispatchThink + FN_DispatchThink, +#else + NULL, +#endif +#ifdef FN_DispatchUse + FN_DispatchUse, +#else + NULL, +#endif +#ifdef FN_DispatchTouch + FN_DispatchTouch, +#else + NULL, +#endif +#ifdef FN_DispatchBlocked + FN_DispatchBlocked, +#else + NULL, +#endif +#ifdef FN_DispatchKeyValue + FN_DispatchKeyValue, +#else + NULL, +#endif +#ifdef FN_DispatchSave + FN_DispatchSave, +#else + NULL, +#endif +#ifdef FN_DispatchRestore + FN_DispatchRestore, +#else + NULL, +#endif +#ifdef FN_DispatchObjectCollsionBox + FN_DispatchObjectCollsionBox, +#else + NULL, +#endif +#ifdef FN_SaveWriteFields + FN_SaveWriteFields, +#else + NULL, +#endif +#ifdef FN_SaveReadFields + FN_SaveReadFields, +#else + NULL, +#endif +#ifdef FN_SaveGlobalState + FN_SaveGlobalState, +#else + NULL, +#endif +#ifdef FN_RestoreGlobalState + FN_RestoreGlobalState, +#else + NULL, +#endif +#ifdef FN_ResetGlobalState + FN_ResetGlobalState, +#else + NULL, +#endif +#ifdef FN_ClientConnect + FN_ClientConnect, +#else + NULL, +#endif +#ifdef FN_ClientDisconnect + FN_ClientDisconnect, +#else + NULL, +#endif +#ifdef FN_ClientKill + FN_ClientKill, +#else + NULL, +#endif +#ifdef FN_ClientPutInServer + FN_ClientPutInServer, +#else + NULL, +#endif +#ifdef FN_ClientCommand + FN_ClientCommand, +#else + NULL, +#endif +#ifdef FN_ClientUserInfoChanged + FN_ClientUserInfoChanged, +#else + NULL, +#endif +#ifdef FN_ServerActivate + FN_ServerActivate, +#else + NULL, +#endif +#ifdef FN_ServerDeactivate + FN_ServerDeactivate, +#else + NULL, +#endif +#ifdef FN_PlayerPreThink + FN_PlayerPreThink, +#else + NULL, +#endif +#ifdef FN_PlayerPostThink + FN_PlayerPostThink, +#else + NULL, +#endif +#ifdef FN_StartFrame + FN_StartFrame, +#else + NULL, +#endif +#ifdef FN_ParmsNewLevel + FN_ParmsNewLevel, +#else + NULL, +#endif +#ifdef FN_ParmsChangeLevel + FN_ParmsChangeLevel, +#else + NULL, +#endif +#ifdef FN_GetGameDescription + FN_GetGameDescription, +#else + NULL, +#endif +#ifdef FN_PlayerCustomization + FN_PlayerCustomization, +#else + NULL, +#endif +#ifdef FN_SpectatorConnect + FN_SpectatorConnect, +#else + NULL, +#endif +#ifdef FN_SpectatorDisconnect + FN_SpectatorDisconnect, +#else + NULL, +#endif +#ifdef FN_SpectatorThink + FN_SpectatorThink, +#else + NULL, +#endif +#ifdef FN_Sys_Error + FN_Sys_Error, +#else + NULL, +#endif +#ifdef FN_PM_Move + FN_PM_Move, +#else + NULL, +#endif +#ifdef FN_PM_Init + FN_PM_Init, +#else + NULL, +#endif +#ifdef FN_PM_FindTextureType + FN_PM_FindTextureType, +#else + NULL, +#endif +#ifdef FN_SetupVisibility + FN_SetupVisibility, +#else + NULL, +#endif +#ifdef FN_UpdateClientData + FN_UpdateClientData, +#else + NULL, +#endif +#ifdef FN_AddToFullPack + FN_AddToFullPack, +#else + NULL, +#endif +#ifdef FN_CreateBaseline + FN_CreateBaseline, +#else + NULL, +#endif +#ifdef FN_RegisterEncoders + FN_RegisterEncoders, +#else + NULL, +#endif +#ifdef FN_GetWeaponData + FN_GetWeaponData, +#else + NULL, +#endif +#ifdef FN_CmdStart + FN_CmdStart, +#else + NULL, +#endif +#ifdef FN_CmdEnd + FN_CmdEnd, +#else + NULL, +#endif +#ifdef FN_ConnectionlessPacket + FN_ConnectionlessPacket, +#else + NULL, +#endif +#ifdef FN_GetHullBounds + FN_GetHullBounds, +#else + NULL, +#endif +#ifdef FN_CreateInstancedBaselines + FN_CreateInstancedBaselines, +#else + NULL, +#endif +#ifdef FN_InconsistentFile + FN_InconsistentFile, +#else + NULL, +#endif +#ifdef FN_AllowLagCompensation + FN_AllowLagCompensation +#else + NULL +#endif +}; // g_EntityAPI2_Table + +// GetEntityAPI2_Post functions +static DLL_FUNCTIONS g_EntityAPI_Post_Table = +{ +#ifdef FN_GameDLLInit_Post + FN_GameDLLInit_Post, +#else + NULL, +#endif +#ifdef FN_DispatchSpawn_Post + FN_DispatchSpawn_Post, +#else + NULL, +#endif +#ifdef FN_DispatchThink_Post + FN_DispatchThink_Post, +#else + NULL, +#endif +#ifdef FN_DispatchUse_Post + FN_DispatchUse_Post, +#else + NULL, +#endif +#ifdef FN_DispatchTouch_Post + FN_DispatchTouch_Post, +#else + NULL, +#endif +#ifdef FN_DispatchBlocked_Post + FN_DispatchBlocked_Post, +#else + NULL, +#endif +#ifdef FN_DispatchKeyValue_Post + FN_DispatchKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_DispatchSave_Post + FN_DispatchSave_Post, +#else + NULL, +#endif +#ifdef FN_DispatchRestore_Post + FN_DispatchRestore_Post, +#else + NULL, +#endif +#ifdef FN_DispatchObjectCollsionBox_Post + FN_DispatchObjectCollsionBox_Post, +#else + NULL, +#endif +#ifdef FN_SaveWriteFields_Post + FN_SaveWriteFields_Post, +#else + NULL, +#endif +#ifdef FN_SaveReadFields_Post + FN_SaveReadFields_Post, +#else + NULL, +#endif +#ifdef FN_SaveGlobalState_Post + FN_SaveGlobalState_Post, +#else + NULL, +#endif +#ifdef FN_RestoreGlobalState_Post + FN_RestoreGlobalState_Post, +#else + NULL, +#endif +#ifdef FN_ResetGlobalState_Post + FN_ResetGlobalState_Post, +#else + NULL, +#endif +#ifdef FN_ClientConnect_Post + FN_ClientConnect_Post, +#else + NULL, +#endif +#ifdef FN_ClientDisconnect_Post + FN_ClientDisconnect_Post, +#else + NULL, +#endif +#ifdef FN_ClientKill_Post + FN_ClientKill_Post, +#else + NULL, +#endif +#ifdef FN_ClientPutInServer_Post + FN_ClientPutInServer_Post, +#else + NULL, +#endif +#ifdef FN_ClientCommand_Post + FN_ClientCommand_Post, +#else + NULL, +#endif +#ifdef FN_ClientUserInfoChanged_Post + FN_ClientUserInfoChanged_Post, +#else + NULL, +#endif +#ifdef FN_ServerActivate_Post + FN_ServerActivate_Post, +#else + NULL, +#endif +#ifdef FN_ServerDeactivate_Post + FN_ServerDeactivate_Post, +#else + NULL, +#endif +#ifdef FN_PlayerPreThink_Post + FN_PlayerPreThink_Post, +#else + NULL, +#endif +#ifdef FN_PlayerPostThink_Post + FN_PlayerPostThink_Post, +#else + NULL, +#endif +#ifdef FN_StartFrame_Post + FN_StartFrame_Post, +#else + NULL, +#endif +#ifdef FN_ParmsNewLevel_Post + FN_ParmsNewLevel_Post, +#else + NULL, +#endif +#ifdef FN_ParmsChangeLevel_Post + FN_ParmsChangeLevel_Post, +#else + NULL, +#endif +#ifdef FN_GetGameDescription_Post + FN_GetGameDescription_Post, +#else + NULL, +#endif +#ifdef FN_PlayerCustomization_Post + FN_PlayerCustomization_Post, +#else + NULL, +#endif +#ifdef FN_SpectatorConnect_Post + FN_SpectatorConnect_Post, +#else + NULL, +#endif +#ifdef FN_SpectatorDisconnect_Post + FN_SpectatorDisconnect_Post, +#else + NULL, +#endif +#ifdef FN_SpectatorThink_Post + FN_SpectatorThink_Post, +#else + NULL, +#endif +#ifdef FN_Sys_Error_Post + FN_Sys_Error_Post, +#else + NULL, +#endif +#ifdef FN_PM_Move_Post + FN_PM_Move_Post, +#else + NULL, +#endif +#ifdef FN_PM_Init_Post + FN_PM_Init_Post, +#else + NULL, +#endif +#ifdef FN_PM_FindTextureType_Post + FN_PM_FindTextureType_Post, +#else + NULL, +#endif +#ifdef FN_SetupVisibility_Post + FN_SetupVisibility_Post, +#else + NULL, +#endif +#ifdef FN_UpdateClientData_Post + FN_UpdateClientData_Post, +#else + NULL, +#endif +#ifdef FN_AddToFullPack_Post + FN_AddToFullPack_Post, +#else + NULL, +#endif +#ifdef FN_CreateBaseline_Post + FN_CreateBaseline_Post, +#else + NULL, +#endif +#ifdef FN_RegisterEncoders_Post + FN_RegisterEncoders_Post, +#else + NULL, +#endif +#ifdef FN_GetWeaponData_Post + FN_GetWeaponData_Post, +#else + NULL, +#endif +#ifdef FN_CmdStart_Post + FN_CmdStart_Post, +#else + NULL, +#endif +#ifdef FN_CmdEnd_Post + FN_CmdEnd_Post, +#else + NULL, +#endif +#ifdef FN_ConnectionlessPacket_Post + FN_ConnectionlessPacket_Post, +#else + NULL, +#endif +#ifdef FN_GetHullBounds_Post + FN_GetHullBounds_Post, +#else + NULL, +#endif +#ifdef FN_CreateInstancedBaselines_Post + FN_CreateInstancedBaselines_Post, +#else + NULL, +#endif +#ifdef FN_InconsistentFile_Post + FN_InconsistentFile_Post, +#else + NULL, +#endif +#ifdef FN_AllowLagCompensation + FN_AllowLagCompensation, +#else + NULL, +#endif +}; // g_EntityAPI2_Table + +static enginefuncs_t g_EngineFuncs_Table = +{ +#ifdef FN_PrecacheModel + FN_PrecacheModel, +#else + NULL, +#endif +#ifdef FN_PrecacheSound + FN_PrecacheSound, +#else + NULL, +#endif +#ifdef FN_SetModel + FN_SetModel, +#else + NULL, +#endif +#ifdef FN_ModelIndex + FN_ModelIndex, +#else + NULL, +#endif +#ifdef FN_ModelFrames + FN_ModelFrames, +#else + NULL, +#endif +#ifdef FN_SetSize + FN_SetSize, +#else + NULL, +#endif +#ifdef FN_ChangeLevel + FN_ChangeLevel, +#else + NULL, +#endif +#ifdef FN_GetSpawnParms + FN_GetSpawnParms, +#else + NULL, +#endif +#ifdef FN_SaveSpawnParms + FN_SaveSpawnParms, +#else + NULL, +#endif +#ifdef FN_VecToYaw + FN_VecToYaw, +#else + NULL, +#endif +#ifdef FN_VecToAngles + FN_VecToAngles, +#else + NULL, +#endif +#ifdef FN_MoveToOrigin + FN_MoveToOrigin, +#else + NULL, +#endif +#ifdef FN_ChangeYaw + FN_ChangeYaw, +#else + NULL, +#endif +#ifdef FN_ChangePitch + FN_ChangePitch, +#else + NULL, +#endif +#ifdef FN_FindEntityByString + FN_FindEntityByString, +#else + NULL, +#endif +#ifdef FN_GetEntityIllum + FN_GetEntityIllum, +#else + NULL, +#endif +#ifdef FN_FindEntityInSphere + FN_FindEntityInSphere, +#else + NULL, +#endif +#ifdef FN_FindClientInPVS + FN_FindClientInPVS, +#else + NULL, +#endif +#ifdef FN_EntitiesInPVS + FN_EntitiesInPVS, +#else + NULL, +#endif +#ifdef FN_MakeVectors + FN_MakeVectors, +#else + NULL, +#endif +#ifdef FN_AngleVectors + FN_AngleVectors, +#else + NULL, +#endif +#ifdef FN_CreateEntity + FN_CreateEntity, +#else + NULL, +#endif +#ifdef FN_RemoveEntity + FN_RemoveEntity, +#else + NULL, +#endif +#ifdef FN_CreateNamedEntity + FN_CreateNamedEntity, +#else + NULL, +#endif +#ifdef FN_MakeStatic + FN_MakeStatic, +#else + NULL, +#endif +#ifdef FN_EntIsOnFloor + FN_EntIsOnFloor, +#else + NULL, +#endif +#ifdef FN_DropToFloor + FN_DropToFloor, +#else + NULL, +#endif +#ifdef FN_WalkMove + FN_WalkMove, +#else + NULL, +#endif +#ifdef FN_SetOrigin + FN_SetOrigin, +#else + NULL, +#endif +#ifdef FN_EmitSound + FN_EmitSound, +#else + NULL, +#endif +#ifdef FN_EmitAmbientSound + FN_EmitAmbientSound, +#else + NULL, +#endif +#ifdef FN_TraceLine + FN_TraceLine, +#else + NULL, +#endif +#ifdef FN_TraceToss + FN_TraceToss, +#else + NULL, +#endif +#ifdef FN_TraceMonsterHull + FN_TraceMonsterHull, +#else + NULL, +#endif +#ifdef FN_TraceHull + FN_TraceHull, +#else + NULL, +#endif +#ifdef FN_TraceModel + FN_TraceModel, +#else + NULL, +#endif +#ifdef FN_TraceTexture + FN_TraceTexture, +#else + NULL, +#endif +#ifdef FN_TraceSphere + FN_TraceSphere, +#else + NULL, +#endif +#ifdef FN_GetAimVector + FN_GetAimVector, +#else + NULL, +#endif +#ifdef FN_ServerCommand + FN_ServerCommand, +#else + NULL, +#endif +#ifdef FN_ServerExecute + FN_ServerExecute, +#else + NULL, +#endif +#ifdef FN_engClientCommand + FN_engClientCommand, +#else + NULL, +#endif +#ifdef FN_ParticleEffect + FN_ParticleEffect, +#else + NULL, +#endif +#ifdef FN_LightStyle + FN_LightStyle, +#else + NULL, +#endif +#ifdef FN_DecalIndex + FN_DecalIndex, +#else + NULL, +#endif +#ifdef FN_PointContents + FN_PointContents, +#else + NULL, +#endif +#ifdef FN_MessageBegin + FN_MessageBegin, +#else + NULL, +#endif +#ifdef FN_MessageEnd + FN_MessageEnd, +#else + NULL, +#endif +#ifdef FN_WriteByte + FN_WriteByte, +#else + NULL, +#endif +#ifdef FN_WriteChar + FN_WriteChar, +#else + NULL, +#endif +#ifdef FN_WriteShort + FN_WriteShort, +#else + NULL, +#endif +#ifdef FN_WriteLong + FN_WriteLong, +#else + NULL, +#endif +#ifdef FN_WriteAngle + FN_WriteAngle, +#else + NULL, +#endif +#ifdef FN_WriteCoord + FN_WriteCoord, +#else + NULL, +#endif +#ifdef FN_WriteString + FN_WriteString, +#else + NULL, +#endif +#ifdef FN_WriteEntity + FN_WriteEntity, +#else + NULL, +#endif +#ifdef FN_CVarRegister + FN_CVarRegister, +#else + NULL, +#endif +#ifdef FN_CVarGetFloat + FN_CVarGetFloat, +#else + NULL, +#endif +#ifdef FN_CVarGetString + FN_CVarGetString, +#else + NULL, +#endif +#ifdef FN_CVarSetFloat + FN_CVarSetFloat, +#else + NULL, +#endif +#ifdef FN_CVarSetString + FN_CVarSetString, +#else + NULL, +#endif +#ifdef FN_AlertMessage + FN_AlertMessage, +#else + NULL, +#endif +#ifdef FN_EngineFprintf + FN_EngineFprintf, +#else + NULL, +#endif +#ifdef FN_PvAllocEntPrivateData + FN_PvAllocEntPrivateData, +#else + NULL, +#endif +#ifdef FN_PvEntPrivateData + FN_PvEntPrivateData, +#else + NULL, +#endif +#ifdef FN_FreeEntPrivateData + FN_FreeEntPrivateData, +#else + NULL, +#endif +#ifdef FN_SzFromIndex + FN_SzFromIndex, +#else + NULL, +#endif +#ifdef FN_AllocString + FN_AllocString, +#else + NULL, +#endif +#ifdef FN_GetVarsOfEnt + FN_GetVarsOfEnt, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntOffset + FN_PEntityOfEntOffset, +#else + NULL, +#endif +#ifdef FN_EntOffsetOfPEntity + FN_EntOffsetOfPEntity, +#else + NULL, +#endif +#ifdef FN_IndexOfEdict + FN_IndexOfEdict, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntIndex + FN_PEntityOfEntIndex, +#else + NULL, +#endif +#ifdef FN_FindEntityByVars + FN_FindEntityByVars, +#else + NULL, +#endif +#ifdef FN_GetModelPtr + FN_GetModelPtr, +#else + NULL, +#endif +#ifdef FN_RegUserMsg + FN_RegUserMsg, +#else + NULL, +#endif +#ifdef FN_AnimationAutomove + FN_AnimationAutomove, +#else + NULL, +#endif +#ifdef FN_GetBonePosition + FN_GetBonePosition, +#else + NULL, +#endif +#ifdef FN_FunctionFromName + FN_FunctionFromName, +#else + NULL, +#endif +#ifdef FN_NameForFunction + FN_NameForFunction, +#else + NULL, +#endif +#ifdef FN_ClientPrintf + FN_ClientPrintf, +#else + NULL, +#endif +#ifdef FN_ServerPrint + FN_ServerPrint, +#else + NULL, +#endif +#ifdef FN_Cmd_Args + FN_Cmd_Args, +#else + NULL, +#endif +#ifdef FN_Cmd_Argv + FN_Cmd_Argv, +#else + NULL, +#endif +#ifdef FN_Cmd_Argc + FN_Cmd_Argc, +#else + NULL, +#endif +#ifdef FN_GetAttachment + FN_GetAttachment, +#else + NULL, +#endif +#ifdef FN_CRC32_Init + FN_CRC32_Init, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessBuffer + FN_CRC32_ProcessBuffer, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessByte + FN_CRC32_ProcessByte, +#else + NULL, +#endif +#ifdef FN_CRC32_Final + FN_CRC32_Final, +#else + NULL, +#endif +#ifdef FN_RandomLong + FN_RandomLong, +#else + NULL, +#endif +#ifdef FN_RandomFloat + FN_RandomFloat, +#else + NULL, +#endif +#ifdef FN_SetView + FN_SetView, +#else + NULL, +#endif +#ifdef FN_Time + FN_Time, +#else + NULL, +#endif +#ifdef FN_CrosshairAngle + FN_CrosshairAngle, +#else + NULL, +#endif +#ifdef FN_LoadFileForMe + FN_LoadFileForMe, +#else + NULL, +#endif +#ifdef FN_FreeFile + FN_FreeFile, +#else + NULL, +#endif +#ifdef FN_EndSection + FN_EndSection, +#else + NULL, +#endif +#ifdef FN_CompareFileTime + FN_CompareFileTime, +#else + NULL, +#endif +#ifdef FN_GetGameDir + FN_GetGameDir, +#else + NULL, +#endif +#ifdef FN_Cvar_RegisterVariable + FN_Cvar_RegisterVariable, +#else + NULL, +#endif +#ifdef FN_FadeClientVolume + FN_FadeClientVolume, +#else + NULL, +#endif +#ifdef FN_SetClientMaxspeed + FN_SetClientMaxspeed, +#else + NULL, +#endif +#ifdef FN_CreateFakeClient + FN_CreateFakeClient, +#else + NULL, +#endif +#ifdef FN_RunPlayerMove + FN_RunPlayerMove, +#else + NULL, +#endif +#ifdef FN_NumberOfEntities + FN_NumberOfEntities, +#else + NULL, +#endif +#ifdef FN_GetInfoKeyBuffer + FN_GetInfoKeyBuffer, +#else + NULL, +#endif +#ifdef FN_InfoKeyValue + FN_InfoKeyValue, +#else + NULL, +#endif +#ifdef FN_SetKeyValue + FN_SetKeyValue, +#else + NULL, +#endif +#ifdef FN_SetClientKeyValue + FN_SetClientKeyValue, +#else + NULL, +#endif +#ifdef FN_IsMapValid + FN_IsMapValid, +#else + NULL, +#endif +#ifdef FN_StaticDecal + FN_StaticDecal, +#else + NULL, +#endif +#ifdef FN_PrecacheGeneric + FN_PrecacheGeneric, +#else + NULL, +#endif +#ifdef FN_GetPlayerUserId + FN_GetPlayerUserId, +#else + NULL, +#endif +#ifdef FN_BuildSoundMsg + FN_BuildSoundMsg, +#else + NULL, +#endif +#ifdef FN_IsDedicatedServer + FN_IsDedicatedServer, +#else + NULL, +#endif +#ifdef FN_CVarGetPointer + FN_CVarGetPointer, +#else + NULL, +#endif +#ifdef FN_GetPlayerWONId + FN_GetPlayerWONId, +#else + NULL, +#endif +#ifdef FN_Info_RemoveKey + FN_Info_RemoveKey, +#else + NULL, +#endif +#ifdef FN_GetPhysicsKeyValue + FN_GetPhysicsKeyValue, +#else + NULL, +#endif +#ifdef FN_SetPhysicsKeyValue + FN_SetPhysicsKeyValue, +#else + NULL, +#endif +#ifdef FN_GetPhysicsInfoString + FN_GetPhysicsInfoString, +#else + NULL, +#endif +#ifdef FN_PrecacheEvent + FN_PrecacheEvent, +#else + NULL, +#endif +#ifdef FN_PlaybackEvent + FN_PlaybackEvent, +#else + NULL, +#endif +#ifdef FN_SetFatPVS + FN_SetFatPVS, +#else + NULL, +#endif +#ifdef FN_SetFatPAS + FN_SetFatPAS, +#else + NULL, +#endif +#ifdef FN_CheckVisibility + FN_CheckVisibility, +#else + NULL, +#endif +#ifdef FN_DeltaSetField + FN_DeltaSetField, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetField + FN_DeltaUnsetField, +#else + NULL, +#endif +#ifdef FN_DeltaAddEncoder + FN_DeltaAddEncoder, +#else + NULL, +#endif +#ifdef FN_GetCurrentPlayer + FN_GetCurrentPlayer, +#else + NULL, +#endif +#ifdef FN_CanSkipPlayer + FN_CanSkipPlayer, +#else + NULL, +#endif +#ifdef FN_DeltaFindField + FN_DeltaFindField, +#else + NULL, +#endif +#ifdef FN_DeltaSetFieldByIndex + FN_DeltaSetFieldByIndex, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetFieldByIndex + FN_DeltaUnsetFieldByIndex, +#else + NULL, +#endif +#ifdef FN_SetGroupMask + FN_SetGroupMask, +#else + NULL, +#endif +#ifdef FN_engCreateInstancedBaseline + FN_engCreateInstancedBaseline, +#else + NULL, +#endif +#ifdef FN_Cvar_DirectSet + FN_Cvar_DirectSet, +#else + NULL, +#endif +#ifdef FN_ForceUnmodified + FN_ForceUnmodified, +#else + NULL, +#endif +#ifdef FN_GetPlayerStats + FN_GetPlayerStats, +#else + NULL, +#endif +#ifdef FN_AddServerCommand + FN_AddServerCommand, +#else + NULL, +#endif +#ifdef FN_Voice_GetClientListening + FN_Voice_GetClientListening, +#else + NULL, +#endif +#ifdef FN_Voice_SetClientListening + FN_Voice_SetClientListening, +#else + NULL, +#endif +#ifdef FN_GetPlayerAuthId + FN_GetPlayerAuthId +#else + NULL +#endif +}; // g_EngineFuncs_Table + + +static enginefuncs_t g_EngineFuncs_Post_Table = +{ +#ifdef FN_PrecacheModel_Post + FN_PrecacheModel_Post, +#else + NULL, +#endif +#ifdef FN_PrecacheSound_Post + FN_PrecacheSound_Post, +#else + NULL, +#endif +#ifdef FN_SetModel_Post + FN_SetModel_Post, +#else + NULL, +#endif +#ifdef FN_ModelIndex_Post + FN_ModelIndex_Post, +#else + NULL, +#endif +#ifdef FN_ModelFrames_Post + FN_ModelFrames_Post, +#else + NULL, +#endif +#ifdef FN_SetSize_Post + FN_SetSize_Post, +#else + NULL, +#endif +#ifdef FN_ChangeLevel_Post + FN_ChangeLevel_Post, +#else + NULL, +#endif +#ifdef FN_GetSpawnParms_Post + FN_GetSpawnParms_Post, +#else + NULL, +#endif +#ifdef FN_SaveSpawnParms_Post + FN_SaveSpawnParms_Post, +#else + NULL, +#endif +#ifdef FN_VecToYaw_Post + FN_VecToYaw_Post, +#else + NULL, +#endif +#ifdef FN_VecToAngles_Post + FN_VecToAngles_Post, +#else + NULL, +#endif +#ifdef FN_MoveToOrigin_Post + FN_MoveToOrigin_Post, +#else + NULL, +#endif +#ifdef FN_ChangeYaw_Post + FN_ChangeYaw_Post, +#else + NULL, +#endif +#ifdef FN_ChangePitch_Post + FN_ChangePitch_Post, +#else + NULL, +#endif +#ifdef FN_FindEntityByString_Post + FN_FindEntityByString_Post, +#else + NULL, +#endif +#ifdef FN_GetEntityIllum_Post + FN_GetEntityIllum_Post, +#else + NULL, +#endif +#ifdef FN_FindEntityInSphere_Post + FN_FindEntityInSphere_Post, +#else + NULL, +#endif +#ifdef FN_FindClientInPVS_Post + FN_FindClientInPVS_Post, +#else + NULL, +#endif +#ifdef FN_EntitiesInPVS_Post + FN_EntitiesInPVS_Post, +#else + NULL, +#endif +#ifdef FN_MakeVectors_Post + FN_MakeVectors_Post, +#else + NULL, +#endif +#ifdef FN_AngleVectors_Post + FN_AngleVectors_Post, +#else + NULL, +#endif +#ifdef FN_CreateEntity_Post + FN_CreateEntity_Post, +#else + NULL, +#endif +#ifdef FN_RemoveEntity_Post + FN_RemoveEntity_Post, +#else + NULL, +#endif +#ifdef FN_CreateNamedEntity_Post + FN_CreateNamedEntity_Post, +#else + NULL, +#endif +#ifdef FN_MakeStatic_Post + FN_MakeStatic_Post, +#else + NULL, +#endif +#ifdef FN_EntIsOnFloor_Post + FN_EntIsOnFloor_Post, +#else + NULL, +#endif +#ifdef FN_DropToFloor_Post + FN_DropToFloor_Post, +#else + NULL, +#endif +#ifdef FN_WalkMove_Post + FN_WalkMove_Post, +#else + NULL, +#endif +#ifdef FN_SetOrigin_Post + FN_SetOrigin_Post, +#else + NULL, +#endif +#ifdef FN_EmitSound_Post + FN_EmitSound_Post, +#else + NULL, +#endif +#ifdef FN_EmitAmbientSound_Post + FN_EmitAmbientSound_Post, +#else + NULL, +#endif +#ifdef FN_TraceLine_Post + FN_TraceLine_Post, +#else + NULL, +#endif +#ifdef FN_TraceToss_Post + FN_TraceToss_Post, +#else + NULL, +#endif +#ifdef FN_TraceMonsterHull_Post + FN_TraceMonsterHull_Post, +#else + NULL, +#endif +#ifdef FN_TraceHull_Post + FN_TraceHull_Post, +#else + NULL, +#endif +#ifdef FN_TraceModel_Post + FN_TraceModel_Post, +#else + NULL, +#endif +#ifdef FN_TraceTexture_Post + FN_TraceTexture_Post, +#else + NULL, +#endif +#ifdef FN_TraceSphere_Post + FN_TraceSphere_Post, +#else + NULL, +#endif +#ifdef FN_GetAimVector_Post + FN_GetAimVector_Post, +#else + NULL, +#endif +#ifdef FN_ServerCommand_Post + FN_ServerCommand_Post, +#else + NULL, +#endif +#ifdef FN_ServerExecute_Post + FN_ServerExecute_Post, +#else + NULL, +#endif +#ifdef FN_engClientCommand_Post + FN_engClientCommand_Post, +#else + NULL, +#endif +#ifdef FN_ParticleEffect_Post + FN_ParticleEffect_Post, +#else + NULL, +#endif +#ifdef FN_LightStyle_Post + FN_LightStyle_Post, +#else + NULL, +#endif +#ifdef FN_DecalIndex_Post + FN_DecalIndex_Post, +#else + NULL, +#endif +#ifdef FN_PointContents_Post + FN_PointContents_Post, +#else + NULL, +#endif +#ifdef FN_MessageBegin_Post + FN_MessageBegin_Post, +#else + NULL, +#endif +#ifdef FN_MessageEnd_Post + FN_MessageEnd_Post, +#else + NULL, +#endif +#ifdef FN_WriteByte_Post + FN_WriteByte_Post, +#else + NULL, +#endif +#ifdef FN_WriteChar_Post + FN_WriteChar_Post, +#else + NULL, +#endif +#ifdef FN_WriteShort_Post + FN_WriteShort_Post, +#else + NULL, +#endif +#ifdef FN_WriteLong_Post + FN_WriteLong_Post, +#else + NULL, +#endif +#ifdef FN_WriteAngle_Post + FN_WriteAngle_Post, +#else + NULL, +#endif +#ifdef FN_WriteCoord_Post + FN_WriteCoord_Post, +#else + NULL, +#endif +#ifdef FN_WriteString_Post + FN_WriteString_Post, +#else + NULL, +#endif +#ifdef FN_WriteEntity_Post + FN_WriteEntity_Post, +#else + NULL, +#endif +#ifdef FN_CVarRegister_Post + FN_CVarRegister_Post, +#else + NULL, +#endif +#ifdef FN_CVarGetFloat_Post + FN_CVarGetFloat_Post, +#else + NULL, +#endif +#ifdef FN_CVarGetString_Post + FN_CVarGetString_Post, +#else + NULL, +#endif +#ifdef FN_CVarSetFloat_Post + FN_CVarSetFloat_Post, +#else + NULL, +#endif +#ifdef FN_CVarSetString_Post + FN_CVarSetString_Post, +#else + NULL, +#endif +#ifdef FN_AlertMessage_Post + FN_AlertMessage_Post, +#else + NULL, +#endif +#ifdef FN_EngineFprintf_Post + FN_EngineFprintf_Post, +#else + NULL, +#endif +#ifdef FN_PvAllocEntPrivateData_Post + FN_PvAllocEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_PvEntPrivateData_Post + FN_PvEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_FreeEntPrivateData_Post + FN_FreeEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_SzFromIndex_Post + FN_SzFromIndex_Post, +#else + NULL, +#endif +#ifdef FN_AllocString_Post + FN_AllocString_Post, +#else + NULL, +#endif +#ifdef FN_GetVarsOfEnt_Post + FN_GetVarsOfEnt_Post, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntOffset_Post + FN_PEntityOfEntOffset_Post, +#else + NULL, +#endif +#ifdef FN_EntOffsetOfPEntity_Post + FN_EntOffsetOfPEntity_Post, +#else + NULL, +#endif +#ifdef FN_IndexOfEdict_Post + FN_IndexOfEdict_Post, +#else + NULL, +#endif +#ifdef FN_PEntityOfEntIndex_Post + FN_PEntityOfEntIndex_Post, +#else + NULL, +#endif +#ifdef FN_FindEntityByVars_Post + FN_FindEntityByVars_Post, +#else + NULL, +#endif +#ifdef FN_GetModelPtr_Post + FN_GetModelPtr_Post, +#else + NULL, +#endif +#ifdef FN_RegUserMsg_Post + FN_RegUserMsg_Post, +#else + NULL, +#endif +#ifdef FN_AnimationAutomove_Post + FN_AnimationAutomove_Post, +#else + NULL, +#endif +#ifdef FN_GetBonePosition_Post + FN_GetBonePosition_Post, +#else + NULL, +#endif +#ifdef FN_FunctionFromName_Post + FN_FunctionFromName_Post, +#else + NULL, +#endif +#ifdef FN_NameForFunction_Post + FN_NameForFunction_Post, +#else + NULL, +#endif +#ifdef FN_ClientPrintf_Post + FN_ClientPrintf_Post, +#else + NULL, +#endif +#ifdef FN_ServerPrint_Post + FN_ServerPrint_Post, +#else + NULL, +#endif +#ifdef FN_Cmd_Args_Post + FN_Cmd_Args_Post, +#else + NULL, +#endif +#ifdef FN_Cmd_Argv_Post + FN_Cmd_Argv_Post, +#else + NULL, +#endif +#ifdef FN_Cmd_Argc_Post + FN_Cmd_Argc_Post, +#else + NULL, +#endif +#ifdef FN_GetAttachment_Post + FN_GetAttachment_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_Init_Post + FN_CRC32_Init_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessBuffer_Post + FN_CRC32_ProcessBuffer_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_ProcessByte_Post + FN_CRC32_ProcessByte_Post, +#else + NULL, +#endif +#ifdef FN_CRC32_Final_Post + FN_CRC32_Final_Post, +#else + NULL, +#endif +#ifdef FN_RandomLong_Post + FN_RandomLong_Post, +#else + NULL, +#endif +#ifdef FN_RandomFloat_Post + FN_RandomFloat_Post, +#else + NULL, +#endif +#ifdef FN_SetView_Post + FN_SetView_Post, +#else + NULL, +#endif +#ifdef FN_Time_Post + FN_Time_Post, +#else + NULL, +#endif +#ifdef FN_CrosshairAngle_Post + FN_CrosshairAngle_Post, +#else + NULL, +#endif +#ifdef FN_LoadFileForMe_Post + FN_LoadFileForMe_Post, +#else + NULL, +#endif +#ifdef FN_FreeFile_Post + FN_FreeFile_Post, +#else + NULL, +#endif +#ifdef FN_EndSection_Post + FN_EndSection_Post, +#else + NULL, +#endif +#ifdef FN_CompareFileTime_Post + FN_CompareFileTime_Post, +#else + NULL, +#endif +#ifdef FN_GetGameDir_Post + FN_GetGameDir_Post, +#else + NULL, +#endif +#ifdef FN_Cvar_RegisterVariable_Post + FN_Cvar_RegisterVariable_Post, +#else + NULL, +#endif +#ifdef FN_FadeClientVolume_Post + FN_FadeClientVolume_Post, +#else + NULL, +#endif +#ifdef FN_SetClientMaxspeed_Post + FN_SetClientMaxspeed_Post, +#else + NULL, +#endif +#ifdef FN_CreateFakeClient_Post + FN_CreateFakeClient_Post, +#else + NULL, +#endif +#ifdef FN_RunPlayerMove_Post + FN_RunPlayerMove_Post, +#else + NULL, +#endif +#ifdef FN_NumberOfEntities_Post + FN_NumberOfEntities_Post, +#else + NULL, +#endif +#ifdef FN_GetInfoKeyBuffer_Post + FN_GetInfoKeyBuffer_Post, +#else + NULL, +#endif +#ifdef FN_InfoKeyValue_Post + FN_InfoKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_SetKeyValue_Post + FN_SetKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_SetClientKeyValue_Post + FN_SetClientKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_IsMapValid_Post + FN_IsMapValid_Post, +#else + NULL, +#endif +#ifdef FN_StaticDecal_Post + FN_StaticDecal_Post, +#else + NULL, +#endif +#ifdef FN_PrecacheGeneric_Post + FN_PrecacheGeneric_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerUserId_Post + FN_GetPlayerUserId_Post, +#else + NULL, +#endif +#ifdef FN_BuildSoundMsg_Post + FN_BuildSoundMsg_Post, +#else + NULL, +#endif +#ifdef FN_IsDedicatedServer_Post + FN_IsDedicatedServer_Post, +#else + NULL, +#endif +#ifdef FN_CVarGetPointer_Post + FN_CVarGetPointer_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerWONId_Post + FN_GetPlayerWONId_Post, +#else + NULL, +#endif +#ifdef FN_Info_RemoveKey_Post + FN_Info_RemoveKey_Post, +#else + NULL, +#endif +#ifdef FN_GetPhysicsKeyValue_Post + FN_GetPhysicsKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_SetPhysicsKeyValue_Post + FN_SetPhysicsKeyValue_Post, +#else + NULL, +#endif +#ifdef FN_GetPhysicsInfoString_Post + FN_GetPhysicsInfoString_Post, +#else + NULL, +#endif +#ifdef FN_PrecacheEvent_Post + FN_PrecacheEvent_Post, +#else + NULL, +#endif +#ifdef FN_PlaybackEvent_Post + FN_PlaybackEvent_Post, +#else + NULL, +#endif +#ifdef FN_SetFatPVS_Post + FN_SetFatPVS_Post, +#else + NULL, +#endif +#ifdef FN_SetFatPAS_Post + FN_SetFatPAS_Post, +#else + NULL, +#endif +#ifdef FN_CheckVisibility_Post + FN_CheckVisibility_Post, +#else + NULL, +#endif +#ifdef FN_DeltaSetField_Post + FN_DeltaSetField_Post, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetField_Post + FN_DeltaUnsetField_Post, +#else + NULL, +#endif +#ifdef FN_DeltaAddEncoder_Post + FN_DeltaAddEncoder_Post, +#else + NULL, +#endif +#ifdef FN_GetCurrentPlayer_Post + FN_GetCurrentPlayer_Post, +#else + NULL, +#endif +#ifdef FN_CanSkipPlayer_Post + FN_CanSkipPlayer_Post, +#else + NULL, +#endif +#ifdef FN_DeltaFindField_Post + FN_DeltaFindField_Post, +#else + NULL, +#endif +#ifdef FN_DeltaSetFieldByIndex_Post + FN_DeltaSetFieldByIndex_Post, +#else + NULL, +#endif +#ifdef FN_DeltaUnsetFieldByIndex_Post + FN_DeltaUnsetFieldByIndex_Post, +#else + NULL, +#endif +#ifdef FN_SetGroupMask_Post + FN_SetGroupMask_Post, +#else + NULL, +#endif +#ifdef FN_engCreateInstancedBaseline_Post + FN_engCreateInstancedBaseline_Post, +#else + NULL, +#endif +#ifdef FN_Cvar_DirectSet_Post + FN_Cvar_DirectSet_Post, +#else + NULL, +#endif +#ifdef FN_ForceUnmodified_Post + FN_ForceUnmodified_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerStats_Post + FN_GetPlayerStats_Post, +#else + NULL, +#endif +#ifdef FN_AddServerCommand_Post + FN_AddServerCommand_Post, +#else + NULL, +#endif +#ifdef FN_Voice_GetClientListening_Post + FN_Voice_GetClientListening_Post, +#else + NULL, +#endif +#ifdef FN_Voice_SetClientListening_Post + FN_Voice_SetClientListening_Post, +#else + NULL, +#endif +#ifdef FN_GetPlayerAuthId_Post + FN_GetPlayerAuthId_Post +#else + NULL +#endif +}; // g_EngineFuncs_Post_Table + + +static NEW_DLL_FUNCTIONS g_NewFuncs_Table = +{ +#ifdef FN_OnFreeEntPrivateData + FN_OnFreeEntPrivateData, +#else + NULL, +#endif +#ifdef FN_GameShutdown + FN_GameShutdown, +#else + NULL, +#endif +#ifdef FN_ShouldCollide + ShouldCollide, +#else + NULL, +#endif +}; + + +static NEW_DLL_FUNCTIONS g_NewFuncs_Post_Table = +{ +#ifdef FN_OnFreeEntPrivateData_Post + FN_OnFreeEntPrivateData_Post, +#else + NULL, +#endif +#ifdef FN_GameShutdown_Post + FN_GameShutdown_Post, +#else + NULL, +#endif +#ifdef FN_ShouldCollide_Post + ShouldCollide_Post, +#else + NULL, +#endif +}; + +// Global variables from metamod. These variable names are referenced by +// various macros. +meta_globals_t *gpMetaGlobals; // metamod globals +gamedll_funcs_t *gpGamedllFuncs; // gameDLL function tables +mutil_funcs_t *gpMetaUtilFuncs; // metamod utility functions + + +plugin_info_t Plugin_info = { + META_INTERFACE_VERSION, + MODULE_NAME, + MODULE_VERSION, + MODULE_DATE, + MODULE_AUTHOR, + MODULE_URL, + MODULE_LOGTAG, + PT_ANYTIME, + PT_ANYTIME +}; + +/* +C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI; version=%d", interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI called with null pFunctionTable"); + return(FALSE); + } + else if(interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEntityAPI version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION); + return(FALSE); + } + memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof( DLL_FUNCTIONS ) ); + + return (TRUE); +} + +C_DLLEXPORT int GetEntityAPI_Post(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI_Post; version=%d", interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI_Post called with null pFunctionTable"); + return(FALSE); + } + else if(interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEntityAPI_Post version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION); + return(FALSE); + } + memcpy(pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) ); + + return(TRUE); +} +*/ + +C_DLLEXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI2; version=%d", *interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI2 called with null pFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, + "GetEntityAPI2 version mismatch; requested=%d ours=%d", + *interfaceVersion, INTERFACE_VERSION); + //! Tell engine what version we had, so it can figure out who is + //! out of date. + *interfaceVersion = INTERFACE_VERSION; + return(FALSE); + } + memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof(DLL_FUNCTIONS)); + g_pFunctionTable=pFunctionTable; + return(TRUE); +} + +C_DLLEXPORT int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEntityAPI2_Post; version=%d", *interfaceVersion); + if(!pFunctionTable) { + LOG_ERROR(PLID, "GetEntityAPI2_Post called with null pFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEntityAPI2_Post version mismatch; requested=%d ours=%d", *interfaceVersion, INTERFACE_VERSION); + //! Tell engine what version we had, so it can figure out who is out of date. + *interfaceVersion = INTERFACE_VERSION; + return(FALSE); + } + memcpy( pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) ); + g_pFunctionTable_Post=pFunctionTable; + return(TRUE); +} + +C_DLLEXPORT int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEngineFunctions; version=%d", + *interfaceVersion); + if(!pengfuncsFromEngine) { + LOG_ERROR(PLID, + "GetEngineFunctions called with null pengfuncsFromEngine"); + return(FALSE); + } + else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) { + LOG_ERROR(PLID, + "GetEngineFunctions version mismatch; requested=%d ours=%d", + *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, &g_EngineFuncs_Table, sizeof(enginefuncs_t)); + g_pengfuncsTable=pengfuncsFromEngine; + return TRUE; +} + +C_DLLEXPORT int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetEngineFunctions_Post; version=%d", *interfaceVersion); + if(!pengfuncsFromEngine) { + LOG_ERROR(PLID, "GetEngineFunctions_Post called with null pengfuncsFromEngine"); + return(FALSE); + } + else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) { + LOG_ERROR(PLID, "GetEngineFunctions_Post version mismatch; requested=%d ours=%d", *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, &g_EngineFuncs_Post_Table, sizeof(enginefuncs_t)); + g_pengfuncsTable_Post=pengfuncsFromEngine; + return TRUE; + +} + +C_DLLEXPORT int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable, + int *interfaceVersion) +{ + LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions; version=%d", + *interfaceVersion); + if(!pNewFunctionTable) { + LOG_ERROR(PLID, + "GetNewDLLFunctions called with null pNewFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) { + LOG_ERROR(PLID, + "GetNewDLLFunctions version mismatch; requested=%d ours=%d", + *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION); + //! Tell engine what version we had, so it can figure out who is + //! out of date. + *interfaceVersion = NEW_DLL_FUNCTIONS_VERSION; + return(FALSE); + } + memcpy(pNewFunctionTable, &g_NewFuncs_Table, sizeof(NEW_DLL_FUNCTIONS)); + g_pNewFunctionsTable=pNewFunctionTable; + return TRUE; +} + +C_DLLEXPORT int GetNewDLLFunctions_Post( NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion ) +{ + LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions_Post; version=%d", *interfaceVersion); + if(!pNewFunctionTable) { + LOG_ERROR(PLID, "GetNewDLLFunctions_Post called with null pNewFunctionTable"); + return(FALSE); + } + else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) { + LOG_ERROR(PLID, "GetNewDLLFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION); + //! Tell engine what version we had, so it can figure out who is out of date. + *interfaceVersion = NEW_DLL_FUNCTIONS_VERSION; + return(FALSE); + } + memcpy(pNewFunctionTable, &g_NewFuncs_Post_Table, sizeof(NEW_DLL_FUNCTIONS)); + g_pNewFunctionsTable_Post=pNewFunctionTable; + return TRUE; +} + + +static META_FUNCTIONS g_MetaFunctions_Table = +{ + NULL, + NULL, + GetEntityAPI2, + GetEntityAPI2_Post, + GetNewDLLFunctions, + GetNewDLLFunctions_Post, + GetEngineFunctions, + GetEngineFunctions_Post +}; + +C_DLLEXPORT int Meta_Query(char *ifvers, plugin_info_t **pPlugInfo, mutil_funcs_t *pMetaUtilFuncs) +{ + if ((int) CVAR_GET_FLOAT("developer") != 0) + UTIL_LogPrintf("[%s] dev: called: Meta_Query; version=%s, ours=%s\n", + Plugin_info.logtag, ifvers, Plugin_info.ifvers); + + // Check for valid pMetaUtilFuncs before we continue. + if(!pMetaUtilFuncs) { + UTIL_LogPrintf("[%s] ERROR: Meta_Query called with null pMetaUtilFuncs\n", Plugin_info.logtag); + return(FALSE); + } + + gpMetaUtilFuncs = pMetaUtilFuncs; + + *pPlugInfo = &Plugin_info; + + // Check for interface version compatibility. + if(!FStrEq(ifvers, Plugin_info.ifvers)) { + int mmajor=0, mminor=0, pmajor=0, pminor=0; + LOG_MESSAGE(PLID, "WARNING: meta-interface version mismatch; requested=%s ours=%s", + Plugin_info.logtag, ifvers); + // If plugin has later interface version, it's incompatible (update + // metamod). + sscanf(ifvers, "%d:%d", &mmajor, &mminor); + sscanf(META_INTERFACE_VERSION, "%d:%d", &pmajor, &pminor); + if(pmajor > mmajor || (pmajor==mmajor && pminor > mminor)) { + LOG_ERROR(PLID, "metamod version is too old for this module; update metamod"); + return(FALSE); + } + // If plugin has older major interface version, it's incompatible + // (update plugin). + else if(pmajor < mmajor) { + LOG_ERROR(PLID, "metamod version is incompatible with this module; please find a newer version of this module"); + return(FALSE); + } + // Minor interface is older, but this is guaranteed to be backwards + // compatible, so we warn, but we still accept it. + else if(pmajor==mmajor && pminor < mminor) + LOG_MESSAGE(PLID, "WARNING: metamod version is newer than expected; consider finding a newer version of this module"); + else + LOG_ERROR(PLID, "unexpected version comparison; metavers=%s, mmajor=%d, mminor=%d; plugvers=%s, pmajor=%d, pminor=%d", ifvers, mmajor, mminor, META_INTERFACE_VERSION, pmajor, pminor); + } + +#ifdef FN_META_QUERY + return FN_META_QUERY(); +#endif // FN_META_QUERY + + return 1; +} + + +C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now, META_FUNCTIONS *pFunctionTable, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs) +{ + if(now > Plugin_info.loadable) { + LOG_ERROR(PLID, "Can't load module right now"); + return(FALSE); + } + if(!pMGlobals) { + LOG_ERROR(PLID, "Meta_Attach called with null pMGlobals"); + return(FALSE); + } + gpMetaGlobals=pMGlobals; + if(!pFunctionTable) { + LOG_ERROR(PLID, "Meta_Attach called with null pFunctionTable"); + return(FALSE); + } + + memcpy(pFunctionTable, &g_MetaFunctions_Table, sizeof(META_FUNCTIONS)); + gpGamedllFuncs=pGamedllFuncs; + + // Let's go. + +#ifdef FN_META_ATTACH + FN_META_ATTACH(); +#endif // FN_META_ATTACH + + return TRUE; +} + +C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason) +{ + if(now > Plugin_info.unloadable && reason != PNL_CMD_FORCED) { + LOG_ERROR(PLID, "Can't unload plugin right now"); + return(FALSE); + } + +#ifdef FN_META_DETACH + return FN_META_DETACH(); +#endif // FN_META_DETACH + return TRUE; +} + + + +#ifdef __linux__ +// linux prototype +C_DLLEXPORT void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) { + +#else +#ifdef _MSC_VER +// MSVC: Simulate __stdcall calling convention +C_DLLEXPORT __declspec(naked) void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) +{ + __asm // Prolog + { + // Save ebp + push ebp + // Set stack frame pointer + mov ebp, esp + // Allocate space for local variables + // The MSVC compiler gives us the needed size in __LOCAL_SIZE. + sub esp, __LOCAL_SIZE + // Push registers + push ebx + push esi + push edi + } +#else // _MSC_VER +#ifdef __GNUC__ +// GCC can also work with this +C_DLLEXPORT void __stdcall GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) +{ +#else // __GNUC__ +// compiler not known +#error There is no support (yet) for your compiler. Please use MSVC or GCC compilers or contact the AMX Mod X dev team. +#endif // __GNUC__ +#endif // _MSC_VER +#endif // __linux__ + + // ** Function core <-- + memcpy(&g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t)); + gpGlobals = pGlobals; + // NOTE! Have to call logging function _after_ copying into g_engfuncs, so + // that g_engfuncs.pfnAlertMessage() can be resolved properly, heh. :) + UTIL_LogPrintf("[%s] dev: called: GiveFnptrsToDll\n", Plugin_info.logtag); + // --> ** Function core + +#ifdef _MSC_VER + // Epilog + if (sizeof(int*) == 8) + { // 64 bit + __asm + { + // Pop registers + pop edi + pop esi + pop ebx + // Restore stack frame pointer + mov esp, ebp + // Restore ebp + pop ebp + // 2 * sizeof(int*) = 16 on 64 bit + ret 16 + } + } + else + { // 32 bit + __asm + { + // Pop registers + pop edi + pop esi + pop ebx + // Restore stack frame pointer + mov esp, ebp + // Restore ebp + pop ebp + // 2 * sizeof(int*) = 8 on 32 bit + ret 8 + } + } +#endif // #ifdef _MSC_VER +} + +#endif // #ifdef USE_METAMOD + +/************* AMXX Stuff *************/ + +// *** Globals *** +// Module info +static amxx_module_info_s g_ModuleInfo = +{ + MODULE_NAME, + MODULE_AUTHOR, + MODULE_VERSION, +#ifdef MODULE_RELOAD_ON_MAPCHANGE + 1, +#else // MODULE_RELOAD_ON_MAPCHANGE + 0, +#endif // MODULE_RELOAD_ON_MAPCHANGE + MODULE_LOGTAG +}; + +// Storage for the requested functions +PFN_ADD_NATIVES g_fn_AddNatives; +PFN_BUILD_PATHNAME g_fn_BuildPathname; +PFN_BUILD_PATHNAME_R g_fn_BuildPathnameR; +PFN_GET_AMXADDR g_fn_GetAmxAddr; +PFN_PRINT_SRVCONSOLE g_fn_PrintSrvConsole; +PFN_GET_MODNAME g_fn_GetModname; +PFN_GET_AMXSCRIPTNAME g_fn_GetAmxScriptName; +PFN_GET_AMXSCRIPT g_fn_GetAmxScript; +PFN_FIND_AMXSCRIPT_BYAMX g_fn_FindAmxScriptByAmx; +PFN_FIND_AMXSCRIPT_BYNAME g_fn_FindAmxScriptByName; +PFN_SET_AMXSTRING g_fn_SetAmxString; +PFN_GET_AMXSTRING g_fn_GetAmxString; +PFN_GET_AMXSTRINGLEN g_fn_GetAmxStringLen; +PFN_FORMAT_AMXSTRING g_fn_FormatAmxString; +PFN_COPY_AMXMEMORY g_fn_CopyAmxMemory; +PFN_LOG g_fn_Log; +PFN_LOG_ERROR g_fn_LogErrorFunc; +PFN_RAISE_AMXERROR g_fn_RaiseAmxError; +PFN_REGISTER_FORWARD g_fn_RegisterForward; +PFN_EXECUTE_FORWARD g_fn_ExecuteForward; +PFN_PREPARE_CELLARRAY g_fn_PrepareCellArray; +PFN_PREPARE_CHARARRAY g_fn_PrepareCharArray; +PFN_PREPARE_CELLARRAY_A g_fn_PrepareCellArrayA; +PFN_PREPARE_CHARARRAY_A g_fn_PrepareCharArrayA; +PFN_IS_PLAYER_VALID g_fn_IsPlayerValid; +PFN_GET_PLAYER_NAME g_fn_GetPlayerName; +PFN_GET_PLAYER_IP g_fn_GetPlayerIP; +PFN_IS_PLAYER_INGAME g_fn_IsPlayerIngame; +PFN_IS_PLAYER_BOT g_fn_IsPlayerBot; +PFN_IS_PLAYER_AUTHORIZED g_fn_IsPlayerAuthorized; +PFN_GET_PLAYER_TIME g_fn_GetPlayerTime; +PFN_GET_PLAYER_PLAYTIME g_fn_GetPlayerPlayTime; +PFN_GET_PLAYER_CURWEAPON g_fn_GetPlayerCurweapon; +PFN_GET_PLAYER_TEAM g_fn_GetPlayerTeam; +PFN_GET_PLAYER_TEAMID g_fn_GetPlayerTeamID; +PFN_GET_PLAYER_DEATHS g_fn_GetPlayerDeaths; +PFN_GET_PLAYER_MENU g_fn_GetPlayerMenu; +PFN_GET_PLAYER_KEYS g_fn_GetPlayerKeys; +PFN_IS_PLAYER_ALIVE g_fn_IsPlayerAlive; +PFN_GET_PLAYER_FRAGS g_fn_GetPlayerFrags; +PFN_IS_PLAYER_CONNECTING g_fn_IsPlayerConnecting; +PFN_IS_PLAYER_HLTV g_fn_IsPlayerHLTV; +PFN_GET_PLAYER_ARMOR g_fn_GetPlayerArmor; +PFN_GET_PLAYER_HEALTH g_fn_GetPlayerHealth; +PFN_ALLOCATOR g_fn_Allocator; +PFN_REALLOCATOR g_fn_Reallocator; +PFN_DEALLOCATOR g_fn_Deallocator; +PFN_AMX_EXEC g_fn_AmxExec; +PFN_AMX_EXECV g_fn_AmxExecv; +PFN_AMX_ALLOT g_fn_AmxAllot; +PFN_AMX_FINDPUBLIC g_fn_AmxFindPublic; +PFN_LOAD_AMXSCRIPT g_fn_LoadAmxScript; +PFN_UNLOAD_AMXSCRIPT g_fn_UnloadAmxScript; +PFN_REAL_TO_CELL g_fn_RealToCell; +PFN_CELL_TO_REAL g_fn_CellToReal; +PFN_REGISTER_SPFORWARD g_fn_RegisterSPForward; +PFN_REGISTER_SPFORWARD_BYNAME g_fn_RegisterSPForwardByName; +PFN_UNREGISTER_SPFORWARD g_fn_UnregisterSPForward; +PFN_MERGEDEFINITION_FILE g_fn_MergeDefinition_File; +PFN_AMX_FINDNATIVE g_fn_AmxFindNative; +PFN_GETPLAYERFLAGS g_fn_GetPlayerFlags; +PFN_GET_PLAYER_EDICT g_fn_GetPlayerEdict; +PFN_FORMAT g_fn_Format; +PFN_REGISTERFUNCTION g_fn_RegisterFunction; +PFN_REQ_FNPTR g_fn_RequestFunction; +PFN_AMX_PUSH g_fn_AmxPush; + +// *** Exports *** +C_DLLEXPORT int AMXX_Query(int *interfaceVersion, amxx_module_info_s *moduleInfo) +{ + // check parameters + if (!interfaceVersion || !moduleInfo) + return AMXX_PARAM; + + // check interface version + if (*interfaceVersion != AMXX_INTERFACE_VERSION) + { + // Tell amxx core our interface version + *interfaceVersion = AMXX_INTERFACE_VERSION; + return AMXX_IFVERS; + } + + // copy module info + memcpy(moduleInfo, &g_ModuleInfo, sizeof(amxx_module_info_s)); + +#ifdef FN_AMXX_QUERY + FN_AMXX_QUERY(); +#endif // FN_AMXX_QUERY + // Everything ok :) + return AMXX_OK; +} + +// request function +#define REQFUNC(name, fptr, type) if ((fptr = (type)reqFnptrFunc(name)) == 0) return AMXX_FUNC_NOT_PRESENT +// request optional function +#define REQFUNC_OPT(name, fptr, type) fptr = (type)reqFnptrFunc(name) + +C_DLLEXPORT int AMXX_Attach(PFN_REQ_FNPTR reqFnptrFunc) +{ + // Check pointer + if (!reqFnptrFunc) + return AMXX_PARAM; + + g_fn_RequestFunction = reqFnptrFunc; + + // Req all known functions + // Misc + REQFUNC("BuildPathname", g_fn_BuildPathname, PFN_BUILD_PATHNAME); + REQFUNC("BuildPathnameR", g_fn_BuildPathnameR, PFN_BUILD_PATHNAME_R); + REQFUNC("PrintSrvConsole", g_fn_PrintSrvConsole, PFN_PRINT_SRVCONSOLE); + REQFUNC("GetModname", g_fn_GetModname, PFN_GET_MODNAME); + REQFUNC("Log", g_fn_Log, PFN_LOG); + REQFUNC("LogError", g_fn_LogErrorFunc, PFN_LOG_ERROR); + REQFUNC("MergeDefinitionFile", g_fn_MergeDefinition_File, PFN_MERGEDEFINITION_FILE); + REQFUNC("Format", g_fn_Format, PFN_FORMAT); + REQFUNC("RegisterFunction", g_fn_RegisterFunction, PFN_REGISTERFUNCTION); + + // Amx scripts + REQFUNC("GetAmxScript", g_fn_GetAmxScript, PFN_GET_AMXSCRIPT); + REQFUNC("FindAmxScriptByAmx", g_fn_FindAmxScriptByAmx, PFN_FIND_AMXSCRIPT_BYAMX); + REQFUNC("FindAmxScriptByName", g_fn_FindAmxScriptByName, PFN_FIND_AMXSCRIPT_BYNAME); + REQFUNC("LoadAmxScript", g_fn_LoadAmxScript, PFN_LOAD_AMXSCRIPT); + REQFUNC("UnloadAmxScript", g_fn_UnloadAmxScript, PFN_UNLOAD_AMXSCRIPT); + REQFUNC("GetAmxScriptName", g_fn_GetAmxScriptName, PFN_GET_AMXSCRIPTNAME); + + // String / mem in amx scripts support + REQFUNC("SetAmxString", g_fn_SetAmxString, PFN_SET_AMXSTRING); + REQFUNC("GetAmxString", g_fn_GetAmxString, PFN_GET_AMXSTRING); + REQFUNC("GetAmxStringLen", g_fn_GetAmxStringLen, PFN_GET_AMXSTRINGLEN); + REQFUNC("FormatAmxString", g_fn_FormatAmxString, PFN_FORMAT_AMXSTRING); + REQFUNC("CopyAmxMemory", g_fn_CopyAmxMemory, PFN_COPY_AMXMEMORY); + REQFUNC("GetAmxAddr", g_fn_GetAmxAddr, PFN_GET_AMXADDR); + + REQFUNC("amx_Exec", g_fn_AmxExec, PFN_AMX_EXEC); + REQFUNC("amx_Execv", g_fn_AmxExecv, PFN_AMX_EXECV); + REQFUNC("amx_FindPublic", g_fn_AmxFindPublic, PFN_AMX_FINDPUBLIC); + REQFUNC("amx_Allot", g_fn_AmxAllot, PFN_AMX_ALLOT); + REQFUNC("amx_FindNative", g_fn_AmxFindNative, PFN_AMX_FINDNATIVE); + + // Natives / Forwards + REQFUNC("AddNatives", g_fn_AddNatives, PFN_ADD_NATIVES); + REQFUNC("RaiseAmxError", g_fn_RaiseAmxError, PFN_RAISE_AMXERROR); + REQFUNC("RegisterForward", g_fn_RegisterForward, PFN_REGISTER_FORWARD); + REQFUNC("RegisterSPForward", g_fn_RegisterSPForward, PFN_REGISTER_SPFORWARD); + REQFUNC("RegisterSPForwardByName", g_fn_RegisterSPForwardByName, PFN_REGISTER_SPFORWARD_BYNAME); + REQFUNC("UnregisterSPForward", g_fn_UnregisterSPForward, PFN_UNREGISTER_SPFORWARD); + REQFUNC("ExecuteForward", g_fn_ExecuteForward, PFN_EXECUTE_FORWARD); + REQFUNC("PrepareCellArray", g_fn_PrepareCellArray, PFN_PREPARE_CELLARRAY); + REQFUNC("PrepareCharArray", g_fn_PrepareCharArray, PFN_PREPARE_CHARARRAY); + REQFUNC("PrepareCellArrayA", g_fn_PrepareCellArrayA, PFN_PREPARE_CELLARRAY_A); + REQFUNC("PrepareCharArrayA", g_fn_PrepareCharArrayA, PFN_PREPARE_CHARARRAY_A); + // Player + REQFUNC("IsPlayerValid", g_fn_IsPlayerValid, PFN_IS_PLAYER_VALID); + REQFUNC("GetPlayerName", g_fn_GetPlayerName, PFN_GET_PLAYER_NAME); + REQFUNC("GetPlayerIP", g_fn_GetPlayerIP, PFN_GET_PLAYER_IP); + REQFUNC("IsPlayerInGame", g_fn_IsPlayerIngame, PFN_IS_PLAYER_INGAME); + REQFUNC("IsPlayerBot", g_fn_IsPlayerBot, PFN_IS_PLAYER_BOT); + REQFUNC("IsPlayerAuthorized", g_fn_IsPlayerAuthorized, PFN_IS_PLAYER_AUTHORIZED); + REQFUNC("GetPlayerTime", g_fn_GetPlayerTime, PFN_GET_PLAYER_TIME); + REQFUNC("GetPlayerPlayTime", g_fn_GetPlayerPlayTime, PFN_GET_PLAYER_PLAYTIME); + REQFUNC("GetPlayerCurweapon", g_fn_GetPlayerCurweapon, PFN_GET_PLAYER_CURWEAPON); + REQFUNC("GetPlayerTeamID", g_fn_GetPlayerTeamID, PFN_GET_PLAYER_TEAMID); + REQFUNC("GetPlayerTeam",g_fn_GetPlayerTeam, PFN_GET_PLAYER_TEAM); + REQFUNC("GetPlayerDeaths", g_fn_GetPlayerDeaths, PFN_GET_PLAYER_DEATHS); + REQFUNC("GetPlayerMenu", g_fn_GetPlayerMenu, PFN_GET_PLAYER_MENU); + REQFUNC("GetPlayerKeys", g_fn_GetPlayerKeys, PFN_GET_PLAYER_KEYS); + REQFUNC("IsPlayerAlive", g_fn_IsPlayerAlive, PFN_IS_PLAYER_ALIVE); + REQFUNC("GetPlayerFrags", g_fn_GetPlayerFrags, PFN_GET_PLAYER_FRAGS); + REQFUNC("IsPlayerConnecting", g_fn_IsPlayerConnecting, PFN_IS_PLAYER_CONNECTING); + REQFUNC("IsPlayerHLTV", g_fn_IsPlayerHLTV, PFN_IS_PLAYER_HLTV); + REQFUNC("GetPlayerArmor", g_fn_GetPlayerArmor, PFN_GET_PLAYER_ARMOR); + REQFUNC("GetPlayerHealth", g_fn_GetPlayerHealth, PFN_GET_PLAYER_HEALTH); + REQFUNC("GetPlayerFlags", g_fn_GetPlayerFlags, PFN_GETPLAYERFLAGS); + REQFUNC("GetPlayerEdict", g_fn_GetPlayerEdict, PFN_GET_PLAYER_EDICT); + REQFUNC("amx_Push", g_fn_AmxPush, PFN_AMX_PUSH); + + // Memory + REQFUNC_OPT("Allocator", g_fn_Allocator, PFN_ALLOCATOR); + REQFUNC_OPT("Reallocator", g_fn_Reallocator, PFN_REALLOCATOR); + REQFUNC_OPT("Deallocator", g_fn_Deallocator, PFN_DEALLOCATOR); + + REQFUNC("CellToReal", g_fn_CellToReal, PFN_CELL_TO_REAL); + REQFUNC("RealToCell", g_fn_RealToCell, PFN_REAL_TO_CELL); + +#ifdef FN_AMXX_ATTACH + FN_AMXX_ATTACH(); +#endif // FN_AMXX_ATACH + + return AMXX_OK; +} + +C_DLLEXPORT int AMXX_Detach() +{ +#ifdef FN_AMXX_DETACH + FN_AMXX_DETACH(); +#endif // FN_AMXX_DETACH + + return AMXX_OK; +} + +C_DLLEXPORT int AMXX_PluginsLoaded() +{ +#ifdef FN_AMXX_PLUGINSLOADED + FN_AMXX_PLUGINSLOADED(); +#endif // FN_AMXX_PLUGINSLOADED + return AMXX_OK; +} + +// Advanced MF functions +void MF_Log(const char *fmt, ...) +{ + // :TODO: Overflow possible here + char msg[3072]; + va_list arglst; + va_start(arglst, fmt); + vsprintf(msg, fmt, arglst); + va_end(arglst); + + g_fn_Log("[%s] %s", MODULE_LOGTAG, msg); +} + +void MF_LogError(AMX *amx, int err, const char *fmt, ...) +{ + // :TODO: Overflow possible here + char msg[3072]; + va_list arglst; + va_start(arglst, fmt); + vsprintf(msg, fmt, arglst); + va_end(arglst); + + g_fn_LogErrorFunc(amx, err, "[%s] %s", MODULE_LOGTAG, msg); +} + + +#ifdef _DEBUG +// validate macros +// Makes sure compiler reports errors when macros are invalid +void ValidateMacros_DontCallThis_Smiley() +{ + MF_BuildPathname("str", "str", 0); + MF_BuildPathnameR(NULL, 0, "%d", 0); + MF_FormatAmxString(NULL, 0, 0, NULL); + MF_GetAmxAddr(NULL, 0); + MF_PrintSrvConsole("str", "str", 0); + MF_GetModname(); + MF_GetScriptName(0); + MF_GetScriptAmx(0); + MF_FindScriptByAmx(NULL); + MF_FindScriptByName("str"); + MF_SetAmxString(NULL, 0, "str", 0); + MF_GetAmxString(NULL, 0, 0, 0); + MF_GetAmxStringLen(NULL); + MF_CopyAmxMemory(NULL, NULL, 0); + MF_Log("str", "str", 0); + MF_LogError(NULL, 0, NULL); + MF_RaiseAmxError(NULL, 0); + MF_RegisterForward("str", (ForwardExecType)0, 0, 0, 0); + MF_ExecuteForward(0, 0, 0); + MF_PrepareCellArray(NULL, 0); + MF_PrepareCharArray(NULL, 0); + MF_PrepareCellArrayA(NULL, 0, true); + MF_PrepareCharArrayA(NULL, 0, true); + MF_IsPlayerValid(0); + MF_GetPlayerName(0); + MF_GetPlayerIP(0); + MF_IsPlayerIngame(0); + MF_IsPlayerBot(0); + MF_IsPlayerAuthorized(0); + MF_GetPlayerTime(0); + MF_GetPlayerPlayTime(0); + MF_GetPlayerCurweapon(0); + MF_GetPlayerTeamID(0); + MF_GetPlayerTeam(0); + MF_GetPlayerDeaths(0); + MF_GetPlayerMenu(0); + MF_GetPlayerKeys(0); + MF_IsPlayerAlive(0); + MF_GetPlayerFrags(0); + MF_IsPlayerConnecting(0); + MF_IsPlayerHLTV(0); + MF_GetPlayerArmor(0); + MF_GetPlayerHealth(0); + MF_AmxExec(0, 0, 0); + MF_AmxExecv(0, 0, 0, 0, 0); + MF_AmxFindPublic(0, 0, 0); + MF_AmxAllot(0, 0, 0, 0); + MF_LoadAmxScript(0, 0, 0, 0, 0); + MF_UnloadAmxScript(0, 0); + MF_RegisterSPForward(0, 0, 0, 0, 0, 0); + MF_RegisterSPForwardByName(0, 0, 0, 0, 0, 0); + MF_UnregisterSPForward(0); + MF_GetPlayerFrags(0); + MF_GetPlayerEdict(0); + MF_Format("", 4, "str"); + MF_RegisterFunction(NULL, ""); +} +#endif + +/************* MEMORY *************/ +// undef all defined macros +#undef new +#undef delete +#undef malloc +#undef calloc +#undef realloc +#undef free + +const unsigned int m_alloc_unknown = 0; +const unsigned int m_alloc_new = 1; +const unsigned int m_alloc_new_array = 2; +const unsigned int m_alloc_malloc = 3; +const unsigned int m_alloc_calloc = 4; +const unsigned int m_alloc_realloc = 5; +const unsigned int m_alloc_delete = 6; +const unsigned int m_alloc_delete_array = 7; +const unsigned int m_alloc_free = 8; + +const char *g_Mem_CurrentFilename = "??"; +int g_Mem_CurrentLine = 0; +const char *g_Mem_CurrentFunc = "??"; + +const char *Mem_MakeSourceFile(const char *sourceFile) +{ + static char buffer[512]; + static size_t pos = 0; + if (!pos) + { + // init + buffer[0] = '['; + strcpy(buffer + 1, MODULE_NAME); + pos = strlen(MODULE_NAME) + 1; + buffer[pos++] = ']'; + } + + // convert from absolute path to [modulename]filename + const char *ptr = strrchr(sourceFile, '\\'); + if (ptr) + ptr++; + else + { + ptr = strrchr(sourceFile, '/'); + if (ptr) + ptr++; + else + ptr = sourceFile; + } + strcpy(buffer + pos, ptr); + return buffer; +} + +void Mem_SetOwner(const char *filename, int line, const char *function) +{ + g_Mem_CurrentFilename = filename; + g_Mem_CurrentLine = line; + g_Mem_CurrentFunc = function; +} + +void Mem_ResetGlobals() +{ + Mem_SetOwner("??", 0, "??"); +} + +// raw (re/de)allocators +void * Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int allocationType, const size_t reportedSize) +{ + if (g_fn_Allocator) + return g_fn_Allocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, allocationType, reportedSize); + else + return malloc(reportedSize); +} + +void * Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress) +{ + if (g_fn_Reallocator) + return g_fn_Reallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, reallocationType, reportedSize, reportedAddress); + else + return realloc(reportedAddress, reportedSize); +} + +void Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int deallocationType, void *reportedAddress) +{ + // If you you get user breakpoint here, something failed :) + // - invalid pointer + // - alloc type mismatch ( for example + // char *a = new char[5]; delete char; + // ) + // - The allocation unit is damaged (for example + // char *a = new char[5]; a[6] = 8; + // ) + // - break on dealloc flag set (somehow) + + if (g_fn_Deallocator) + g_fn_Deallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, deallocationType, reportedAddress); + else + free(reportedAddress); +} + +// new and delete operators +void *operator new(size_t reportedSize) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} + +void *operator new[](size_t reportedSize) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} + +// Microsoft memory tracking operators +void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} +void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine) +{ + if (reportedSize == 0) + reportedSize = 1; + void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize); + // :TODO: Handler support ? + if (ptr) + return ptr; + + // allocation failed + return NULL; +} + +void operator delete(void *reportedAddress) +{ + if (!reportedAddress) + return; + + Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete, reportedAddress); +} + +void operator delete[](void *reportedAddress) +{ + if (!reportedAddress) + return; + + Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete_array, reportedAddress); +} + +/************* stuff from dlls/util.cpp *************/ +// must come here because cbase.h declares it's own operator new + +#ifdef USE_METAMOD + +// Selected portions of dlls/util.cpp from SDK 2.1. +// Functions copied from there as needed... +// And modified to avoid buffer overflows (argh). + +/*** +* +* Copyright (c) 1999, 2000 Valve LLC. All rights reserved. +* +* This product contains software technology licensed from Id +* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc. +* All Rights Reserved. +* +* Use, distribution, and modification of this source code and/or resulting +* object code is restricted to non-commercial enhancements to products from +* Valve LLC. All other use, distribution, or modification is prohibited +* without written permission from Valve LLC. +* +****/ +/* + +===== util.cpp ======================================================== + + Utility code. Really not optional after all. + +*/ + +#include +#include "sdk_util.h" +#include + +#include // for strncpy(), etc + +#include "osdep.h" // win32 vsnprintf, etc + +char* UTIL_VarArgs( char *format, ... ) +{ + va_list argptr; + static char string[1024]; + + va_start (argptr, format); + vsnprintf (string, sizeof(string), format, argptr); + va_end (argptr); + + return string; +} + + +//========================================================= +// UTIL_LogPrintf - Prints a logged message to console. +// Preceded by LOG: ( timestamp ) < message > +//========================================================= +void UTIL_LogPrintf( char *fmt, ... ) +{ + va_list argptr; + static char string[1024]; + + va_start ( argptr, fmt ); + vsnprintf ( string, sizeof(string), fmt, argptr ); + va_end ( argptr ); + + // Print to server console + ALERT( at_logged, "%s", string ); +} + + +void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, + const char *pMessage) +{ + if ( !pEntity ) + return; + + MESSAGE_BEGIN( MSG_ONE, SVC_TEMPENTITY, NULL, ENT(pEntity->pev) ); + WRITE_BYTE( TE_TEXTMESSAGE ); + WRITE_BYTE( textparms.channel & 0xFF ); + + WRITE_SHORT( FixedSigned16( textparms.x, 1<<13 ) ); + WRITE_SHORT( FixedSigned16( textparms.y, 1<<13 ) ); + WRITE_BYTE( textparms.effect ); + + WRITE_BYTE( textparms.r1 ); + WRITE_BYTE( textparms.g1 ); + WRITE_BYTE( textparms.b1 ); + WRITE_BYTE( textparms.a1 ); + + WRITE_BYTE( textparms.r2 ); + WRITE_BYTE( textparms.g2 ); + WRITE_BYTE( textparms.b2 ); + WRITE_BYTE( textparms.a2 ); + + WRITE_SHORT( FixedUnsigned16( textparms.fadeinTime, 1<<8 ) ); + WRITE_SHORT( FixedUnsigned16( textparms.fadeoutTime, 1<<8 ) ); + WRITE_SHORT( FixedUnsigned16( textparms.holdTime, 1<<8 ) ); + + if ( textparms.effect == 2 ) + WRITE_SHORT( FixedUnsigned16( textparms.fxTime, 1<<8 ) ); + + if ( strlen( pMessage ) < 512 ) + { + WRITE_STRING( pMessage ); + } + else + { + char tmp[512]; + strncpy( tmp, pMessage, 511 ); + tmp[511] = 0; + WRITE_STRING( tmp ); + } + MESSAGE_END(); +} + +short FixedSigned16( float value, float scale ) +{ + int output; + + output = (int) (value * scale); + + if ( output > 32767 ) + output = 32767; + + if ( output < -32768 ) + output = -32768; + + return (short)output; +} + +unsigned short FixedUnsigned16( float value, float scale ) +{ + int output; + + output = (int) (value * scale); + if ( output < 0 ) + output = 0; + if ( output > 0xFFFF ) + output = 0xFFFF; + + return (unsigned short)output; +} +#endif // USE_METAMOD diff --git a/dlls/BB/amxxmodule.h b/dlls/BB/amxxmodule.h new file mode 100644 index 00000000..baf6d259 --- /dev/null +++ b/dlls/BB/amxxmodule.h @@ -0,0 +1,2239 @@ +/* + * AMX Mod X Module Interface Functions + * This file may be freely used +*/ + +// prevent double include +#ifndef __AMXXMODULE_H__ +#define __AMXXMODULE_H__ + +// config +#include "moduleconfig.h" + +// metamod include files +#ifdef USE_METAMOD +#include +#include +#include "osdep.h" +#endif // #ifdef USE_METAMOD + +// DLL Export +#undef DLLEXPORT +#ifndef __linux__ +#define DLLEXPORT __declspec(dllexport) +#else +#define DLLEXPORT +#define LINUX +#endif + +#undef C_DLLEXPORT +#define C_DLLEXPORT extern "C" DLLEXPORT + +// ***** AMXX stuff ***** + +// module interface version was 1 +// 2 - added logtag to struct (amxx1.1-rc1) +// 3 - added new tagAMX structure (amxx1.5) +#define AMXX_INTERFACE_VERSION 3 + +// amxx module info +struct amxx_module_info_s +{ + const char *name; + const char *author; + const char *version; + int reload; // reload on mapchange when nonzero + const char *logtag; // added in version 2 +}; + + + +// return values from functions called by amxx +#define AMXX_OK 0 /* no error */ +#define AMXX_IFVERS 1 /* interface version */ +#define AMXX_PARAM 2 /* Invalid parameter */ +#define AMXX_FUNC_NOT_PRESENT 3 /* Function not present */ + +// *** Small stuff *** +// The next section is copied from the amx.h file +// Copyright (c) ITB CompuPhase, 1997-2005 + +#if defined HAVE_STDINT_H + #include +#else + #if defined __LCC__ || defined __DMC__ || defined LINUX + #if defined HAVE_INTTYPES_H + #include + #else + #include + #endif + #elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L + /* The ISO C99 defines the int16_t and int_32t types. If the compiler got + * here, these types are probably undefined. + */ + #if defined __MACH__ + #include + typedef unsigned short int uint16_t; + typedef unsigned long int uint32_t; + #elif defined __FreeBSD__ + #include + #else + typedef short int int16_t; + typedef unsigned short int uint16_t; + #if defined SN_TARGET_PS2 + typedef int int32_t; + typedef unsigned int uint32_t; + #else + typedef long int int32_t; + typedef unsigned long int uint32_t; + #endif + #if defined __WIN32__ || defined _WIN32 || defined WIN32 + typedef __int64 int64_t; + typedef unsigned __int64 uint64_t; + #define HAVE_I64 + #elif defined __GNUC__ + typedef long long int64_t; + typedef unsigned long long uint64_t; + #define HAVE_I64 + #endif + #endif + #endif + #define HAVE_STDINT_H +#endif +#if defined _LP64 || defined WIN64 || defined _WIN64 + #if !defined __64BIT__ + #define __64BIT__ + #endif +#endif + +/* calling convention for native functions */ +#if !defined AMX_NATIVE_CALL + #define AMX_NATIVE_CALL +#endif +/* calling convention for all interface functions and callback functions */ +#if !defined AMXAPI + #if defined STDECL + #define AMXAPI __stdcall + #elif defined CDECL + #define AMXAPI __cdecl + #else + #define AMXAPI + #endif +#endif +#if !defined AMXEXPORT + #define AMXEXPORT +#endif + +#if !defined PAWN_CELL_SIZE + #define PAWN_CELL_SIZE 32 /* by default, use 32-bit cells */ +#endif +#if PAWN_CELL_SIZE==16 + typedef uint16_t ucell; + typedef int16_t cell; +#elif PAWN_CELL_SIZE==32 + typedef uint32_t ucell; + typedef int32_t cell; +#define REAL float +#elif PAWN_CELL_SIZE==64 + typedef uint64_t ucell; + typedef int64_t cell; +#define REAL double +#else + #error Unsupported cell size (PAWN_CELL_SIZE) +#endif + +#define UNPACKEDMAX ((1 << (sizeof(cell)-1)*8) - 1) +#define UNLIMITED (~1u >> 1) + +struct tagAMX; +typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params); +typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index, + cell *result, cell *params); +typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx); +#if !defined _FAR + #define _FAR +#endif + +#if defined _MSC_VER + #pragma warning(disable:4103) /* disable warning message 4103 that complains + * about pragma pack in a header file */ + #pragma warning(disable:4100) /* "'%$S' : unreferenced formal parameter" */ +#endif + + +/* Some compilers do not support the #pragma align, which should be fine. Some + * compilers give a warning on unknown #pragmas, which is not so fine... + */ +#if (defined SN_TARGET_PS2 || defined __GNUC__) && !defined AMX_NO_ALIGN + #define AMX_NO_ALIGN +#endif + +#if defined __GNUC__ + #define PACKED __attribute__((packed)) +#else + #define PACKED +#endif + +#if !defined AMX_NO_ALIGN + #if defined LINUX || defined __FreeBSD__ + #pragma pack(1) /* structures must be packed (byte-aligned) */ + #elif defined MACOS && defined __MWERKS__ + #pragma options align=mac68k + #else + #pragma pack(push) + #pragma pack(1) /* structures must be packed (byte-aligned) */ + #if defined __TURBOC__ + #pragma option -a- /* "pack" pragma for older Borland compilers */ + #endif + #endif +#endif + +typedef struct { + const char _FAR *name PACKED; + AMX_NATIVE func PACKED; +} AMX_NATIVE_INFO; + +#define AMX_USERNUM 4 + +/* The AMX structure is the internal structure for many functions. Not all + * fields are valid at all times; many fields are cached in local variables. + */ +typedef struct tagAMX { + unsigned char _FAR *base PACKED; /* points to the AMX header plus the code, optionally also the data */ + unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */ + AMX_CALLBACK callback PACKED; + AMX_DEBUG debug PACKED; /* debug callback */ + /* for external functions a few registers must be accessible from the outside */ + cell cip PACKED; /* instruction pointer: relative to base + amxhdr->cod */ + cell frm PACKED; /* stack frame base: relative to base + amxhdr->dat */ + cell hea PACKED; /* top of the heap: relative to base + amxhdr->dat */ + cell hlw PACKED; /* bottom of the heap: relative to base + amxhdr->dat */ + cell stk PACKED; /* stack pointer: relative to base + amxhdr->dat */ + cell stp PACKED; /* top of the stack: relative to base + amxhdr->dat */ + int flags PACKED; /* current status, see amx_Flags() */ + /* user data */ + long usertags[AMX_USERNUM] PACKED; + //okay userdata[3] in AMX Mod X is for the CPlugin * pointer + //we're also gonna set userdata[2] to a special debug structure + void _FAR *userdata[AMX_USERNUM] PACKED; + /* native functions can raise an error */ + int error PACKED; + /* passing parameters requires a "count" field */ + int paramcount; + /* the sleep opcode needs to store the full AMX status */ + cell pri PACKED; + cell alt PACKED; + cell reset_stk PACKED; + cell reset_hea PACKED; + cell sysreq_d PACKED; /* relocated address/value for the SYSREQ.D opcode */ + /* support variables for the JIT */ + int reloc_size PACKED; /* required temporary buffer for relocations */ + long code_size PACKED; /* estimated memory footprint of the native code */ +} PACKED AMX; + +enum { + AMX_ERR_NONE, + /* reserve the first 15 error codes for exit codes of the abstract machine */ + AMX_ERR_EXIT, /* forced exit */ + AMX_ERR_ASSERT, /* assertion failed */ + AMX_ERR_STACKERR, /* stack/heap collision */ + AMX_ERR_BOUNDS, /* index out of bounds */ + AMX_ERR_MEMACCESS, /* invalid memory access */ + AMX_ERR_INVINSTR, /* invalid instruction */ + AMX_ERR_STACKLOW, /* stack underflow */ + AMX_ERR_HEAPLOW, /* heap underflow */ + AMX_ERR_CALLBACK, /* no callback, or invalid callback */ + AMX_ERR_NATIVE, /* native function failed */ + AMX_ERR_DIVIDE, /* divide by zero */ + AMX_ERR_SLEEP, /* go into sleepmode - code can be restarted */ + AMX_ERR_INVSTATE, /* invalid state for this access */ + + AMX_ERR_MEMORY = 16, /* out of memory */ + AMX_ERR_FORMAT, /* invalid file format */ + AMX_ERR_VERSION, /* file is for a newer version of the AMX */ + AMX_ERR_NOTFOUND, /* function not found */ + AMX_ERR_INDEX, /* invalid index parameter (bad entry point) */ + AMX_ERR_DEBUG, /* debugger cannot run */ + AMX_ERR_INIT, /* AMX not initialized (or doubly initialized) */ + AMX_ERR_USERDATA, /* unable to set user data field (table full) */ + AMX_ERR_INIT_JIT, /* cannot initialize the JIT */ + AMX_ERR_PARAMS, /* parameter error */ + AMX_ERR_DOMAIN, /* domain error, expression result does not fit in range */ +}; + +#if !defined AMX_NO_ALIGN + #if defined __linux__ + #pragma pack() /* reset default packing */ + #else + #pragma pack(pop) /* reset previous packing */ + #endif +#endif + + +// ***** declare functions ***** + +#ifdef USE_METAMOD +void UTIL_LogPrintf( char *fmt, ... ); +void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, const char *pMessage); +short FixedSigned16( float value, float scale ); +unsigned short FixedUnsigned16( float value, float scale ); + +#ifdef FN_META_QUERY +void FN_META_QUERY(void); +#endif // FN_META_QUERY + +#ifdef FN_META_ATTACH +void FN_META_ATTACH(void); +#endif // FN_META_ATTACH + +#ifdef FN_META_DETACH +void FN_META_DETACH(void); +#endif // FN_META_DETACH + + + + + +#ifdef FN_GameDLLInit +void FN_GameDLLInit(void); +#endif // FN_GameDLLInit + +#ifdef FN_DispatchSpawn +int FN_DispatchSpawn(edict_t *pent); +#endif // FN_DispatchSpawn + +#ifdef FN_DispatchThink +void FN_DispatchThink(edict_t *pent); +#endif // FN_DispatchThink + +#ifdef FN_DispatchUse +void FN_DispatchUse(edict_t *pentUser, edict_t *pentOther); +#endif // FN_DispatchUse + +#ifdef FN_DispatchTouch +void FN_DispatchTouch(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_DispatchTouch + +#ifdef FN_DispatchBlocked +void FN_DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther); +#endif // FN_DispatchBlocked + +#ifdef FN_DispatchKeyValue +void FN_DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd); +#endif // FN_DispatchKeyValue + +#ifdef FN_DispatchSave +void FN_DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData); +#endif // FN_DispatchSave + +#ifdef FN_DispatchRestore +int FN_DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity); +#endif // FN_DispatchRestore + +#ifdef FN_DispatchObjectCollsionBox +void FN_DispatchObjectCollsionBox(edict_t *pent); +#endif // FN_DispatchObjectCollsionBox + +#ifdef FN_SaveWriteFields +void FN_SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveWriteFields + +#ifdef FN_SaveReadFields +void FN_SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveReadFields + +#ifdef FN_SaveGlobalState +void FN_SaveGlobalState(SAVERESTOREDATA *pSaveData); +#endif // FN_SaveGlobalState + +#ifdef FN_RestoreGlobalState +void FN_RestoreGlobalState(SAVERESTOREDATA *pSaveData); +#endif // FN_RestoreGlobalState + +#ifdef FN_ResetGlobalState +void FN_ResetGlobalState(void); +#endif // FN_ResetGlobalState + +#ifdef FN_ClientConnect +BOOL FN_ClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]); +#endif // FN_ClientConnect + +#ifdef FN_ClientDisconnect +void FN_ClientDisconnect(edict_t *pEntity); +#endif // FN_ClientDisconnect + +#ifdef FN_ClientKill +void FN_ClientKill(edict_t *pEntity); +#endif // FN_ClientKill + +#ifdef FN_ClientPutInServer +void FN_ClientPutInServer(edict_t *pEntity); +#endif // FN_ClientPutInServer + +#ifdef FN_ClientCommand +void FN_ClientCommand(edict_t *pEntity); +#endif // FN_ClientCommand + +#ifdef FN_ClientUserInfoChanged +void FN_ClientUserInfoChanged(edict_t *pEntity, char *infobuffer); +#endif // FN_ClientUserInfoChanged + +#ifdef FN_ServerActivate +void FN_ServerActivate(edict_t *pEdictList, int edictCount, int clientMax); +#endif // FN_ServerActivate + +#ifdef FN_ServerDeactivate +void FN_ServerDeactivate(void); +#endif // FN_ServerDeactivate + +#ifdef FN_PlayerPreThink +void FN_PlayerPreThink(edict_t *pEntity); +#endif // FN_PlayerPreThink + +#ifdef FN_PlayerPostThink +void FN_PlayerPostThink(edict_t *pEntity); +#endif // FN_PlayerPostThink + +#ifdef FN_StartFrame +void FN_StartFrame(void); +#endif // FN_StartFrame + +#ifdef FN_ParmsNewLevel +void FN_ParmsNewLevel(void); +#endif // FN_ParmsNewLevel + +#ifdef FN_ParmsChangeLevel +void FN_ParmsChangeLevel(void); +#endif // FN_ParmsChangeLevel + +#ifdef FN_GetGameDescription +const char *FN_GetGameDescription(void); +#endif // FN_GetGameDescription + +#ifdef FN_PlayerCustomization +void FN_PlayerCustomization(edict_t *pEntity, customization_t *pCust); +#endif // FN_PlayerCustomization + +#ifdef FN_SpectatorConnect +void FN_SpectatorConnect(edict_t *pEntity); +#endif // FN_SpectatorConnect + +#ifdef FN_SpectatorDisconnect +void FN_SpectatorDisconnect(edict_t *pEntity); +#endif // FN_SpectatorDisconnect + +#ifdef FN_SpectatorThink +void FN_SpectatorThink(edict_t *pEntity); +#endif // FN_SpectatorThink + +#ifdef FN_Sys_Error +void FN_Sys_Error(const char *error_string); +#endif // FN_Sys_Error + +#ifdef FN_PM_Move +void FN_PM_Move(struct playermove_s *ppmove, int server); +#endif // FN_PM_Move + +#ifdef FN_PM_Init +void FN_PM_Init(struct playermove_s *ppmove); +#endif // FN_PM_Init + +#ifdef FN_PM_FindTextureType +char FN_PM_FindTextureType(char *name); +#endif // FN_PM_FindTextureType + +#ifdef FN_SetupVisibility +void FN_SetupVisibility(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas); +#endif // FN_SetupVisibility + +#ifdef FN_UpdateClientData +void FN_UpdateClientData(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd); +#endif // FN_UpdateClientData + +#ifdef FN_AddToFullPack +int FN_AddToFullPack(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet); +#endif // FN_AddToFullPack + +#ifdef FN_CreateBaseline +void FN_CreateBaseline(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs); +#endif // FN_CreateBaseline + +#ifdef FN_RegisterEncoders +void FN_RegisterEncoders(void); +#endif // FN_RegisterEncoders + +#ifdef FN_GetWeaponData +int FN_GetWeaponData(struct edict_s *player, struct weapon_data_s *info); +#endif // FN_GetWeaponData + +#ifdef FN_CmdStart +void FN_CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed); +#endif // FN_CmdStart + +#ifdef FN_CmdEnd +void FN_CmdEnd(const edict_t *player); +#endif // FN_CmdEnd + +#ifdef FN_ConnectionlessPacket +int FN_ConnectionlessPacket(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size); +#endif // FN_ConnectionlessPacket + +#ifdef FN_GetHullBounds +int FN_GetHullBounds(int hullnumber, float *mins, float *maxs); +#endif // FN_GetHullBounds + +#ifdef FN_CreateInstancedBaselines +void FN_CreateInstancedBaselines(void); +#endif // FN_CreateInstancedBaselines + +#ifdef FN_InconsistentFile +int FN_InconsistentFile(const edict_t *player, const char *filename, char *disconnect_message); +#endif // FN_InconsistentFile + +#ifdef FN_AllowLagCompensation +int FN_AllowLagCompensation(void); +#endif // FN_AllowLagCompensation + + + + +#ifdef FN_GameDLLInit_Post +void FN_GameDLLInit_Post(void); +#endif // FN_GameDLLInit_Post + +#ifdef FN_DispatchSpawn_Post +int FN_DispatchSpawn_Post(edict_t *pent); +#endif // FN_DispatchSpawn_Post + +#ifdef FN_DispatchThink_Post +void FN_DispatchThink_Post(edict_t *pent); +#endif // FN_DispatchThink_Post + +#ifdef FN_DispatchUse_Post +void FN_DispatchUse_Post(edict_t *pentUser, edict_t *pentOther); +#endif // FN_DispatchUse_Post + +#ifdef FN_DispatchTouch_Post +void FN_DispatchTouch_Post(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_DispatchTouch_Post + +#ifdef FN_DispatchBlocked_Post +void FN_DispatchBlocked_Post(edict_t *pentBlocked, edict_t *pentOther); +#endif // FN_DispatchBlocked_Post + +#ifdef FN_DispatchKeyValue_Post +void FN_DispatchKeyValue_Post(edict_t *pentKeyvalue, KeyValueData *pkvd); +#endif // FN_DispatchKeyValue_Post + +#ifdef FN_DispatchSave_Post +void FN_DispatchSave_Post(edict_t *pent, SAVERESTOREDATA *pSaveData); +#endif // FN_DispatchSave_Post + +#ifdef FN_DispatchRestore_Post +int FN_DispatchRestore_Post(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity); +#endif // FN_DispatchRestore_Post + +#ifdef FN_DispatchObjectCollsionBox_Post +void FN_DispatchObjectCollsionBox_Post(edict_t *pent); +#endif // FN_DispatchObjectCollsionBox_Post + +#ifdef FN_SaveWriteFields_Post +void FN_SaveWriteFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveWriteFields_Post + +#ifdef FN_SaveReadFields_Post +void FN_SaveReadFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount); +#endif // FN_SaveReadFields_Post + +#ifdef FN_SaveGlobalState_Post +void FN_SaveGlobalState_Post(SAVERESTOREDATA *pSaveData); +#endif // FN_SaveGlobalState_Post + +#ifdef FN_RestoreGlobalState_Post +void FN_RestoreGlobalState_Post(SAVERESTOREDATA *pSaveData); +#endif // FN_RestoreGlobalState_Post + +#ifdef FN_ResetGlobalState_Post +void FN_ResetGlobalState_Post(void); +#endif // FN_ResetGlobalState_Post + +#ifdef FN_ClientConnect_Post +BOOL FN_ClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]); +#endif // FN_ClientConnect_Post + +#ifdef FN_ClientDisconnect_Post +void FN_ClientDisconnect_Post(edict_t *pEntity); +#endif // FN_ClientDisconnect_Post + +#ifdef FN_ClientKill_Post +void FN_ClientKill_Post(edict_t *pEntity); +#endif // FN_ClientKill_Post + +#ifdef FN_ClientPutInServer_Post +void FN_ClientPutInServer_Post(edict_t *pEntity); +#endif // FN_ClientPutInServer_Post + +#ifdef FN_ClientCommand_Post +void FN_ClientCommand_Post(edict_t *pEntity); +#endif // FN_ClientCommand_Post + +#ifdef FN_ClientUserInfoChanged_Post +void FN_ClientUserInfoChanged_Post(edict_t *pEntity, char *infobuffer); +#endif // FN_ClientUserInfoChanged_Post + +#ifdef FN_ServerActivate_Post +void FN_ServerActivate_Post(edict_t *pEdictList, int edictCount, int clientMax); +#endif // FN_ServerActivate_Post + +#ifdef FN_ServerDeactivate_Post +void FN_ServerDeactivate_Post(void); +#endif // FN_ServerDeactivate_Post + +#ifdef FN_PlayerPreThink_Post +void FN_PlayerPreThink_Post(edict_t *pEntity); +#endif // FN_PlayerPreThink_Post + +#ifdef FN_PlayerPostThink_Post +void FN_PlayerPostThink_Post(edict_t *pEntity); +#endif // FN_PlayerPostThink_Post + +#ifdef FN_StartFrame_Post +void FN_StartFrame_Post(void); +#endif // FN_StartFrame_Post + +#ifdef FN_ParmsNewLevel_Post +void FN_ParmsNewLevel_Post(void); +#endif // FN_ParmsNewLevel_Post + +#ifdef FN_ParmsChangeLevel_Post +void FN_ParmsChangeLevel_Post(void); +#endif // FN_ParmsChangeLevel_Post + +#ifdef FN_GetGameDescription_Post +const char *FN_GetGameDescription_Post(void); +#endif // FN_GetGameDescription_Post + +#ifdef FN_PlayerCustomization_Post +void FN_PlayerCustomization_Post(edict_t *pEntity, customization_t *pCust); +#endif // FN_PlayerCustomization_Post + +#ifdef FN_SpectatorConnect_Post +void FN_SpectatorConnect_Post(edict_t *pEntity); +#endif // FN_SpectatorConnect_Post + +#ifdef FN_SpectatorDisconnect_Post +void FN_SpectatorDisconnect_Post(edict_t *pEntity); +#endif // FN_SpectatorDisconnect_Post + +#ifdef FN_SpectatorThink_Post +void FN_SpectatorThink_Post(edict_t *pEntity); +#endif // FN_SpectatorThink_Post + +#ifdef FN_Sys_Error_Post +void FN_Sys_Error_Post(const char *error_string); +#endif // FN_Sys_Error_Post + +#ifdef FN_PM_Move_Post +void FN_PM_Move_Post(struct playermove_s *ppmove, int server); +#endif // FN_PM_Move_Post + +#ifdef FN_PM_Init_Post +void FN_PM_Init_Post(struct playermove_s *ppmove); +#endif // FN_PM_Init_Post + +#ifdef FN_PM_FindTextureType_Post +char FN_PM_FindTextureType_Post(char *name); +#endif // FN_PM_FindTextureType_Post + +#ifdef FN_SetupVisibility_Post +void FN_SetupVisibility_Post(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas); +#endif // FN_SetupVisibility_Post + +#ifdef FN_UpdateClientData_Post +void FN_UpdateClientData_Post(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd); +#endif // FN_UpdateClientData_Post + +#ifdef FN_AddToFullPack_Post +int FN_AddToFullPack_Post(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet); +#endif // FN_AddToFullPack_Post + +#ifdef FN_CreateBaseline_Post +void FN_CreateBaseline_Post(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs); +#endif // FN_CreateBaseline_Post + +#ifdef FN_RegisterEncoders_Post +void FN_RegisterEncoders_Post(void); +#endif // FN_RegisterEncoders_Post + +#ifdef FN_GetWeaponData_Post +int FN_GetWeaponData_Post(struct edict_s *player, struct weapon_data_s *info); +#endif // FN_GetWeaponData_Post + +#ifdef FN_CmdStart_Post +void FN_CmdStart_Post(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed); +#endif // FN_CmdStart_Post + +#ifdef FN_CmdEnd_Post +void FN_CmdEnd_Post(const edict_t *player); +#endif // FN_CmdEnd_Post + +#ifdef FN_ConnectionlessPacket_Post +int FN_ConnectionlessPacket_Post(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size); +#endif // FN_ConnectionlessPacket_Post + +#ifdef FN_GetHullBounds_Post +int FN_GetHullBounds_Post(int hullnumber, float *mins, float *maxs); +#endif // FN_GetHullBounds_Post + +#ifdef FN_CreateInstancedBaselines_Post +void FN_CreateInstancedBaselines_Post(void); +#endif // FN_CreateInstancedBaselines_Post + +#ifdef FN_InconsistentFile_Post +int FN_InconsistentFile_Post(const edict_t *player, const char *filename, char *disconnect_message); +#endif // FN_InconsistentFile_Post + +#ifdef FN_AllowLagCompensation_Post +int FN_AllowLagCompensation_Post(void); +#endif // FN_AllowLagCompensation_Post + + + +#ifdef FN_PrecacheModel +int FN_PrecacheModel(char *s); +#endif // FN_PrecacheModel + +#ifdef FN_PrecacheSound +int FN_PrecacheSound(char *s); +#endif // FN_PrecacheSound + +#ifdef FN_SetModel +void FN_SetModel(edict_t *e, const char *m); +#endif // FN_SetModel + +#ifdef FN_ModelIndex +int FN_ModelIndex(const char *m); +#endif // FN_ModelIndex + +#ifdef FN_ModelFrames +int FN_ModelFrames(int modelIndex); +#endif // FN_ModelFrames + +#ifdef FN_SetSize +void FN_SetSize(edict_t *e, const float *rgflMin, const float *rgflMax); +#endif // FN_SetSize + +#ifdef FN_ChangeLevel +void FN_ChangeLevel(char *s1, char *s2); +#endif // FN_ChangeLevel + +#ifdef FN_GetSpawnParms +void FN_GetSpawnParms(edict_t *ent); +#endif // FN_GetSpawnParms + +#ifdef FN_SaveSpawnParms +void FN_SaveSpawnParms(edict_t *ent); +#endif // FN_SaveSpawnParms + +#ifdef FN_VecToYaw +float FN_VecToYaw(const float *rgflVector); +#endif // FN_VecToYaw + +#ifdef FN_VecToAngles +void FN_VecToAngles(const float *rgflVectorIn, float *rgflVectorOut); +#endif // FN_VecToAngles + +#ifdef FN_MoveToOrigin +void FN_MoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType); +#endif // FN_MoveToOrigin + +#ifdef FN_ChangeYaw +void FN_ChangeYaw(edict_t *ent); +#endif // FN_ChangeYaw + +#ifdef FN_ChangePitch +void FN_ChangePitch(edict_t *ent); +#endif // FN_ChangePitch + +#ifdef FN_FindEntityByString +edict_t *FN_FindEntityByString(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue); +#endif // FN_FindEntityByString + +#ifdef FN_GetEntityIllum +int FN_GetEntityIllum(edict_t *pEnt); +#endif // FN_GetEntityIllum + +#ifdef FN_FindEntityInSphere +edict_t *FN_FindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad); +#endif // FN_FindEntityInSphere + +#ifdef FN_FindClientInPVS +edict_t *FN_FindClientInPVS(edict_t *pEdict); +#endif // FN_FindClientInPVS + +#ifdef FN_EntitiesInPVS +edict_t *FN_EntitiesInPVS(edict_t *pplayer); +#endif // FN_EntitiesInPVS + +#ifdef FN_MakeVectors +void FN_MakeVectors(const float *rgflVector); +#endif // FN_MakeVectors + +#ifdef FN_AngleVectors +void FN_AngleVectors(const float *rgflVector, float *forward, float *right, float *up); +#endif // FN_AngleVectors + +#ifdef FN_CreateEntity +edict_t *FN_CreateEntity(void); +#endif // FN_CreateEntity + +#ifdef FN_RemoveEntity +void FN_RemoveEntity(edict_t *e); +#endif // FN_RemoveEntity + +#ifdef FN_CreateNamedEntity +edict_t *FN_CreateNamedEntity(int className); +#endif // FN_CreateNamedEntity + +#ifdef FN_MakeStatic +void FN_MakeStatic(edict_t *ent); +#endif // FN_MakeStatic + +#ifdef FN_EntIsOnFloor +int FN_EntIsOnFloor(edict_t *ent); +#endif // FN_EntIsOnFloor + +#ifdef FN_DropToFloor +int FN_DropToFloor(edict_t *ent); +#endif // FN_DropToFloor + +#ifdef FN_WalkMove +int FN_WalkMove(edict_t *ent, float yaw, float dist, int iMode); +#endif // FN_WalkMove + +#ifdef FN_SetOrigin +void FN_SetOrigin(edict_t *e, const float *rgflOrigin); +#endif // FN_SetOrigin + +#ifdef FN_EmitSound +void FN_EmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch); +#endif // FN_EmitSound + +#ifdef FN_EmitAmbientSound +void FN_EmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch); +#endif // FN_EmitAmbientSound + +#ifdef FN_TraceLine +void FN_TraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceLine + +#ifdef FN_TraceToss +void FN_TraceToss(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr); +#endif // FN_TraceToss + +#ifdef FN_TraceMonsterHull +int FN_TraceMonsterHull(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceMonsterHull + +#ifdef FN_TraceHull +void FN_TraceHull(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceHull + +#ifdef FN_TraceModel +void FN_TraceModel(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr); +#endif // FN_TraceModel + +#ifdef FN_TraceTexture +const char *FN_TraceTexture(edict_t *pTextureEntity, const float *v1, const float *v2 ); +#endif // FN_TraceTexture + +#ifdef FN_TraceSphere +void FN_TraceSphere(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceSphere + +#ifdef FN_GetAimVector +void FN_GetAimVector(edict_t *ent, float speed, float *rgflReturn); +#endif // FN_GetAimVector + +#ifdef FN_ServerCommand +void FN_ServerCommand(char *str); +#endif // FN_ServerCommand + +#ifdef FN_ServerExecute +void FN_ServerExecute(void); +#endif // FN_ServerExecute + +#ifdef FN_engClientCommand +void FN_engClientCommand(edict_t *pEdict, char *szFmt, ...); +#endif // FN_engClientCommand + +#ifdef FN_ParticleEffect +void FN_ParticleEffect(const float *org, const float *dir, float color, float count); +#endif // FN_ParticleEffect + +#ifdef FN_LightStyle +void FN_LightStyle(int style, char *val); +#endif // FN_LightStyle + +#ifdef FN_DecalIndex +int FN_DecalIndex(const char *name); +#endif // FN_DecalIndex + +#ifdef FN_PointContents +int FN_PointContents(const float *rgflVector); +#endif // FN_PointContents + +#ifdef FN_MessageBegin +void FN_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_MessageBegin + +#ifdef FN_MessageEnd +void FN_MessageEnd(void); +#endif // FN_MessageEnd + +#ifdef FN_WriteByte +void FN_WriteByte(int iValue); +#endif // FN_WriteByte + +#ifdef FN_WriteChar +void FN_WriteChar(int iValue); +#endif // FN_WriteChar + +#ifdef FN_WriteShort +void FN_WriteShort(int iValue); +#endif // FN_WriteShort + +#ifdef FN_WriteLong +void FN_WriteLong(int iValue); +#endif // FN_WriteLong + +#ifdef FN_WriteAngle +void FN_WriteAngle(float flValue); +#endif // FN_WriteAngle + +#ifdef FN_WriteCoord +void FN_WriteCoord(float flValue); +#endif // FN_WriteCoord + +#ifdef FN_WriteString +void FN_WriteString(const char *sz); +#endif // FN_WriteString + +#ifdef FN_WriteEntity +void FN_WriteEntity(int iValue); +#endif // FN_WriteEntity + +#ifdef FN_CVarRegister +void FN_CVarRegister(cvar_t *pCvar); +#endif // FN_CVarRegister + +#ifdef FN_CVarGetFloat +float FN_CVarGetFloat(const char *szVarName); +#endif // FN_CVarGetFloat + +#ifdef FN_CVarGetString +const char *FN_CVarGetString(const char *szVarName); +#endif // FN_CVarGetString + +#ifdef FN_CVarSetFloat +void FN_CVarSetFloat(const char *szVarName, float flValue); +#endif // FN_CVarSetFloat + +#ifdef FN_CVarSetString +void FN_CVarSetString(const char *szVarName, const char *szValue); +#endif // FN_CVarSetString + +#ifdef FN_AlertMessage +void FN_AlertMessage(ALERT_TYPE atype, char *szFmt, ...); +#endif // FN_AlertMessage + +#ifdef FN_EngineFprintf +void FN_EngineFprintf(FILE *pfile, char *szFmt, ...); +#endif // FN_EngineFprintf + +#ifdef FN_PvAllocEntPrivateData +void *FN_PvAllocEntPrivateData(edict_t *pEdict, int32 cb); +#endif // FN_PvAllocEntPrivateData + +#ifdef FN_PvEntPrivateData +void *FN_PvEntPrivateData(edict_t *pEdict); +#endif // FN_PvEntPrivateData + +#ifdef FN_FreeEntPrivateData +void FN_FreeEntPrivateData(edict_t *pEdict); +#endif // FN_FreeEntPrivateData + +#ifdef FN_SzFromIndex +const char *FN_SzFromIndex(int iString); +#endif // FN_SzFromIndex + +#ifdef FN_AllocString +int FN_AllocString(const char *szValue); +#endif // FN_AllocString + +#ifdef FN_GetVarsOfEnt +struct entvars_s *FN_GetVarsOfEnt(edict_t *pEdict); +#endif // FN_GetVarsOfEnt + +#ifdef FN_PEntityOfEntOffset +edict_t *FN_PEntityOfEntOffset(int iEntOffset); +#endif // FN_PEntityOfEntOffset + +#ifdef FN_EntOffsetOfPEntity +int FN_EntOffsetOfPEntity(const edict_t *pEdict); +#endif // FN_EntOffsetOfPEntity + +#ifdef FN_IndexOfEdict +int FN_IndexOfEdict(const edict_t *pEdict); +#endif // FN_IndexOfEdict + +#ifdef FN_PEntityOfEntIndex +edict_t *FN_PEntityOfEntIndex(int iEntIndex); +#endif // FN_PEntityOfEntIndex + +#ifdef FN_FindEntityByVars +edict_t *FN_FindEntityByVars(struct entvars_s *pvars); +#endif // FN_FindEntityByVars + +#ifdef FN_GetModelPtr +void *FN_GetModelPtr(edict_t *pEdict); +#endif // FN_GetModelPtr + +#ifdef FN_RegUserMsg +int FN_RegUserMsg(const char *pszName, int iSize); +#endif // FN_RegUserMsg + +#ifdef FN_AnimationAutomove +void FN_AnimationAutomove(const edict_t *pEdict, float flTime); +#endif // FN_AnimationAutomove + +#ifdef FN_GetBonePosition +void FN_GetBonePosition(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles); +#endif // FN_GetBonePosition + +#ifdef FN_FunctionFromName +unsigned long FN_FunctionFromName(const char *pName); +#endif // FN_FunctionFromName + +#ifdef FN_NameForFunction +const char *FN_NameForFunction(unsigned long function); +#endif // FN_NameForFunction + +#ifdef FN_ClientPrintf +void FN_ClientPrintf(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg); +#endif // FN_ClientPrintf + +#ifdef FN_ServerPrint +void FN_ServerPrint(const char *szMsg); +#endif // FN_ServerPrint + +#ifdef FN_Cmd_Args +const char *FN_Cmd_Args(void); +#endif // FN_Cmd_Args + +#ifdef FN_Cmd_Argv +const char *FN_Cmd_Argv(int argc); +#endif // FN_Cmd_Argv + +#ifdef FN_Cmd_Argc +int FN_Cmd_Argc(void); +#endif // FN_Cmd_Argc + +#ifdef FN_GetAttachment +void FN_GetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ); +#endif // FN_GetAttachment + +#ifdef FN_CRC32_Init +void FN_CRC32_Init(CRC32_t *pulCRC); +#endif // FN_CRC32_Init + +#ifdef FN_CRC32_ProcessBuffer +void FN_CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len); +#endif // FN_CRC32_ProcessBuffer + +#ifdef FN_CRC32_ProcessByte +void FN_CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch); +#endif // FN_CRC32_ProcessByte + +#ifdef FN_CRC32_Final +CRC32_t FN_CRC32_Final(CRC32_t pulCRC); +#endif // FN_CRC32_Final + +#ifdef FN_RandomLong +long FN_RandomLong(long lLow, long lHigh); +#endif // FN_RandomLong + +#ifdef FN_RandomFloat +float FN_RandomFloat(float flLow, float flHigh); +#endif // FN_RandomFloat + +#ifdef FN_SetView +void FN_SetView(const edict_t *pClient, const edict_t *pViewent); +#endif // FN_SetView + +#ifdef FN_Time +float FN_Time(void); +#endif // FN_Time + +#ifdef FN_CrosshairAngle +void FN_CrosshairAngle(const edict_t *pClient, float pitch, float yaw); +#endif // FN_CrosshairAngle + +#ifdef FN_LoadFileForMe +byte *FN_LoadFileForMe(char *filename, int *pLength); +#endif // FN_LoadFileForMe + +#ifdef FN_FreeFile +void FN_FreeFile(void *buffer); +#endif // FN_FreeFile + +#ifdef FN_EndSection +void FN_EndSection(const char *pszSectionName); +#endif // FN_EndSection + +#ifdef FN_CompareFileTime +int FN_CompareFileTime(char *filename1, char *filename2, int *iCompare); +#endif // FN_CompareFileTime + +#ifdef FN_GetGameDir +void FN_GetGameDir(char *szGetGameDir); +#endif // FN_GetGameDir + +#ifdef FN_Cvar_RegisterVariable +void FN_Cvar_RegisterVariable(cvar_t *variable); +#endif // FN_Cvar_RegisterVariable + +#ifdef FN_FadeClientVolume +void FN_FadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds); +#endif // FN_FadeClientVolume + +#ifdef FN_SetClientMaxspeed +void FN_SetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed); +#endif // FN_SetClientMaxspeed + +#ifdef FN_CreateFakeClient +edict_t *FN_CreateFakeClient(const char *netname); +#endif // FN_CreateFakeClient + +#ifdef FN_RunPlayerMove +void FN_RunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec); +#endif // FN_RunPlayerMove + +#ifdef FN_NumberOfEntities +int FN_NumberOfEntities(void); +#endif // FN_NumberOfEntities + +#ifdef FN_GetInfoKeyBuffer +char *FN_GetInfoKeyBuffer(edict_t *e); +#endif // FN_GetInfoKeyBuffer + +#ifdef FN_InfoKeyValue +char *FN_InfoKeyValue(char *infobuffer, char *key); +#endif // FN_InfoKeyValue + +#ifdef FN_SetKeyValue +void FN_SetKeyValue(char *infobuffer, char *key, char *value); +#endif // FN_SetKeyValue + +#ifdef FN_SetClientKeyValue +void FN_SetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value); +#endif // FN_SetClientKeyValue + +#ifdef FN_IsMapValid +int FN_IsMapValid(char *filename); +#endif // FN_IsMapValid + +#ifdef FN_StaticDecal +void FN_StaticDecal(const float *origin, int decalIndex, int entityIndex, int modelIndex); +#endif // FN_StaticDecal + +#ifdef FN_PrecacheGeneric +int FN_PrecacheGeneric(char *s); +#endif // FN_PrecacheGeneric + +#ifdef FN_GetPlayerUserId +int FN_GetPlayerUserId(edict_t *e ); +#endif // FN_GetPlayerUserId + +#ifdef FN_BuildSoundMsg +void FN_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); +#endif // FN_BuildSoundMsg + +#ifdef FN_IsDedicatedServer +int FN_IsDedicatedServer(void); +#endif // FN_IsDedicatedServer + +#ifdef FN_CVarGetPointer +cvar_t *FN_CVarGetPointer(const char *szVarName); +#endif // FN_CVarGetPointer + +#ifdef FN_GetPlayerWONId +unsigned int FN_GetPlayerWONId(edict_t *e); +#endif // FN_GetPlayerWONId + +#ifdef FN_Info_RemoveKey +void FN_Info_RemoveKey( char *s, const char *key); +#endif // FN_Info_RemoveKey + +#ifdef FN_GetPhysicsKeyValue +const char *FN_GetPhysicsKeyValue(const edict_t *pClient, const char *key); +#endif // FN_GetPhysicsKeyValue + +#ifdef FN_SetPhysicsKeyValue +void FN_SetPhysicsKeyValue(const edict_t *pClient, const char *key, const char *value); +#endif // FN_SetPhysicsKeyValue + +#ifdef FN_GetPhysicsInfoString +const char *FN_GetPhysicsInfoString( const edict_t *pClient); +#endif // FN_GetPhysicsInfoString + +#ifdef FN_PrecacheEvent +unsigned short FN_PrecacheEvent(int type, const char *psz); +#endif // FN_PrecacheEvent + +#ifdef FN_PlaybackEvent +void FN_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); +#endif // FN_PlaybackEvent + +#ifdef FN_SetFatPVS +unsigned char *FN_SetFatPVS(float *org); +#endif // FN_SetFatPVS + +#ifdef FN_SetFatPAS +unsigned char *FN_SetFatPAS(float *org); +#endif // FN_SetFatPAS + +#ifdef FN_CheckVisibility +int FN_CheckVisibility(const edict_t *entity, unsigned char *pset); +#endif // FN_CheckVisibility + +#ifdef FN_DeltaSetField +void FN_DeltaSetField(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaSetField + +#ifdef FN_DeltaUnsetField +void FN_DeltaUnsetField(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaUnsetField + +#ifdef FN_DeltaAddEncoder +void FN_DeltaAddEncoder(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ); +#endif // FN_DeltaAddEncoder + +#ifdef FN_GetCurrentPlayer +int FN_GetCurrentPlayer(void); +#endif // FN_GetCurrentPlayer + +#ifdef FN_CanSkipPlayer +int FN_CanSkipPlayer(const edict_t *player); +#endif // FN_CanSkipPlayer + +#ifdef FN_DeltaFindField +int FN_DeltaFindField(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaFindField + +#ifdef FN_DeltaSetFieldByIndex +void FN_DeltaSetFieldByIndex(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaSetFieldByIndex + +#ifdef FN_DeltaUnsetFieldByIndex +void FN_DeltaUnsetFieldByIndex(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaUnsetFieldByIndex + +#ifdef FN_SetGroupMask +void FN_SetGroupMask(int mask, int op); +#endif // FN_SetGroupMask + +#ifdef FN_engCreateInstancedBaseline +int FN_engCreateInstancedBaseline(int classname, struct entity_state_s *baseline); +#endif // FN_engCreateInstancedBaseline + +#ifdef FN_Cvar_DirectSet +void FN_Cvar_DirectSet(struct cvar_s *var, char *value); +#endif // FN_Cvar_DirectSet + +#ifdef FN_ForceUnmodified +void FN_ForceUnmodified(FORCE_TYPE type, float *mins, float *maxs, const char *filename); +#endif // FN_ForceUnmodified + +#ifdef FN_GetPlayerStats +void FN_GetPlayerStats(const edict_t *pClient, int *ping, int *packet_loss); +#endif // FN_GetPlayerStats + +#ifdef FN_AddServerCommand +void FN_AddServerCommand(char *cmd_name, void (*function) (void)); +#endif // FN_AddServerCommand + +#ifdef FN_Voice_GetClientListening +qboolean FN_Voice_GetClientListening(int iReceiver, int iSender); +#endif // FN_Voice_GetClientListening + +#ifdef FN_Voice_SetClientListening +qboolean FN_Voice_SetClientListening(int iReceiver, int iSender, qboolean bListen); +#endif // FN_Voice_SetClientListening + +#ifdef FN_GetPlayerAuthId +const char *FN_GetPlayerAuthId(edict_t *e); +#endif // FN_GetPlayerAuthId + + + + + + +#ifdef FN_PrecacheModel_Post +int FN_PrecacheModel_Post(char *s); +#endif // FN_PrecacheModel_Post + +#ifdef FN_PrecacheSound_Post +int FN_PrecacheSound_Post(char *s); +#endif // FN_PrecacheSound_Post + +#ifdef FN_SetModel_Post +void FN_SetModel_Post(edict_t *e, const char *m); +#endif // FN_SetModel_Post + +#ifdef FN_ModelIndex_Post +int FN_ModelIndex_Post(const char *m); +#endif // FN_ModelIndex_Post + +#ifdef FN_ModelFrames_Post +int FN_ModelFrames_Post(int modelIndex); +#endif // FN_ModelFrames_Post + +#ifdef FN_SetSize_Post +void FN_SetSize_Post(edict_t *e, const float *rgflMin, const float *rgflMax); +#endif // FN_SetSize_Post + +#ifdef FN_ChangeLevel_Post +void FN_ChangeLevel_Post(char *s1, char *s2); +#endif // FN_ChangeLevel_Post + +#ifdef FN_GetSpawnParms_Post +void FN_GetSpawnParms_Post(edict_t *ent); +#endif // FN_GetSpawnParms_Post + +#ifdef FN_SaveSpawnParms_Post +void FN_SaveSpawnParms_Post(edict_t *ent); +#endif // FN_SaveSpawnParms_Post + +#ifdef FN_VecToYaw_Post +float FN_VecToYaw_Post(const float *rgflVector); +#endif // FN_VecToYaw_Post + +#ifdef FN_VecToAngles_Post +void FN_VecToAngles_Post(const float *rgflVectorIn, float *rgflVectorOut); +#endif // FN_VecToAngles_Post + +#ifdef FN_MoveToOrigin_Post +void FN_MoveToOrigin_Post(edict_t *ent, const float *pflGoal, float dist, int iMoveType); +#endif // FN_MoveToOrigin_Post + +#ifdef FN_ChangeYaw_Post +void FN_ChangeYaw_Post(edict_t *ent); +#endif // FN_ChangeYaw_Post + +#ifdef FN_ChangePitch_Post +void FN_ChangePitch_Post(edict_t *ent); +#endif // FN_ChangePitch_Post + +#ifdef FN_FindEntityByString_Post +edict_t *FN_FindEntityByString_Post(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue); +#endif // FN_FindEntityByString_Post + +#ifdef FN_GetEntityIllum_Post +int FN_GetEntityIllum_Post(edict_t *pEnt); +#endif // FN_GetEntityIllum_Post + +#ifdef FN_FindEntityInSphere_Post +edict_t *FN_FindEntityInSphere_Post(edict_t *pEdictStartSearchAfter, const float *org, float rad); +#endif // FN_FindEntityInSphere_Post + +#ifdef FN_FindClientInPVS_Post +edict_t *FN_FindClientInPVS_Post(edict_t *pEdict); +#endif // FN_FindClientInPVS_Post + +#ifdef FN_EntitiesInPVS_Post +edict_t *FN_EntitiesInPVS_Post(edict_t *pplayer); +#endif // FN_EntitiesInPVS_Post + +#ifdef FN_MakeVectors_Post +void FN_MakeVectors_Post(const float *rgflVector); +#endif // FN_MakeVectors_Post + +#ifdef FN_AngleVectors_Post +void FN_AngleVectors_Post(const float *rgflVector, float *forward, float *right, float *up); +#endif // FN_AngleVectors_Post + +#ifdef FN_CreateEntity_Post +edict_t *FN_CreateEntity_Post(void); +#endif // FN_CreateEntity_Post + +#ifdef FN_RemoveEntity_Post +void FN_RemoveEntity_Post(edict_t *e); +#endif // FN_RemoveEntity_Post + +#ifdef FN_CreateNamedEntity_Post +edict_t *FN_CreateNamedEntity_Post(int className); +#endif // FN_CreateNamedEntity_Post + +#ifdef FN_MakeStatic_Post +void FN_MakeStatic_Post(edict_t *ent); +#endif // FN_MakeStatic_Post + +#ifdef FN_EntIsOnFloor_Post +int FN_EntIsOnFloor_Post(edict_t *ent); +#endif // FN_EntIsOnFloor_Post + +#ifdef FN_DropToFloor_Post +int FN_DropToFloor_Post(edict_t *ent); +#endif // FN_DropToFloor_Post + +#ifdef FN_WalkMove_Post +int FN_WalkMove_Post(edict_t *ent, float yaw, float dist, int iMode); +#endif // FN_WalkMove_Post + +#ifdef FN_SetOrigin_Post +void FN_SetOrigin_Post(edict_t *e, const float *rgflOrigin); +#endif // FN_SetOrigin_Post + +#ifdef FN_EmitSound_Post +void FN_EmitSound_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch); +#endif // FN_EmitSound_Post + +#ifdef FN_EmitAmbientSound_Post +void FN_EmitAmbientSound_Post(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch); +#endif // FN_EmitAmbientSound_Post + +#ifdef FN_TraceLine_Post +void FN_TraceLine_Post(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceLine_Post + +#ifdef FN_TraceToss_Post +void FN_TraceToss_Post(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr); +#endif // FN_TraceToss_Post + +#ifdef FN_TraceMonsterHull_Post +int FN_TraceMonsterHull_Post(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceMonsterHull_Post + +#ifdef FN_TraceHull_Post +void FN_TraceHull_Post(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceHull_Post + +#ifdef FN_TraceModel_Post +void FN_TraceModel_Post(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr); +#endif // FN_TraceModel_Post + +#ifdef FN_TraceTexture_Post +const char *FN_TraceTexture_Post(edict_t *pTextureEntity, const float *v1, const float *v2 ); +#endif // FN_TraceTexture_Post + +#ifdef FN_TraceSphere_Post +void FN_TraceSphere_Post(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr); +#endif // FN_TraceSphere_Post + +#ifdef FN_GetAimVector_Post +void FN_GetAimVector_Post(edict_t *ent, float speed, float *rgflReturn); +#endif // FN_GetAimVector_Post + +#ifdef FN_ServerCommand_Post +void FN_ServerCommand_Post(char *str); +#endif // FN_ServerCommand_Post + +#ifdef FN_ServerExecute_Post +void FN_ServerExecute_Post(void); +#endif // FN_ServerExecute_Post + +#ifdef FN_engClientCommand_Post +void FN_engClientCommand_Post(edict_t *pEdict, char *szFmt, ...); +#endif // FN_engClientCommand_Post + +#ifdef FN_ParticleEffect_Post +void FN_ParticleEffect_Post(const float *org, const float *dir, float color, float count); +#endif // FN_ParticleEffect_Post + +#ifdef FN_LightStyle_Post +void FN_LightStyle_Post(int style, char *val); +#endif // FN_LightStyle_Post + +#ifdef FN_DecalIndex_Post +int FN_DecalIndex_Post(const char *name); +#endif // FN_DecalIndex_Post + +#ifdef FN_PointContents_Post +int FN_PointContents_Post(const float *rgflVector); +#endif // FN_PointContents_Post + +#ifdef FN_MessageBegin_Post +void FN_MessageBegin_Post(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_MessageBegin_Post + +#ifdef FN_MessageEnd_Post +void FN_MessageEnd_Post(void); +#endif // FN_MessageEnd_Post + +#ifdef FN_WriteByte_Post +void FN_WriteByte_Post(int iValue); +#endif // FN_WriteByte_Post + +#ifdef FN_WriteChar_Post +void FN_WriteChar_Post(int iValue); +#endif // FN_WriteChar_Post + +#ifdef FN_WriteShort_Post +void FN_WriteShort_Post(int iValue); +#endif // FN_WriteShort_Post + +#ifdef FN_WriteLong_Post +void FN_WriteLong_Post(int iValue); +#endif // FN_WriteLong_Post + +#ifdef FN_WriteAngle_Post +void FN_WriteAngle_Post(float flValue); +#endif // FN_WriteAngle_Post + +#ifdef FN_WriteCoord_Post +void FN_WriteCoord_Post(float flValue); +#endif // FN_WriteCoord_Post + +#ifdef FN_WriteString_Post +void FN_WriteString_Post(const char *sz); +#endif // FN_WriteString_Post + +#ifdef FN_WriteEntity_Post +void FN_WriteEntity_Post(int iValue); +#endif // FN_WriteEntity_Post + +#ifdef FN_CVarRegister_Post +void FN_CVarRegister_Post(cvar_t *pCvar); +#endif // FN_CVarRegister_Post + +#ifdef FN_CVarGetFloat_Post +float FN_CVarGetFloat_Post(const char *szVarName); +#endif // FN_CVarGetFloat_Post + +#ifdef FN_CVarGetString_Post +const char *FN_CVarGetString_Post(const char *szVarName); +#endif // FN_CVarGetString_Post + +#ifdef FN_CVarSetFloat_Post +void FN_CVarSetFloat_Post(const char *szVarName, float flValue); +#endif // FN_CVarSetFloat_Post + +#ifdef FN_CVarSetString_Post +void FN_CVarSetString_Post(const char *szVarName, const char *szValue); +#endif // FN_CVarSetString_Post + +#ifdef FN_AlertMessage_Post +void FN_AlertMessage_Post(ALERT_TYPE atype, char *szFmt, ...); +#endif // FN_AlertMessage_Post + +#ifdef FN_EngineFprintf_Post +void FN_EngineFprintf_Post(FILE *pfile, char *szFmt, ...); +#endif // FN_EngineFprintf_Post + +#ifdef FN_PvAllocEntPrivateData_Post +void *FN_PvAllocEntPrivateData_Post(edict_t *pEdict, long cb); +#endif // FN_PvAllocEntPrivateData_Post + +#ifdef FN_PvEntPrivateData_Post +void *FN_PvEntPrivateData_Post(edict_t *pEdict); +#endif // FN_PvEntPrivateData_Post + +#ifdef FN_FreeEntPrivateData_Post +void FN_FreeEntPrivateData_Post(edict_t *pEdict); +#endif // FN_FreeEntPrivateData_Post + +#ifdef FN_SzFromIndex_Post +const char *FN_SzFromIndex_Post(int iString); +#endif // FN_SzFromIndex_Post + +#ifdef FN_AllocString_Post +int FN_AllocString_Post(const char *szValue); +#endif // FN_AllocString_Post + +#ifdef FN_GetVarsOfEnt_Post +struct entvars_s *FN_GetVarsOfEnt_Post(edict_t *pEdict); +#endif // FN_GetVarsOfEnt_Post + +#ifdef FN_PEntityOfEntOffset_Post +edict_t *FN_PEntityOfEntOffset_Post(int iEntOffset); +#endif // FN_PEntityOfEntOffset_Post + +#ifdef FN_EntOffsetOfPEntity_Post +int FN_EntOffsetOfPEntity_Post(const edict_t *pEdict); +#endif // FN_EntOffsetOfPEntity_Post + +#ifdef FN_IndexOfEdict_Post +int FN_IndexOfEdict_Post(const edict_t *pEdict); +#endif // FN_IndexOfEdict_Post + +#ifdef FN_PEntityOfEntIndex_Post +edict_t *FN_PEntityOfEntIndex_Post(int iEntIndex); +#endif // FN_PEntityOfEntIndex_Post + +#ifdef FN_FindEntityByVars_Post +edict_t *FN_FindEntityByVars_Post(struct entvars_s *pvars); +#endif // FN_FindEntityByVars_Post + +#ifdef FN_GetModelPtr_Post +void *FN_GetModelPtr_Post(edict_t *pEdict); +#endif // FN_GetModelPtr_Post + +#ifdef FN_RegUserMsg_Post +int FN_RegUserMsg_Post(const char *pszName, int iSize); +#endif // FN_RegUserMsg_Post + +#ifdef FN_AnimationAutomove_Post +void FN_AnimationAutomove_Post(const edict_t *pEdict, float flTime); +#endif // FN_AnimationAutomove_Post + +#ifdef FN_GetBonePosition_Post +void FN_GetBonePosition_Post(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles); +#endif // FN_GetBonePosition_Post + +#ifdef FN_FunctionFromName_Post +unsigned long FN_FunctionFromName_Post(const char *pName); +#endif // FN_FunctionFromName_Post + +#ifdef FN_NameForFunction_Post +const char *FN_NameForFunction_Post(unsigned long function); +#endif // FN_NameForFunction_Post + +#ifdef FN_ClientPrintf_Post +void FN_ClientPrintf_Post(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg); +#endif // FN_ClientPrintf_Post + +#ifdef FN_ServerPrint_Post +void FN_ServerPrint_Post(const char *szMsg); +#endif // FN_ServerPrint_Post + +#ifdef FN_Cmd_Args_Post +const char *FN_Cmd_Args_Post(void); +#endif // FN_Cmd_Args_Post + +#ifdef FN_Cmd_Argv_Post +const char *FN_Cmd_Argv_Post(int argc); +#endif // FN_Cmd_Argv_Post + +#ifdef FN_Cmd_Argc_Post +int FN_Cmd_Argc_Post(void); +#endif // FN_Cmd_Argc_Post + +#ifdef FN_GetAttachment_Post +void FN_GetAttachment_Post(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles ); +#endif // FN_GetAttachment_Post + +#ifdef FN_CRC32_Init_Post +void FN_CRC32_Init_Post(CRC32_t *pulCRC); +#endif // FN_CRC32_Init_Post + +#ifdef FN_CRC32_ProcessBuffer_Post +void FN_CRC32_ProcessBuffer_Post(CRC32_t *pulCRC, void *p, int len); +#endif // FN_CRC32_ProcessBuffer_Post + +#ifdef FN_CRC32_ProcessByte_Post +void FN_CRC32_ProcessByte_Post(CRC32_t *pulCRC, unsigned char ch); +#endif // FN_CRC32_ProcessByte_Post + +#ifdef FN_CRC32_Final_Post +CRC32_t FN_CRC32_Final_Post(CRC32_t pulCRC); +#endif // FN_CRC32_Final_Post + +#ifdef FN_RandomLong_Post +long FN_RandomLong_Post(long lLow, long lHigh); +#endif // FN_RandomLong_Post + +#ifdef FN_RandomFloat_Post +float FN_RandomFloat_Post(float flLow, float flHigh); +#endif // FN_RandomFloat_Post + +#ifdef FN_SetView_Post +void FN_SetView_Post(const edict_t *pClient, const edict_t *pViewent); +#endif // FN_SetView_Post + +#ifdef FN_Time_Post +float FN_Time_Post(void); +#endif // FN_Time_Post + +#ifdef FN_CrosshairAngle_Post +void FN_CrosshairAngle_Post(const edict_t *pClient, float pitch, float yaw); +#endif // FN_CrosshairAngle_Post + +#ifdef FN_LoadFileForMe_Post +byte *FN_LoadFileForMe_Post(char *filename, int *pLength); +#endif // FN_LoadFileForMe_Post + +#ifdef FN_FreeFile_Post +void FN_FreeFile_Post(void *buffer); +#endif // FN_FreeFile_Post + +#ifdef FN_EndSection_Post +void FN_EndSection_Post(const char *pszSectionName); +#endif // FN_EndSection_Post + +#ifdef FN_CompareFileTime_Post +int FN_CompareFileTime_Post(char *filename1, char *filename2, int *iCompare); +#endif // FN_CompareFileTime_Post + +#ifdef FN_GetGameDir_Post +void FN_GetGameDir_Post(char *szGetGameDir); +#endif // FN_GetGameDir_Post + +#ifdef FN_Cvar_RegisterVariable_Post +void FN_Cvar_RegisterVariable_Post(cvar_t *variable); +#endif // FN_Cvar_RegisterVariable_Post + +#ifdef FN_FadeClientVolume_Post +void FN_FadeClientVolume_Post(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds); +#endif // FN_FadeClientVolume_Post + +#ifdef FN_SetClientMaxspeed_Post +void FN_SetClientMaxspeed_Post(const edict_t *pEdict, float fNewMaxspeed); +#endif // FN_SetClientMaxspeed_Post + +#ifdef FN_CreateFakeClient_Post +edict_t *FN_CreateFakeClient_Post(const char *netname); +#endif // FN_CreateFakeClient_Post + +#ifdef FN_RunPlayerMove_Post +void FN_RunPlayerMove_Post(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec); +#endif // FN_RunPlayerMove_Post + +#ifdef FN_NumberOfEntities_Post +int FN_NumberOfEntities_Post(void); +#endif // FN_NumberOfEntities_Post + +#ifdef FN_GetInfoKeyBuffer_Post +char *FN_GetInfoKeyBuffer_Post(edict_t *e); +#endif // FN_GetInfoKeyBuffer_Post + +#ifdef FN_InfoKeyValue_Post +char *FN_InfoKeyValue_Post(char *infobuffer, char *key); +#endif // FN_InfoKeyValue_Post + +#ifdef FN_SetKeyValue_Post +void FN_SetKeyValue_Post(char *infobuffer, char *key, char *value); +#endif // FN_SetKeyValue_Post + +#ifdef FN_SetClientKeyValue_Post +void FN_SetClientKeyValue_Post(int clientIndex, char *infobuffer, char *key, char *value); +#endif // FN_SetClientKeyValue_Post + +#ifdef FN_IsMapValid_Post +int FN_IsMapValid_Post(char *filename); +#endif // FN_IsMapValid_Post + +#ifdef FN_StaticDecal_Post +void FN_StaticDecal_Post(const float *origin, int decalIndex, int entityIndex, int modelIndex); +#endif // FN_StaticDecal_Post + +#ifdef FN_PrecacheGeneric_Post +int FN_PrecacheGeneric_Post(char *s); +#endif // FN_PrecacheGeneric_Post + +#ifdef FN_GetPlayerUserId_Post +int FN_GetPlayerUserId_Post(edict_t *e ); +#endif // FN_GetPlayerUserId_Post + +#ifdef FN_BuildSoundMsg_Post +void FN_BuildSoundMsg_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed); +#endif // FN_BuildSoundMsg_Post + +#ifdef FN_IsDedicatedServer_Post +int FN_IsDedicatedServer_Post(void); +#endif // FN_IsDedicatedServer_Post + +#ifdef FN_CVarGetPointer_Post +cvar_t *FN_CVarGetPointer_Post(const char *szVarName); +#endif // FN_CVarGetPointer_Post + +#ifdef FN_GetPlayerWONId_Post +unsigned int FN_GetPlayerWONId_Post(edict_t *e); +#endif // FN_GetPlayerWONId_Post + +#ifdef FN_Info_RemoveKey_Post +void FN_Info_RemoveKey_Post( char *s, const char *key); +#endif // FN_Info_RemoveKey_Post + +#ifdef FN_GetPhysicsKeyValue_Post +const char *FN_GetPhysicsKeyValue_Post(const edict_t *pClient, const char *key); +#endif // FN_GetPhysicsKeyValue_Post + +#ifdef FN_SetPhysicsKeyValue_Post +void FN_SetPhysicsKeyValue_Post(const edict_t *pClient, const char *key, const char *value); +#endif // FN_SetPhysicsKeyValue_Post + +#ifdef FN_GetPhysicsInfoString_Post +const char *FN_GetPhysicsInfoString_Post( const edict_t *pClient); +#endif // FN_GetPhysicsInfoString_Post + +#ifdef FN_PrecacheEvent_Post +unsigned short FN_PrecacheEvent_Post(int type, const char *psz); +#endif // FN_PrecacheEvent_Post + +#ifdef FN_PlaybackEvent_Post +void FN_PlaybackEvent_Post(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2); +#endif // FN_PlaybackEvent_Post + +#ifdef FN_SetFatPVS_Post +unsigned char *FN_SetFatPVS_Post(float *org); +#endif // FN_SetFatPVS_Post + +#ifdef FN_SetFatPAS_Post +unsigned char *FN_SetFatPAS_Post(float *org); +#endif // FN_SetFatPAS_Post + +#ifdef FN_CheckVisibility_Post +int FN_CheckVisibility_Post(const edict_t *entity, unsigned char *pset); +#endif // FN_CheckVisibility_Post + +#ifdef FN_DeltaSetField_Post +void FN_DeltaSetField_Post(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaSetField_Post + +#ifdef FN_DeltaUnsetField_Post +void FN_DeltaUnsetField_Post(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaUnsetField_Post + +#ifdef FN_DeltaAddEncoder_Post +void FN_DeltaAddEncoder_Post(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) ); +#endif // FN_DeltaAddEncoder_Post + +#ifdef FN_GetCurrentPlayer_Post +int FN_GetCurrentPlayer_Post(void); +#endif // FN_GetCurrentPlayer_Post + +#ifdef FN_CanSkipPlayer_Post +int FN_CanSkipPlayer_Post(const edict_t *player); +#endif // FN_CanSkipPlayer_Post + +#ifdef FN_DeltaFindField_Post +int FN_DeltaFindField_Post(struct delta_s *pFields, const char *fieldname); +#endif // FN_DeltaFindField_Post + +#ifdef FN_DeltaSetFieldByIndex_Post +void FN_DeltaSetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaSetFieldByIndex_Post + +#ifdef FN_DeltaUnsetFieldByIndex_Post +void FN_DeltaUnsetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber); +#endif // FN_DeltaUnsetFieldByIndex_Post + +#ifdef FN_SetGroupMask_Post +void FN_SetGroupMask_Post(int mask, int op); +#endif // FN_SetGroupMask_Post + +#ifdef FN_engCreateInstancedBaseline_Post +int FN_engCreateInstancedBaseline_Post(int classname, struct entity_state_s *baseline); +#endif // FN_engCreateInstancedBaseline_Post + +#ifdef FN_Cvar_DirectSet_Post +void FN_Cvar_DirectSet_Post(struct cvar_s *var, char *value); +#endif // FN_Cvar_DirectSet_Post + +#ifdef FN_ForceUnmodified_Post +void FN_ForceUnmodified_Post(FORCE_TYPE type, float *mins, float *maxs, const char *filename); +#endif // FN_ForceUnmodified_Post + +#ifdef FN_GetPlayerStats_Post +void FN_GetPlayerStats_Post(const edict_t *pClient, int *ping, int *packet_loss); +#endif // FN_GetPlayerStats_Post + +#ifdef FN_AddServerCommand_Post +void FN_AddServerCommand_Post(char *cmd_name, void (*function)(void)); +#endif // FN_AddServerCommand_Post + +#ifdef FN_Voice_GetClientListening_Post +qboolean FN_Voice_GetClientListening_Post(int iReceiver, int iSender); +#endif // FN_Voice_GetClientListening_Post + +#ifdef FN_Voice_SetClientListening_Post +qboolean FN_Voice_SetClientListening_Post(int iReceiver, int iSender, qboolean bListen); +#endif // FN_Voice_SetClientListening_Post + +#ifdef FN_GetPlayerAuthId_Post +const char *FN_GetPlayerAuthId_Post(edict_t *e); +#endif // FN_GetPlayerAuthId + + + + +#ifdef FN_OnFreeEntPrivateData +void FN_OnFreeEntPrivateData(edict_t *pEnt); +#endif // FN_OnFreeEntPrivateData + +#ifdef FN_GameShutdown +void FN_GameShutdown(void); +#endif // FN_GameShutdown + +#ifdef FN_ShouldCollide +int FN_ShouldCollide(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_ShouldCollide + + + + + +#ifdef FN_OnFreeEntPrivateData_Post +void FN_OnFreeEntPrivateData_Post(edict_t *pEnt); +#endif // FN_OnFreeEntPrivateData_Post + +#ifdef FN_GameShutdown_Post +void FN_GameShutdown_Post(void); +#endif // FN_GameShutdown_Post + +#ifdef FN_ShouldCollide_Post +int FN_ShouldCollide_Post(edict_t *pentTouched, edict_t *pentOther); +#endif // FN_ShouldCollide_Post + +#endif // USE_METAMOD + + +#ifdef FN_AMXX_QUERY +void FN_AMXX_QUERY(void); +#endif // FN_AMXX_QUERY + +#ifdef FN_AMXX_ATTACH +void FN_AMXX_ATTACH(void); +#endif // FN_AMXX_ATTACH + +#ifdef FN_AMXX_DETACH +void FN_AMXX_DETACH(void); +#endif // FN_AMXX_DETACH + +#ifdef FN_AMXX_PLUGINSLOADED +void FN_AMXX_PLUGINSLOADED(void); +#endif // FN_AMXX_PLUGINSLOADED + +// *** Types *** +typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/); + +// ***** Module funcs stuff ***** +enum ForwardExecType +{ + ET_IGNORE = 0, // Ignore return vaue + ET_STOP, // Stop on PLUGIN_HANDLED + ET_STOP2, // Stop on PLUGIN_HANDLED, continue on other values, return biggest return value + ET_CONTINUE, // Continue; return biggest return value +}; + +enum ForwardParam +{ + FP_DONE = -1, // specify this as the last argument + // only tells the function that there are no more arguments + FP_CELL, // normal cell + FP_FLOAT, // float; used as normal cell though + FP_STRING, // string + FP_STRINGEX, // string; will be updated to the last function's value + FP_ARRAY, // array; use the return value of prepareArray. +}; + + +typedef int (*PFN_ADD_NATIVES) (const AMX_NATIVE_INFO * /*list*/); +typedef char * (*PFN_BUILD_PATHNAME) (const char * /*format*/, ...); +typedef char * (*PFN_BUILD_PATHNAME_R) (char * /*buffer*/, size_t /* maxlen */, const char * /* format */, ...); +typedef cell * (*PFN_GET_AMXADDR) (AMX * /*amx*/, cell /*offset*/); +typedef void (*PFN_PRINT_SRVCONSOLE) (char * /*format*/, ...); +typedef const char * (*PFN_GET_MODNAME) (void); +typedef const char * (*PFN_GET_AMXSCRIPTNAME) (int /*id*/); +typedef AMX * (*PFN_GET_AMXSCRIPT) (int /*id*/); +typedef int (*PFN_FIND_AMXSCRIPT_BYAMX) (const AMX * /*amx*/); +typedef int (*PFN_FIND_AMXSCRIPT_BYNAME) (const char * /*name*/); +typedef int (*PFN_SET_AMXSTRING) (AMX * /*amx*/, cell /*amx_addr*/, const char * /* source */, int /* max */); +typedef char * (*PFN_GET_AMXSTRING) (AMX * /*amx*/, cell /*amx_addr*/, int /*bufferId*/, int * /*pLen*/); +typedef int (*PFN_GET_AMXSTRINGLEN) (const cell *ptr); +typedef char * (*PFN_FORMAT_AMXSTRING) (AMX * /*amx*/, cell * /*params*/, int /*startParam*/, int * /*pLen*/); +typedef void (*PFN_COPY_AMXMEMORY) (cell * /*dest*/, const cell * /*src*/, int /*len*/); +typedef void (*PFN_LOG) (const char * /*fmt*/, ...); +typedef void (*PFN_LOG_ERROR) (AMX * /*amx*/, int /*err*/, const char * /*fmt*/, ...); +typedef int (*PFN_RAISE_AMXERROR) (AMX * /*amx*/, int /*error*/); +typedef int (*PFN_REGISTER_FORWARD) (const char * /*funcname*/, ForwardExecType /*exectype*/, ... /*paramtypes terminated by PF_DONE*/); +typedef int (*PFN_EXECUTE_FORWARD) (int /*id*/, ... /*params*/); +typedef cell (*PFN_PREPARE_CELLARRAY) (cell * /*ptr*/, unsigned int /*size*/); +typedef cell (*PFN_PREPARE_CHARARRAY) (char * /*ptr*/, unsigned int /*size*/); +typedef cell (*PFN_PREPARE_CELLARRAY_A) (cell * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/); +typedef cell (*PFN_PREPARE_CHARARRAY_A) (char * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/); +typedef int (*PFN_IS_PLAYER_VALID) (int /*id*/); +typedef const char * (*PFN_GET_PLAYER_NAME) (int /*id*/); +typedef const char * (*PFN_GET_PLAYER_IP) (int /*id*/); +typedef int (*PFN_IS_PLAYER_INGAME) (int /*id*/); +typedef int (*PFN_IS_PLAYER_BOT) (int /*id*/); +typedef int (*PFN_IS_PLAYER_AUTHORIZED) (int /*id*/); +typedef float (*PFN_GET_PLAYER_TIME) (int /*id*/); +typedef float (*PFN_GET_PLAYER_PLAYTIME) (int /*id*/); +typedef int (*PFN_GETPLAYERFLAGS) (int /* id*/); +typedef int (*PFN_GET_PLAYER_CURWEAPON) (int /*id*/); +typedef const char * (*PFN_GET_PLAYER_TEAM) (int /*id*/); +typedef int (*PFN_GET_PLAYER_TEAMID) (int /*id*/); +typedef int (*PFN_GET_PLAYER_DEATHS) (int /*id*/); +typedef int (*PFN_GET_PLAYER_MENU) (int /*id*/); +typedef int (*PFN_GET_PLAYER_KEYS) (int /*id*/); +typedef int (*PFN_IS_PLAYER_ALIVE) (int /*id*/); +typedef int (*PFN_GET_PLAYER_FRAGS) (int /*id*/); +typedef int (*PFN_IS_PLAYER_CONNECTING) (int /*id*/); +typedef int (*PFN_IS_PLAYER_HLTV) (int /*id*/); +typedef int (*PFN_GET_PLAYER_ARMOR) (int /*id*/); +typedef int (*PFN_GET_PLAYER_HEALTH) (int /*id*/); +#ifdef USE_METAMOD +typedef edict_t * (*PFN_GET_PLAYER_EDICT) (int /*id*/); +#else +typedef void * (*PFN_GET_PLAYER_EDICT) (int /*id*/); +#endif + +typedef void * (*PFN_ALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/, + const unsigned int /*type*/, const size_t /*size*/); +typedef void * (*PFN_REALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/, + const unsigned int /*type*/, const size_t /*size*/, void* /*addr*/ ); +typedef void (*PFN_DEALLOCATOR) (const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/, + const unsigned int /*type*/, const void* /*addr*/ ); +typedef int (*PFN_AMX_EXEC) (AMX* /*amx*/, cell* /*return val*/, int /*index*/); +typedef int (*PFN_AMX_EXECV) (AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, cell[] /*params*/); +typedef int (*PFN_AMX_ALLOT) (AMX* /*amx*/, int /*length*/, cell* /*amx_addr*/, cell** /*phys_addr*/); +typedef int (*PFN_AMX_FINDPUBLIC) (AMX* /*amx*/, char* /*func name*/, int* /*index*/); +typedef int (*PFN_AMX_FINDNATIVE) (AMX* /*amx*/, char* /*func name*/, int* /*index*/); +typedef int (*PFN_LOAD_AMXSCRIPT) (AMX* /*amx*/, void** /*code*/, const char* /*path*/, char[64] /*error info*/, int /* debug */); +typedef int (*PFN_UNLOAD_AMXSCRIPT) (AMX* /*amx*/,void** /*code*/); +typedef cell (*PFN_REAL_TO_CELL) (REAL /*x*/); +typedef REAL (*PFN_CELL_TO_REAL) (cell /*x*/); +typedef int (*PFN_REGISTER_SPFORWARD) (AMX * /*amx*/, int /*func*/, ... /*params*/); +typedef int (*PFN_REGISTER_SPFORWARD_BYNAME) (AMX * /*amx*/, const char * /*funcName*/, ... /*params*/); +typedef void (*PFN_UNREGISTER_SPFORWARD) (int /*id*/); +typedef void (*PFN_MERGEDEFINITION_FILE) (const char * /*filename*/); +typedef const char * (*PFN_FORMAT) (const char * /*fmt*/, ... /*params*/); +typedef void (*PFN_REGISTERFUNCTION) (void * /*pfn*/, const char * /*desc*/); +typedef int (*PFN_AMX_PUSH) (AMX * /*amx*/, cell /*value*/); + +extern PFN_ADD_NATIVES g_fn_AddNatives; +extern PFN_BUILD_PATHNAME g_fn_BuildPathname; +extern PFN_BUILD_PATHNAME_R g_fn_BuildPathnameR; +extern PFN_GET_AMXADDR g_fn_GetAmxAddr; +extern PFN_PRINT_SRVCONSOLE g_fn_PrintSrvConsole; +extern PFN_GET_MODNAME g_fn_GetModname; +extern PFN_GET_AMXSCRIPTNAME g_fn_GetAmxScriptName; +extern PFN_GET_AMXSCRIPT g_fn_GetAmxScript; +extern PFN_FIND_AMXSCRIPT_BYAMX g_fn_FindAmxScriptByAmx; +extern PFN_FIND_AMXSCRIPT_BYNAME g_fn_FindAmxScriptByName; +extern PFN_SET_AMXSTRING g_fn_SetAmxString; +extern PFN_GET_AMXSTRING g_fn_GetAmxString; +extern PFN_GET_AMXSTRINGLEN g_fn_GetAmxStringLen; +extern PFN_FORMAT_AMXSTRING g_fn_FormatAmxString; +extern PFN_COPY_AMXMEMORY g_fn_CopyAmxMemory; +extern PFN_LOG g_fn_Log; +extern PFN_LOG_ERROR g_fn_LogErrorFunc; +extern PFN_RAISE_AMXERROR g_fn_RaiseAmxError; +extern PFN_REGISTER_FORWARD g_fn_RegisterForward; +extern PFN_EXECUTE_FORWARD g_fn_ExecuteForward; +extern PFN_PREPARE_CELLARRAY g_fn_PrepareCellArray; +extern PFN_PREPARE_CHARARRAY g_fn_PrepareCharArray; +extern PFN_PREPARE_CELLARRAY_A g_fn_PrepareCellArrayA; +extern PFN_PREPARE_CHARARRAY_A g_fn_PrepareCharArrayA; +extern PFN_IS_PLAYER_VALID g_fn_IsPlayerValid; +extern PFN_GET_PLAYER_NAME g_fn_GetPlayerName; +extern PFN_GET_PLAYER_IP g_fn_GetPlayerIP; +extern PFN_IS_PLAYER_INGAME g_fn_IsPlayerIngame; +extern PFN_IS_PLAYER_BOT g_fn_IsPlayerBot; +extern PFN_IS_PLAYER_AUTHORIZED g_fn_IsPlayerAuthorized; +extern PFN_GET_PLAYER_TIME g_fn_GetPlayerTime; +extern PFN_GET_PLAYER_PLAYTIME g_fn_GetPlayerPlayTime; +extern PFN_GET_PLAYER_CURWEAPON g_fn_GetPlayerCurweapon; +extern PFN_GET_PLAYER_TEAMID g_fn_GetPlayerTeamID; +extern PFN_GET_PLAYER_DEATHS g_fn_GetPlayerDeaths; +extern PFN_GET_PLAYER_MENU g_fn_GetPlayerMenu; +extern PFN_GET_PLAYER_KEYS g_fn_GetPlayerKeys; +extern PFN_IS_PLAYER_ALIVE g_fn_IsPlayerAlive; +extern PFN_GET_PLAYER_FRAGS g_fn_GetPlayerFrags; +extern PFN_IS_PLAYER_CONNECTING g_fn_IsPlayerConnecting; +extern PFN_IS_PLAYER_HLTV g_fn_IsPlayerHLTV; +extern PFN_GET_PLAYER_ARMOR g_fn_GetPlayerArmor; +extern PFN_GET_PLAYER_HEALTH g_fn_GetPlayerHealth; +extern PFN_AMX_EXEC g_fn_AmxExec; +extern PFN_AMX_EXECV g_fn_AmxExecv; +extern PFN_AMX_ALLOT g_fn_AmxAllot; +extern PFN_AMX_FINDPUBLIC g_fn_AmxFindPublic; +extern PFN_LOAD_AMXSCRIPT g_fn_LoadAmxScript; +extern PFN_UNLOAD_AMXSCRIPT g_fn_UnloadAmxScript; +extern PFN_REAL_TO_CELL g_fn_RealToCell; +extern PFN_CELL_TO_REAL g_fn_CellToReal; +extern PFN_REGISTER_SPFORWARD g_fn_RegisterSPForward; +extern PFN_REGISTER_SPFORWARD_BYNAME g_fn_RegisterSPForwardByName; +extern PFN_UNREGISTER_SPFORWARD g_fn_UnregisterSPForward; +extern PFN_MERGEDEFINITION_FILE g_fn_MergeDefinition_File; +extern PFN_AMX_FINDNATIVE g_fn_AmxFindNative; +extern PFN_GETPLAYERFLAGS g_fn_GetPlayerFlags; +extern PFN_GET_PLAYER_EDICT g_fn_GetPlayerEdict; +extern PFN_FORMAT g_fn_Format; +extern PFN_GET_PLAYER_TEAM g_fn_GetPlayerTeam; +extern PFN_REGISTERFUNCTION g_fn_RegisterFunction; +extern PFN_REQ_FNPTR g_fn_RequestFunction; +extern PFN_AMX_PUSH g_fn_AmxPush; + +#ifdef MAY_NEVER_BE_DEFINED +// Function prototypes for intellisense and similar systems +// They understand #if 0 so we use #ifdef MAY_NEVER_BE_DEFINED +int MF_AddNatives (const AMX_NATIVE_INFO *list) { } +char * MF_BuildPathname (const char * format, ...) { } +char * MF_BuildPathnameR (char *buffer, size_t maxlen, const char *fmt, ...) { } +cell * MF_GetAmxAddr (AMX * amx, cell offset) { } +void MF_PrintSrvConsole (char * format, ...) { } +const char * MF_GetModname (void) { } +const char * MF_GetScriptName (int id) { } +AMX * MF_GetScriptAmx (int id) { } +int MF_FindScriptByAmx (const AMX * amx) { } +int MF_FindScriptByAmx (const char * name) { } +int MF_SetAmxString (AMX * amx, cell amx_addr, const char * source , int max ) { } +char * MF_GetAmxString (AMX * amx, cell amx_addr, int bufferId, int * pLen) { } +int MF_GetAmxStringLen (const cell *ptr) { } +char * MF_FormatAmxString (AMX * amx, cell * params, int startParam, int * pLen) { } +void MF_CopyAmxMemory (cell * dest, const cell * src, int len) { } +void MF_Log (const char * fmt, ...) { } +void MF_LogError (AMX * amx, int err, const char *fmt, ...) { } +int MF_RaiseAmxError (AMX * amx, int error) { } +int MF_RegisterForward (const char * funcname, ForwardExecType exectype, ...) { } +int MF_ExecuteForward (int id, ...) { } +cell MF_PrepareCellArray (cell * ptr, unsigned int size) { } +cell MF_PrepareCharArray (char * ptr, unsigned int size) { } +cell MF_PrepareCellArrayA (cell * ptr, unsigned int size, bool copyBack) { } +cell MF_PrepareCharArrayA (char * ptr, unsigned int size, bool copyBack) { } +int MF_IsPlayerValid (int id) { } +const char * MF_GetPlayerName (int id) { } +const char * MF_GetPlayerIP (int id) { } +int MF_IsPlayerIngame (int id) { } +int MF_IsPlayerBot (int id) { } +int MF_IsPlayerAuthorized (int id) { } +float MF_GetPlayerTime (int id) { } +float MF_GetPlayerPlayTime (int id) { } +int MF_GetPlayerCurweapon (int id) { } +const char * MF_GetPlayerTeam (int id) { } +int MF_GetPlayerTeamID (int id) { } +int MF_GetPlayerDeaths (int id) { } +int MF_GetPlayerMenu (int id) { } +int MF_GetPlayerKeys (int id) { } +int MF_IsPlayerAlive (int id) { } +int MF_GetPlayerFrags (int id) { } +int MF_IsPlayerConnecting (int id) { } +int MF_IsPlayerHLTV (int id) { } +int MF_GetPlayerArmor (int id) { } +int MF_GetPlayerHealth (int id) { } +REAL amx_ctof (cell x) { } +cell amx_ftoc (float x) { } +int MF_RegisterSPForwardByName (AMX * amx, const char *str, ...) { } +int MF_RegisterSPForward (AMX * amx, int func, ...) { } +void MF_UnregisterSPForward (int id) { } +int MF_GetPlayerFlags (int id) { } +edict_t* MF_GetPlayerEdict (int id) { } +const char * MF_Format (const char *fmt, ...) { } +void MF_RegisterFunction (void *pfn, const char *description) { } +void * MF_RequestFunction (const char *description) { } +int MF_AmxPush (AMX *amx, cell *params) { } +int MF_AmxExec (AMX *amx, cell *retval, int idx) { } +#endif // MAY_NEVER_BE_DEFINED + +#define MF_AddNatives g_fn_AddNatives +#define MF_BuildPathname g_fn_BuildPathname +#define MF_BuildPathnameR g_fn_BuildPathnameR +#define MF_FormatAmxString g_fn_FormatAmxString +#define MF_GetAmxAddr g_fn_GetAmxAddr +#define MF_PrintSrvConsole g_fn_PrintSrvConsole +#define MF_GetModname g_fn_GetModname +#define MF_GetScriptName g_fn_GetAmxScriptName +#define MF_GetScriptAmx g_fn_GetAmxScript +#define MF_FindScriptByAmx g_fn_FindAmxScriptByAmx +#define MF_FindScriptByName g_fn_FindAmxScriptByName +#define MF_SetAmxString g_fn_SetAmxString +#define MF_GetAmxString g_fn_GetAmxString +#define MF_GetAmxStringLen g_fn_GetAmxStringLen +#define MF_CopyAmxMemory g_fn_CopyAmxMemory +void MF_Log(const char *fmt, ...); +void MF_LogError(AMX *amx, int err, const char *fmt, ...); +#define MF_RaiseAmxError g_fn_RaiseAmxError +#define MF_RegisterForward g_fn_RegisterForward +#define MF_ExecuteForward g_fn_ExecuteForward +#define MF_PrepareCellArray g_fn_PrepareCellArray +#define MF_PrepareCharArray g_fn_PrepareCharArray +#define MF_PrepareCellArrayA g_fn_PrepareCellArrayA +#define MF_PrepareCharArrayA g_fn_PrepareCharArrayA +#define MF_IsPlayerValid g_fn_IsPlayerValid +#define MF_GetPlayerName g_fn_GetPlayerName +#define MF_GetPlayerIP g_fn_GetPlayerIP +#define MF_IsPlayerIngame g_fn_IsPlayerIngame +#define MF_IsPlayerBot g_fn_IsPlayerBot +#define MF_IsPlayerAuthorized g_fn_IsPlayerAuthorized +#define MF_GetPlayerTime g_fn_GetPlayerTime +#define MF_GetPlayerPlayTime g_fn_GetPlayerPlayTime +#define MF_GetPlayerCurweapon g_fn_GetPlayerCurweapon +#define MF_GetPlayerTeam g_fn_GetPlayerTeam +#define MF_GetPlayerTeamID g_fn_GetPlayerTeamID +#define MF_GetPlayerDeaths g_fn_GetPlayerDeaths +#define MF_GetPlayerMenu g_fn_GetPlayerMenu +#define MF_GetPlayerKeys g_fn_GetPlayerKeys +#define MF_IsPlayerAlive g_fn_IsPlayerAlive +#define MF_GetPlayerFrags g_fn_GetPlayerFrags +#define MF_IsPlayerConnecting g_fn_IsPlayerConnecting +#define MF_IsPlayerHLTV g_fn_IsPlayerHLTV +#define MF_GetPlayerArmor g_fn_GetPlayerArmor +#define MF_GetPlayerHealth g_fn_GetPlayerHealth +#define MF_AmxExec g_fn_AmxExec +#define MF_AmxExecv g_fn_AmxExecv +#define MF_AmxFindPublic g_fn_AmxFindPublic +#define MF_AmxAllot g_fn_AmxAllot +#define MF_AmxFindNative g_fn_AmxFindNative +#define MF_LoadAmxScript g_fn_LoadAmxScript +#define MF_UnloadAmxScript g_fn_UnloadAmxScript +#define MF_MergeDefinitionFile g_fn_MergeDefinition_File +#define amx_ctof g_fn_CellToReal +#define amx_ftoc g_fn_RealToCell +#define MF_RegisterSPForwardByName g_fn_RegisterSPForwardByName +#define MF_RegisterSPForward g_fn_RegisterSPForward +#define MF_UnregisterSPForward g_fn_UnregisterSPForward +#define MF_GetPlayerFlags g_fn_GetPlayerFlags +#define MF_GetPlayerEdict g_fn_GetPlayerEdict +#define MF_Format g_fn_Format +#define MF_RegisterFunction g_fn_RegisterFunction +#define MF_RequestFunction g_fn_RequestFunction; +#define MF_AmxPush g_fn_AmxPush + +/*** Memory ***/ +void *operator new(size_t reportedSize); +void *operator new[](size_t reportedSize); +void *operator new(size_t reportedSize, const char *sourceFile, int sourceLine); +void *operator new[](size_t reportedSize, const char *sourceFile, int sourceLine); +void operator delete(void *reportedAddress); +void operator delete[](void *reportedAddress); + +// Allocation types +extern const unsigned int m_alloc_unknown; +extern const unsigned int m_alloc_new; +extern const unsigned int m_alloc_new_array; +extern const unsigned int m_alloc_malloc; +extern const unsigned int m_alloc_calloc; +extern const unsigned int m_alloc_realloc; +extern const unsigned int m_alloc_delete; +extern const unsigned int m_alloc_delete_array; +extern const unsigned int m_alloc_free; + +// To be called before new / delete +void Mem_SetOwner(const char *filename, int line, const char *function); +// Actual allocator +void * Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int allocationType, const size_t reportedSize); +void * Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress); +void Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc, + const unsigned int deallocationType, void *reportedAddress); + +// memory macros +#ifndef __FUNCTION__ +#define __FUNCTION__ "??" +#endif + +// call Mem_SetOwner, followed by the actual new operator +#define new (Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? NULL : new +// call Mem_SetOwner, followed by the actual delete operator +#define delete (Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? Mem_SetOwner("",0,"") : delete +#define malloc(sz) Mem_Allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_malloc,sz) +#define calloc(sz) Mem_Allocator (__FILE__,__LINE__,__FUNCTION__,m_alloc_calloc,sz) +#define realloc(ptr,sz) Mem_Reallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_realloc,sz,ptr) +#define free(ptr) Mem_Deallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_free,ptr) + +#endif // #ifndef __AMXXMODULE_H__ diff --git a/dlls/BB/bb.cpp b/dlls/BB/bb.cpp new file mode 100644 index 00000000..bdfd5918 --- /dev/null +++ b/dlls/BB/bb.cpp @@ -0,0 +1,139 @@ +#include "bb.h" + +static cell AMX_NATIVE_CALL get_user_exp(AMX *amx,cell *params) +{ + return amx_ftoc(GetUserExp(params[1])); +} + +static cell AMX_NATIVE_CALL set_user_exp(AMX *amx,cell *params) +{ + float Exp = amx_ctof(params[2]); + SetUserExp(params[1], Exp ); + return 1; +} + +static cell AMX_NATIVE_CALL get_user_points(AMX *amx,cell *params) +{ + return amx_ftoc(GetUserPoints(params[1])); +} + +static cell AMX_NATIVE_CALL set_user_points(AMX *amx,cell *params) +{ + float Exp = amx_ctof(params[2]); + SetUserPoints(params[1], Exp ); + return 1; +} + +static cell AMX_NATIVE_CALL get_user_level(AMX *amx,cell *params) +{ + return GetUserLevel(params[1]); +} + +static cell AMX_NATIVE_CALL set_user_level(AMX *amx,cell *params) +{ + SetUserLevel(params[1], params[2] ); + return 1; +} + +static cell AMX_NATIVE_CALL get_user_speed(AMX *amx,cell *params) +{ + return GetUserSpeed(params[1]); +} + +static cell AMX_NATIVE_CALL set_user_speed(AMX *amx,cell *params) +{ + SetUserSpeed(params[1], params[2] ); + return 1; +} + +static cell AMX_NATIVE_CALL get_user_hitpoints(AMX *amx,cell *params) +{ + return GetUserHitPoints(params[1]); +} + +static cell AMX_NATIVE_CALL set_user_hitpoints(AMX *amx,cell *params) +{ + SetUserHitPoints(params[1], params[2] ); + return 1; +} + +static cell AMX_NATIVE_CALL get_user_skill(AMX *amx,cell *params) +{ + return GetUserSkill(params[1]); +} + +static cell AMX_NATIVE_CALL set_user_skill(AMX *amx,cell *params) +{ + SetUserSkill(params[1], params[2] ); + return 1; +} + +static cell AMX_NATIVE_CALL send_progress_bar(AMX *amx,cell *params) +{ + int len = 0; + float time = amx_ctof(params[3]); + SendProgressBar(params[1], MF_GetAmxString( amx, params[2], 0, &len ), time ); + return 1; +} + +static cell AMX_NATIVE_CALL send_show_objective(AMX *amx,cell *params) +{ + int len = 0; + SendShowObjective(params[1], MF_GetAmxString( amx, params[2], 0, &len ) ); + return 1; +} + +static cell AMX_NATIVE_CALL send_show_message(AMX *amx,cell *params) +{ + int len = 0; + float time = amx_ctof(params[2]); + SendShowMessage(params[1], time, MF_GetAmxString( amx, params[2], 0, &len ), MF_GetAmxString( amx, params[3], 0, &len ) ); + return 1; +} + +static cell AMX_NATIVE_CALL reset_user_hud(AMX *amx,cell *params) +{ + UpdateBBHud( params[1] ); + return 1; +} + +static cell AMX_NATIVE_CALL is_user_zombie(AMX *amx,cell *params) +{ + return IsUserZombie(params[1]); +} + + +AMX_NATIVE_INFO bb_Exports[] = +{ + {"bb_is_user_zombie",is_user_zombie}, + {"bb_reset_user_hud", reset_user_hud}, + + {"bb_show_message",send_show_message}, + {"bb_show_objective", send_show_objective}, + {"bb_show_progress_bar", send_progress_bar}, + + {"bb_get_user_skill",get_user_skill}, + {"bb_set_user_skill", set_user_skill}, + + {"bb_get_user_hitpoints",get_user_hitpoints}, + {"bb_set_user_hitpoints", set_user_hitpoints}, + + {"bb_get_user_speed",get_user_speed}, + {"bb_set_user_speed", set_user_speed}, + + {"bb_get_user_exp",get_user_exp}, + {"bb_set_user_exp", set_user_exp}, + + {"bb_get_user_points",get_user_points}, + {"bb_set_user_points", set_user_points}, + + {"bb_get_user_level",get_user_level}, + {"bb_set_user_level", set_user_level}, + + { NULL, NULL } +}; + +void OnAmxxAttach() +{ + MF_AddNatives(bb_Exports); +} \ No newline at end of file diff --git a/dlls/BB/bb.h b/dlls/BB/bb.h new file mode 100644 index 00000000..d433be78 --- /dev/null +++ b/dlls/BB/bb.h @@ -0,0 +1,115 @@ +// prevent double include +#ifndef __BB_H__ +#define __BB_H__ + +#include "pdata.h" +#include "bb_const.h" + +void UpdateBBHud( long& target); + +inline float GetUserExp( long& target) + { return GetPData(target, BB_PDATA_EXP, 100.0); } + +inline void SetUserExp( long& target, float& exp) + { SetPData(target, BB_PDATA_EXP, exp); } + +inline float GetUserPoints( long& target) + { return GetPData(target, BB_PDATA_POINT, 100.0); } + +inline void SetUserPoints( long& target, float& points) + {SetPData(target, BB_PDATA_POINT, points, true);} + +inline long GetUserLevel(long& target) + { return GetPData(target,BB_PDATA_LEVEL,100); } + +inline void SetUserLevel(long& target, long& level) +{ + long i; + float totalxp = 0.0; + + for(i=1;i<=level;i++) { + totalxp += 150.0 + ((i-1) * 300.0); + } + + SetUserExp( target, totalxp ); + + MESSAGE_BEGIN(MSG_ONE,120, NULL, MF_GetPlayerEdict( target) ); + WRITE_COORD(0); + WRITE_BYTE(level); + WRITE_BYTE( GetUserPoints(target) ); + MESSAGE_END(); + + MESSAGE_BEGIN(MSG_ALL,81, NULL, MF_GetPlayerEdict( target )); + WRITE_BYTE( target ); + WRITE_SHORT( MF_GetPlayerFrags( target ) ); + WRITE_SHORT( MF_GetPlayerDeaths( target ) ); + WRITE_BYTE(level); + MESSAGE_END(); + + SetPData(target,BB_PDATA_LEVEL,level); + SetPData(target,BB_PDATA_LEVEL - 1,level); + +} + +inline long GetUserSpeed(long& target) + { return GetPData(target,BB_PDATA_SPEED,100); } + +inline void SetUserSpeed(long& target, long& speed) + { SetPData(target,BB_PDATA_SPEED,speed, true);} + +inline long GetUserHitPoints(long& target) + { return GetPData(target,BB_PDATA_HITPOINTS,100); } + +inline void SetUserHitPoints(long& target, long& hitpoints) + { SetPData(target,BB_PDATA_HITPOINTS,hitpoints, true); } + +inline long GetUserSkill(long& target) + { return GetPData(target,BB_PDATA_SKILL,100); } + +inline void SetUserSkill(long& target, long& skill ) + { SetPData(target,BB_PDATA_SKILL,skill,true); } + +inline bool IsUserZombie(long& target) +{ + return ( (MF_GetPlayerEdict( target ))->v.team == 2); +} + +inline void SendProgressBar( long& target, char* message, float& time) +{ + MESSAGE_BEGIN(MSG_ONE, 122, NULL, MF_GetPlayerEdict( target)); + WRITE_STRING(message); + WRITE_COORD(time); + MESSAGE_END(); +} + +inline void SendShowObjective( long& target, char* message) +{ + MESSAGE_BEGIN(MSG_ONE, 122, NULL, MF_GetPlayerEdict( target)); + WRITE_COORD(-1); + WRITE_BYTE(144); + WRITE_STRING(message); + MESSAGE_END(); +} + +inline void SendShowMessage( long& target, float& duration, char* message, char* message2) +{ + MESSAGE_BEGIN(MSG_ONE, 122, NULL, MF_GetPlayerEdict( target)); + WRITE_COORD(duration); + WRITE_BYTE(32); + WRITE_STRING(message); + WRITE_STRING(message2); + MESSAGE_END(); +} + +void UpdateBBHud( long& target) +{ + MESSAGE_BEGIN( MSG_ONE, 113, NULL, MF_GetPlayerEdict( target) ); + WRITE_BYTE( GetUserHitPoints(target) ); + WRITE_BYTE( GetUserSpeed(target) ); + WRITE_BYTE( GetUserSkill(target) ); + WRITE_BYTE( GetUserPoints(target) ); + MESSAGE_END(); +} + +#endif + diff --git a/dlls/BB/bb.inc b/dlls/BB/bb.inc new file mode 100644 index 00000000..dd25ddb4 --- /dev/null +++ b/dlls/BB/bb.inc @@ -0,0 +1,47 @@ +/* BrainBread Fun Module + * + * (c) 2005, XxAvalanchexX (converted to module by Rukia) + * + * This file is provided as is (no warranties). + */ + +#if defined _brainbread_included + #endinput +#endif +#define _brainbread_included + +#pragma library BBFUN + +#include +#include + +native bb_is_user_zombie(id) +native bb_reset_user_hud(id) + +native bb_show_message(id,Float:time = -1,message[],message2[] = "") +native bb_show_objective(id,message[] = "") +native bb_show_progress_bar(id,message[],time = 10) + +native bb_get_user_skill(id) +native bb_set_user_skill(id,skill) +stock bb_add_user_skill(id,skill) bb_set_user_skill(id,bb_get_user_skill(id) + skill) + +native Float:bb_get_user_exp(id) +native bb_set_user_exp(id,Float:exp) +stock bb_add_user_exp(id,Float:exp) bb_set_user_exp(id,bb_get_user_exp(id) + exp) + +native Float:bb_get_user_points(id) +native bb_set_user_points(id,Float:points) +stock bb_add_user_points(id,Float:points) bb_set_user_ponts(id,bb_get_user_points(id) + points) + +native bb_get_user_level(id) +native bb_set_user_level(id,level) +stock bb_add_user_level(id,level) bb_set_user_level(id,bb_get_user_level(id) + level) + +native bb_get_user_speed(id) +native bb_set_user_speed(id,speed) +stock bb_add_user_speed(id,speed) bb_set_user_speed(id,bb_get_user_speed(id) + speed) + +native bb_get_user_hitpoints(id) +native bb_set_user_hitpoints(id,hitpoints) +stock bb_add_user_hitpoints(id,hitpoints) bb_set_user_hitpoints(id,bb_get_user_hitpoints(id) + hitpoints) \ No newline at end of file diff --git a/dlls/BB/bb.ncb b/dlls/BB/bb.ncb new file mode 100644 index 0000000000000000000000000000000000000000..60e55f562f32f36c04a0bae15ebc389a391074e3 GIT binary patch literal 191488 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

f=w;!Ja8RyxTeI-aSPBrVV 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 literal 0 HcmV?d00001 diff --git a/dlls/BB/bb.sln b/dlls/BB/bb.sln new file mode 100644 index 00000000..4fde9650 --- /dev/null +++ b/dlls/BB/bb.sln @@ -0,0 +1,21 @@ +Microsoft Visual Studio Solution File, Format Version 8.00 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bb", "bb.vcproj", "{29798873-02F2-4075-AFE7-58CE8F9B5124}" + ProjectSection(ProjectDependencies) = postProject + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + Debug = Debug + Release = Release + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {29798873-02F2-4075-AFE7-58CE8F9B5124}.Debug.ActiveCfg = Debug|Win32 + {29798873-02F2-4075-AFE7-58CE8F9B5124}.Debug.Build.0 = Debug|Win32 + {29798873-02F2-4075-AFE7-58CE8F9B5124}.Release.ActiveCfg = Release|Win32 + {29798873-02F2-4075-AFE7-58CE8F9B5124}.Release.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/dlls/BB/bb.vcproj b/dlls/BB/bb.vcproj new file mode 100644 index 00000000..b3da03e0 --- /dev/null +++ b/dlls/BB/bb.vcproj @@ -0,0 +1,180 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dlls/BB/bb_const.h b/dlls/BB/bb_const.h new file mode 100644 index 00000000..af142627 --- /dev/null +++ b/dlls/BB/bb_const.h @@ -0,0 +1,12 @@ +// prevent double include +#ifndef __BB_CONST__ +#define __BB_CONST__ + +#define BB_PDATA_LEVEL 505 +#define BB_PDATA_EXP 4 +#define BB_PDATA_POINT 432 +#define BB_PDATA_SPEED 501 +#define BB_PDATA_HITPOINTS 502 +#define BB_PDATA_SKILL 503 + +#endif \ No newline at end of file diff --git a/dlls/BB/bb_const.inc b/dlls/BB/bb_const.inc new file mode 100644 index 00000000..26e289f1 --- /dev/null +++ b/dlls/BB/bb_const.inc @@ -0,0 +1,26 @@ +/* BrainBread Fun Module Constants + * + * (c) 2005, XxAvalanchexX (converted to module by Rukia) + * + * This file is provided as is (no warranties). + */ + +#if defined _brainbread_const_included + #endinput +#endif +#define _brainbread_const_included + + +#define SPRAY_BSPRITZ 1 +#define SPRAY_BGUSH 2 +#define SPRAY_SMOKEPUFF 4 +#define SPRAY_EXPLOSION 5 + +#define DOT_GREEN 1 +#define DOT_RED 2 +#define DOT_WHITE 3 +#define DOT_LTBLUE 4 +#define DOT_BLUE 5 +#define DOT_ORANGE 6 +#define DOT_FLYELLOW 7 +#define DOT_FLGREEN 8 diff --git a/dlls/BB/bb_stocks.inc b/dlls/BB/bb_stocks.inc new file mode 100644 index 00000000..b94feb17 --- /dev/null +++ b/dlls/BB/bb_stocks.inc @@ -0,0 +1,112 @@ +/* BrainBread Fun Module Stocks + * + * (c) 2005, XxAvalanchexX (converted to module by Rukia) + * + * This file is provided as is (no warranties). + */ + +#if defined _brainbread_stocks_included + #endinput +#endif +#define _brainbread_stocks_included + +/* Used to create a spray */ +stock bb_spray(type,origin[3]) { + + /* type: type of spray, see below */ + /* origin: origin of where spray comes from */ + + /* TYPES: + SPRAY_BSPRITZ (1) = Blood spritz + SPRAY_BGUSH (2) = Blood gush + SPRAY_SMOKEPUFF (4) = Smoke puffs + SPRAY_EXPLOSION (5) = Firey explosion */ + + message_begin(MSG_PVS,118,origin,0); + write_byte(type); + write_coord(origin[0]); + write_coord(origin[1]); + write_coord(origin[2]); + write_coord(random_num(-1,1)); + write_coord(random_num(-1,1)); + write_coord(random_num(-1,1)); + write_coord(random_num(-1,1)); + write_coord(random_num(-1,1)); + write_coord(random_num(-1,1)); + message_end(); + + return 1; +} + +/* Used to create a spray, with more parameters */ +stock bb_spray_adv(type,origin[3],size[3],dir[3]) { + + /* type: type of spray, see below */ + /* origin: origin of where spray comes from */ + /* size: size of spray, in XYZ format (I think), use a small number like -1 to 1 */ + /* dir: direction of spray, in XYZ format (I think), use a small number like -1 to 1 */ + + /* TYPES: + SPRAY_BSPRITZ (1) = Blood spritz + SPRAY_BGUSH (2) = Blood gush + SPRAY_SMOKEPUFF (4) = Smoke puffs + SPRAY_EXPLOSION (5) = Firey explosion */ + + message_begin(MSG_PVS,118,origin,0); + write_byte(type); + write_coord(origin[0]); + write_coord(origin[1]); + write_coord(origin[2]); + write_coord(size[0]); + write_coord(size[1]); + write_coord(size[2]); + write_coord(dir[0]); + write_coord(dir[1]); + write_coord(dir[2]); + message_end(); + + return 1; +} + +/* Used to set dots on the radar */ +stock bb_radar(id,dot_id,dot_origin[3],dot_status,dot_type) { + + /* dot_id: unique ID for this dot, use same ID to modify the same dot */ + /* dot_origin: the origin of where to place this dot */ + /* dot_status: 0 to remove the dot, 1 to add or modify the dot */ + /* dot_type: the type of dot, see below */ + + /* dot_origin and dot_type need not be set accurately when removing the dot */ + + /* TYPES: + DOT_GREEN (1) = Green Dot, used to mark teammates + DOT_RED (2) = Red Dot, used to mark enemies for zombies + DOT_WHITE (3) = White Dot, used to mark mission zones + DOT_LTBLUE (4) = Light Blue Dot, not used for BrainBread + DOT_BLUE (5) = Blue Dot, used to mark the BlackHawk + DOT_ORANGE (6) = Orange Dot, not used for BrainBread + DOT_FLYELLOW (7) = Flashing Yellow Dot, used to mark the Case or Fred + DOT_FLGREEN (8) = Flashing Green Dot, not used for BrainBread, + it stops flashing and turns to white after 3 seconds */ + + message_begin(MSG_ONE,93,{0,0,0},id); + write_short(dot_id); + write_byte(1); + write_coord(dot_origin[0]); + write_coord(dot_origin[1]); + write_coord(dot_origin[2]); + write_byte(1); + message_end(); + + message_begin(MSG_ONE,93,{0,0,0},id); + write_short(dot_id); + write_byte((dot_status > 0) ? 2 : 0); + + if(dot_status > 0) { + write_byte(dot_type); + } + + message_end(); + + return 1; +} diff --git a/dlls/BB/moduleconfig.h b/dlls/BB/moduleconfig.h new file mode 100644 index 00000000..80c07cc3 --- /dev/null +++ b/dlls/BB/moduleconfig.h @@ -0,0 +1,462 @@ +// Configuration + +#ifndef __MODULECONFIG_H__ +#define __MODULECONFIG_H__ + +// Module info +#define MODULE_NAME "BBFUN" +#define MODULE_VERSION "1.17" +#define MODULE_AUTHOR "Rukia" +#define MODULE_URL "www.rcrclansite.com" +#define MODULE_LOGTAG "BB" +// If you want the module not to be reloaded on mapchange, remove / comment out the next line +#define MODULE_RELOAD_ON_MAPCHANGE + +#ifdef __DATE__ +#define MODULE_DATE __DATE__ +#else // __DATE__ +#define MODULE_DATE "Today" +#endif // __DATE__ + +// metamod plugin? +#define USE_METAMOD + +// - AMXX Init functions +// Also consider using FN_META_* +// AMXX query +//#define FN_AMXX_QUERY OnAmxxQuery +// AMXX attach +// Do native functions init here (MF_AddNatives) +#define FN_AMXX_ATTACH OnAmxxAttach +// AMXX detach +// #define FN_AMXX_DETACH OnAmxxDetach +// All plugins loaded +// Do forward functions init here (MF_RegisterForward) +// #define FN_AMXX_PLUGINSLOADED OnPluginsLoaded + +/**** METAMOD ****/ +// If your module doesn't use metamod, you may close the file now :) +#ifdef USE_METAMOD +// ---- +// Hook Functions +// Uncomment these to be called +// You can also change the function name + +// - Metamod init functions +// Also consider using FN_AMXX_* +// Meta query +//#define FN_META_QUERY OnMetaQuery +// Meta attach +//#define FN_META_ATTACH OnMetaAttach +// Meta detach +//#define FN_META_DETACH OnMetaDetach + +// (wd) are Will Day's notes +// - GetEntityAPI2 functions +// #define FN_GameDLLInit GameDLLInit /* pfnGameInit() */ +// #define FN_DispatchSpawn DispatchSpawn /* pfnSpawn() */ +// #define FN_DispatchThink DispatchThink /* pfnThink() */ +// #define FN_DispatchUse DispatchUse /* pfnUse() */ +// #define FN_DispatchTouch DispatchTouch /* pfnTouch() */ +// #define FN_DispatchBlocked DispatchBlocked /* pfnBlocked() */ +// #define FN_DispatchKeyValue DispatchKeyValue /* pfnKeyValue() */ +// #define FN_DispatchSave DispatchSave /* pfnSave() */ +// #define FN_DispatchRestore DispatchRestore /* pfnRestore() */ +// #define FN_DispatchObjectCollsionBox DispatchObjectCollsionBox /* pfnSetAbsBox() */ +// #define FN_SaveWriteFields SaveWriteFields /* pfnSaveWriteFields() */ +// #define FN_SaveReadFields SaveReadFields /* pfnSaveReadFields() */ +// #define FN_SaveGlobalState SaveGlobalState /* pfnSaveGlobalState() */ +// #define FN_RestoreGlobalState RestoreGlobalState /* pfnRestoreGlobalState() */ +// #define FN_ResetGlobalState ResetGlobalState /* pfnResetGlobalState() */ +// #define FN_ClientConnect ClientConnect /* pfnClientConnect() (wd) Client has connected */ +// #define FN_ClientDisconnect ClientDisconnect /* pfnClientDisconnect() (wd) Player has left the game */ +// #define FN_ClientKill ClientKill /* pfnClientKill() (wd) Player has typed "kill" */ +// #define FN_ClientPutInServer ClientPutInServer /* pfnClientPutInServer() (wd) Client is entering the game */ +// #define FN_ClientCommand ClientCommand /* pfnClientCommand() (wd) Player has sent a command (typed or from a bind) */ +// #define FN_ClientUserInfoChanged ClientUserInfoChanged /* pfnClientUserInfoChanged() (wd) Client has updated their setinfo structure */ +// #define FN_ServerActivate ServerActivate /* pfnServerActivate() (wd) Server is starting a new map */ +// #define FN_ServerDeactivate ServerDeactivate /* pfnServerDeactivate() (wd) Server is leaving the map (shutdown or changelevel); SDK2 */ +// #define FN_PlayerPreThink PlayerPreThink /* pfnPlayerPreThink() */ +// #define FN_PlayerPostThink PlayerPostThink /* pfnPlayerPostThink() */ +// #define FN_StartFrame StartFrame /* pfnStartFrame() */ +// #define FN_ParmsNewLevel ParmsNewLevel /* pfnParmsNewLevel() */ +// #define FN_ParmsChangeLevel ParmsChangeLevel /* pfnParmsChangeLevel() */ +// #define FN_GetGameDescription GetGameDescription /* pfnGetGameDescription() Returns string describing current .dll. E.g. "TeamFotrress 2" "Half-Life" */ +// #define FN_PlayerCustomization PlayerCustomization /* pfnPlayerCustomization() Notifies .dll of new customization for player. */ +// #define FN_SpectatorConnect SpectatorConnect /* pfnSpectatorConnect() Called when spectator joins server */ +// #define FN_SpectatorDisconnect SpectatorDisconnect /* pfnSpectatorDisconnect() Called when spectator leaves the server */ +// #define FN_SpectatorThink SpectatorThink /* pfnSpectatorThink() Called when spectator sends a command packet (usercmd_t) */ +// #define FN_Sys_Error Sys_Error /* pfnSys_Error() Notify game .dll that engine is going to shut down. Allows mod authors to set a breakpoint. SDK2 */ +// #define FN_PM_Move PM_Move /* pfnPM_Move() (wd) SDK2 */ +// #define FN_PM_Init PM_Init /* pfnPM_Init() Server version of player movement initialization; (wd) SDK2 */ +// #define FN_PM_FindTextureType PM_FindTextureType /* pfnPM_FindTextureType() (wd) SDK2 */ +// #define FN_SetupVisibility SetupVisibility /* pfnSetupVisibility() Set up PVS and PAS for networking for this client; (wd) SDK2 */ +// #define FN_UpdateClientData UpdateClientData /* pfnUpdateClientData() Set up data sent only to specific client; (wd) SDK2 */ +// #define FN_AddToFullPack AddToFullPack /* pfnAddToFullPack() (wd) SDK2 */ +// #define FN_CreateBaseline CreateBaseline /* pfnCreateBaseline() Tweak entity baseline for network encoding allows setup of player baselines too.; (wd) SDK2 */ +// #define FN_RegisterEncoders RegisterEncoders /* pfnRegisterEncoders() Callbacks for network encoding; (wd) SDK2 */ +// #define FN_GetWeaponData GetWeaponData /* pfnGetWeaponData() (wd) SDK2 */ +// #define FN_CmdStart CmdStart /* pfnCmdStart() (wd) SDK2 */ +// #define FN_CmdEnd CmdEnd /* pfnCmdEnd() (wd) SDK2 */ +// #define FN_ConnectionlessPacket ConnectionlessPacket /* pfnConnectionlessPacket() (wd) SDK2 */ +// #define FN_GetHullBounds GetHullBounds /* pfnGetHullBounds() (wd) SDK2 */ +// #define FN_CreateInstancedBaselines CreateInstancedBaselines /* pfnCreateInstancedBaselines() (wd) SDK2 */ +// #define FN_InconsistentFile InconsistentFile /* pfnInconsistentFile() (wd) SDK2 */ +// #define FN_AllowLagCompensation AllowLagCompensation /* pfnAllowLagCompensation() (wd) SDK2 */ + +// - GetEntityAPI2_Post functions +// #define FN_GameDLLInit_Post GameDLLInit_Post +// #define FN_DispatchSpawn_Post DispatchSpawn_Post +// #define FN_DispatchThink_Post DispatchThink_Post +// #define FN_DispatchUse_Post DispatchUse_Post +// #define FN_DispatchTouch_Post DispatchTouch_Post +// #define FN_DispatchBlocked_Post DispatchBlocked_Post +// #define FN_DispatchKeyValue_Post DispatchKeyValue_Post +// #define FN_DispatchSave_Post DispatchSave_Post +// #define FN_DispatchRestore_Post DispatchRestore_Post +// #define FN_DispatchObjectCollsionBox_Post DispatchObjectCollsionBox_Post +// #define FN_SaveWriteFields_Post SaveWriteFields_Post +// #define FN_SaveReadFields_Post SaveReadFields_Post +// #define FN_SaveGlobalState_Post SaveGlobalState_Post +// #define FN_RestoreGlobalState_Post RestoreGlobalState_Post +// #define FN_ResetGlobalState_Post ResetGlobalState_Post +// #define FN_ClientConnect_Post ClientConnect_Post +// #define FN_ClientDisconnect_Post ClientDisconnect_Post +// #define FN_ClientKill_Post ClientKill_Post +// #define FN_ClientPutInServer_Post ClientPutInServer_Post +// #define FN_ClientCommand_Post ClientCommand_Post +// #define FN_ClientUserInfoChanged_Post ClientUserInfoChanged_Post +// #define FN_ServerActivate_Post ServerActivate_Post +// #define FN_ServerDeactivate_Post ServerDeactivate_Post +// #define FN_PlayerPreThink_Post PlayerPreThink_Post +// #define FN_PlayerPostThink_Post PlayerPostThink_Post +// #define FN_StartFrame_Post StartFrame_Post +// #define FN_ParmsNewLevel_Post ParmsNewLevel_Post +// #define FN_ParmsChangeLevel_Post ParmsChangeLevel_Post +// #define FN_GetGameDescription_Post GetGameDescription_Post +// #define FN_PlayerCustomization_Post PlayerCustomization_Post +// #define FN_SpectatorConnect_Post SpectatorConnect_Post +// #define FN_SpectatorDisconnect_Post SpectatorDisconnect_Post +// #define FN_SpectatorThink_Post SpectatorThink_Post +// #define FN_Sys_Error_Post Sys_Error_Post +// #define FN_PM_Move_Post PM_Move_Post +// #define FN_PM_Init_Post PM_Init_Post +// #define FN_PM_FindTextureType_Post PM_FindTextureType_Post +// #define FN_SetupVisibility_Post SetupVisibility_Post +// #define FN_UpdateClientData_Post UpdateClientData_Post +// #define FN_AddToFullPack_Post AddToFullPack_Post +// #define FN_CreateBaseline_Post CreateBaseline_Post +// #define FN_RegisterEncoders_Post RegisterEncoders_Post +// #define FN_GetWeaponData_Post GetWeaponData_Post +// #define FN_CmdStart_Post CmdStart_Post +// #define FN_CmdEnd_Post CmdEnd_Post +// #define FN_ConnectionlessPacket_Post ConnectionlessPacket_Post +// #define FN_GetHullBounds_Post GetHullBounds_Post +// #define FN_CreateInstancedBaselines_Post CreateInstancedBaselines_Post +// #define FN_InconsistentFile_Post InconsistentFile_Post +// #define FN_AllowLagCompensation_Post AllowLagCompensation_Post + +// - GetEngineAPI functions +// #define FN_PrecacheModel PrecacheModel +// #define FN_PrecacheSound PrecacheSound +// #define FN_SetModel SetModel +// #define FN_ModelIndex ModelIndex +// #define FN_ModelFrames ModelFrames +// #define FN_SetSize SetSize +// #define FN_ChangeLevel ChangeLevel +// #define FN_GetSpawnParms GetSpawnParms +// #define FN_SaveSpawnParms SaveSpawnParms +// #define FN_VecToYaw VecToYaw +// #define FN_VecToAngles VecToAngles +// #define FN_MoveToOrigin MoveToOrigin +// #define FN_ChangeYaw ChangeYaw +// #define FN_ChangePitch ChangePitch +// #define FN_FindEntityByString FindEntityByString +// #define FN_GetEntityIllum GetEntityIllum +// #define FN_FindEntityInSphere FindEntityInSphere +// #define FN_FindClientInPVS FindClientInPVS +// #define FN_EntitiesInPVS EntitiesInPVS +// #define FN_MakeVectors MakeVectors +// #define FN_AngleVectors AngleVectors +// #define FN_CreateEntity CreateEntity +// #define FN_RemoveEntity RemoveEntity +// #define FN_CreateNamedEntity CreateNamedEntity +// #define FN_MakeStatic MakeStatic +// #define FN_EntIsOnFloor EntIsOnFloor +// #define FN_DropToFloor DropToFloor +// #define FN_WalkMove WalkMove +// #define FN_SetOrigin SetOrigin +// #define FN_EmitSound EmitSound +// #define FN_EmitAmbientSound EmitAmbientSound +// #define FN_TraceLine TraceLine +// #define FN_TraceToss TraceToss +// #define FN_TraceMonsterHull TraceMonsterHull +// #define FN_TraceHull TraceHull +// #define FN_TraceModel TraceModel +// #define FN_TraceTexture TraceTexture +// #define FN_TraceSphere TraceSphere +// #define FN_GetAimVector GetAimVector +// #define FN_ServerCommand ServerCommand +// #define FN_ServerExecute ServerExecute +// #define FN_engClientCommand engClientCommand +// #define FN_ParticleEffect ParticleEffect +// #define FN_LightStyle LightStyle +// #define FN_DecalIndex DecalIndex +// #define FN_PointContents PointContents +// #define FN_MessageBegin MessageBegin +// #define FN_MessageEnd MessageEnd +// #define FN_WriteByte WriteByte +// #define FN_WriteChar WriteChar +// #define FN_WriteShort WriteShort +// #define FN_WriteLong WriteLong +// #define FN_WriteAngle WriteAngle +// #define FN_WriteCoord WriteCoord +// #define FN_WriteString WriteString +// #define FN_WriteEntity WriteEntity +// #define FN_CVarRegister CVarRegister +// #define FN_CVarGetFloat CVarGetFloat +// #define FN_CVarGetString CVarGetString +// #define FN_CVarSetFloat CVarSetFloat +// #define FN_CVarSetString CVarSetString +// #define FN_AlertMessage AlertMessage +// #define FN_EngineFprintf EngineFprintf +// #define FN_PvAllocEntPrivateData PvAllocEntPrivateData +// #define FN_PvEntPrivateData PvEntPrivateData +// #define FN_FreeEntPrivateData FreeEntPrivateData +// #define FN_SzFromIndex SzFromIndex +// #define FN_AllocString AllocString +// #define FN_GetVarsOfEnt GetVarsOfEnt +// #define FN_PEntityOfEntOffset PEntityOfEntOffset +// #define FN_EntOffsetOfPEntity EntOffsetOfPEntity +// #define FN_IndexOfEdict IndexOfEdict +// #define FN_PEntityOfEntIndex PEntityOfEntIndex +// #define FN_FindEntityByVars FindEntityByVars +// #define FN_GetModelPtr GetModelPtr +// #define FN_RegUserMsg RegUserMsg +// #define FN_AnimationAutomove AnimationAutomove +// #define FN_GetBonePosition GetBonePosition +// #define FN_FunctionFromName FunctionFromName +// #define FN_NameForFunction NameForFunction +// #define FN_ClientPrintf ClientPrintf +// #define FN_ServerPrint ServerPrint +// #define FN_Cmd_Args Cmd_Args +// #define FN_Cmd_Argv Cmd_Argv +// #define FN_Cmd_Argc Cmd_Argc +// #define FN_GetAttachment GetAttachment +// #define FN_CRC32_Init CRC32_Init +// #define FN_CRC32_ProcessBuffer CRC32_ProcessBuffer +// #define FN_CRC32_ProcessByte CRC32_ProcessByte +// #define FN_CRC32_Final CRC32_Final +// #define FN_RandomLong RandomLong +// #define FN_RandomFloat RandomFloat +// #define FN_SetView SetView +// #define FN_Time Time +// #define FN_CrosshairAngle CrosshairAngle +// #define FN_LoadFileForMe LoadFileForMe +// #define FN_FreeFile FreeFile +// #define FN_EndSection EndSection +// #define FN_CompareFileTime CompareFileTime +// #define FN_GetGameDir GetGameDir +// #define FN_Cvar_RegisterVariable Cvar_RegisterVariable +// #define FN_FadeClientVolume FadeClientVolume +// #define FN_SetClientMaxspeed SetClientMaxspeed +// #define FN_CreateFakeClient CreateFakeClient +// #define FN_RunPlayerMove RunPlayerMove +// #define FN_NumberOfEntities NumberOfEntities +// #define FN_GetInfoKeyBuffer GetInfoKeyBuffer +// #define FN_InfoKeyValue InfoKeyValue +// #define FN_SetKeyValue SetKeyValue +// #define FN_SetClientKeyValue SetClientKeyValue +// #define FN_IsMapValid IsMapValid +// #define FN_StaticDecal StaticDecal +// #define FN_PrecacheGeneric PrecacheGeneric +// #define FN_GetPlayerUserId GetPlayerUserId +// #define FN_BuildSoundMsg BuildSoundMsg +// #define FN_IsDedicatedServer IsDedicatedServer +// #define FN_CVarGetPointer CVarGetPointer +// #define FN_GetPlayerWONId GetPlayerWONId +// #define FN_Info_RemoveKey Info_RemoveKey +// #define FN_GetPhysicsKeyValue GetPhysicsKeyValue +// #define FN_SetPhysicsKeyValue SetPhysicsKeyValue +// #define FN_GetPhysicsInfoString GetPhysicsInfoString +// #define FN_PrecacheEvent PrecacheEvent +// #define FN_PlaybackEvent PlaybackEvent +// #define FN_SetFatPVS SetFatPVS +// #define FN_SetFatPAS SetFatPAS +// #define FN_CheckVisibility CheckVisibility +// #define FN_DeltaSetField DeltaSetField +// #define FN_DeltaUnsetField DeltaUnsetField +// #define FN_DeltaAddEncoder DeltaAddEncoder +// #define FN_GetCurrentPlayer GetCurrentPlayer +// #define FN_CanSkipPlayer CanSkipPlayer +// #define FN_DeltaFindField DeltaFindField +// #define FN_DeltaSetFieldByIndex DeltaSetFieldByIndex +// #define FN_DeltaUnsetFieldByIndex DeltaUnsetFieldByIndex +// #define FN_SetGroupMask SetGroupMask +// #define FN_engCreateInstancedBaseline engCreateInstancedBaseline +// #define FN_Cvar_DirectSet Cvar_DirectSet +// #define FN_ForceUnmodified ForceUnmodified +// #define FN_GetPlayerStats GetPlayerStats +// #define FN_AddServerCommand AddServerCommand +// #define FN_Voice_GetClientListening Voice_GetClientListening +// #define FN_Voice_SetClientListening Voice_SetClientListening +// #define FN_GetPlayerAuthId GetPlayerAuthId + +// - GetEngineAPI_Post functions +// #define FN_PrecacheModel_Post PrecacheModel_Post +// #define FN_PrecacheSound_Post PrecacheSound_Post +// #define FN_SetModel_Post SetModel_Post +// #define FN_ModelIndex_Post ModelIndex_Post +// #define FN_ModelFrames_Post ModelFrames_Post +// #define FN_SetSize_Post SetSize_Post +// #define FN_ChangeLevel_Post ChangeLevel_Post +// #define FN_GetSpawnParms_Post GetSpawnParms_Post +// #define FN_SaveSpawnParms_Post SaveSpawnParms_Post +// #define FN_VecToYaw_Post VecToYaw_Post +// #define FN_VecToAngles_Post VecToAngles_Post +// #define FN_MoveToOrigin_Post MoveToOrigin_Post +// #define FN_ChangeYaw_Post ChangeYaw_Post +// #define FN_ChangePitch_Post ChangePitch_Post +// #define FN_FindEntityByString_Post FindEntityByString_Post +// #define FN_GetEntityIllum_Post GetEntityIllum_Post +// #define FN_FindEntityInSphere_Post FindEntityInSphere_Post +// #define FN_FindClientInPVS_Post FindClientInPVS_Post +// #define FN_EntitiesInPVS_Post EntitiesInPVS_Post +// #define FN_MakeVectors_Post MakeVectors_Post +// #define FN_AngleVectors_Post AngleVectors_Post +// #define FN_CreateEntity_Post CreateEntity_Post +// #define FN_RemoveEntity_Post RemoveEntity_Post +// #define FN_CreateNamedEntity_Post CreateNamedEntity_Post +// #define FN_MakeStatic_Post MakeStatic_Post +// #define FN_EntIsOnFloor_Post EntIsOnFloor_Post +// #define FN_DropToFloor_Post DropToFloor_Post +// #define FN_WalkMove_Post WalkMove_Post +// #define FN_SetOrigin_Post SetOrigin_Post +// #define FN_EmitSound_Post EmitSound_Post +// #define FN_EmitAmbientSound_Post EmitAmbientSound_Post +// #define FN_TraceLine_Post TraceLine_Post +// #define FN_TraceToss_Post TraceToss_Post +// #define FN_TraceMonsterHull_Post TraceMonsterHull_Post +// #define FN_TraceHull_Post TraceHull_Post +// #define FN_TraceModel_Post TraceModel_Post +// #define FN_TraceTexture_Post TraceTexture_Post +// #define FN_TraceSphere_Post TraceSphere_Post +// #define FN_GetAimVector_Post GetAimVector_Post +// #define FN_ServerCommand_Post ServerCommand_Post +// #define FN_ServerExecute_Post ServerExecute_Post +// #define FN_engClientCommand_Post engClientCommand_Post +// #define FN_ParticleEffect_Post ParticleEffect_Post +// #define FN_LightStyle_Post LightStyle_Post +// #define FN_DecalIndex_Post DecalIndex_Post +// #define FN_PointContents_Post PointContents_Post +// #define FN_MessageBegin_Post MessageBegin_Post +// #define FN_MessageEnd_Post MessageEnd_Post +// #define FN_WriteByte_Post WriteByte_Post +// #define FN_WriteChar_Post WriteChar_Post +// #define FN_WriteShort_Post WriteShort_Post +// #define FN_WriteLong_Post WriteLong_Post +// #define FN_WriteAngle_Post WriteAngle_Post +// #define FN_WriteCoord_Post WriteCoord_Post +// #define FN_WriteString_Post WriteString_Post +// #define FN_WriteEntity_Post WriteEntity_Post +// #define FN_CVarRegister_Post CVarRegister_Post +// #define FN_CVarGetFloat_Post CVarGetFloat_Post +// #define FN_CVarGetString_Post CVarGetString_Post +// #define FN_CVarSetFloat_Post CVarSetFloat_Post +// #define FN_CVarSetString_Post CVarSetString_Post +// #define FN_AlertMessage_Post AlertMessage_Post +// #define FN_EngineFprintf_Post EngineFprintf_Post +// #define FN_PvAllocEntPrivateData_Post PvAllocEntPrivateData_Post +// #define FN_PvEntPrivateData_Post PvEntPrivateData_Post +// #define FN_FreeEntPrivateData_Post FreeEntPrivateData_Post +// #define FN_SzFromIndex_Post SzFromIndex_Post +// #define FN_AllocString_Post AllocString_Post +// #define FN_GetVarsOfEnt_Post GetVarsOfEnt_Post +// #define FN_PEntityOfEntOffset_Post PEntityOfEntOffset_Post +// #define FN_EntOffsetOfPEntity_Post EntOffsetOfPEntity_Post +// #define FN_IndexOfEdict_Post IndexOfEdict_Post +// #define FN_PEntityOfEntIndex_Post PEntityOfEntIndex_Post +// #define FN_FindEntityByVars_Post FindEntityByVars_Post +// #define FN_GetModelPtr_Post GetModelPtr_Post +// #define FN_RegUserMsg_Post RegUserMsg_Post +// #define FN_AnimationAutomove_Post AnimationAutomove_Post +// #define FN_GetBonePosition_Post GetBonePosition_Post +// #define FN_FunctionFromName_Post FunctionFromName_Post +// #define FN_NameForFunction_Post NameForFunction_Post +// #define FN_ClientPrintf_Post ClientPrintf_Post +// #define FN_ServerPrint_Post ServerPrint_Post +// #define FN_Cmd_Args_Post Cmd_Args_Post +// #define FN_Cmd_Argv_Post Cmd_Argv_Post +// #define FN_Cmd_Argc_Post Cmd_Argc_Post +// #define FN_GetAttachment_Post GetAttachment_Post +// #define FN_CRC32_Init_Post CRC32_Init_Post +// #define FN_CRC32_ProcessBuffer_Post CRC32_ProcessBuffer_Post +// #define FN_CRC32_ProcessByte_Post CRC32_ProcessByte_Post +// #define FN_CRC32_Final_Post CRC32_Final_Post +// #define FN_RandomLong_Post RandomLong_Post +// #define FN_RandomFloat_Post RandomFloat_Post +// #define FN_SetView_Post SetView_Post +// #define FN_Time_Post Time_Post +// #define FN_CrosshairAngle_Post CrosshairAngle_Post +// #define FN_LoadFileForMe_Post LoadFileForMe_Post +// #define FN_FreeFile_Post FreeFile_Post +// #define FN_EndSection_Post EndSection_Post +// #define FN_CompareFileTime_Post CompareFileTime_Post +// #define FN_GetGameDir_Post GetGameDir_Post +// #define FN_Cvar_RegisterVariable_Post Cvar_RegisterVariable_Post +// #define FN_FadeClientVolume_Post FadeClientVolume_Post +// #define FN_SetClientMaxspeed_Post SetClientMaxspeed_Post +// #define FN_CreateFakeClient_Post CreateFakeClient_Post +// #define FN_RunPlayerMove_Post RunPlayerMove_Post +// #define FN_NumberOfEntities_Post NumberOfEntities_Post +// #define FN_GetInfoKeyBuffer_Post GetInfoKeyBuffer_Post +// #define FN_InfoKeyValue_Post InfoKeyValue_Post +// #define FN_SetKeyValue_Post SetKeyValue_Post +// #define FN_SetClientKeyValue_Post SetClientKeyValue_Post +// #define FN_IsMapValid_Post IsMapValid_Post +// #define FN_StaticDecal_Post StaticDecal_Post +// #define FN_PrecacheGeneric_Post PrecacheGeneric_Post +// #define FN_GetPlayerUserId_Post GetPlayerUserId_Post +// #define FN_BuildSoundMsg_Post BuildSoundMsg_Post +// #define FN_IsDedicatedServer_Post IsDedicatedServer_Post +// #define FN_CVarGetPointer_Post CVarGetPointer_Post +// #define FN_GetPlayerWONId_Post GetPlayerWONId_Post +// #define FN_Info_RemoveKey_Post Info_RemoveKey_Post +// #define FN_GetPhysicsKeyValue_Post GetPhysicsKeyValue_Post +// #define FN_SetPhysicsKeyValue_Post SetPhysicsKeyValue_Post +// #define FN_GetPhysicsInfoString_Post GetPhysicsInfoString_Post +// #define FN_PrecacheEvent_Post PrecacheEvent_Post +// #define FN_PlaybackEvent_Post PlaybackEvent_Post +// #define FN_SetFatPVS_Post SetFatPVS_Post +// #define FN_SetFatPAS_Post SetFatPAS_Post +// #define FN_CheckVisibility_Post CheckVisibility_Post +// #define FN_DeltaSetField_Post DeltaSetField_Post +// #define FN_DeltaUnsetField_Post DeltaUnsetField_Post +// #define FN_DeltaAddEncoder_Post DeltaAddEncoder_Post +// #define FN_GetCurrentPlayer_Post GetCurrentPlayer_Post +// #define FN_CanSkipPlayer_Post CanSkipPlayer_Post +// #define FN_DeltaFindField_Post DeltaFindField_Post +// #define FN_DeltaSetFieldByIndex_Post DeltaSetFieldByIndex_Post +// #define FN_DeltaUnsetFieldByIndex_Post DeltaUnsetFieldByIndex_Post +// #define FN_SetGroupMask_Post SetGroupMask_Post +// #define FN_engCreateInstancedBaseline_Post engCreateInstancedBaseline_Post +// #define FN_Cvar_DirectSet_Post Cvar_DirectSet_Post +// #define FN_ForceUnmodified_Post ForceUnmodified_Post +// #define FN_GetPlayerStats_Post GetPlayerStats_Post +// #define FN_AddServerCommand_Post AddServerCommand_Post +// #define FN_Voice_GetClientListening_Post Voice_GetClientListening_Post +// #define FN_Voice_SetClientListening_Post Voice_SetClientListening_Post +// #define FN_GetPlayerAuthId_Post GetPlayerAuthId_Post + +// #define FN_OnFreeEntPrivateData OnFreeEntPrivateData +// #define FN_GameShutdown GameShutdown +// #define FN_ShouldCollide ShouldCollide + +// #define FN_OnFreeEntPrivateData_Post OnFreeEntPrivateData_Post +// #define FN_GameShutdown_Post GameShutdown_Post +// #define FN_ShouldCollide_Post ShouldCollide_Post + + +#endif // USE_METAMOD + +#endif // __MODULECONFIG_H__ \ No newline at end of file diff --git a/dlls/BB/pdata.h b/dlls/BB/pdata.h new file mode 100644 index 00000000..c8698b98 --- /dev/null +++ b/dlls/BB/pdata.h @@ -0,0 +1,29 @@ +// prevent double include +#ifndef __PDATA_H__ +#define __PDATA_H__ + +#include +#include "amxxmodule.h" + +#if defined __linux__ + #define EXTRAOFFSET 5 // offsets 5 higher in Linux builds +#else + #define EXTRAOFFSET 0 // no change in Windows builds +#endif // defined __linux__ + +template +inline void SetPData( long& targetid, long offset, ValueType value, bool reset = false ) +{ + edict_t* target = MF_GetPlayerEdict( targetid ); + *((ValueType *)target->pvPrivateData + offset + EXTRAOFFSET) = value; + if(reset) UpdateBBHud( targetid ); +}; + +template +inline ValueType GetPData( long& targetid, long offset, ValueType value ) +{ + edict_t* target = MF_GetPlayerEdict( targetid ); + return *((ValueType *)target->pvPrivateData + offset + EXTRAOFFSET); +} + +#endif \ No newline at end of file