@amxts/core 0.1.0

package/amxmodx/base/include/amxmodx.inc

@@ -0,0 +1,3447 @@
+// vim: set ts=4 sw=4 tw=99 noet:
+//
+// AMX Mod X, based on AMX Mod by Aleksander Naszko ("OLO").
+// Copyright (C) The AMX Mod X Development Team.
+//
+// This software is licensed under the GNU General Public License, version 3 or higher.
+// Additional exceptions apply. For full license details, see LICENSE.txt or visit:
+//     https://alliedmods.net/amxmodx-license
+
+#if defined _amxmodx_included
+	#endinput
+#endif
+#define _amxmodx_included
+
+#include <core>
+#include <float>
+#include <amxconst>
+#include <string>
+#include <file>
+#include <vault>
+#include <lang>
+#include <messages>
+#include <vector>
+#include <sorting>
+#include <cellarray>
+#include <cellstack>
+#include <celltrie>
+#include <datapack>
+#include <newmenus>
+#include <textparse_smc>
+#include <textparse_ini>
+#include <cvars>
+#include <gameconfig>
+
+/**
+ * Called just after server activation.
+ *
+ * @note Good place to initialize most of the plugin, such as registering
+ *       cvars, commands or forwards, creating data structures for later use, or
+ *       generating and loading other required configurations.
+ *
+ * @noreturn
+ */
+forward plugin_init();
+
+/**
+ * Called just before the plugin is paused from execution.
+ *
+ * @noreturn
+ */
+forward plugin_pause();
+
+/**
+ * Called just after the plugin is unpaused.
+ *
+ * @noreturn
+ */
+forward plugin_unpause();
+
+/**
+ * Called when the mod tries to change the map.
+ *
+ * @note This is *only* called if the mod itself handles the map change. The
+ *       server command "changelevel", which is used by many plugins, will not
+ *       trigger this forward. Unfortunately, this means that in practice this
+ *       forward can be unreliable and will not be called in many situations.
+ * @note AMXX 1.8.3 has added the engine_changelevel() function, which will utilize
+ *       the correct engine function to change the map, and therefore trigger
+ *       this forward.
+ *
+ * @param map   Map that the mod tries to change to
+ *
+ * @return      PLUGIN_CONTINUE to let the mod change the map
+ *              PLUGIN_HANDLED or higher to prevent the map change
+ */
+forward server_changelevel(map[]);
+
+/**
+ * Called when all plugins went through plugin_init()
+ *
+ * @note When this forward is called, most plugins should have registered their
+ *       cvars and commands already.
+ *
+ * @noreturn
+ */
+forward plugin_cfg();
+
+/**
+ * Called just before server deactivation and subsequent unloading of the
+ * plugin.
+ *
+ * @note The plugin is required to manually free Handles it has acquired, such
+ *       as those from dynamic data structures. Failing to do that will result
+ *       in the plugin and AMXX leaking memory.
+ *
+ * @noreturn
+ */
+forward plugin_end();
+
+/**
+ * Called when a message is about to be logged.
+ *
+ * @note Message data and information can be retrieved using the read_log* set
+ *       of functions.
+ *
+ * @return      PLUGIN_CONTINUE to let the log message through
+ *              PLUGIN_HANDLED or higher to stop the log message
+ */
+forward plugin_log();
+
+/**
+ * This forward allows plugins to add models, sounds and generic files to the
+ * precache tables using the precache_* set of functions.
+ *
+ * @note Adding files to the precaching tables will trigger the client to
+ *       download them to its local filesystem.
+ * @note There is a hard upper limit of entries in the precaching tables for
+ *       every game, this limit is 512 in most cases. The entries will be filled
+ *       and indexed incrementally. Going over this limit will crash the server.
+ *
+ * @noreturn
+ */
+forward plugin_precache();
+
+/**
+ * Called when a clients info has changed.
+ *
+ * @param id    Client index
+ *
+ * @noreturn
+ */
+forward client_infochanged(id);
+
+/**
+ * Called when a client is connecting.
+ *
+ * @note This forward is called too early to do anything that directly affects
+ *       the client.
+ *
+ * @param id    Client index
+ *
+ * @noreturn
+ */
+forward client_connect(id);
+
+/**
+ * Called when a client is connecting.
+ *
+ * @note This forward is called too early to do anything that directly affects
+ *       the client.
+ *
+ * @param id        Client index
+ * @param name      Client name
+ * @param ip        Client ip address with port
+ * @param reason    A reason that will be displayed when player gets rejected (can be overwritten)
+ *
+ * @return          PLUGIN_CONTINUE to let a client join to the server
+ *                  PLUGIN_HANDLED or higher to prevent a client to join
+ */
+forward client_connectex(id, const name[], const ip[], reason[128]);
+
+/**
+ * Called when the client gets a valid SteamID.
+ *
+ * @note This may occur before or after client_putinserver has been called.
+ * @note This is called for bots, and the SteamID will be "BOT".
+ *
+ * @param id		Client index
+ * @param authid	Client auth
+ *
+ * @noreturn
+ */
+forward client_authorized(id, const authid[]);
+
+/**
+ * @deprecated This function does not catch all cases.
+ */
+#pragma deprecated Use client_disconnected() instead.
+forward client_disconnect(id);
+
+/**
+ * Called when a client is disconnected from the server.
+ *
+ * @note This will be called in some additional cases that client_disconnect doesn't cover, 
+ *       most notably when a client aborts the connection process. It is guaranteed to pair 
+ *       with the client_connect() forward.
+ * @note When this fires the player entity is still valid (e.g. is_user_connected(id) will 
+ *       return true), but no networked commands will reach the client.
+ *
+ * @param id         Client index
+ * @param drop       If true, the game has explicitly dropped the client
+ * @param message    If drop is true, a writable buffer containing the disconnect info message
+ * @param maxlen     Maximum size of buffer
+ *
+ * @noreturn
+ */
+forward client_disconnected(id, bool:drop, message[], maxlen);
+
+/**
+ * Called when a client entity has been removed from the server.
+ *
+ * @note This fires after the client_disconnected() forward, when the player entity has been
+ *       removed (e.g. is_user_connected(id) will return false).
+ *
+ * @param id         Client index
+ * @param drop       If true, the game has explicitly dropped the client
+ * @param message    If drop is true, contains the disconnect info message
+ *
+ * @noreturn
+ */
+forward client_remove(id, bool:drop, const message[]);
+
+
+/**
+ * Called when a client attempts to execute a command.
+ *
+ * @note The command and its arguments can be read using the read_arg* set of
+ *       functions.
+ *
+ * @param id    Client index
+ *
+ * @return      PLUGIN_CONTINUE to let the client execute the command
+ *              PLUGIN_HANDLED or higher to stop the command
+ */
+forward client_command(id);
+
+/**
+ * Called when a client is entering the game.
+ *
+ * @note It is not defined whether the client already has a SteamID when this
+ *       forward is called. client_authorized may occur either before or after
+ *       this.
+ *
+ * @param id    Client index
+ *
+ * @noreturn
+ */
+forward client_putinserver(id);
+
+/**
+ * Sets informations about the calling plugin.
+ *
+ * @param plugin_name   Name of the plugin
+ * @param version       Version of the plugin
+ * @param author        Author of the plugin
+ * @param url           URL of the plugin
+ * @param description   Description of the plugin
+ *
+ * @return              Plugin id of the calling plugin
+ */
+native register_plugin(const plugin_name[], const version[], const author[], const url[] = "", const description[] = "");
+
+/**
+ * Precaches a model file.
+ *
+ * @note Can only be used inside of the plugin_precache() forward.
+ *
+ * @param name  Path to the model file
+ *
+ * @return      Unique cache id of the model
+ * @error       If called outside of the plugin_precache() forward, an error is
+ *              thrown.
+ */
+native precache_model(const name[]);
+
+/**
+ * Precaches a sound file.
+ *
+ * @note Can only be used inside of the plugin_precache() forward.
+ * @note The filepath is always relative to the "sound" folder, and the file has
+ *       to be a wav file. Precaching a file with this will add it to the engine
+ *       sound table, making it available for usage in emit_sound() for example.
+ * @note Precaching other filetypes (such as mp3 music), optionally in different
+ *       locations, has to be done with precache_generic()
+ *
+ * @param name  Path to the sound file
+ *
+ * @return      Unique cache id of the sound
+ * @error       If called outside of the plugin_precache() forward, an error is
+ *              thrown.
+ */
+native precache_sound(const name[]);
+
+/**
+ * Precaches a generic file.
+ *
+ * @note Can only be used inside of the plugin_precache() forward.
+ * @note Precaching sounds with this will not add them to the engine sound table.
+ *
+ * @param szFile    Path to the file
+ *
+ * @return          Unique cache id of the file
+ * @error           If called outside of the plugin_precache() forward, an error
+ *                  is thrown.
+ */
+native precache_generic(const szFile[]);
+
+/**
+ * Precaches an event file.
+ *
+ * @note The event type should always be 1.
+ * @note Contrary to the other precache_* natives, this can be used outside of
+ *       the plugin_precache() forward, e.g. in plugin_init() or plugin_cfg().
+ *       A bug in some clients makes this necessary, as plugin_precache() is
+ *       called before the mod has precached its own, default event files. This
+ *       can cause the event table to be misaligned on the client, leading to
+ *       visual and audio bugs that are hard to diagnose.
+ *
+ * @param type  Event type
+ * @param Name  Formatting rules, path to the event file
+ * @param ...   Variable number of formatting parameters
+ *
+ * @return      Unique cache id of the event
+ */
+native precache_event(type, const Name[], any:...);
+
+/**
+ * Changes the map.
+ *
+ * @note  This calls the pfnChangelLevel engine function.
+ * @note  This has the same behavior as using the "changelevel" server command,
+ *        but will also trigger the server_changelevel() forward in AMXX
+ *        plugins. It will also notify any Metamod plugins that are hooking
+ *        the pfnChangeLevel function.
+ *
+ * @param map   Map name to change to
+ *
+ * @noreturn
+ */
+native engine_changelevel(const map[]);
+
+/**
+ * Sets info on the client.
+ *
+ * @param index     Client index
+ * @param info      Info key
+ * @param value     New value
+ *
+ * @noreturn
+ * @error           If the index is not within the range of 1 to MaxClients or
+ *                  the client is not connected, an error will be thrown.
+ */
+native set_user_info(index, const info[], const value[]);
+
+/**
+ * Gets info from the client.
+ *
+ * @param index     Client index
+ * @param info      Info key
+ * @param output    Buffer to copy value to
+ * @param len       Maximum size of the buffer
+ *
+ * @return          Number of cells written to buffer
+ * @error           If the index is not within the range of 1 to MaxClients or
+ *                  the client is not connected, an error will be thrown.
+ */
+native get_user_info(index, const info[], output[], len);
+
+/**
+ * Sets info on the server.
+ *
+ * @param info      Info key
+ * @param value     New value
+ *
+ * @noreturn
+ */
+native set_localinfo(const info[], const value[]);
+
+/**
+ * Gets info from the server.
+ *
+ * @param info      Info key
+ * @param output    Buffer to copy value to
+ * @param len       Maximum size of the buffer
+ *
+ * @return          Number of cells written to buffer
+ */
+native get_localinfo(const info[], output[], len);
+
+/**
+ * Shows text or a file in MOTD window.
+ *
+ * @param player    Client index, use 0 to display to all clients
+ * @param message   Message to display inside the MOTD window, if this is a
+ *                  filename the contents of this file will be displayed
+ * @param header    Text for the MOTD header, if empty the servers hostname will
+ *                  be displayed instead
+ *
+ * @noreturn
+ */
+native show_motd(player, const message[], const header[] = "");
+
+/**
+ * Sends a message to the client.
+ *
+ * @note This functions return value behaves differently depending on what is
+ *       used as the client index: If 0 is specified, then the function will
+ *       return 0 if nothing has been sent (no client connected). If either a
+ *       single client is specified or there is at least one client connected,
+ *       the number of printed characters will refer to the message that is sent
+ *       last, to the client with the highest index.
+ *
+ * @param index     Client index, use 0 to display to all clients
+ * @param type      Message type, see print_* destination constants in
+ *                  amxconst.inc
+ * @param message   Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native client_print(index, type, const message[], any:...);
+
+/**
+ * Sends colored chat messages to clients.
+ *
+ * @note This only works in Counter-Strike 1.6 and Condition Zero.
+ * @note The colors can be modified inside of the format string using special
+ *       characters. These characters can be included using the escape character
+ *          green           x04   ; use location color from this point forward
+ *          red/blue/grey   x03   ; use team color from this point forward
+ *          red/blue/grey   x02   ; use team color to the end of the client name
+ *                                ; This only works at the start of the string,
+ *                                ; and precludes using other control characters
+ *          default         x01   ; use default color from this point forward
+ * @note The team color is defined by the sender's index. Alternatively, a
+ *       specific team color can be enforced using the print_team_* constants in
+ *       amxconst.inc
+ * @note Usage examples:
+ *       client_print_color(id, print_team_red, "^4Green ^3Red ^1Default")
+ *       client_print_color(id, id2, "^4Green ^3id2's team color, ^1Default")
+ * @note Including colors in ML can be done using the same escaping method:
+ *       EXAMPLE_ML_KEY = ^4Green ^3Team color ^1Default
+ * @note This functions return value behaves differently depending on what is
+ *       used as the client index: If 0 is specified, then the function will
+ *       return 0 if nothing has been sent (no client connected). If either a
+ *       single client is specified, or there is at least one client connected,
+ *       the number of printed characters will refer to the message that is sent
+ *       last, to the client with the highest index.
+ *
+ * @param index     Client index, use 0 to display to all clients
+ * @param sender    Client index used as the message sender
+ * @param fmt       Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native client_print_color(index, sender, const message[], any:...);
+
+/**
+ * Sends a message to the client via the engine.
+ *
+ * @note This functions return value behaves differently depending on what is
+ *       used as the client index: If 0 is specified, then the function will
+ *       return 0 if nothing has been sent (no client connected). If either a
+ *       single client is specified, or there is at least one client connected,
+ *       the number of printed characters will refer to the message that is sent
+ *       last, to the client with the highest index.
+ *
+ * @param player    Client index, use 0 to display to all clients
+ * @param type      Message type, see engprint_* destination constants in
+ *                  amxconst.inc
+ * @param message   Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native engclient_print(player, type, const message[], any:...);
+
+/**
+ * Sends a message to the console of a client or the server.
+ *
+ * @param index     Client index, or 0 to print to the server console
+ * @param message   Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native console_print(id, const message[], any:...);
+
+/**
+ * Executes a command from the specified client or the server console.
+ *
+ * @param id    Client index, or 0 to execute from the server console
+ * @param cmd   Formatting rules
+ * @param ...   Variable number of formatting parameters
+ *
+ * @return      Length of the formatted command
+ */
+native console_cmd(id, const cmd[], any:...);
+
+/**
+ * Registers a function to be called on a given game event.
+ *
+ * @note Please consider using register_event_ex() instead which allows you to
+ *       use named constants for flags instead of letters.
+ * @note Examples for event conditions:
+ *       "2=c4" - Second parameter of message must be the string "c4"
+ *       "3>10" - Third parameter of message must be greater than 10
+ *       "3!4" - Third parameter of message must not be equal to 4
+ *       "2&Buy" - Second parameter of message must contain "Buy" substring
+ *       "2!Buy" - Second parameter of message must not equal "Buy"
+ * @note Due to a long-standing bug that would break compatibility with older
+ *       plugins, the client id should be checked for alive/dead state if using
+ *       flags "d" or "e".
+ * @note If multiple conditions are specified for a single parameter, only one
+ *       of them has to hold true for the event function to be called.
+ *
+ * @param event     Name of event that should be hooked
+ * @param function  Name of callback function
+ * @param flags     Flags used for filtering events, the valid flags are:
+ *                  "a" - Global event (sent to every client)
+ *                  "b" - Event sent to single client
+ *                  "c" - Call only once when repeated to multiple clients
+ *                  "d" - Call only if sent to dead client
+ *                  "e" - Call only if sent to alive client
+ *                  "f" - Call only if sent to human client ("b" flag required)
+ *                  "g" - Call only if sent to bot ("b" flag required)
+ * @param cond      Condition string used for filtering events, built as:
+ *                  "<argument number><comparison operator><value>"
+ *                  Argument number is the argument position to be filtered
+ *                  The comparison operator may be:
+ *                    - "=" for equality comparison (all argument types)
+ *                    - "!" for inequality comparison (all argument types)
+ *                    - "&" for bitwise and (int argument) or substring
+ *                      comparison (string argument)
+ *                    - "<" for less than comparison (int/float arguments)
+ *                    - ">" for greater than comparison (int/float arguments)
+ *                  The argument is compared to the specified value accordingly
+ * @param ...       Any number of additional conditions
+ *
+ * @return          Event handle
+ * @error           If an invalid event name or callback function is provided,
+ *                  an error will be thrown.
+ */
+native register_event(const event[], const function[], const flags[], const cond[] = "", ...);
+
+/**
+ * Registers a function to be called on a given game event.
+ *
+ * @note Examples for event conditions:
+ *       "2=c4" - Second parameter of message must be the string "c4"
+ *       "3>10" - Third parameter of message must be greater than 10
+ *       "3!4" - Third parameter of message must not be equal to 4
+ *       "2&Buy" - Second parameter of message must contain "Buy" substring
+ *       "2!Buy" - Second parameter of message must not equal "Buy"
+ * @note Due to a long-standing bug that would break compatibility with older
+ *       plugins, the client id should be checked for alive/dead state if using
+ *       flags "d" or "e".
+ * @note If multiple conditions are specified for a single parameter, only one
+ *       of them has to hold true for the event function to be called.
+ *
+ * @param event     Name of event that should be hooked
+ * @param function  Name of callback function
+ * @param flags     Flags used for filtering events (enum RegisterEventFlags); the valid flags are:
+ *                    RegisterEvent_Global - Global event (sent to every client)
+ *                    RegisterEvent_Single - Event sent to single client
+ *                    RegisterEvent_OnceForMultiple - Call only once when repeated to multiple clients
+ *                    RegisterEvent_OnlyDead - Call only if sent to dead client
+ *                    RegisterEvent_OnlyAlive - Call only if sent to alive client
+ *                    RegisterEvent_OnlyHuman - Call only if sent to human client (RegisterEvent_Single required)
+ *                    RegisterEvent_OnlyBots - Call only if sent to bot (RegisterEvent_Single required)
+ * @param cond      Condition string used for filtering events, built as:
+ *                  "<argument number><comparison operator><value>"
+ *                  Argument number is the argument position to be filtered
+ *                  The comparison operator may be:
+ *                    "=" for equality comparison (all argument types)
+ *                    "!" for inequality comparison (all argument types)
+ *                    "&" for bitwise and (int argument) or substring
+ *                        comparison (string argument)
+ *                    "<" for less than comparison (int/float arguments)
+ *                    ">" for greater than comparison (int/float arguments)
+ *                  The argument is compared to the specified value accordingly
+ * @param ...       Any number of additional conditions
+ *
+ * @return          Event handle
+ * @error           If an invalid event name or callback function is provided,
+ *                  an error will be thrown.
+ */
+native register_event_ex(const event[], const function[], RegisterEventFlags:flags, const cond[] = "", ...);
+
+/**
+ * Enables a function hook of a game event which has been previously registered with register_event_ex().
+ *
+ * @param handle    Value returned from register_event() or register_event_ex()
+ *
+ * @noreturn
+ * @error           If an invalid handle is provided, an error will be thrown.
+ */
+native enable_event(handle);
+
+/**
+ * Disables a function hook of a game event which has been previously registered with register_event_ex().
+ *
+ * @param handle    Value returned from register_event() or register_event_ex()
+ *
+ * @noreturn
+ * @error           If an invalid handle is provided, an error will be thrown.
+ */
+native disable_event(handle);
+
+/**
+ * Registers a function to be called on a given log event.
+ *
+ * @note Examples for log conditions:
+ *       "0 = World triggered" "1 = Game_Commencing"
+ *       "1 = say"
+ *       "3 = Terrorists_Win"
+ *       "1 = entered the game"
+ *       "0 = Server cvar"
+ *
+ * @param function  Name of callback function
+ * @param argsnum   Number of arguments of the log event
+ * @param ...       Any number of conditions used for filtering events
+ *                  A condition string is built as:
+ *                  "<argument number><comparison operator><string>"
+ *                  Argument number is the argument position to be filtered
+ *                  The comparison operator may be:
+ *                    - "=" for equality comparison
+ *                    - "&" for substring comparison
+ *                  The argument is compared to the specified string accordingly
+ *
+ * @return          Log event handle
+ * @error           If an invalid callback function is provided, an error will
+ *                  be thrown.
+ */
+native register_logevent(const function[], argsnum, ...);
+
+/**
+ * Enables a function hook of a game log event which has been previously registered with register_logevent().
+ *
+ * @param handle    Value returned from register_logevent()
+ *
+ * @noreturn
+ * @error           If an invalid handle is provided, an error will be thrown.
+ */
+native enable_logevent(handle);
+
+/**
+ * Disables a function hook of a game log event which has been previously registered with register_logevent().
+ *
+ * @param handle    Value returned from register_logevent()
+ *
+ * @noreturn
+ * @error           If an invalid handle is provided, an error will be thrown.
+ */
+native disable_logevent(handle);
+
+/**
+ * Sets display parameters for hudmessages.
+ *
+ * @note As of AMXX 1.61, setting the channel to -1 will automatically choose
+ *       the next available HUD channel for the client.
+ * @note There are four different HUD channels available on the client (1-4).
+ *       Sending a hudmessage to a channel will overwrite any existing messages
+ *       already displaying on that channel.
+ * @note If you plan to create a permanent message, don't forget to specify a
+ *       specific channel to avoid possible flickering due to auto-channeling.
+ * @note For the hudmessage coordinates x and y, -1.0 will center the message
+ *       on the respective axis.
+ * @note These parameters stay until the next call to set_hudmessage overwrites
+ *       them. Multiple calls to show_hudmessage will therefore re-use the same
+ *       parameters. The parameters are not stored per-plugin, so other plugins
+ *       can overwrite them.
+ *
+ * @param red           Red component of hudmessage color
+ * @param green         Green component of hudmessage color
+ * @param blue          Blue component of hudmessage color
+ * @param x             Location of the message on the x axis in percent
+ * @param y             Location of the message on the y axis in percent
+ * @param effects       Display effect
+ * @param fxtime        Duration of the effect
+ * @param holdtime      Time the message stays on screen
+ * @param fadeintime    Time it takes the message to fully appear (fade-in)
+ * @param fadeouttime   Time it takes the message to fully disappear (fade-out)
+ * @param channel       Channel to use on the client
+ * @param alpha1        Alpha component of hudmessage color
+ * @param color2[4]     Color 2 array {r,g,b,a}
+ * 
+ * @noreturn
+ */
+native set_hudmessage(red = 200, green = 100, blue = 0, Float:x = -1.0, Float:y = 0.35, effects = 0, Float:fxtime = 6.0, Float:holdtime = 12.0, Float:fadeintime = 0.1, Float:fadeouttime = 0.2, channel = -1, alpha1 = 0, color2[4] = {255, 255, 250, 0});
+
+/**
+ * Displays a message on the client HUD.
+ *
+ * @note Use set_hudmessage to define how the message should look on screen.
+ * @note This functions return value behaves differently depending on what is
+ *       used as the client index: If 0 is specified, then the function will
+ *       return 0 if nothing has been sent (no client connected). If either a
+ *       single client is specified, or there is at least one client connected,
+ *       the number of printed characters will refer to the message that is sent
+ *       last, to the client with the highest index.
+ *
+ * @param index     Client index, use 0 to display to all clients
+ * @param message   Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native show_hudmessage(index, const message[], any:...);
+
+/**
+ * Sets display parameters for director hudmessages.
+ *
+ * @note For the hudmessage coordinates x and y, -1.0 will center the message
+ *       on the respective axis.
+ * @note These parameters stay until the next call to set_dhudmessage overwrites
+ *       them. Multiple calls to show_dhudmessage will therefore re-use the same
+ *       parameters. The parameters are not stored per-plugin, so other plugins
+ *       can overwrite them.
+ *
+ * @param red           Red component of hudmessage color
+ * @param green         Green component of hudmessage color
+ * @param blue          Blue component of hudmessage color
+ * @param x             Location of the message on the x axis in percent
+ * @param y             Location of the message on the y axis in percent
+ * @param effects       Display effect
+ * @param fxtime        Duration of the effect
+ * @param holdtime      Time the message stays on screen
+ * @param fadeintime    Time it takes the message to fully appear (fade-in)
+ * @param fadeouttime   Time it takes the message to fully disappear (fade-out)
+ *
+ * @noreturn
+ */
+native set_dhudmessage(red = 200, green = 100, blue = 0, Float:x = -1.0, Float:y = 0.35, effects = 0, Float:fxtime = 6.0, Float:holdtime = 12.0, Float:fadeintime = 0.1, Float:fadeouttime = 0.2);
+
+/**
+ * Displays a director message on the client HUD.
+ *
+ * @note Use set_dhudmessage to define how the message should look on screen.
+ * @note Unlike the classic HUD message, which is channel-based, director
+ *       messages are stack-based. You can have up to 8 messages displaying at
+ *       once. If more are added, they will be overwritten in the order they were
+ *       sent. There is no way to clear a specific message.
+ * @note The message has a maximum length of 128 characters which this function
+ *       will automatically enforce.
+ * @note This functions return value behaves differently depending on what is
+ *       used as the client index: If 0 is specified, then the function will
+ *       return 0 if nothing has been sent (no client connected). If either a
+ *       single client is specified, or there is at least one client connected,
+ *       the number of printed characters will refer to the message that is sent
+ *       last, to the client with the highest index.
+ *
+ * @param index     Client index, use 0 to display to all clients
+ * @param message   Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native show_dhudmessage(index, const message[], any:...);
+
+/**
+ * Displays a menu to the client.
+ *
+ * @note Keys is a bitflag value that represents which keys the user can press
+ *       on the menu. If you want to display disabled menu options, or skip
+ *       certain number slots, you should exclude that key from the bitflag.
+ *       amxconst.inc provides MENU_KEY_* constants for convenience.
+ * @note The title parameter is not displayed to the client and is only used for
+ *       identifying menus internally and assigning them to their callbacks.
+ *       The title corresponds to the menu name that you register with
+ *       register_menuid()
+ *
+ * @param index     Client to display menu to, use 0 to display to all clients
+ * @param keys      Enabled keys
+ * @param menu      Menu body
+ * @param time      Menu timeout in seconds, -1 to disable
+ * @param title     Name of the menu for internal tracking purposes
+ *
+ * @return          1 on success, 0 if menu could not be displayed (client not
+ *                  connected)
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native show_menu(index, keys, const menu[], time = -1, const title[] = "");
+
+/**
+ * Retrieves values from a client message.
+ *
+ * @note For use within callbacks registered with register_event_ex()
+ * @note Usage examples:
+ *       value = read_data(1);
+ *       read_data(2, floatvalue);
+ *       written = read_data(3, buffer, buffersize);
+ *
+ * @param value     Argument number to retrieve value from
+ * @param ...       Changes the native's behavior depending on how many
+ *                  additional parameters are provided:
+ *                     0 - Return the argument integer value directly
+ *                     1 - Store the argument float value in the variable passed
+ *                         as the second parameter
+ *                     2 - Copy the argument string value to the buffer provided
+ *                         in the second parameter, using the third as the
+ *                         maximum buffer size
+ *
+ * @return          Changes depending on how many additional parameters are
+ *                  provided:
+ *                     0 - Returns the argument integer value
+ *                     1 - Returns the argument float value, converted
+ *                         (truncated) to an integer
+ *                     2 - Returns the number of cells written to the buffer
+ */
+native read_data(value, any:...);
+
+/**
+ * Returns the number of values in the client message.
+ *
+ * @note For use within callbacks registered with register_event_ex()
+ *
+ * @return      Number of values in client message
+ */
+native read_datanum();
+
+/**
+ * Returns the message id of the client message.
+ *
+ * @note For use within callbacks registered with register_event_ex()
+ *
+ * @return      Message id of the client message
+ */
+native read_datatype();
+
+/**
+ * Retrieves current log message.
+ *
+ * @note Should only be used inside of the plugin_log() forward.
+ *
+ * @param output    Buffer to copy log message to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native read_logdata(output[], len);
+
+/**
+ * Returns number of log message arguments.
+ *
+ * @note Should only be used inside of the plugin_log() forward.
+ *
+ * @return          Number of arguments in the log message
+ */
+native read_logargc();
+
+/**
+ * Retrieves argument of log message.
+ *
+ * @note Should only be used inside of the plugin_log() forward.
+ *
+ * @param id        Argument index, starting from 0
+ * @param output    Buffer to copy log argument to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native read_logargv(id, output[], len);
+
+/**
+ * Parse log data about client.
+ *
+ * @note When client actions are logged, they appear in the the format
+ *       "Name<#userid><SteamID><teamname>", this native extracts the individual
+ *       pieces of information.
+ *
+ * @param text      String to process
+ * @param name      Buffer to copy client name to
+ * @param nlen      Maximum name buffer size
+ * @param userid    Variable to store userid in
+ * @param authid    Buffer to copy client authid to
+ * @param alen      Maximum auth buffer size
+ * @param team      Buffer to copy client team to
+ * @param tlen      Maximum team buffer size
+ *
+ * @noreturn
+ * @error           If the provided string is not valid client log data, an
+ *                  error will be thrown.
+ */
+native parse_loguser(const text[], name[], nlen, &userid =-2, authid[] = "", alen = 0, team[] = "", tlen = 0);
+
+/**
+ * Sends a message to the console of the server.
+ *
+ * @param message   Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ */
+native server_print(const message[], any:...);
+
+/**
+ * Returns if the given mapname is deemed valid by the engine.
+ *
+ * @param mapname   Name of the map
+ *
+ * @return          1 if the map name is valid, 0 otherwise
+ */
+native is_map_valid(const mapname[]);
+
+/**
+ * Returns if the client is a bot.
+ *
+ * @param index     Client index
+ *
+ * @return          1 if client is a bot, 0 otherwise
+ */
+native is_user_bot(index);
+
+/**
+ * Returns if the client is a HLTV proxy.
+ *
+ * @param index     Client index
+ *
+ * @return          1 if client is a HLTV proxy, 0 otherwise
+ */
+native is_user_hltv(index);
+
+/**
+ * Returns if the client is authorized.
+ *
+ * @note This does not throw an error if the provided index is out of the
+ *       1 to MaxClients range. That means you can safely use this native
+ *       without manually verifying that the index is a valid client index.
+ *
+ * @param index     Client index
+ *
+ * @return          1 if client is authorized, 0 otherwise
+ */
+native is_user_authorized(index);
+
+/**
+ * Returns if the client is connected.
+ *
+ * @note This does not throw an error if the provided index is out of the
+ *       1 to MaxClients range. That means you can safely use this native
+ *       without manually verifying that the index is a valid client index.
+ *
+ * @param index     Client index
+ *
+ * @return          1 if client is connected, 0 otherwise
+ */
+native is_user_connected(index);
+
+/**
+ * Returns if the client is connecting.
+ *
+ * @param index     Client index
+ *
+ * @return          1 if client is connecting, 0 otherwise
+ */
+native is_user_connecting(index);
+
+/**
+ * Returns if the client is alive.
+ *
+ * @note This will never return true if a client is not connected. If you need
+ *       to know whether a client is alive, an additional call to
+ *       is_user_connected() is unnecessary.
+ *
+ * @param index     Client index
+ *
+ * @return          1 if client is alive, 0 otherwise
+ */
+native is_user_alive(index);
+
+/**
+ * Returns if the server is a dedicated server.
+ *
+ * @return          1 if server is a dedicated server, 0 otherwise
+ */
+native is_dedicated_server();
+
+/**
+ * Returns if the server is running on Linux.
+ *
+ * @return          1 if server is running on Linux, 0 otherwise
+ */
+native is_linux_server();
+
+/**
+ * Returns if the AMXX installation has the JIT enabled.
+ *
+ * @return          1 if JIT is enabled, 0 otherwise
+ */
+native is_jit_enabled();
+
+/**
+ * Retrieves the version string of the AMXX installation.
+ *
+ * @param buffer    Buffer to copy version to
+ * @param length    Maximum buffer size
+ *
+ * @return          Number of cells written to the buffer
+ */
+native get_amxx_verstring(buffer[], length);
+
+/**
+ * Returns the last known attacker of a client.
+ *
+ * @note As of AMXX 1.75 this can return a non-client entity index if the client
+ *       was attacked by a non-client entity.
+ *
+ * @param index     Client index
+ * @param ...       If provided, the attacker weapon will be stored in an
+ *                  optional second parameter, and the body hit place will be
+ *                  stored in an optional third parameter
+ *
+ * @return          Attacker client index, a non-client entity or 0 if no
+ *                  attacker was found
+ * @error           If the client index is not within the range of 1 to
+ *                  MaxClients, an error will be thrown.
+ */
+native get_user_attacker(index, ...);
+
+/**
+ * Traces the client's current aim vector to see if it hits something.
+ *
+ * @note If the trace does not hit a client, id and body will be set to 0.
+ * @note If the trace hits nothing within the specified distance, 0 is returned.
+ * @note For a list of possible body hitplaces see the HIT_* constants in amxconst.inc.
+ *
+ * @param index     Client index to trace aim from
+ * @param id        Variable to store hit client index (if applicable)
+ * @param body      Variable to store hit client body part (if applicable)
+ * @param dist      Maximum distance of the trace
+ *
+ * @return          Distance between the trace start and end point
+ * @error           If the client index is not within the range of 1 to
+ *                  MaxClients, an error will be thrown.
+ */
+native Float:get_user_aiming(index, &id, &body = HIT_GENERIC, dist = 9999);
+
+/**
+ * Returns the client's frags.
+ *
+ * @note While this is mod-independent, the mod may track frag count differently,
+ *       so it can only be retrieved using another native or other methods.
+ * @note This will actually return the client's overall score, which may or may
+ *       not be equal to their scored frags depending on the mod.
+ *
+ * @param index     Client index
+ *
+ * @return          Frags/Score of the client. Also returns 0 if the client is
+ *                  not connected or the index is not within the range of
+ *                  1 to MaxClients
+ */
+native get_user_frags(index);
+
+/**
+ * Returns the client's armor value.
+ *
+ * @note While this is mod-independent, the mod may track armor data differently,
+ *       so it can only be retrieved using another native or other methods.
+ *
+ * @param index     Client index
+ *
+ * @return          Amount of armor the client has. Also returns 0 if the client
+ *                  is not connected or the index is not within the range of
+ *                  1 to MaxClients
+ */
+native get_user_armor(index);
+
+/**
+ * Returns the client's death count.
+ *
+ * @note While this is mod-independent, the mod may track death count differently,
+ *       so it can only be retrieved using another native or other methods.
+ *
+ * @param index     Client index
+ *
+ * @return          Amount of deaths the client has. Also returns 0 if the
+ *                  client is not connected or the index is not within the range
+ *                  of 1 to MaxClients
+ */
+native get_user_deaths(index);
+
+/**
+ * Returns the client's health points.
+ *
+ * @note While this is mod-independent, the mod may track health points
+ *       differently, so it can only be retrieved using another native or other
+ *       methods.
+ *
+ * @param index     Client index
+ *
+ * @return          Amount of health points the client has. Also returns 0 if
+ *                  the client is not connected or the index is not within the
+ *                  range of 1 to MaxClients
+ */
+native get_user_health(index);
+
+/**
+ * Retrieves a client's index by name.
+ *
+ * @param name  Name to search for
+ *
+ * @return      Client index on success, 0 otherwise
+ */
+native get_user_index(const name[]);
+
+/**
+ * Retrieves the IP of a client or the server.
+ *
+ * @param index             Client index, use 0 to retrieve the server IP
+ * @param ip                Buffer to copy IP to
+ * @param len               Maximum buffer size
+ * @param without_port      Remove the port from the IP if nonzero
+ *
+ * @return                  Number of cells written to the buffer
+ */
+native get_user_ip(index, ip[], len, without_port = 0);
+
+/**
+ * Returns if the client has the specified weapon in their inventory.
+ *
+ * @param index         Client index
+ * @param weapon        Weapon index
+ * @param setweapon     If zero the weapon bit will be removed from the client's
+ *                      inventory, if 1 it will be set
+ *
+ * @return              1 if the weapon is present, 0 if it is not
+ * @error               If the client index is not within the range of 1 to
+ *                      MaxClients, an error will be thrown.
+ */
+native user_has_weapon(index, weapon, setweapon = -1);
+
+/**
+ * Returns weapon index of the currently carried weapon. Also allows retrieval
+ * of ammo in the clip and backpack.
+ *
+ * @param index     Client index
+ * @param clip      Optional variable to store clip ammo to
+ * @param ammo      Optional variable to store backpack ammo to
+ *
+ * @return          Weapon index on success or 0 if the client is not connected
+ * @error           If the client index is not within the range of 1 to
+ *                  MaxClients, an error will be thrown.
+ */
+native get_user_weapon(index, &clip = 0, &ammo = 0);
+
+/**
+ * Retrieves ammo in the clip and backpack of the specified weapon.
+ *
+ * @param index     Client index
+ * @param weapon    Weapon index
+ * @param clip      Variable to store clip ammo to
+ * @param ammo      Variable to store backpack ammo to
+ *
+ * @return          1 on success or 0 if the client is not connected
+ * @error           If the client index is not within the range of 1 to
+ *                  MaxClients or the weapon index is invalid, an error will
+ *                  be thrown.
+ */
+native get_user_ammo(index, weapon, &clip, &ammo);
+
+/**
+ * Converts an integer to a text string.
+ *
+ * @note The conversion algorithm is limited to a certain range of numbers, but
+ *       is guaranteed to work correctly for all numbers from 0 to 999. Outside
+ *       of that range, the conversion will result in an incorrect string, but
+ *       will not fail.
+ * @note The conversion is to english text, there is no way to change this.
+ *
+ * @param num       Integer to convert
+ * @param output    Buffer to copy string to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native num_to_word(num, output[], len);
+
+/**
+ * Returns the team id of the client, and optionally retrieves the name of
+ * the team.
+ *
+ * @param index     Client index
+ * @param team      Buffer to copy team name to
+ * @param len       Maximum size of buffer
+ *
+ * @return          Team index on success, -1 if client index is invalid or
+ *                  the client is not connected
+ */
+native get_user_team(index, team[] = "", len = 0);
+
+/**
+ * Returns client's playing time in seconds.
+ *
+ * @param index     Client index
+ * @param flag      If nonzero, the result will not include the time it took
+ *                  the client to connect.
+ *
+ * @return          Connection time in seconds, 0 if client index is invalid or
+ *                  client is not connected
+ */
+native get_user_time(index, flag = 0);
+
+/**
+ * Retrieves the ping and loss of a client.
+ *
+ * @param index     Client index
+ * @param ping      Variable to store ping in
+ * @param loss      Variable to store loss in
+ *
+ * @return          1 on success, 0 if client index is invalid or the client
+ *                  is not connected
+ */
+native get_user_ping(index, &ping, &loss);
+
+/**
+ * Retrieves an origin related to the client.
+ *
+ * @note For a list of possible modes see the Origin_* constants in amxconst.inc.
+ *
+ * @param index     Client index
+ * @param origin    Array to store origin in
+ * @param mode      What type of origin to retrieve:
+ *                    Origin_Client - current position
+ *                    Origin_Eyes - position of eyes (and weapon)
+ *                    Origin_AimEndClient - aim end position from client position
+ *                    Origin_AimEndEyes - aim end position from eyes (hit point for weapon)
+ *                    Origin_CS_LastBullet - position of last bullet hit (only for Counter-Strike)
+ *
+ * @return          1 on success, 0 if client is not connected
+ * @error           If the client index is not within the range of 1 to
+ *                  MaxClients, an error will be thrown.
+ */
+native get_user_origin(index, origin[3], mode = 0);
+
+/**
+ * Retrieves all weapons in the client inventory, stores them in an array, and
+ * returns the inventory as a bitflag sum.
+ *
+ * @note Make sure that num has an initial value of 0 or the native will not
+ *       work correctly.
+ *
+ * @param index     Client index
+ * @param weapons   Array to store weapon indexes in
+ * @param num       Variable to store number of weapons in the inventory to
+ *
+ * @return          Bitflag sum of weapon indexes, 0 if client is not connected
+ * @error           If the client index is not within the range of 1 to
+ *                  MaxClients, an error will be thrown.
+ */
+native get_user_weapons(index, weapons[32], &num);
+
+/**
+ * Retrieves the full name of a weapon.
+ *
+ * @param id        Weapon index
+ * @param weapon    Buffer to copy name to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native get_weaponname(id, weapon[], len);
+
+/**
+ * Retrieves the name of a client or the server.
+ *
+ * @param index     Client index, or 0 to retrieve the server hostname
+ * @param name      Buffer to copy name to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native get_user_name(index, name[], len);
+
+/**
+ * Retrieves the SteamID of a client.
+ *
+ * @note The SteamID is only available once the client_authorized() forward has
+ *       been called for the client.
+ *
+ * @param index     Client index
+ * @param authid    Buffer to copy auth to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native get_user_authid(index, authid[], len);
+
+/**
+ * Returns the userid of a client.
+ *
+ * @param index     Client index
+ *
+ * @return          Client userid, 0 if the userid is not available or the
+ *                  client index is invalid
+ */
+native get_user_userid(index);
+
+/**
+ * Slaps the client with specified power. Killing the client if applicable.
+ *
+ * @note This removes "power" amount of health from the client, performing
+ *       a kill if they have no health left after the slap.
+ * @note The function will apply a velocity to the client that is independent
+ *       of the slap power. The slap direction can be influenced by the third
+ *       parameter.
+ *
+ * @param index     Client index
+ * @param power     Power of the slap
+ * @param rnddir    If set to zero the player will be slapped along it's aim
+ *                  vector, otherwise the direction will be randomized
+ *
+ * @return          1 if user is alive and slap succeeded, 0 otherwise
+ */
+native user_slap(index, power, rnddir = 1);
+
+/**
+ * Kills a client.
+ *
+ * @param index     Client index
+ * @param flag      If nonzero, the death will not affect the client's score
+ *
+ * @return          1 on success, 0 if client index is invalid or the client
+ *                  is not connected
+ */
+native user_kill(index, flag = 0);
+
+/**
+ * Logs a message to the current AMXX log file.
+ *
+ * @note The message will automatically be tagged with the plugin's name and the
+ *       log will include a timestamp with the message.
+ *
+ * @param string    Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @noreturn
+ */
+native log_amx(const string[], any:...);
+
+/**
+ * Logs a message to the current server log file.
+ *
+ * @note The log will include a timestamp with the message.
+ *
+ * @param string    Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ */
+native log_message(const message[], any:...);
+
+/**
+ * Logs a message hookable by plugins to the current server log file.
+ *
+ * @note The log will include a timestamp with the message.
+ * @note The message can be hooked using "register_logevent".
+ *
+ * @param string    Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ */
+native elog_message(const message[], any:...);
+
+/**
+ * Logs a message to the specified file
+ *
+ * @note The log will include a timestamp with the message.
+ *
+ * @param string    Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @noreturn
+ */
+native log_to_file(const file[], const message[], any:...);
+
+/**
+ * Returns the number of clients on the server.
+ *
+ * @param flag      Count clients still in the connecting process if nonzero
+ *
+ * @return          Number of clients on the server
+ */
+native get_playersnum(flag = 0);
+
+/**
+ * Stores a filtered list of client indexes to an array.
+ *
+ * @note Please consider using get_players_ex() instead which allows you to
+ *       use named constants for flags instead of letters.
+ * @note Example retrieving all alive CTs: get_players(players, num "ae", "CT")
+ *
+ * @param players   Array to store indexes to
+ * @param num       Variable to store number of indexes to
+ * @param flags     Optional list of filtering flags:
+ *                    "a" - do not include dead clients
+ *                    "b" - do not include alive clients
+ *                    "c" - do not include bots
+ *                    "d" - do not include human clients
+ *                    "e" - match with team
+ *                    "f" - match with part of name
+ *                    "g" - match case insensitive
+ *                    "h" - do not include HLTV proxies
+ *                    "i" - include connecting clients
+ * @param team      String to match against if the "e" or "f" flag is specified
+ *
+ * @noreturn
+ */
+native get_players(players[MAX_PLAYERS], &num, const flags[] = "", const team[] = "");
+
+/**
+ * Retrieves argument of client command as string.
+ *
+ * @note Should only be used inside of the client_command() forward.
+ *
+ * @param id        Argument index starting from 1, 0 returns the command itself
+ * @param output    Buffer to copy command argument to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native read_argv(id, output[], len);
+
+/**
+ * Retrieves argument of client command as integer value.
+ *
+ * @note Should only be used inside of the client_command() forward.
+ *
+ * @param id        Argument index starting from 1
+ *
+ * @return          Integer value
+ */
+native read_argv_int(id);
+
+/**
+ * Retrieves argument of client command as float value.
+ *
+ * @note Should only be used inside of the client_command() forward.
+ *
+ * @param id        Argument index starting from 1
+ *
+ * @return          Float value
+ */
+native Float:read_argv_float(id);
+
+/**
+ * Retrieves full client command string.
+ *
+ * @note Should only be used inside of the client_command() forward.
+ *
+ * @param output    Buffer to copy command line to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native read_args(output[], len);
+
+/**
+ * Returns number of client command arguments.
+ *
+ * @note Should only be used inside of the client_command() forward.
+ * @note This count includes the command itself. I.e. in a command with 4
+ *       arguments, this will return 5.
+ *
+ * @return          Number of arguments in the command
+ */
+native read_argc();
+
+/**
+ * Converts a flag string to a bitflag value.
+ *
+ * @note Example: The string "abcd" represents the sum of 1, 2, 4, and 8 - or
+ *       (1<<0)|(1<<1)|(1<<2)|(1<<3). The function will return 15.
+ *
+ * @param flags     Flag string to convert
+ *
+ * @return          Bitflag value
+ */
+native read_flags(const flags[]);
+
+/**
+ * Converts a bitflag value to a flag string.
+ *
+ * @note Example: The value 3 will yield the string "ab"
+ *
+ * @param flags     Bitflag value to convert
+ * @param output    Buffer to copy flag string to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native get_flags(flags, output[], len);
+
+/**
+ * Find a player given a filter.
+ *
+ * @note Please consider using find_player_ex() instead which allows you to
+ *       use named constants for flags instead of letters.
+ * @note If matching by userid, do not also specify the "a", "b" or "c" flags,
+ *       or the function may not return a correct result.
+ *
+ * @param flags     List of filtering flags:
+ *                    "a" - match with name
+ *                    "b" - match with name substring
+ *                    "c" - match with authid
+ *                    "d" - match with ip
+ *                    "e" - match with team name
+ *                    "f" - do not include dead clients
+ *                    "g" - do not include alive clients
+ *                    "h" - do not include bots
+ *                    "i" - do not include human clients
+ *                    "j" - return last matched client instead of the first
+ *                    "k" - match with userid
+ *                    "l" - match case insensitively
+ *                    "m" - include connecting clients
+ * @param ...       String to match against (integer if "k" flag is specified)
+ *
+ * @return          Client index, or 0 if no client was found
+ */
+native find_player(const flags[], ...);
+
+/**
+ * Find a player given a filter.
+ *
+ * @note If matching by userid, do not also specify FindPlayer_MatchName, FindPlayer_MatchNameSubstring
+ *       or FindPlayer_MatchAuthId, or the function may not return a correct result.
+ *
+ * @param flags     Filtering flags (enum FindPlayerFlags); valid flags are:
+ *                    FindPlayer_MatchName - match with name
+ *                    FindPlayer_MatchNameSubstring - match with name substring
+ *                    FindPlayer_MatchAuthId - match with authid
+ *                    FindPlayer_MatchIP - match with ip
+ *                    FindPlayer_MatchTeam - match with team name
+ *                    FindPlayer_ExcludeDead - do not include dead clients
+ *                    FindPlayer_ExcludeAlive - do not include alive clients
+ *                    FindPlayer_ExcludeBots - do not include bots
+ *                    FindPlayer_ExcludeHuman - do not include human clients
+ *                    FindPlayer_LastMatched - return last matched client instead of the first
+ *                    FindPlayer_MatchUserId - match with userid
+ *                    FindPlayer_CaseInsensitive - match case insensitively
+ *                    FindPlayer_IncludeConnecting - include connecting clients
+ * @param ...       String to match against (integer if FindPlayer_MatchUserId is specified)
+ *
+ * @return          Client index, or 0 if no client was found
+ */
+native find_player_ex(FindPlayerFlags:flags, ...);
+
+/**
+ * Removes double-quotes from the beginning and end of a string.
+ *
+ * @note If the string only has a double-quote at either the start *or* the end,
+ *       and not both, the function will do nothing.
+ * @note The function does not perform any trimming per-se. But if a
+ *       double-quote is found at the beginning of the string, it will remove
+ *       one ^r (carriage return) character at the end of the string if present,
+ *       even if no matching double-quote is found. This is for convenience.
+ *
+ * @param text      String to remove double-quotes from
+ *
+ * @return          1 if matching double-quotes have been removed, 0 otherwise
+ */
+native remove_quotes(text[]);
+
+/**
+ * Executes a command on the client.
+ *
+ * @note Executing malicious commands on the client ("slowhacking") is frowned
+ *       upon.
+ * @note Valve has introduced a command filter to Counter-Strike 1.6. It is not
+ *       possible to execute many commands if the client has opted in to this.
+ *
+ * @param index     Client index, use 0 to execute on all clients
+ * @param command   Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Length of formatted command string
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native client_cmd(index, const command[], any:...);
+
+/**
+ * Execute a command from the client without actually sending it to the client's
+ * DLL.
+ *
+ * @note This emulates a client command on the server side, and is an excellent
+ *       tool to force a client to do certain actions related to the game.
+ * @note The command has to stand alone in the command parameter, only add
+ *       arguments using the designated parameters.
+ * @note Commands emulated using this function will not trigger plugin command
+ *       hooks. For an alternative that does, see amxclient_cmd()
+ *
+ * @param index         Client index, use 0 to execute from all clients
+ * @param command       Client command to execute on
+ * @param arg1          Optional command arguments
+ * @param arg2          Optional command arguments
+ *
+ * @noreturn
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native engclient_cmd(index, const command[], const arg1[] = "", const arg2[] = "");
+
+/**
+ * Execute a command from the client without actually sending it to the client's
+ * DLL. This triggers plugin command hooks.
+ *
+ * @note This emulates a client command on the server side, and is an excellent
+ *       tool to force a client to do certain actions related to the game.
+ * @note The command has to stand alone in the command parameter, only add
+ *       arguments using the designated parameters.
+ * @note Commands emulated using this function will trigger other plugin's
+ *       command hooks. For an alternative that doesn't, see engclient_cmd()
+ *
+ * @param index         Client index, use 0 to execute from all clients
+ * @param command       Client command to execute on
+ * @param arg1          Optional command arguments
+ * @param arg2          Optional command arguments
+ *
+ * @noreturn
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native amxclient_cmd(index, const command[], const arg1[] = "", const arg2[] = "");
+
+/**
+ * Queues a command to be executed from the server console.
+ *
+ * @note Warning: This is a potential source of command injection. Do not feed
+ *       client-controlled input (including client names) to this function
+ *       without sanitizing it first.
+ * @note The queued commands will be executed by the engine on the next frame.
+ *       If you require them to be executed immediately, see server_exec()
+ *
+ * @param command   Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @noreturn
+ */
+native server_cmd(const command[], any:...);
+
+/**
+ * Retrieves the name of the currently played map.
+ *
+ * @param name      Buffer to copy map name to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer
+ */
+native get_mapname(name[], len);
+
+/**
+ * Returns time remaining on map.
+ *
+ * @return  Time left on map, in seconds
+ */
+native get_timeleft();
+
+/**
+ * Returns the game time based on the game tick.
+ *
+ * @note This time is counted up from map start. If the engine is not processing
+ *       this function will return the same value between calls, which makes it
+ *       unusable for profiling purposes.
+ *
+ * @return      Game time, in seconds
+ */
+native Float:get_gametime();
+
+/**
+ * Returns the maxplayers setting of the current server, that is how many
+ * clients it supports.
+ *
+ * @note As of AMXX 1.8.3, this value is also exposed through a dynamic constant
+ *       via the MaxClients variable, declared in amxconst.inc
+ *
+ * @return      Maxplayers setting
+ */
+native get_maxplayers();
+
+/**
+ * Retrieves the name of the currently played mod.
+ *
+ * @note This retrieves the short name of the mod. Example: for Counter-Strike,
+ *       it will copy "cstrike" to the buffer.
+ *
+ * @param name      Buffer to copy mod name to
+ * @param len       Maximum size of the buffer
+ *
+ * @return          Number of cells written to buffer
+ */
+native get_modname(name[], len);
+
+/**
+ * Retrieves the current time using the specified format string.
+ *
+ * @note Uses the strftime C function. For a list of valid format parameters,
+ *       see: http://cplusplus.com/reference/clibrary/ctime/strftime.html
+ *       A common example for a format string would be: "%m/%d/%Y - %H:%M:%S"
+ *
+ * @param format    Format string
+ * @param output    Buffer to copy formatted time string to
+ * @param len       Maximum size of buffer
+ *
+ * @return          Number of cells written to buffer
+ */
+native get_time(const format[], output[], len);
+
+/**
+ * Retrieves the provided time using the specified format string.
+ *
+ * @note Uses the strftime C function. For a list of valid format parameters,
+ *       see: http://cplusplus.com/reference/clibrary/ctime/strftime.html
+ *       A common example for a format string would be: "%m/%d/%Y - %H:%M:%S"
+ *
+ * @param output    Buffer to copy formatted time string to
+ * @param len       Maximum size of buffer
+ * @param format    Format string
+ * @param time      Unix timestamp, use -1 to use the current time
+ *
+ * @return          Number of cells written to buffer
+ * @error           If the conversion process fails, an error will be thrown.
+ */
+native format_time(output[], len, const format[], time = -1);
+
+/**
+ * Returns the system time as a unix timestamp (number of seconds since unix
+ * epoch).
+ *
+ * @param offset    Optional offset value in seconds
+ *
+ * @return          Unix time stamp
+ */
+native get_systime(offset = 0);
+
+/**
+ * Converts time strings to unix time stamp.
+ *
+ * @note Uses the strptime C function. For a list of valid format parameters,
+ *       see: http://www.cplusplus.com/reference/ctime/strftime/
+ *       An example for a input/format combination would be:
+ *       Input: "10:32:54 04/02/2013"  Format: "%H:%M:%S %m:%d:%Y"
+ * @note Information missing from the input will be filled with the current
+ *       time and date.
+ *
+ * @param input     Time string to convert
+ * @param format    Formatting information for conversion
+ * @param time      If different from -1, the converted time will be added to
+ *                  this time stamp
+ *
+ * @return          Unix time stamp
+ * @error           If the conversion process fails, an error will be thrown.
+ */
+native parse_time(const input[], const format[], time = -1);
+
+/**
+ * Calls a function after a specified time has elapsed.
+ *
+ * @note Please consider using set_task_ex() instead which allows you to
+ *       use named constants for flags instead of letters.
+ *
+ * @note The function is called in the following manner if data is passed:
+ *   data[]          - Data passed
+ *   id              - Task index
+ *
+ * @note The function is called in the following manner if no data is passed:
+ *   id              - Task index
+ *
+ * @param time          Time interval to assign
+ * @param function      Function to execute
+ * @param id            Task id to assign
+ * @param parameter     Data to pass through to callback
+ * @param len           Size of data
+ * @param flags         Optional set of flags:
+ *                        "a" - repeat timer a set amount of times
+ *                        "b" - loop indefinitely until timer is stopped
+ *                        "c" - time interval is treated as absolute time after
+ *                              map start
+ *                        "d" - time interval is treated as absolute time before
+ *                              map change
+ * @param repeat        If the "a" flag is set, the task will be repeated this
+ *                      many times
+ *
+ * @noreturn
+ * @error               If an invalid callback function is provided, an error is
+ *                      thrown.
+ */
+native set_task(Float:time, const function[], id = 0, const any:parameter[] = "", len = 0, const flags[] = "", repeat = 0);
+
+/**
+ * Removes all tasks with the specified id.
+ *
+ * @param id        Task id to search for
+ * @param outside   Will remove tasks set by other plugins if nonzero
+ *
+ * @return          Number of removed tasks
+ */
+native remove_task(id = 0, outside = 0);
+
+/**
+ * Modifies the time interval of all tasks with the specified id.
+ *
+ * @param id        Task id to search for
+ * @param newTime   New time interval to set
+ * @param outside   Will affect tasks set by other plugins if nonzero
+ *
+ * @return          Number of affected tasks
+ */
+native change_task(id = 0, Float:newTime = 1.0, outside = 0);
+
+/**
+ * Returns if a task with the specified id exists.
+ *
+ * @param id        Task id to search for
+ * @param outside   Search for tasks set by other plugins if nonzero
+ *
+ * @return          1 if a task was found, 0 otherwise
+ */
+native task_exists(id = 0, outside = 0);
+
+/**
+ * Sets the specified admin flags to a client.
+ *
+ * @note For a list of possible flags, see the ADMIN_* constants in amxconst.inc
+ * @note This function just adds the flags using a bitwise-or operation. After it
+ *       has run, the flags may not exactly equal the specified bitflag sum.
+ * @note AMXX stores multiple sets of flags internally, but only flag set
+ *       0 is actively used. You should not change the value of the third
+ *       parameter from the default.
+ *
+ * @param index     Client index, 0 to set flags of server
+ * @param flags     Admin flags
+ * @param id        Flag set id, ranging from 0 to 31
+ *
+ * @noreturn
+ * @error           If the index is not within the range of 0 to MaxClients, an
+ *                  error will be thrown.
+ */
+native set_user_flags(index, flags = -1, id = 0);
+
+/**
+ * Returns the client's admin flags as a bitflag sum.
+ *
+ * @note For a list of possible flags, see the ADMIN_* constants in amxconst.inc
+ * @note AMXX stores multiple sets of flags internally, but only flag set
+ *       0 is actively used. You should not change the value of the second
+ *       parameter from the default.
+ *
+ * @param index     Client index, 0 to get flags of server
+ * @param id        Flag set id, ranging from 0 to 31
+ *
+ * @return          Bitflag sum of client's admin flags
+ * @error           If the index is not within the range of 0 to MaxClients, an
+ *                  error will be thrown.
+ */
+native get_user_flags(index, id = 0);
+
+/**
+ * Removes the specified admin flags from a client.
+ *
+ * @note For a list of possible flags, see the ADMIN_* constants in amxconst.inc
+ * @note This function just removes the flags using a bitwise-and operation.
+ * @note AMXX stores multiple sets of flags internally, but only flag set
+ *       0 is actively used. You should not change the value of the third
+ *       parameter from the default.
+ *
+ * @param index     Client index, 0 to set flags of server
+ * @param flags     Admin flags
+ * @param id        Flag set id, ranging from 0 to 31
+ *
+ * @noreturn
+ * @error           If the index is not within the range of 0 to MaxClients, an
+ *                  error will be thrown.
+ */
+native remove_user_flags(index, flags = -1, id = 0);
+
+/**
+ * Registers a callback to be called when the client executes a command from the
+ * console.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ * @note Opting in to FlagManager enables the admin privileges to be overwritten
+ *       by the end user via the cmdaccess.ini config file.
+ * @note Automatic detection for FlagManager will only include a command if it
+ *       has required privileges (flags is not -1) and it is not a command
+ *       starting with "say".
+ *
+ * @param client_cmd    Command to register
+ * @param function      Callback function
+ * @param flags         Admin privilege flags required
+ * @param info          Command description
+ * @param FlagManager   0 opts out of flag manager, 1 opts in, -1 selects
+ *                      automatically
+ * @param info_ml       If true, the parameter "info" will be looked up as multilingual key
+ *
+ * @return              Command id, 0 on failure
+ * @error               If an invalid callback function is specified, an error
+ *                      will be thrown.
+ */
+native register_clcmd(const client_cmd[], const function[], flags = -1, const info[] = "", FlagManager = -1, bool:info_ml = false);
+
+/**
+ * Registers a callback to be called when the client or server executes a
+ * command from the console.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ * @note Opting in to FlagManager enables the admin privileges to be overwritten
+ *       by the end user via the cmdaccess.ini config file.
+ * @note Automatic detection for FlagManager will only include a command if it
+ *       has required privileges (flags is not -1) and it is not a command
+ *       starting with "say".
+ *
+ * @param client_cmd    Command to register
+ * @param function      Callback function
+ * @param flags         Admin privilege flags required
+ * @param info          Command description
+ * @param FlagManager   0 opts out of flag manager, 1 opts in, -1 selects
+ *                      automatically
+ * @param info_ml       If true, the parameter "info" will be looked up as multilingual key
+ *
+ * @return              Command id, 0 on failure
+ * @error               If an invalid callback function is specified, an error
+ *                      will be thrown.
+ */
+native register_concmd(const cmd[], const function[], flags = -1, const info[] = "", FlagManager = -1, bool:info_ml = false);
+
+/**
+ * Registers a callback to be called when the server executes a command from the
+ * console.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ *
+ * @param client_cmd    Command to register
+ * @param function      Callback function
+ * @param flags         Admin privilege flags required
+ * @param info          Command description
+ * @param info_ml       If true, the parameter "info" will be looked up as multilingual key
+ *
+ * @return              Command id, 0 on failure
+ * @error               If an invalid callback function is specified, an error
+ *                      will be thrown.
+ */
+native register_srvcmd(const server_cmd[], const function[], flags = -1, const info[] = "", bool:info_ml = false);
+
+/**
+ * Retrieves information about a client command.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ *
+ * @param index     Command index
+ * @param command   Buffer to copy command name to
+ * @param len1      Maximum name buffer size
+ * @param flags     Variable to store privilege flags to
+ * @param info      Buffer to copy command description to
+ * @param len2      Maximum description buffer size
+ * @param flag      Only considers commands that can be accessed with
+ *                  the specified privilege flags
+ * @param info_ml   Variable to store whether the parameter "info" is a multilingual key
+ *
+ * @return          1 on success, 0 if command was not found
+ */
+native get_clcmd(index, command[], len1, &flags, info[], len2, flag, &bool:info_ml = false);
+
+/**
+ * Returns number of registered client commands.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ *
+ * @param flag      Only considers commands that can be accessed with
+ *                  the specified privilege flags
+ *
+ * @return          Number of registered client commands
+ */
+native get_clcmdsnum(flag);
+
+/**
+ * Retrieves information about a server command.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ *
+ * @param index     Command index
+ * @param command   Buffer to copy command name to
+ * @param len1      Maximum name buffer size
+ * @param flags     Variable to store privilege flags to
+ * @param info      Buffer to copy command description to
+ * @param len2      Maximum description buffer size
+ * @param flag      Only considers commands that can be accessed with
+ *                  the specified privilege flags
+ * @param info_ml   Variable to store whether the parameter "info" is a multilingual key
+ *
+ * @return          1 on success, 0 if command was not found
+ */
+native get_srvcmd(index, server_cmd[], len1, &flags, info[], len2, flag, &bool:info_ml = false);
+
+/**
+ * Returns number of registered server commands.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ *
+ * @param flag      Only considers commands that can be accessed with
+ *                  the specified privilege flags
+ *
+ * @return          Number of registered server commands
+ */
+native get_srvcmdsnum(flag);
+
+/**
+ * Retrieves information about a console command.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ *
+ * @param index     Command index
+ * @param command   Buffer to copy command name to
+ * @param len1      Maximum name buffer size
+ * @param flags     Variable to store privilege flags to
+ * @param info      Buffer to copy command description to
+ * @param len2      Maximum description buffer size
+ * @param flag      Only considers commands that can be accessed with
+ *                  the specified privilege flags
+ * @param id        If set to 0 only server commands will be considered,
+ *                  positive will only consider client commands, otherwise
+ *                  all console commands will be considered
+ * @param info_ml   Variable to store whether the parameter "info" is a multilingual key
+ *
+ * @return          1 on success, 0 if command was not found
+ */
+native get_concmd(index, cmd[], len1, &flags, info[], len2, flag, id = -1, &bool:info_ml = false);
+
+/**
+ * Returns the parent plugin id of a console command.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ *
+ * @param cid           Command index
+ * @param flag_mask     Only considers commands that can be accessed with
+ *                      the specified privilege flags.
+ * @param id_type       If set to 0 only server commands will be considered,
+ *                      positive will only consider client commands, otherwise
+ *                      all console commands will be considered.
+ *
+ * @return              Plugin id
+ */
+native get_concmd_plid(cid, flag_mask, id_type);
+
+/**
+ * Returns number of registered console commands.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ *
+ * @param flag      Only considers commands that can be accessed with
+ *                  the specified privilege flags
+ * @param id        If set to 0 only server commands will be considered,
+ *                  positive will only consider client commands, otherwise
+ *                  all console commands will be considered
+ *
+ * @return          Number of registered console commands
+ */
+native get_concmdsnum(flag, id = -1);
+
+/**
+ * Returns unique menu id of a menu.
+ *
+ * @param menu      Menu name
+ * @param outside   Catch menus outside the calling plugin
+ *
+ * @return          Menu id
+ */
+native register_menuid(const menu[], outside = 0);
+
+/**
+ * Registers a callback function to a menu id and keys.
+ *
+ * @param menuid        Menu id
+ * @param keys          Key flags
+ * @param function      Callback function
+ *
+ * @noreturn
+ * @error               If an invalid callback function is specified, an error
+ *                      will be thrown.
+ */
+native register_menucmd(menuid, keys, const function[]);
+
+/**
+ * Returns if the client is watching a menu.
+ *
+ * @note If there is no menu, the id is 0. If the id is negative, then the client
+ *       views a VGUI menu. Otherwise, the id is an id acquired from the
+ *       register_menuid() function.
+ *
+ * @param index     Client index
+ * @param id        Variable to store menu id to
+ * @param keys      Variable to store menu keys to
+ *
+ * @return          1 if client views a menu, 0 otherwise
+ * @error           If the client index is not within the range of 1 to
+ *                  MaxClients, an error will be thrown.
+ */
+native get_user_menu(index, &id, &keys);
+
+/**
+ * Forces the server to execute the command queue immediately.
+ *
+ * @note Commands can be added to the queue using server_cmd()
+ *
+ * @noreturn
+ */
+native server_exec();
+
+/**
+ * Emits a sound from an entity from the engine.
+ *
+ * @note The sample must be precached using precache_sound() so it is available
+ *       in the engine's sound table.
+ * @note For a list of available channels, see CHAN_* constants in amxconst.inc,
+ *       sounds emitted from the same channel will override each other.
+ * @note There are helpful reference constants in amxconst.inc for sound volume
+ *       (VOL_*), attenuation (ATTN_*), flags (SND_*), and pitch (PITCH_*).
+ *
+ * @param index     Entity index, use 0 to emit from all clients
+ * @param channel   Channel to emit from
+ * @param sample    Sound file to emit
+ * @param vol       Volume in percent
+ * @param att       Sound attenuation
+ * @param flags     Emit flags
+ * @param pitch     Sound pitch
+ *
+ * @noreturn
+ */
+native emit_sound(index, channel, const sample[], Float:vol, Float:att, flags, pitch);
+
+/**
+ * Returns a random floating point value generated by the engine.
+ *
+ * @param a     Minimum value (inclusive)
+ * @param b     Maximum value (inclusive)
+ *
+ * @return      Generated random value
+ */
+native Float:random_float(Float:a, Float:b);
+
+/**
+ * Returns a random integer value generated by the engine.
+ *
+ * @param a     Minimum value (inclusive)
+ * @param b     Maximum value (inclusive)
+ *
+ * @return      Generated random value
+ */
+native random_num(a, b);
+
+/**
+ * Returns unique id of a client message.
+ *
+ * @note Example usage: get_user_msgid("TextMsg")
+ * @note The message id is unique as long as the server is running, but might
+ *       change between updates. They should not be hardcoded into plugins.
+ * @note On first server start, this function will return 0 if used inside
+ *       plugin_precache(). Consider hooking RegUserMsg in order to retrieve
+ *       the correct message id.
+ *
+ * @param name      Client message name
+ *
+ * @return          Message id, 0 if message was not found
+ */
+native get_user_msgid(const name[]);
+
+/**
+ * Retrieves the client message name from a message id.
+ *
+ * @param msgid     Client message id
+ * @param name      Buffer to copy message name to
+ * @param len       Maximum buffer size
+ *
+ * @return          Number of cells written to buffer, 0 on invalid message id
+ */
+native get_user_msgname(msgid, name[], len);
+
+/**
+ * Returns a unique id for a public variable.
+ *
+ * @note Variables declared with the "public" specifier are accessible by-name
+ *       from outside of the declaring plugin.
+ * @note If multiple plugins declare the same public variable, this native will
+ *       still return a unique id.
+ *
+ * @param name      Variable name
+ *
+ * @return          Xvar id on success, -1 on failure
+ */
+native get_xvar_id(const name[]);
+
+/**
+ * Returns if a public variable exists in any loaded plugin.
+ *
+ * @param name      Variable name
+ *
+ * @return          1 if public cvar exists, 0 otherwise
+ */
+native xvar_exists(const name[]);
+
+/**
+ * Returns the integer value of a public variable.
+ *
+ * @note If multiple plugins declare the same public variable, they are not
+ *       automatically synchronized. The xvar system accesses only one of all
+ *       public variables directly. Xvars have to be read through the natives or
+ *       the value will be incorrect.
+ *
+ * @param id    Xvar id, an xvar id can be retrieved using get_xvar_id()
+ *
+ * @return      Xvar integer value
+ */
+native get_xvar_num(id);
+
+/**
+ * Returns the float value of a public variable.
+ *
+ * @note If multiple plugins declare the same public variable, they are not
+ *       automatically synchronized. The xvar system accesses only one of all
+ *       public variables directly. Xvars have to be read through the natives or
+ *       the value will be incorrect.
+ *
+ * @param id    Xvar id, an xvar id can be retrieved using get_xvar_id()
+ *
+ * @return      Xvar float value
+ */
+native Float:get_xvar_float(id);
+
+/**
+ * Sets the integer value of a public variable.
+ *
+ * @note If multiple plugins declare the same public variable, they are not
+ *       automatically synchronized. The xvar system accesses only one of all
+ *       public variables directly. Xvars have to be set through the natives or
+ *       the xvar will not be updated.
+ *
+ * @param id        Xvar id, an xvar id can be retrieved using get_xvar_id()
+ * @param value     Value to set
+ *
+ * @noreturn
+ * @error           If an invalid xvar id is specified, an error will be thrown.
+ */
+native set_xvar_num(id, value = 0);
+
+/**
+ * Sets the float value of a public variable.
+ *
+ * @note If multiple plugins declare the same public variable, they are not
+ *       automatically synchronized. The xvar system accesses only one of all
+ *       public variables directly. Xvars have to be set through the natives or
+ *       the xvar will not be updated.
+ *
+ * @param id        Xvar id, an xvar id can be retrieved using get_xvar_id()
+ * @param value     Value to set
+ *
+ * @noreturn
+ * @error           If an invalid xvar id is specified, an error will be thrown.
+ */
+native set_xvar_float(id, Float:value = 0.0);
+
+/**
+ * Returns if a module is loaded.
+ *
+ * @param name      Module name
+ *
+ * @return          Module id of the matching module, -1 otherwise
+ */
+native is_module_loaded(const name[]);
+
+/**
+ * Retrieves info about a module by module index.
+ *
+ * @note For a list of possible status flags, see module_* constants in
+ *       amxconst.inc
+ *
+ * @param id            Module id
+ * @param name          Buffer to copy module name to
+ * @param nameLen       Maximum name buffer size
+ * @param author        Buffer to copy module author to
+ * @param authorLen     Maximum author buffer size
+ * @param version       Buffer to copy module version to
+ * @param versionLen    Maximum version buffer size
+ * @param status        Variable to store module status to
+ *
+ * @return              Module id on success, -1 on invalid module
+ */
+native get_module(id, name[], nameLen, author[], authorLen, version[], versionLen, &status);
+
+/**
+ * Returns the number of currently registered modules.
+ *
+ * @return  Number of modules
+ */
+native get_modulesnum();
+
+/**
+ * Returns if a plugin is loaded by registered name or filename.
+ *
+ * @note An example for a registered name would be "Admin Base", while a possible
+ *       filename would be "admin.amxx".
+ * @note Prior to AMXX 1.80, this function would only search for plugins
+ *       registered names, not the filename.
+ * @note The plugin name matching is case insensitive, while the filename
+ *       matching is case sensitive.
+ *
+ * @param name          Plugin name or filename
+ * @param usefilename   If true searches for plugin filename, false searches for
+ *                      plugin name
+ *
+ * @return              Plugin id of the matching plugin, -1 otherwise
+ */
+native is_plugin_loaded(const name[], bool:usefilename = false);
+
+/**
+ * Retrieves info about a plugin by plugin index.
+ *
+ * @param index     Plugin index, -1 to target calling plugin
+ * @param filename  Buffer to copy plugin filename to
+ * @param len1      Maximum filename buffer size
+ * @param name      Buffer to copy plugin name to
+ * @param len2      Maximum name buffer size
+ * @param version   Buffer to copy plugin version to
+ * @param len3      Maximum version buffer size
+ * @param author    Buffer to copy plugin author to
+ * @param len4      Maximum author buffer size
+ * @param status    Buffer to copy plugin status flags to
+ * @param len5      Maximum status buffer size
+ * @param url       Buffer to copy plugin url to
+ * @param len6      Maximum url buffer size
+ * @param desc      Buffer to copy plugin description to
+ * @param len7      Maximum description buffer size
+ *
+ * @return          Plugin index on success, -1 if there is no plugin with given
+ *                  index
+ */
+native get_plugin(index, filename[] = "", len1 = 0, name[] = "", len2 = 0, version[] = "", len3 = 0, author[] = "", len4 = 0, status[] = "", len5 = 0, url[] = "", len6 = 0, desc[] = "", len7 = 0);
+
+/**
+ * Returns the number of loaded AMXX plugins.
+ *
+ * @return  Number of loaded plugins
+ */
+native get_pluginsnum();
+
+/**
+ * Pauses a plugin so it will not be executed until it is unpaused.
+ *
+ * @note This used to be able to pause specific functions, but this functionality
+ *       (along with the flags "b" and "e") has been deprecated.
+ * @note If used without flag "c" this will pause the calling plugin.
+ *
+ * @param flag      Pause flags
+ *                    "a" - pause plugin
+ *                    "c" - search for other plugins using param1
+ *                    "d" - stop plugin, making it unavailable to unpause
+ * @param param1    Plugin filename
+ * @param param2    Unused and ignored
+ *
+ * @return          1 on success, 0 otherwise
+ * @error           If it is attempted to use the deprecated functionality,
+ *                  an error is thrown.
+ */
+native pause(const flag[], const param1[] = "", const param2[] = "");
+
+/**
+ * Unpauses a plugin so it will resume execution if it was previously paused.
+ *
+ * @note This used to be able to unpause specific functions, but this
+ *       functionality (along with the flags "b" and "e") has been deprecated.
+ * @note Without specifying flag "c" this function will do nothing, as a plugin
+ *       is incapable of unpausing itself. This is a relict of the deprecated
+ *       functionality.
+ *
+ * @param flag      Pause flags
+ *                    "a" - pause plugin
+ *                    "c" - search for other plugins using param1
+ * @param param1    Plugin filename
+ * @param param2    Unused and ignored
+ *
+ * @return          1 on success, 0 otherwise
+ * @error           If it is attempted to use the deprecated functionality,
+ *                  an error is thrown.
+ */
+native unpause(const flag[], const param1[] = "", const param2[] = "");
+
+/**
+ * Initiates a function call to this or another plugin by function name.
+ *
+ * @note This only sets up the function call and covers the pre-requisites.
+ *       Push parameters using the callfunc_push_* set of functions. The call
+ *       will be executed only upon using callfunc_end()
+ *
+ * @param func      Function name
+ * @param plugin    Plugin filename, if empty the calling plugin is targeted
+ *                  The filename has to be the full exact name (e.g. stats.amxx)
+ *
+ * @return           1 on success
+ *                   0 on runtime error
+ *                  -1 if plugin was not found
+ *                  -2 if function was not found
+ * @error           If called while another callfunc has not yet been finished,
+ *                  an error is thrown.
+ */
+native callfunc_begin(const func[], const plugin[] = "");
+
+/**
+ * Initiates a function call to this or another plugin by function id.
+ *
+ * @note This only sets up the function call and covers the pre-requisites.
+ *       Push parameters using the callfunc_push_* set of functions. The call
+ *       will be executed only upon using callfunc_end()
+ * @note The function id can be retrieved by get_func_id()
+ *
+ * @param func      Function id
+ * @param plugin    Plugin filename, if empty the calling plugin is targeted
+ *                  The filename has to be the full exact name (e.g. stats.amxx)
+ *
+ * @return           1 on success
+ *                  -1 if plugin was not found
+ *                  -2 if function is not executable
+ * @error           If called while another callfunc has not yet been finished,
+ *                  or the specified function is invalid, an error is thrown.
+ */
+native callfunc_begin_i(func, plugin = -1);
+
+/**
+ * Retrieves a functions id for use with callfunc_begin_i()
+ *
+ * @param funcName  Function name
+ * @param pluginId  Plugin id, if -1 the calling plugin is targeted
+ *                  The plugin id can be retrieved using find_plugin_byfile()
+ *
+ * @return          >=0 Function id on success
+ *                  -1 if plugin or function was not found
+ */
+native get_func_id(const funcName[], pluginId = -1);
+
+/**
+ * Pushes an int value onto the current call.
+ *
+ * @param value     Int value to push
+ *
+ * @noreturn
+ * @error           If called without initiating a callfunc, or the maximum
+ *                  amount of parameters is reached, an error is thrown.
+ */
+native callfunc_push_int(value);
+
+/**
+ * Pushes a float value onto the current call.
+ *
+ * @param value     Float value to push
+ *
+ * @noreturn
+ * @error           If called without initiating a callfunc, or the maximum
+ *                  amount of parameters is reached, an error is thrown.
+ */
+native callfunc_push_float(Float: value);
+
+/**
+ * Pushes an int value reference onto the current call.
+ *
+ * @note Changes made to this value by the called function will be reflected
+ *       in the calling plugin.
+ *
+ * @param value     Int value to push
+ *
+ * @noreturn
+ * @error           If called without initiating a callfunc, or the maximum
+ *                  amount of parameters is reached, an error is thrown.
+ */
+native callfunc_push_intrf(&value);
+
+/**
+ * Pushes a float value reference onto the current call.
+ *
+ * @note Changes made to this value by the called function will be reflected
+ *       in the calling plugin.
+ *
+ * @param value     Float value to push
+ *
+ * @noreturn
+ * @error           If called without initiating a callfunc, or the maximum
+ *                  amount of parameters is reached, an error is thrown.
+ */
+native callfunc_push_floatrf(&Float:value);
+
+/**
+ * Pushes a string onto the current call.
+ *
+ * @note This will defy the "const" specifier if copyback is true, which is
+ *       only kept for special backwards compatibility.
+ *
+ * @param VALUE     String to push
+ * @param copyback  If true, any changes made in the called function will be
+ *                  copied back to the calling plugin
+ *
+ * @noreturn
+ * @error           If called without initiating a callfunc, or the maximum
+ *                  amount of parameters is reached, an error is thrown.
+ */
+native callfunc_push_str(const VALUE[], bool:copyback = true);
+
+/**
+ * Pushes an array onto the current call.
+ *
+ * @note This will defy the "const" specifier if copyback is true, which is
+ *       only kept for special backwards compatibility.
+ *
+ * @param VALUE         Array to push
+ * @param array_size    Size of the array
+ * @param copyback      If true, any changes made in the called function will be
+ *                      copied back to the calling plugin
+ *
+ * @noreturn
+ * @error           If called without initiating a callfunc, or the maximum
+ *                  amount of parameters is reached, an error is thrown.
+ */
+native callfunc_push_array(const VALUE[], array_size, bool:copyback = true);
+
+/**
+ * Completes the call to a function.
+ *
+ * @return       1 on success
+ *              -1 if the plugin was not found
+ *              -2 if the function was not found
+ * @error       If called without initiating a callfunc, an error is thrown.
+ */
+native callfunc_end();
+
+/**
+ * Called when an inconsistent file is encountered by the engine.
+ *
+ * @param id        Client index
+ * @param filename  Detected file
+ * @param reason    Buffer storing the disconnect reason (can be overwritten)
+ *
+ * @return          PLUGIN_CONTINUE to let the engine kick the client
+ *                  PLUGIN_HANDLED to block the inconsistency kick
+ */
+forward inconsistent_file(id, const filename[], reason[64]);
+
+/**
+ * Forces the clients and server to be running with the same version of a
+ * specified file.
+ *
+ * @note For a list of possible enforcement types, see the force_* constants
+ *       in amxconst.inc
+ *
+ * @param force_type    Enforcement type
+ * @param mins          Bounding box mins vector
+ * @param maxs          Bounding box maxs vector
+ * @param filename      Filename
+ *
+ * @return              1 on success, 0 otherwise
+ */
+native force_unmodified(force_type, const mins[3], const maxs[3], const filename[]);
+
+/**
+ * Calculates the MD5 keysum of a string.
+ *
+ * @param szString      String to calculate keysum of
+ * @param md5buffer     Buffer to copy the MD5 hash to
+ *
+ * @return              Number of cells written to the buffer (always 32)
+ */
+#pragma deprecated Use hash_string() function. Also, see Hash_* constants.
+native md5(const szString[], md5buffer[34]);
+
+/**
+ * Calculates the MD5 keysum of a file.
+ *
+ * @param file          Path to file to calculate keysum of
+ * @param md5buffer     Buffer to copy the MD5 hash to
+ *
+ * @return              Number of cells written to the buffer (always 32)
+ * @error               If the file can not be opened, and error is thrown.
+ */
+#pragma deprecated Use hash_file() function. Also, see Hash_* constants.
+native md5_file(const file[], md5buffer[34]);
+
+/**
+ * Generate a hash value (message digest)
+ *
+ * @param string        String to be hashed.
+ * @param type          Type of selected hashing algorithm. See Hash_* constants in amxconst.inc file.
+ * @param output        Output string to store hash in.
+ * @param outputSize    The maximum size of the output string to store hash in.
+ *
+ * @return              Number of written bytes.
+ */
+native hash_string(const string[], const HashType:type, output[], const outputSize);
+
+/**
+ * Generate a hash value using the contents of a given file
+ *
+ * @param fileName      Path of file to be hashed.
+ * @param type          Type of selected hashing algorithm. See Hash_* constants in amxconst.inc file.
+ * @param output        Output string to store hash in.
+ * @param outputSize    The maximum size of the output string to store hash in.
+ *
+ * @return              Number of written bytes.
+ * @error               If the file couldn't be opened, an error is thrown.
+ */
+native hash_file(const fileName[], const HashType:type, output[], const outputSize);
+
+/**
+ * Returns the internal flags set on the plugin's state.
+ *
+ * @param hdr       If nonzero, the function will return the pcode rather than
+ *                  state flags
+ * @param plid      Plugin id, -1 to target calling plugin
+ *
+ * @return          Plugin flags
+ */
+native plugin_flags(hdr = 0, plid = -1);
+
+/**
+ * Allows plugins to declare module dependencies using require_module()
+ *
+ * @deprecated Module dependency has been automatically handled by the compiler
+ *             since AMXX 1.50, released in 2005. This forward is no longer
+ *             called.
+ *
+ * @noreturn
+ */
+#pragma deprecated Module dependency is now automatically handled by the compiler. This forward is no longer called.
+forward plugin_modules();
+
+/**
+ * Adds a module dependency.
+ *
+ * @deprecated Module dependency has been automatically handled by the compiler
+ *             since AMXX 1.50, released in 2005. This native has no effect.
+ *
+ * @noreturn
+ */
+#pragma deprecated Module dependency is now automatically handled by the compiler. This native has no effect.
+native require_module(const module[]);
+
+/**
+ * Returns if the server is 64 bit.
+ *
+ * @deprecated As a result of Valve dropping support for 64bit binaries, AMXX is
+ *             also not shipping 64bit builds anymore. This native is basically
+ *             guaranteed to return 0.
+ *
+ * @return  1 if the server is 64 bit, 0 otherwise
+ */
+#pragma deprecated AMXX is not shipping 64bits builds anymore. This native is basically guaranteed to return 0.
+native is_amd64_server();
+
+/**
+ * Returns plugin id by filename.
+ *
+ * @param filename      Filename to match
+ * @param ignoreCase    If nonzero matches case insensitively, case sensitively
+ *                      otherwise
+ *
+ * @return              Plugin id, -1 (INVALID_PLUGIN_ID) on failure
+ */
+native find_plugin_byfile(const filename[], ignoreCase = 1);
+
+/**
+ * Called before plugin_init(), allows the plugin to register natives.
+ *
+ * @noreturn
+ */
+forward plugin_natives();
+
+/**
+ * Registers a native.
+ *
+ * @note Style 0 natives call the handler in the following manner:
+ *
+ * public native_handler(plugin_id, argc)
+ *
+ *   plugin_id    - plugin calling the native
+ *   argc         - number of parameters
+ *
+ * @note Style 1 natives are deprecated. Plugins should not use them, they might
+ *       break.
+ * @note Style 1 natives work a little different. Instead of passing plugin id
+ *       and number of parameters, the handler should be prototyped just like the
+ *       native would be called. For each by-reference parameter, the plugin
+ *       then has to use param_convert() to properly use them.
+ * @note A native should *never* recurse. Bad things will happen.
+ *
+ * @param name      Native name
+ * @param handler   Callback function
+ * @param style     Native style
+ *
+ * @noreturn
+ * @error           If an invalid callback is specified, an error is thrown.
+ */
+native register_native(const name[], const handler[], style = 0);
+
+/**
+ * Registers the plugin as a library.
+ *
+ * @note To mark a library as required, place the following in the include
+ *       file:
+ *       #pragma reqlib <name>
+ *       #if !defined AMXMODX_NOAUTOLOAD
+ *          #pragma loadlib <name>
+ *       #endif
+ *
+ * @noreturn
+ */
+native register_library(const library[]);
+
+/**
+ * Logs an error in the native and breaks into the AMXX debugger.
+ *
+ * @note This acts as if the calling plugin - the plugin that is calling the
+ *       native, not the plugin calling this function - triggered the error,
+ *       just like when AMXX natives error.
+ *
+ * @param error     Error number
+ * @param fmt       Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @noreturn
+ * @error           The function is guaranteed to throw an error, but will make
+ *                  it appear as if the plugin calling the native triggered it.
+ */
+native log_error(error, const fmt[], any:...);
+
+/**
+ * Converts a parameter to work as a by-reference parameter.
+ *
+ * @deprecated Style 1 natives are deprecated and should be converted to
+ *             style 0. This should not be used.
+ *
+ * @note This only needs to be called if the native was registered with style 1.
+ * @note Remember that arrays (and strings) are always by-reference and need to
+ *       be converted.
+ *
+ * @param num       Argument to convert, starting from 1
+ *
+ * @noreturn
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 0, an error will be thrown.
+ */
+native param_convert(num);
+
+/**
+ * Retrieves a string from the plugin calling the native.
+ *
+ * @param param     Argument to retrieve, starting from 1
+ * @param dest      Buffer to copy string to
+ * @param maxlen    Maximum size of buffer
+ *
+ * @return          Number of cells copied to buffer
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native get_string(param, dest[], maxlen);
+
+/**
+ * Copies a string to the plugin calling the native.
+ *
+ * @param param     Argument to set, starting from 1
+ * @param dest      Buffer to copy string from
+ * @param maxlen    Maximum size of buffer
+ *
+ * @return          Number of cells copied from buffer
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native set_string(param, dest[], maxlen);
+
+/**
+ * Returns the integer value of a parameter from the plugin calling the native.
+ *
+ * @param param     Argument to retrieve, starting from 1
+ *
+ * @return          Integer value
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native get_param(param);
+
+/**
+ * Returns the float value of a parameter from the plugin calling the native.
+ *
+ * @param param     Argument to retrieve, starting from 1
+ *
+ * @return          Float value
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native Float:get_param_f(param);
+
+/**
+ * Returns the integer value of a by-reference parameter from the plugin calling
+ * the native.
+ *
+ * @param param     Argument to retrieve, starting from 1
+ *
+ * @return          Integer value
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native get_param_byref(param);
+
+/**
+ * Returns the float value of a by-reference parameter from the plugin calling
+ * the native.
+ *
+ * @param param     Argument to retrieve, starting from 1
+ *
+ * @return          Float value
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native Float:get_float_byref(param);
+
+/**
+ * Sets the integer value of a by-reference parameter to the plugin calling the
+ * native.
+ *
+ * @param param     Argument to set, starting from 1
+ * @param value     Value to set parameter to
+ *
+ * @noreturn
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native set_param_byref(param, value);
+
+/**
+ * Sets the float value of a by-reference parameter to the plugin calling the
+ * native.
+ *
+ * @param param     Argument to set, starting from 1
+ * @param value     Value to set parameter to
+ *
+ * @noreturn
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native set_float_byref(param, Float:value);
+
+/**
+ * Retrieves an array from the plugin calling the native.
+ *
+ * @param param     Argument to retrieve, starting from 1
+ * @param dest      Buffer to copy array to
+ * @param maxlen    Size of buffer
+ *
+ * @noreturn
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native get_array(param, dest[], size);
+
+/**
+ * Retrieves a float array from the plugin calling the native.
+ *
+ * @param param     Argument to retrieve, starting from 1
+ * @param dest      Buffer to copy array to
+ * @param maxlen    Size of buffer
+ *
+ * @noreturn
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native get_array_f(param, Float:dest[], size);
+
+/**
+ * Copies an array to the plugin calling the native.
+ *
+ * @param param     Argument to set, starting from 1
+ * @param source    Buffer to copy array from
+ * @param maxlen    Size of buffer
+ *
+ * @noreturn
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native set_array(param, const source[], size);
+
+/**
+ * Copies a float array to the plugin calling the native.
+ *
+ * @param param     Argument to set, starting from 1
+ * @param source    Buffer to copy array from
+ * @param maxlen    Size of buffer
+ *
+ * @noreturn
+ * @error           If used outside of a native callback, or the native was
+ *                  created with style 1, an error will be thrown.
+ */
+native set_array_f(param, const Float:source[], size);
+
+/**
+ * Allows to trap error messages that occur in a plugin.
+ *
+ * @note This can be used to override the debug messages that occur when the
+ *       plugin causes some kind of runtime error.
+ * @note The handler will be called in the following manner:
+ *
+ * public error_filter(error_code, bool:debugging, message[])
+ *
+ *   error_code      - AMX_ERR_* code.
+ *   debugging       - True if the plugin is in debug mode, false otherwise
+ *   message[]       - Message sent along with the error
+ *
+ * @note The handler should return PLUGIN_CONTINUE to let the error through the
+ *       filter, or PLUGIN_HANDLED to block the error from displaying.
+ *
+ * @param handler       Function name to call
+ *
+ * @noreturn
+ * @error               If an invalid callback function is provided, an error
+ *                      is thrown.
+ */
+native set_error_filter(const handler[]);
+
+/**
+ * Returns a trace handle for the item at the top of the traced call stack.
+ *
+ * @note Intended for use inside an error handler set with set_error_filter()
+ *
+ * @return      Trace handle, 0 if no debugging information is available
+ */
+native dbg_trace_begin();
+
+/**
+ * Returns the next item in a traced call stack.
+ *
+ * @param trace     Trace handle
+ *
+ * @return          New trace handle, 0 if no more traces exist
+ */
+native dbg_trace_next(trace);
+
+/**
+ * Retrieves the call stack info for a trace.
+ *
+ * @param trace         Trace handle
+ * @param line          Variable to set line at which plugin failed to
+ * @param function      Buffer to copy function to
+ * @param maxLength1    Maximum function buffer size
+ * @param file          Buffer to copy filename to
+ * @param maxLength2    Maximum filename buffer size
+ *
+ * @return              1 on success, 0 if no trace data is available
+ */
+native dbg_trace_info(trace, &line, function[], maxLength1, file[], maxLength2);
+
+/**
+ * Retrieves the formatted error string from a trace.
+ *
+ * @note The string format is generally: "Run time error <errno>: <description>"
+ *
+ * @param buffer        Buffer to copy error message to
+ * @param maxLength     Maximum buffer size
+ *
+ * @return              1 on success, 0 if no trace data is available
+ */
+native dbg_fmt_error(buffer[], maxLength);
+
+/**
+ * Sets a native filter, letting the plugin intercept and handle an
+ * automatic native requirement.
+ *
+ * @note This has to be used inside the plugin_native() forward, otherwise it
+ *       has no effect.
+ * @note This is useful for creating plugins that can dynamically decide which
+ *       modules or features to use at runtime, often necessary for cross-mod
+ *       plugins. It allows to deploy a single version of the plugin instead
+ *       of compiling multiple versions for each use-case.
+ * @note The handler will be called in the following manner:
+ *
+ * public native_filter(const native[], index, trap)
+ *
+ *   native      - Native name
+ *   index       - Native index
+ *   trap        - 0 if native couldn't be found, 1 if native use was attempted
+ *
+ * @note The handler should return PLUGIN_CONTINUE to let the error through the
+ *       filter (which will throw a run-time error), or return PLUGIN_HANDLED
+ *       to continue operation.
+ * @note Returning PLUGIN_CONTINUE if trap is 0 will result in the plugin
+ *       failing to load!
+ *
+ * @param handler   Function name to call
+ *
+ * @return          1 if handler is set successfully, 0 otherwise (called
+ *                  outside of plugin_native() forward)
+ * @error           If an invalid callback function is provided, an error is
+ *                  thrown.
+ */
+native set_native_filter(const handler[]);
+
+/**
+ * Sets a module/library filter, letting the plugin intercept and handle an
+ * automatic module requirement.
+ *
+ * @note This has to be used inside the plugin_native() forward, otherwise it
+ *       has no effect.
+ * @note This is useful for creating plugins that can dynamically decide which
+ *       modules or features to use at runtime, often necessary for cross-mod
+ *       plugins. It allows to deploy a single version of the plugin instead
+ *       of compiling multiple versions for each use-case.
+ * @note For a list of possible libtypes see the LibType enum in amxconst.inc
+ * @note The handler will be called in the following manner:
+ *
+ * public module_filter(const library[], LibType:type)
+ *
+ *   library     - Shortname of library or class that is required
+ *   libtrype    - Type of requirement being checked (library/module or class)
+ *
+ * @note The handler should return PLUGIN_CONTINUE to let the error through the
+ *       filter (which will result in the plugin failing to load), or
+ *       PLUGIN_HANDLED to imply that load can continue without the module.
+ * @note Errors occuring inside the handler will not be filtered and cause the
+ *       plugin to fail load as if the handler returned PLUGIN_CONTINUE.
+ *
+ * @return      0 on success, -1 if filtering is not available, -2 if handler
+ *              could not be found.
+ */
+native set_module_filter(const handler[]);
+
+/**
+ * Aborts execution of the current callback by throwing an error.
+ *
+ * @note Warning: This function should not be used inside error filters, module
+ *       filters (native filters are safe if trap equals 1) or the
+ *       plugin_natives() forward.
+ * @note The message will automatically be tagged with the plugin's name and the
+ *       log will include a timestamp with the message.
+ * @note For a list of possible error codes, see AMX_* constants in amxconst.inc
+ *
+ * @param error     Error code
+ * @param fmt       Formatting rules
+ * @param ...       Variable list of formatting parameters
+ *
+ * @noreturn
+ * @error           The function is guaranteed to throw an error, using the
+ *                  specified custom log message.
+ */
+native abort(error, const fmt[] = "", any:...);
+
+/**
+ * Returns if a specific module is loaded.
+ *
+ * @note This uses the same method AMXX uses internally to see if a module is
+ *       required by a plugin.
+ * @note Example usage: module_exists("cstrike")
+ *
+ * @param logtag    Module shortname
+ *
+ * @return          1 if module is loaded, 0 otherwise
+ */
+native module_exists(const logtag[]);
+
+/**
+ * Returns if a specific library or class is loaded.
+ *
+ * @note This is the newer version of module_exists(), enabling users to
+ *       distinguish between libraries and classes, while module_exists() always
+ *       checks for both types.
+ * @note For a list of possible types, see the LibType enum in amxconst.inc
+ *
+ * @param library   Library/Class shortname
+ * @param type      Type to search for
+ *
+ * @return          1 if module is loaded, 0 otherwise
+ */
+native LibraryExists(const library[], LibType:type);
+
+/**
+ * Returns the next valid hudchannel for the client.
+ *
+ * @note This function uses the same method set_hudmessage() uses to determine
+ *       the next channel if it is set to auto-select.
+ *
+ * @param player    Client index
+ *
+ * @return          Valid hudchannel (1-4)
+ * @error           If the index is not within the range of 1 to MaxClients or
+ *                  the client is not connected, an error will be thrown.
+ */
+native next_hudchannel(player);
+
+/**
+ * Creates a HUD synchronization object.
+ *
+ * @note Create one of these for each section of the screen that contains
+ *       overlapping HUD messages. For example, if using both sides of the
+ *       screen to display three messages that could potentially overlap,
+ *       each side is considered a synchronizable area. You can then use
+ *       ShowSyncHudMsg() to correctly synchronize displaying the HUD message
+ *       with any other messages potentially in its class.
+ * @note This does not do anything like reserving screen area. Its sole
+ *       purpose is to be able to wipe an old message on an auto-channel and
+ *       ensure that it will not clear a message from another plugin.
+ *
+ * @param num   Unused and ignored
+ * @param ...   Unused and ignored
+ *
+ * @return      HUD sync object handle
+ */
+native CreateHudSyncObj(num = 0, ...);
+
+/**
+ * Displays a synchronized HUD message.
+ *
+ * @note This will check that the HUD object has its previous display on the
+ *       screen cleared before it proceeds to write another message. It will
+ *       only do this in the case of that channel not having been cleared
+ *       already.
+ * @note This uses the display parameters set with set_hudmessage(), ignoring
+ *       the selected channel in favor of its own synchronization.
+ * @note This functions return value behaves differently depending on what is
+ *       used as the client index: If 0 is specified, then the function will
+ *       return 0 if nothing has been sent (no client connected). If either a
+ *       single client is specified, or there is at least one client connected,
+ *       the number of printed characters will refer to the message that is sent
+ *       last, to the client with the highest index.
+ *
+ * @param target    Client index, use 0 to display to all clients
+ * @param syncObj   HUD sync object handle
+ * @param fmt       Formatting rules
+ * @param ...       Variable number of formatting parameters
+ *
+ * @return          Number of printed characters
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native ShowSyncHudMsg(target, syncObj, const fmt[], any:...);
+
+/**
+ * Clears the display on a HUD sync object.
+ *
+ * @note This sends an empty message to the previously occupied HUD channel.
+ *       It is not quite the same as manually sending an empty message to the
+ *       sync object as that would send out two separate messages, one for
+ *       clearing the occupied channel and another using a new channel, which
+ *       will subsequently not mark the sync object as cleared.
+ *
+ * @param target    Client index, use 0 to display to all clients
+ * @param syncObj   HUD sync object handle
+ *
+ * @noreturn
+ * @error           If a single client is specified and the index is not within
+ *                  the range of 1 to MaxClients, an error will be thrown.
+ */
+native ClearSyncHud(target, syncObj);
+
+/**
+ * Triggers the software interrupt 3, used for breaking into an attached
+ * debugger.
+ *
+ * @note Warning: This is a debugging function that is not intended for general
+ *       plugin use. Using this function will either halt the server and break
+ *       into the attached debugger, or outright crash the server if no
+ *       debugger is attached.
+ *
+ * @noreturn
+ */
+native int3();
+
+/**
+ * Sets the calling plugin to a failed state.
+ *
+ * @note Calling this will cause the calling plugin to completely cease
+ *       operation. It is not possible to recover.
+ * @note This should be used to gracefully handle fatal errors. The log message
+ *       will appear in the AMXX error log.
+ *
+ * @param fmt   Formatting rules
+ * @param ...   Variable number of formatting parameters
+ *
+ * @noreturn
+ * @error       The function is guaranteed to throw a fatal error, ceasing
+ *              further operation of the plugin.
+ */
+native set_fail_state(const fmt[], any:...);
+
+/**
+ * Returns the reference address of the variable passed in.
+ *
+ * @note Addresses are local to the plugin and do not represent a full CPU
+ *       address.
+ *
+ * @param ...   Variable to retrieve address from
+ *
+ * @return      Variable address
+ */
+native get_var_addr(any:...);
+
+/**
+ * Returns the value of an address.
+ *
+ * @note Addresses can be acquired using get_var_addr()
+ *
+ * @param addr      Variable address
+ *
+ * @return          Value at address
+ * @error           If the plugin attempts to access an address outside of the
+ *                  stack or heap limits of the plugin, an error will be thrown.
+ */
+native get_addr_val(addr);
+
+/**
+ * Sets the value of an address.
+ *
+ * @note Addresses can be acquired using get_var_addr()
+ *
+ * @param addr      Variable address
+ * @param val       Value to set
+ *
+ * @noreturn
+ * @error           If the plugin attempts to access an address outside of the
+ *                  stack or heap limits of the plugin, an error will be thrown.
+ */
+native set_addr_val(addr, val);
+
+/**
+ * Creates a global forward that will be called in all plugins.
+ *
+ * @note For a list of valid stop types, see the ET_* constants in amxconst.inc
+ * @note For a list of valid parameter types, see the FP_* constants in
+ *       amxconst.inc
+ *
+ * @param name          Function name to call
+ * @param stop_type     Treatment of the plugin return values
+ * @param ...           List of parameter types
+ *
+ * @return              Forward handle, -1 on failure
+ */
+native CreateMultiForward(const name[], stop_type, ...);
+
+/**
+ * Creates a private forward that will be called in a single plugin.
+ *
+ * @note Unlike other natives expecting a plugin id, specifying -1 will not
+ *       select the calling plugin, and instead throw an error.
+ *
+ * @param plugin_id     Plugin to call forward in. The plugin id can be
+ *                      retrieved using find_plugin_byfile()
+ * @param name          Function name to call
+ * @param ...           List of parameter types
+ *
+ * @return              Forward handle, -1 on failure
+ * @error               If an invalid plugin id is specified, an error will be
+ *                      thrown.
+ */
+native CreateOneForward(plugin_id, const name[], ...);
+
+/**
+ * Prepares an array for use in a forward. Pass the result ExecuteForward()
+ * instead of the array itself.
+ *
+ * @param array         Array to prepare
+ * @param size          Size of array
+ * @param copyback      If nonzero, modifications made by the called plugin(s)
+ *                      will be copied back to the caller
+ *
+ * @return              Special handle for use in ExecuteForward()
+ */
+native PrepareArray(const array[], size, copyback = 0);
+
+/**
+ * Executes a forward.
+ *
+ * @note Passing arrays requires them to be prepared using PrepareArray()
+ *
+ * @param forward_handle    Forward handle
+ * @param ret               Optional variable to store return value in
+ * @param ...               Variable number of parameters to pass through
+ *
+ * @return                  1 on success, 0 if forward can't be executed
+ * @error                   If the number of parameters mismatch from the number
+ *                          of parameters that the forward was declared with,
+ *                          an error is thrown.
+ */
+native ExecuteForward(forward_handle, &ret = 0, any:...);
+
+/**
+ * Destroys and deallocates a forward.
+ *
+ * @note Does not distinguish between private and global forwards.
+ *
+ * @param forward_handle    Forward handle
+ *
+ * @noreturn
+ */
+native DestroyForward(forward_handle);
+
+/**
+ * Sets all elements of array to a specified value.
+ *
+ * @param array     Array to modify
+ * @param value     Value to set each element to
+ * @param size      Size of array
+ *
+ * @noreturn
+ */
+native arrayset(any:array[], any:value, size);
+
+/**
+ * Returns the weapon id associated with a weapon name.
+ *
+ * @note The weapon name is case sensitive and has the weapon_* form.
+ *
+ * @param name      Weapon name
+ *
+ * @return          Weapon id, or 0 if no id was found
+ */
+native get_weaponid(const name[]);
+
+/**
+ * Adds an admin to the dynamic admin storage for lookup at a later time.
+ *
+ * @note For a list of possible access flags, see the ADMIN_* constants in
+ *       amxconst.inc
+ * @note For a list of possible auth flags, see the FLAG_* constants in
+ *       amxconst.inc
+ *
+ * @param AuthData      Auth information to set (can be name, IP or SteamID)
+ * @param Password      Password to set
+ * @param Access        Admin access flags
+ * @param Flags         Auth behavior flags
+ *
+ * @noreturn
+ */
+native admins_push(const AuthData[], const Password[], Access, Flags);
+
+/**
+ * Returns the number of admins in the dynamic admin storage.
+ *
+ * @return  Number of admins
+ */
+native admins_num();
+
+/**
+ * Retrieves information about a dynamically stored admin.
+ *
+ * @note For a list of possible props, see the AdminProp enum in amxconst.inc
+ *
+ * @param num           Admin storage index
+ * @param Property      Admin property to retrieve
+ * @param Buffer        Buffer to copy property information to, if AdminProp_Auth
+ *                      or AdminProp_Password is specified
+ * @param BufferSize    Maximum buffer size
+ *
+ * @return              Property value if AdminProp_Access or AdminProp_Flags
+ *                      is requested, 0 otherwise
+ * @error               If an invalid storage index is specified, an error will
+ *                      be thrown.
+ */
+native admins_lookup(num, AdminProp:Property, Buffer[] = "", BufferSize = 0);
+
+/**
+ * Clears the list of dynamically stored admins.
+ *
+ * @noreturn
+ */
+native admins_flush();
+
+/**
+ * Returns if a map contains at least one entity with the provided class name.
+ *
+ * @param classname     Entity classname to match
+ *
+ * @return              True if an entity is found, false otherwise
+ */
+native bool:has_map_ent_class(const classname[]);
+
+
+/**
+ * Called when the map has loaded, and all configs are done executing.
+ * This includes servercfgfile (server.cfg), amxx.cfg, plugin's config, and
+ * per-map config.
+ *
+ * @note This is best place to initialize plugin functions which are based on cvar data.  
+ * @note This will always be called once and only once per map.  It will be 
+ *       called few seconds after plugin_cfg().
+ *
+ * @noreturn
+ */
+forward OnConfigsExecuted();
+
+/**
+ * Called when the map has loaded, right after plugin_cfg() but any time 
+ * before OnConfigsExecuted.  It's called after amxx.cfg and  all 
+ * AutoExecConfig() exec commands have been added to the server command buffer.
+ *
+ * @note This will always be called once and only once per map.
+ *
+ * @noreturn
+ */
+forward OnAutoConfigsBuffered();
+
+/**
+ * Specifies that the given config file should be executed after plugin load.
+ *
+ * @note OnConfigsExecuted() will not be called until the config file has executed,
+ *       but it will be called if the execution fails.
+ * @note The name parameter should not contain dots, otherwise file will not be executed.
+ *
+ * @param autoCreate    If true, and the config file does not exist, such a config
+ *                      file will be automatically created and populated with
+ *                      information from the plugin's registered cvars.
+ * @param name          Name of the config file, excluding the .cfg extension.
+ *                      If empty, <plugin.filename.cfg> is assumed.
+ * @param folder        Folder under plugins/ to use.
+ *
+ * @noreturn
+ */
+native AutoExecConfig(bool:autoCreate = true, const name[] = "", const folder[] = "");
+
+/**
+ * Creates a single use hook for the next frame.
+ *
+ * @param callback      Function to be executed on the next frame.
+ * @param data          Optional data to be passed to the callback function.
+ *
+ * @note                Callback function prototype:
+ *                          public function(data)
+ *
+ * @noreturn
+ */
+native RequestFrame(const callback[], any:data = 0);
+
+// Always keep this at the bottom of this file
+#include <message_stocks>