AlliedModders Wiki - User contributions [en]

CCSGameRules Offset List (Counter-Strike: Source)

2008-09-21T01:06:21Z

Sawce: Undo revision 6230 by Matt29addai (Talk)

For use when using [[Virtual Offsets (Source Mods)|virtual offsets]].

This is the list of offsets I've been using. These are the Linux offsets. Windows offsets are 1 less.

== The List ==
This comes from the symbol tables, so you'll have to look in the SDK for return types...or guess for the CSS specific functions near the end.

Last Updated 28 April 2008

<pre>
// Auto reconstructed from vtable block @ 0x00B446E0
// from "server_i486.so", by ida_vtables.idc
0 CGameRules::Name(void)
1 CBaseGameSystemPerFrame::Init(void)
2 CBaseGameSystemPerFrame::Shutdown(void)
3 CCSGameRules::LevelInitPreEntity(void)
4 CCSGameRules::LevelInitPostEntity(void)
5 CBaseGameSystemPerFrame::LevelShutdownPreEntity(void)
6 CBaseGameSystemPerFrame::LevelShutdownPostEntity(void)
7 CBaseGameSystemPerFrame::OnSave(void)
8 CBaseGameSystemPerFrame::OnRestore(void)
9 CBaseGameSystemPerFrame::SafeRemoveIfDesired(void)
10 CBaseGameSystemPerFrame::IsPerFrame(void)
11 CCSGameRules::~CCSGameRules()
12 CCSGameRules::~CCSGameRules()
13 CBaseGameSystemPerFrame::FrameUpdatePrePlayerRunCommand(void)
14 CBaseGameSystemPerFrame::FrameUpdatePreEntityThink(void)
15 CGameRules::FrameUpdatePostEntityThink(void)
16 CBaseGameSystemPerFrame::PreClientUpdate(void)
17 CCSGameRules::_GetClassName(void)
18 CMultiplayRules::SwitchToNextBestWeapon(CBaseCombatCharacter *,CBaseCombatWeapon *)
19 CCSGameRules::GetNextBestWeapon(CBaseCombatCharacter *,CBaseCombatWeapon *)
20 CCSGameRules::ShouldCollide(int,int)
21 CCSGameRules::DefaultFOV(void)
22 CCSGameRules::GetViewVectors(void)const
23 CGameRules::GetAmmoDamage(CBaseEntity *,CBaseEntity *,int)
24 CGameRules::GetDamageMultiplier(void)
25 CMultiplayRules::IsMultiplayer(void)
26 CCSGameRules::GetEncryptionKey(void)
27 CCSGameRules::LevelShutdown(void)
28 CTeamplayRules::Precache(void)
29 CMultiplayRules::RefreshSkillData(bool)
30 CCSGameRules::Think(void)
31 CMultiplayRules::IsAllowedToSpawn(CBaseEntity *)
32 CCSGameRules::EndGameFrame(void)
33 CGameRules::IsSkillLevel(int)
34 CGameRules::GetSkillLevel(void)
35 CGameRules::OnSkillLevelChanged(int)
36 CGameRules::SetSkillLevel(int)
37 CMultiplayRules::FAllowFlashlight(void)
38 CCSGameRules::FShouldSwitchWeapon(CBasePlayer *,CBaseCombatWeapon *)
39 CMultiplayRules::IsDeathmatch(void)
40 CTeamplayRules::IsTeamplay(void)
41 CMultiplayRules::IsCoOp(void)
42 CCSGameRules::GetGameDescription(void)
43 CMultiplayRules::ClientConnected(edict_t *,char const*,char const*,char *,int)
44 CTeamplayRules::InitHUD(CBasePlayer *)
45 CCSGameRules::ClientDisconnected(edict_t *)
46 CCSGameRules::FlPlayerFallDamage(CBasePlayer *)
47 CTeamplayRules::FPlayerCanTakeDamage(CBasePlayer *,CBaseEntity *)
48 CTeamplayRules::ShouldAutoAim(CBasePlayer *,edict_t *)
49 CGameRules::GetAutoAimScale(CBasePlayer *)
50 CGameRules::ShouldUseRobustRadiusDamage(CBaseEntity *)
51 CCSGameRules::RadiusDamage(CTakeDamageInfo const&,Vector const&,float,int,CBaseEntity *)
52 CCSGameRules::FlPlayerFallDeathDoesScreenFade(CBasePlayer *)
53 CMultiplayRules::AllowDamage(CBaseEntity *,CTakeDamageInfo const&)
54 CCSGameRules::PlayerSpawn(CBasePlayer *)
55 CMultiplayRules::PlayerThink(CBasePlayer *)
56 CCSGameRules::FPlayerCanRespawn(CBasePlayer *)
57 CMultiplayRules::FlPlayerSpawnTime(CBasePlayer *)
58 CCSGameRules::GetPlayerSpawnSpot(CBasePlayer *)
59 CCSGameRules::IsSpawnPointValid(CBaseEntity *,CBasePlayer *)
60 CMultiplayRules::AllowAutoTargetCrosshair(void)
61 CCSGameRules::ClientCommand(char const*,CBaseEntity *)
62 CCSGameRules::ClientSettingsChanged(CBasePlayer *)
63 CTeamplayRules::IPointsForKill(CBasePlayer *,CBasePlayer *)
64 CCSGameRules::PlayerKilled(CBasePlayer *,CTakeDamageInfo const&)
65 CCSGameRules::DeathNotice(CBasePlayer *,CTakeDamageInfo const&)
66 CGameRules::GetCustomKillString(CTakeDamageInfo const&)
67 CGameRules::AdjustPlayerDamageInflicted(float)
68 CGameRules::AdjustPlayerDamageTaken(CTakeDamageInfo *)
69 CMultiplayRules::CanHavePlayerItem(CBasePlayer *,CBaseCombatWeapon *)
70 CMultiplayRules::WeaponShouldRespawn(CBaseCombatWeapon *)
71 CMultiplayRules::FlWeaponRespawnTime(CBaseCombatWeapon *)
72 CMultiplayRules::FlWeaponTryRespawn(CBaseCombatWeapon *)
73 CMultiplayRules::VecWeaponRespawnSpot(CBaseCombatWeapon *)
74 CMultiplayRules::CanHaveItem(CBasePlayer *,CItem *)
75 CMultiplayRules::PlayerGotItem(CBasePlayer *,CItem *)
76 CMultiplayRules::ItemShouldRespawn(CItem *)
77 CMultiplayRules::FlItemRespawnTime(CItem *)
78 CMultiplayRules::VecItemRespawnSpot(CItem *)
79 CMultiplayRules::VecItemRespawnAngles(CItem *)
80 CGameRules::CanHaveAmmo(CBaseCombatCharacter *,int)
81 CGameRules::CanHaveAmmo(CBaseCombatCharacter *,char const*)
82 CMultiplayRules::PlayerGotAmmo(CBaseCombatCharacter *,char *,int)
83 CGameRules::GetAmmoQuantityScale(int)
84 CCSGameRules::InitDefaultAIRelationships(void)
85 CCSGameRules::AIClassText(int)
86 CMultiplayRules::FlHealthChargerRechargeTime(void)
87 CMultiplayRules::FlHEVChargerRechargeTime(void)
88 CMultiplayRules::DeadPlayerWeapons(CBasePlayer *)
89 CMultiplayRules::DeadPlayerAmmo(CBasePlayer *)
90 CTeamplayRules::GetTeamID(CBaseEntity *)
91 CTeamplayRules::PlayerRelationship(CBaseEntity *,CBaseEntity *)
92 CTeamplayRules::PlayerCanHearChat(CBasePlayer *,CBasePlayer *)
93 CTeamplayRules::GetTeamIndex(char const*)
94 CTeamplayRules::GetIndexedTeamName(int)
95 CTeamplayRules::IsValidTeam(char const*)
96 CTeamplayRules::ChangePlayerTeam(CBasePlayer *,char const*,bool,bool)
97 CCSGameRules::SetDefaultPlayerTeam(CBasePlayer *)
98 CCSGameRules::UpdateClientData(CBasePlayer *)
99 CCSGameRules::PlayTextureSounds(void)
100 CMultiplayRules::PlayFootstepSounds(CBasePlayer *)
101 CCSGameRules::FAllowNPCs(void)
102 CMultiplayRules::EndMultiplayerGame(void)
103 CGameRules::WeaponTraceEntity(CBaseEntity *,Vector const&,Vector const&,unsigned int,CGameTrace *)
104 CCSGameRules::CreateStandardEntities(void)
105 CCSGameRules::GetChatPrefix(bool,CBasePlayer *)
106 CCSGameRules::GetChatLocation(bool,CBasePlayer *)
107 CCSGameRules::GetChatFormat(bool,CBasePlayer *)
108 CGameRules::ShouldBurningPropsEmitLight(void)
109 CGameRules::InRoundRestart(void)
110 CGameRules::CanEntityBeUsePushed(CBaseEntity *)
111 CCSGameRules::CreateCustomNetworkStringTables(void)
112 CMultiplayRules::GetNextLevelName(char *,int)
113 CMultiplayRules::ChangeLevel(void)
114 CCSGameRules::GoToIntermission(void)
115 CCSGameRules::SetAllowWeaponSwitch(bool)
116 CCSGameRules::GetAllowWeaponSwitch(void)
117 std::bad_cast::~bad_cast()

</pre>

Iroh Migration

2008-06-08T05:49:10Z

Sawce:

__FORCETOC__
sente to iroh migration plans

=TODO List=
<ol>
<li><strike>Shutdown all Sente servers except e-mail.</strike></li>
<li><strike>Move CVS/SVN to Iroh.</strike></li>
<li>Move any "root" stuff to Iroh (such as scripts).</li>
<li><strike>Open a port on Iroh so Sente can use its MySQL.</strike></li>
<li><strike>Move MySQL.</strike></li>
<li><strike>Start a MySQL proxy from Sente to Iroh.</strike></li>
<li>Move all owned and movable sites from Sente to Iroh.</li>
<li>Change IP addresses on owned domains.</li>
<li>Bring Iroh web services <strike>and MySQL</strike> online.</li>
<li>Move all cronjobs for moved sites.</li>
<li>Create web proxies from Sente to Iroh for all moved sites.</li>
<li>Bring remaining Sente web services back online.</li>
<li>Repeat processes as hostees can be contacted for IP changes.</li>
<li>Create new e-mail services on iroh, verify that they work.</li>
<li>Move e-mail boxes from Sente to Iroh.</li>
<li>Change e-mail IP address.</li>
</ol>

=Movable Owned Sites=
*ampaste.net
*<strike>metamodsource.net</strike>
*<strike>cvs.alliedmods.net</strike>
*<strike>svn.alliedmods.net</strike>
*<strike>users.svn.alliedmods.net</strike>
*<strike>amxmodx.org</strike>
*tcwonline.org
*<strike>forums.alliedmods.net</strike>
*www.alliedmods.net
*<strike>bugs.alliedmods.net</strike>
*docs.sourcemod.net
*<strike>www.sourcemod.net</strike>
**bring symbol archive back up
*<strike>wiki.alliedmods.net</strike>

=Movable Hosted Sites=
*<strike>urahara.amxmodx.org</strike> (HAG)
*jaguar.alliedmods.net
*shero.alliedmods.net
*uaio.amxmodx.org
*jghg.amxmodx.org
*electricmole.alliedmods.net
*<strike>bailopan.net</strike>
*<strike>dav.bailopan.net</strike> (REMOVED)
*whitewolf.sourcemod.net

=Odds and Ends=
*Turn DS's alliedmods e-mail address into a real account instead of an alias

AMX Mod X 1.8.0 Changes

2007-08-08T02:35:32Z

Sawce: /* Plugin Changes */

AMX Mod X 1.8 is a large feature release with many changes, both to the development API and user-mode features.

=Changelog=
==Overall Changes==
*Added a new module, Ham Sandwich, for hooking virtual CBaseEntity functions in mods.
*Command flags are now initially dumped to disk and can be edited via <tt>configs/cmdaccess.ini</tt>.
*Added {{AMBug|48738}}: Romanian translation from X-5173.
*Added {{AMBug|50741}} and {{AMBug|43830}}: per-map plugins files can now be prefixed based.
*Added {{amb|17}}: New menu rendering is now more consistent; non-consistent controls are deprecated.
*Added {{amb|32}}: The server console commands "amxx cvars" and "amxx cmds" can now filter by plugin.
*Added {{amb|122}}: Log file names now include a four-digit year.
*Fixed {{amb|18}}: New menus are now properly destroyed if overridden.
*Fixed {{amb|46}}: <tt>is_user_bot</tt> had some false positives.
*Fixed {{amb|69}}: Fixed Metamod trying to reload AMX Mod X against a poorly configured clock.
*Fixed {{amb|207}}: New menus now display "0" instead of "10."
*Fixed {{amb|208}}: New menus did not reset callback results after each call.
*Fixed {{amb|200}}: Dynamic/fake natives were not re-entrant.
*Fixed {{amb|244}}: Run-time errors blocked forwards.
*Fixed {{amb|305}}: Core crashed on mods that removed the standard <tt>mp_timelimit</tt> cvar.
*Fixed many various internal new menu rendering and item selection bugs.
==Scripting Changes==
*Added natives for dynamic global arrays.
*Added a new, magic <tt>any</tt> tag from [[SourceMod]].
*Added a <tt>charsmax</tt> operator for safe sizeof(string)-1 usage.
*Added <tt>set_pcvar_string</tt>().
*Added <tt>LookupLangKey</tt>().
*Added <tt>SQL_QuoteString</tt>().
*Added <tt>[g|s]et_pdata_cbase[_safe]</tt>() to the Ham Sandwich module.
*Added <tt>geoip_code[2|3]_ex</tt>(), which address a serious issue in the now deprecated <tt>geoip_code[2|3]</tt>().
*Added <tt>lookup_sequence</tt>(), <tt>set_controller</tt>(), <tt>set_pev_string</tt>(), and <tt>pev_serial</tt>() to Fakemeta.
*Added <tt>ns_get_user_team</tt>.
*Added a menu property to change the numbering color.
*Added {{amb|27}}: <tt>SQL_Rewind</tt>().
*Added {{amb|37}}: <tt>cs_[g|s]et_user_submodel</tt>().
*Added {{amb|38}}: <tt>cs_[g|s]et_user_lastactivity</tt>().
*Added {{amb|39}}: <tt>cs_[g|s]et_hostage_lastuse</tt>() and <tt>cs_[g|s]et_hostage_nextuser</tt>().
*Added {{amb|63}}: <tt>floatmin</tt>(), <tt>floatmax</tt>(), and <tt>floatclamp()</tt>.
*Added {{amb|76}}: Formatting functions can now use %x or %X for hexadecimal numbers.
*Added {{amb|92}}: <tt>create_tr2</tt>() and <tt>free_tr2</tt>().
*Added {{amb|205}}: <tt>cs_[g|s]et_c4_explode_time</tt>().
*Added {{amb|216}}: <tt>SQL_MakeStdTuple</tt>() now has a timeout parameter.
*Added {{amb|237}}: Fakemeta can now call "ServerPrint."
*Added {{amb|242}}: <tt>cs_[g|s]et_user_hostagekills</tt>().
*Added {{amb|245}}: <tt>precache_sound</tt> now returns a precache index.
*Added {{amb|261}}: <tt>has_flag</tt>() and <tt>has_all_flags</tt>().
*Added {{amb|291}}: <tt>cs_[g|s]et_c4_defusing</tt>().
*Added {{amb|673}}: <tt>regex_compile</tt>() and <tt>regex_match_c</tt> for pre-compiling expressions.
*Added {{AMBug|46213}}: <tt>player_menu_info</tt>() now returns a page number.
*Added {{AMBug|51064}}: Some parameters to <tt>get_plugin</tt> are now optional.
*Added {{AMBug|50610}}: Some parameters to <tt>get_user_weapon</tt> are now optional.
*Added {{AMBug|48841}}: <tt>tfc_is_user_feigning</tt>().
*Added {{AMBug|45664}}: <tt>tfc_is_team_ally</tt>().
*Fixed {{AMBug|49337}}: <tt>get_pcvar_float</tt>() malfunctioned on high numbers.
*Fixed {{amb|78}}: <tt>get_concmdsnum</tt> could return an incorrect result.
*Fixed {{amb|85}}: Tag mismatches on <tt>ShowSyncHudMsg</tt>().
*Fixed {{amb|90}}: <tt>set_native_filter</tt>() did not work in rare cases.
*Fixed {{amb|107}}: <tt>socket_open</tt>() didn't return an error by reference.
*Fixed {{amb|110}}: <tt>socket_change</tt>() could return 1 on certain failures.
*Fixed {{amb|116}}: <tt>DispatchKeyValue</tt>() did not work on worldspawn (entity 0).
*Fixed {{amb|149}}: <tt>register_event</tt> with the "e" flag could catch incorrect players.
*Fixed {{amb|230}}: <tt>radius_damage</tt>() didn't kill players on all mods.
*Fixed {{amb|257}}: <tt>get_user_origin</tt>() mode 4 had false positives.
*Fixed {{amb|343}}: <tt>TFC_ClearModel</tt>() did not function as documented.
*Fixed {{amb|421}}: <tt>get_user_weapons</tt>() could omit a weapon on Day of Defeat.
*Fixed {{amb|437}}: <tt>dod_set_user_kills</tt>() and <tt>dod_set_user_score</tt>() could mess up the scoreboard.
*Fixed {{amb|519}}: <tt>geoip_code[2|3]</tt>() buffer overflowed on error.
*Fixed {{amb|736}}: <tt>find_entity</tt>() was defined twice.
*Fixed a memory leak in <tt>SortCustom1D</tt>().
*Fixed a crash bug in <tt>fwrite_blocks</tt>().

==Plugin Changes==
*There is no longer a hardcoded limit to the number of admins.
*There is no longer a hardcoded limit to the map list.
*There is no longer a hardcoded limit to the number of "imessages."
*Added {{amb|34}}: There are now plugin command/cvar menus.
*Added {{AMBug|45044}}: amx_banmenu now prints the ban time length.
*Added {{AMBug|43757}}: amx_addadmin now writes a comment with the player's name.
*Added {{AMBug|29353}}: amx_plugins now prints paginated output.
*Added {{AMBug|50742}}: admin.sma now supports prefix based per-map configs.
*Added {{amb|28}}: statscfg.sma can now use translations.
*Added {{amb|30}}: <tt>csstats_rankbots</tt> prevents bots from showing on <tt>/top15</tt>.
*Added {{amb|31}}: plmenu.sma ban and slap options are now configurable.
*Added {{amb|42}}: Added new values for <tt>amx_show_activity</tt>.
*Added {{amb|51}}: amx_vote can now take more than two options.
*Added {{amb|64}}: amx_voteban autodetects whether it should IP ban.
*Added {{amb|307}}: amx_addban now caches the last ten connections.
*Added {{amb|311}}: mapcycle file now ignores .bsp extensions.
*Added {{amb|340}}: amx_ban/amx_banip now display a reason in the activity.
*Added {{amb|427}}: Additional weapons to <tt>dod_[g|s]et_user_ammo</tt>().
*Fixed {{amb|29}}: pausecfg.sma did not translate two phrases.
*Fixed {{amb|91}}: miscstats.sma truncated some language translations.
*Fixed {{amb|94}}: amx_psay sometimes sent truncated messages.
*Fixed {{amb|109}}: mapsmenu.sma now checks <tt>mapcyclefile</tt> before reverting to <tt>mapcycle.txt</tt>.
*Fixed {{amb|118}}: amx_help would not list <tt>ADMIN_ADMIN</tt> commands.
*Fixed {{amb|130}}: Various menus did not take <tt>ADMIN_ALL</tt> or <tt>ADMIN_ADMIN</tt> into account.
*Fixed {{amb|183}}: plmenu.sma did not work on Natural Selection.
*Fixed {{amb|196}}: amx_modules did not handle invalid modules properly.
*Fixed {{amb|222}}: cl_rebuy could exploit CS weapon restrictions. This also makes CZ bots obey restrictions.
*Fixed {{amb|228}}: amxmod_compat could cause <tt>set_user_hitzones</tt>() to break.
*Fixed {{amb|350}}: <tt>traceline_set_float</tt> from the AMX Mod Compat layer was broken.
*Fixed {{amb|467}}: <tt>conmotd.txt</tt> is now removed.
*Fixed {{amb|633}}: Immune admins can now target themselves.
*Fixed a potential exploit in adminslots.sma.
*SQL cvars are now protected.
*Added {{amb|743}}: plmenu for cstrike has an option to move to spectator.

==Module Changes==
*Fixed {{amb|108}}: IP-based stats no longer include a port when saving.
*Fixed {{amb|503}}: CSX did not set a META_RESULT when paused.

AMX Mod X 1.8.0 Changes

2007-08-06T23:15:46Z

Sawce: /* Scripting Changes */

AMX Mod X 1.8 is a large feature release with many changes, both to the development API and user-mode features.

=Changelog=
==Overall Changes==
*Added a new module, Ham Sandwich, for hooking virtual CBaseEntity functions in mods.
*Command flags are now initially dumped to disk and can be edited via <tt>configs/cmdaccess.ini</tt>.
*Added {{AMBug|48738}}: Romanian translation from X-5173.
*Added {{AMBug|50741}} and {{AMBug|43830}}: per-map plugins files can now be prefixed based.
*Added {{amb|17}}: New menu rendering is now more consistent; non-consistent controls are deprecated.
*Added {{amb|32}}: The server console commands "amxx cvars" and "amxx cmds" can now filter by plugin.
*Added {{amb|122}}: Log file names now include a four-digit year.
*Fixed {{amb|18}}: New menus are now properly destroyed if overridden.
*Fixed {{amb|46}}: <tt>is_user_bot</tt> had some false positives.
*Fixed {{amb|69}}: Fixed Metamod trying to reload AMX Mod X against a poorly configured clock.
*Fixed {{amb|207}}: New menus now display "0" instead of "10."
*Fixed {{amb|208}}: New menus did not reset callback results after each call.
*Fixed {{amb|200}}: Dynamic/fake natives were not re-entrant.
*Fixed {{amb|244}}: Run-time errors blocked forwards.
*Fixed {{amb|305}}: Core crashed on mods that removed the standard <tt>mp_timelimit</tt> cvar.
*Fixed many various internal new menu rendering and item selection bugs.
==Scripting Changes==
*Added natives for dynamic global arrays.
*Added a new, magic <tt>any</tt> tag from [[SourceMod]].
*Added a <tt>charsmax</tt> operator for safe sizeof(string)-1 usage.
*Added <tt>set_pcvar_string</tt>().
*Added <tt>LookupLangKey</tt>().
*Added <tt>SQL_QuoteString</tt>().
*Added <tt>[g|s]et_pdata_cbase[_safe]</tt>() to the Ham Sandwich module.
*Added <tt>geoip_code[2|3]_ex</tt>(), which address a serious issue in the now deprecated <tt>geoip_code[2|3]</tt>().
*Added <tt>lookup_sequence</tt>(), <tt>set_controller</tt>(), <tt>set_pev_string</tt>(), and <tt>pev_serial</tt>() to Fakemeta.
*Added <tt>ns_get_user_team</tt>.
*Added a menu property to change the numbering color.
*Added {{amb|27}}: <tt>SQL_Rewind</tt>().
*Added {{amb|37}}: <tt>cs_[g|s]et_user_submodel</tt>().
*Added {{amb|38}}: <tt>cs_[g|s]et_user_lastactivity</tt>().
*Added {{amb|39}}: <tt>cs_[g|s]et_hostage_lastuse</tt>() and <tt>cs_[g|s]et_hostage_nextuser</tt>().
*Added {{amb|63}}: <tt>floatmin</tt>(), <tt>floatmax</tt>(), and <tt>floatclamp()</tt>.
*Added {{amb|76}}: Formatting functions can now use %x or %X for hexadecimal numbers.
*Added {{amb|92}}: <tt>create_tr2</tt>() and <tt>free_tr2</tt>().
*Added {{amb|205}}: <tt>cs_[g|s]et_c4_explode_time</tt>().
*Added {{amb|216}}: <tt>SQL_MakeStdTuple</tt>() now has a timeout parameter.
*Added {{amb|237}}: Fakemeta can now call "ServerPrint."
*Added {{amb|242}}: <tt>cs_[g|s]et_user_hostagekills</tt>().
*Added {{amb|245}}: <tt>precache_sound</tt> now returns a precache index.
*Added {{amb|261}}: <tt>has_flag</tt>() and <tt>has_all_flags</tt>().
*Added {{amb|291}}: <tt>cs_[g|s]et_c4_defusing</tt>().
*Added {{amb|673}}: <tt>regex_compile</tt>() and <tt>regex_match_c</tt> for pre-compiling expressions.
*Added {{AMBug|46213}}: <tt>player_menu_info</tt>() now returns a page number.
*Added {{AMBug|51064}}: Some parameters to <tt>get_plugin</tt> are now optional.
*Added {{AMBug|50610}}: Some parameters to <tt>get_user_weapon</tt> are now optional.
*Added {{AMBug|48841}}: <tt>tfc_is_user_feigning</tt>().
*Added {{AMBug|45664}}: <tt>tfc_is_team_ally</tt>().
*Fixed {{AMBug|49337}}: <tt>get_pcvar_float</tt>() malfunctioned on high numbers.
*Fixed {{amb|78}}: <tt>get_concmdsnum</tt> could return an incorrect result.
*Fixed {{amb|85}}: Tag mismatches on <tt>ShowSyncHudMsg</tt>().
*Fixed {{amb|90}}: <tt>set_native_filter</tt>() did not work in rare cases.
*Fixed {{amb|107}}: <tt>socket_open</tt>() didn't return an error by reference.
*Fixed {{amb|110}}: <tt>socket_change</tt>() could return 1 on certain failures.
*Fixed {{amb|116}}: <tt>DispatchKeyValue</tt>() did not work on worldspawn (entity 0).
*Fixed {{amb|149}}: <tt>register_event</tt> with the "e" flag could catch incorrect players.
*Fixed {{amb|230}}: <tt>radius_damage</tt>() didn't kill players on all mods.
*Fixed {{amb|257}}: <tt>get_user_origin</tt>() mode 4 had false positives.
*Fixed {{amb|343}}: <tt>TFC_ClearModel</tt>() did not function as documented.
*Fixed {{amb|421}}: <tt>get_user_weapons</tt>() could omit a weapon on Day of Defeat.
*Fixed {{amb|437}}: <tt>dod_set_user_kills</tt>() and <tt>dod_set_user_score</tt>() could mess up the scoreboard.
*Fixed {{amb|519}}: <tt>geoip_code[2|3]</tt>() buffer overflowed on error.
*Fixed {{amb|736}}: <tt>find_entity</tt>() was defined twice.
*Fixed a memory leak in <tt>SortCustom1D</tt>().
*Fixed a crash bug in <tt>fwrite_blocks</tt>().

==Plugin Changes==
*There is no longer a hardcoded limit to the number of admins.
*There is no longer a hardcoded limit to the map list.
*There is no longer a hardcoded limit to the number of "imessages."
*Added {{amb|34}}: There are now plugin command/cvar menus.
*Added {{AMBug|45044}}: amx_banmenu now prints the ban time length.
*Added {{AMBug|43757}}: amx_addadmin now writes a comment with the player's name.
*Added {{AMBug|29353}}: amx_plugins now prints paginated output.
*Added {{AMBug|50742}}: admin.sma now supports prefix based per-map configs.
*Added {{amb|28}}: statscfg.sma can now use translations.
*Added {{amb|30}}: <tt>csstats_rankbots</tt> prevents bots from showing on <tt>/top15</tt>.
*Added {{amb|31}}: plmenu.sma ban and slap options are now configurable.
*Added {{amb|42}}: Added new values for <tt>amx_show_activity</tt>.
*Added {{amb|51}}: amx_vote can now take more than two options.
*Added {{amb|64}}: amx_voteban autodetects whether it should IP ban.
*Added {{amb|307}}: amx_addban now caches the last ten connections.
*Added {{amb|311}}: mapcycle file now ignores .bsp extensions.
*Added {{amb|340}}: amx_ban/amx_banip now display a reason in the activity.
*Added {{amb|427}}: Additional weapons to <tt>dod_[g|s]et_user_ammo</tt>().
*Fixed {{amb|29}}: pausecfg.sma did not translate two phrases.
*Fixed {{amb|91}}: miscstats.sma truncated some language translations.
*Fixed {{amb|94}}: amx_psay sometimes sent truncated messages.
*Fixed {{amb|109}}: mapsmenu.sma now checks <tt>mapcyclefile</tt> before reverting to <tt>mapcycle.txt</tt>.
*Fixed {{amb|118}}: amx_help would not list <tt>ADMIN_ADMIN</tt> commands.
*Fixed {{amb|130}}: Various menus did not take <tt>ADMIN_ALL</tt> or <tt>ADMIN_ADMIN</tt> into account.
*Fixed {{amb|183}}: plmenu.sma did not work on Natural Selection.
*Fixed {{amb|196}}: amx_modules did not handle invalid modules properly.
*Fixed {{amb|222}}: cl_rebuy could exploit CS weapon restrictions. This also makes CZ bots obey restrictions.
*Fixed {{amb|228}}: amxmod_compat could cause <tt>set_user_hitzones</tt>() to break.
*Fixed {{amb|350}}: <tt>traceline_set_float</tt> from the AMX Mod Compat layer was broken.
*Fixed {{amb|467}}: <tt>conmotd.txt</tt> is now removed.
*Fixed {{amb|633}}: Immune admins can now target themselves.
*Fixed a potential exploit in adminslots.sma.
*SQL cvars are now protected.
==Module Changes==
*Fixed {{amb|108}}: IP-based stats no longer include a port when saving.
*Fixed {{amb|503}}: CSX did not set a META_RESULT when paused.

Admin Commands (SourceMod)

2007-06-08T15:00:10Z

Sawce: Format fixes

This page lists all of the major admin commands in SourceMod.

'''Chat Triggers''': Remember that commands do not have to be entered through the console; they can be entered via chat triggers. For example, saying "!ban bail" in chat will execute the same command as "sm_ban" and forward the output to chat. You can also use "/" instead of "!" to suppress your command from being shown to users.

'''Targetting Players''': There are a number of ways to target players:
<ul>
<li>name - The player will be targeted by a partial name match (multiple matches will report back an error).</li>
<li>#userid - If userid is numeric, the player will be targeted by their userid (found via the "users" command).</li>
<li>#name - If name is non-numeric, the player will be targeted by an exact name match.</li>
</ul>

=Basic Commands=
These commands are found in the "basecommands" plugin.

:{|
|- class="t2th"
| Command
| Format
| Access
| Description
|- class="t2td"
| sm_kick
| <#userid|name> [reason]
| kick
| Kicks a player.
|- class="t2td"
| sm_map
| <map>
| map
| Changes the current map.
|- class="t2td"
| sm_rcon
| <argstring>
| rcon
| Executes the argument string via rcon.
|- class="t2td"
| sm_cvar
| <cvar> [value]
| cvar
| Retrieves or changes a cvar value. Protected cvars can only be accessed with rcon access, and sv_cheats can only be accessed with cheat access.
|- class="t2td"
| sm_execcfg
| <filename>
| config
| Executes a config file (path not needed, but extension is).
|- class="t2td"
| sm_who
| <nowiki>[#userid|name]</nowiki>
| admin
| Lists all users and their access rights, or a specific user's access rights.
|- class="t2td"
| sm_ban
| <nowiki><#userid|name> <minutes|0> </nowiki>[reason]
| ban
| Bans a client.
|- class="t2td"
| sm_unban
| <steamid>
| unban
| Unbans a Steam ID.
|- class="t2td"
| sm_addban
| <time> <steamid> [reason]
| rcon
| Adds a Steam ID to Source's ban list.
|- class="t2td"
| sm_banip
| <time> <ip> [reason]
| rcon
| Adds an IP address to Source's ban list.
|}

[[Category:SourceMod Documentation]]

HamSandwich General Usage (AMX Mod X)

2007-05-11T03:39:55Z

Sawce: /* Changing Hook Parameters */

== About Ham Sandwich ==
Ham Sandwich is a module that provides additional hooking and function calling capabilities to [[AMX Mod X]]. It is scheduled to be included with the 1.8 branch of AMX Mod X.

Instead of hooking and executing Half-Life engine calls, like the modules FakeMeta and Engine do, this hooks and executes virtual function calls.

=== What is a virtual function? ===
A virtual function is a member function of a class in C++. In the case of Ham Sandwich, the virtual function would be a member function of a game entity. The virtual functions deal with various events in game, such as damage, and using entities.

Unlike normal member functions, virtual functions can be changed by class derivatives. For example, a typical hierarchy of entities in Half-Life game dlls look something like this:

CBaseEntity
CBaseAnimating
CBaseMonster
CZombie
CHeadCrab
CBarnacle
CBasePlayer
CBot

Now for example, if CBaseEntity has the virtual function called "FunctionA", and that function does nothing. But, CBarnacle also declares the function "FunctionA", and instead of doing nothing it causes the barnacle to die.

If something like this were to be executed:
CBaseEntity *ent=GET_PRIVATE(entity);
ent->FunctionA();

And the entity were a barnacle, the barnacle would die. If the entity was a zombie, nothing would happen.

=== What are some limitations? ===

Dealing with virtual functions have a couple minor drawbacks.
==== Custom Entities ====
Hooking virtual functions, such as TakeDamage, that get called on custom entities is a little bit awkward.

Because of the way where classes derive, and they get their own virtual table for each class, the type of class that the game dll allocates will be whatever gets hooked for a particular hook.

For example, say you have a plugin like this:

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

new myStr;
public plugin_init()
{
myStr = engfunc( EngFunc_AllocString, "info_target" );

register_clcmd( "make_entity", "cmdMakeEntity" );

RegisterHam(Ham_TakeDamage, "damageHook", "MyEntityClass"); // Error!
}
public cmdMakeEntity( id )
{
new ent = engfunc( EngFunc_CreateEntity, myStr );
set_pev( ent, pev_classname, "MyEntityClass" );
// ...
}

That will not work, because the class "MyEntityClass" is not native to the gamedll. Instead, you would need to hook TakeDamage for "info_target", and do some form of parsing on the entities that get passed to it (such as checking classname), if you want to deal with custom entity hooking.

==== End of Chain Derivatives ====
The normal way virtual functions get called is by a virtual table that resides somewhere in the class. A magical index is assigned to each function, and then it looks up the function pointer inside of the virtual table, and executes the required function.

However, compilers are smart enough to optimize away the virtual function lookup if it knows two things about a call:
* The exact class type of the entity.
* That the entity is not derived any further.

An example would be using the hierarchy shown earlier. If, inside of CBot::TakeDamage a call to the virtual function CBot::Killed is made, most compilers will optimize the virtual function lookup out, so that CBot::TakeDamage would then directly call CBot::Killed. This means that the hook would never be called.

Fortunately, these instances are kind of rare.

==== Config File Requirements ====
Every hook and every ExecuteHam() call requires an entry for the function which the scripter is attempting to hook or execute. The function needs to be in the amxmodx/configs/hamdata.ini config file, under the game mod and operating system.

If a function that the script attempts to hook or call is not configured in the hamdata.ini file, then the module will cause the plugin to cease operation, as this is a fatal error.

The fatal errors can be filtered out by including a forward in the script called '''HamFilter'''. This is similar to native/module filters available inside of the core of amxmodx, whenever a fatal error occurs, it will pass along the parameters to HamFilter, and if HamFilter returns '''PLUGIN_HANDLED''', the error will be ignored (but the attempted hook or execution will not take place). If the forward does not exist, or if it returns something other than PLUGIN_HANDLED, the plugin will fail.

An example layout for HamFilter:
public HamFilter(Ham:which, HamError:err, const reason[])
{
// Ignore an unconfigured ns_awardkill
if (which == Ham_NS_AwardKill && err == HAM_FUNC_NOT_CONFIGURED)(
{
return PLUGIN_HANDLED;
}
// We absolutely need to be able to use cs_roundrespawn!
// If we can't, then the plugin cannot continue.
if (which == Ham_CS_RoundRespawn)
{
return 0;
}
}

Additionally, you can check to see if a function is valid to execute or hook by using the '''IsHamValid()''' native. The validity of a function is determined when the module is first loaded, and it will never change, so if you want to check it, there is no need to do so before every execute.

== Supported Mods ==
=== Mostly Supported ===
These mods have a very large list of functions that are usable in the module.
* Counter-Strike 1.6
* Condition Zero
* Day of Defeat
* Team Fortress Classic
* The Specialists
* Natural-Selection

=== Weakly Supported ===
Because these mods do not contain a Linux binary, they are much harder to disassemble. There is only plans for disassembling two functions for each (TakeDamage and Use).
* Sven-Coop
* Earth's Special Forces

== Hooking Functions ==
The big feature for Ham Sandwich is the ability to hook virtual functions.

=== Creating the Hook ===
Creating a hook is a lot like creating a hook in Fakemeta.

#include <amxmodx>
#include <hamsandwich>

public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}

public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
// Stuff...
}

This creates a basic hook which is called any time a player takes damage. Look in '''ham_const.inc''' for forward parameters for each hook.

Like FakeMeta, there is a hidden last parameter (it goes after the classname in this case). Set it to 1 to do post hooking.

=== Blocking the Hook ===
Like Fakemeta and Engine, it is possible to stop a function from being called. This is called '''superceding'''.

Blocking in Ham Sandwich is identical to how it is accomplished in Fakemeta. In each hook, you return one of four special values:

* HAM_IGNORED - Nothing happened, the call continues.
* HAM_HANDLED - You did something, but the call continues.
* HAM_OVERRIDE - The call will still be executed, but instead you will change the return value.
* HAM_SUPERCEDE - The call is not executed, and you use your return value, if applicable.

You can use the native '''GetHamReturnStatus()''' to check the current return status of the hook.

=== Return Values ===
You can get or change the return values for all the hooks available in Ham Sandwich. Look in '''ham_const.inc''' for a list of all hooks and their return values.

These natives will get any ''modified'' return values.
* native GetHamReturnInteger(&output);
* native GetHamReturnFloat(&Float:output);
* native GetHamReturnVector(Float:output[3]);
* native GetHamReturnEntity(&output);
* native GetHamReturnString(output[], size);

These natives will get the ''original'' return value from the function.
Note that this is '''only''' valid to call in a post hook, it will be undefined to call it at any other time.
* native GetOrigHamReturnInteger(&output);
* native GetOrigHamReturnFloat(&Float:output);
* native GetOrigHamReturnVector(Float:output[3]);
* native GetOrigHamReturnCbase(&output);
* native GetOrigHamReturnString(output[], size);

These natives will change the return value to whatever you please.
Note that this will have no effect on the actual return value from the function '''unless''' the return status of the hook is HAM_OVERRIDE or HAM_SUPERCEDE.
* native SetHamReturnInteger(value);
* native SetHamReturnFloat(Float:value);
* native SetHamReturnVector(const Float:value[3]);
* native SetHamReturnEntity(value);
* native SetHamReturnString(const value[]);

=== Changing Hook Parameters ===
One feature available in Ham Sandwich that is not available in FakeMeta is the ability to change all parameters on the fly for each hook.

This means that, for example, if you wanted to make a plugin that halved all damage players take, you would do something like this:
#include <amxmodx>
#include <hamsandwich>
public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}
public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
SetHamParamFloat(4, damage / 2.0);
return HAM_HANDLED;
}

All hooks after the one you change them in will see the modified values. Hooks are executed in the order in which they are registered.

All available parameter changing natives are:

* native SetHamParamInteger(which, value);
* native SetHamParamFloat(which, Float:value);
* native SetHamParamVector(which, const Float:value[3]);
* native SetHamParamEntity(which, value);
* native SetHamParamString(which, const output[]);
* native SetHamParamTraceResult(which, tr_handle);

=== Disabling Hooks ===

Similar to how FakeMeta allows for unregistering of hooks with unregister_forward, HamSandwich will allow you to disable and enable hooks whenever you want.

The '''RegisterHam''' function will return a handle (tagged with HamHook). You can then make subsequent calls to DisableHamHook() and EnableHamHook() with the handle to stop it from forwarding, or enable its forwards again.

There is no way to completely unregister the hooks (until map change), as deleting a hook is a delicate process.

HamSandwich General Usage (AMX Mod X)

2007-05-11T03:39:13Z

Sawce: /* Return Values */

== About Ham Sandwich ==
Ham Sandwich is a module that provides additional hooking and function calling capabilities to [[AMX Mod X]]. It is scheduled to be included with the 1.8 branch of AMX Mod X.

Instead of hooking and executing Half-Life engine calls, like the modules FakeMeta and Engine do, this hooks and executes virtual function calls.

=== What is a virtual function? ===
A virtual function is a member function of a class in C++. In the case of Ham Sandwich, the virtual function would be a member function of a game entity. The virtual functions deal with various events in game, such as damage, and using entities.

Unlike normal member functions, virtual functions can be changed by class derivatives. For example, a typical hierarchy of entities in Half-Life game dlls look something like this:

CBaseEntity
CBaseAnimating
CBaseMonster
CZombie
CHeadCrab
CBarnacle
CBasePlayer
CBot

Now for example, if CBaseEntity has the virtual function called "FunctionA", and that function does nothing. But, CBarnacle also declares the function "FunctionA", and instead of doing nothing it causes the barnacle to die.

If something like this were to be executed:
CBaseEntity *ent=GET_PRIVATE(entity);
ent->FunctionA();

And the entity were a barnacle, the barnacle would die. If the entity was a zombie, nothing would happen.

=== What are some limitations? ===

Dealing with virtual functions have a couple minor drawbacks.
==== Custom Entities ====
Hooking virtual functions, such as TakeDamage, that get called on custom entities is a little bit awkward.

Because of the way where classes derive, and they get their own virtual table for each class, the type of class that the game dll allocates will be whatever gets hooked for a particular hook.

For example, say you have a plugin like this:

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

new myStr;
public plugin_init()
{
myStr = engfunc( EngFunc_AllocString, "info_target" );

register_clcmd( "make_entity", "cmdMakeEntity" );

RegisterHam(Ham_TakeDamage, "damageHook", "MyEntityClass"); // Error!
}
public cmdMakeEntity( id )
{
new ent = engfunc( EngFunc_CreateEntity, myStr );
set_pev( ent, pev_classname, "MyEntityClass" );
// ...
}

That will not work, because the class "MyEntityClass" is not native to the gamedll. Instead, you would need to hook TakeDamage for "info_target", and do some form of parsing on the entities that get passed to it (such as checking classname), if you want to deal with custom entity hooking.

==== End of Chain Derivatives ====
The normal way virtual functions get called is by a virtual table that resides somewhere in the class. A magical index is assigned to each function, and then it looks up the function pointer inside of the virtual table, and executes the required function.

However, compilers are smart enough to optimize away the virtual function lookup if it knows two things about a call:
* The exact class type of the entity.
* That the entity is not derived any further.

An example would be using the hierarchy shown earlier. If, inside of CBot::TakeDamage a call to the virtual function CBot::Killed is made, most compilers will optimize the virtual function lookup out, so that CBot::TakeDamage would then directly call CBot::Killed. This means that the hook would never be called.

Fortunately, these instances are kind of rare.

==== Config File Requirements ====
Every hook and every ExecuteHam() call requires an entry for the function which the scripter is attempting to hook or execute. The function needs to be in the amxmodx/configs/hamdata.ini config file, under the game mod and operating system.

If a function that the script attempts to hook or call is not configured in the hamdata.ini file, then the module will cause the plugin to cease operation, as this is a fatal error.

The fatal errors can be filtered out by including a forward in the script called '''HamFilter'''. This is similar to native/module filters available inside of the core of amxmodx, whenever a fatal error occurs, it will pass along the parameters to HamFilter, and if HamFilter returns '''PLUGIN_HANDLED''', the error will be ignored (but the attempted hook or execution will not take place). If the forward does not exist, or if it returns something other than PLUGIN_HANDLED, the plugin will fail.

An example layout for HamFilter:
public HamFilter(Ham:which, HamError:err, const reason[])
{
// Ignore an unconfigured ns_awardkill
if (which == Ham_NS_AwardKill && err == HAM_FUNC_NOT_CONFIGURED)(
{
return PLUGIN_HANDLED;
}
// We absolutely need to be able to use cs_roundrespawn!
// If we can't, then the plugin cannot continue.
if (which == Ham_CS_RoundRespawn)
{
return 0;
}
}

Additionally, you can check to see if a function is valid to execute or hook by using the '''IsHamValid()''' native. The validity of a function is determined when the module is first loaded, and it will never change, so if you want to check it, there is no need to do so before every execute.

== Supported Mods ==
=== Mostly Supported ===
These mods have a very large list of functions that are usable in the module.
* Counter-Strike 1.6
* Condition Zero
* Day of Defeat
* Team Fortress Classic
* The Specialists
* Natural-Selection

=== Weakly Supported ===
Because these mods do not contain a Linux binary, they are much harder to disassemble. There is only plans for disassembling two functions for each (TakeDamage and Use).
* Sven-Coop
* Earth's Special Forces

== Hooking Functions ==
The big feature for Ham Sandwich is the ability to hook virtual functions.

=== Creating the Hook ===
Creating a hook is a lot like creating a hook in Fakemeta.

#include <amxmodx>
#include <hamsandwich>

public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}

public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
// Stuff...
}

This creates a basic hook which is called any time a player takes damage. Look in '''ham_const.inc''' for forward parameters for each hook.

Like FakeMeta, there is a hidden last parameter (it goes after the classname in this case). Set it to 1 to do post hooking.

=== Blocking the Hook ===
Like Fakemeta and Engine, it is possible to stop a function from being called. This is called '''superceding'''.

Blocking in Ham Sandwich is identical to how it is accomplished in Fakemeta. In each hook, you return one of four special values:

* HAM_IGNORED - Nothing happened, the call continues.
* HAM_HANDLED - You did something, but the call continues.
* HAM_OVERRIDE - The call will still be executed, but instead you will change the return value.
* HAM_SUPERCEDE - The call is not executed, and you use your return value, if applicable.

You can use the native '''GetHamReturnStatus()''' to check the current return status of the hook.

=== Return Values ===
You can get or change the return values for all the hooks available in Ham Sandwich. Look in '''ham_const.inc''' for a list of all hooks and their return values.

These natives will get any ''modified'' return values.
* native GetHamReturnInteger(&output);
* native GetHamReturnFloat(&Float:output);
* native GetHamReturnVector(Float:output[3]);
* native GetHamReturnEntity(&output);
* native GetHamReturnString(output[], size);

These natives will get the ''original'' return value from the function.
Note that this is '''only''' valid to call in a post hook, it will be undefined to call it at any other time.
* native GetOrigHamReturnInteger(&output);
* native GetOrigHamReturnFloat(&Float:output);
* native GetOrigHamReturnVector(Float:output[3]);
* native GetOrigHamReturnCbase(&output);
* native GetOrigHamReturnString(output[], size);

These natives will change the return value to whatever you please.
Note that this will have no effect on the actual return value from the function '''unless''' the return status of the hook is HAM_OVERRIDE or HAM_SUPERCEDE.
* native SetHamReturnInteger(value);
* native SetHamReturnFloat(Float:value);
* native SetHamReturnVector(const Float:value[3]);
* native SetHamReturnEntity(value);
* native SetHamReturnString(const value[]);

=== Changing Hook Parameters ===
One feature available in Ham Sandwich that is not available in FakeMeta is the ability to change all parameters on the fly for each hook.

This means that, for example, if you wanted to make a plugin that halved all damage players take, you would do something like this:
#include <amxmodx>
#include <fakemeta>
public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}
public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
SetHamParamFloat(4, damage / 2.0);
return HAM_HANDLED;
}

All hooks after the one you change them in will see the modified values. Hooks are executed in the order in which they are registered.

All available parameter changing natives are:

* native SetHamParamInteger(which, value);
* native SetHamParamFloat(which, Float:value);
* native SetHamParamVector(which, const Float:value[3]);
* native SetHamParamEntity(which, value);
* native SetHamParamString(which, const output[]);
* native SetHamParamTraceResult(which, tr_handle);

=== Disabling Hooks ===

Similar to how FakeMeta allows for unregistering of hooks with unregister_forward, HamSandwich will allow you to disable and enable hooks whenever you want.

The '''RegisterHam''' function will return a handle (tagged with HamHook). You can then make subsequent calls to DisableHamHook() and EnableHamHook() with the handle to stop it from forwarding, or enable its forwards again.

There is no way to completely unregister the hooks (until map change), as deleting a hook is a delicate process.

HamSandwich General Usage (AMX Mod X)

2007-05-11T03:36:14Z

Sawce: /* Config File Requirements */

== About Ham Sandwich ==
Ham Sandwich is a module that provides additional hooking and function calling capabilities to [[AMX Mod X]]. It is scheduled to be included with the 1.8 branch of AMX Mod X.

Instead of hooking and executing Half-Life engine calls, like the modules FakeMeta and Engine do, this hooks and executes virtual function calls.

=== What is a virtual function? ===
A virtual function is a member function of a class in C++. In the case of Ham Sandwich, the virtual function would be a member function of a game entity. The virtual functions deal with various events in game, such as damage, and using entities.

Unlike normal member functions, virtual functions can be changed by class derivatives. For example, a typical hierarchy of entities in Half-Life game dlls look something like this:

CBaseEntity
CBaseAnimating
CBaseMonster
CZombie
CHeadCrab
CBarnacle
CBasePlayer
CBot

Now for example, if CBaseEntity has the virtual function called "FunctionA", and that function does nothing. But, CBarnacle also declares the function "FunctionA", and instead of doing nothing it causes the barnacle to die.

If something like this were to be executed:
CBaseEntity *ent=GET_PRIVATE(entity);
ent->FunctionA();

And the entity were a barnacle, the barnacle would die. If the entity was a zombie, nothing would happen.

=== What are some limitations? ===

Dealing with virtual functions have a couple minor drawbacks.
==== Custom Entities ====
Hooking virtual functions, such as TakeDamage, that get called on custom entities is a little bit awkward.

Because of the way where classes derive, and they get their own virtual table for each class, the type of class that the game dll allocates will be whatever gets hooked for a particular hook.

For example, say you have a plugin like this:

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

new myStr;
public plugin_init()
{
myStr = engfunc( EngFunc_AllocString, "info_target" );

register_clcmd( "make_entity", "cmdMakeEntity" );

RegisterHam(Ham_TakeDamage, "damageHook", "MyEntityClass"); // Error!
}
public cmdMakeEntity( id )
{
new ent = engfunc( EngFunc_CreateEntity, myStr );
set_pev( ent, pev_classname, "MyEntityClass" );
// ...
}

That will not work, because the class "MyEntityClass" is not native to the gamedll. Instead, you would need to hook TakeDamage for "info_target", and do some form of parsing on the entities that get passed to it (such as checking classname), if you want to deal with custom entity hooking.

==== End of Chain Derivatives ====
The normal way virtual functions get called is by a virtual table that resides somewhere in the class. A magical index is assigned to each function, and then it looks up the function pointer inside of the virtual table, and executes the required function.

However, compilers are smart enough to optimize away the virtual function lookup if it knows two things about a call:
* The exact class type of the entity.
* That the entity is not derived any further.

An example would be using the hierarchy shown earlier. If, inside of CBot::TakeDamage a call to the virtual function CBot::Killed is made, most compilers will optimize the virtual function lookup out, so that CBot::TakeDamage would then directly call CBot::Killed. This means that the hook would never be called.

Fortunately, these instances are kind of rare.

==== Config File Requirements ====
Every hook and every ExecuteHam() call requires an entry for the function which the scripter is attempting to hook or execute. The function needs to be in the amxmodx/configs/hamdata.ini config file, under the game mod and operating system.

If a function that the script attempts to hook or call is not configured in the hamdata.ini file, then the module will cause the plugin to cease operation, as this is a fatal error.

The fatal errors can be filtered out by including a forward in the script called '''HamFilter'''. This is similar to native/module filters available inside of the core of amxmodx, whenever a fatal error occurs, it will pass along the parameters to HamFilter, and if HamFilter returns '''PLUGIN_HANDLED''', the error will be ignored (but the attempted hook or execution will not take place). If the forward does not exist, or if it returns something other than PLUGIN_HANDLED, the plugin will fail.

An example layout for HamFilter:
public HamFilter(Ham:which, HamError:err, const reason[])
{
// Ignore an unconfigured ns_awardkill
if (which == Ham_NS_AwardKill && err == HAM_FUNC_NOT_CONFIGURED)(
{
return PLUGIN_HANDLED;
}
// We absolutely need to be able to use cs_roundrespawn!
// If we can't, then the plugin cannot continue.
if (which == Ham_CS_RoundRespawn)
{
return 0;
}
}

Additionally, you can check to see if a function is valid to execute or hook by using the '''IsHamValid()''' native. The validity of a function is determined when the module is first loaded, and it will never change, so if you want to check it, there is no need to do so before every execute.

== Supported Mods ==
=== Mostly Supported ===
These mods have a very large list of functions that are usable in the module.
* Counter-Strike 1.6
* Condition Zero
* Day of Defeat
* Team Fortress Classic
* The Specialists
* Natural-Selection

=== Weakly Supported ===
Because these mods do not contain a Linux binary, they are much harder to disassemble. There is only plans for disassembling two functions for each (TakeDamage and Use).
* Sven-Coop
* Earth's Special Forces

== Hooking Functions ==
The big feature for Ham Sandwich is the ability to hook virtual functions.

=== Creating the Hook ===
Creating a hook is a lot like creating a hook in Fakemeta.

#include <amxmodx>
#include <hamsandwich>

public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}

public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
// Stuff...
}

This creates a basic hook which is called any time a player takes damage. Look in '''ham_const.inc''' for forward parameters for each hook.

Like FakeMeta, there is a hidden last parameter (it goes after the classname in this case). Set it to 1 to do post hooking.

=== Blocking the Hook ===
Like Fakemeta and Engine, it is possible to stop a function from being called. This is called '''superceding'''.

Blocking in Ham Sandwich is identical to how it is accomplished in Fakemeta. In each hook, you return one of four special values:

* HAM_IGNORED - Nothing happened, the call continues.
* HAM_HANDLED - You did something, but the call continues.
* HAM_OVERRIDE - The call will still be executed, but instead you will change the return value.
* HAM_SUPERCEDE - The call is not executed, and you use your return value, if applicable.

You can use the native '''GetHamReturnStatus()''' to check the current return status of the hook.

=== Return Values ===
You can get or change the return values for all the hooks available in Ham Sandwich. Look in '''ham_const.inc''' for a list of all hooks and their return values.

These natives will get any ''modified'' return values.
* native GetHamReturnInteger(&output);
* native GetHamReturnFloat(&Float:output);
* native GetHamReturnVector(Float:output[3]);
* native GetHamReturnEntity(&output);
* native GetHamReturnString(output[], size);

These natives will get the ''original'' return value from the function.
* native GetOrigHamReturnInteger(&output);
* native GetOrigHamReturnFloat(&Float:output);
* native GetOrigHamReturnVector(Float:output[3]);
* native GetOrigHamReturnCbase(&output);
* native GetOrigHamReturnString(output[], size);

These natives will change the return value to whatever you please.
* native SetHamReturnInteger(value);
* native SetHamReturnFloat(Float:value);
* native SetHamReturnVector(const Float:value[3]);
* native SetHamReturnEntity(value);
* native SetHamReturnString(const value[]);

=== Changing Hook Parameters ===
One feature available in Ham Sandwich that is not available in FakeMeta is the ability to change all parameters on the fly for each hook.

This means that, for example, if you wanted to make a plugin that halved all damage players take, you would do something like this:
#include <amxmodx>
#include <fakemeta>
public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}
public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
SetHamParamFloat(4, damage / 2.0);
return HAM_HANDLED;
}

All hooks after the one you change them in will see the modified values. Hooks are executed in the order in which they are registered.

All available parameter changing natives are:

* native SetHamParamInteger(which, value);
* native SetHamParamFloat(which, Float:value);
* native SetHamParamVector(which, const Float:value[3]);
* native SetHamParamEntity(which, value);
* native SetHamParamString(which, const output[]);
* native SetHamParamTraceResult(which, tr_handle);

=== Disabling Hooks ===

Similar to how FakeMeta allows for unregistering of hooks with unregister_forward, HamSandwich will allow you to disable and enable hooks whenever you want.

The '''RegisterHam''' function will return a handle (tagged with HamHook). You can then make subsequent calls to DisableHamHook() and EnableHamHook() with the handle to stop it from forwarding, or enable its forwards again.

There is no way to completely unregister the hooks (until map change), as deleting a hook is a delicate process.

HamSandwich General Usage (AMX Mod X)

2007-05-11T03:34:30Z

Sawce: /* About Ham Sandwich */

== About Ham Sandwich ==
Ham Sandwich is a module that provides additional hooking and function calling capabilities to [[AMX Mod X]]. It is scheduled to be included with the 1.8 branch of AMX Mod X.

Instead of hooking and executing Half-Life engine calls, like the modules FakeMeta and Engine do, this hooks and executes virtual function calls.

=== What is a virtual function? ===
A virtual function is a member function of a class in C++. In the case of Ham Sandwich, the virtual function would be a member function of a game entity. The virtual functions deal with various events in game, such as damage, and using entities.

Unlike normal member functions, virtual functions can be changed by class derivatives. For example, a typical hierarchy of entities in Half-Life game dlls look something like this:

CBaseEntity
CBaseAnimating
CBaseMonster
CZombie
CHeadCrab
CBarnacle
CBasePlayer
CBot

Now for example, if CBaseEntity has the virtual function called "FunctionA", and that function does nothing. But, CBarnacle also declares the function "FunctionA", and instead of doing nothing it causes the barnacle to die.

If something like this were to be executed:
CBaseEntity *ent=GET_PRIVATE(entity);
ent->FunctionA();

And the entity were a barnacle, the barnacle would die. If the entity was a zombie, nothing would happen.

=== What are some limitations? ===

Dealing with virtual functions have a couple minor drawbacks.
==== Custom Entities ====
Hooking virtual functions, such as TakeDamage, that get called on custom entities is a little bit awkward.

Because of the way where classes derive, and they get their own virtual table for each class, the type of class that the game dll allocates will be whatever gets hooked for a particular hook.

For example, say you have a plugin like this:

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

new myStr;
public plugin_init()
{
myStr = engfunc( EngFunc_AllocString, "info_target" );

register_clcmd( "make_entity", "cmdMakeEntity" );

RegisterHam(Ham_TakeDamage, "damageHook", "MyEntityClass"); // Error!
}
public cmdMakeEntity( id )
{
new ent = engfunc( EngFunc_CreateEntity, myStr );
set_pev( ent, pev_classname, "MyEntityClass" );
// ...
}

That will not work, because the class "MyEntityClass" is not native to the gamedll. Instead, you would need to hook TakeDamage for "info_target", and do some form of parsing on the entities that get passed to it (such as checking classname), if you want to deal with custom entity hooking.

==== End of Chain Derivatives ====
The normal way virtual functions get called is by a virtual table that resides somewhere in the class. A magical index is assigned to each function, and then it looks up the function pointer inside of the virtual table, and executes the required function.

However, compilers are smart enough to optimize away the virtual function lookup if it knows two things about a call:
* The exact class type of the entity.
* That the entity is not derived any further.

An example would be using the hierarchy shown earlier. If, inside of CBot::TakeDamage a call to the virtual function CBot::Killed is made, most compilers will optimize the virtual function lookup out, so that CBot::TakeDamage would then directly call CBot::Killed. This means that the hook would never be called.

Fortunately, these instances are kind of rare.

==== Config File Requirements ====
Every hook and every ExecuteHam() call requires an entry for the function which the scripter is attempting to hook or execute. The function needs to be in the amxmodx/configs/hamdata.ini config file, under the game mod and operating system.

If a function that the script attempts to hook or call is not configured in the hamdata.ini file, then the module will cause the plugin to cease operation, as this is a fatal error.

The fatal errors can be filtered out by including a forward in the script called '''HamFilter'''. This is similar to native/module filters available inside of the core of amxmodx, whenever a fatal error occurs, it will pass along the parameters to HamFilter, and if HamFilter returns '''PLUGIN_HANDLED''', the error will be ignored (but the attempted hook or execution will not take place). If the forward does not exist, or if it returns something other than PLUGIN_HANDLED, the plugin will fail.

An example layout for HamFilter:
public HamFilter(Ham:which, HamError:err, const reason[])
{
// Ignore an unconfigured ns_awardkill
if (which == Ham_NS_AwardKill && err == HAM_FUNC_NOT_CONFIGURED)(
{
return PLUGIN_HANDLED;
}
// We absolutely need to be able to use cs_roundrespawn!
// If we can't, then the plugin cannot continue.
if (which == Ham_CS_RoundRespawn)
{
return 0;
}
}

== Supported Mods ==
=== Mostly Supported ===
These mods have a very large list of functions that are usable in the module.
* Counter-Strike 1.6
* Condition Zero
* Day of Defeat
* Team Fortress Classic
* The Specialists
* Natural-Selection

=== Weakly Supported ===
Because these mods do not contain a Linux binary, they are much harder to disassemble. There is only plans for disassembling two functions for each (TakeDamage and Use).
* Sven-Coop
* Earth's Special Forces

== Hooking Functions ==
The big feature for Ham Sandwich is the ability to hook virtual functions.

=== Creating the Hook ===
Creating a hook is a lot like creating a hook in Fakemeta.

#include <amxmodx>
#include <hamsandwich>

public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}

public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
// Stuff...
}

This creates a basic hook which is called any time a player takes damage. Look in '''ham_const.inc''' for forward parameters for each hook.

Like FakeMeta, there is a hidden last parameter (it goes after the classname in this case). Set it to 1 to do post hooking.

=== Blocking the Hook ===
Like Fakemeta and Engine, it is possible to stop a function from being called. This is called '''superceding'''.

Blocking in Ham Sandwich is identical to how it is accomplished in Fakemeta. In each hook, you return one of four special values:

* HAM_IGNORED - Nothing happened, the call continues.
* HAM_HANDLED - You did something, but the call continues.
* HAM_OVERRIDE - The call will still be executed, but instead you will change the return value.
* HAM_SUPERCEDE - The call is not executed, and you use your return value, if applicable.

You can use the native '''GetHamReturnStatus()''' to check the current return status of the hook.

=== Return Values ===
You can get or change the return values for all the hooks available in Ham Sandwich. Look in '''ham_const.inc''' for a list of all hooks and their return values.

These natives will get any ''modified'' return values.
* native GetHamReturnInteger(&output);
* native GetHamReturnFloat(&Float:output);
* native GetHamReturnVector(Float:output[3]);
* native GetHamReturnEntity(&output);
* native GetHamReturnString(output[], size);

These natives will get the ''original'' return value from the function.
* native GetOrigHamReturnInteger(&output);
* native GetOrigHamReturnFloat(&Float:output);
* native GetOrigHamReturnVector(Float:output[3]);
* native GetOrigHamReturnCbase(&output);
* native GetOrigHamReturnString(output[], size);

These natives will change the return value to whatever you please.
* native SetHamReturnInteger(value);
* native SetHamReturnFloat(Float:value);
* native SetHamReturnVector(const Float:value[3]);
* native SetHamReturnEntity(value);
* native SetHamReturnString(const value[]);

=== Changing Hook Parameters ===
One feature available in Ham Sandwich that is not available in FakeMeta is the ability to change all parameters on the fly for each hook.

This means that, for example, if you wanted to make a plugin that halved all damage players take, you would do something like this:
#include <amxmodx>
#include <fakemeta>
public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}
public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
SetHamParamFloat(4, damage / 2.0);
return HAM_HANDLED;
}

All hooks after the one you change them in will see the modified values. Hooks are executed in the order in which they are registered.

All available parameter changing natives are:

* native SetHamParamInteger(which, value);
* native SetHamParamFloat(which, Float:value);
* native SetHamParamVector(which, const Float:value[3]);
* native SetHamParamEntity(which, value);
* native SetHamParamString(which, const output[]);
* native SetHamParamTraceResult(which, tr_handle);

=== Disabling Hooks ===

Similar to how FakeMeta allows for unregistering of hooks with unregister_forward, HamSandwich will allow you to disable and enable hooks whenever you want.

The '''RegisterHam''' function will return a handle (tagged with HamHook). You can then make subsequent calls to DisableHamHook() and EnableHamHook() with the handle to stop it from forwarding, or enable its forwards again.

There is no way to completely unregister the hooks (until map change), as deleting a hook is a delicate process.

HamSandwich General Usage (AMX Mod X)

2007-05-11T03:24:43Z

Sawce: /* Hooking Functions */

== About Ham Sandwich ==
Ham Sandwich is a module that provides additional hooking and function calling capabilities to [[AMX Mod X]]. It is scheduled to be included with the 1.8 branch of AMX Mod X.

Instead of hooking and executing Half-Life engine calls, like the modules FakeMeta and Engine do, this hooks and executes virtual function calls.

=== What is a virtual function? ===
A virtual function is a member function of a class in C++. In the case of Ham Sandwich, the virtual function would be a member function of a game entity. The virtual functions deal with various events in game, such as damage, and using entities.

Unlike normal member functions, virtual functions can be changed by class derivatives. For example, a typical hierarchy of entities in Half-Life game dlls look something like this:

CBaseEntity
CBaseAnimating
CBaseMonster
CZombie
CHeadCrab
CBarnacle
CBasePlayer
CBot

Now for example, if CBaseEntity has the virtual function called "FunctionA", and that function does nothing. But, CBarnacle also declares the function "FunctionA", and instead of doing nothing it causes the barnacle to die.

If something like this were to be executed:
CBaseEntity *ent=GET_PRIVATE(entity);
ent->FunctionA();

And the entity were a barnacle, the barnacle would die. If the entity was a zombie, nothing would happen.

=== What are some limitations? ===

Dealing with virtual functions have a couple minor drawbacks.
==== Custom Entities ====
Hooking virtual functions, such as TakeDamage, that get called on custom entities is a little bit awkward.

Because of the way where classes derive, and they get their own virtual table for each class, the type of class that the game dll allocates will be whatever gets hooked for a particular hook.

For example, say you have a plugin like this:

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

new myStr;
public plugin_init()
{
myStr = engfunc( EngFunc_AllocString, "info_target" );

register_clcmd( "make_entity", "cmdMakeEntity" );

RegisterHam(Ham_TakeDamage, "damageHook", "MyEntityClass"); // Error!
}
public cmdMakeEntity( id )
{
new ent = engfunc( EngFunc_CreateEntity, myStr );
set_pev( ent, pev_classname, "MyEntityClass" );
// ...
}

That will not work, because the class "MyEntityClass" is not native to the gamedll. Instead, you would need to hook TakeDamage for "info_target", and do some form of parsing on the entities that get passed to it (such as checking classname), if you want to deal with custom entity hooking.

==== End of Chain Derivatives ====
The normal way virtual functions get called is by a virtual table that resides somewhere in the class. A magical index is assigned to each function, and then it looks up the function pointer inside of the virtual table, and executes the required function.

However, compilers are smart enough to optimize away the virtual function lookup if it knows two things about a call:
* The exact class type of the entity.
* That the entity is not derived any further.

An example would be using the hierarchy shown earlier. If, inside of CBot::TakeDamage a call to the virtual function CBot::Killed is made, most compilers will optimize the virtual function lookup out, so that CBot::TakeDamage would then directly call CBot::Killed. This means that the hook would never be called.

Fortunately, these instances are kind of rare.

== Supported Mods ==
=== Mostly Supported ===
These mods have a very large list of functions that are usable in the module.
* Counter-Strike 1.6
* Condition Zero
* Day of Defeat
* Team Fortress Classic
* The Specialists
* Natural-Selection

=== Weakly Supported ===
Because these mods do not contain a Linux binary, they are much harder to disassemble. There is only plans for disassembling two functions for each (TakeDamage and Use).
* Sven-Coop
* Earth's Special Forces

== Hooking Functions ==
The big feature for Ham Sandwich is the ability to hook virtual functions.

=== Creating the Hook ===
Creating a hook is a lot like creating a hook in Fakemeta.

#include <amxmodx>
#include <hamsandwich>

public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}

public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
// Stuff...
}

This creates a basic hook which is called any time a player takes damage. Look in '''ham_const.inc''' for forward parameters for each hook.

Like FakeMeta, there is a hidden last parameter (it goes after the classname in this case). Set it to 1 to do post hooking.

=== Blocking the Hook ===
Like Fakemeta and Engine, it is possible to stop a function from being called. This is called '''superceding'''.

Blocking in Ham Sandwich is identical to how it is accomplished in Fakemeta. In each hook, you return one of four special values:

* HAM_IGNORED - Nothing happened, the call continues.
* HAM_HANDLED - You did something, but the call continues.
* HAM_OVERRIDE - The call will still be executed, but instead you will change the return value.
* HAM_SUPERCEDE - The call is not executed, and you use your return value, if applicable.

You can use the native '''GetHamReturnStatus()''' to check the current return status of the hook.

=== Return Values ===
You can get or change the return values for all the hooks available in Ham Sandwich. Look in '''ham_const.inc''' for a list of all hooks and their return values.

These natives will get any ''modified'' return values.
* native GetHamReturnInteger(&output);
* native GetHamReturnFloat(&Float:output);
* native GetHamReturnVector(Float:output[3]);
* native GetHamReturnEntity(&output);
* native GetHamReturnString(output[], size);

These natives will get the ''original'' return value from the function.
* native GetOrigHamReturnInteger(&output);
* native GetOrigHamReturnFloat(&Float:output);
* native GetOrigHamReturnVector(Float:output[3]);
* native GetOrigHamReturnCbase(&output);
* native GetOrigHamReturnString(output[], size);

These natives will change the return value to whatever you please.
* native SetHamReturnInteger(value);
* native SetHamReturnFloat(Float:value);
* native SetHamReturnVector(const Float:value[3]);
* native SetHamReturnEntity(value);
* native SetHamReturnString(const value[]);

=== Changing Hook Parameters ===
One feature available in Ham Sandwich that is not available in FakeMeta is the ability to change all parameters on the fly for each hook.

This means that, for example, if you wanted to make a plugin that halved all damage players take, you would do something like this:
#include <amxmodx>
#include <fakemeta>
public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}
public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
SetHamParamFloat(4, damage / 2.0);
return HAM_HANDLED;
}

All hooks after the one you change them in will see the modified values. Hooks are executed in the order in which they are registered.

All available parameter changing natives are:

* native SetHamParamInteger(which, value);
* native SetHamParamFloat(which, Float:value);
* native SetHamParamVector(which, const Float:value[3]);
* native SetHamParamEntity(which, value);
* native SetHamParamString(which, const output[]);
* native SetHamParamTraceResult(which, tr_handle);

=== Disabling Hooks ===

Similar to how FakeMeta allows for unregistering of hooks with unregister_forward, HamSandwich will allow you to disable and enable hooks whenever you want.

The '''RegisterHam''' function will return a handle (tagged with HamHook). You can then make subsequent calls to DisableHamHook() and EnableHamHook() with the handle to stop it from forwarding, or enable its forwards again.

There is no way to completely unregister the hooks (until map change), as deleting a hook is a delicate process.

HamSandwich General Usage (AMX Mod X)

2007-05-10T18:38:16Z

Sawce:

== About Ham Sandwich ==
Ham Sandwich is a module that provides additional hooking and function calling capabilities to [[AMX Mod X]]. It is scheduled to be included with the 1.8 branch of AMX Mod X.

Instead of hooking and executing Half-Life engine calls, like the modules FakeMeta and Engine do, this hooks and executes virtual function calls.

=== What is a virtual function? ===
A virtual function is a member function of a class in C++. In the case of Ham Sandwich, the virtual function would be a member function of a game entity. The virtual functions deal with various events in game, such as damage, and using entities.

Unlike normal member functions, virtual functions can be changed by class derivatives. For example, a typical hierarchy of entities in Half-Life game dlls look something like this:

CBaseEntity
CBaseAnimating
CBaseMonster
CZombie
CHeadCrab
CBarnacle
CBasePlayer
CBot

Now for example, if CBaseEntity has the virtual function called "FunctionA", and that function does nothing. But, CBarnacle also declares the function "FunctionA", and instead of doing nothing it causes the barnacle to die.

If something like this were to be executed:
CBaseEntity *ent=GET_PRIVATE(entity);
ent->FunctionA();

And the entity were a barnacle, the barnacle would die. If the entity was a zombie, nothing would happen.

=== What are some limitations? ===

Dealing with virtual functions have a couple minor drawbacks.
==== Custom Entities ====
Hooking virtual functions, such as TakeDamage, that get called on custom entities is a little bit awkward.

Because of the way where classes derive, and they get their own virtual table for each class, the type of class that the game dll allocates will be whatever gets hooked for a particular hook.

For example, say you have a plugin like this:

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

new myStr;
public plugin_init()
{
myStr = engfunc( EngFunc_AllocString, "info_target" );

register_clcmd( "make_entity", "cmdMakeEntity" );

RegisterHam(Ham_TakeDamage, "damageHook", "MyEntityClass"); // Error!
}
public cmdMakeEntity( id )
{
new ent = engfunc( EngFunc_CreateEntity, myStr );
set_pev( ent, pev_classname, "MyEntityClass" );
// ...
}

That will not work, because the class "MyEntityClass" is not native to the gamedll. Instead, you would need to hook TakeDamage for "info_target", and do some form of parsing on the entities that get passed to it (such as checking classname), if you want to deal with custom entity hooking.

==== End of Chain Derivatives ====
The normal way virtual functions get called is by a virtual table that resides somewhere in the class. A magical index is assigned to each function, and then it looks up the function pointer inside of the virtual table, and executes the required function.

However, compilers are smart enough to optimize away the virtual function lookup if it knows two things about a call:
* The exact class type of the entity.
* That the entity is not derived any further.

An example would be using the hierarchy shown earlier. If, inside of CBot::TakeDamage a call to the virtual function CBot::Killed is made, most compilers will optimize the virtual function lookup out, so that CBot::TakeDamage would then directly call CBot::Killed. This means that the hook would never be called.

Fortunately, these instances are kind of rare.

== Supported Mods ==
=== Mostly Supported ===
These mods have a very large list of functions that are usable in the module.
* Counter-Strike 1.6
* Condition Zero
* Day of Defeat
* Team Fortress Classic
* The Specialists
* Natural-Selection

=== Weakly Supported ===
Because these mods do not contain a Linux binary, they are much harder to disassemble. There is only plans for disassembling two functions for each (TakeDamage and Use).
* Sven-Coop
* Earth's Special Forces

== Hooking Functions ==
The big feature for Ham Sandwich is the ability to hook virtual functions.

=== Creating the Hook ===
Creating a hook is a lot like creating a hook in Fakemeta.

#include <amxmodx>
#include <hamsandwich>

public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}

public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
// Stuff...
}

This creates a basic hook which is called any time a player takes damage. Look in '''ham_const.inc''' for forward parameters for each hook.

Like FakeMeta, there is a hidden last parameter (it goes after the classname in this case). Set it to 1 to do post hooking.

=== Blocking the Hook ===
Like Fakemeta and Engine, it is possible to stop a function from being called. This is called '''superceding'''.

Blocking in Ham Sandwich is identical to how it is accomplished in Fakemeta. In each hook, you return one of four special values:

* HAM_IGNORED - Nothing happened, the call continues.
* HAM_HANDLED - You did something, but the call continues.
* HAM_OVERRIDE - The call will still be executed, but instead you will change the return value.
* HAM_SUPERCEDE - The call is not executed, and you use your return value, if applicable.

You can use the native '''GetHamReturnStatus()''' to check the current return status of the hook.

=== Return Values ===
You can get or change the return values for all the hooks available in Ham Sandwich. Look in '''ham_const.inc''' for a list of all hooks and their return values.

These natives will get any ''modified'' return values.
* native GetHamReturnInteger(&output);
* native GetHamReturnFloat(&Float:output);
* native GetHamReturnVector(Float:output[3]);
* native GetHamReturnEntity(&output);
* native GetHamReturnString(output[], size);

These natives will get the ''original'' return value from the function.
* native GetOrigHamReturnInteger(&output);
* native GetOrigHamReturnFloat(&Float:output);
* native GetOrigHamReturnVector(Float:output[3]);
* native GetOrigHamReturnCbase(&output);
* native GetOrigHamReturnString(output[], size);

These natives will change the return value to whatever you please.
* native SetHamReturnInteger(value);
* native SetHamReturnFloat(Float:value);
* native SetHamReturnVector(const Float:value[3]);
* native SetHamReturnEntity(value);
* native SetHamReturnString(const value[]);

=== Changing Hook Parameters ===
One feature available in Ham Sandwich that is not available in FakeMeta is the ability to change all parameters on the fly for each hook.

This means that, for example, if you wanted to make a plugin that halved all damage players take, you would do something like this:
#include <amxmodx>
#include <fakemeta>
public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}
public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
SetHamParamFloat(4, damage / 2.0);
return HAM_HANDLED;
}

All hooks after the one you change them in will see the modified values. Hooks are executed in the order in which they are registered.

All available parameter changing natives are:

* native SetHamParamInteger(which, value);
* native SetHamParamFloat(which, Float:value);
* native SetHamParamVector(which, const Float:value[3]);
* native SetHamParamEntity(which, value);
* native SetHamParamString(which, const output[]);
* native SetHamParamTraceResult(which, tr_handle);

HamSandwich General Usage (AMX Mod X)

2007-05-10T18:36:38Z

Sawce: /* Hooking Functions */

== About Ham Sandwich ==
Ham Sandwich is a module that provides additional hooking and function calling capabilities to [[AMX Mod X]]. It is scheduled to be included with the 1.8 branch of AMX Mod X.

Instead of hooking and executing Half-Life engine calls, like the modules FakeMeta and Engine do, this hooks and executes virtual function calls.

=== What is a virtual function? ===
A virtual function is a member function of a class in C++. In the case of Ham Sandwich, the virtual function would be a member function of a game entity. The virtual functions deal with various events in game, such as damage, and using entities.

Unlike normal member functions, virtual functions can be changed by class derivatives. For example, a typical hierarchy of entities in Half-Life game dlls look something like this:

CBaseEntity
CBaseAnimating
CBaseMonster
CZombie
CHeadCrab
CBarnacle
CBasePlayer
CBot

Now for example, if CBaseEntity has the virtual function called "FunctionA", and that function does nothing. But, CBarnacle also declares the function "FunctionA", and instead of doing nothing it causes the barnacle to die.

If something like this were to be executed:
CBaseEntity *ent=GET_PRIVATE(entity);
ent->FunctionA();

And the entity were a barnacle, the barnacle would die. If the entity was a zombie, nothing would happen.

=== What are some limitations? ===

Dealing with virtual functions have a couple minor drawbacks.
==== Custom Entities ====
Hooking virtual functions, such as TakeDamage, that get called on custom entities is a little bit awkward.

Because of the way where classes derive, and they get their own virtual table for each class, the type of class that the game dll allocates will be whatever gets hooked for a particular hook.

For example, say you have a plugin like this:

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

new myStr;
public plugin_init()
{
myStr = engfunc( EngFunc_AllocString, "info_target" );

register_clcmd( "make_entity", "cmdMakeEntity" );

RegisterHam(Ham_TakeDamage, "damageHook", "MyEntityClass"); // Error!
}
public cmdMakeEntity( id )
{
new ent = engfunc( EngFunc_CreateEntity, myStr );
set_pev( ent, pev_classname, "MyEntityClass" );
// ...
}

That will not work, because the class "MyEntityClass" is not native to the gamedll. Instead, you would need to hook TakeDamage for "info_target", and do some form of parsing on the entities that get passed to it (such as checking classname), if you want to deal with custom entity hooking.

==== End of Chain Derivatives ====
The normal way virtual functions get called is by a virtual table that resides somewhere in the class. A magical index is assigned to each function, and then it looks up the function pointer inside of the virtual table, and executes the required function.

However, compilers are smart enough to optimize away the virtual function lookup if it knows two things about a call:
* The exact class type of the entity.
* That the entity is not derived any further.

An example would be using the hierarchy shown earlier. If, inside of CBot::TakeDamage a call to the virtual function CBot::Killed is made, most compilers will optimize the virtual function lookup out, so that CBot::TakeDamage would then directly call CBot::Killed. This means that the hook would never be called.

Fortunately, these instances are kind of rare.

=== Supported Mods ===
==== Mostly Supported ====
These mods have a very large list of functions that are usable in the module.
* Counter-Strike 1.6
* Condition Zero
* Day of Defeat
* Team Fortress Classic
* The Specialists
* Natural-Selection

==== Weakly Supported ====
Because these mods do not contain a Linux binary, they are much harder to disassemble. There is only plans for disassembling two functions for each (TakeDamage and Use).
* Sven-Coop
* Earth's Special Forces

=== Hooking Functions ===
The big feature for Ham Sandwich is the ability to hook virtual functions.

==== Creating the Hook ====
Creating a hook is a lot like creating a hook in Fakemeta.

#include <amxmodx>
#include <hamsandwich>

public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}

public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
// Stuff...
}

This creates a basic hook which is called any time a player takes damage. Look in '''ham_const.inc''' for forward parameters for each hook.

Like FakeMeta, there is a hidden last parameter (it goes after the classname in this case). Set it to 1 to do post hooking.

==== Blocking the Hook ====
Like Fakemeta and Engine, it is possible to stop a function from being called. This is called '''superceding'''.

Blocking in HamSandwich is identical to how it is accomplished in Fakemeta. In each hook, you return one of four special values:

* HAM_IGNORED - Nothing happened, the call continues.
* HAM_HANDLED - You did something, but the call continues.
* HAM_OVERRIDE - The call will still be executed, but instead you will change the return value.
* HAM_SUPERCEDE - The call is not executed, and you use your return value, if applicable.

You can use the native '''GetHamReturnStatus()''' to check the current return status of the hook.

==== Return Values ====
You can get or change the return values for all the hooks available in HamSandwich. Look in '''ham_const.inc''' for a list of all hooks and their return values.

These natives will get any ''modified'' return values.
* native GetHamReturnInteger(&output);
* native GetHamReturnFloat(&Float:output);
* native GetHamReturnVector(Float:output[3]);
* native GetHamReturnEntity(&output);
* native GetHamReturnString(output[], size);

These natives will get the ''original'' return value from the function.
* native GetOrigHamReturnInteger(&output);
* native GetOrigHamReturnFloat(&Float:output);
* native GetOrigHamReturnVector(Float:output[3]);
* native GetOrigHamReturnCbase(&output);
* native GetOrigHamReturnString(output[], size);

These natives will change the return value to whatever you please.
* native SetHamReturnInteger(value);
* native SetHamReturnFloat(Float:value);
* native SetHamReturnVector(const Float:value[3]);
* native SetHamReturnEntity(value);
* native SetHamReturnString(const value[]);

==== Changing Hook Parameters ====
One feature available in HamSandwich that is not available in FakeMeta is the ability to change all parameters on the fly for each hook.

This means that, for example, if you wanted to make a plugin that halved all damage players take, you would do something like this:
#include <amxmodx>
#include <fakemeta>
public plugin_init()
{
RegisterHam(Ham_TakeDamage, "player_hurt", "player");
}
public player_hurt(this, inflictor, attacker, Float:damage, damagebits)
{
SetHamParamFloat(4, damage / 2.0);
return HAM_HANDLED;
}

All hooks after the one you change them in will see the modified values. Hooks are executed in the order in which they are registered.

All available parameter changing natives are:

* native SetHamParamInteger(which, value);
* native SetHamParamFloat(which, Float:value);
* native SetHamParamVector(which, const Float:value[3]);
* native SetHamParamEntity(which, value);
* native SetHamParamString(which, const output[]);
* native SetHamParamTraceResult(which, tr_handle);

HamSandwich General Usage (AMX Mod X)

2007-05-10T18:32:55Z

Sawce: /* Hooking Functions */

HamSandwich General Usage (AMX Mod X)

2007-05-10T18:28:40Z

Sawce: /* Hooking Functions */

HamSandwich General Usage (AMX Mod X)

2007-05-10T18:23:34Z

Sawce:

HamSandwich General Usage (AMX Mod X)

2007-05-10T18:15:07Z

Sawce: HamSandwich General Usage (AMX Madsfod X) moved to HamSandwich General Usage (AMX Mod X): lol typo

== About Ham Sandwich ==
Ham Sandwich is a module that provides additional hooking and function calling capabilities to [[AMX Mod X]].

Instead of hooking and executing Half-Life engine calls, like the modules FakeMeta and Engine do, this hooks and executes virtual function calls.

=== What is a virtual function? ===
A virtual function is a member function of a class in C++. In the case of Ham Sandwich, the virtual function would be a member function of a game entity. The virtual functions deal with various events in game, such as damage, and using entities.

Unlike normal member functions, virtual functions can be changed by class derivatives. For example, a typical hierarchy of entities in Half-Life game dlls look something like this:

CBaseEntity
CBaseAnimating
CBaseMonster
CZombie
CHeadCrab
CBarnacle
CBasePlayer
CBot

Now for example, if CBaseEntity has the virtual function called "FunctionA", and that function does nothing. But, CBarnacle also declares the function "FunctionA", and instead of doing nothing it causes the barnacle to die.

If something like this were to be executed:
CBaseEntity *ent=GET_PRIVATE(entity);
ent->FunctionA();

And the entity were a barnacle, the barnacle would die. If the entity was a zombie, nothing would happen.

=== What are some limitations? ===

Dealing with virtual functions have a couple minor drawbacks.
==== Custom Entities ====
Hooking virtual functions, such as TakeDamage, that get called on custom entities is a little bit awkward.

Because of the way where classes derive, and they get their own virtual table for each class, the type of class that the game dll allocates will be whatever gets hooked for a particular hook.

For example, say you have a plugin like this:

#include <amxmodx>
#include <fakemeta>
#include <hamsandwich>

new myStr;
public plugin_init()
{
myStr = engfunc( EngFunc_AllocString, "info_target" );

register_clcmd( "make_entity", "cmdMakeEntity" );

RegisterHam(Ham_TakeDamage, "damageHook", "MyEntityClass"); // Error!
}
public cmdMakeEntity( id )
{
new ent = engfunc( EngFunc_CreateEntity, myStr );
set_pev( ent, pev_classname, "MyEntityClass" );
// ...
}

That will not work, because the class "MyEntityClass" is not native to the gamedll. Instead, you would need to hook TakeDamage for "info_target", and do some form of parsing on the entities that get passed to it (such as checking classname), if you want to deal with custom entity hooking.

==== End of Chain Derivatives ====
The normal way virtual functions get called is by a virtual table that resides somewhere in the class. A magical index is assigned to each function, and then it looks up the function pointer inside of the virtual table, and executes the required function.

However, compilers are smart enough to optimize away the virtual function lookup if it knows two things about a call:
* The exact class type of the entity.
* That the entity is not derived any further.

An example would be using the hierarchy shown earlier. If, inside of CBot::TakeDamage a call to the virtual function CBot::Killed is made, most compilers will optimize the virtual function lookup out, so that CBot::TakeDamage would then directly call CBot::Killed. This means that the hook would never be called.

Fortunately, these instances are kind of rare.

HamSandwich General Usage (AMX Madsfod X)

2007-05-10T18:15:07Z

Sawce: HamSandwich General Usage (AMX Madsfod X) moved to HamSandwich General Usage (AMX Mod X): lol typo

#REDIRECT [[HamSandwich General Usage (AMX Mod X)]]

HamSandwich General Usage (AMX Mod X)

2007-05-10T18:10:52Z

Sawce: /* What are some limitations? */

HamSandwich General Usage (AMX Mod X)

2007-05-10T18:01:43Z

Sawce: New page: == About Ham Sandwich == Ham Sandwich is a module that provides additional hooking and function calling capabilities to AMX Mod X. Instead of hooking and executing Half-Life engine ca...

Signature Scanning

2007-02-19T21:01:41Z

Sawce:

[[Category:Documentation (SourceMM)]]

== Introduction ==

This article demonstrates a technique developed by Lance Vorgin known as "Signature Scanning", or sigscanning for short.

== What is Sigscanning? ==

Sigscanning is a multi-step process involving extracting function signatures from a binary and then scanning for them at run-time to locate an otherwise-hidden function. A signature for a function is a set of bytes unique to a function. These bytes are the instructions a program uses to operate. These sets of bytes are what make up functions (or subroutines as they are called in Assembly). When we have enough of these bytes to form a unique set, we can then match them again to the function in memory.

Why is this useful for plugins? Each time Valve releases an update for their mods, they may change classes such as CBaseEntity used by many plugin coders to interact with a player’s entity. Due to the fact that we do not have the appropriate class headers for each of these changes, we may be using virtual functions that now exist at different addresses. This would cause a crash at run-time. To avoid this, the following solutions are available:
*rely on manual offsets into the class' vtable
*modify the provided class headers by inserting dummy virtual functions to fix the offsets
*sigscanning

Each have their pros and cons, but it turns out that although sigscanning is the most tedious out of the three, it is the most reliable. The first two choices are typically broken by updates.

== Assembly and Memory ==

To understand all of this, one must first understand how the code of a C++ program is compiled into a binary file.

When you hit "Build Solution" on your IDE or run a makefile, your compiler does a multitude of operations. First it takes the code and runs it through a preprocessor. The preprocessor takes all the "#" directives (e.g. #define, #include, etc.) and substitutes them with normal C++ code. After the preprocessor has done its job, the code is passed on to the parser. In simplified terms, the parser basically takes C++ code and turns it into Assembly (asm) code. After the parser has parsed the code into Assembly code, the assembler "assembles" the code into mostly machine (byte) code which is put into object files that carry the .obj or .o extension. Then the linker gathers all the object files where it looks for function calls and sets the "links" to them (static linking) as well as external calls to functions outside the scope of the assembled code (dynamic linking) and finally maps any runtime calls (runtime linking). After this, it finally outputs the finished product (a binary file, i.e. an executable or library). When a server loads your plugin, it uses runtime calls to call functions from within your plugin, and likewise your plugin calls functions from the server.

Now where this all comes into play in sigscanning is where you will be taking the server module (.dll or .so file) from memory and scanning it in its machine-code form for those functions that you need. This is done by first disassembling the server module back into Assembly form and finding the instructions that make up that function you want.

Assembly is the "lowest-level" language in programming terms. It is easy to flip-flop between Assembly and machine code because they are basically the same, except Assembly uses something called "Mnemonics" before every instruction. These are the human-readable keywords push, pop, mov, call, etc. that define what the instruction does. As C++ code is translated into Assembly, you can imagine the very structured syntax of C++ flattened out into primitive simple Assembly instructions. I won’t go into further detail on Assembly due to its complex nature. The best way to learn more about it (which is recommended) is to read one of the reference links provided at the bottom of this writing.

== Before We Go Further ==

Read BAILOPAN’s three DevLogs on sigscanning to gain an understanding of the proceeding sections.
*Oh, you’ve not hacked yet? – http://www.sourcemod.net/devlog/?p=55
*Finding Functions, Part 2 – http://www.sourcemod.net/devlog/?p=56
*Finding Functions, Part 3 – http://www.sourcemod.net/devlog/?p=57

== Scanning for Signatures at Run-time ==

This is the complete code for a basic sigscanner. All functions and variables are described with comments.

=== sigscan.h ===

<cpp>#ifndef SIGSCAN_H
#define SIGSCAN_H

class CSigScan {
private:
/* Private Variables */
/* Base Address of the server module in memory */
static unsigned char *base_addr;
/* The length to the module's ending address */
static size_t base_len;

/* The signature to scan for */
unsigned char *sig_str;
/* A mask to ignore certain bytes in the signature such as addresses
The mask should be as long as all the bytes in the signature string
Use '?' to ignore a byte and 'x' to check it
Example: "xxx????xx" - The first 3 bytes are checked, then the next 4 are
ignored, then the last 2 are checked */
char *sig_mask;
/* The length of sig_str and sig_mask (not including a terminating null for sig_mask) */
size_t sig_len;

/* Private Functions */
void* FindSignature(void);

public:
/* Public Variables */

/* sigscan_dllfunc is a pointer of something that resides inside the gamedll so we can get
the base address of it. From a SourceMM plugin, just set this to ismm->serverFactory(0)
in Load(). From a Valve Server Plugin, you must set this to an actual factory returned
from gameServerFactory and hope that a SourceMM plugin did not override it. */
static void *(*sigscan_dllfunc)(const char *pName, int *pReturnCode);

/* If the scan was successful or not */
char is_set;
/* Starting address of the found function */
void *sig_addr;

/* Public Functions */
CSigScan(void)sig_str(NULL), sig_mask(NULL), sig_len(0), sig_addr(NULL) {}
~CSigScan(void);

static bool GetDllMemInfo(void);
void Init(unsigned char *sig, char *mask, size_t len);
};

/* Sigscanned member functions are casted to member function pointers of this class
and called with member function pointer syntax */
class EmptyClass { };

void InitSigs(void);

/* Sig Functions */
class CBaseAnimating;
void CBaseAnimating_Ignite(CBaseAnimating *cba, float flFlameLifetime);

#endif</cpp>

=== sigscan.cpp ===

<cpp>#include <stdio.h>

#ifdef WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#else
#include <dlfcn.h>
#include <sys/types.h>
#include <sys/stat.h>
#endif

#include "sigscan.h"

/* There is no ANSI ustrncpy */
unsigned char* ustrncpy(unsigned char *dest, const unsigned char *src, int len) {
while(len--)
dest[len] = src[len];

return dest;
}

/* //////////////////////////////////////
CSigScan Class
////////////////////////////////////// */
unsigned char* CSigScan::base_addr;
size_t CSigScan::base_len;
void *(*CSigScan::sigscan_dllfunc)(const char *pName, int *pReturnCode);

/* Initialize the Signature Object */
void CSigScan::Init(unsigned char *sig, char *mask, size_t len) {
is_set = 0;

sig_len = len;
sig_str = new unsigned char[sig_len];
ustrncpy(sig_str, sig, sig_len);

sig_mask = new char[sig_len+1];
strncpy(sig_mask, mask, sig_len);
sig_mask[sig_len+1] = 0;

if(!base_addr)
return ; // GetDllMemInfo() Failed

if((sig_addr = FindSignature()) == NULL)
return ; // FindSignature() Failed

is_set = 1;
// SigScan Successful!
}

/* Destructor frees sig-string allocated memory */
CSigScan::~CSigScan(void) {
delete[] sig_str;
delete[] sig_mask;
}

/* Get base address of the server module (base_addr) and get its ending offset (base_len) */
bool CSigScan::GetDllMemInfo(void) {
void *pAddr = (void*)sigscan_dllfunc;
base_addr = 0;
base_len = 0;

#ifdef WIN32
MEMORY_BASIC_INFORMATION mem;

if(!pAddr)
return false; // GetDllMemInfo failed!pAddr

if(!VirtualQuery(pAddr, &mem, sizeof(mem)))
return false;

base_addr = (unsigned char*)mem.AllocationBase;

IMAGE_DOS_HEADER *dos = (IMAGE_DOS_HEADER*)mem.AllocationBase;
IMAGE_NT_HEADERS *pe = (IMAGE_NT_HEADERS*)((unsigned long)dos+(unsigned long)dos->e_lfanew);

if(pe->Signature != IMAGE_NT_SIGNATURE) {
base_addr = 0;
return false; // GetDllMemInfo failedpe points to a bad location
}

base_len = (size_t)pe->OptionalHeader.SizeOfImage;

#else

Dl_info info;
struct stat buf;

if(!dladdr(pAddr, &info))
return false;

if(!info.dli_fbase || !info.dli_fname)
return false;

if(stat(info.dli_fname, &buf) != 0)
return false;

base_addr = (unsigned char*)info.dli_fbase;
base_len = buf.st_size;
#endif

return true;
}

/* Scan for the signature in memory then return the starting position's address */
void* CSigScan::FindSignature(void) {
unsigned char *pBasePtr = base_addr;
unsigned char *pEndPtr = base_addr+base_len;
size_t i;

while(pBasePtr < pEndPtr) {
for(i = 0;i < sig_len;i++) {
if((sig_mask[i] != '?') && (sig_str[i] != pBasePtr[i]))
break;
}

// If 'i' reached the end, we know we have a match!
if(i == sig_len)
return (void*)pBasePtr;

pBasePtr++;
}

return NULL;
}

/* Signature Objects */
CSigScan CBaseAnimating_Ignite_Sig;

/* Set the static base_addr and base_len variables then initialize all Signature Objects */
void InitSigs(void) {
CSigScan::GetDllMemInfo();

/* void CBaseAnimating::Ignite(float flFlameLifetime, bool bNPCOnly, float flSize,
bool bCalledByLevelDesigner);
Last Address: 0x220BC7A0
Signature: 56 8B F1 8B? 86? BC? 00? 00? 00? C1? E8? 1B? A8? 01? 0F? 85?
9A? 00? 00? 00? 8B 16 FF 92? F0? 00? 00? 00? 80? 7C? 24? 0C?
00? 74? 08? 84 C0 0F? 84? 83? 00? 00? 00? 3C 01 75? 20? 80
7C 24 14 00 75? 19? 8B CE E8 83? 1A? 01? 00? 85? C0? 74?
0E? 8B 10 8B C8 FF 92? 08? 05? 00? 00? 84 C0 74? 5F? 57
6A 01 56 E8 48? EA? 07? 00? 8B F8 83 C4 08 85 FF 74?
3D? 8B 44 24 0C 50 8B CF E8 83? E5? 07? 00? 68 00 00
00 08 8B CE
*/
CBaseAnimating_Ignite_Sig.Init((unsigned char*)
"\x56\x8B\xF1\x8B\x86\xBC\x00\x00\x00\xC1\xE8\x1B\xA8\x01\x0F\x85\x9A\x00\x00\x00"
"\x8B\x16\xFF\x92\xF0\x00\x00\x00\x80\x7C\x24\x0C\x00\x74\x08\x84\xC0\x0F\x84\x83"
"\x00\x00\x00\x3C\x01\x75\x20\x80\x7C\x24\x14\x00\x75\x19\x8B\xCE\xE8\x83\x1A\x01"
"\x00\x85\xC0\x74\x0E\x8B\x10\x8B\xC8\xFF\x92\x08\x05\x00\x00\x84\xC0\x74\x5F\x57"
"\x6A\x01\x56\xE8\x48\xEA\x07\x00\x8B\xF8\x83\xC4\x08\x85\xFF\x74\x3D\x8B\x44\x24"
"\x0C\x50\x8B\xCF\xE8\x83\xE5\x07\x00\x68\x00\x00\x00\x08\x8B\xCE"
,
"xxx?????????????????"
"xxx????????????xx???"
"???xx??xxxxx??xxx???"
"?????xxxxx?????xx??x"
"xxxx????xxxxxxx??xxx"
"xxxxx????xxxxxxx"
,
116);

return ;
}

/* Example of a sig-scanned method function */
void CBaseAnimating_Ignite(CBaseAnimating *cba, float flFlameLifetime) {
int bNPCOnly = false, bCalledByLevelDesigner = false;
float flSize = 0.0f;

if(!CBaseAnimating_Ignite_Sig.is_set)
return ; // sigscan failed

union {
void (EmptyClass::*mfpnew)(float, bool, float, bool);
void* addr;
} u;
u.addr = CBaseAnimating_Ignite_Sig.sig_addr;

(reinterpret_cast<EmptyClass*>(cba)->*u.mfpnew)(flFlameLifetime, (bool)bNPCOnly, flSize,
(bool)bCalledByLevelDesigner);

return;
}</cpp>
This will find the signature of a function at runtime, however it is useless unless you already have or know how to find signatures for which it can scan.

== Finding the Signature of a Function ==

To find a signature for a function, we need a Disassembler to disassemble the server module. Here are links to free Disassemblers that seem to work well:
* [http://www.dirfile.com/ida_pro_freeware_version.htm IDA Pro Freeware Version (Windows)]
* [http://www.smidgeonsoft.prohosting.com/pebrowse-pro-file-viewer.html PEBrowse Professional (Windows)]
* [http://pvdasm.reverse-engineering.net/index.php?Section=1 Proview “PVDasm” Disassembler (Windows)]
* [http://www.gnu.org/software/binutils/manual/html_chapter/binutils_4.html GNU objdump (Linux)]
* [http://www.gnu.org/software/ddd/ Data Display Debugger (Linux)]

=== Linux ===

Showdax pointed out a very helpful way that makes finding signatures under Linux much easier than under Windows. The GNU tool "objdump" can be used against the server module to disassemble the binary into AT&T Assembly code with each subroutine given its name from the source code. Here is an example of how to use the objdump tool:
<pre>~/usr/srcds/dod/bin$ objdump -d server_i486.so > server_i486.so.objdump</pre>
This dumps the disassembled code into the file "server_i486.so.objdump". You can then simply open up that file and search for the function name that corresponds to its subroutine then extract its bytes to create a signature (discussed later in [[#Creating a Searchable Signature]]).

=== Windows ===

Under Windows, finding a signature becomes much more complicated as PE-format binaries do not include symbol names for each subroutine. I suggest using the IDA Pro Freeware Disassembler since I will be using a method I have found to find signatures that I only know how to do in IDA Pro (although you may be able to find a way to do my method in the other disassemblers).

The rest of this section will assume you are running Windows, have a copy of Microsoft Visual Studio C++ and are using the IDA Pro Freeware Disassembler. First what you need to do is compile the HL2:DM server module. So navigate your way to the "hl2src/dlls" directory and open up "hl_sdk.vcproj". Once open inside MSVC++, go to the Build menu and select Configuration Manager. Set the configuration to "Release" and press OK. Go to the Build menu again and select Build. This may take a bit as everything is compiled together. Once finished, you should have a new directory named "Release_hl2." Inside, there will be the compiled server.dll file and a server.pdb file. The PDB file is key to finding the subroutines in Assembly for the function you want to use.

Now open IDA Pro and go to the File menu and open the server.dll file you just compiled. When you open it, a dialog will pop up. Just press "OK" and everything will start to load. Eventually IDA Pro will say something akin to "There is a PDB file located in the same directory for this binary." Click "Yes" and it will use that PDB file to name the subroutines which will make this process much easier. As things load, IDA Pro will go through the DLL, disassembling it and naming everything to their corresponding function or variable name. This may take a while and may even appear that IDA has frozen, but it has not so don't close it or you will have to start over.

After some time, everything will have finished. Before we continue, however, we have to open up yet another IDA Pro again (don't close the other IDA Pro) and load the server.dll for the mod we will be sigscanning (in this case, Counter-Strike: Source). This file is located in "cstrike/bin" in your game installation directory. Again, do the same procedure, except this time we won't have a PDB file for it. This should take a shorter time than last time since there is no PDB file. After both IDA Pro processes have finished disassembling, we are ready to start finding signatures.

To start looking for a signature, switch over to the HL2:DM server module IDA Pro window. Above, we have the signature for CBaseAnimating::Ignite in the [[#sigscan.cpp]] section. As a new example, let's try to find the signature for Teleporting an entity. This is the prototype for its method from the source code:
<cpp>virtual void CBaseEntity::Teleport(const Vector *newPosition, const QAngle *newAngles,
const Vector *newVelocity);</cpp>
Now in IDA Pro look for CBaseEntity::Teleport in the Names list then double click it. You should be brought to the location of CBaseEntity::Teleport in the disassembly, however, its internal name is given as CBaseEntity_Teleport. As you can see, IDA Pro lists all the local and parameter variables near the top (lines starting with var_ and arg_), and then the actual code is listed below with its corresponding byte representation. (Tip: I had to actually set IDA Pro to list the opcode bytes from the Options menu, in "General" then under the tab "Disassembly"). At first, it seems feasible to just use the bytes here for the signature, but Valve decided to change almost all the CBase* methods (that I've seen) for Counter-Strike: Source from the Half-Life 2: Deathmatch code. Due to this fact, we will have to use the HL2:DM disassembly as clues for finding the same function/method in the CS:S disassembly. To find our Teleport function, we will have to find a unique set of instructions that wouldn't be repeated in another subroutine. I had to do some trial and error with this function since Valve had changed or moved various pieces of code. If you try looking over the subroutine for something unique, you may see a group of repeated mov instructions:
<asm>.text:220C96CF 89 44 24 18 mov [esp+30h+var_18], eax
.text:220C96D3 89 74 24 1C mov [esp+30h+var_14], esi
.text:220C96D7 89 74 24 20 mov [esp+30h+var_10], esi
.text:220C96DB 89 74 24 24 mov [esp+30h+var_C], esi
.text:220C96DF 89 74 24 28 mov [esp+30h+var_8], esi
.text:220C96E3 89 74 24 2C mov [esp+30h+var_4], esi</asm>
Try searching for part of this in the CS:S disassembly. If you get results, search for the next item to make sure there isn't another set of the same instructions. Then to verify this is the correct subroutine for the function Teleport(), compare the two subroutines to see if they have similar instructions in the same places. If they do then it is most likely correct and now you can use some of the instructions from your find in machine-code form to create a signature, which is discussed in the next section.

== Creating a Searchable Signature ==

Once we have found the subroutine for the function we want, we can start extracting the bytes for use in a signature. Here is part of the assembly for CBaseEntity::Teleport:
<asm>220D9940 CBaseEntity_Teleport proc near ; CODE XREFsub_220B6330+14 p
220D9940 ; sub_22143900+A p ...
220D9940
220D9940 83 EC 18 sub esp, 18h
220D9943 53 push ebx
220D9944 56 push esi
220D9945 8B D9 mov ebx, ecx
220D9947 8B 0D 78 B2 46 22 mov ecx, dword_2246B278
220D994D 33 F6 xor esi, esi
220D994F 33 C0 xor eax, eax
220D9951 3B CE cmp ecx, esi
220D9953 7E 21 jle short loc_220D9976
220D9955 8B 15 6C B2 46 22 mov edx, dword_2246B26C
220D995B EB 03 jmp short loc_220D9960
220D995B ; ---------------------------------------------------------------------------
220D995D 8D 49 00 align 10h
220D9960
220D9960 loc_220D9960 ; CODE XREFCBaseEntity_Teleport+1B j
220D9960 ; CBaseEntity_Teleport+2A j
220D9960 39 1C 82 cmp [edx+eax*4], ebx
220D9963 74 09 jz short loc_220D996E
220D9965 83 C0 01 add eax, 1
220D9968 3B C1 cmp eax, ecx
220D996A 7C F4 jl short loc_220D9960
220D996C EB 08 jmp short loc_220D9976
220D996E ; ---------------------------------------------------------------------------
220D996E
220D996E loc_220D996E ; CODE XREFCBaseEntity_Teleport+23 j
220D996E 3B C6 cmp eax, esi
220D9970 0F 8D 17 01 00 00 jge loc_220D9A8D
220D9976
220D9976 loc_220D9976 ; CODE XREFCBaseEntity_Teleport+13 j
220D9976 ; CBaseEntity_Teleport+2C j
220D9976 55 push ebp
220D9977 57 push edi
220D9978 8D 44 24 10 lea eax, [esp+28h+var_18]
220D997C 50 push eax
220D997D 51 push ecx
220D997E B9 6C B2 46 22 mov ecx, offset dword_2246B26C
220D9983 89 5C 24 18 mov [esp+30h+var_18], ebx
220D9987 E8 B4 88 F9 FF call sub_22072240
220D998C 8D 4C 24 14 lea ecx, [esp+28h+var_14]
220D9990 51 push ecx
220D9991 53 push ebx
220D9992 89 44 24 18 mov [esp+30h+var_18], eax
220D9996 89 74 24 1C mov [esp+30h+var_14], esi
220D999A 89 74 24 20 mov [esp+30h+var_10], esi</asm>
I have written a small C program for which I use to create a signature string and signature mask from. It is not necessary to use, but it can help to reduce the amount of tedious work you have to do to create a signature.

=== sigcreator.c ===

<cpp>#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

int main() {
int i, len, out_i = 0, mask_i = 0;
char *sig, *out, *mask;

sig = (char*)calloc(1024, sizeof(char));

printf("?");
fgets(sig, 1022, stdin);
len = strlen(sig);

out = (char*)calloc(len*2, sizeof(char));
mask = (char*)calloc(len*2, sizeof(char));

for(i = 0;i < len;i++) {
if(isalnum(sig[i]) && isalnum(sig[i+1])) {
out[out_i++] = '\\';
out[out_i++] = 'x';
out[out_i++] = sig[i];
out[out_i++] = sig[i+1];
if(sig[i+2] == '?') {
mask[mask_i++] = '?';
i += 2;
}
else {
mask[mask_i++] = 'x';
i++;
}
}
}

printf("\n\nSize%d\n\nSig:\n%s\n\nMask:\n%s", strlen(mask), out, mask);
getchar();

free(sig);
free(out);
free(mask);
return 0;
}</cpp>
It takes an input string of hexadecimal characters just as they appear in bold in the Assembly above. For each byte that should be ignored, a question mark after a hexadecimal byte will tell the program where a "?" should be in the signature mask. I will give an example of what the input and output should look like near the end of this section.

When creating a signature, you must also create a signature mask as well. A signature mask tells the sigscanner which bytes to ignore, such as addresses which may change at runtime. The signature mask is the same length as the signature. A question mark ("?") in the mask signifies the position of the byte in the signature string to be ignored. Any other character corresponding to a byte in the signature string will be checked (usually we use "x" to represent these).

For the Teleport() function we found in the last section, we will build our signature from the bold hexadecimal characters in the Assembly above. I will be using the format of my "Sig Creator" for developing a signature string and mask for the sigscanner. The first three instructions in the subroutine are called the "function prologue." These instructions will most likely never change as long as the variable declarations are not changed. So to start off, input "83 EC 18 53 56" into the sigcreator. Next is a mov instruction that probably won’t change "8B D9". After that is another mov instruction, but this mov instruction contains an address in it, so add this to the input "8B? 0D? 78? B2? 46? 22?". This will appear as question marks in the signature mask. The next set of xor instructions don’t reference an address so they’re safe to add normally to the input "33 F6 33 C0". From here on, continue to input each segment of bytes into the sigcreator, where any segment referencing an address should have question marks following each hexadecimal character pairs (like I did for the mov instruction). Eventually you’ll end at those last mov instructions. This isn’t the end of the subroutine, but it’s enough to develop a worthy signature. So press enter in the sigcreator, and it should output something like this:
<pre>?83 EC 18 53 56 8B D9 8B? 0D? 78? B2? 46? 22? 33 F6 33 C0 3B CE 7E? 21? 8B? 15?
6C? B2? 46? 22? EB? 03? 8D? 49? 00? 39 1C 82 74? 09? 83? C0? 01? 3B C1 7C? F4?
EB? 08? 3B C6 0F? 8D? 17? 01? 00? 00? 55 57? 8D? 44? 24? 10? 50 51 B9? 6C? B2?
46? 22? 89 5C 24 18 E8? B4? 88? F9? FF? 8D? 4C? 24? 14? 51 53 89 44 24 18 89
74 24 1C 89 74 24 20 89 74 24 24 89 74 24 28 89 74 24 2C

Size106

Sig:
\x83\xEC\x18\x53\x56\x8B\xD9\x8B\x0D\x78\xB2\x46\x22\x33\xF6\x33\xC0\x3B\xCE\x7E
\x21\x8B\x15\x6C\xB2\x46\x22\xEB\x03\x8D\x49\x00\x39\x1C\x82\x74\x09\x83\xC0\x01
\x3B\xC1\x7C\xF4\xEB\x08\x3B\xC6\x0F\x8D\x17\x01\x00\x00\x55\x57\x8D\x44\x24\x10
\x50\x51\xB9\x6C\xB2\x46\x22\x89\x5C\x24\x18\xE8\xB4\x88\xF9\xFF\x8D\x4C\x24\x14
\x51\x53\x89\x44\x24\x18\x89\x74\x24\x1C\x89\x74\x24\x20\x89\x74\x24\x24\x89\x74
\x24\x28\x89\x74\x24\x2C

Mask:
xxxxxxx??????xxxxxx?????????????xxx?????xx????xx??????x?????xx?????xxxx?????????
xxxxxxxxxxxxxxxxxxxxxxxxxx</pre>
Now you have a nice signature and mask you can use for your sigscanner and it also gives you the length of the signature as well. Cheers!

== Contributors ==

Thank you to those who contributed to this document directly and/or indirectly:
*Lance Vorgin – Forefather of sigscanners, posted his sigscanner on the [[SourceMod]] forums somewhere
*BAILOPAN – Created his DevLogs on how to create a sigscanner, also gave tips as well as other useful information
*Showdax – Suggested the objdump command for disassembly on Linux
*CyberMind – Examples of how to use a different method of calling sig functions
*Jacob Lojo – Posted a thread on how to develop a signature from disassembly (I was having trouble finding sigs with my scanner before his post). Also contributed a link to another disassembler
*SeLfkiLL – Revision and completed code for the sigscanner and sigcreator

== References ==

*Oh, you’ve not hacked yet? – http://www.sourcemod.net/devlog/?p=55
*Finding Functions, Part 2 – http://www.sourcemod.net/devlog/?p=56
*Finding Functions, Part 3 – http://www.sourcemod.net/devlog/?p=57
*Introduction to Reverse Engineering Software - http://www.acm.uiuc.edu/sigmil/RevEng/index.html
*The Art of Assembly Language Programming - http://maven.smith.edu/~thiebaut/ArtOfAssembly/artofasm.html

== See Also ==

* [[Signatures_and_Offsets]]

Mod folder

2007-01-14T05:26:23Z

Sawce:

The subdirectory that your mod is stored in, in relation to the Half-Life base folder.

Some common mod folders:
*'''cstrike''' - Counter-Strike
*'''czero''' - Counter-Strike: Condition Zero
*'''dod''' - Day of Defeat
*'''ns''' - Natural-Selection
*'''tfc''' - Team Fortress Classic
*'''ts''' - The Specialists
*'''valve''' - Half-Life Death Match

Installing AMX Mod X Manually

2007-01-08T20:36:51Z

Sawce: /* Configure */

This guide will help you install AMX Mod X without the assistance of an automated tool.

=Introduction=
There are a few ways you can install [[AMX Mod X]]. If you have [[shell]] or direct access to your server, you can do all pf the operations directly on the server itself. If you only have [[FTP]] access, it's best to install [[AMX Mod X]] on a "[[dummy]]" folder on your hard drive, do all configuration there, and then upload the files to your server. Otherwise, you can upload the files as you're installing and then use [[FTP]] to change things along the way.

Throughout the documentation we'll refer to your "[[mod folder]]" - this is the folder your mod is stored in, like "cstrike" (for Counter-Strike), or "dod" (for Day of Defeat). If you're installing on a listen server, it will be in \Program Files\Steam\SteamApps\<your steam login>\<Valve game or Half-Life>\<mod folder>. If you're using a dedicated server, it will be HLServer\<mod folder>. On linux this is hlds_l/<mod folder>. If you are using remote/[[FTP]] access, you may be restricted to your [[mod folder]] or hlds_l already, and don't need to find it. For this documentation, <mod folder> will refer to the mod folder mentioned above. For [[Linux]] users, binaries will not end in ".dll", they will usually end in "_i386.so" or "_amd64.so" for [[AMD64]] machines.

=Directory Structure=
You should familiarize yourself with AMX Mod X's directory structure. The addons folder resides in your [[mod folder]].
<pre>
--addons - this is where Server addons go
|--metamod - this is where Metamod goes. Metamod is necessary to run AMX Mod X
|--dlls - this is where Metamod's binaries go
|--amxmodx - this is where AMX Mod X goes
|--dlls - amxmodx_mm.dll should go here
|--modules - Where modules are stored (_amxx.dll or _amxx_i386.so etc)
|--plugins - Where plugins are stored (.amx or .amxx)
|--scripting - Where example source code and the compiler/assembler are stored
|--include - Where include files for source code is stored
|--compiled - Where the compiler batch file stores .amxx output
|--doc - This documentation is kept here
|--data - Binary data, for example saved stats, language caches, and GeoIP information
|--lang - Dictionary text files for AMX Mod X ML features (multi lingual)
|--configs - Configuration files
|--logs - AMX Mod X log files
</pre>

=Installing Metamod=
Because AMX Mod X is a [[Metamod]] plugin, you must first install Metamod. If you already have it installed, you may skip this section and jump to [[#Installing AMX Mod X]].
==Directory Structure==
#In your mod folder, create a folder called "addons".
#In <mod folder>\addons, create a folder called "metamod".
#In <mod folder>\addons\metamod, create a folder called "dlls".
==Upload Binaries==
#Go to the [http://www.metamod.org/ Metamod Website] and download Metamod. You will want to get either the Windows [[DLL]] or the [[Linux SO]] (for either 32bit [[Linux]] or [[Linux]] on [[AMD64]]).
#Extract the metamod file and upload or copy it to your server. It must be placed in <mod folder>\addons\metamod\dlls.
==Configure==
<ol><li>In your mod folder, find the "[[liblist.gam]]" file. Open the file with a text editor, such as [[notepad]]. If you're using FTP or a control panel, you will need to download the file first.</li>
<li>For Windows, find this line:
::<pre>gamedll "dlls\mp.dll"</pre>
::Replace it with this line:
::<pre>gamedll "addons\metamod\dlls\metamod.dll"</pre>
For Linux, find this line:
::<pre>gamedll_linux "dlls/mp_i386.so"</pre>
::Replace it with this line:
::<pre>gamedll_linux "addons/metamod/dlls/metamod_i386.so"</pre>
::''(Note: AMD64 is no longer supported for various reasons, please use 32bit)''</li>
<li>Save liblist.gam (and upload it over the old one if your server is remote).</li>
<li>Edit the file <mod folder>\addons\metamod\plugins.ini. If it does not exist, create it. This file is your list of Metamod plugins.</li>
<li>For Windows, add
<pre>win32 addons\amxmodx\dlls\amxmodx_mm.dll</pre>
For Linux add:
<pre>linux addons/amxmodx/dlls/amxmodx_mm_i386.so</pre>
</li>
<li>Save (and upload) plugins.ini.</li>
</ol>

==Installing AMX Mod X==
#Go to www.amxmodx.org and click "Downloads". Download the amxmodx-base package for either Windows, Linux, or AMD64.
#Extract the base package to your mod folder. This will place AMX Mod X into <mod folder>\addons\amxmodx. If you're uploading over FTP, you should extract it to a dummy location first (like your desktop).
#Go back to the AMX Mod X download site. If there is an addon pack for your mod available, and you want to use it, download the addon package corresponding to your mod. As of this writing, addon packs are available for Counter-Strike/Condition-Zero, Team Fortress Classic, Day of Defeat, The Specialists, Natural Selection, and Earth's Special Forces. Make sure you download the pack that corresponds to the server's operating system, either Windows, Linux, or Linux AMD64.
#Extract the addon pack to the same place as before, it should simply add more files to your AMX Mod X installation.
#If you're using FTP, upload the addons folder.
#AMX Mod X should now be installed! You can type "meta list" in your [[server console]] to see if it was successful.
#You can now move on to [[Configuring AMX Mod X]]. If you encountered problems, see [[Troubleshooting AMX Mod X]].

[[Category:Documentation (AMX Mod X)]]

User:Sawce

2006-12-10T08:31:37Z

Sawce:

Man, hes so awesome.

Configuring AMX Mod X

2006-12-10T08:31:12Z

Sawce: /* Map Specific Plugins */

=Admins=
See the section on [[Adding Admins (AMX Mod X)|Adding Admins]] for more information.

=Plugins=
==Installing==
Often, plugins will have their own directions if they need special installation requirements. However, this will instruct you on the basics of adding a plugin.
#Follow any directions the plugin author has given you. If the plugin requires extra steps or special files, make sure you have them in the proper place and order.
#If you are given a .sma source file instead of a .amxx, you must compile the plugin yourself. For more information, see [[Compiling Plugins (AMX Mod X)]].
#Place the plugin's .amxx file in the addons/amxmodx/plugins folder.
#Add the plugin's name to addons\amxmodx\configs\plugins.ini. Example: <pre>myplugin.amxx</pre>
#Change map or restart the server. If the plugin has any load errors, see [[Troubleshooting AMX Mod X#Plugins|Troubleshooting AMX Mod X]].

==Removing==
#Remove the entry from addons\amxmodx\configs\plugins.ini by deleting it or prepending a semi-colon to comment it out.
#Delete any associated files.

==Default Plugins==
:{|
|- class="t2th"
| Plugin
| Purpose
|- class="t2td"
| admin.amxx
| Administration Base
|- class="t2td"
| admin_sql.amxx
| Administration Base for SQL. Use only one base.
|- class="t2td"
| admincmd.amxx
| Basic administration commands (such as kick/slap).
|- class="t2td"
| adminhelp.amxx
| Help for admin commands.
|- class="t2td"
| adminslots.amxx
| Slot reservation.
|- class="t2td"
| multilingual.amxx
| Multi-Lingual client configuration.
|- class="t2td"
| menufront.amxx
| Front-end for admin menus.
|- class="t2td"
| cmdmenu.amxx
| Command menu for settings.
|- class="t2td"
| plmenu.amxx
| Player menu commands (kick, ban, etc).
|- class="t2td"
| telemenu.amxx
| Teleport Menu (fun module required).
|- class="t2td"
| mapsmenu.amxx
| Maps menu (vote, changeleve, etc).
|- class="t2td"
| adminchat.amxx
| Console-based chat commands.
|- class="t2td"
| antiflood.amxx
| Prevents clients from flooding the say chat.
|- class="t2td"
| scrollmsg.amxx
| Displays a scrolling message.
|- class="t2td"
| imessage.amxx
| Displays a centered, timed information message.
|- class="t2td"
| adminvote.amxx
| Voting commands.
|- class="t2td"
| nextmap.amxx
| Displays next map in the mapcycle.
|- class="t2td"
| mapchooser.amxx
| Allows players to vote for the next map.
|- class="t2td"
| timeleft.amxx
| Displays time left on the current map.
|- class="t2td"
| pausecfg.amxx
| Allows pausing/unpausing of plugins.
|- class="t2td"
| statscfg.amxx
| Configuration of statistical plugins.
|}

=Modules=
Modules add additional functionality for plugins to use.
==Installing==
#Figure out what operating system your server is: Windows, Linux, or Linux using AMD64 (64bit).
#If the module is 3rd party, download the module corresponding to your OS. It will end in .dll for Windows, _i386.so for Linux, or _amd64.so for AMD64.
#Place the file in addons/amxmodx/modules/ and follow any additional instructions.
#If the module is already in addons/amxmodx/configs/modules.ini, remove the ';' next to its name to enable it.
#Otherwise, add the module's name to modules.ini. [[AMX Mod X]] supports generic notation, for example: <pre>mysql_amxx</pre> ... will automatically detect the correct module to use.
#To see if the module is working, you can type <tt>amxx modules</tt> in your [[server console]].

==Removing==
#Remove the entry from addons\amxmodx\configs\modules.ini by deleting it or prepending a semi-colon to comment it out.
#Delete any associated files if you don't need them.

==Default Modules==
:{|
|- class="t2th"
| Module
| Purpose
|- class="t2td"
| fun_amxx
| General functions for changing game values.
|- class="t2td"
| engine_amxx
| More advanced functions for getting and setting values in the HL engine.
|- class="t2td"
| fakemeta_amxx
| Expert/advanced functions for manipulating, hooking, and calling functions in the HL engine.
|- class="t2td"
| *sql_amxx
| SQL/Database scripting functions.
|- class="t2td"
| geoip_amxx
| Functions for finding countries by IP address.
|- class="t2td"
| array_amxx
| Functions for somewhat-dynamic arrays.
|- class="t2td"
| sockets_amxx
| Functions for socket (TCP/UDP) control and manipulation.
|- class="t2td"
| regex_amxx
| Functions for regular expression support.
|}

=CVARs=
The base [[CVAR]]s AMX Mod X defines are located in amxmodx/configs/amxx.cfg. You can edit these the same way you edit the server.cfg file:
:{|
|- class="t2th"
| CVAR
| Default Setting
| Purpose
|- class="t2td"
| amx_default_access
| "z"
| Sets the default access level for non-admin players.
|- class="t2td"
| amx_password_field
| "_pw"
| Name of the setinfo key which a user should store their password in.
|- class="t2td"
| amx_mode
| 1
| Changes the mode of logging into a server: 
0 - Disable logging, players won't be checked and no access will be given. 
1 - Normal mode which obeys flags set in accounts. 
2 - Kick all players not on the users list.
|- class="t2td"
| amx_show_activity
| 2
| Sets the mode of admin activity on the server: 
0 - Disabled 
1 - Show action anonymously 
2 - Show action with the admin's name
|- class="t2td"
| amx_scrollmsg
| "Welcome to %hostname% -- This server is using AMX Mod X" 600
| Sets the parameters (message and frequency) for a scrolling message.
|- class="t2td"
| amx_imessage
| "Welcome to %hostname" "000255100" "This server is using AMX Mod X\nVisit http://www.amxmodx.org" "00010025"
| Adds a center-typed colored message. The last parameter is in RRRGGGBBB format (red, green, blue).
|- class="t2td"
| amx_freq_imessage
| 180
| Frequency, in seconds, of the colored center messages.
|- class="t2td"
| amx_flood_time
| 0.75
| Chat flood prevention. Sets how fast a player can chat (in seconds).
|- class="t2td"
| amx_reservation
| 0
| Sets the amount of reserved slots.
|- class="t2td"
| amx_time_display
| "ab 1200" "ab 600" "ab 300" "ab 180" "ab 60" "bcde 11"
| Sets flags for remaining time display: 
a - Display white text on bottom 
b - Use voice 
c - Don't add "remaining" in voice 
d - Don't add "hours/minutes/seconds" in voice 
e - Show/speak if current time is less than set in parameter
|- class="t2td"
| amx_time_voice
| 1
| Sets whether to announce "say thetime" and "say timeleft" with voice.
|- class="t2td"
| amx_vote_delay
| 10
| Sets the minimum delay in seconds between two voting sessions.
|- class="t2td"
| amx_vote_time
| 10
| Sets how long a voting sessions lasts for.
|- class="t2td"
| amx_vote_answers
| 1
| Displays who votes for which options, publically.
|- class="t2td"
| amx_voteban_ratio
| 0.40
| Ratio for a ban vote to be successful.
|- class="t2td"
| amx_votekick_ratio
| 0.40
| Ratio for a kick vote to be successful.
|- class="t2td"
| amx_votemap_ratio
| 0.40
| Ratio for a map vote to be successful.
|- class="t2td"
| amx_vote_ratio
| 0.40
| Ratio for a general vote to be successful.
|- class="t2td"
| amx_extendmap_max
| 90
| Maximum time a mapvote can be extended.
|- class="t2td"
| amx_extendmap_step
| 15
| Amount of time a map extensions adds.
|- class="t2td"
| amx_client_languages
| 1
| Enables or disables the ability for clients to choose their own language.
|- class="t2td"
| amx_debug
| 1
| Sets the debug mode for plugins: 
0 - No debugging (warning messages for plugin errors) 
1 - Plugins with "debug" option in plugins.ini are put into debug mode. 
2 - All plugins are put into debug mode (full backtraces for errors). 
Note that debug mode greatly decreases JIT performance.
|- class="t2td"
| amx_mldebug
| 0
| Logs multi-lingual translation problems.
|}

=SQL=
Make sure you have mysql_amxx enabled in AMX Mod X's amxmodx/configs/modules.ini file.

Then, open amxmodx/configs/sql.cfg and edit the cvars accordingly:

:{|
|- class="t2th"
| CVAR
| Default Setting
| Purpose
|- class="t2td"
| amx_sql_host
| "127.0.0.1"
| IP address of SQL server.
|- class="t2td"
| amx_sql_user
| "root"
| Username to connect to the SQL server.
|- class="t2td"
| amx_sql_pass
| ""
| Password to connect to the SQL server.
|- class="t2td"
| amx_sql_db
| "amx"
| Database to use on the SQL server.
|- class="t2td"
| amx_sql_table
| "admins"
| The table to use for the admin_sql plugin.
|- class="t2td"
| amx_sql_type
| "mysql"
| The database type to connect to.
|}
*Note: amx_sql_type as of AMXX 1.75

=Maps=

==Map Cycle==
If you use the mapsmenu plugin, you can either use "maps.ini" or "mapcycle.txt" to manage map rotations.

Delete "maps.ini" to use mapcycle.txt, otherwise, simply add a list of map names to maps.ini like so:
<pre>de_dust
cs_assault
de_aztec</pre>

Et cetera.

==Map Config Files==
For each map, you can also add a configuration file that will execute when the map loads. This is useful to set certain settings for 3rd party maps, say, removing the freeze time on fy_iceworld.

To do this, simply create a folder in amxmodx/configs called "maps" and place a .cfg file named after the map with the settings in it, for example, you might have amxmodx/configs/maps/fy_iceworld.cfg:

<pre>
mp_startmoney 16000
mp_freezetime 0
mp_timelimit 20
</pre>

==Map Specific Plugins==
Each map can have a specific plugins.ini file for which it will load on map change. This plugins file will be loaded in addition to the standard plugins.ini file.

The file is to be located at ''amxmodx/configs/maps/plugins-mapname.ini'' For example, for de_dust you would create the file '''amxmodx/configs/maps/plugins-de_dust.ini'''

In addition, a plugin can be tagged as "''disabled''" which will prevent this plugin from being loaded. You accomplish this the same way you tag a plugin as debug mode, by entering the word ''disabled'' after the plugin name in the file, which will prevent it from being loaded for that map.

For example, if you wanted the map de_dust to disable the plugin ''ham.amxx'' and enable the plugin ''pickle.amxx'' you would put this in ''amxmodx/configs/maps/plugins-de_dust.ini'':

<pre>
ham.amxx disabled
pickle.amxx
</pre>

'''Note:''' This feature was added in [[AMX_Mod_X_1.76_Changes|AMX Mod X 1.76]]

=Menus=
==Client Commands==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\clcmds.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
c - execute on selected player. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Slay player" "amx_slay #%userid%" "bd" "u"
|}

==Commands==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\cmds.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
c - execute on selected player. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Pause" "amx_pause" "bd" "u"
|}

==Configs==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\configs.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command.
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "PUBLIC Settings" "servercfgfile server.cfg;exec server.cfg" "a" "u"
|}

==CVARs==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\cvars.ini
|-
| class="t2th" | Format:
| class="t2td" | "CVAR" "Values" ... "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | CVAR - the CVAR's name 
Values - list of space delimited, quotation enclosed values
|-
| class="t2th" | Example:
| class="t2td" | "mp_autoteambalance" "0" "1" "@" "u"
|}

==Speech==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\speech.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console 
b - execute from admin console 
c - execute on selected player 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Hello!" "spk \'vox/hello\'" "cd" "u"
|}

[[Category:Documentation (AMX Mod X)]]

Configuring AMX Mod X

2006-12-10T07:54:27Z

Sawce: /* Map Specific Config Files */

=Admins=
See the section on [[Adding Admins (AMX Mod X)|Adding Admins]] for more information.

=Plugins=
==Installing==
Often, plugins will have their own directions if they need special installation requirements. However, this will instruct you on the basics of adding a plugin.
#Follow any directions the plugin author has given you. If the plugin requires extra steps or special files, make sure you have them in the proper place and order.
#If you are given a .sma source file instead of a .amxx, you must compile the plugin yourself. For more information, see [[Compiling Plugins (AMX Mod X)]].
#Place the plugin's .amxx file in the addons/amxmodx/plugins folder.
#Add the plugin's name to addons\amxmodx\configs\plugins.ini. Example: <pre>myplugin.amxx</pre>
#Change map or restart the server. If the plugin has any load errors, see [[Troubleshooting AMX Mod X#Plugins|Troubleshooting AMX Mod X]].

==Removing==
#Remove the entry from addons\amxmodx\configs\plugins.ini by deleting it or prepending a semi-colon to comment it out.
#Delete any associated files.

==Default Plugins==
:{|
|- class="t2th"
| Plugin
| Purpose
|- class="t2td"
| admin.amxx
| Administration Base
|- class="t2td"
| admin_sql.amxx
| Administration Base for SQL. Use only one base.
|- class="t2td"
| admincmd.amxx
| Basic administration commands (such as kick/slap).
|- class="t2td"
| adminhelp.amxx
| Help for admin commands.
|- class="t2td"
| adminslots.amxx
| Slot reservation.
|- class="t2td"
| multilingual.amxx
| Multi-Lingual client configuration.
|- class="t2td"
| menufront.amxx
| Front-end for admin menus.
|- class="t2td"
| cmdmenu.amxx
| Command menu for settings.
|- class="t2td"
| plmenu.amxx
| Player menu commands (kick, ban, etc).
|- class="t2td"
| telemenu.amxx
| Teleport Menu (fun module required).
|- class="t2td"
| mapsmenu.amxx
| Maps menu (vote, changeleve, etc).
|- class="t2td"
| adminchat.amxx
| Console-based chat commands.
|- class="t2td"
| antiflood.amxx
| Prevents clients from flooding the say chat.
|- class="t2td"
| scrollmsg.amxx
| Displays a scrolling message.
|- class="t2td"
| imessage.amxx
| Displays a centered, timed information message.
|- class="t2td"
| adminvote.amxx
| Voting commands.
|- class="t2td"
| nextmap.amxx
| Displays next map in the mapcycle.
|- class="t2td"
| mapchooser.amxx
| Allows players to vote for the next map.
|- class="t2td"
| timeleft.amxx
| Displays time left on the current map.
|- class="t2td"
| pausecfg.amxx
| Allows pausing/unpausing of plugins.
|- class="t2td"
| statscfg.amxx
| Configuration of statistical plugins.
|}

=Modules=
Modules add additional functionality for plugins to use.
==Installing==
#Figure out what operating system your server is: Windows, Linux, or Linux using AMD64 (64bit).
#If the module is 3rd party, download the module corresponding to your OS. It will end in .dll for Windows, _i386.so for Linux, or _amd64.so for AMD64.
#Place the file in addons/amxmodx/modules/ and follow any additional instructions.
#If the module is already in addons/amxmodx/configs/modules.ini, remove the ';' next to its name to enable it.
#Otherwise, add the module's name to modules.ini. [[AMX Mod X]] supports generic notation, for example: <pre>mysql_amxx</pre> ... will automatically detect the correct module to use.
#To see if the module is working, you can type <tt>amxx modules</tt> in your [[server console]].

==Removing==
#Remove the entry from addons\amxmodx\configs\modules.ini by deleting it or prepending a semi-colon to comment it out.
#Delete any associated files if you don't need them.

==Default Modules==
:{|
|- class="t2th"
| Module
| Purpose
|- class="t2td"
| fun_amxx
| General functions for changing game values.
|- class="t2td"
| engine_amxx
| More advanced functions for getting and setting values in the HL engine.
|- class="t2td"
| fakemeta_amxx
| Expert/advanced functions for manipulating, hooking, and calling functions in the HL engine.
|- class="t2td"
| *sql_amxx
| SQL/Database scripting functions.
|- class="t2td"
| geoip_amxx
| Functions for finding countries by IP address.
|- class="t2td"
| array_amxx
| Functions for somewhat-dynamic arrays.
|- class="t2td"
| sockets_amxx
| Functions for socket (TCP/UDP) control and manipulation.
|- class="t2td"
| regex_amxx
| Functions for regular expression support.
|}

=CVARs=
The base [[CVAR]]s AMX Mod X defines are located in amxmodx/configs/amxx.cfg. You can edit these the same way you edit the server.cfg file:
:{|
|- class="t2th"
| CVAR
| Default Setting
| Purpose
|- class="t2td"
| amx_default_access
| "z"
| Sets the default access level for non-admin players.
|- class="t2td"
| amx_password_field
| "_pw"
| Name of the setinfo key which a user should store their password in.
|- class="t2td"
| amx_mode
| 1
| Changes the mode of logging into a server: 
0 - Disable logging, players won't be checked and no access will be given. 
1 - Normal mode which obeys flags set in accounts. 
2 - Kick all players not on the users list.
|- class="t2td"
| amx_show_activity
| 2
| Sets the mode of admin activity on the server: 
0 - Disabled 
1 - Show action anonymously 
2 - Show action with the admin's name
|- class="t2td"
| amx_scrollmsg
| "Welcome to %hostname% -- This server is using AMX Mod X" 600
| Sets the parameters (message and frequency) for a scrolling message.
|- class="t2td"
| amx_imessage
| "Welcome to %hostname" "000255100" "This server is using AMX Mod X\nVisit http://www.amxmodx.org" "00010025"
| Adds a center-typed colored message. The last parameter is in RRRGGGBBB format (red, green, blue).
|- class="t2td"
| amx_freq_imessage
| 180
| Frequency, in seconds, of the colored center messages.
|- class="t2td"
| amx_flood_time
| 0.75
| Chat flood prevention. Sets how fast a player can chat (in seconds).
|- class="t2td"
| amx_reservation
| 0
| Sets the amount of reserved slots.
|- class="t2td"
| amx_time_display
| "ab 1200" "ab 600" "ab 300" "ab 180" "ab 60" "bcde 11"
| Sets flags for remaining time display: 
a - Display white text on bottom 
b - Use voice 
c - Don't add "remaining" in voice 
d - Don't add "hours/minutes/seconds" in voice 
e - Show/speak if current time is less than set in parameter
|- class="t2td"
| amx_time_voice
| 1
| Sets whether to announce "say thetime" and "say timeleft" with voice.
|- class="t2td"
| amx_vote_delay
| 10
| Sets the minimum delay in seconds between two voting sessions.
|- class="t2td"
| amx_vote_time
| 10
| Sets how long a voting sessions lasts for.
|- class="t2td"
| amx_vote_answers
| 1
| Displays who votes for which options, publically.
|- class="t2td"
| amx_voteban_ratio
| 0.40
| Ratio for a ban vote to be successful.
|- class="t2td"
| amx_votekick_ratio
| 0.40
| Ratio for a kick vote to be successful.
|- class="t2td"
| amx_votemap_ratio
| 0.40
| Ratio for a map vote to be successful.
|- class="t2td"
| amx_vote_ratio
| 0.40
| Ratio for a general vote to be successful.
|- class="t2td"
| amx_extendmap_max
| 90
| Maximum time a mapvote can be extended.
|- class="t2td"
| amx_extendmap_step
| 15
| Amount of time a map extensions adds.
|- class="t2td"
| amx_client_languages
| 1
| Enables or disables the ability for clients to choose their own language.
|- class="t2td"
| amx_debug
| 1
| Sets the debug mode for plugins: 
0 - No debugging (warning messages for plugin errors) 
1 - Plugins with "debug" option in plugins.ini are put into debug mode. 
2 - All plugins are put into debug mode (full backtraces for errors). 
Note that debug mode greatly decreases JIT performance.
|- class="t2td"
| amx_mldebug
| 0
| Logs multi-lingual translation problems.
|}

=SQL=
Make sure you have mysql_amxx enabled in AMX Mod X's amxmodx/configs/modules.ini file.

Then, open amxmodx/configs/sql.cfg and edit the cvars accordingly:

:{|
|- class="t2th"
| CVAR
| Default Setting
| Purpose
|- class="t2td"
| amx_sql_host
| "127.0.0.1"
| IP address of SQL server.
|- class="t2td"
| amx_sql_user
| "root"
| Username to connect to the SQL server.
|- class="t2td"
| amx_sql_pass
| ""
| Password to connect to the SQL server.
|- class="t2td"
| amx_sql_db
| "amx"
| Database to use on the SQL server.
|- class="t2td"
| amx_sql_table
| "admins"
| The table to use for the admin_sql plugin.
|- class="t2td"
| amx_sql_type
| "mysql"
| The database type to connect to.
|}
*Note: amx_sql_type as of AMXX 1.75

=Maps=

==Map Cycle==
If you use the mapsmenu plugin, you can either use "maps.ini" or "mapcycle.txt" to manage map rotations.

Delete "maps.ini" to use mapcycle.txt, otherwise, simply add a list of map names to maps.ini like so:
<pre>de_dust
cs_assault
de_aztec</pre>

Et cetera.

==Map Config Files==
For each map, you can also add a configuration file that will execute when the map loads. This is useful to set certain settings for 3rd party maps, say, removing the freeze time on fy_iceworld.

To do this, simply create a folder in amxmodx/configs called "maps" and place a .cfg file named after the map with the settings in it, for example, you might have amxmodx/configs/maps/fy_iceworld.cfg:

<pre>
mp_startmoney 16000
mp_freezetime 0
mp_timelimit 20
</pre>

==Map Specific Plugins==
Each map can have a specific plugins.ini file for which it will load on map change.

The file is to be located at ''amxmodx/configs/maps/plugins-mapname.ini'' For example, for de_dust you would create the file '''amxmodx/configs/maps/plugins-de_dust.ini'''

In addition, a plugin can be tagged as "''disabled''" which will prevent this plugin from being loaded. You accomplish this the same way you tag a plugin as debug mode, by entering the word ''disabled'' after the plugin name in the file, which will prevent it from being loaded for that map.

For example, if you wanted the map de_dust to disable the plugin ''ham.amxx'' and enable the plugin ''pickle.amxx'' you would put this in ''amxmodx/configs/maps/plugins-de_dust.ini'':

<pre>
ham.amxx disabled
pickle.amxx
</pre>

'''Note:''' This feature was added in [[AMX_Mod_X_1.76_Changes|AMX Mod X 1.76]]

=Menus=
==Client Commands==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\clcmds.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
c - execute on selected player. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Slay player" "amx_slay #%userid%" "bd" "u"
|}

==Commands==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\cmds.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
c - execute on selected player. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Pause" "amx_pause" "bd" "u"
|}

==Configs==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\configs.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command.
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "PUBLIC Settings" "servercfgfile server.cfg;exec server.cfg" "a" "u"
|}

==CVARs==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\cvars.ini
|-
| class="t2th" | Format:
| class="t2td" | "CVAR" "Values" ... "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | CVAR - the CVAR's name 
Values - list of space delimited, quotation enclosed values
|-
| class="t2th" | Example:
| class="t2td" | "mp_autoteambalance" "0" "1" "@" "u"
|}

==Speech==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\speech.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console 
b - execute from admin console 
c - execute on selected player 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Hello!" "spk \'vox/hello\'" "cd" "u"
|}

[[Category:Documentation (AMX Mod X)]]

Configuring AMX Mod X

2006-12-10T07:52:08Z

Sawce: /* Map Specific Plugins */

=Admins=
See the section on [[Adding Admins (AMX Mod X)|Adding Admins]] for more information.

=Plugins=
==Installing==
Often, plugins will have their own directions if they need special installation requirements. However, this will instruct you on the basics of adding a plugin.
#Follow any directions the plugin author has given you. If the plugin requires extra steps or special files, make sure you have them in the proper place and order.
#If you are given a .sma source file instead of a .amxx, you must compile the plugin yourself. For more information, see [[Compiling Plugins (AMX Mod X)]].
#Place the plugin's .amxx file in the addons/amxmodx/plugins folder.
#Add the plugin's name to addons\amxmodx\configs\plugins.ini. Example: <pre>myplugin.amxx</pre>
#Change map or restart the server. If the plugin has any load errors, see [[Troubleshooting AMX Mod X#Plugins|Troubleshooting AMX Mod X]].

==Removing==
#Remove the entry from addons\amxmodx\configs\plugins.ini by deleting it or prepending a semi-colon to comment it out.
#Delete any associated files.

==Default Plugins==
:{|
|- class="t2th"
| Plugin
| Purpose
|- class="t2td"
| admin.amxx
| Administration Base
|- class="t2td"
| admin_sql.amxx
| Administration Base for SQL. Use only one base.
|- class="t2td"
| admincmd.amxx
| Basic administration commands (such as kick/slap).
|- class="t2td"
| adminhelp.amxx
| Help for admin commands.
|- class="t2td"
| adminslots.amxx
| Slot reservation.
|- class="t2td"
| multilingual.amxx
| Multi-Lingual client configuration.
|- class="t2td"
| menufront.amxx
| Front-end for admin menus.
|- class="t2td"
| cmdmenu.amxx
| Command menu for settings.
|- class="t2td"
| plmenu.amxx
| Player menu commands (kick, ban, etc).
|- class="t2td"
| telemenu.amxx
| Teleport Menu (fun module required).
|- class="t2td"
| mapsmenu.amxx
| Maps menu (vote, changeleve, etc).
|- class="t2td"
| adminchat.amxx
| Console-based chat commands.
|- class="t2td"
| antiflood.amxx
| Prevents clients from flooding the say chat.
|- class="t2td"
| scrollmsg.amxx
| Displays a scrolling message.
|- class="t2td"
| imessage.amxx
| Displays a centered, timed information message.
|- class="t2td"
| adminvote.amxx
| Voting commands.
|- class="t2td"
| nextmap.amxx
| Displays next map in the mapcycle.
|- class="t2td"
| mapchooser.amxx
| Allows players to vote for the next map.
|- class="t2td"
| timeleft.amxx
| Displays time left on the current map.
|- class="t2td"
| pausecfg.amxx
| Allows pausing/unpausing of plugins.
|- class="t2td"
| statscfg.amxx
| Configuration of statistical plugins.
|}

=Modules=
Modules add additional functionality for plugins to use.
==Installing==
#Figure out what operating system your server is: Windows, Linux, or Linux using AMD64 (64bit).
#If the module is 3rd party, download the module corresponding to your OS. It will end in .dll for Windows, _i386.so for Linux, or _amd64.so for AMD64.
#Place the file in addons/amxmodx/modules/ and follow any additional instructions.
#If the module is already in addons/amxmodx/configs/modules.ini, remove the ';' next to its name to enable it.
#Otherwise, add the module's name to modules.ini. [[AMX Mod X]] supports generic notation, for example: <pre>mysql_amxx</pre> ... will automatically detect the correct module to use.
#To see if the module is working, you can type <tt>amxx modules</tt> in your [[server console]].

==Removing==
#Remove the entry from addons\amxmodx\configs\modules.ini by deleting it or prepending a semi-colon to comment it out.
#Delete any associated files if you don't need them.

==Default Modules==
:{|
|- class="t2th"
| Module
| Purpose
|- class="t2td"
| fun_amxx
| General functions for changing game values.
|- class="t2td"
| engine_amxx
| More advanced functions for getting and setting values in the HL engine.
|- class="t2td"
| fakemeta_amxx
| Expert/advanced functions for manipulating, hooking, and calling functions in the HL engine.
|- class="t2td"
| *sql_amxx
| SQL/Database scripting functions.
|- class="t2td"
| geoip_amxx
| Functions for finding countries by IP address.
|- class="t2td"
| array_amxx
| Functions for somewhat-dynamic arrays.
|- class="t2td"
| sockets_amxx
| Functions for socket (TCP/UDP) control and manipulation.
|- class="t2td"
| regex_amxx
| Functions for regular expression support.
|}

=CVARs=
The base [[CVAR]]s AMX Mod X defines are located in amxmodx/configs/amxx.cfg. You can edit these the same way you edit the server.cfg file:
:{|
|- class="t2th"
| CVAR
| Default Setting
| Purpose
|- class="t2td"
| amx_default_access
| "z"
| Sets the default access level for non-admin players.
|- class="t2td"
| amx_password_field
| "_pw"
| Name of the setinfo key which a user should store their password in.
|- class="t2td"
| amx_mode
| 1
| Changes the mode of logging into a server: 
0 - Disable logging, players won't be checked and no access will be given. 
1 - Normal mode which obeys flags set in accounts. 
2 - Kick all players not on the users list.
|- class="t2td"
| amx_show_activity
| 2
| Sets the mode of admin activity on the server: 
0 - Disabled 
1 - Show action anonymously 
2 - Show action with the admin's name
|- class="t2td"
| amx_scrollmsg
| "Welcome to %hostname% -- This server is using AMX Mod X" 600
| Sets the parameters (message and frequency) for a scrolling message.
|- class="t2td"
| amx_imessage
| "Welcome to %hostname" "000255100" "This server is using AMX Mod X\nVisit http://www.amxmodx.org" "00010025"
| Adds a center-typed colored message. The last parameter is in RRRGGGBBB format (red, green, blue).
|- class="t2td"
| amx_freq_imessage
| 180
| Frequency, in seconds, of the colored center messages.
|- class="t2td"
| amx_flood_time
| 0.75
| Chat flood prevention. Sets how fast a player can chat (in seconds).
|- class="t2td"
| amx_reservation
| 0
| Sets the amount of reserved slots.
|- class="t2td"
| amx_time_display
| "ab 1200" "ab 600" "ab 300" "ab 180" "ab 60" "bcde 11"
| Sets flags for remaining time display: 
a - Display white text on bottom 
b - Use voice 
c - Don't add "remaining" in voice 
d - Don't add "hours/minutes/seconds" in voice 
e - Show/speak if current time is less than set in parameter
|- class="t2td"
| amx_time_voice
| 1
| Sets whether to announce "say thetime" and "say timeleft" with voice.
|- class="t2td"
| amx_vote_delay
| 10
| Sets the minimum delay in seconds between two voting sessions.
|- class="t2td"
| amx_vote_time
| 10
| Sets how long a voting sessions lasts for.
|- class="t2td"
| amx_vote_answers
| 1
| Displays who votes for which options, publically.
|- class="t2td"
| amx_voteban_ratio
| 0.40
| Ratio for a ban vote to be successful.
|- class="t2td"
| amx_votekick_ratio
| 0.40
| Ratio for a kick vote to be successful.
|- class="t2td"
| amx_votemap_ratio
| 0.40
| Ratio for a map vote to be successful.
|- class="t2td"
| amx_vote_ratio
| 0.40
| Ratio for a general vote to be successful.
|- class="t2td"
| amx_extendmap_max
| 90
| Maximum time a mapvote can be extended.
|- class="t2td"
| amx_extendmap_step
| 15
| Amount of time a map extensions adds.
|- class="t2td"
| amx_client_languages
| 1
| Enables or disables the ability for clients to choose their own language.
|- class="t2td"
| amx_debug
| 1
| Sets the debug mode for plugins: 
0 - No debugging (warning messages for plugin errors) 
1 - Plugins with "debug" option in plugins.ini are put into debug mode. 
2 - All plugins are put into debug mode (full backtraces for errors). 
Note that debug mode greatly decreases JIT performance.
|- class="t2td"
| amx_mldebug
| 0
| Logs multi-lingual translation problems.
|}

=SQL=
Make sure you have mysql_amxx enabled in AMX Mod X's amxmodx/configs/modules.ini file.

Then, open amxmodx/configs/sql.cfg and edit the cvars accordingly:

:{|
|- class="t2th"
| CVAR
| Default Setting
| Purpose
|- class="t2td"
| amx_sql_host
| "127.0.0.1"
| IP address of SQL server.
|- class="t2td"
| amx_sql_user
| "root"
| Username to connect to the SQL server.
|- class="t2td"
| amx_sql_pass
| ""
| Password to connect to the SQL server.
|- class="t2td"
| amx_sql_db
| "amx"
| Database to use on the SQL server.
|- class="t2td"
| amx_sql_table
| "admins"
| The table to use for the admin_sql plugin.
|- class="t2td"
| amx_sql_type
| "mysql"
| The database type to connect to.
|}
*Note: amx_sql_type as of AMXX 1.75

=Maps=

==Map Cycle==
If you use the mapsmenu plugin, you can either use "maps.ini" or "mapcycle.txt" to manage map rotations.

Delete "maps.ini" to use mapcycle.txt, otherwise, simply add a list of map names to maps.ini like so:
<pre>de_dust
cs_assault
de_aztec</pre>

Et cetera.

==Map Specific Config Files==
For each map, you can also add a configuration file that will execute when the map loads. This is useful to set certain settings for 3rd party maps, say, removing the freeze time on fy_iceworld.

To do this, simply create a folder in amxmodx/configs called "maps" and place a .cfg file named after the map with the settings in it, for example, you might have amxmodx/configs/maps/fy_iceworld.cfg:

<pre>
mp_startmoney 16000
mp_freezetime 0
mp_timelimit 20
</pre>

==Map Specific Plugins==
Each map can have a specific plugins.ini file for which it will load on map change.

The file is to be located at ''amxmodx/configs/maps/plugins-mapname.ini'' For example, for de_dust you would create the file '''amxmodx/configs/maps/plugins-de_dust.ini'''

In addition, a plugin can be tagged as "''disabled''" which will prevent this plugin from being loaded. You accomplish this the same way you tag a plugin as debug mode, by entering the word ''disabled'' after the plugin name in the file, which will prevent it from being loaded for that map.

For example, if you wanted the map de_dust to disable the plugin ''ham.amxx'' and enable the plugin ''pickle.amxx'' you would put this in ''amxmodx/configs/maps/plugins-de_dust.ini'':

<pre>
ham.amxx disabled
pickle.amxx
</pre>

'''Note:''' This feature was added in [[AMX_Mod_X_1.76_Changes|AMX Mod X 1.76]]

=Menus=
==Client Commands==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\clcmds.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
c - execute on selected player. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Slay player" "amx_slay #%userid%" "bd" "u"
|}

==Commands==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\cmds.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
c - execute on selected player. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Pause" "amx_pause" "bd" "u"
|}

==Configs==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\configs.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command.
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "PUBLIC Settings" "servercfgfile server.cfg;exec server.cfg" "a" "u"
|}

==CVARs==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\cvars.ini
|-
| class="t2th" | Format:
| class="t2td" | "CVAR" "Values" ... "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | CVAR - the CVAR's name 
Values - list of space delimited, quotation enclosed values
|-
| class="t2th" | Example:
| class="t2td" | "mp_autoteambalance" "0" "1" "@" "u"
|}

==Speech==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\speech.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console 
b - execute from admin console 
c - execute on selected player 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Hello!" "spk \'vox/hello\'" "cd" "u"
|}

[[Category:Documentation (AMX Mod X)]]

Configuring AMX Mod X

2006-12-10T07:47:03Z

Sawce: /* Maps */

=Admins=
See the section on [[Adding Admins (AMX Mod X)|Adding Admins]] for more information.

=Plugins=
==Installing==
Often, plugins will have their own directions if they need special installation requirements. However, this will instruct you on the basics of adding a plugin.
#Follow any directions the plugin author has given you. If the plugin requires extra steps or special files, make sure you have them in the proper place and order.
#If you are given a .sma source file instead of a .amxx, you must compile the plugin yourself. For more information, see [[Compiling Plugins (AMX Mod X)]].
#Place the plugin's .amxx file in the addons/amxmodx/plugins folder.
#Add the plugin's name to addons\amxmodx\configs\plugins.ini. Example: <pre>myplugin.amxx</pre>
#Change map or restart the server. If the plugin has any load errors, see [[Troubleshooting AMX Mod X#Plugins|Troubleshooting AMX Mod X]].

==Removing==
#Remove the entry from addons\amxmodx\configs\plugins.ini by deleting it or prepending a semi-colon to comment it out.
#Delete any associated files.

==Default Plugins==
:{|
|- class="t2th"
| Plugin
| Purpose
|- class="t2td"
| admin.amxx
| Administration Base
|- class="t2td"
| admin_sql.amxx
| Administration Base for SQL. Use only one base.
|- class="t2td"
| admincmd.amxx
| Basic administration commands (such as kick/slap).
|- class="t2td"
| adminhelp.amxx
| Help for admin commands.
|- class="t2td"
| adminslots.amxx
| Slot reservation.
|- class="t2td"
| multilingual.amxx
| Multi-Lingual client configuration.
|- class="t2td"
| menufront.amxx
| Front-end for admin menus.
|- class="t2td"
| cmdmenu.amxx
| Command menu for settings.
|- class="t2td"
| plmenu.amxx
| Player menu commands (kick, ban, etc).
|- class="t2td"
| telemenu.amxx
| Teleport Menu (fun module required).
|- class="t2td"
| mapsmenu.amxx
| Maps menu (vote, changeleve, etc).
|- class="t2td"
| adminchat.amxx
| Console-based chat commands.
|- class="t2td"
| antiflood.amxx
| Prevents clients from flooding the say chat.
|- class="t2td"
| scrollmsg.amxx
| Displays a scrolling message.
|- class="t2td"
| imessage.amxx
| Displays a centered, timed information message.
|- class="t2td"
| adminvote.amxx
| Voting commands.
|- class="t2td"
| nextmap.amxx
| Displays next map in the mapcycle.
|- class="t2td"
| mapchooser.amxx
| Allows players to vote for the next map.
|- class="t2td"
| timeleft.amxx
| Displays time left on the current map.
|- class="t2td"
| pausecfg.amxx
| Allows pausing/unpausing of plugins.
|- class="t2td"
| statscfg.amxx
| Configuration of statistical plugins.
|}

=Modules=
Modules add additional functionality for plugins to use.
==Installing==
#Figure out what operating system your server is: Windows, Linux, or Linux using AMD64 (64bit).
#If the module is 3rd party, download the module corresponding to your OS. It will end in .dll for Windows, _i386.so for Linux, or _amd64.so for AMD64.
#Place the file in addons/amxmodx/modules/ and follow any additional instructions.
#If the module is already in addons/amxmodx/configs/modules.ini, remove the ';' next to its name to enable it.
#Otherwise, add the module's name to modules.ini. [[AMX Mod X]] supports generic notation, for example: <pre>mysql_amxx</pre> ... will automatically detect the correct module to use.
#To see if the module is working, you can type <tt>amxx modules</tt> in your [[server console]].

==Removing==
#Remove the entry from addons\amxmodx\configs\modules.ini by deleting it or prepending a semi-colon to comment it out.
#Delete any associated files if you don't need them.

==Default Modules==
:{|
|- class="t2th"
| Module
| Purpose
|- class="t2td"
| fun_amxx
| General functions for changing game values.
|- class="t2td"
| engine_amxx
| More advanced functions for getting and setting values in the HL engine.
|- class="t2td"
| fakemeta_amxx
| Expert/advanced functions for manipulating, hooking, and calling functions in the HL engine.
|- class="t2td"
| *sql_amxx
| SQL/Database scripting functions.
|- class="t2td"
| geoip_amxx
| Functions for finding countries by IP address.
|- class="t2td"
| array_amxx
| Functions for somewhat-dynamic arrays.
|- class="t2td"
| sockets_amxx
| Functions for socket (TCP/UDP) control and manipulation.
|- class="t2td"
| regex_amxx
| Functions for regular expression support.
|}

=CVARs=
The base [[CVAR]]s AMX Mod X defines are located in amxmodx/configs/amxx.cfg. You can edit these the same way you edit the server.cfg file:
:{|
|- class="t2th"
| CVAR
| Default Setting
| Purpose
|- class="t2td"
| amx_default_access
| "z"
| Sets the default access level for non-admin players.
|- class="t2td"
| amx_password_field
| "_pw"
| Name of the setinfo key which a user should store their password in.
|- class="t2td"
| amx_mode
| 1
| Changes the mode of logging into a server: 
0 - Disable logging, players won't be checked and no access will be given. 
1 - Normal mode which obeys flags set in accounts. 
2 - Kick all players not on the users list.
|- class="t2td"
| amx_show_activity
| 2
| Sets the mode of admin activity on the server: 
0 - Disabled 
1 - Show action anonymously 
2 - Show action with the admin's name
|- class="t2td"
| amx_scrollmsg
| "Welcome to %hostname% -- This server is using AMX Mod X" 600
| Sets the parameters (message and frequency) for a scrolling message.
|- class="t2td"
| amx_imessage
| "Welcome to %hostname" "000255100" "This server is using AMX Mod X\nVisit http://www.amxmodx.org" "00010025"
| Adds a center-typed colored message. The last parameter is in RRRGGGBBB format (red, green, blue).
|- class="t2td"
| amx_freq_imessage
| 180
| Frequency, in seconds, of the colored center messages.
|- class="t2td"
| amx_flood_time
| 0.75
| Chat flood prevention. Sets how fast a player can chat (in seconds).
|- class="t2td"
| amx_reservation
| 0
| Sets the amount of reserved slots.
|- class="t2td"
| amx_time_display
| "ab 1200" "ab 600" "ab 300" "ab 180" "ab 60" "bcde 11"
| Sets flags for remaining time display: 
a - Display white text on bottom 
b - Use voice 
c - Don't add "remaining" in voice 
d - Don't add "hours/minutes/seconds" in voice 
e - Show/speak if current time is less than set in parameter
|- class="t2td"
| amx_time_voice
| 1
| Sets whether to announce "say thetime" and "say timeleft" with voice.
|- class="t2td"
| amx_vote_delay
| 10
| Sets the minimum delay in seconds between two voting sessions.
|- class="t2td"
| amx_vote_time
| 10
| Sets how long a voting sessions lasts for.
|- class="t2td"
| amx_vote_answers
| 1
| Displays who votes for which options, publically.
|- class="t2td"
| amx_voteban_ratio
| 0.40
| Ratio for a ban vote to be successful.
|- class="t2td"
| amx_votekick_ratio
| 0.40
| Ratio for a kick vote to be successful.
|- class="t2td"
| amx_votemap_ratio
| 0.40
| Ratio for a map vote to be successful.
|- class="t2td"
| amx_vote_ratio
| 0.40
| Ratio for a general vote to be successful.
|- class="t2td"
| amx_extendmap_max
| 90
| Maximum time a mapvote can be extended.
|- class="t2td"
| amx_extendmap_step
| 15
| Amount of time a map extensions adds.
|- class="t2td"
| amx_client_languages
| 1
| Enables or disables the ability for clients to choose their own language.
|- class="t2td"
| amx_debug
| 1
| Sets the debug mode for plugins: 
0 - No debugging (warning messages for plugin errors) 
1 - Plugins with "debug" option in plugins.ini are put into debug mode. 
2 - All plugins are put into debug mode (full backtraces for errors). 
Note that debug mode greatly decreases JIT performance.
|- class="t2td"
| amx_mldebug
| 0
| Logs multi-lingual translation problems.
|}

=SQL=
Make sure you have mysql_amxx enabled in AMX Mod X's amxmodx/configs/modules.ini file.

Then, open amxmodx/configs/sql.cfg and edit the cvars accordingly:

:{|
|- class="t2th"
| CVAR
| Default Setting
| Purpose
|- class="t2td"
| amx_sql_host
| "127.0.0.1"
| IP address of SQL server.
|- class="t2td"
| amx_sql_user
| "root"
| Username to connect to the SQL server.
|- class="t2td"
| amx_sql_pass
| ""
| Password to connect to the SQL server.
|- class="t2td"
| amx_sql_db
| "amx"
| Database to use on the SQL server.
|- class="t2td"
| amx_sql_table
| "admins"
| The table to use for the admin_sql plugin.
|- class="t2td"
| amx_sql_type
| "mysql"
| The database type to connect to.
|}
*Note: amx_sql_type as of AMXX 1.75

=Maps=

==Map Cycle==
If you use the mapsmenu plugin, you can either use "maps.ini" or "mapcycle.txt" to manage map rotations.

Delete "maps.ini" to use mapcycle.txt, otherwise, simply add a list of map names to maps.ini like so:
<pre>de_dust
cs_assault
de_aztec</pre>

Et cetera.

==Map Specific Config Files==
For each map, you can also add a configuration file that will execute when the map loads. This is useful to set certain settings for 3rd party maps, say, removing the freeze time on fy_iceworld.

To do this, simply create a folder in amxmodx/configs called "maps" and place a .cfg file named after the map with the settings in it, for example, you might have amxmodx/configs/maps/fy_iceworld.cfg:

<pre>
mp_startmoney 16000
mp_freezetime 0
mp_timelimit 20
</pre>

==Map Specific Plugins==
Each map can have a specific plugins.ini file for which it will load on map change.

The file is to be located at ''amxmodx/configs/maps/plugins-mapname.ini'' For example, for de_dust you would create the file '''amxmodx/configs/maps/plugins-de_dust.ini'''

In addition, a plugin can be tagged as "''disabled''" which will prevent this plugin from being loaded. You accomplish this the same way you tag a plugin as debug mode, by entering the word ''disabled'' after the plugin name in the file, which will prevent it from being loaded for that map.

For example, if you wanted the map de_dust to disable the plugin ''ham.amxx'' and enable the plugin ''pickle.amxx'' you would put this in ''amxmodx/configs/maps/plugins-de_dust.ini'':

<pre>
ham.amxx disabled
pickle.amxx
</pre>

=Menus=
==Client Commands==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\clcmds.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
c - execute on selected player. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Slay player" "amx_slay #%userid%" "bd" "u"
|}

==Commands==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\cmds.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
c - execute on selected player. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Pause" "amx_pause" "bd" "u"
|}

==Configs==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\configs.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command.
Flags are one of the following: 
a - execute from server console. 
b - execute from admin console. 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "PUBLIC Settings" "servercfgfile server.cfg;exec server.cfg" "a" "u"
|}

==CVARs==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\cvars.ini
|-
| class="t2th" | Format:
| class="t2td" | "CVAR" "Values" ... "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | CVAR - the CVAR's name 
Values - list of space delimited, quotation enclosed values
|-
| class="t2th" | Example:
| class="t2td" | "mp_autoteambalance" "0" "1" "@" "u"
|}

==Speech==
:{|
|-
| class="t2th" | File:
| class="t2td" | addons\amxmodx\configs\speech.ini
|-
| class="t2th" | Format:
| class="t2td" | "Name" "Command" "Flags" "Access Level"
|-
| class="t2th" | Options:
| class="t2td" | Name is the name that will appear on the menu. 
Command is the format for the console command - you can use %userid% to insert the user's id. 
Flags are one of the following: 
a - execute from server console 
b - execute from admin console 
c - execute on selected player 
d - display menu again once done
|-
| class="t2th" | Example:
| class="t2td" | "Hello!" "spk \'vox/hello\'" "cd" "u"
|}

[[Category:Documentation (AMX Mod X)]]