@amxts/core 0.1.0

package/amxmodx/base/include/ns_const.inc

@@ -0,0 +1,196 @@
+// 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
+
+//
+// Natural Selection Module Constants
+//
+
+#if defined NS_CONST_INC
+	#endinput
+#endif
+#define NS_CONST_INC
+
+
+enum NSGameplay
+{
+	NSGame_CantTell,		/**< It is too soon to tell (can't find avhgameplay
+								 entity or it doesn't have private data) */
+
+	NSGame_MarineVAlien,	/**< Marine vs Aliens (standard) gameplay */
+	NSGame_MarineVMarine,	/**< Marine vs Marine */
+	NSGame_AlienVAlien,		/**< Alien  vs Alien  */
+
+	NSGame_Unknown,			/**< Can find the gameplay entity, but can't 
+								 determine gameplay type. */
+};
+
+// entity pev->iuser4 fields
+enum {
+	MASK_NONE = 0,
+	MASK_SIGHTED = 1,
+	MASK_DETECTED = 2,
+	MASK_BUILDABLE = 4,
+	MASK_BASEBUILD0 = 8,		// Base build slot #0
+	MASK_WEAPONS1 = 8,		// Marine weapons 1
+	MASK_CARAPACE = 8,		// Alien carapace
+	MASK_WEAPONS2 = 16,		// Marines weapons 2
+	MASK_REGENERATION = 16,		// Alien regeneration
+	MASK_BASEBUILD1 = 16,		// Base build slot #1
+	MASK_WEAPONS3 = 32,		// Marine weapons 3
+	MASK_REDEMPTION = 32,		// Alien redemption
+	MASK_BASEBUILD2 = 32,		// Base build slot #2
+	MASK_ARMOR1 = 64,		// Marine armor 1
+	MASK_CELERITY = 64,		// Alien celerity
+	MASK_BASEBUILD3 = 64,		// Base build slot #3
+	MASK_ARMOR2 = 128,		// Marine armor 2
+	MASK_ADRENALINE = 128,		// Alien adrenaline
+	MASK_BASEBUILD4 = 128,		// Base build slot #4
+	MASK_ARMOR3 = 256,		// Marine armor 3
+	MASK_SILENCE = 256,		// Alien silence
+	MASK_BASEBUILD5 = 256,		// Base build slot #5
+	MASK_JETPACK = 512,		// Marine jetpacks
+	MASK_CLOAKING = 512,		// Alien cloaking
+	MASK_BASEBUILD6 = 512,		// Base build slot #6
+	MASK_FOCUS = 1024,		// Alien focus
+	MASK_MOTION = 1024,		// Marine motion tracking
+	MASK_BASEBUILD7 = 1024,		// Base build slot #7
+	MASK_SCENTOFFEAR = 2048,	// Alien scent of fear
+	MASK_DEFENSE2 = 4096,		// Defense level 2
+	MASK_DEFENSE3 = 8192,		// Defense level 3
+	MASK_ELECTRICITY = 8192,	// Electricy
+	MASK_MOVEMENT2 = 16384,		// Movement level 2,
+	MASK_MOVEMENT3 = 32768,		// Movement level 3
+	MASK_HEAVYARMOR = 32768,	// Marine heavy armor
+	MASK_SENSORY2 = 65536,		// Sensory level 2
+	MASK_SENSORY3 = 131072,		// Sensory level 3
+	MASK_ALIEN_MOVEMENT = 262144,	// Onos is charging
+	MASK_WALLSTICKING = 524288,	// Flag for wall-sticking
+	MASK_PRIMALSCREAM = 1048576,	// Alien is in range of active primal scream
+	MASK_UMBRA = 2097152,		// In umbra
+	MASK_DIGESTING = 4194304,	// When set on a visible player, player is digesting.  When set on invisible player, player is being digested
+	MASK_RECYCLING = 8388608,	// Building is recycling
+	MASK_TOPDOWN = 16777216,	// Commander view
+	MASK_PLAYER_STUNNED = 33554432,	// Player has been stunned by stomp
+	MASK_ENSNARED = 67108864,   	// Webbed
+	MASK_ALIEN_EMBRYO = 134217728,  // Gestating
+	MASK_SELECTABLE = 268435456,	// ???
+	MASK_PARASITED = 536870912,	// Parasite flag
+	MASK_SENSORY_NEARBY = 1073741824 // Sensory chamber in range
+};
+
+
+enum {
+	CLASS_UNKNOWN = 0,
+	CLASS_SKULK,
+	CLASS_GORGE,
+	CLASS_LERK,
+	CLASS_FADE,
+	CLASS_ONOS,
+	CLASS_MARINE,
+	CLASS_JETPACK,
+	CLASS_HEAVY,
+	CLASS_COMMANDER,
+	CLASS_GESTATE,
+	CLASS_DEAD,
+	CLASS_NOTEAM
+};
+
+enum {
+	WEAPON_NONE = 0,
+	WEAPON_CLAWS,
+	WEAPON_SPIT,
+	WEAPON_SPORES,
+	WEAPON_SPIKE,
+	WEAPON_BITE,
+	WEAPON_BITE2,
+	WEAPON_SWIPE,
+	WEAPON_WEBSPINNER,
+	WEAPON_METABOLIZE,
+	WEAPON_PARASITE,
+	WEAPON_BLINK,
+	WEAPON_DIVINEWIND,
+	WEAPON_KNIFE,
+	WEAPON_PISTOL,
+	WEAPON_LMG,
+	WEAPON_SHOTGUN,
+	WEAPON_HMG,
+	WEAPON_WELDER,
+	WEAPON_MINE,
+	WEAPON_GRENADE_GUN,
+	WEAPON_LEAP,
+	WEAPON_CHARGE,
+	WEAPON_UMBRA,
+	WEAPON_PRIMALSCREAM,
+	WEAPON_BILEBOMB,
+	WEAPON_ACIDROCKET,
+	WEAPON_HEALINGSPRAY,
+	WEAPON_GRENADE,
+	WEAPON_STOMP,
+	WEAPON_DEVOUR,
+	WEAPON_MAX
+};
+
+enum {
+	HIVETRAIT_NONE	= 0,
+	HIVETRAIT_DC	= 92,
+	HIVETRAIT_SC	= 93,
+	HIVETRAIT_MC	= 94
+};
+
+enum NSPS_VelShape
+{
+	NSPS_VS_POINT = 1,
+	NSPS_VS_BOX,
+	NSPS_VS_SPHERE,
+	NSPS_VS_BLOB
+};
+
+/* Genshape used in ns_set_ps_genshape
+ * NOTE: The following are in the ns.ps file but
+ *       are not listed in the .fgd file.  Use
+ *       at your own risk!
+ *       Line, Triangle, Plane, Cylinder, 
+ *       Cone, Disc, Rectangle and None
+ */
+enum NSPS_GenShape
+{
+	NSPS_GS_POINT = 0,
+	NSPS_GS_LINE,
+	NSPS_GS_TRIANGLE,
+	NSPS_GS_PLANE,
+	NSPS_GS_BOX,
+	NSPS_GS_CYLINDER,
+	NSPS_GS_CONE,
+	NSPS_GS_BLOB,
+	NSPS_GS_DISC,
+	NSPS_GS_RECTANGLE,
+	NSPS_GS_NONE
+};
+enum NSPS_RenderMode
+{
+	NSPS_R_NORMAL = 0,
+	NSPS_R_TRANSCOLOR,
+	NSPS_R_TRANSTEXTURE,
+	NSPS_R_GLOW,
+	NSPS_R_TRANSALPHA,
+	NSPS_R_ADDITIVE
+};
+enum NSPS_Flags
+{
+	NSPS_FL_START_ON = 1,
+	NSPS_FL_PARTICLE_DENSITY = 2,
+	NSPS_FL_FADE_IN = 4,
+	NSPS_FL_FADE_OUT = 8,
+	NSPS_FL_USE_GRAVITY = 16,
+	NSPS_FL_USE_TRI = 32,
+	NSPS_FL_CONSTRAIN_PITCH = 128,
+	NSPS_FL_COLLIDE = 256,
+	NSPS_FL_HI_DETAIL = 512,
+	NSPS_FL_FACE_UP = 1024
+};

package/amxmodx/base/include/nvault.inc

@@ -0,0 +1,154 @@
+// 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
+
+//
+// NVault Functions
+//
+
+#if defined _nvault_included
+	#endinput
+#endif
+#define _nvault_included
+
+#pragma reqlib nvault
+#if !defined AMXMODX_NOAUTOLOAD
+	#pragma loadlib nvault
+#endif
+
+/**
+ * @global All timestamps are in UNIX epoch form.
+ */
+
+/**
+ * Opens a vault by name. Creates a vault if it doesn't exist yet.
+ *
+ * @param name          Name of the vault. The vault will be created in
+ *                      ${amxx_datadir}/vault directory.
+ *
+ * @return              The vault handle to be used in other natives.
+ *                      INVALID_HANDLE (-1) if not successfully opened.
+ */
+native nvault_open(const name[]);
+
+/**
+ * Retrieves a value from the given key.
+ * 
+ * @note An example of retrieving a string:
+ *       nvault_get(vaultHandle, "myKey", myString, charsmax(myString));
+ *
+ * @param vault         A vault handle returned from nvault_open()
+ * @param key           A key to get the value from
+ * @param ...           If three argument are given, gets a float value and
+ *                      puts it in the third argument by reference.
+ *                      If four arguments are given, gets a string from the
+ *                      vault and copies it to the third argument, up to 
+ *                      4th argument characters.
+ *
+ * @return              Result as integer if only the first two arguments
+ *                      of the function are used.
+ *                      1 if only the first three arguments are used.
+ *                      String length if all four parameters are used.
+ * @error               On invalid vault handle.
+ */
+native nvault_get(vault, const key[], any:...);
+
+/**
+ * Retrieves full information about a vault entry.
+ *
+ * @param vault         A vault handle returned from nvault_open()
+ * @param key           A key to get information from
+ * @param value         A string where the value should be stored
+ * @param maxlen        Maximum length of the @value string
+ * @param timestamp     The timestamp of the entry
+ *
+ * @return              1 if an entry was found, 0 otherwise.
+ * @error               On invalid vault handle.
+ */
+native nvault_lookup(vault, const key[], value[], maxlen, &timestamp);
+
+/**
+ * Sets value of a vault entry and updates the timestamp.
+ *
+ * @note A new entry is created if one with the given key doesn't exist.
+ *
+ * @param vault         A vault handle returned from nvault_open()
+ * @param key           A key to set the value for
+ * @param value         A value to set
+ *
+ * @noreturn
+ * @error               On invalid vault handle.
+ */
+native nvault_set(vault, const key[], const value[]);
+
+/**
+ * Sets value of a vault entry and makes it permanent (non-erasable with nvault_prune()).
+ *
+ * @note A new entry is created if one with the given key doesn't exist.
+ * @note Permanent entries have no timestamp.
+ *
+ * @param vault         A vault handle returned from nvault_open()
+ * @param key           A key to set the permanent value for
+ * @param value         A permanent value to set
+ *
+ * @noreturn
+ * @error               On invalid vault handle.
+ */
+native nvault_pset(vault, const key[], const value[]);
+
+/**
+ * Prunes the vault for entries that are within the given timestamps.
+ * 
+ * @note This will not erase values set with nvault_pset().
+ * @note An example of pruning all entries that are older than 24 hours:
+ *       nvault_prune(vaultHandle, 0, get_systime() - (60 * 60 * 24));
+ *
+ * @param vault         A vault handle returned from nvault_open()
+ * @param start         The timestamp to start erasing from
+ * @param end           The timestamp to erase to
+ *
+ * @return              Number of erased values.
+ * @error               On invalid vault handle.
+ */
+native nvault_prune(vault, start, end);
+
+/**
+ * Closes a vault.
+ *
+ * @param vault         A vault handle returned from nvault_open()
+ *
+ * @noreturn
+ * @error               On invalid vault handle.
+ */
+native nvault_close(vault);
+
+/**
+ * Removes an entry from the vault by its key.
+ *
+ * @param vault         A vault handle returned from nvault_open()
+ * @param key           The key to remove from the vault
+ *
+ * @noreturn
+ * @error               On invalid vault handle.
+ */
+native nvault_remove(vault, const key[]);
+
+/**
+ * "Touches" an entry in the vault, updating its timestamp.
+ * 
+ * @note If timestamp is equal to -1, it will use the current time.
+ * @note An empty entry is created if one with the given key doesn't exist.
+ *
+ * @param vault         A vault handle returned from nvault_open()
+ * @param key           The key to search for
+ * @param timestamp     Update an entry's timestamp to this one. Default is -1.
+ *
+ * @noreturn
+ * @error               On invalid vault handle.
+ */
+native nvault_touch(vault, const key[], timestamp=-1);

package/amxmodx/base/include/regex.inc

@@ -0,0 +1,348 @@
+// 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
+
+//
+// Regular Expressions API
+//
+
+#if defined _regex_included
+	#endinput
+#endif
+#define _regex_included
+
+#pragma reqlib regex
+#if !defined AMXMODX_NOAUTOLOAD
+	#pragma loadlib regex
+#endif
+
+
+enum Regex
+{
+	REGEX_MATCH_FAIL   = -2,
+	REGEX_PATTERN_FAIL = -1,
+	REGEX_NO_MATCH     =  0,
+	REGEX_OK           =  1
+};
+
+/**
+ * Flags for compiling regex expressions.
+ * These come directly from the pcre library and can be used in regex_compile_ex.
+ */
+#define PCRE_CASELESS           0x00000001  /* Ignore Case */
+#define PCRE_MULTILINE          0x00000002  /* Multilines (affects ^ and $ so that they match the start/end of a line rather than matching the start/end of the string). */
+#define PCRE_DOTALL             0x00000004  /* Single line (affects . so that it matches any character, even new line characters). */
+#define PCRE_EXTENDED           0x00000008  /* Pattern extension (ignore whitespace and # comments). */
+#define PCRE_ANCHORED           0x00000010  /* Force pattern anchoring. */
+#define PCRE_DOLLAR_ENDONLY     0x00000020  /* $ not to match newline at end. */
+#define PCRE_UNGREEDY           0x00000200  /* Invert greediness of quantifiers */
+#define PCRE_NOTEMPTY           0x00000400  /* An empty string is not a valid match. */
+#define PCRE_UTF8               0x00000800  /* Use UTF-8 Chars */
+#define PCRE_NO_UTF8_CHECK      0x00002000  /* Do not check the pattern for UTF-8 validity (only relevant if PCRE_UTF8 is set) */
+#define PCRE_NEVER_UTF          0x00010000  /* Lock out interpretation of the pattern as UTF-8 */
+#define PCRE_FIRSTLINE          0x00040000  /* Force matching to be before newline */
+#define PCRE_DUPNAMES           0x00080000  /* Allow duplicate names for subpattern */
+#define PCRE_NEWLINE_CR         0x00100000  /* Specify that a newline is indicated by a single character CR           )                            */
+#define PCRE_NEWLINE_CRLF       0x00300000  /* specify that a newline is indicated by the two-character CRLF sequence )  Overrides the default     */
+#define PCRE_NEWLINE_ANY        0x00400000  /* Specify that any Unicode newline sequence should be recognized.        )  newline definition (LF)   */
+#define PCRE_NEWLINE_ANYCRLF    0x00500000  /* Specify that any of CR, LF and CRLF sequences should be recognized     )                            */
+#define PCRE_UCP                0x20000000  /* Change the way PCRE processes \B, \b, \D, \d, \S, \s, \W, \w etc. to use Unicode properties */
+
+/**
+ * Regex expression error codes.
+ * This can be used with regex_compile_ex and regex_match_ex.
+ */
+enum /*RegexError*/
+{
+	REGEX_ERROR_NONE           =  0,    /* No error */
+	REGEX_ERROR_NOMATCH        = -1,    /* No match was found */
+	REGEX_ERROR_NULL           = -2,
+	REGEX_ERROR_BADOPTION      = -3,
+	REGEX_ERROR_BADMAGIC       = -4,
+	REGEX_ERROR_UNKNOWN_OPCODE = -5,
+	REGEX_ERROR_NOMEMORY       = -6,
+	REGEX_ERROR_NOSUBSTRING    = -7,
+	REGEX_ERROR_MATCHLIMIT     = -8,
+	REGEX_ERROR_CALLOUT        = -9,    /* Never used by PCRE itself */
+	REGEX_ERROR_BADUTF8        = -10,
+	REGEX_ERROR_BADUTF8_OFFSET = -11,
+	REGEX_ERROR_PARTIAL        = -12,
+	REGEX_ERROR_BADPARTIAL     = -13,
+	REGEX_ERROR_INTERNAL       = -14,
+	REGEX_ERROR_BADCOUNT       = -15,
+	REGEX_ERROR_DFA_UITEM      = -16,
+	REGEX_ERROR_DFA_UCOND      = -17,
+	REGEX_ERROR_DFA_UMLIMIT    = -18,
+	REGEX_ERROR_DFA_WSSIZE     = -19,
+	REGEX_ERROR_DFA_RECURSE    = -20,
+	REGEX_ERROR_RECURSIONLIMIT = -21,
+	REGEX_ERROR_NULLWSLIMIT    = -22,   /* No longer actually used */
+	REGEX_ERROR_BADNEWLINE     = -23,
+	REGEX_ERROR_BADOFFSET      = -24,
+	REGEX_ERROR_SHORTUTF8      = -25,
+	REGEX_ERROR_RECURSELOOP    = -26,
+	REGEX_ERROR_JIT_STACKLIMIT = -27,
+	REGEX_ERROR_BADMODE        = -28,
+	REGEX_ERROR_BADENDIANNESS  = -29,
+	REGEX_ERROR_DFA_BADRESTART = -30,
+	REGEX_ERROR_JIT_BADOPTION  = -31,
+	REGEX_ERROR_BADLENGTH      = -32,
+	REGEX_ERROR_UNSET          = -33
+};
+
+/**
+ * Precompile a regular expression.
+ *
+ * @note  Use this if you intend on using the same expression multiple times.
+ *        Pass the regex handle returned here to regex_match_c to check for matches.
+ *
+ * @note  This handle is automatically freed on map change.  However,
+ *        if you are completely done with it before then, you should
+ *        call regex_free on this handle.
+ *
+ * @note  Consider using regex_compile_ex instead if you want to use PCRE_* flags.
+ *
+ * @param pattern       The regular expression pattern.
+ * @param ret           Error code encountered, if applicable.
+ * @param error         Error message encountered, if applicable.
+ * @param maxLen        Maximum string length of the error buffer.
+ * @param flags         General flags for the regular expression.
+ *                      i = Ignore case
+ *                      m = Multilines (affects ^ and $ so that they match
+ *                          the start/end of a line rather than matching the
+ *                          start/end of the string).
+ *                      s = Single line (affects . so that it matches any character,
+ *                          even new line characters).
+ *                      x = Pattern extension (ignore whitespace and # comments).
+ *
+ * @return              -1 on error in the pattern, > valid regex handle (> 0) on success.
+ */
+native Regex:regex_compile(const pattern[], &ret = 0, error[] = "", maxLen = 0, const flags[]="");
+
+/**
+ * Matches a string against a pre-compiled regular expression pattern.
+ *
+ * @note  You should free the returned handle with regex_free()
+ *        when you are done with this pattern.
+ *
+ * @note  Use the regex handle passed to this function to extract
+ *        matches with regex_substr().
+ *
+ * @param string        The string to check.
+ * @param pattern       The regular expression pattern.
+ * @param ret           Error code, if applicable, or number of results on success. See REGEX_ERROR_* defines.
+ *
+ * @return              -2 = Matching error (error code is stored in ret)
+ *                       0 = No match.
+ *                      >1 = Number of results.
+ */
+native regex_match_c(const string[], Regex:pattern, &ret = 0);
+
+/**
+ * Matches a string against a regular expression pattern.
+ *
+ * @note  If you intend on using the same regular expression pattern
+ *        multiple times, consider using regex_compile and regex_match_ex
+ *        instead of making this function reparse the expression each time.
+ *
+ * @note  Flags only exist in amxmodx 1.8 and later.
+ *
+ * @note  You should free the returned handle with regex_free()
+ *        when you are done extracting all of the substrings.
+ *
+ * @param string        The string to check.
+ * @param pattern       The regular expression pattern.
+ * @param ret           Error code, or result state of the match.
+ * @param error         Error message, if applicable.
+ * @param maxLen        Maximum length of the error buffer.
+ * @param flags         General flags for the regular expression.
+ *                      i = Ignore case
+ *                      m = Multilines (affects ^ and $ so that they match
+ *                          the start/end of a line rather than matching the
+ *                          start/end of the string).
+ *                      s = Single line (affects . so that it matches any character,
+ *                          even new line characters).
+ *                      x = Pattern extension (ignore whitespace and # comments).
+ *
+ * @return              -2 = Matching error (error code is stored in ret)
+ *                      -1 = Error in pattern (error message and offset # in error and ret)
+ *                       0 = No match.
+ *                      >1 = Handle for getting more information (via regex_substr)
+ */
+native Regex:regex_match(const string[], const pattern[], &ret = 0, error[] = "", maxLen = 0, const flags[] = "");
+
+/**
+ * Returns a matched substring from a regex handle.
+ *
+ * @note  Substring ids start at 0 and end at ret - 1, where ret is from the corresponding
+ *        regex_match* function call.
+ *
+ * @param id            The regex handle to extract data from.
+ * @param str_id        The index of the expression to get - starts at 0, and ends at ret - 1.
+ * @param buffer        The buffer to set to the matching substring.
+ * @param maxLen        The maximum string length of the buffer.
+ *
+ * @return              1 on success, otherwise 0 on failure.
+ */
+native regex_substr(Regex:id, str_id, buffer[], maxLen);
+
+/**
+ * Frees the memory associated with a regex result, and sets the handle to 0.
+ *
+ * @note  This must be called on all results from regex_match() when you are done extracting
+ *        the results with regex_substr().
+ *
+ * @note  The results of regex_compile() or regex_compile_ex() (and subsequently, regex_match_c())
+ *        only need to be freed when you are done using the pattern.
+ *
+ * @note  Do not use the handle again after freeing it!
+ *
+ * @param id            The regex handle to free.
+ * @noreturn
+ */
+native regex_free(&Regex:id);
+
+
+/**
+ * The following natives are only available in 1.8.3 and above.
+ */
+
+/**
+ * Precompile a regular expression.
+ *
+ * @note  Use this if you intend on using the same expression multiple times.
+ *        Pass the regex handle returned here to regex_match_c() to check for matches.
+ *
+ * @note  Unlike regex_compile(), this allows you to use PCRE flags directly.
+ *
+ * @param pattern       The regular expression pattern.
+ * @param flags         General flags for the regular expression, see PCRE_* defines.
+ * @param error         Error message encountered, if applicable.
+ * @param maxLen        Maximum string length of the error buffer.
+ * @param errcode       Regex type error code encountered, if applicable. See REGEX_ERROR_* defines.
+ *
+ * @return              Valid regex handle (> 0) on success, or -1 on failure.
+ */
+native Regex:regex_compile_ex(const pattern[], flags = 0, error[]= "", maxLen = 0, &errcode = 0);
+
+/**
+ * Matches a string against a pre-compiled regular expression pattern, matching all
+ * occurrences of the pattern inside the string. This is similar to using the "g" flag
+ * in perl regex.
+ *
+ * @note  You should free the returned handle (with regex_free())
+ *        when you are done with this pattern.
+ *
+ * @note  Use the regex handle passed to this function to extract
+ *        matches with regex_substr().
+ *
+ * @param pattern       The regular expression pattern.
+ * @param string        The string to check.
+ * @param ret           Error code, if applicable, or number of results on success.
+ *                      See REGEX_ERROR_* defines.
+ *
+ * @return              -2 = Matching error (error code is stored in ret)
+ *                       0 = No match.
+ *                      >1 = Number of results.
+ */
+native regex_match_all_c(const string[], Regex:pattern, &ret = 0);
+
+/**
+ * Matches a string against a regular expression pattern, matching all occurrences of the
+ * pattern inside the string. This is similar to using the "g" flag in perl regex.
+ *
+ * @note  If you intend on using the same regular expression pattern
+ *        multiple times, consider using regex_compile and regex_match_ex
+ *        instead of making this function reparse the expression each time.
+ *
+ * @note  Flags only exist in amxmodx 1.8 and later.
+ *
+ * @note  You should free the returned handle with regex_free()
+ *        when you are done extracting all of the substrings.
+ *
+ * @param string        The string to check.
+ * @param pattern       The regular expression pattern.
+ * @param flags         General flags for the regular expression, see PCRE_* defines.
+ * @param error         Error message encountered, if applicable.
+ * @param maxLen        Maximum string length of the error buffer.
+ * @param errcode       Regex type error code encountered, if applicable. See REGEX_ERROR_* defines.
+ *
+ * @return              -2 = Matching error (error code is stored in ret)
+ *                      -1 = Error in pattern (error message and offset # in error and ret)
+ *                       0 = No match.
+ *                      >1 = Handle for getting more information (via regex_substr)
+ */
+native Regex:regex_match_all(const string[], const pattern[], flags = 0, error[]= "", maxLen = 0, &errcode = 0);
+
+/**
+ * Matches a string against a regular expression pattern.
+ *
+ * @note  If you intend on using the same regular expression pattern
+ *        multiple times, consider using compile regex_compile_ex and regex_match*
+ *        instead of making this function reparse the expression each time.
+ *
+ * @param str           The string to check.
+ * @param pattern       The regular expression pattern.
+ * @param flags         General flags for the regular expression.
+ * @param error         Error message, if applicable.
+ * @param maxLen        Maximum length of the error buffer.
+ * @param errcode       Regex type error code encountered, if applicable. See REGEX_ERROR_* defines.
+ *
+ * @return              -2 = Matching error (error code is stored in ret)
+ *                      -1 = Pattern error (error code is stored in ret)
+ *                       0 = No match.
+ *                      >1 = Number of results.
+ */
+stock regex_match_simple(const str[], const pattern[], flags = 0, error[]= "", maxLen = 0, &errcode = 0)
+{
+	new Regex:regex = regex_compile_ex(pattern, flags, error, maxLen, errcode);
+	if (regex < REGEX_OK)
+	{
+		return -1;
+	}
+	new substrings = regex_match_c(str, regex);
+	regex_free(regex);
+	return substrings;
+}
+
+/**
+ * Flags used with regex_replace to control the replacement behavior.
+ */
+#define REGEX_FORMAT_DEFAULT   0       /* Uses the standard formatting rules to replace matches */
+#define REGEX_FORMAT_NOCOPY    (1<<0)  /* The sections that do not match the regular expression are not copied when replacing matches. */
+#define REGEX_FORMAT_FIRSTONLY (1<<1)  /* Only the first occurrence of a regular expression is replaced. */
+
+/**
+ * Perform a regular expression search and replace.
+ *
+ * An optional parameter, flags, allows you to specify options on how the replacement is performed.
+ * Supported format specifiers for replace parameter:
+ *   $number  : Substitutes the substring matched by group number.
+ *              n must be an integer value designating a valid backreference, greater than 0, and of two digits at most.
+ *   ${name}  : Substitutes the substring matched by the named group name (a maximum of 32 characters).
+ *   $&       : Substitutes a copy of the whole match.
+ *   $`       : Substitutes all the text of the input string before the match.
+ *   $'       : Substitutes all the text of the input string after the match.
+ *   $+       : Substitutes the last group that was captured.
+ *   $_       : Substitutes the entire input string.
+ *   $$       : Substitutes a literal "$".
+ * As note, the character \ can be also used with format specifier, this is same hehavior as $.
+ *
+ * @param pattern       The regular expression pattern.
+ * @param string        The string to check.
+ * @param error         Error message, if applicable.
+ * @param maxLen        Maximum length of the error buffer.
+ * @param replace       The string will be used to replace any matches. See above for format specifiers.
+ * @param flags         General flags to control how the string is replaced. See REGEX_FORMAT_* defines.
+ * @param errcode       Regex type error code encountered, if applicable. See REGEX_ERROR_* defines.
+ *
+ * @return              -2 = Matching error (error code is stored in ret)
+ *                       0 = No match.
+ *                      >1 = Number of matches.
+ */
+native regex_replace(Regex:pattern, string[], maxLen, const replace[], flags = REGEX_FORMAT_DEFAULT, &errcode = 0);