From 8afd62a7c9d9431be0414a7cbe161da9e89c4d2d Mon Sep 17 00:00:00 2001 From: David Anderson Date: Fri, 28 May 2004 06:28:49 +0000 Subject: [PATCH] Rewrite. Note: untested --- dlls/pgsql/admin_pgsql.sma | 274 ---- dlls/pgsql/amxxmodule.cpp | 2990 +++++++++++++++++++++++++++++++++++ dlls/pgsql/amxxmodule.h | 2152 +++++++++++++++++++++++++ dlls/pgsql/lib/libpq.lib | Bin 277593 -> 44139 bytes dlls/pgsql/moduleconfig.h | 462 ++++++ dlls/pgsql/pgsql.cfg | 9 - dlls/pgsql/pgsql.inc | 32 - dlls/pgsql/pgsql_amx.cpp | 281 ++-- dlls/pgsql/pgsql_amx.def | 6 - dlls/pgsql/pgsql_amx.h | 123 +- dlls/pgsql/pgsql_amx.vcproj | 30 +- dlls/pgsql/readme.txt | 35 - 12 files changed, 5799 insertions(+), 595 deletions(-) delete mode 100755 dlls/pgsql/admin_pgsql.sma create mode 100755 dlls/pgsql/amxxmodule.cpp create mode 100755 dlls/pgsql/amxxmodule.h create mode 100755 dlls/pgsql/moduleconfig.h delete mode 100755 dlls/pgsql/pgsql.cfg delete mode 100755 dlls/pgsql/pgsql.inc delete mode 100755 dlls/pgsql/pgsql_amx.def delete mode 100755 dlls/pgsql/readme.txt diff --git a/dlls/pgsql/admin_pgsql.sma b/dlls/pgsql/admin_pgsql.sma deleted file mode 100755 index c6963db3..00000000 --- a/dlls/pgsql/admin_pgsql.sma +++ /dev/null @@ -1,274 +0,0 @@ -/* AMX Mod X -* Admin Base for PgSQL Plugin -* -* by the David "BAILOPAN" Anderson -* -* This file for AMX Mod X. -* -* -* This program is free software; you can redistribute it and/or modify it -* under the terms of the GNU General Public License as published by the -* Free Software Foundation; either version 2 of the License, or (at -* your option) any later version. -* -* This program is distributed in the hope that it will be useful, but -* WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -* General Public License for more details. -* -* You should have received a copy of the GNU General Public License -* along with this program; if not, write to the Free Software Foundation, -* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -* -* In addition, as a special exception, the author gives permission to -* link the code of this program with the Half-Life Game Engine ("HL -* Engine") and Modified Game Libraries ("MODs") developed by Valve, -* L.L.C ("Valve"). You must obey the GNU General Public License in all -* respects for all of the code used other than the HL Engine and MODs -* from Valve. If you modify this file, you may extend this exception -* to your version of the file, but you are not obligated to do so. If -* you do not wish to do so, delete this exception statement from your -* version. -*/ - -#include -#include -#include - -#define MAX_ADMINS 64 - -new g_aPassword[MAX_ADMINS][32] -new g_aName[MAX_ADMINS][32] -new g_aFlags[MAX_ADMINS] -new g_aAccess[MAX_ADMINS] -new g_aNum = 0 -#if !defined NO_STEAM -new g_cmdLoopback[16] -#endif - -public plugin_init() -{ - register_plugin("Admin Base for PgSQL","0.16","BAILOPAN") - - register_cvar("amx_mode","2.0") - register_cvar("amx_password_field","_pw") - register_cvar("amx_default_access","") - register_srvcmd("amx_sqladmins","adminSql") - register_cvar("amx_pgsql_host","127.0.0.1") - register_cvar("amx_pgsql_user","root") - register_cvar("amx_pgsql_pass","") - register_cvar("amx_pgsql_db","amx") - - register_cvar("amx_vote_ratio","0.02") - register_cvar("amx_votekick_ratio","0.40") - register_cvar("amx_voteban_ratio","0.40") - register_cvar("amx_votemap_ratio","0.40") - register_cvar("amx_vote_time","10") - register_cvar("amx_vote_answers","1") - register_cvar("amx_vote_delay","60") - register_cvar("amx_last_voting","0") - register_cvar("amx_show_activity","2") - set_cvar_float("amx_last_voting",0.0) - - register_concmd("amx_reloadadmins","cmdReload",ADMIN_ADMIN) - -#if !defined NO_STEAM - format( g_cmdLoopback, 15, "amxauth%c%c%c%c" , - random_num('A','Z') , random_num('A','Z') ,random_num('A','Z'),random_num('A','Z') ) - register_clcmd( g_cmdLoopback, "ackSignal" ) -#endif - - remove_user_flags(0,read_flags("z")) // remove 'user' flag from server rights - - new configsDir[128] - get_configsdir(configsDir, 127) - server_cmd("exec %s/amxx.cfg", configsDir) // Execute main configuration file - server_cmd("exec %s/pgsql.cfg;amx_sqladmins", configsDir) -} - -public adminSql() { - new host[64],user[32],pass[32],db[32],error[128] - get_cvar_string("amx_pgsql_host",host,63) - get_cvar_string("amx_pgsql_user",user,31) - get_cvar_string("amx_pgsql_pass",pass,31) - get_cvar_string("amx_pgsql_db",db,31) - - new pgsql = pgsql_connect(host,user,pass,db) - if(pgsql < 1){ - pgsql_error(pgsql, error, 128) - server_print("[AMXX] PgSQL error: can't connect: '%s'",error) - return PLUGIN_HANDLED - } - - pgsql_query(pgsql,"CREATE TABLE IF NOT EXISTS admins ( auth varchar(32) NOT NULL default '', password varchar(32) NOT NULL default '', access varchar(32) NOT NULL default '', flags varchar(32) NOT NULL default '' ) TYPE=MyISAM") - - if(pgsql_query(pgsql,"SELECT auth,password,access,flags FROM admins") < 1) { - pgsql_error(pgsql,error,127) - server_print("[AMXX] PgSQL error: can't load admins: '%s'",error) - return PLUGIN_HANDLED - } - - new szFlags[32],szAccess[32],iAccess - while( pgsql_nextrow(pgsql) > 0 ) - { - pgsql_getfield(pgsql, 1, g_aName[ g_aNum ] ,31) - pgsql_getfield(pgsql, 2, g_aPassword[ g_aNum ] ,31) - pgsql_getfield(pgsql, 3, szAccess,31) - pgsql_getfield(pgsql, 4, szFlags,31) - - iAccess = read_flags(szAccess) - if (!(iAccess & ADMIN_USER) && !(iAccess & ADMIN_ADMIN)) { - iAccess |= ADMIN_ADMIN - } - - g_aAccess[ g_aNum ] = iAccess - g_aFlags[ g_aNum ] = read_flags( szFlags ) - ++g_aNum - } - - server_print("[AMXX] Loaded %d admin%s from database",g_aNum, (g_aNum == 1) ? "" : "s" ) - pgsql_close(pgsql) - return PLUGIN_HANDLED -} - -public cmdReload(id,level,cid) -{ - if (!cmd_access(id,level,cid,1)) - return PLUGIN_HANDLED - - g_aNum = 0 - adminSql() // Re-Load admins accounts - - return PLUGIN_HANDLED -} - -getAccess(id,name[],authid[],ip[], password[]){ - new index = -1 - new result = 0 - for(new i = 0; i < g_aNum; ++i) { - if (g_aFlags[i] & FLAG_AUTHID) { - if (equal(authid,g_aName[i])) { - index = i - break - } - } - else if (g_aFlags[i] & FLAG_IP) { - new c = strlen( g_aName[i] ) - if ( g_aName[i][ c - 1 ] == '.' ) { /* check if this is not a xxx.xxx. format */ - if ( equal( g_aName[i] , ip , c ) ) { - index = i - break - } - } /* in other case an IP must just match */ - else if ( equal(ip,g_aName[i]) ){ - index = i - break - } - } - else { - if (g_aFlags[i] & FLAG_TAG) { - if (contain(name,g_aName[i])!=-1){ - index = i - break - } - } - else if (equal(name,g_aName[i])) { - index = i - break - } - } - } - if (index != -1) { - if (g_aFlags[index] & FLAG_NOPASS){ - result |= 8 - new sflags[32] - get_flags(g_aAccess[index],sflags,31) - set_user_flags(id,g_aAccess[index]) - log_amx("Login: ^"%s<%d><%s><>^" became an admin (account ^"%s^") (access ^"%s^") (address ^"%s^")", - name,get_user_userid(id),authid,g_aName[index] ,sflags,ip) - } - else if (equal(password,g_aPassword[index])) { - result |= 12 - set_user_flags(id,g_aAccess[index]) - new sflags[32] - get_flags(g_aAccess[index],sflags,31) - log_amx("Login: ^"%s<%d><%s><>^" became an admin (account ^"%s^") (access ^"%s^") (address ^"%s^")", - name,get_user_userid(id),authid,g_aName[index] ,sflags,ip) - } - else { - result |= 1 - if (g_aFlags[index] & FLAG_KICK){ - result |= 2 - log_amx("Login: ^"%s<%d><%s><>^" kicked due to invalid password (account ^"%s^") (address ^"%s^")", - name,get_user_userid(id),authid,g_aName[index],ip) - } - } - } - else if (get_cvar_float("amx_mode")==2.0) { - result |= 2 - } - else { - new defaccess[32] - get_cvar_string("amx_default_access",defaccess,31) - if (!defaccess[0]) - defaccess[0] = 'z' - new idefaccess = read_flags(defaccess) - if (idefaccess){ - result |= 8 - set_user_flags(id,idefaccess) - } - } - - return result -} - -accessUser( id, name[]="" ) -{ - remove_user_flags(id) - new userip[32],userauthid[32],password[32],passfield[32],username[32] - get_user_ip(id,userip,31,1) - get_user_authid(id,userauthid,31) - if ( name[0] ) copy( username , 31, name) - else get_user_name(id,username,31 ) - get_cvar_string("amx_password_field",passfield,31) - get_user_info(id,passfield,password,31) - new result = getAccess(id,username,userauthid,userip,password) - if (result & 1) client_cmd(id,"echo ^"* Invalid Password!^"") - if (result & 2) { -#if !defined NO_STEAM - client_cmd(id,g_cmdLoopback) -#else - client_cmd(id,"echo ^"* You have no entry to the server...^";disconnect") -#endif - return PLUGIN_HANDLED - } - if (result & 4) client_cmd(id,"echo ^"* Password accepted^"") - if (result & 8) client_cmd(id,"echo ^"* Privileges set^"") - return PLUGIN_CONTINUE -} - -public client_infochanged(id) -{ - if ( !is_user_connected(id) || !get_cvar_num("amx_mode") ) - return PLUGIN_CONTINUE - - new newname[32], oldname[32] - get_user_name(id,oldname,31) - get_user_info(id,"name",newname,31) - - if ( !equal(newname,oldname) ) - accessUser( id , newname ) - - return PLUGIN_CONTINUE -} - -#if !defined NO_STEAM - -public ackSignal(id) - server_cmd("kick #%d ^"You have no entry to the server...^"", get_user_userid(id) ) - -public client_authorized(id) -#else -public client_connect(id) -#endif - return get_cvar_num( "amx_mode" ) ? accessUser( id ) : PLUGIN_CONTINUE diff --git a/dlls/pgsql/amxxmodule.cpp b/dlls/pgsql/amxxmodule.cpp new file mode 100755 index 00000000..b021ab49 --- /dev/null +++ b/dlls/pgsql/amxxmodule.cpp @@ -0,0 +1,2990 @@ +/* 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; + +// 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)); + 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 ) ); + + 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)); + 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)); + 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)); + 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)); + 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 *************/ + +// *** Types *** +typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/); + +// *** 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 +}; + +// Storage for the requested functions +PFN_ADD_NATIVES g_fn_AddNatives; +PFN_BUILD_PATHNAME g_fn_BuildPathname; +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_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_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_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; + +// *** 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; + + // Req all known functions + // Misc + REQFUNC("BuildPathname", g_fn_BuildPathname, PFN_BUILD_PATHNAME); + REQFUNC("PrintSrvConsole", g_fn_PrintSrvConsole, PFN_PRINT_SRVCONSOLE); + REQFUNC("GetModname", g_fn_GetModname, PFN_GET_MODNAME); + REQFUNC("Log", g_fn_Log, PFN_LOG); + + // 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); + + // 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); + + // 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); + + // 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("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); + + // 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_NAME, msg); +} + + +#ifdef _DEBUG +// validate macros +// Makes sure compiler reports errors when macros are invalid +void ValidateMacros_DontCallThis_Smiley() +{ + MF_BuildPathname("str", "str", 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_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_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_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, 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); + MF_UnloadAmxScript(0, 0); + MF_RegisterSPForward(0, 0, 0, 0, 0, 0); + MF_RegisterSPForwardByName(0, 0, 0, 0, 0, 0); + MF_UnregisterSPForward(0); +} +#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 + throw std::bad_alloc(); +} + +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 + throw std::bad_alloc(); +} + +// 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 + throw std::bad_alloc(); +} +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 + throw std::bad_alloc(); +} + +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/pgsql/amxxmodule.h b/dlls/pgsql/amxxmodule.h new file mode 100755 index 00000000..b548edf1 --- /dev/null +++ b/dlls/pgsql/amxxmodule.h @@ -0,0 +1,2152 @@ +/* + * 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 is 1 +#define AMXX_INTERFACE_VERSION 1 + +// amxx module info +struct amxx_module_info_s +{ + const char *name; + const char *author; + const char *version; + int reload; // reload on mapchange when nonzero +}; + + + +// 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-2004 + +#if defined __LCC__ || defined __DMC__ || defined __linux__ + #include +#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 __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 + + +/* 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 SMALL_CELL_SIZE + #define SMALL_CELL_SIZE 32 /* by default, use 32-bit cells */ +#endif +#if SMALL_CELL_SIZE==32 + typedef uint32_t ucell; + typedef int32_t cell; + typedef float REAL; +#elif SMALL_CELL_SIZE==64 + typedef uint64_t ucell; + typedef int64_t cell; + typedef double REAL; +#else + #error Unsupported cell size (SMALL_CELL_SIZE) +#endif + +#define UNPACKEDMAX ((1 << (sizeof(cell)-1)*8) - 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 + + +#if defined SN_TARGET_PS2 || defined __GNUC__ + #define AMX_NO_ALIGN +#endif + + +#if defined __GNUC__ + #define PACKED __attribute__((packed)) +#else + #define PACKED +#endif + + +#if !defined AMX_NO_ALIGN + #if defined __linux__ + #pragma pack(1) /* structures must be packed (byte-aligned) */ + #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 ("amxhdr") 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() */ + /* for assertions and debug hook */ + cell curline PACKED; + cell curfile PACKED; + int dbgcode PACKED; + cell dbgaddr PACKED; + cell dbgparam PACKED; + char _FAR *dbgname PACKED; + /* user data */ + long usertags[AMX_USERNUM] PACKED; + void _FAR *userdata[AMX_USERNUM] PACKED; + /* native functions can raise an error */ + int error PACKED; + /* 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 */ + #if defined JIT + /* 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 */ + #endif +} 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_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 */ +}; + + +// ***** 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_DETTACH +void FN_META_DETTACH(void); +#endif // FN_META_DETTACH + + + + + +#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, long 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_DETTACH +void FN_AMXX_DETTACH(void); +#endif // FN_AMXX_DETTACH + +#ifdef FN_AMXX_PLUGINSLOADED +void FN_AMXX_PLUGINSLOADED(void); +#endif // FN_AMXX_PLUGINSLOADED + +// ***** 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 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 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 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_GET_PLAYER_CURWEAPON) (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*/); +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*/, int /*numparams*/, ... /*params*/); +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_LOAD_AMXSCRIPT) (AMX* /*amx*/, void** /*code*/, const char* /*path*/, char[64] /*error info*/); +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*/); + +extern PFN_ADD_NATIVES g_fn_AddNatives; +extern PFN_BUILD_PATHNAME g_fn_BuildPathname; +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_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_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; + +#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, ...) { } +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, ...) { } +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) { } +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) { } +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) { } +#endif // MAY_NEVER_BE_DEFINED + +#define MF_AddNatives g_fn_AddNatives +#define MF_BuildPathname g_fn_BuildPathname +#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, ...); +#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_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_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_LoadAmxScript g_fn_LoadAmxScript +#define MF_UnloadAmxScript g_fn_UnloadAmxScript +#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 + +/*** 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/pgsql/lib/libpq.lib b/dlls/pgsql/lib/libpq.lib index 9fe13e3d6b5fde521e1e9fa4d0f938aa11e32547..1c4c382c96066f4a67da527d5ed8339fd8b7ff5a 100755 GIT binary patch delta 71 zcmcclL*VrdrU}yQrshUQ2F9ivl{mv;?9E2uu|aUow3XaU5RQ?_^o0kR#U}4tEx^3u L?6%1lSI+_fBS{z@ literal 277593 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 diff --git a/dlls/pgsql/moduleconfig.h b/dlls/pgsql/moduleconfig.h new file mode 100755 index 00000000..c3be1116 --- /dev/null +++ b/dlls/pgsql/moduleconfig.h @@ -0,0 +1,462 @@ +// Configuration + +#ifndef __MODULECONFIG_H__ +#define __MODULECONFIG_H__ + +// Module info +#define MODULE_NAME "PgSQL" +#define MODULE_VERSION "1.1" +#define MODULE_AUTHOR "BAILOPAN" +#define MODULE_URL "http://www.bailopan.com/" +#define MODULE_LOGTAG "PGSQL" +// If you want the module not to be reloaded on mapchange, remove / comment out the next line +#define MODULE_RELOAD_ON_MAPCHANGE + +#ifdef __DATE__ +#define MODULE_DATE __DATE__ +#else // __DATE__ +#define MODULE_DATE "Unknown" +#endif // __DATE__ + +// metamod plugin? +// #define USE_METAMOD + +// - AMXX Init functions +// Also consider using FN_META_* +// AMXX query +//#define FN_AMXX_QUERY OnAmxxQuery +// AMXX attach +// Do native functions init here (MF_AddNatives) +#define FN_AMXX_ATTACH OnAmxxAttach +// AMXX dettach +//#define FN_AMXX_DETTACH 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 dettach +//#define FN_META_DETTACH OnMetaDettach + +// (wd) are Will Day's notes +// - GetEntityAPI2 functions +// #define FN_GameDLLInit GameDLLInit /* pfnGameInit() */ +// #define FN_DispatchSpawn DispatchSpawn /* pfnSpawn() */ +// #define FN_DispatchThink DispatchThink /* pfnThink() */ +// #define FN_DispatchUse DispatchUse /* pfnUse() */ +// #define FN_DispatchTouch DispatchTouch /* pfnTouch() */ +// #define FN_DispatchBlocked DispatchBlocked /* pfnBlocked() */ +// #define FN_DispatchKeyValue DispatchKeyValue /* pfnKeyValue() */ +// #define FN_DispatchSave DispatchSave /* pfnSave() */ +// #define FN_DispatchRestore DispatchRestore /* pfnRestore() */ +// #define FN_DispatchObjectCollsionBox DispatchObjectCollsionBox /* pfnSetAbsBox() */ +// #define FN_SaveWriteFields SaveWriteFields /* pfnSaveWriteFields() */ +// #define FN_SaveReadFields SaveReadFields /* pfnSaveReadFields() */ +// #define FN_SaveGlobalState SaveGlobalState /* pfnSaveGlobalState() */ +// #define FN_RestoreGlobalState RestoreGlobalState /* pfnRestoreGlobalState() */ +// #define FN_ResetGlobalState ResetGlobalState /* pfnResetGlobalState() */ +// #define FN_ClientConnect ClientConnect /* pfnClientConnect() (wd) Client has connected */ +// #define FN_ClientDisconnect ClientDisconnect /* pfnClientDisconnect() (wd) Player has left the game */ +// #define FN_ClientKill ClientKill /* pfnClientKill() (wd) Player has typed "kill" */ +// #define FN_ClientPutInServer ClientPutInServer /* pfnClientPutInServer() (wd) Client is entering the game */ +// #define FN_ClientCommand ClientCommand /* pfnClientCommand() (wd) Player has sent a command (typed or from a bind) */ +// #define FN_ClientUserInfoChanged ClientUserInfoChanged /* pfnClientUserInfoChanged() (wd) Client has updated their setinfo structure */ +// #define FN_ServerActivate ServerActivate /* pfnServerActivate() (wd) Server is starting a new map */ +// #define FN_ServerDeactivate ServerDeactivate /* pfnServerDeactivate() (wd) Server is leaving the map (shutdown or changelevel); SDK2 */ +// #define FN_PlayerPreThink PlayerPreThink /* pfnPlayerPreThink() */ +// #define FN_PlayerPostThink PlayerPostThink /* pfnPlayerPostThink() */ +// #define FN_StartFrame StartFrame /* pfnStartFrame() */ +// #define FN_ParmsNewLevel ParmsNewLevel /* pfnParmsNewLevel() */ +// #define FN_ParmsChangeLevel ParmsChangeLevel /* pfnParmsChangeLevel() */ +// #define FN_GetGameDescription GetGameDescription /* pfnGetGameDescription() Returns string describing current .dll. E.g. "TeamFotrress 2" "Half-Life" */ +// #define FN_PlayerCustomization PlayerCustomization /* pfnPlayerCustomization() Notifies .dll of new customization for player. */ +// #define FN_SpectatorConnect SpectatorConnect /* pfnSpectatorConnect() Called when spectator joins server */ +// #define FN_SpectatorDisconnect SpectatorDisconnect /* pfnSpectatorDisconnect() Called when spectator leaves the server */ +// #define FN_SpectatorThink SpectatorThink /* pfnSpectatorThink() Called when spectator sends a command packet (usercmd_t) */ +// #define FN_Sys_Error Sys_Error /* pfnSys_Error() Notify game .dll that engine is going to shut down. Allows mod authors to set a breakpoint. SDK2 */ +// #define FN_PM_Move PM_Move /* pfnPM_Move() (wd) SDK2 */ +// #define FN_PM_Init PM_Init /* pfnPM_Init() Server version of player movement initialization; (wd) SDK2 */ +// #define FN_PM_FindTextureType PM_FindTextureType /* pfnPM_FindTextureType() (wd) SDK2 */ +// #define FN_SetupVisibility SetupVisibility /* pfnSetupVisibility() Set up PVS and PAS for networking for this client; (wd) SDK2 */ +// #define FN_UpdateClientData UpdateClientData /* pfnUpdateClientData() Set up data sent only to specific client; (wd) SDK2 */ +// #define FN_AddToFullPack AddToFullPack /* pfnAddToFullPack() (wd) SDK2 */ +// #define FN_CreateBaseline CreateBaseline /* pfnCreateBaseline() Tweak entity baseline for network encoding allows setup of player baselines too.; (wd) SDK2 */ +// #define FN_RegisterEncoders RegisterEncoders /* pfnRegisterEncoders() Callbacks for network encoding; (wd) SDK2 */ +// #define FN_GetWeaponData GetWeaponData /* pfnGetWeaponData() (wd) SDK2 */ +// #define FN_CmdStart CmdStart /* pfnCmdStart() (wd) SDK2 */ +// #define FN_CmdEnd CmdEnd /* pfnCmdEnd() (wd) SDK2 */ +// #define FN_ConnectionlessPacket ConnectionlessPacket /* pfnConnectionlessPacket() (wd) SDK2 */ +// #define FN_GetHullBounds GetHullBounds /* pfnGetHullBounds() (wd) SDK2 */ +// #define FN_CreateInstancedBaselines CreateInstancedBaselines /* pfnCreateInstancedBaselines() (wd) SDK2 */ +// #define FN_InconsistentFile InconsistentFile /* pfnInconsistentFile() (wd) SDK2 */ +// #define FN_AllowLagCompensation AllowLagCompensation /* pfnAllowLagCompensation() (wd) SDK2 */ + +// - GetEntityAPI2_Post functions +// #define FN_GameDLLInit_Post GameDLLInit_Post +// #define FN_DispatchSpawn_Post DispatchSpawn_Post +// #define FN_DispatchThink_Post DispatchThink_Post +// #define FN_DispatchUse_Post DispatchUse_Post +// #define FN_DispatchTouch_Post DispatchTouch_Post +// #define FN_DispatchBlocked_Post DispatchBlocked_Post +// #define FN_DispatchKeyValue_Post DispatchKeyValue_Post +// #define FN_DispatchSave_Post DispatchSave_Post +// #define FN_DispatchRestore_Post DispatchRestore_Post +// #define FN_DispatchObjectCollsionBox_Post DispatchObjectCollsionBox_Post +// #define FN_SaveWriteFields_Post SaveWriteFields_Post +// #define FN_SaveReadFields_Post SaveReadFields_Post +// #define FN_SaveGlobalState_Post SaveGlobalState_Post +// #define FN_RestoreGlobalState_Post RestoreGlobalState_Post +// #define FN_ResetGlobalState_Post ResetGlobalState_Post +// #define FN_ClientConnect_Post ClientConnect_Post +// #define FN_ClientDisconnect_Post ClientDisconnect_Post +// #define FN_ClientKill_Post ClientKill_Post +// #define FN_ClientPutInServer_Post ClientPutInServer_Post +// #define FN_ClientCommand_Post ClientCommand_Post +// #define FN_ClientUserInfoChanged_Post ClientUserInfoChanged_Post +// #define FN_ServerActivate_Post ServerActivate_Post +// #define FN_ServerDeactivate_Post ServerDeactivate_Post +// #define FN_PlayerPreThink_Post PlayerPreThink_Post +// #define FN_PlayerPostThink_Post PlayerPostThink_Post +// #define FN_StartFrame_Post StartFrame_Post +// #define FN_ParmsNewLevel_Post ParmsNewLevel_Post +// #define FN_ParmsChangeLevel_Post ParmsChangeLevel_Post +// #define FN_GetGameDescription_Post GetGameDescription_Post +// #define FN_PlayerCustomization_Post PlayerCustomization_Post +// #define FN_SpectatorConnect_Post SpectatorConnect_Post +// #define FN_SpectatorDisconnect_Post SpectatorDisconnect_Post +// #define FN_SpectatorThink_Post SpectatorThink_Post +// #define FN_Sys_Error_Post Sys_Error_Post +// #define FN_PM_Move_Post PM_Move_Post +// #define FN_PM_Init_Post PM_Init_Post +// #define FN_PM_FindTextureType_Post PM_FindTextureType_Post +// #define FN_SetupVisibility_Post SetupVisibility_Post +// #define FN_UpdateClientData_Post UpdateClientData_Post +// #define FN_AddToFullPack_Post AddToFullPack_Post +// #define FN_CreateBaseline_Post CreateBaseline_Post +// #define FN_RegisterEncoders_Post RegisterEncoders_Post +// #define FN_GetWeaponData_Post GetWeaponData_Post +// #define FN_CmdStart_Post CmdStart_Post +// #define FN_CmdEnd_Post CmdEnd_Post +// #define FN_ConnectionlessPacket_Post ConnectionlessPacket_Post +// #define FN_GetHullBounds_Post GetHullBounds_Post +// #define FN_CreateInstancedBaselines_Post CreateInstancedBaselines_Post +// #define FN_InconsistentFile_Post InconsistentFile_Post +// #define FN_AllowLagCompensation_Post AllowLagCompensation_Post + +// - GetEngineAPI functions +// #define FN_PrecacheModel PrecacheModel +// #define FN_PrecacheSound PrecacheSound +// #define FN_SetModel SetModel +// #define FN_ModelIndex ModelIndex +// #define FN_ModelFrames ModelFrames +// #define FN_SetSize SetSize +// #define FN_ChangeLevel ChangeLevel +// #define FN_GetSpawnParms GetSpawnParms +// #define FN_SaveSpawnParms SaveSpawnParms +// #define FN_VecToYaw VecToYaw +// #define FN_VecToAngles VecToAngles +// #define FN_MoveToOrigin MoveToOrigin +// #define FN_ChangeYaw ChangeYaw +// #define FN_ChangePitch ChangePitch +// #define FN_FindEntityByString FindEntityByString +// #define FN_GetEntityIllum GetEntityIllum +// #define FN_FindEntityInSphere FindEntityInSphere +// #define FN_FindClientInPVS FindClientInPVS +// #define FN_EntitiesInPVS EntitiesInPVS +// #define FN_MakeVectors MakeVectors +// #define FN_AngleVectors AngleVectors +// #define FN_CreateEntity CreateEntity +// #define FN_RemoveEntity RemoveEntity +// #define FN_CreateNamedEntity CreateNamedEntity +// #define FN_MakeStatic MakeStatic +// #define FN_EntIsOnFloor EntIsOnFloor +// #define FN_DropToFloor DropToFloor +// #define FN_WalkMove WalkMove +// #define FN_SetOrigin SetOrigin +// #define FN_EmitSound EmitSound +// #define FN_EmitAmbientSound EmitAmbientSound +// #define FN_TraceLine TraceLine +// #define FN_TraceToss TraceToss +// #define FN_TraceMonsterHull TraceMonsterHull +// #define FN_TraceHull TraceHull +// #define FN_TraceModel TraceModel +// #define FN_TraceTexture TraceTexture +// #define FN_TraceSphere TraceSphere +// #define FN_GetAimVector GetAimVector +// #define FN_ServerCommand ServerCommand +// #define FN_ServerExecute ServerExecute +// #define FN_engClientCommand engClientCommand +// #define FN_ParticleEffect ParticleEffect +// #define FN_LightStyle LightStyle +// #define FN_DecalIndex DecalIndex +// #define FN_PointContents PointContents +// #define FN_MessageBegin MessageBegin +// #define FN_MessageEnd MessageEnd +// #define FN_WriteByte WriteByte +// #define FN_WriteChar WriteChar +// #define FN_WriteShort WriteShort +// #define FN_WriteLong WriteLong +// #define FN_WriteAngle WriteAngle +// #define FN_WriteCoord WriteCoord +// #define FN_WriteString WriteString +// #define FN_WriteEntity WriteEntity +// #define FN_CVarRegister CVarRegister +// #define FN_CVarGetFloat CVarGetFloat +// #define FN_CVarGetString CVarGetString +// #define FN_CVarSetFloat CVarSetFloat +// #define FN_CVarSetString CVarSetString +// #define FN_AlertMessage AlertMessage +// #define FN_EngineFprintf EngineFprintf +// #define FN_PvAllocEntPrivateData PvAllocEntPrivateData +// #define FN_PvEntPrivateData PvEntPrivateData +// #define FN_FreeEntPrivateData FreeEntPrivateData +// #define FN_SzFromIndex SzFromIndex +// #define FN_AllocString AllocString +// #define FN_GetVarsOfEnt GetVarsOfEnt +// #define FN_PEntityOfEntOffset PEntityOfEntOffset +// #define FN_EntOffsetOfPEntity EntOffsetOfPEntity +// #define FN_IndexOfEdict IndexOfEdict +// #define FN_PEntityOfEntIndex PEntityOfEntIndex +// #define FN_FindEntityByVars FindEntityByVars +// #define FN_GetModelPtr GetModelPtr +// #define FN_RegUserMsg RegUserMsg +// #define FN_AnimationAutomove AnimationAutomove +// #define FN_GetBonePosition GetBonePosition +// #define FN_FunctionFromName FunctionFromName +// #define FN_NameForFunction NameForFunction +// #define FN_ClientPrintf ClientPrintf +// #define FN_ServerPrint ServerPrint +// #define FN_Cmd_Args Cmd_Args +// #define FN_Cmd_Argv Cmd_Argv +// #define FN_Cmd_Argc Cmd_Argc +// #define FN_GetAttachment GetAttachment +// #define FN_CRC32_Init CRC32_Init +// #define FN_CRC32_ProcessBuffer CRC32_ProcessBuffer +// #define FN_CRC32_ProcessByte CRC32_ProcessByte +// #define FN_CRC32_Final CRC32_Final +// #define FN_RandomLong RandomLong +// #define FN_RandomFloat RandomFloat +// #define FN_SetView SetView +// #define FN_Time Time +// #define FN_CrosshairAngle CrosshairAngle +// #define FN_LoadFileForMe LoadFileForMe +// #define FN_FreeFile FreeFile +// #define FN_EndSection EndSection +// #define FN_CompareFileTime CompareFileTime +// #define FN_GetGameDir GetGameDir +// #define FN_Cvar_RegisterVariable Cvar_RegisterVariable +// #define FN_FadeClientVolume FadeClientVolume +// #define FN_SetClientMaxspeed SetClientMaxspeed +// #define FN_CreateFakeClient CreateFakeClient +// #define FN_RunPlayerMove RunPlayerMove +// #define FN_NumberOfEntities NumberOfEntities +// #define FN_GetInfoKeyBuffer GetInfoKeyBuffer +// #define FN_InfoKeyValue InfoKeyValue +// #define FN_SetKeyValue SetKeyValue +// #define FN_SetClientKeyValue SetClientKeyValue +// #define FN_IsMapValid IsMapValid +// #define FN_StaticDecal StaticDecal +// #define FN_PrecacheGeneric PrecacheGeneric +// #define FN_GetPlayerUserId GetPlayerUserId +// #define FN_BuildSoundMsg BuildSoundMsg +// #define FN_IsDedicatedServer IsDedicatedServer +// #define FN_CVarGetPointer CVarGetPointer +// #define FN_GetPlayerWONId GetPlayerWONId +// #define FN_Info_RemoveKey Info_RemoveKey +// #define FN_GetPhysicsKeyValue GetPhysicsKeyValue +// #define FN_SetPhysicsKeyValue SetPhysicsKeyValue +// #define FN_GetPhysicsInfoString GetPhysicsInfoString +// #define FN_PrecacheEvent PrecacheEvent +// #define FN_PlaybackEvent PlaybackEvent +// #define FN_SetFatPVS SetFatPVS +// #define FN_SetFatPAS SetFatPAS +// #define FN_CheckVisibility CheckVisibility +// #define FN_DeltaSetField DeltaSetField +// #define FN_DeltaUnsetField DeltaUnsetField +// #define FN_DeltaAddEncoder DeltaAddEncoder +// #define FN_GetCurrentPlayer GetCurrentPlayer +// #define FN_CanSkipPlayer CanSkipPlayer +// #define FN_DeltaFindField DeltaFindField +// #define FN_DeltaSetFieldByIndex DeltaSetFieldByIndex +// #define FN_DeltaUnsetFieldByIndex DeltaUnsetFieldByIndex +// #define FN_SetGroupMask SetGroupMask +// #define FN_engCreateInstancedBaseline engCreateInstancedBaseline +// #define FN_Cvar_DirectSet Cvar_DirectSet +// #define FN_ForceUnmodified ForceUnmodified +// #define FN_GetPlayerStats GetPlayerStats +// #define FN_AddServerCommand AddServerCommand +// #define FN_Voice_GetClientListening Voice_GetClientListening +// #define FN_Voice_SetClientListening Voice_SetClientListening +// #define FN_GetPlayerAuthId GetPlayerAuthId + +// - GetEngineAPI_Post functions +// #define FN_PrecacheModel_Post PrecacheModel_Post +// #define FN_PrecacheSound_Post PrecacheSound_Post +// #define FN_SetModel_Post SetModel_Post +// #define FN_ModelIndex_Post ModelIndex_Post +// #define FN_ModelFrames_Post ModelFrames_Post +// #define FN_SetSize_Post SetSize_Post +// #define FN_ChangeLevel_Post ChangeLevel_Post +// #define FN_GetSpawnParms_Post GetSpawnParms_Post +// #define FN_SaveSpawnParms_Post SaveSpawnParms_Post +// #define FN_VecToYaw_Post VecToYaw_Post +// #define FN_VecToAngles_Post VecToAngles_Post +// #define FN_MoveToOrigin_Post MoveToOrigin_Post +// #define FN_ChangeYaw_Post ChangeYaw_Post +// #define FN_ChangePitch_Post ChangePitch_Post +// #define FN_FindEntityByString_Post FindEntityByString_Post +// #define FN_GetEntityIllum_Post GetEntityIllum_Post +// #define FN_FindEntityInSphere_Post FindEntityInSphere_Post +// #define FN_FindClientInPVS_Post FindClientInPVS_Post +// #define FN_EntitiesInPVS_Post EntitiesInPVS_Post +// #define FN_MakeVectors_Post MakeVectors_Post +// #define FN_AngleVectors_Post AngleVectors_Post +// #define FN_CreateEntity_Post CreateEntity_Post +// #define FN_RemoveEntity_Post RemoveEntity_Post +// #define FN_CreateNamedEntity_Post CreateNamedEntity_Post +// #define FN_MakeStatic_Post MakeStatic_Post +// #define FN_EntIsOnFloor_Post EntIsOnFloor_Post +// #define FN_DropToFloor_Post DropToFloor_Post +// #define FN_WalkMove_Post WalkMove_Post +// #define FN_SetOrigin_Post SetOrigin_Post +// #define FN_EmitSound_Post EmitSound_Post +// #define FN_EmitAmbientSound_Post EmitAmbientSound_Post +// #define FN_TraceLine_Post TraceLine_Post +// #define FN_TraceToss_Post TraceToss_Post +// #define FN_TraceMonsterHull_Post TraceMonsterHull_Post +// #define FN_TraceHull_Post TraceHull_Post +// #define FN_TraceModel_Post TraceModel_Post +// #define FN_TraceTexture_Post TraceTexture_Post +// #define FN_TraceSphere_Post TraceSphere_Post +// #define FN_GetAimVector_Post GetAimVector_Post +// #define FN_ServerCommand_Post ServerCommand_Post +// #define FN_ServerExecute_Post ServerExecute_Post +// #define FN_engClientCommand_Post engClientCommand_Post +// #define FN_ParticleEffect_Post ParticleEffect_Post +// #define FN_LightStyle_Post LightStyle_Post +// #define FN_DecalIndex_Post DecalIndex_Post +// #define FN_PointContents_Post PointContents_Post +// #define FN_MessageBegin_Post MessageBegin_Post +// #define FN_MessageEnd_Post MessageEnd_Post +// #define FN_WriteByte_Post WriteByte_Post +// #define FN_WriteChar_Post WriteChar_Post +// #define FN_WriteShort_Post WriteShort_Post +// #define FN_WriteLong_Post WriteLong_Post +// #define FN_WriteAngle_Post WriteAngle_Post +// #define FN_WriteCoord_Post WriteCoord_Post +// #define FN_WriteString_Post WriteString_Post +// #define FN_WriteEntity_Post WriteEntity_Post +// #define FN_CVarRegister_Post CVarRegister_Post +// #define FN_CVarGetFloat_Post CVarGetFloat_Post +// #define FN_CVarGetString_Post CVarGetString_Post +// #define FN_CVarSetFloat_Post CVarSetFloat_Post +// #define FN_CVarSetString_Post CVarSetString_Post +// #define FN_AlertMessage_Post AlertMessage_Post +// #define FN_EngineFprintf_Post EngineFprintf_Post +// #define FN_PvAllocEntPrivateData_Post PvAllocEntPrivateData_Post +// #define FN_PvEntPrivateData_Post PvEntPrivateData_Post +// #define FN_FreeEntPrivateData_Post FreeEntPrivateData_Post +// #define FN_SzFromIndex_Post SzFromIndex_Post +// #define FN_AllocString_Post AllocString_Post +// #define FN_GetVarsOfEnt_Post GetVarsOfEnt_Post +// #define FN_PEntityOfEntOffset_Post PEntityOfEntOffset_Post +// #define FN_EntOffsetOfPEntity_Post EntOffsetOfPEntity_Post +// #define FN_IndexOfEdict_Post IndexOfEdict_Post +// #define FN_PEntityOfEntIndex_Post PEntityOfEntIndex_Post +// #define FN_FindEntityByVars_Post FindEntityByVars_Post +// #define FN_GetModelPtr_Post GetModelPtr_Post +// #define FN_RegUserMsg_Post RegUserMsg_Post +// #define FN_AnimationAutomove_Post AnimationAutomove_Post +// #define FN_GetBonePosition_Post GetBonePosition_Post +// #define FN_FunctionFromName_Post FunctionFromName_Post +// #define FN_NameForFunction_Post NameForFunction_Post +// #define FN_ClientPrintf_Post ClientPrintf_Post +// #define FN_ServerPrint_Post ServerPrint_Post +// #define FN_Cmd_Args_Post Cmd_Args_Post +// #define FN_Cmd_Argv_Post Cmd_Argv_Post +// #define FN_Cmd_Argc_Post Cmd_Argc_Post +// #define FN_GetAttachment_Post GetAttachment_Post +// #define FN_CRC32_Init_Post CRC32_Init_Post +// #define FN_CRC32_ProcessBuffer_Post CRC32_ProcessBuffer_Post +// #define FN_CRC32_ProcessByte_Post CRC32_ProcessByte_Post +// #define FN_CRC32_Final_Post CRC32_Final_Post +// #define FN_RandomLong_Post RandomLong_Post +// #define FN_RandomFloat_Post RandomFloat_Post +// #define FN_SetView_Post SetView_Post +// #define FN_Time_Post Time_Post +// #define FN_CrosshairAngle_Post CrosshairAngle_Post +// #define FN_LoadFileForMe_Post LoadFileForMe_Post +// #define FN_FreeFile_Post FreeFile_Post +// #define FN_EndSection_Post EndSection_Post +// #define FN_CompareFileTime_Post CompareFileTime_Post +// #define FN_GetGameDir_Post GetGameDir_Post +// #define FN_Cvar_RegisterVariable_Post Cvar_RegisterVariable_Post +// #define FN_FadeClientVolume_Post FadeClientVolume_Post +// #define FN_SetClientMaxspeed_Post SetClientMaxspeed_Post +// #define FN_CreateFakeClient_Post CreateFakeClient_Post +// #define FN_RunPlayerMove_Post RunPlayerMove_Post +// #define FN_NumberOfEntities_Post NumberOfEntities_Post +// #define FN_GetInfoKeyBuffer_Post GetInfoKeyBuffer_Post +// #define FN_InfoKeyValue_Post InfoKeyValue_Post +// #define FN_SetKeyValue_Post SetKeyValue_Post +// #define FN_SetClientKeyValue_Post SetClientKeyValue_Post +// #define FN_IsMapValid_Post IsMapValid_Post +// #define FN_StaticDecal_Post StaticDecal_Post +// #define FN_PrecacheGeneric_Post PrecacheGeneric_Post +// #define FN_GetPlayerUserId_Post GetPlayerUserId_Post +// #define FN_BuildSoundMsg_Post BuildSoundMsg_Post +// #define FN_IsDedicatedServer_Post IsDedicatedServer_Post +// #define FN_CVarGetPointer_Post CVarGetPointer_Post +// #define FN_GetPlayerWONId_Post GetPlayerWONId_Post +// #define FN_Info_RemoveKey_Post Info_RemoveKey_Post +// #define FN_GetPhysicsKeyValue_Post GetPhysicsKeyValue_Post +// #define FN_SetPhysicsKeyValue_Post SetPhysicsKeyValue_Post +// #define FN_GetPhysicsInfoString_Post GetPhysicsInfoString_Post +// #define FN_PrecacheEvent_Post PrecacheEvent_Post +// #define FN_PlaybackEvent_Post PlaybackEvent_Post +// #define FN_SetFatPVS_Post SetFatPVS_Post +// #define FN_SetFatPAS_Post SetFatPAS_Post +// #define FN_CheckVisibility_Post CheckVisibility_Post +// #define FN_DeltaSetField_Post DeltaSetField_Post +// #define FN_DeltaUnsetField_Post DeltaUnsetField_Post +// #define FN_DeltaAddEncoder_Post DeltaAddEncoder_Post +// #define FN_GetCurrentPlayer_Post GetCurrentPlayer_Post +// #define FN_CanSkipPlayer_Post CanSkipPlayer_Post +// #define FN_DeltaFindField_Post DeltaFindField_Post +// #define FN_DeltaSetFieldByIndex_Post DeltaSetFieldByIndex_Post +// #define FN_DeltaUnsetFieldByIndex_Post DeltaUnsetFieldByIndex_Post +// #define FN_SetGroupMask_Post SetGroupMask_Post +// #define FN_engCreateInstancedBaseline_Post engCreateInstancedBaseline_Post +// #define FN_Cvar_DirectSet_Post Cvar_DirectSet_Post +// #define FN_ForceUnmodified_Post ForceUnmodified_Post +// #define FN_GetPlayerStats_Post GetPlayerStats_Post +// #define FN_AddServerCommand_Post AddServerCommand_Post +// #define FN_Voice_GetClientListening_Post Voice_GetClientListening_Post +// #define FN_Voice_SetClientListening_Post Voice_SetClientListening_Post +// #define FN_GetPlayerAuthId_Post GetPlayerAuthId_Post + +// #define FN_OnFreeEntPrivateData OnFreeEntPrivateData +// #define FN_GameShutdown GameShutdown +// #define FN_ShouldCollide ShouldCollide + +// #define FN_OnFreeEntPrivateData_Post OnFreeEntPrivateData_Post +// #define FN_GameShutdown_Post GameShutdown_Post +// #define FN_ShouldCollide_Post ShouldCollide_Post + + +#endif // USE_METAMOD + +#endif // __MODULECONFIG_H__ \ No newline at end of file diff --git a/dlls/pgsql/pgsql.cfg b/dlls/pgsql/pgsql.cfg deleted file mode 100755 index ea7104b0..00000000 --- a/dlls/pgsql/pgsql.cfg +++ /dev/null @@ -1,9 +0,0 @@ -// pgSQL configuration file -// File location: $moddir/addons/amxx/configs/pgsql.cfg - -// *NOTE* Linux users may encounter problems if they specify "localhost" instead of "127.0.0.1" -// We recommend using your server IP address instead of its name -amx_pgsql_host "127.0.0.1" -amx_pgsql_user "root" -amx_pgsql_pass "" -amx_pgsql_db "amx" \ No newline at end of file diff --git a/dlls/pgsql/pgsql.inc b/dlls/pgsql/pgsql.inc deleted file mode 100755 index 1341fa11..00000000 --- a/dlls/pgsql/pgsql.inc +++ /dev/null @@ -1,32 +0,0 @@ -/* PostgreSQL functions -* -* by David "BAILOPAN" Anderson -* Under the GNU General Public License, version 2 -*/ - -#if defined _pgsql_included - #endinput -#endif -#define _pgsql_included - -/* Opens connection. If already such exists then that will be used. -* Function returns sql id to use with other sql natives. -* Host can be plain ip or hostname, ports are not yet allowed. */ -native pgsql_connect(host[],user[],pass[],dbname[]); - -/* Uses an existing connection (sql) to perform a new query (query) (might close previous query if any). - Will return the number of rows found. - */ -native pgsql_query(sql,query[], {Float,_}:...); - -/* Advances to the next row in the query set. */ -native pgsql_nextrow(sql); - -/* Stores specified column (fieldnum) of current query (sql) in (dest) with (maxlength) characters maximum. */ -native pgsql_getfield(sql,fieldnum,dest[],maxlength); - -/* Clears query (sql) and closes connection (if any other plugin doesn't use it). */ -native pgsql_close(sql); - -/* Stores last error of current query/connection (sql) in (dest) with (maxlength) characters maximum. */ -native pgsql_error(sql,dest[],maxlength); \ No newline at end of file diff --git a/dlls/pgsql/pgsql_amx.cpp b/dlls/pgsql/pgsql_amx.cpp index 0c60aabb..1eb69ac0 100755 --- a/dlls/pgsql/pgsql_amx.cpp +++ b/dlls/pgsql/pgsql_amx.cpp @@ -30,7 +30,24 @@ #include "pgsql_amx.h" -pgs *cns = NULL; +std::string error; +std::vector dblist; + +int sql_exists(const char* host,const char* user,const char* pass,const char* dbase) { + std::vector::iterator i; + int id = 0; + for (i=dblist.begin(); i!=dblist.end(); i++) { + id++; + if (((*i)->host.compare(host) == 0) && + ((*i)->user.compare(user) == 0) && + ((*i)->pass.compare(pass) == 0) && + ((*i)->name.compare(dbase) == 0) && + (!(*i)->free)) { + return id; + } + } + return -1; +} bool is_ipaddr(const char *IP) { @@ -43,180 +60,201 @@ bool is_ipaddr(const char *IP) return true; } - -char *make_connstring(const char *host, const char *user, const char *pass, const char *name) +void pgdb::Kill() { - int len = 46 + strlen(host) + strlen(user) + strlen(pass) + strlen(name) + 2; - char *c_info = new char[len]; - - if (is_ipaddr(host)) { - sprintf(c_info, "hostaddr = '%s' user = '%s' pass = '%s' name = '%s'", host, user, pass, name); - } else { - sprintf(c_info, "host = '%s' user = '%s' pass = '%s' name = '%s'", host, user, pass, name); - } - - return c_info; + if (free) + return; + PQfinish(cn); + host.clear(); + user.clear(); + pass.clear(); + name.clear(); + row = 0; + free = true; } -PGconn* make_connection(const char *h, const char *u, const char *ps, const char *n) +int pgdb::Connect(const char *hh, const char *uu, const char *pp, const char *dd) { - pgs *p = cns; - int last = 0; + host.assign(hh); + user.assign(uu); + pass.assign(pp); + name.assign(dd); + + if (is_ipaddr(host.c_str())) { + cstr.assign("hostaddr = '"); + } else { + cstr.assign("host = '"); + } - while (p) { - last = p->ii(); - if (p->v.host==h && p->v.user==u && p->v.pass==ps && p->v.name==n) { - return p->v.cn; - } - } - char *c_info = make_connstring(h, u, ps, n); - /* now search for a free one */ - p = cns; - while (p) { - if (p->free) { - p->set(h, u, ps, n, p->ii()); - return p->v.cn; - } else { - p = p->link(); - } - } - if (cns == NULL) { - cns = new pgs; - PGconn *cn = PQconnectdb(c_info); - cns->set(h, u, ps, n, 1); - cns->scn(cn); - return cn; - } else { - p = new pgs(h, u, ps, n, last+1); - cns->sln(p); - PGconn *cn = PQconnectdb(c_info); - cns->scn(cn); - return cn; - } -} + cstr.append(host); + cstr.append("' user = '"); + cstr.append(user); + cstr.append("' pass = '"); + cstr.append(pass); + cstr.append("' name = '"); + cstr.append(name); + cstr.append("'"); -pgs* get_conn_i(int n=1) -{ - pgs *p = cns; - int i=0; - while (p) { - if (++i==n) { - return p; - } else { - p = p->link(); - } + cn = PQconnectdb(cstr.c_str()); + + if (PQstatus(cn) != CONNECTION_OK) { + err.assign(PQerrorMessage(cn)); + free = true; + lastError = PQstatus(cn); + return 0; } - return NULL; + free = false; + return true; } static cell AMX_NATIVE_CALL pgsql_connect(AMX *amx, cell *params) { - int i; - const char *host = GET_AMXSTRING(amx,params[1],0,i); - const char *user = GET_AMXSTRING(amx,params[2],1,i); - const char *pass = GET_AMXSTRING(amx,params[3],2,i); - const char *name = GET_AMXSTRING(amx,params[4],3,i); + int len; + unsigned int i; + pgdb *c = NULL; - PGconn *cn = make_connection(host, user, pass, name); + const char *host = MF_GetAmxString(amx,params[1],0,&len); + const char *user = MF_GetAmxString(amx,params[2],1,&len); + const char *pass = MF_GetAmxString(amx,params[3],2,&len); + const char *name = MF_GetAmxString(amx,params[4],3,&len); - if (PQstatus(cn) != CONNECTION_OK) { - char *error = PQerrorMessage(cn); - SET_AMXSTRING(amx, params[5], (error?error:""), params[6]); + int id = sql_exists(host, user, pass, name); + + if (id >= 0) + return id; + + id = -1; + for (i=0; ifree) { + id = i; + break; + } + } + + if (id < 0) { + c = new pgdb; + dblist.push_back(c); + id = dblist.size() - 1; + } else { + c = dblist[id]; + } + + if (!c->Connect(host, user, pass, name)) { + MF_SetAmxString(amx, params[5], c->err.c_str(), params[6]); return 0; } - return 1; + return id+1; } + static cell AMX_NATIVE_CALL pgsql_error(AMX *amx, cell *params) { - int c = params[1]; - pgs *p = get_conn_i(c); - char *error = PQerrorMessage(p->v.cn); - SET_AMXSTRING(amx, params[2], (error==NULL?"":error), params[3]); - return 1; + unsigned int id = params[1] - 1; + + if (id >= dblist.size() || dblist[id]->free) { + error.assign("Invalid handle."); + MF_RaiseAmxError(amx, AMX_ERR_NATIVE); + return 0; + } + + dblist[id]->err.assign(PQerrorMessage(dblist[id]->cn)); + MF_SetAmxString(amx, params[2], dblist[id]->err.c_str(), params[3]); + return dblist[id]->lastError; } static cell AMX_NATIVE_CALL pgsql_query(AMX *amx, cell *params) { - pgs *p = get_conn_i(params[1]); - if (p == NULL) { + unsigned int id = params[1] - 1; + + if (id >= dblist.size() || dblist[id]->free) { + error.assign("Invalid handle."); + MF_RaiseAmxError(amx, AMX_ERR_NATIVE); return 0; } - if (p->v.res) { - p->reset(); - } + pgdb *c = dblist[id]; + + if (c->res) + c->reset(); int i; - const char *query = FORMAT_AMXSTRING(amx, params, 2, i); + const char *query = MF_FormatAmxString(amx, params, 2, &i); - p->v.res = PQexec(p->v.cn, query); + c->res = PQexec(c->cn, query); + c->row = 0; - if (PQresultStatus(p->v.res) != PGRES_COMMAND_OK) { + if (PQresultStatus(c->res) != PGRES_COMMAND_OK) { + c->lastError = PQresultStatus(c->res); return -1; } - return PQntuples(p->v.res); + return PQntuples(c->res); } static cell AMX_NATIVE_CALL pgsql_nextrow(AMX *amx, cell *params) { - pgs *p = get_conn_i(params[1]); + unsigned int id = params[1] - 1; - if (p == NULL) { + if (id >= dblist.size() || dblist[id]->free) { + error.assign("Invalid handle."); + MF_RaiseAmxError(amx, AMX_ERR_NATIVE); return 0; } - if (p->v.cn == NULL) { - return -1; - } - if (PQstatus(p->v.cn)!= CONNECTION_OK) { - return -1; - } + pgdb *c = dblist[id]; - if (p->v.row > PQntuples(p->v.res)) { + if (c->row > PQntuples(c->res)) return 0; - } - p->v.row++; + c->row++; return 1; } static cell AMX_NATIVE_CALL pgsql_getfield(AMX *amx, cell *params) { - pgs *p = get_conn_i(params[1]); - int col = params[2] + 1; - if (p == NULL) { + unsigned int id = params[1] - 1; + int col = params[2]; + + if (id >= dblist.size() || dblist[id]->free) { + error.assign("Invalid handle."); + MF_RaiseAmxError(amx, AMX_ERR_NATIVE); return 0; } - if (p->v.cn == NULL) { - return -1; - } - if (PQstatus(p->v.cn)!= CONNECTION_OK) { - return -1; - } + pgdb *c = dblist[id]; - if (col-1 > PQnfields(p->v.res)) { + if (col-1 > PQnfields(c->res)) return 0; - } - char *field = PQgetvalue(p->v.res, p->v.row, col); - return SET_AMXSTRING(amx, params[3], field?field:"", params[4]); + char *field = PQgetvalue(c->res, c->row, col); + return MF_SetAmxString(amx, params[3], field?field:"", params[4]); } static cell AMX_NATIVE_CALL pgsql_close(AMX *amx, cell *params) { - pgs *p = get_conn_i(params[1]); - - p->close(); + unsigned int id = params[1] - 1; + + if (id >= dblist.size() || dblist[id]->free) { + error.assign("Invalid handle."); + MF_RaiseAmxError(amx, AMX_ERR_NATIVE); + return 0; + } + + pgdb *c = dblist[id]; + + c->Kill(); return 1; } +void OnAmxxAttach() +{ + MF_AddNatives(pgsql_exports); +} + AMX_NATIVE_INFO pgsql_exports[] = { {"dbi_connect", pgsql_connect}, {"dbi_error", pgsql_error}, @@ -224,25 +262,12 @@ AMX_NATIVE_INFO pgsql_exports[] = { {"dbi_nextrow", pgsql_nextrow}, {"dbi_close", pgsql_close}, {"dbi_getfield", pgsql_getfield}, + {"pgsql_connect", pgsql_connect}, + {"pgsql_error", pgsql_error}, + {"pgsql_query", pgsql_query}, + {"pgsql_nextrow", pgsql_nextrow}, + {"pgsql_close", pgsql_close}, + {"pgsql_getfield", pgsql_getfield}, {NULL, NULL}, }; - -C_DLLEXPORT int AMX_Query(module_info_s** info) { - *info = &module_info; - return 1; -} - -C_DLLEXPORT int AMX_Attach(pfnamx_engine_g* amxeng,pfnmodule_engine_g* meng) { - g_engAmxFunc = amxeng; - g_engModuleFunc = meng; - - ADD_AMXNATIVES(&module_info, pgsql_exports); - - return(1); -} - -C_DLLEXPORT int AMX_Detach() { - delete cns; - return(1); -} diff --git a/dlls/pgsql/pgsql_amx.def b/dlls/pgsql/pgsql_amx.def deleted file mode 100755 index 283974b1..00000000 --- a/dlls/pgsql/pgsql_amx.def +++ /dev/null @@ -1,6 +0,0 @@ -LIBRARY fun_amx -EXPORTS - AMX_Attach @1 - AMX_Detach @3 -SECTIONS - .data READ WRITE diff --git a/dlls/pgsql/pgsql_amx.h b/dlls/pgsql/pgsql_amx.h index 7ea475cc..56ff7a43 100755 --- a/dlls/pgsql/pgsql_amx.h +++ b/dlls/pgsql/pgsql_amx.h @@ -31,109 +31,32 @@ #include #include #include -#include +#include +#include +#include "amxxmodule.h" -#define destroy(x) if(x){delete(x);x=0;} -#define destarr(x) if(x){delete[]x;x=0;} - -pfnamx_engine_g* g_engAmxFunc; -pfnmodule_engine_g* g_engModuleFunc; - -#define NAME "PgSQL" -#define AUTHOR "BAILOPAN" -#define VERSION "1.00" -#define URL "http://www.bailopan.com/" -#define LOGTAG "PGSQL" -#define DATE __DATE__ - -module_info_s module_info = { - NAME, - AUTHOR, - VERSION, - AMX_INTERFACE_VERSION, - RELOAD_MODULE, -}; - -class pgs +class pgdb { public: - pgs() - { - } - - pgs(const char *h, const char *u, const char *p, const char *n, int i=1) - { - set(h, u, p, n, i); - } - - void set(const char *h, const char *u, const char *p, const char *n, int i=1) - { - v.host = h; - v.user = u; - v.pass = p; - v.name = n; - v.cn = NULL; - v.row = 0; - next = NULL; - id = i; - free = false; - } - - pgs* link() - { - return next; - } - - int ii() - { - return id; - } - - void scn(PGconn *cn) - { - v.cn = cn; - } - - void sln(pgs *p) - { - next = p; - } - - void reset() - { - PQclear(v.res); - v.row = 0; - } - - void close() - { - PQfinish(v.cn); - destroy(v.host); - destroy(v.user); - destroy(v.pass); - destroy(v.name); - v.row = 0; - free = true; - } - - struct pgsql { - const char *host; - const char *user; - const char *pass; - const char *name; - PGconn *cn; - PGresult *res; - int row; - } v; - - ~pgs() - { - close(); - } + void reset() { PQclear(res); row = 0; } + pgdb() { free = true; } + int Connect(const char *hh, const char *uu, const char *pp, const char *dd); + void Kill(); + ~pgdb() { Kill(); } bool free; - -private: - pgs *next; - int id; + PGconn *cn; + PGresult *res; + int row; + std::string host; + std::string user; + std::string pass; + std::string name; + std::string cstr; + std::string err; + int lastError; }; + +extern std::string error; +extern std::vector dblist; +extern AMX_NATIVE_INFO pgsql_exports[]; diff --git a/dlls/pgsql/pgsql_amx.vcproj b/dlls/pgsql/pgsql_amx.vcproj index 0633c919..7bfc3933 100755 --- a/dlls/pgsql/pgsql_amx.vcproj +++ b/dlls/pgsql/pgsql_amx.vcproj @@ -39,11 +39,11 @@ Name="VCCustomBuildTool"/> @@ -103,10 +103,11 @@ Name="VCCustomBuildTool"/> - - + + + + + + + + - - diff --git a/dlls/pgsql/readme.txt b/dlls/pgsql/readme.txt deleted file mode 100755 index 7f846175..00000000 --- a/dlls/pgsql/readme.txt +++ /dev/null @@ -1,35 +0,0 @@ -PgSQL Module for AMX Mod X -by David "BAILOPAN" Anderson ----------------------------- - -Installation ------------- - -1] Place the pgsql.cfg file in your addons/amxx/configs dir. - - -2] Place the module in the right place: -Linux: - -Place geoip_amx_i386.so into addons/amxx/modules/ -(If you want a glibc2.3 optimized binary, use geoip_amx_i686.so) -Add this line to addons/amxx/modules.ini : -geoip_amx_i386.so - - -Windows: - -Place geoip_amx.dll into addons/ammx/modules/ -Add this line to addons/amxx/modules.ini : -geoip_amx.dll - - -3] Scripters: Place "pgsql.inc" in addons/amxx/scripting/include - -4] If you are using pgsql to store admins: -Place admin_pgsql.amx in addons/amxx/plugins/ -And add this line to addons/amxx/plugins.ini: -admin_pgsql.amx - -5] Put pgsql.cfg in addons/amxx/configs/ -Open it and make sure the host, user, password, and database name are correct \ No newline at end of file