From 1471e0cf727cee737579655aa52b90c22661473c Mon Sep 17 00:00:00 2001 From: hermansimensen Date: Sun, 24 May 2020 17:52:05 +0200 Subject: [PATCH 1/9] Discord Logging uncomment #define DISCORD, if you would like to use this plugin without discord logging!. --- shavit-bash2.sp | 57 +++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 55 insertions(+), 2 deletions(-) diff --git a/shavit-bash2.sp b/shavit-bash2.sp index 133d426..5d84126 100644 --- a/shavit-bash2.sp +++ b/shavit-bash2.sp @@ -1,4 +1,5 @@ #define TIMER +#define DISCORD #include #include @@ -10,10 +11,15 @@ #include #endif +#if defined DISCORD +#include +#endif + #undef REQUIRE_EXTENSIONS #include #include + #pragma newdecls required #define BAN_LENGTH "0" @@ -167,6 +173,7 @@ bool g_bLateLoad; Handle g_hTeleport; bool g_bDhooksLoaded; +bool g_bDiscordLoaded; #if defined TIMER bool g_bSendProxyLoaded; #endif @@ -175,6 +182,8 @@ ConVar g_hBanLength; char g_sBanLength[32]; ConVar g_hAntiNull; ConVar g_hAutoban; +ConVar g_hLogToDiscord; +ConVar g_hWebhook; bool g_bAdminMode[MAXPLAYERS + 1]; //shavit @@ -192,6 +201,8 @@ public void OnPluginStart() AutoExecConfig(true, "bash", "sourcemod"); HookConVarChange(g_hBanLength, OnBanLengthChanged); g_hAntiNull = CreateConVar("bash_antinull", "0", "Punish for null movement stats", _, true, 0.0, true, 1.0); + g_hLogToDiscord = CreateConVar("bash_discord", "0", "Print anticheat logs to discord server.", _, true, 0.0, true, 1.0); + g_hWebhook = CreateConVar("bash_discord_webhook", "https://discordapp.com/api/webhooks/xxxxxx", _); //HookUserMessage(umVGUIMenu, OnVGUIMenu, true); @@ -224,6 +235,8 @@ public void OnAllPluginsLoaded() g_bDhooksLoaded = true; } + g_bDiscordLoaded = LibraryExists("discord-api"); + #if defined TIMER g_bSendProxyLoaded = LibraryExists("sendproxy"); #endif @@ -239,7 +252,12 @@ public void OnLibraryAdded(const char[] name) { Initialize(); g_bDhooksLoaded = true; - } + } + + if(StrEqual(name, "discord-api")) + { + g_bDiscordLoaded = true; + } #if defined TIMER else if(StrEqual(name, "sendproxy")) @@ -394,7 +412,38 @@ void SaveOldLogs() stock bool PrintToDiscord(int client, const char[] log, any ...) { - + if(g_bDiscordLoaded) + { + #if defined DISCORD + char webhook[255]; + GetConVarString(g_hWebhook, webhook, 255); + + char clientName[32]; + GetClientName(client, clientName, 32); + + char hostName[128]; + GetConVarString(FindConVar("hostname"), hostName, 128); + + PrintToServer("Webhook URL: %s", webhook); + DiscordWebHook hook = new DiscordWebHook(webhook); + hook.SlackMode = true; + + hook.SetUsername("BASH 2.0"); + + MessageEmbed Embed = new MessageEmbed(); + + Embed.SetColor("#ff2222"); + Embed.SetTitle(hostName); + Embed.AddField("Player", clientName, true); + Embed.AddField("Event", log, true); + + hook.Embed(Embed); + + hook.Send(); + delete hook; + return true; + #endif + } return false; } @@ -404,6 +453,10 @@ stock bool AnticheatLog(int client, const char[] log, any ...) VFormat(buffer, sizeof(buffer), log, 3); PrintToAdmins("%N %s", client, buffer); + if(g_hLogToDiscord.BoolValue && LibraryExists("discord-api")) { + PrintToDiscord(client, buffer); + } + Handle myHandle = GetMyHandle(); char sPlugin[PLATFORM_MAX_PATH]; GetPluginFilename(myHandle, sPlugin, PLATFORM_MAX_PATH); From 2b1ff79ae9013cdd211d9eb387b6d26b642c5622 Mon Sep 17 00:00:00 2001 From: hermansimensen Date: Sun, 24 May 2020 17:58:04 +0200 Subject: [PATCH 2/9] Update README and remove debug --- README.md | 6 ++++++ shavit-bash2.sp | 1 - 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 00646a6..a1b6254 100644 --- a/README.md +++ b/README.md @@ -14,3 +14,9 @@ bash_antinull - lets you disable or enable null kicking bash_banlength - lets you set banlength bash_autoban - disable/enable automatic banning. + +bash_discord - Enable/Disable discord logging + +bash_discord_webhook - The url for the discord webhook. + + diff --git a/shavit-bash2.sp b/shavit-bash2.sp index 5d84126..0860c7d 100644 --- a/shavit-bash2.sp +++ b/shavit-bash2.sp @@ -424,7 +424,6 @@ stock bool PrintToDiscord(int client, const char[] log, any ...) char hostName[128]; GetConVarString(FindConVar("hostname"), hostName, 128); - PrintToServer("Webhook URL: %s", webhook); DiscordWebHook hook = new DiscordWebHook(webhook); hook.SlackMode = true; From 29e9f20d070c4cf62b4abe52569569e2fd1c6c20 Mon Sep 17 00:00:00 2001 From: hermansimensen Date: Sun, 24 May 2020 18:17:19 +0200 Subject: [PATCH 3/9] ReadME --- README.md | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index a1b6254..b684d44 100644 --- a/README.md +++ b/README.md @@ -1,22 +1,24 @@ -# bash2 +# BASH 2.0 **Commands** - +```python bash2_stats - Show strafe stats - bash2_admin - toggle admin mode, lets you enable/disable printing of bash logs into the chat. +``` **Cvars** +```python bash_antinull - lets you disable or enable null kicking - bash_banlength - lets you set banlength - bash_autoban - disable/enable automatic banning. - bash_discord - Enable/Disable discord logging - bash_discord_webhook - The url for the discord webhook. +``` + +### Depencenies + +Discord API (https://github.com/Deathknife/sourcemod-discord) + SteamWorks & SMJansson From b58b63d217e6ab770d36e9cd112950688a9852c2 Mon Sep 17 00:00:00 2001 From: hermansimensen Date: Sun, 24 May 2020 18:41:52 +0200 Subject: [PATCH 4/9] Readme --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index b684d44..2e20cf9 100644 --- a/README.md +++ b/README.md @@ -22,3 +22,4 @@ bash_discord_webhook - The url for the discord webhook. Discord API (https://github.com/Deathknife/sourcemod-discord) + SteamWorks & SMJansson +![Bash2.0 Discord Demo](https://i.imgur.com/lrvCf1F.png) From 165ca73ed0b028b5a9d61f650fe30a1f21d9bc50 Mon Sep 17 00:00:00 2001 From: hermansimensen Date: Sun, 24 May 2020 19:53:12 +0200 Subject: [PATCH 5/9] Link steam profiles in discord log --- shavit-bash2.sp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/shavit-bash2.sp b/shavit-bash2.sp index 0860c7d..3862fe7 100644 --- a/shavit-bash2.sp +++ b/shavit-bash2.sp @@ -433,7 +433,13 @@ stock bool PrintToDiscord(int client, const char[] log, any ...) Embed.SetColor("#ff2222"); Embed.SetTitle(hostName); - Embed.AddField("Player", clientName, true); + + char steamid[65]; + char playerName[512]; + GetClientAuthId(client, AuthId_SteamID64, steamid, sizeof( steamid )); + Format(playerName, sizeof(playerName), "[%N](http://www.steamcommunity.com/profiles/%s)", client, steamid); + + Embed.AddField("Player", playerName, true); Embed.AddField("Event", log, true); hook.Embed(Embed); From 84e10494ad1e38d69d917ade152f53ab19e1f93f Mon Sep 17 00:00:00 2001 From: hermansimensen Date: Sun, 24 May 2020 21:21:28 +0200 Subject: [PATCH 6/9] Add includes --- include/sendproxy.inc | 84 + include/smlib/arrays.inc | 158 ++ include/smlib/clients.inc | 3096 +++++++++++++++++++++++++++++++++ include/smlib/colors.inc | 522 ++++++ include/smlib/concommands.inc | 47 + include/smlib/convars.inc | 72 + include/smlib/crypt.inc | 629 +++++++ include/smlib/debug.inc | 30 + include/smlib/desktop.ini | 5 + include/smlib/dynarrays.inc | 24 + include/smlib/edicts.inc | 127 ++ include/smlib/effects.inc | 734 ++++++++ include/smlib/entities.inc | 2141 +++++++++++++++++++++++ include/smlib/files.inc | 453 +++++ include/smlib/game.inc | 58 + include/smlib/general.inc | 251 +++ include/smlib/math.inc | 344 ++++ include/smlib/menus.inc | 38 + include/smlib/server.inc | 135 ++ include/smlib/sql.inc | 108 ++ include/smlib/strings.inc | 233 +++ include/smlib/teams.inc | 318 ++++ include/smlib/vehicles.inc | 141 ++ include/smlib/weapons.inc | 403 +++++ include/smlib/world.inc | 17 + 25 files changed, 10168 insertions(+) create mode 100644 include/sendproxy.inc create mode 100644 include/smlib/arrays.inc create mode 100644 include/smlib/clients.inc create mode 100644 include/smlib/colors.inc create mode 100644 include/smlib/concommands.inc create mode 100644 include/smlib/convars.inc create mode 100644 include/smlib/crypt.inc create mode 100644 include/smlib/debug.inc create mode 100644 include/smlib/desktop.ini create mode 100644 include/smlib/dynarrays.inc create mode 100644 include/smlib/edicts.inc create mode 100644 include/smlib/effects.inc create mode 100644 include/smlib/entities.inc create mode 100644 include/smlib/files.inc create mode 100644 include/smlib/game.inc create mode 100644 include/smlib/general.inc create mode 100644 include/smlib/math.inc create mode 100644 include/smlib/menus.inc create mode 100644 include/smlib/server.inc create mode 100644 include/smlib/sql.inc create mode 100644 include/smlib/strings.inc create mode 100644 include/smlib/teams.inc create mode 100644 include/smlib/vehicles.inc create mode 100644 include/smlib/weapons.inc create mode 100644 include/smlib/world.inc diff --git a/include/sendproxy.inc b/include/sendproxy.inc new file mode 100644 index 0000000..a75b195 --- /dev/null +++ b/include/sendproxy.inc @@ -0,0 +1,84 @@ +#if !defined _SENDPROXYMANAGER_INC_ +#define _SENDPROXYMANAGER_INC_ + + + +enum SendPropType { + Prop_Int = 0, + Prop_Float = 1, + Prop_String = 2, + //Prop_Array = 3, + Prop_Vector = 4, + Prop_Max +}; + +typeset SendProxyCallback +{ + function Action (int entity, const char[] PropName, int &iValue, int element); //Prop_Int + function Action (int entity, const char[] PropName, float &flValue, int element); //Prop_Float + function Action (int entity, const char[] PropName, char modifiedValue[4096], int element); //Prop_String + function Action (int entity, const char[] PropName, float vecValues[3], int element); //Prop_Vector +}; + +typeset SendProxyCallbackGamerules +{ + function Action (const char[] PropName, int &iValue, int element); //Prop_Int + function Action (const char[] PropName, float &flValue, int element); //Prop_Float + function Action (const char[] PropName, char modifiedValue[4096], int element); //Prop_String + function Action (const char[] PropName, float vecValues[3], int element); //Prop_Vector +}; + +typeset PropChangedCallback +{ + function void(int entity, const char[] PropName, const char[] oldValue, const char[] newValue); +}; + +typeset GameRulesPropChangedCallback +{ + function void(const char[] PropName, const char[] oldValue, const char[] newValue); +}; + +//Returns true upon success, false upon failure +native bool SendProxy_Hook(int entity, char[] propname, SendPropType proptype, SendProxyCallback callback); +native bool SendProxy_HookGameRules(char[] propname, SendPropType proptype, SendProxyCallbackGamerules callback); +native bool SendProxy_HookArrayProp(int entity, const char[] name, int element, SendPropType: ype, SendProxyCallback callback); +native bool SendProxy_UnhookArrayProp(int entity, const char[] name, int element, SendPropType type, SendProxyCallback callback); +native bool SendProxy_Unhook(int entity, char[] propname, SendProxyCallback callback); +native bool SendProxy_UnhookGameRules(char[] propname, SendProxyCallbackGamerules callback); +native bool SendProxy_IsHooked(int entity, char[] propname); +native bool SendProxy_IsHookedGameRules(char[] propname); + +native bool SendProxy_HookPropChange(entity, const char[] name, PropChangedCallback callback); +native bool SendProxy_HookPropChangeGameRules(const char[] name, GameRulesPropChangedCallback callback); +native void SendProxy_UnhookPropChange(entity, const char[] name, PropChangedCallback callback); +native void SendProxy_UnhookPropChangeGameRules(const char[] name, GameRulesPropChangedCallback callback); + +#if !defined REQUIRE_EXTENSIONS +public __ext_sendproxymanager_SetNTVOptional() +{ + MarkNativeAsOptional("SendProxy_Hook"); + MarkNativeAsOptional("SendProxy_HookArrayProp"); + MarkNativeAsOptional("SendProxy_Unhook"); + MarkNativeAsOptional("SendProxy_IsHooked"); + MarkNativeAsOptional("SendProxy_HookPropChange"); + MarkNativeAsOptional("SendProxy_UnhookPropChange"); +} +#endif + +public Extension __ext_sendproxymanager = +{ + name = "SendProxy Manager", + file = "sendproxy.ext", +#if defined AUTOLOAD_EXTENSIONS + autoload = 1, +#else + autoload = 0, +#endif +#if defined REQUIRE_EXTENSIONS + required = 1, +#else + required = 0, +#endif +}; + +#endif \ No newline at end of file diff --git a/include/smlib/arrays.inc b/include/smlib/arrays.inc new file mode 100644 index 0000000..dd318eb --- /dev/null +++ b/include/smlib/arrays.inc @@ -0,0 +1,158 @@ +#if defined _smlib_array_included + #endinput +#endif +#define _smlib_array_included + +#include + +/** + * Returns the index for the first occurance of the given value. + * If the value cannot be found, -1 will be returned. + * + * @param array Static Array. + * @param size Size of the Array. + * @param value Value to search for. + * @param start Optional: Offset where to start (0 - (size-1)). + * @return Array index, or -1 if the value couldn't be found. + */ +stock int Array_FindValue(any[] array, int size, any value, int start=0) +{ + if (start < 0) { + start = 0; + } + + for (int i=start; i < size; i++) { + + if (array[i] == value) { + return i; + } + } + + return -1; +} + +/** + * Searchs for the first occurance of a string in the array. + * If the value cannot be located, -1 will be returned. + * + * @param array Static Array. + * @param size Size of the Array. + * @param value String to search for. + * @param start Optional: Offset where to start(0 - (size-1)). + * @return Array index, or -1 if the value couldn't be found. + */ +stock int Array_FindString(const char[][] array, int size, const char[] str, bool caseSensitive=true, int start=0) +{ + if (start < 0) { + start = 0; + } + + for (int i=start; i < size; i++) { + + if (StrEqual(array[i], str, caseSensitive)) { + return i; + } + } + + return -1; +} + +/** + * Returns the Index of the Lowest value in the array + * + * @param array Static Array. + * @param size Size of the Array. + * @param start Optional: Offset where to start (0 - (size-1)). + * @return Array index. + */ +stock int Array_FindLowestValue(any[] array, int size, int start=0) +{ + if (start < 0) { + start = 0; + } + + any value = array[start]; + any tempValue; + int x = start; + + for (int i=start; i < size; i++) { + + tempValue = array[i]; + + if (tempValue < value) { + value = tempValue; + x = i; + } + + } + + return x; +} + +/** + * Returns the Index of the Highest value in the array + * + * @param array Static Array. + * @param size Size of the Array. + * @param start Optional: Offset where to start (0 - (size-1)). + * @return Array index. + */ +stock int Array_FindHighestValue(any[] array, int size, int start=0) +{ + if (start < 0) { + start = 0; + } + + any value = array[start]; + any tempValue; + int x = start; + + for (int i=start; i < size; i++) { + + tempValue = array[i]; + + if (tempValue > value) { + value = tempValue; + x = i; + } + + } + + return x; +} + +/** + * Fills an array with a given value in a 1 dimensional static array. + * You can specify the amount of cells to be written. + * + * @param array Static Array. + * @param size Number of cells to write (eg. the array's size) + * @param value Fill value. + * @param start Optional: Offset where to start (0 - (size-1)). + * @noreturn + */ +stock void Array_Fill(any[] array, int size, any value, int start=0) +{ + if (start < 0) { + start = 0; + } + + for (int i=start; i < size; i++) { + array[i] = value; + } +} + +/** + * Copies a 1 dimensional static array. + * + * @param array Static Array to copy from. + * @param newArray New Array to copy to. + * @param size Size of the array (or number of cells to copy) + * @noreturn + */ +stock void Array_Copy(const any[] array, any[] newArray, int size) +{ + for (int i=0; i < size; i++) { + newArray[i] = array[i]; + } +} diff --git a/include/smlib/clients.inc b/include/smlib/clients.inc new file mode 100644 index 0000000..1edd1a5 --- /dev/null +++ b/include/smlib/clients.inc @@ -0,0 +1,3096 @@ +#if defined _smlib_client_included + #endinput +#endif +#define _smlib_client_included + +// Defined here beacause needed in teams.inc +#define CLIENTFILTER_ALL 0 // No filtering +#define CLIENTFILTER_BOTS ( 1 << 1 ) // Fake clients +#define CLIENTFILTER_NOBOTS ( 1 << 2 ) // No fake clients +#define CLIENTFILTER_AUTHORIZED ( 1 << 3 ) // SteamID validated +#define CLIENTFILTER_NOTAUTHORIZED ( 1 << 4 ) // SteamID not validated (yet) +#define CLIENTFILTER_ADMINS ( 1 << 5 ) // Generic Admins (or higher) +#define CLIENTFILTER_NOADMINS ( 1 << 6 ) // No generic admins +// All flags below require ingame checking (optimization) +#define CLIENTFILTER_INGAME ( 1 << 7 ) // Ingame +#define CLIENTFILTER_INGAMEAUTH ( 1 << 8 ) // Ingame & Authorized +#define CLIENTFILTER_NOTINGAME ( 1 << 9 ) // Not ingame (currently connecting) +#define CLIENTFILTER_ALIVE ( 1 << 10 ) // Alive +#define CLIENTFILTER_DEAD ( 1 << 11 ) // Dead +#define CLIENTFILTER_SPECTATORS ( 1 << 12 ) // Spectators +#define CLIENTFILTER_NOSPECTATORS ( 1 << 13 ) // No Spectators +#define CLIENTFILTER_OBSERVERS ( 1 << 14 ) // Observers +#define CLIENTFILTER_NOOBSERVERS ( 1 << 15 ) // No Observers +#define CLIENTFILTER_TEAMONE ( 1 << 16 ) // First Team (Terrorists, ...) +#define CLIENTFILTER_TEAMTWO ( 1 << 17 ) // Second Team (Counter-Terrorists, ...) + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * Very useful macro to iterate all clients + * matching the specified flags. + * + * @param 1 Name of the client index variable (will be only valid in the loop). + * @param 2 CLIENTFILTER_ flags to check. + */ +#define LOOP_CLIENTS(%1,%2) for (int %1=Client_GetNext(%2); %1 >= 1 && %1 <= MaxClients; %1=Client_GetNext(%2, ++%1)) + +/** + * Macro for iterating trough all observers of a player. + * + * @param 1 Client Index for who to get the observers. + * @param 2 Name of the observer client index variable (will be only valid in the loop). + * @param 3 CLIENTFILTER_ flags to check. + */ +#define LOOP_OBSERVERS(%1,%2,%3) for (int %2=Client_GetNextObserver(%1, 1, %3); %2 >= 1 && %2 <= MaxClients; %2=Client_GetNextObserver(%1, ++%2, %3)) + +/** + * Very useful macro to iterate all weapons of a client. + * + * @param 1 Client Index + * @param 2 Name of the weapon index variable (will be only valid in the loop). + * @param 3 Name of the client's weapon index variable (will be only valid in the loop). + */ +#define LOOP_CLIENTWEAPONS(%1,%2,%3) for (new %3, %2=Client_GetNextWeapon(%1, %3); %2 != -1; %2=Client_GetNextWeapon(%1, %3)) + +// Hud Element hiding flags (possibly outdated) +#define HIDEHUD_WEAPONSELECTION ( 1<<0 ) // Hide ammo count & weapon selection +#define HIDEHUD_FLASHLIGHT ( 1<<1 ) +#define HIDEHUD_ALL ( 1<<2 ) +#define HIDEHUD_HEALTH ( 1<<3 ) // Hide health & armor / suit battery +#define HIDEHUD_PLAYERDEAD ( 1<<4 ) // Hide when local player's dead +#define HIDEHUD_NEEDSUIT ( 1<<5 ) // Hide when the local player doesn't have the HEV suit +#define HIDEHUD_MISCSTATUS ( 1<<6 ) // Hide miscellaneous status elements (trains, pickup history, death notices, etc) +#define HIDEHUD_CHAT ( 1<<7 ) // Hide all communication elements (saytext, voice icon, etc) +#define HIDEHUD_CROSSHAIR ( 1<<8 ) // Hide crosshairs +#define HIDEHUD_VEHICLE_CROSSHAIR ( 1<<9 ) // Hide vehicle crosshair +#define HIDEHUD_INVEHICLE ( 1<<10 ) +#define HIDEHUD_BONUS_PROGRESS ( 1<<11 ) // Hide bonus progress display (for bonus map challenges) + +/** +* Sets the Hide-Hud flags of a client +* +* @param client Client index. +* @param flags Flag to set, use one of the HIDEHUD_ hiding constants +* @noreturn +*/ +stock void Client_SetHideHud(int client, int flags) +{ + SetEntProp(client, Prop_Send, "m_iHideHUD", flags); +} + +/** +* Checks if the specified index is a player and connected. +* +* @param entity An entity index. +* @param checkConnected Set to false to skip the IsClientConnected check +* @return Returns true if the specified entity index is a player connected, false otherwise. +*/ +stock bool Client_IsValid(int client, bool checkConnected=true) +{ + if (client > 4096) { + client = EntRefToEntIndex(client); + } + + if (client < 1 || client > MaxClients) { + return false; + } + + if (checkConnected && !IsClientConnected(client)) { + return false; + } + + return true; +} + +/** +* Checks if the specified index is a player and ingame. +* +* @param entity An entity index. +* @return Returns true if the specified index is a player and ingame, false otherwise. +*/ +stock bool Client_IsIngame(int client) +{ + if (!Client_IsValid(client, false)) { + return false; + } + + return IsClientInGame(client); +} + +/** +* Checks if the specified index is a player, ingame and authorized. +* +* @param entity An entity index. +* @return Returns true if the specified index is a player, ingame and authed, false otherwise. +*/ +stock bool Client_IsIngameAuthorized(int client) +{ + if (!Client_IsIngame(client)) { + return false; + } + + return IsClientAuthorized(client); +} + +#define MAX_STEAMAUTH_LENGTH 21 + +/** +* Finds a player by his SteamID +* +* @param auth SteamID to search for +* @param authIDtype Type of AuthID +* @return Client Index or -1 +*/ +stock int Client_FindBySteamId(const char[] auth, AuthIdType authType=AuthId_Steam2) +{ + char clientAuth[MAX_STEAMAUTH_LENGTH]; + for (int client=1; client <= MaxClients; client++) { + if (!IsClientAuthorized(client)) { + continue; + } + + GetClientAuthId(client, authType, clientAuth, sizeof(clientAuth)); + + if (StrEqual(auth, clientAuth)) { + return client; + } + } + + return -1; +} + +/** +* Finds a player by his name. +* Only returns the first matching player. +* +* @param name Name to search for. +* @param partOfName Whether to search for the part of a name or compare the full name. +* @param caseSensitive If true, comparison is case sensitive. If false (default), comparison is case insensitive. +* @return Client Index or -1 +*/ +stock int Client_FindByName(const char[] name, bool partOfName=true, bool caseSensitive=false) +{ + char clientName[MAX_STEAMAUTH_LENGTH]; + for (int client=1; client <= MaxClients; client++) { + if (!IsClientAuthorized(client)) { + continue; + } + + GetClientName(client, clientName, sizeof(clientName)); + + if (partOfName) { + if (StrContains(clientName, name, caseSensitive) != -1) { + return client; + } + } + else if (StrEqual(name, clientName, caseSensitive)) { + return client; + } + } + + return -1; +} + +// Spectator Movement modes +enum Obs_Mode +{ + OBS_MODE_NONE = 0, // not in spectator mode + OBS_MODE_DEATHCAM, // special mode for death cam animation + OBS_MODE_FREEZECAM, // zooms to a target, and freeze-frames on them + OBS_MODE_FIXED, // view from a fixed camera position + OBS_MODE_IN_EYE, // follow a player in first person view + OBS_MODE_CHASE, // follow a player in third person view + OBS_MODE_ROAMING, // free roaming + + NUM_OBSERVER_MODES +}; + +// Force Camera Restrictions with mp_forcecamera +enum Obs_Allow +{ + OBS_ALLOW_ALL = 0, // allow all modes, all targets + OBS_ALLOW_TEAM, // allow only own team & first person, no PIP + OBS_ALLOW_NONE, // don't allow any spectating after death (fixed & fade to black) + + OBS_ALLOW_NUM_MODES, +}; + +/** + * Gets the client's observer mode (Obs_Mode). + * + * @param client Client Index. + * @return The current observer mode (ObsMode). + */ +stock Obs_Mode Client_GetObserverMode(int client) +{ + return view_as(GetEntProp(client, Prop_Send, "m_iObserverMode")); +} + + +/** + * Sets the client's observer mode. + * Use a value of the Obs_Mode enum. + * This is a rewrite of CBasePlayer::SetObserverMode(). + * + * @param client Client Index. + * @param mode New Observer mode value (Obs_Mode). + * @param updateMoveType Set to true (default) to allow this function updating the movetype, false otherwise. + * @noreturn + */ +stock bool Client_SetObserverMode(int client, Obs_Mode mode, bool updateMoveType=true) +{ + if (mode < OBS_MODE_NONE || mode >= NUM_OBSERVER_MODES) { + return false; + } + + // check mp_forcecamera settings for dead players + if (mode > OBS_MODE_FIXED && GetClientTeam(client) > TEAM_SPECTATOR) + { + ConVar mp_forcecamera = FindConVar("mp_forcecamera"); + + if (mp_forcecamera != null) { + switch (mp_forcecamera.IntValue) + { + case OBS_ALLOW_TEAM: { + mode = OBS_MODE_IN_EYE; + } + case OBS_ALLOW_NONE: { + mode = OBS_MODE_FIXED; // don't allow anything + } + } + } + } + + Obs_Mode observerMode = Client_GetObserverMode(client); + if (observerMode > OBS_MODE_DEATHCAM) { + // remember mode if we were really spectating before + Client_SetObserverLastMode(client, observerMode); + } + + SetEntProp(client, Prop_Send, "m_iObserverMode", view_as(mode)); + + switch (mode) { + case OBS_MODE_NONE, OBS_MODE_FIXED, OBS_MODE_DEATHCAM: { + Client_SetFOV(client, 0); // Reset FOV + + if (updateMoveType) { + SetEntityMoveType(client, MOVETYPE_NONE); + } + } + case OBS_MODE_CHASE, OBS_MODE_IN_EYE: { + // udpate FOV and viewmodels + Client_SetViewOffset(client, NULL_VECTOR); + + if (updateMoveType) { + SetEntityMoveType(client, MOVETYPE_OBSERVER); + } + } + case OBS_MODE_ROAMING: { + Client_SetFOV(client, 0); // Reset FOV + Client_SetViewOffset(client, NULL_VECTOR); + + if (updateMoveType) { + SetEntityMoveType(client, MOVETYPE_OBSERVER); + } + } + } + + return true; +} + +/** + * Gets the client's last oberserver mode + * + * @param client Client Index. + * @return Last Observer mode + */ +stock Obs_Mode Client_GetObserverLastMode(int client) +{ + return view_as(GetEntProp(client, Prop_Data, "m_iObserverLastMode")); +} + +/** + * Sets the client's last oberserver mode + * + * @param client Client Index. + * @param mode Last Observer mode + * @noreturn + */ +stock void Client_SetObserverLastMode(int client, Obs_Mode mode) +{ + SetEntProp(client, Prop_Data, "m_iObserverLastMode", view_as(mode)); +} + +/** + * Gets the client's view offset. + * This is the position relative to the client itself. + * + * @param client Client Index. + * @param vec Vector Buffer. + * @noreturn + */ +stock void Client_GetViewOffset(int client, float vec[3]) +{ + GetEntPropVector(client, Prop_Data, "m_vecViewOffset", vec); +} + +/** + * Sets the client's view offset. + * This is the position relative to the client itself. + * + * @param client Client Index. + * @param vec Vector buffer. + * @noreturn + */ +stock void Client_SetViewOffset(int client, float vec[3]) +{ + SetEntPropVector(client, Prop_Data, "m_vecViewOffset", vec); +} + +/** + * Gets the client's current observer target entity. + * + * @param client Client Index. + * @return Observed Entity Index. + */ +stock int Client_GetObserverTarget(int client) +{ + return GetEntPropEnt(client, Prop_Send, "m_hObserverTarget"); +} + +/** + * Sets the client's current observer target entity. + * + * @param client Client Index. + * @param entity Observed Entity Index. + * @param resetFOV If to reset the client's field of view. + * @noreturn + */ +stock void Client_SetObserverTarget(int client, int entity, bool resetFOV=true) +{ + SetEntPropEnt(client, Prop_Send, "m_hObserverTarget", entity); + + if (resetFOV) { + Client_SetFOV(client, 0); + } +} + +/** + * Gets the client's Field Of View. + * + * @param client Client Index. + * @return Field Of View + */ +stock int Client_GetFOV(int client) +{ + return GetEntProp(client, Prop_Send, "m_iFOV"); +} + +/** + * Sets the client's Field Of View. + * + * @param client Client Index. + * @param value Field Of View + * @noreturn + */ +stock void Client_SetFOV(int client, int value) +{ + SetEntProp(client, Prop_Send, "m_iFOV", value); +} + +/** + * Checks if the client's View Model is drawn for the client. + * + * @param client Client Index. + * @return True if the viewmodel is drawn, false otherwise. + */ +stock bool Client_DrawViewModel(int client) +{ + return view_as(GetEntProp(client, Prop_Send, "m_bDrawViewmodel")); +} + +/** + * Sets if to draw the client's view model for the client. + * + * @param client Client Index. + * @param drawViewModel Set to true if to draw, false otherwise. + * @noreturn + */ +stock void Client_SetDrawViewModel(int client, bool drawViewModel) +{ + SetEntProp(client, Prop_Send, "m_bDrawViewmodel", drawViewModel); +} + +/** + * Puts the specified client into thirdperson or back to firstperson when false + * This doesn't work correctly in all games, it works in CS:S and DOD:S and some other games. + * Todo: Enhance this + * + * @param client Client Index. + * @param enable If set to true, the client will be put into thirdperson mode, + * if false the client will be put in firstperson mode. + * @noreturn + */ +stock void Client_SetThirdPersonMode(int client, bool enable=true) +{ + if (enable) { + Client_SetObserverTarget(client, 0); + Client_SetObserverMode(client, OBS_MODE_DEATHCAM, false); + Client_SetDrawViewModel(client, false); + Client_SetFOV(client, 120); + } + else { + Client_SetObserverTarget(client, -1); + Client_SetObserverMode(client, OBS_MODE_NONE, false); + Client_SetDrawViewModel(client, true); + Client_SetFOV(client, 90); + } +} + +/** + * Checks if the client is in thirdperson mode + * + * @param client Cient Undex + * @return true if the client is currently in thirdperson mode, false otherwise + */ +stock bool Client_IsInThirdPersonMode(int client) +{ + return view_as(GetEntProp(client, Prop_Data, "m_iObserverMode")); +} + +#define FFADE_IN 0x0001 // Just here so we don't pass 0 into the function +#define FFADE_OUT 0x0002 // Fade out (not in) +#define FFADE_MODULATE 0x0004 // Modulate (don't blend) +#define FFADE_STAYOUT 0x0008 // ignores the duration, stays faded out until new ScreenFade message received +#define FFADE_PURGE 0x0010 // Purges all other fades, replacing them with this one + +/** + * Fades a client's screen to a specified color + * Your adviced to read the FFADE_ Comments + * + * @param client Player for which to fade the screen + * @param duration duration in seconds the effect stays + * @param mode fade mode, see FFADE_ defines + * @param holdtime holdtime in seconds + * @param r red amount + * @param g green amount + * @param b blue amount + * @param a transparency + * @return True on success, false otherwise + */ +stock bool Client_ScreenFade(int client, int duration, int mode, int holdtime=-1, int r=0, int g=0, int b=0, int a=255, bool reliable=true) +{ + Handle userMessage = StartMessageOne("Fade", client, (reliable?USERMSG_RELIABLE:0)); + + if (userMessage == null) { + return false; + } + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available && + GetUserMessageType() == UM_Protobuf) { + + Protobuf message = UserMessageToProtobuf(userMessage); + + int color[4]; + color[0] = r; + color[1] = g; + color[2] = b; + color[3] = a; + + message.SetInt("duration", duration); + message.SetInt("hold_time", holdtime); + message.SetInt("flags", mode); + message.SetColor("clr", color); + } + else { + + BfWrite message = UserMessageToBfWrite(userMessage); + + message.WriteShort(duration); // Fade duration + message.WriteShort(holdtime); // Fade hold time + message.WriteShort(mode); // What to do + message.WriteByte(r); // Color R + message.WriteByte(g); // Color G + message.WriteByte(b); // Color B + message.WriteByte(a); // Color Alpha + } + EndMessage(); + + return true; +} + +/** + * This function retrieves an array that holds all clones of a client by IP check. + * Size of CloneList has to be MaxClients at least, or MAX_PLAYERS + * + * @param client Client index. + * @param closelist An array that holds all clones of a client. + * @return Returns how many clones a client has. + */ +stock int Client_GetClones(int client, int[] cloneList) +{ + int x=0; + char ip_client[16], ip_player[16]; + + GetClientIP(client, ip_client, sizeof(client)); + + for (int player=1; player <= MaxClients; player++) { + + if (IsClientInGame(player)) { + GetClientIP(player, ip_player, sizeof(ip_player)); + + if (StrEqual(ip_client, ip_player, false)) { + cloneList[x++] = player; + } + } + } + + return x; +} + +/* + * This function returns true if the client is at a ladder.. + * + * @param client Client index. + * @return Returns true if the client is on a ladder other wise false. + */ +stock bool Client_IsOnLadder(int client) +{ + return view_as(GetEntityMoveType(client)) == MOVETYPE_LADDER; +} + +enum Water_Level +{ + WATER_LEVEL_NOT_IN_WATER = 0, + WATER_LEVEL_FEET_IN_WATER, + WATER_LEVEL_WAIST_IN_WATER, + WATER_LEVEL_HEAD_IN_WATER +}; + +/* + * This function returns how deep a client is in water. + * + * @param client Client index. + * @return Returns 0 if not in water. 1 if feets are in water. 2 if waist is in water. 3 if head is in water. + */ +stock Water_Level Client_GetWaterLevel(int client) +{ + return view_as(GetEntProp(client, Prop_Send, "m_nWaterLevel")); +} + +/* + * Returns how much suit sprint power a client has left in percent. + * + * @param client Client index. + * @return returns the actual power left in percent. + */ +stock float Client_GetSuitSprintPower(int client) +{ + return GetEntPropFloat(client, Prop_Send, "m_flSuitPower"); +} + +/* + * Sets a client suit sprint power in percent. + * + * @param client Client index. + * @param power power (0.0 to 100.0) + * @noreturn + */ +stock void Client_SetSuitSprintPower(int client, float power) +{ + SetEntPropFloat(client, Prop_Send, "m_flSuitPower", power); +} + +/* + * Returns the client count put in the server. + * + * @param inGameOnly If false connecting players are also counted. + * @param countBots If true bots will be counted too. + * @return Client count in the server. + */ +stock int Client_GetCount(bool countInGameOnly=true, bool countFakeClients=true) +{ + int numClients = 0; + + for (int client=1; client <= MaxClients; client++) { + + if (!IsClientConnected(client)) { + continue; + } + + if (countInGameOnly && !IsClientInGame(client)) { + continue; + } + + if (!countFakeClients && IsFakeClient(client)) { + continue; + } + + numClients++; + } + + return numClients; +} + +/* + * Returns the ping of a client like it is displayed in the scoreboard. + * The weird calculation formula is taken from Valve's SDK + * hl2sdk\game\server\util.cpp: UTIL_GetPlayerConnectionInfo() + * The Scoreboard uses the goldSource corrected Ping, the net_graph doesn't + * For Fake Clients 0 is returned. + * + * @param client Client index + * @param goldSource If true, get the ping as displayed in the player's scoreboard, false returns the net_graph variant. + * @return Client's fake ping or 0 for fake clients + */ +stock int Client_GetFakePing(int client, bool goldSource=true) +{ + if (IsFakeClient(client)) { + return 0; + } + + int ping; + float latency = GetClientLatency(client, NetFlow_Outgoing); // in seconds + + // that should be the correct latency, we assume that cmdrate is higher + // then updaterate, what is the case for default settings + char cl_cmdrate[4]; + GetClientInfo(client, "cl_cmdrate", cl_cmdrate, sizeof(cl_cmdrate)); + + float tickRate = GetTickInterval(); + latency -= (0.5 / StringToInt(cl_cmdrate)) + TICKS_TO_TIME(1.0); // correct latency + + if (goldSource) { + // in GoldSrc we had a different, not fixed tickrate. so we have to adjust + // Source pings by half a tick to match the old GoldSrc pings. + latency -= tickRate * 0.5; + } + + ping = RoundFloat(latency * 1000.0); // as msecs + ping = Math_Clamp(ping, 5, 1000); // set bounds, dont show pings under 5 msecs + + return ping; +} + +/** + * Searches for the closest client in relation to the given client. + * + * @param client Client index + * @return The closest client or -1 + */ +stock int Client_GetClosestToClient(int client) +{ + return Edict_GetClosestToEdict(client, true); +} + +/** + * Gets the name of the last place (if set by the game) + * + * @param entity Entity index. + * @param buffer String buffer + * @param size Size of the String buffer + * @noreturn + */ +stock void Client_GetLastPlaceName(int client, char[] buffer, int size) +{ + GetEntPropString(client, Prop_Send, "m_szLastPlaceName", buffer, size); +} + +/** + * Returns the client's Score. + * + * @param client Client's index. + * @return Score. + */ +stock int Client_GetScore(int client) +{ + return GetClientFrags(client); +} + +/** + * Sets the client's Score. + * + * @param client Client's index. + * @param value Score. + * @noreturn + */ +stock void Client_SetScore(int client, int value) +{ + SetEntProp(client, Prop_Data, "m_iFrags", value); +} + +/** + * Returns the client's Death count + * + * @param client Client's index. + * @return Death count + */ +stock int Client_GetDeaths(int client) +{ + return GetEntProp(client, Prop_Data, "m_iDeaths"); +} + +/** + * Sets the client's Death count. + * + * @param client Client's index. + * @param value Death count + * @noreturn + */ +stock void Client_SetDeaths(int client, any value) +{ + SetEntProp(client, Prop_Data, "m_iDeaths", value); +} + +/** + * Returns the client's Armor + * + * @param client Client's index. + * @return Armor value + */ +stock int Client_GetArmor(int client) +{ + return GetEntProp(client, Prop_Data, "m_ArmorValue"); +} + +/** + * Sets the client's Armor. + * + * @param client Client's index. + * @param value Armor value + * @noreturn + */ +stock int Client_SetArmor(int client, any value) +{ + SetEntProp(client, Prop_Data, "m_ArmorValue", value); +} + +/** + * Returns the client's Suitpower + * + * @param client Client's index. + * @return Suitpower + */ +stock float Client_GetSuitPower(int client) +{ + return GetEntPropFloat(client, Prop_Data, "m_flSuitPower"); +} + +/** + * Sets the client's Suitpower + * + * @param client Client's index. + * @param value Suitpower + * @noreturn + */ +stock void Client_SetSuitPower(int client, float value) +{ + SetEntPropFloat(client, Prop_Data, "m_flSuitPower", value); +} + +// suit usage bits +#define bits_SUIT_DEVICE_SPRINT 0x00000001 +#define bits_SUIT_DEVICE_FLASHLIGHT 0x00000002 +#define bits_SUIT_DEVICE_BREATHER 0x00000004 +#define MAX_SUIT_DEVICES 3 + +/** + * Returns the client's active devices (Max MAX_SUIT_DEVICES) + * The return is a bitwise value with bits_SUIT_DEVICE_SPRINT, + * bits_SUIT_DEVICE_FLASHLIGHT and/or bits_SUIT_DEVICE_BREATHER set. + * + * @param client Client's index. + * @return The active devices (bitwise value) + */ +stock int Client_GetActiveDevices(int client) +{ + return GetEntProp(client, Prop_Send, "m_bitsActiveDevices"); +} + +/** + * Returns the time when the client is allowed to spray + * a decal again. + * + * @param client Client's index. + * @return Next decal time + */ +stock float Client_GetNextDecalTime(int client) +{ + return GetEntPropFloat(client, Prop_Data, "m_flNextDecalTime"); +} + +/** + * Returns whether the client is allowed to spray a decal or not. + * + * @param client Client's index. + * @return True if he is allowed to spray a decal, false otherwise + */ +stock bool Client_CanSprayDecal(int client) +{ + return Client_GetNextDecalTime(client) <= GetGameTime(); +} + +/** + * Returns the vehicle the client is in, if the client + * isn't in a vehicle, -1 is returned. + * + * @param client Client's index. + * @return Vehicle index, -1 if the client isn't in a vehicle. + */ +stock int Client_GetVehicle(int client) +{ + return GetEntPropEnt(client, Prop_Send, "m_hVehicle"); +} + +/** + * Returns whether the client is in a vehicle or not. + * + * @param client Client's index. + * @return True if he is in a vehicle, false otherwise + */ +stock bool Client_IsInVehicle(int client) +{ + return Client_GetVehicle(client) != -1; +} + +/** + * Removes all decals for a client + * + * @param client Client's index. + * @noreturn + */ +stock void Client_RemoveAllDecals(int client) +{ + ClientCommand(client, "r_cleardecals"); +} + +/** + * Let's the client exit the vehicle + * + * @param vehicle Client index. + * @return True on success, false otherwise. + */ +stock bool Client_ExitVehicle(int client) +{ + int vehicle = Client_GetVehicle(client); + + if (vehicle == -1) { + return false; + } + + return AcceptEntityInput(vehicle, "ExitVehicle"); +} + +/** + * Plays a soundfile as if the player is using voicecomm for a single client. + * The voiceindicator is shown on the right, as if the players is talking. + * Thanks to Peace-Maker for the function. + * + * @param client For whom to play the sound. + * @param emitter Player/Entity the voice stream comes from. + * @param soundfile Path to the soundfile relative to the sound folder. + * @param length Length in seconds how long the hud "voiceindicator" is shown. + * @param pitch The pitch of the audiofile. + * @return True on success, false on failure. + */ +stock bool Client_RawAudio(int client, const int emitter, const char[] soundfile, float length = 0.0, int pitch = 100) +{ + Handle message = StartMessageOne("RawAudio", client); + + if (message == null) { + return false; + } + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available + && GetUserMessageType() == UM_Protobuf) { + + PbSetInt(message, "pitch", pitch); + PbSetInt(message, "entidx", emitter); + PbSetFloat(message, "duration", length ); + PbSetString(message, "voice_filename", soundfile); + } + else { + BfWriteByte(message, pitch); + BfWriteByte(message, emitter); + BfWriteFloat(message, length); + BfWriteString(message, soundfile); + } + EndMessage(); + + return true; +} + +/** + * Plays a soundfile as if the player is using voicecomm for all players. + * The voiceindicator is shown on the right, as if the players is talking. + * Thanks to Peace-Maker for the function. + * + * @param emitter Player/Entity the voice stream comes from. + * @param soundfile Path to the soundfile relative to the sound folder. + * @param length Length in seconds how long the hud "voiceindicator" is shown. + * @param pitch The pitch of the audiofile. + * @return True on success, false on failure. + */ +stock bool Client_RawAudioToAll(const int emitter, const char[] soundfile, float length = 0.0, int pitch = 100) +{ + Handle message = StartMessageAll("RawAudio"); + + if (message == null) { + return false; + } + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available + && GetUserMessageType() == UM_Protobuf) { + + PbSetInt(message, "pitch", pitch); + PbSetInt(message, "entidx", emitter); + PbSetFloat(message, "duration", length); + PbSetString(message, "voice_filename", soundfile); + } + else { + BfWriteByte(message, pitch); + BfWriteByte(message, emitter); + BfWriteFloat(message, length); + BfWriteString(message, soundfile); + } + EndMessage(); + + return true; +} + +/** + * Sets an Impulse value for a client (eg: "impulse 100" for flashlight, value would be 100). + * See: http://developer.valvesoftware.com/wiki/Impulse + * + * @param client Client Index + * @param value The impulse command value. + * @noreturn + */ +stock void Client_Impulse(int client, int value) +{ + SetEntProp(client, Prop_Data, "m_nImpulse", value); +} + +/** + * Gets the offset for a client's weapon list (m_hMyWeapons). + * The offset will saved globally for optimization. + * + * @param client Client Index. + * @return Weapon list offset or -1 on failure. + */ +stock int Client_GetWeaponsOffset(int client) +{ + static int offset = -1; + + if (offset == -1) { + offset = FindDataMapInfo(client, "m_hMyWeapons"); + } + + return offset; +} + +/** + * Gets the current/active weapon of a client + * + * @param client Client Index. + * @return Weapon Index or INVALID_ENT_REFERENCE if the client has no active weapon. + */ +stock int Client_GetActiveWeapon(int client) +{ + int weapon = GetEntPropEnt(client, Prop_Data, "m_hActiveWeapon"); + + if (!Entity_IsValid(weapon)) { + return INVALID_ENT_REFERENCE; + } + + return weapon; +} + +/** + * Gets the classname and entity index of the current/active weapon of a client. + * + * @param client Client Index. + * @param buffer String Buffer to store the weapon's classname. + * @param size Max size of char buffer. + * @return Weapon Entity Index on success or INVALID_ENT_REFERENCE otherwise + */ +stock int Client_GetActiveWeaponName(int client, char[] buffer, int size) +{ + int weapon = Client_GetActiveWeapon(client); + + if (weapon == INVALID_ENT_REFERENCE) { + buffer[0] = '\0'; + return INVALID_ENT_REFERENCE; + } + + Entity_GetClassName(weapon, buffer, size); + + return weapon; +} + +/** + * Changes the active/current weapon of a player by Index. + * Note: No changing animation will be played ! + * + * @param client Client Index. + * @param weapon Index of a valid weapon. + * @noreturn + */ +stock void Client_SetActiveWeapon(int client, int weapon) +{ + SetEntPropEnt(client, Prop_Data, "m_hActiveWeapon", weapon); + ChangeEdictState(client, FindDataMapInfo(client, "m_hActiveWeapon")); +} + +/** + * Changes the active weapon the client is holding. + * Note: No changing animation will be played ! + * + * @param client Client Index. + * @param className Weapon Classname. + * @return True on success, false on failure. + */ +stock bool Client_ChangeWeapon(int client, const char[] className) +{ + int weapon = Client_GetWeapon(client, className); + + if (weapon == INVALID_ENT_REFERENCE) { + return false; + } + + Client_SetActiveWeapon(client,weapon); + + return true; +} + +/** + * Changes the active weapon to the last. + * If the last active weapon can't be found, the default weapon is taken. + * If the default weapon can't be found, the first weapon in the list is taken. + * If the first weapon can't be found, INVALID_ENT_REFERENCEE is returned. + * + * @param client Client Index. + * @return Entity Index or, INVALID_ENT_REFERENCE. + */ +stock int Client_ChangeToLastWeapon(int client) +{ + int weapon = Client_GetLastActiveWeapon(client); + + if (weapon == INVALID_ENT_REFERENCE) { + weapon = Client_GetDefaultWeapon(client); + + if (weapon == INVALID_ENT_REFERENCE) { + weapon = Client_GetFirstWeapon(client); + + if (weapon == INVALID_ENT_REFERENCE) { + return INVALID_ENT_REFERENCE; + } + } + } + + Client_SetActiveWeapon(client, weapon); + + return weapon; +} + +/** + * Gets the last active weapon of a client. + * + * @param client Client Index. + * @return Entity Index of the weapon on success, INVALID_ENT_REFERENCE on failure. + */ +stock int Client_GetLastActiveWeapon(int client) +{ + int weapon = GetEntPropEnt(client, Prop_Data, "m_hLastWeapon"); + + if (!Entity_IsValid(weapon)) { + return INVALID_ENT_REFERENCE; + } + + return weapon; +} + +/** + * Gets the classname of the last active weapon of a client. + * + * @param client Client Index. + * @param buffer Buffer to store the weapon classname. + * @param size Max size of char buffer. + * @return True on success, false on failure. + */ +stock bool Client_GetLastActiveWeaponName(int client, char[] buffer, int size) +{ + int weapon = Client_GetLastActiveWeapon(client); + + if (weapon == INVALID_ENT_REFERENCE) { + buffer[0] = '\0'; + return false; + } + + Entity_GetClassName(weapon, buffer, size); + + return true; +} + +/** + * Sets the last active weapon of a client. + * + * @param client Client Index. + * @param weapon Entity Index of a weapon. + * @noreturn + */ +stock void Client_SetLastActiveWeapon(int client, int weapon) +{ + SetEntPropEnt(client, Prop_Data, "m_hLastWeapon", weapon); + ChangeEdictState(client, FindDataMapInfo(client, "m_hLastWeapon")); +} + +/** + * Equips (attaches) a weapon to a client. + * + * @param client Client Index. + * @param weapon Entity Index of the weapon. + * @param switchTo If true, the client will switch to that weapon (make it active). + * @noreturn + */ +stock void Client_EquipWeapon(int client, int weapon, bool switchTo=false) +{ + EquipPlayerWeapon(client, weapon); + + if (switchTo) { + Client_SetActiveWeapon(client, weapon); + } +} + +/** + * Safely detaches a clients weapon, to remove it as example. + * The client will select his last weapon when detached. + * + * @param client Client Index. + * @param weapon Entity Index of the weapon, you'd like to detach. + * @return True on success, false otherwise. + */ +stock bool Client_DetachWeapon(int client, int weapon) +{ + if (!RemovePlayerItem(client, weapon)) { + return false; + } + + if (Client_GetActiveWeapon(client) == INVALID_ENT_REFERENCE) { + Client_ChangeToLastWeapon(client); + } + + return true; +} + +/** + * Gives a client a weapon. + * + * @param client Client Index. + * @param className Weapon Classname String. + * @param switchTo If set to true, the client will switch the active weapon to the new weapon. + * @return Entity Index of the given weapon on success, INVALID_ENT_REFERENCE on failure. + */ +stock int Client_GiveWeapon(int client, const char[] className, bool switchTo=true) +{ + int weapon = Client_GetWeapon(client, className); + + if (weapon == INVALID_ENT_REFERENCE) { + weapon = Weapon_CreateForOwner(client, className); + + if (weapon == INVALID_ENT_REFERENCE) { + return INVALID_ENT_REFERENCE; + } + } + + Client_EquipWeapon(client, weapon, switchTo); + + return weapon; +} + +/** + * Gives a client a weapon and ammo for that weapon. + * + * @param client Client Index. + * @param className Weapon Classname String. + * @param switchTo If set to true, the client will switch the active weapon to the new weapon. + * @param primaryAmmo Primary ammo stock value from the client, if -1 the value is untouched. + * @param secondaryAmmo Secondary ammo stock value from the client, if -1 the value is untouched. + * @param primaryClip Primary ammo value in the weapon clip, if -1 the value is untouched. + * @param secondaryClip Secondary ammo value in the weapon clip, if -1 the value is untouched. + * @return Entity Index of the given weapon on success, INVALID_ENT_REFERENCE on failure. + */ +stock int Client_GiveWeaponAndAmmo(int client, const char[] className, bool switchTo=true, int primaryAmmo=-1, int secondaryAmmo=-1, int primaryClip=-1, int secondaryClip=-1) +{ + int weapon = Client_GiveWeapon(client, className, switchTo); + + if (weapon == INVALID_ENT_REFERENCE) { + return INVALID_ENT_REFERENCE; + } + + if (primaryClip != -1) { + Weapon_SetPrimaryClip(weapon, primaryClip); + } + + if (secondaryClip != -1) { + Weapon_SetSecondaryClip(weapon, secondaryClip); + } + + Client_SetWeaponPlayerAmmoEx(client, weapon, primaryAmmo, secondaryAmmo); + + return weapon; +} + +/** + * Removes a weapon from a client. + * + * @param client Client Index. + * @param className Weapon Classname String. + * @param firstOnly If false it loops trough the whole weapon list and deletes all weapons that match the specified classname. + * @param clearAmmo If true, the ammo the client carries for that weapon will be set to 0 (primary and secondary). + * @return True on success, false otherwise. + */ +stock bool Client_RemoveWeapon(int client, const char[] className, bool firstOnly=true, bool clearAmmo=false) +{ + int offset = Client_GetWeaponsOffset(client) - 4; + + for (int i=0; i < MAX_WEAPONS; i++) { + offset += 4; + + int weapon = GetEntDataEnt2(client, offset); + + if (!Weapon_IsValid(weapon)) { + continue; + } + + if (!Entity_ClassNameMatches(weapon, className)) { + continue; + } + + if (clearAmmo) { + Client_SetWeaponPlayerAmmoEx(client, weapon, 0, 0); + } + + if (Client_GetActiveWeapon(client) == weapon) { + Client_ChangeToLastWeapon(client); + } + + if (RemovePlayerItem(client, weapon)) { + Entity_Kill(weapon); + } + + if (firstOnly) { + return true; + } + } + + return false; +} + +/** + * Removes all weapons of a client. + * You can specify a weapon it shouldn't remove and if to + * clear the player's ammo for a weapon when it gets removed. + * + * @param client Client Index. + * @param exclude If not empty, this weapon won't be removed from the client. + * @param clearAmmo If true, the ammo the player carries for all removed weapons are set to 0 (primary and secondary). + * @return Number of removed weapons. + */ +stock int Client_RemoveAllWeapons(int client, const char exclude[]="", bool clearAmmo=false) +{ + int offset = Client_GetWeaponsOffset(client) - 4; + + int numWeaponsRemoved = 0; + for (int i=0; i < MAX_WEAPONS; i++) { + offset += 4; + + int weapon = GetEntDataEnt2(client, offset); + + if (!Weapon_IsValid(weapon)) { + continue; + } + + if (exclude[0] != '\0' && Entity_ClassNameMatches(weapon, exclude)) { + Client_SetActiveWeapon(client, weapon); + continue; + } + + if (clearAmmo) { + Client_SetWeaponPlayerAmmoEx(client, weapon, 0, 0); + } + + if (RemovePlayerItem(client, weapon)) { + Entity_Kill(weapon); + } + + numWeaponsRemoved++; + } + + return numWeaponsRemoved; +} + +/** + * Checks if a client has a specific weapon. + * + * @param client Client Index. + * @param className Weapon Classname. + * @return True if client has the weapon, otherwise false. + */ +stock bool Client_HasWeapon(int client, const char[] className) +{ + int weapon = Client_GetWeapon(client, className); + + return (weapon != INVALID_ENT_REFERENCE); +} + +/** + * Gets the weapon of a client by the weapon's classname. + * + * @param client Client Index. + * @param className Classname of the weapon. + * @return Entity index on success or INVALID_ENT_REFERENCE. + */ +stock int Client_GetWeapon(int client, const char[] className) +{ + int offset = Client_GetWeaponsOffset(client) - 4; + int weapon = INVALID_ENT_REFERENCE; + for (int i=0; i < MAX_WEAPONS; i++) { + offset += 4; + + weapon = GetEntDataEnt2(client, offset); + + if (!Weapon_IsValid(weapon)) { + continue; + } + + if (Entity_ClassNameMatches(weapon, className)) { + return weapon; + } + } + + return INVALID_ENT_REFERENCE; +} + +/** + * Gets the weapon of a client by slot number. + * Note: This is incompatible to games that have multiple + * weapons in one slot (eg.: hl2dm). + * + * @param client Client Index. + * @param slot Slot Index. + * @return Entity index on success or INVALID_ENT_REFERENCE. + */ +stock int Client_GetWeaponBySlot(int client, int slot) +{ + return GetPlayerWeaponSlot(client, slot); +} + +/** + * Gets the clients default weapon (Entity Index). + * + * @param client Client Index. + * @return Entity Index on success, INVALID_ENT_REFERENCE on failure. + */ +stock int Client_GetDefaultWeapon(int client) +{ + char weaponName[MAX_WEAPON_STRING]; + if (Client_GetDefaultWeaponName(client, weaponName, sizeof(weaponName))) { + return INVALID_ENT_REFERENCE; + } + + return Client_GetWeapon(client, weaponName); +} + +/** + * Gets the clients default weapon (classname). + * This function doesn't work in all games (maybe only works in hl2dm). + * It will return an empty string if cl_defaultweapon doesn't exist. + * + * @param client Client Index. + * @param buffer Buffer to store the default weapon's classname. + * @param size Max size of char buffer. + * @return True on success, false otherwise. + */ +stock bool Client_GetDefaultWeaponName(int client, char[] buffer, int size) +{ + if (!GetClientInfo(client, "cl_defaultweapon", buffer, size)) { + buffer[0] = '\0'; + return false; + } + + return true; +} + +/** + * Gets the first weapon of the client's weapon list (m_hMyWeapons). + * Note: This has nothing to do with weapon slots. + * + * @param client Client Index. + * @return Entity Index of the weapon or INVALID_ENT_REFERENCE. + */ +stock int Client_GetFirstWeapon(int client) +{ + int offset = Client_GetWeaponsOffset(client) - 4; + + for (int i=0; i < MAX_WEAPONS; i++) { + offset += 4; + + int weapon = GetEntDataEnt2(client, offset); + + if (!Weapon_IsValid(weapon)) { + continue; + } + + return weapon; + } + + return INVALID_ENT_REFERENCE; +} + +/** + * Gets the number of weapons a client has. + * + * @param client Client Index. + * @return Number of weapons. + */ +stock int Client_GetWeaponCount(int client) +{ + int numWeapons = 0; + + int offset = Client_GetWeaponsOffset(client) - 4; + + for (int i=0; i < MAX_WEAPONS; i++) { + offset += 4; + + int weapon = GetEntDataEnt2(client, offset); + + if (!Weapon_IsValid(weapon)) { + continue; + } + + numWeapons++; + } + + return numWeapons; +} + +/** + * Checks whether the client is currently reloading his active weapon. + * + * @param client Client Index. + * @return True if client is reloading, false otherwise. + */ +stock bool Client_IsReloading(int client) +{ + int weapon = Client_GetActiveWeapon(client); + + if (weapon == INVALID_ENT_REFERENCE) { + return false; + } + + return Weapon_IsReloading(weapon); +} + +/** + * Sets the primary and secondary clip value of a weapon. + * + * @param client Client Index. + * @param classname Classname of a weapon. + * @param primaryClip Primary ammo value in the weapon clip, if -1 the value is untouched. + * @param secondaryClip Secondary ammo value in the weapon clip, if -1 the value is untouched. + * @return True on success, false on failure. + */ +stock bool Client_SetWeaponClipAmmo(int client, const char[] className, int primaryClip=-1, int secondaryClip=-1) +{ + int weapon = Client_GetWeapon(client, className); + + if (weapon == INVALID_ENT_REFERENCE) { + return false; + } + + if (primaryClip != -1) { + Weapon_SetPrimaryClip(weapon, primaryClip); + } + + if (secondaryClip != -1) { + Weapon_SetSecondaryClip(weapon, primaryClip); + } + + return true; +} + +/** + * Gets the primary and secondary ammo the player carries for a specific weapon classname. + * + * @param client Client Index. + * @param classname Classname of a weapon. + * @param primaryAmmo Primary ammo stock from the client, if -1 the value is untouched. + * @param secondaryAmmo Secondary ammo stock from the client, if -1 the value is untouched. + * @return True on success, false on failure. + */ +stock bool Client_GetWeaponPlayerAmmo(int client, const char[] className, int &primaryAmmo=-1, int &secondaryAmmo=-1) +{ + int weapon = Client_GetWeapon(client, className); + + if (weapon == INVALID_ENT_REFERENCE) { + return false; + } + + int offset_ammo = FindDataMapInfo(client, "m_iAmmo"); + + if (primaryAmmo != -1) { + int offset = offset_ammo + (Weapon_GetPrimaryAmmoType(weapon) * 4); + primaryAmmo = GetEntData(client, offset); + } + + if (secondaryAmmo != -1) { + int offset = offset_ammo + (Weapon_GetSecondaryAmmoType(weapon) * 4); + secondaryAmmo = GetEntData(client, offset); + } + + return true; +} + +/** + * Gets the primary and secondary ammo the player carries for a specific weapon index. + * + * @param client Client Index. + * @param weapon Weapon Entity Index. + * @param primaryAmmo Primary ammo stock value from the client, if -1 the value is untouched. + * @param secondaryAmmo Secondary ammo stock value from the client, if -1 the value is untouched. + * @noreturn + */ +stock void Client_GetWeaponPlayerAmmoEx(int client, int weapon, int &primaryAmmo=-1, int &secondaryAmmo=-1) +{ + int offset_ammo = FindDataMapInfo(client, "m_iAmmo"); + + if (primaryAmmo != -1) { + int offset = offset_ammo + (Weapon_GetPrimaryAmmoType(weapon) * 4); + primaryAmmo = GetEntData(client, offset); + } + + if (secondaryAmmo != -1) { + int offset = offset_ammo + (Weapon_GetSecondaryAmmoType(weapon) * 4); + secondaryAmmo = GetEntData(client, offset); + } +} + +/** + * Sets the primary and secondary ammo the player carries for a specific weapon classname. + * + * @param client Client Index. + * @param classname Weapon Classname String. + * @param primaryAmmo Primary ammo stock from the client, if -1 the value is untouched. + * @param secondaryAmmo Secondary ammo stock from the client, if -1 the value is untouched. + * @return True on success, false on failure. + */ +stock bool Client_SetWeaponPlayerAmmo(int client, const char[] className, int primaryAmmo=-1, int secondaryAmmo=-1) +{ + int weapon = Client_GetWeapon(client, className); + + if (weapon == INVALID_ENT_REFERENCE) { + return false; + } + + Client_SetWeaponPlayerAmmoEx(client, weapon, primaryAmmo, secondaryAmmo); + + return true; +} + +/** + * Sets the primary and secondary ammo the player carries for a specific weapon index. + * + * @param client Client Index. + * @param weapon Weapon Entity Index. + * @param primaryAmmo Primary ammo stock value from the client, if -1 the value is untouched. + * @param secondaryAmmo Secondary ammo stock value from the client, if -1 the value is untouched. + * @noreturn + */ +stock void Client_SetWeaponPlayerAmmoEx(int client, int weapon, int primaryAmmo=-1, int secondaryAmmo=-1) +{ + int offset_ammo = FindDataMapInfo(client, "m_iAmmo"); + + if (primaryAmmo != -1) { + int offset = offset_ammo + (Weapon_GetPrimaryAmmoType(weapon) * 4); + SetEntData(client, offset, primaryAmmo, 4, true); + } + + if (secondaryAmmo != -1) { + int offset = offset_ammo + (Weapon_GetSecondaryAmmoType(weapon) * 4); + SetEntData(client, offset, secondaryAmmo, 4, true); + } +} + +/** + * Sets the value from primary and secondary ammo stock, of a client. + * + * @param client Client Index. + * @param className Classname of a weapon. + * @param primaryAmmo Primary ammo stock value from the client, if -1 the value is untouched. + * @param secondaryAmmo Secondary ammo stock value from the client, if -1 the value is untouched. + * @param primaryClip Primary ammo value in the weapon clip, if -1 the value is untouched. + * @param secondaryClip Secondary ammo value in the weapon clip, if -1 the value is untouched. + * @return True on success, false on invalid weapon. + */ +stock bool Client_SetWeaponAmmo(int client, const char[] className, int primaryAmmo=-1, int secondaryAmmo=-1, int primaryClip=-1, int secondaryClip=-1) +{ + int weapon = Client_GetWeapon(client, className); + + if (weapon == INVALID_ENT_REFERENCE) { + return false; + } + + if (primaryClip != -1) { + Weapon_SetPrimaryClip(weapon, primaryClip); + } + if (secondaryClip != -1) { + Weapon_SetSecondaryClip(weapon, secondaryClip); + } + Client_SetWeaponPlayerAmmoEx(client, weapon, primaryAmmo, secondaryAmmo); + + return true; +} + +/** + * Gets the next weapon of a client, starting at start. + * + * @param client Client Index (must be a valid client ingame). + * @param index Reference to an index variable, will contain the index of the next weapon to check. + * @return Weapon Index or -1 if no more weapons are found. + */ +stock int Client_GetNextWeapon(int client, int &index = 0) +{ + int offset = Client_GetWeaponsOffset(client) + (index * 4); + + int weapon; + while (index < MAX_WEAPONS) { + index++; + + weapon = GetEntDataEnt2(client, offset); + + if (Weapon_IsValid(weapon)) { + return weapon; + } + + offset += 4; + } + + return -1; +} + +/** + * Prints white text to the bottom center of the screen + * for one client. Does not work in all games. + * Line Breaks can be done with "\n". + * + * @param client Client Index. + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @return True on success, false if this usermessage doesn't exist. + */ +stock bool Client_PrintHintText(int client, const char[] format, any ...) +{ + Handle userMessage = StartMessageOne("HintText", client); + + if (userMessage == null) { + return false; + } + + char buffer[254]; + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 3); + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available + && GetUserMessageType() == UM_Protobuf) { + + PbSetString(userMessage, "text", buffer); + } + else { + BfWriteByte(userMessage, 1); + BfWriteString(userMessage, buffer); + } + + EndMessage(); + + return true; +} + +/** + * Prints white text to the bottom center of the screen + * for all clients. Does not work in all games. + * Line Breaks can be done with "\n". + * + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_PrintHintTextToAll(const char[] format, any ...) +{ + char buffer[254]; + + for (int client=1; client <= MaxClients; client++) { + + if (!IsClientInGame(client)) { + continue; + } + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 2); + Client_PrintHintText(client, buffer); + } +} + +/** + * Prints white text to the right-center side of the screen + * for one client. Does not work in all games. + * Line Breaks can be done with "\n". + * + * @param client Client Index. + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @return True on success, false if this usermessage doesn't exist. + */ +stock bool Client_PrintKeyHintText(int client, const char[] format, any ...) +{ + Handle userMessage = StartMessageOne("KeyHintText", client); + + if (userMessage == null) { + return false; + } + + char buffer[254]; + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 3); + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available + && GetUserMessageType() == UM_Protobuf) { + + PbAddString(userMessage, "hints", buffer); + } + else { + BfWriteByte(userMessage, 1); + BfWriteString(userMessage, buffer); + } + + EndMessage(); + + return true; +} + +/** + * Prints white text to the right-center side of the screen + * for all clients. Does not work in all games. + * Line Breaks can be done with "\n". + * + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_PrintKeyHintTextToAll(const char[] format, any ...) +{ + char buffer[254]; + + for (int client=1; client <= MaxClients; client++) { + + if (!IsClientInGame(client)) { + continue; + } + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 2); + Client_PrintKeyHintText(client, buffer); + } +} + +/** + * Prints a reliable raw chat message to a client in the chat area. + * If the client == 0, the message will printed to server console. + * + * @param client Client Index. + * @param message String Message. + * @param subject Client Index/Subject (normally used for teamcolors) + * @param isChat Tells the game to handle the chat as normal (false) or chat message (true, plays a sound), only works if SayText2 is supported. + * @noreturn + */ +stock void Client_PrintToChatRaw(int client, const char[] message, int subject=0, bool isChat=false) +{ + if (client == 0) { + char buffer[253]; + Color_StripFromChatText(message, buffer, sizeof(buffer)); + PrintToServer(buffer); + return; + } + + static bool sayText2_supported = true; + static bool sayText2_checked = false; + + if (!sayText2_checked) { + + if (GetUserMessageId("SayText2") == INVALID_MESSAGE_ID) { + sayText2_supported = false; + } + + sayText2_checked = true; + } + + Handle userMessage = null; + + if (sayText2_supported) { + userMessage = StartMessageOne("SayText2", client, USERMSG_RELIABLE); + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available + && GetUserMessageType() == UM_Protobuf) { + + PbSetInt(userMessage, "ent_idx", subject); + PbSetBool(userMessage, "chat", isChat); + PbSetString(userMessage, "msg_name", message); + + // psychonic: Furthermore, some usermessages with repeated field, + // such as the commonly-used SayText2, expected an undocumented + // specific number of values added, else the client will crash when receiving. + PbAddString(userMessage, "params", ""); + PbAddString(userMessage, "params", ""); + PbAddString(userMessage, "params", ""); + PbAddString(userMessage, "params", ""); + } + else { + BfWriteByte(userMessage , subject); + BfWriteByte(userMessage , isChat); + BfWriteString(userMessage , message); + } + } + else { + userMessage = StartMessageOne("SayText", client, USERMSG_RELIABLE); + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available + && GetUserMessageType() == UM_Protobuf) { + + PbSetInt(userMessage, "ent_idx", subject); + PbSetString(userMessage, "text", message); + PbSetBool(userMessage, "chat", isChat); + } + else { + BfWriteByte(userMessage , subject); + BfWriteString(userMessage , message); + // For DoD:S nickname coloring + BfWriteByte(userMessage , -1); + } + } + + EndMessage(); +} + +/** + * Prints a reliable chat message to one client in the chat area. + * Allows up to 253 Characters (including \0) to be printed. + * Supports chat color tags (see: colors.inc). + * + * @param client Client Index. + * @param isChat Tells the game to handle the chat as normal (false) or chat message (true, plays a sound), only works if SayText2 is supported. + * @param format Formatting rules String. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_PrintToChat(int client, bool isChat, const char[] format, any ...) +{ + char buffer[512], buffer2[253]; + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 4); + int subject = Color_ParseChatText(buffer, buffer2, sizeof(buffer2)); + + Client_PrintToChatRaw(client, buffer2, subject, isChat); + + Color_ChatClearSubject(); +} + +static int printToChat_excludeclient = -1; + +/** + * Exclude a client from the next call to a Client_PrintToChat function. + * + * @param client Client Index. + * @noreturn + */ +stock void Client_PrintToChatExclude(int client) +{ + printToChat_excludeclient = client; +} + +/** + * Prints a reliable chat message to all clients in the chat area. + * Allows up to 253 Characters (including \0) to be printed. + * Supports chat color tags (see: colors.inc). + * + * @param isChat Tells the game to handle the chat as normal (false) or chat message (true, plays a sound), only works if SayText2 is supported. + * @param format Formatting rules String. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_PrintToChatAll(bool isChat, const char[] format, any ...) +{ + char buffer[512], buffer2[253]; + int subject, language, lastLanguage = -1; + + for (int client=1; client <= MaxClients; client++) { + + if (!IsClientInGame(client)) { + continue; + } + + if (client == printToChat_excludeclient) { + printToChat_excludeclient = -1; + continue; + } + + language = GetClientLanguage(client); + + if (language != lastLanguage) { + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 3); + subject = Color_ParseChatText(buffer, buffer2, sizeof(buffer2)); + + lastLanguage = language; + } + + Client_PrintToChatRaw(client, buffer2, subject, isChat); + } + + Color_ChatClearSubject(); +} + +/** + * Prints a reliable chat message to the specified clients in the chat area. + * Allows up to 253 Characters (including \0) to be print. + * Supports chat color tags (see: colors.inc). + * + * @param clients Client Array. + * @param numClients Number of clients in the client array. + * @param isChat Tells the game to handle the chat as normal (false) or chat message (true, plays a sound), only works if SayText2 is supported. + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_PrintToChatEx(int[] clients, int numClients, bool isChat, const char[] format, any ...) +{ + char buffer[512], buffer2[253]; + int client, subject, language, lastLanguage = -1; + + for (int i=0; i < numClients; i++) { + + client = clients[i]; + + if (!IsClientInGame(client)) { + continue; + } + + if (client == printToChat_excludeclient) { + printToChat_excludeclient = -1; + continue; + } + + language = GetClientLanguage(client); + + if (language != lastLanguage) { + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 5); + subject = Color_ParseChatText(buffer, buffer2, sizeof(buffer2)); + + lastLanguage = language; + } + + Client_PrintToChatRaw(client, buffer2, subject, isChat); + } + + Color_ChatClearSubject(); +} + +enum ClientHudPrint { + ClientHudPrint_Notify = 1, + ClientHudPrint_Console, + ClientHudPrint_Talk, + Client_HudPrint_Center +}; + +/** + * Prints a relieable message to the client's console. + * Allows up to 254 Characters (including \0) to be print (253 for talk). + * Supports chat color tags (see: colors.inc, only available in Left 4 Dead (2) or higher). + * Chat colors are stripped automatically if not supported. + * + * @param clients Client Array. + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_PrintToConsole(int client, const char[] format, any ...) +{ + char buffer[512]; + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 3); + + Client_Print(client, ClientHudPrint_Console, buffer); +} + +/** + * Prints a relieable message to the client's console. + * Allows up to 254 Characters (including \0) to be print. + * Supports chat color tags in chat & console (see: colors.inc). + * Chat colors are stripped automatically if not supported in the destination. + * + * @param clients Client Array. + * @param destination Destination place (use onf of the ClientHudPrint_) + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_Print(int client, ClientHudPrint destination, const char[] format, any ...) +{ + char buffer[512], buffer2[254]; + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 4); + + int subject = Color_ParseChatText(buffer, buffer2, sizeof(buffer2)); + + if (destination == ClientHudPrint_Talk) { + Client_PrintToChatRaw(client, buffer2, subject, false); + return; + } + + EngineVersion engineVersion = GetEngineVersion(); + if (client == 0 || + destination != ClientHudPrint_Console || + (destination == ClientHudPrint_Console + && engineVersion != Engine_Left4Dead && engineVersion != Engine_Left4Dead2)) + { + Color_StripFromChatText(buffer2, buffer2, sizeof(buffer2)); + + if (client == 0) { + PrintToServer(buffer2); + return; + } + } + + Handle userMessage = null; + userMessage = StartMessageOne("TextMsg", client, USERMSG_RELIABLE); + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available + && GetUserMessageType() == UM_Protobuf) { + + PbSetInt(userMessage, "msg_dst", view_as(destination)); + PbAddString(userMessage, "params", buffer2); + PbAddString(userMessage, "params", ""); + PbAddString(userMessage, "params", ""); + PbAddString(userMessage, "params", ""); + PbAddString(userMessage, "params", ""); + } + else { + BfWriteByte(userMessage , view_as(destination)); + BfWriteString(userMessage , buffer2); + } + + EndMessage(); +} + +/** + * Replies to a message in a command. + * A client index of 0 will use PrintToServer(). + * If the command was from the console, Client_PrintToConsole() is used. + * If the command was from chat, Client_PrintToChat() is used. + * + * @param client Client Index. + * @param format Formatting rules String. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_Reply(int client, const char[] format, any ...) +{ + char buffer[255]; + + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 3); + + if (GetCmdReplySource() == SM_REPLY_TO_CONSOLE) { + Client_PrintToConsole(client, buffer); + } + else { + Client_PrintToChat(client, false, buffer); + } +} + +#define SHAKE_START 0 // Starts the screen shake for all players within the radius. +#define SHAKE_STOP 1 // Stops the screen shake for all players within the radius. +#define SHAKE_AMPLITUDE 2 // Modifies the amplitude of an active screen shake for all players within the radius. +#define SHAKE_FREQUENCY 3 // Modifies the frequency of an active screen shake for all players within the radius. +#define SHAKE_START_RUMBLEONLY 4 // Starts a shake effect that only rumbles the controller, no screen effect. +#define SHAKE_START_NORUMBLE 5 // Starts a shake that does NOT rumble the controller. + +/** + * Shakes a client's screen with the specified amptitude, + * frequency & duration. + * + * @param client Client Index. + * @param command Shake Mode, use one of the SHAKE_ definitions. + * @param amplitude Shake magnitude/amplitude. + * @param frequency Shake noise frequency. + * @param duration Shake lasts this long. + * @return True on success, false otherwise. + */ +stock bool Client_Shake(int client, int command=SHAKE_START, float amplitude=50.0, float frequency=150.0, float duration=3.0) +{ + if (command == SHAKE_STOP) { + amplitude = 0.0; + } + else if (amplitude <= 0.0) { + return false; + } + + Handle userMessage = StartMessageOne("Shake", client); + + if (userMessage == null) { + return false; + } + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available + && GetUserMessageType() == UM_Protobuf) { + + PbSetInt(userMessage, "command", command); + PbSetFloat(userMessage, "local_amplitude", amplitude); + PbSetFloat(userMessage, "frequency", frequency); + PbSetFloat(userMessage, "duration", duration); + } + else { + BfWriteByte(userMessage, command); // Shake Command + BfWriteFloat(userMessage, amplitude); // shake magnitude/amplitude + BfWriteFloat(userMessage, frequency); // shake noise frequency + BfWriteFloat(userMessage, duration); // shake lasts this long + } + + EndMessage(); + + return true; +} + +/** + * Checks whether the client is a generic admin. + * + * @param Client Index. + * @return True if the client is a generic admin, false otheriwse. + */ +stock bool Client_IsAdmin(int client) +{ + AdminId adminId = GetUserAdmin(client); + + if (adminId == INVALID_ADMIN_ID) { + return false; + } + + return GetAdminFlag(adminId, Admin_Generic); +} + +/** + * Checks whether a client has certain admin flags + * + * @param Client Index. + * @return True if the client has the admin flags, false otherwise. + */ +stock bool Client_HasAdminFlags(int client, int flags=ADMFLAG_GENERIC) +{ + AdminId adminId = GetUserAdmin(client); + + if (adminId == INVALID_ADMIN_ID) { + return false; + } + + return view_as(GetAdminFlags(adminId, Access_Effective) & flags); +} + +/** + * Returns whether a player is in a specific admin group. + * + * @param client Client Index. + * @param groupName Admin group name to check. + * @param caseSensitive True if the group check has to be case sensitive, false otherwise. + * @return True if the client is in the admin group, false otherwise. + */ +stock bool Client_IsInAdminGroup(int client, const char[] groupName, bool caseSensitive=true) +{ + AdminId adminId = GetUserAdmin(client); + + // Validate id. + if (adminId == INVALID_ADMIN_ID) { + return false; + } + + // Get number of groups. + int count = GetAdminGroupCount(adminId); + + // Validate number of groups. + if (count == 0) { + return false; + } + + char groupname[64]; + + // Loop through each group. + for (int i = 0; i < count; i++) { + // Get group name. + GetAdminGroup(adminId, i, groupname, sizeof(groupname)); + + // Compare names. + if (StrEqual(groupName, groupname, caseSensitive)) { + return true; + } + } + + // No match. + return false; +} + +/** + * Checks if the client is currently looking at the wall in front + * of him with the given distance as max value. + * + * @param client Client Index. + * @param distance Max Distance as Float value. + * @return True if he is looking at a wall, false otherwise. + */ +stock bool Client_IsLookingAtWall(int client, float distance=40.0) { + + float posEye[3], posEyeAngles[3]; + bool isClientLookingAtWall = false; + + GetClientEyePosition(client, posEye); + GetClientEyeAngles(client, posEyeAngles); + + posEyeAngles[0] = 0.0; + + Handle trace = TR_TraceRayFilterEx(posEye, posEyeAngles, CONTENTS_SOLID, RayType_Infinite, _smlib_TraceEntityFilter); + + if (TR_DidHit(trace)) { + + if (TR_GetEntityIndex(trace) > 0) { + delete trace; + return false; + } + + float posEnd[3]; + + TR_GetEndPosition(posEnd, trace); + + if (GetVectorDistance(posEye, posEnd, true) <= (distance * distance)) { + isClientLookingAtWall = true; + } + } + + delete trace; + + return isClientLookingAtWall; +} + +public bool _smlib_TraceEntityFilter(int entity, int contentsMask) +{ + return entity == 0; +} + +/** + * Gets a client's class. + * Currently supported games are: TF2, Dark Messiah. + * Other games maybe work too, but are not tested. + * + * @param client Client Index. + * @return Class Index. + */ +stock int Client_GetClass(int client) +{ + if (GetEngineVersion() == Engine_DarkMessiah) { + return GetEntProp(client, Prop_Send, "m_iPlayerClass"); + } + + return GetEntProp(client, Prop_Send, "m_iClass"); +} + +/** + * Sets a client's class. + * Currently supported games are: TF2, Dark Messiah. + * Other games maybe work too, but are not tested. + * + * @param client Client Index. + * @param playerClass The class number to set the player to. Depends on game. + * @param persistant If true changes the players desired class so the change stays after death (probably TF2 only). + * @return Class Index. + */ +stock int Client_SetClass(int client, int playerClass, bool persistant=false) +{ + if (GetEngineVersion() == Engine_DarkMessiah) { + SetEntProp(client, Prop_Send, "m_iPlayerClass", playerClass); + } else { + SetEntProp(client, Prop_Send, "m_iClass", playerClass); + + if (persistant) { + SetEntProp(client, Prop_Send, "m_iDesiredPlayerClass", playerClass); + } + } +} + +/** + * Returns what buttons are currently pressed by the client. + * + * @param client Client Index. + * @return Buttons as bitflag. + */ +stock int Client_GetButtons(int client) +{ + return GetClientButtons(client); +} + +/** + * Sets the client buttons. + * Note: This will only work OnPreThink (sdkhooks) or OnPlayerRunCmd. + * + * @param client Client Index. + * @param buttons Buttons as bitflag. + * @noreturn + */ +stock void Client_SetButtons(int client, int buttons) +{ + SetEntProp(client, Prop_Data, "m_nButtons", buttons); +} + +/** + * Adds buttons to the already pressed buttons. + * Note: This will likely only work OnPreThink (sdkhooks) or OnPlayerRunCmd. + * + * @param client Client Index. + * @param buttons Buttons as bitflag. + * @noreturn + */ +stock void Client_AddButtons(int client, int buttons) +{ + int newButtons = Client_GetButtons(client); + newButtons |= buttons; + Client_SetButtons(client, newButtons); +} + +/** + * Removes buttons from the already pressed buttons. + * Note: This will only work OnPreThink (sdkhooks) or OnPlayerRunCmd. + * + * @param client Client Index. + * @param buttons Buttons as bitflag. + * @noreturn + */ +stock void Client_RemoveButtons(int client, int buttons) +{ + int newButtons = Client_GetButtons(client); + newButtons &= ~buttons; + Client_SetButtons(client, newButtons); +} + +/** + * Clears all buttons. + * Note: This will likely only work OnPreThink (sdkhooks) or OnPlayerRunCmd. + * + * @param client Client Index. + * @noreturn + */ +stock void Client_ClearButtons(int client) +{ + Client_SetButtons(client,0); +} + +/** + * Returns if the given buttons are pressed by the client or not. + * + * @param client Client Index. + * @param buttons Buttons as bitflag. + * @return True if the buttons are pressed otherwise false. + */ +stock bool Client_HasButtons(int client, int buttons) +{ + return view_as(Client_GetButtons(client) & buttons); +} + +/** + * Returns only the buttons that have changed since the last call of this. + * Example usage: Within OnPlayerRunCmd use this function to call another function only once when a player pressed or released a button. + * + * @param client Client Index. + * @param buttons Buttons as bitflag. + * @return Return changed buttons + */ +stock int Client_GetChangedButtons(int client) +{ + static int oldButtons[MAXPLAYERS+1] = {0,...}; + + int buttons = Client_GetButtons(client); + int changedButtons = buttons ^ oldButtons[client]; + + oldButtons[client] = buttons; + + return changedButtons; +} + +/** + * Sets the client's maxspeed to the given value (in units per second) + * + * @param Client Client Index + * @param maxspeed the maximum speed the client can move + * @noreturn + */ +stock void Client_SetMaxSpeed(int client, float value) +{ + Entity_SetMaxSpeed(client, value); +} + +/** + * Shows a screen overlay tp a client. + * There can only be one overlay at a time. + * If you want to clear the overlay, pass + * an empty string to this function. + * + * @param Client Client Index. + * @param path Overlay path (based on the game/materials/ folder) or empty String to not show any overlay. + * @noreturn + */ +stock void Client_SetScreenOverlay(int client, const char[] path) +{ + ClientCommand(client, "r_screenoverlay \"%s\"", path); +} + +/** + * Shows a screen overlay to all clients. + * There can only be one overlay at a time. + * If you want to clear the overlay, pass + * an empty string to this function. + * + * @param Client Client Index. + * @param path Overlay path (based on the game/materials/ folder) or empty String to not show any overlay. + * @noreturn + */ +stock void Client_SetScreenOverlayForAll(const char[] path) +{ + LOOP_CLIENTS(client, CLIENTFILTER_INGAME | CLIENTFILTER_NOBOTS) { + Client_SetScreenOverlay(client, path); + } +} + +/** + * Mutes a client's voice + * + * @param Client Client Index. + * @noreturn + */ +stock void Client_Mute(int client) +{ + SetClientListeningFlags(client, VOICE_MUTED); +} + +/** + * UnMutes a client's voice + * Code copied from basecomm.sp + * + * @param Client Client Index. + * @noreturn + */ +stock void Client_UnMute(int client) +{ + static ConVar cvDeadTalk; + + if (cvDeadTalk == null) { + cvDeadTalk = FindConVar("sm_deadtalk"); + } + + if (cvDeadTalk == null) { + SetClientListeningFlags(client, VOICE_NORMAL); + } + else { + if (cvDeadTalk.IntValue == 1 && !IsPlayerAlive(client)) { + SetClientListeningFlags(client, VOICE_LISTENALL); + } + else if (cvDeadTalk.IntValue == 2 && !IsPlayerAlive(client)) { + SetClientListeningFlags(client, VOICE_TEAM); + } + else { + SetClientListeningFlags(client, VOICE_NORMAL); + } + } +} + +/** + * Checks if a client's voice is muted + * + * @param client Client Index. + * @return True if the client is muted, false otherwise. + */ +stock bool Client_IsMuted(int client) +{ + return view_as(GetClientListeningFlags(client) & VOICE_MUTED); +} + +/** + * Checks if a client matches the specified flag filter. + * Use one of the CLIENTFILTER_ constants. + * Note that this already checks if the client is ingame or connected + * so you don't have to do that yourself. + * This function is optimized to make as less native calls as possible :) + * + * @param client Client Index. + * @param flags Client Filter Flags (Use the CLIENTFILTER_ constants). + * @return True if the client if the client matches, false otherwise. + */ +stock bool Client_MatchesFilter(int client, int flags) +{ + bool isIngame = false; + + if (flags >= CLIENTFILTER_INGAME) { + isIngame = IsClientInGame(client); + + if (isIngame) { + if (flags & CLIENTFILTER_NOTINGAME) { + return false; + } + } + else { + return false; + } + } + else if (!IsClientConnected(client)) { + return false; + } + + if (!flags) { + return true; + } + + if (flags & CLIENTFILTER_INGAMEAUTH) { + flags |= CLIENTFILTER_INGAME | CLIENTFILTER_AUTHORIZED; + } + + if (flags & CLIENTFILTER_BOTS && !IsFakeClient(client)) { + return false; + } + + if (flags & CLIENTFILTER_NOBOTS && IsFakeClient(client)) { + return false; + } + + if (flags & CLIENTFILTER_ADMINS && !Client_IsAdmin(client)) { + return false; + } + + if (flags & CLIENTFILTER_NOADMINS && Client_IsAdmin(client)) { + return false; + } + + if (flags & CLIENTFILTER_AUTHORIZED && !IsClientAuthorized(client)) { + return false; + } + + if (flags & CLIENTFILTER_NOTAUTHORIZED && IsClientAuthorized(client)) { + return false; + } + + if (isIngame) { + + if (flags & CLIENTFILTER_ALIVE && !IsPlayerAlive(client)) { + return false; + } + + if (flags & CLIENTFILTER_DEAD && IsPlayerAlive(client)) { + return false; + } + + if (flags & CLIENTFILTER_SPECTATORS && GetClientTeam(client) != TEAM_SPECTATOR) { + return false; + } + + if (flags & CLIENTFILTER_NOSPECTATORS && GetClientTeam(client) == TEAM_SPECTATOR) { + return false; + } + + if (flags & CLIENTFILTER_OBSERVERS && !IsClientObserver(client)) { + return false; + } + + if (flags & CLIENTFILTER_NOOBSERVERS && IsClientObserver(client)) { + return false; + } + + if (flags & CLIENTFILTER_TEAMONE && GetClientTeam(client) != TEAM_ONE) { + return false; + } + + if (flags & CLIENTFILTER_TEAMTWO && GetClientTeam(client) != TEAM_TWO) { + return false; + } + } + + return true; +} + +/** + * Gets all clients matching the specified flags filter. + * + * @param client Client Array, size should be MaxClients or MAXPLAYERS + * @param flags Client Filter Flags (Use the CLIENTFILTER_ constants). + * @return The number of clients stored in the array + */ +stock int Client_Get(int[] clients, int flags=CLIENTFILTER_ALL) +{ + int x=0; + for (int client = 1; client <= MaxClients; client++) { + + if (!Client_MatchesFilter(client, flags)) { + continue; + } + + clients[x++] = client; + } + + return x; +} + +/** + * Gets a random client matching the specified flags filter. + * + * @param flags Client Filter Flags (Use the CLIENTFILTER_ constants). + * @return Client Index or -1 if no client was found + */ +stock int Client_GetRandom(int flags=CLIENTFILTER_ALL) +{ + int[] clients = new int[MaxClients]; + int num = Client_Get(clients, flags); + + if (num == 0) { + return -1; + } + else if (num == 1) { + return clients[0]; + } + + int random = Math_GetRandomInt(0, num-1); + + return clients[random]; +} + +/** + * Gets a client matching certain flags starting at start. + * + * @param flags Client Filter Flags (Use the CLIENTFILTER_ constants). + * @param start Start Index. + * @return Client Index or -1 if no client was found + */ +stock int Client_GetNext(int flags, int start=1) +{ + for (int client=start; client <= MaxClients; client++) { + + if (Client_MatchesFilter(client, flags)) { + return client; + } + } + + return -1; +} + +/** + * Retrieves the time duration a client played on the current map. + * + * @param client Client Index. + * @return Time in seconds as Float + */ +stock float Client_GetMapTime(int client) +{ + float fClientTime = GetClientTime(client); + float fGameTime = GetGameTime(); + + return (fClientTime < fGameTime) ? fClientTime : fGameTime; +} + +/** + * Gets client money value (for games like Counter-Strike:Source). + * + * @param client Client Index. + * @return Money value from the client. + */ +stock int Client_GetMoney(int client) +{ + return GetEntProp(client, Prop_Send, "m_iAccount"); +} + +/** + * Sets client money value (for games like Counter-Strike:Source). + * + * @param client Client Index. + * @param value Money value to set. + * @noreturn + */ +stock void Client_SetMoney(int client, any value) +{ + SetEntProp(client, Prop_Send, "m_iAccount", value); +} + +/** + * Gets a client's observers. + * + * @param client Client Index. + * @param observers Array with size of MaxClients or MAXPLAYERS. + * @param flags Client Filter Flags (Use the CLIENTFILTER_ constants). + * @return Number of observers found. + */ +stock int Client_GetObservers(int client, int[] observers, int flags=CLIENTFILTER_ALL) +{ + int count = 0; + + LOOP_CLIENTS(player, CLIENTFILTER_OBSERVERS | flags) { + + if (Client_GetObserverTarget(player) == client) { + observers[count++] = player; + } + } + + return count; +} + +static float getPlayersInRadius_distances[MAXPLAYERS+1]; + +/** + * Gets all players near a player in a certain radius and + * orders the players by distance (optional). + * + * @param client Client Index. + * @param clients Array with size of MaxClients or MAXPLAYERS. + * @param radius radius Float (max distance) + * @param orderByDistance Set to true to order the clients by distance, false otherwise. + * @return Number of clients found. + */ +stock int Client_GetPlayersInRadius(int client, int[] clients, float radius, bool orderByDistance=true) +{ + float origin_client[3], distance; + int count=0; + + Entity_GetAbsOrigin(client, origin_client); + + LOOP_CLIENTS(player, CLIENTFILTER_INGAME) { + + if (player == client) { + continue; + } + + distance = Entity_GetDistanceOrigin(player, origin_client); + + if (distance <= radius) { + clients[count++] = player; + + if (orderByDistance) { + getPlayersInRadius_distances[player] = distance; + } + } + } + + if (orderByDistance) { + SortCustom1D(clients, count, __smlib_GetPlayersInRadius_Sort); + } + + return count; +} + +public int __smlib_GetPlayersInRadius_Sort(int player1, int player2, const int[] clients, Handle hndl) +{ + return FloatCompare(getPlayersInRadius_distances[player1], getPlayersInRadius_distances[player2]); +} + +/** + * Gets the next player observing client starting at start. + * + * @param client Client Index (Observer Target) + * @param start Start Index. + * @param flags Client Filter Flags (Use the CLIENTFILTER_ constants). + * @return Client Index or -1 if no client was found + */ +stock int Client_GetNextObserver(int client, int start=1, int flags=CLIENTFILTER_ALL) +{ + for (int player=start; player <= MaxClients; player++) { + + if (Client_MatchesFilter(player, CLIENTFILTER_OBSERVERS | flags)) { + + if (Client_GetObserverTarget(player) == client) { + return player; + } + } + } + + return -1; +} + +/** + * Searchs and returns the game's player_manager entity. + * This should be called on every map start. + * + * @return player_manager entity or INVALID_ENT_REFERENCE if not found. + */ +stock int Client_GetPlayerManager() +{ + static int player_manager = INVALID_ENT_REFERENCE; + + if (player_manager != INVALID_ENT_REFERENCE) { + + if (Entity_IsValid(player_manager)) { + return player_manager; + } + else { + player_manager = INVALID_ENT_REFERENCE; + } + } + + int maxEntities = GetMaxEntities(); + + for (int entity=0; entity < maxEntities; entity++) { + + if (!Entity_IsValid(entity)) { + continue; + } + + if (Entity_ClassNameMatches(entity, "player_manager", true)) { + player_manager = EntIndexToEntRef(entity); + + return player_manager; + } + } + + return INVALID_ENT_REFERENCE; +} + +/** + * Sets the client's ping as displayed in the scoreboards. + * Should be called OnGameFrame. + * + * @param client Client Index + * @param value New ping value. + * @return True on sucess, false otherwise. + */ +stock bool Client_SetPing(int client, int value) +{ + int player_manager = Client_GetPlayerManager(); + + static int offset = -1; + + if (offset== -1) { + offset = GetEntSendPropOffs(player_manager, "m_iPing", true); + + if (offset == -1) { + return false; + } + } + + SetEntData(player_manager, offset + (client * 4), value, 4, true); + + return true; +} + +static int printToTop_excludeclient = -1; + +/** + * Exclude a client from the next call to a Client_PrintToTop function. + * + * @param client Client Index. + * @noreturn + */ +stock void Client_PrintToTopExclude(int client) +{ + printToTop_excludeclient = client; +} + +/** + * Prints colored text to the top left of the screen + * for one client. Does not work in all games. + * Line Breaks can't be done. + * + * @param client Client Index. + * @param r Red amount. + * @param g Green amount. + * @param b Blue amount. + * @param a Transparency. + * @param duration Duration in seconds the text stays (min 10 - max 200 seconds). + * @param text Text to print to. + * @return True on success, false if the key value for the dialog couldn't be created or closed. + */ +stock bool Client_PrintToTopRaw(int client, int r=255, int g=255, int b=255, int a=255, float duration=10.0, const char[] text) +{ + //message line max 50 + //overline: 39*_ + //underline: 44*T + KeyValues keyValue = new KeyValues("Stuff", "title", text); + + if (keyValue == null) { + return false; + } + + keyValue.SetColor("color", r, g, b, a); + keyValue.SetNum("level", 1); + keyValue.SetNum("time", RoundToFloor(duration)); + + CreateDialog(client, keyValue, DialogType_Msg); + + delete keyValue; + if (keyValue != null) { + return false; + } + return true; +} + +/** + * Prints colored text to the top left of the screen + * for one client. Does not work in all games. + * Line Breaks can't be done. + * + * @param client Client Index. + * @param r Red amount. + * @param g Green amount. + * @param b Blue amount. + * @param a Transparency. + * @param duration Duration in seconds the text stays (min 10 - max 200 seconds). + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @return True on success, false if the key value for the dialog couldn't be created or closed. + */ +stock bool Client_PrintToTop(int client, int r=255, int g=255, int b=255, int a=255, float duration=10.0, const char[] format, any ...) +{ + char buffer[150]; + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 8); + + return Client_PrintToTopRaw(client, r, g, b, a, duration, buffer); +} + +/** + * Prints colored text to the top left of the screen + * to all clients. Does not work in all games. + * Line Breaks can't be done. + * + * @param r Red amount. + * @param g Green amount. + * @param b Blue amount. + * @param a Transparency. + * @param duration Duration in seconds the text stays (min 10 - max 200 seconds). + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_PrintToTopAll(int r=255, int g=255, int b=255, int a=255, float duration=10.0, const char[] format, any ...) +{ + char buffer[150]; + int language, lastLanguage = -1; + + for (int client=1; client <= MaxClients; client++) { + + if (!IsClientInGame(client)) { + continue; + } + + if (client == printToTop_excludeclient) { + printToTop_excludeclient = -1; + continue; + } + + language = GetClientLanguage(client); + + if (language != lastLanguage) { + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 7); + + lastLanguage = language; + } + + Client_PrintToTopRaw(client, r, g, b, a, duration, buffer); + } +} + +/** + * Prints colored text to the top left of the screen + * to specified clients. Does not work in all games. + * Line Breaks can't be done. + * + * @param clients Client Array. + * @param numClients Number of clients in the clients array. + * @param r Red amount. + * @param g Green amount. + * @param b Blue amount. + * @param a Transparency. + * @param duration Duration in seconds the text stays (min 10 - max 200 seconds). + * @param format Formatting rules. + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void Client_PrintToTopEx(int[] clients, int numClients, int r=255, int g=255, int b=255, int a=255, float duration=10.0, const char[] format, any ...) +{ + char buffer[150]; + int client, language, lastLanguage = -1; + + for (int i=0; i < numClients; i++) { + + client = clients[i]; + + if (!IsClientInGame(client)) { + continue; + } + + if (client == printToTop_excludeclient) { + printToTop_excludeclient = -1; + continue; + } + + language = GetClientLanguage(client); + + if (language != lastLanguage) { + SetGlobalTransTarget(client); + VFormat(buffer, sizeof(buffer), format, 9); + + lastLanguage = language; + } + + Client_PrintToTopRaw(client, r, g, b, a, duration, buffer); + } +} + +/** + * Opens the scoreboard for a specific client + * + * @tested csgo + * @param client Client index + * @noreturn + */ +stock void Client_ShowScoreboard(int client, int flags=USERMSG_RELIABLE | USERMSG_BLOCKHOOKS) +{ + Handle handle = StartMessageOne("VGUIMenu", client, flags); + + if (GetFeatureStatus(FeatureType_Native, "GetUserMessageType") == FeatureStatus_Available && + GetUserMessageType() == UM_Protobuf) { + + PbSetString(handle, "name", "scores"); + PbSetBool(handle, "show", true); + } + else { + BfWriteString(handle, "scores"); + BfWriteByte(handle, 1); // Show + BfWriteByte(handle, 0); // subkeys count + } + + EndMessage(); +} \ No newline at end of file diff --git a/include/smlib/colors.inc b/include/smlib/colors.inc new file mode 100644 index 0000000..c7c2305 --- /dev/null +++ b/include/smlib/colors.inc @@ -0,0 +1,522 @@ +#if defined _smlib_colors_included + #endinput +#endif +#define _smlib_colors_included + +#include +#include +#include + +#define CHATCOLOR_NOSUBJECT -2 +#define SMLIB_COLORS_GAMEDATAFILE "smlib_colors.games" + +enum ChatColorSubjectType +{ + ChatColorSubjectType_none = -3, + + // Subject/Team colors + ChatColorSubjectType_player = -2, + ChatColorSubjectType_undefined = -1, + ChatColorSubjectType_world = 0 + // Anything higher is a specific team +} + +enum ChatColorInfo +{ + ChatColorInfo_Code, + ChatColorInfo_Alternative, + bool:ChatColorInfo_Supported, + ChatColorSubjectType:ChatColorInfo_SubjectType +}; + +enum ChatColor +{ + ChatColor_Normal, + ChatColor_Orange, + ChatColor_Red, + ChatColor_RedBlue, + ChatColor_Blue, + ChatColor_BlueRed, + ChatColor_Team, + ChatColor_Lightgreen, + ChatColor_Gray, + ChatColor_Green, + ChatColor_Olivegreen, + ChatColor_Black +} + +static char chatColorTags[][] = { + "N", // Normal + "O", // Orange + "R", // Red + "RB", // Red, Blue + "B", // Blue + "BR", // Blue, Red + "T", // Team + "L", // Light green + "GRA", // GRAy + "G", // Green + "OG", // Olive green + "BLA" // BLAck +}; + +static char chatColorNames[][] = { + "normal", // Normal + "orange", // Orange + "red", // Red + "redblue", // Red, Blue + "blue", // Blue + "bluered", // Blue, Red + "team", // Team + "lightgreen", // Light green + "gray", // GRAy + "green", // Green + "olivegreen", // Olive green + "black" // BLAck +}; + +static int chatColorInfo[][ChatColorInfo] = +{ + // Code , alternative , Is Supported? Chat color subject type Color name + { '\x01', -1/* None */ , true, ChatColorSubjectType_none, }, // Normal + { '\x01', 0 /* None */ , true, ChatColorSubjectType_none, }, // Orange + { '\x03', 9 /* Green */ , true, view_as(2) }, // Red + { '\x03', 4 /* Blue */ , true, view_as(2) }, // Red, Blue + { '\x03', 9 /* Green */ , true, view_as(3) }, // Blue + { '\x03', 2 /* Red */ , true, view_as(3) }, // Blue, Red + { '\x03', 9 /* Green */ , true, ChatColorSubjectType_player }, // Team + { '\x03', 9 /* Green */ , true, ChatColorSubjectType_world }, // Light green + { '\x03', 9 /* Green */ , true, ChatColorSubjectType_undefined},// GRAy + { '\x04', 0 /* Normal*/ , true, ChatColorSubjectType_none }, // Green + { '\x05', 9 /* Green */ , true, ChatColorSubjectType_none }, // Olive green + { '\x06', 9 /* Green */ , true, ChatColorSubjectType_none } // BLAck +}; + +static bool checkTeamPlay = false; +static ConVar mp_teamplay = null; +static bool isSayText2_supported = true; +static int chatSubject = CHATCOLOR_NOSUBJECT; + +/** + * Sets the subject (a client) for the chat color parser. + * Call this before Color_ParseChatText() or Client_PrintToChat(). + * + * @param client Client Index/Subject + * @noreturn + */ +stock void Color_ChatSetSubject(int client) +{ + chatSubject = client; +} + +/** + * Gets the subject used for the chat color parser. + * + * @return Client Index/Subject, or CHATCOLOR_NOSUBJECT if none + */ +stock int Color_ChatGetSubject() +{ + return chatSubject; +} + +/** + * Clears the subject used for the chat color parser. + * Call this after Color_ParseChatText(). + * + * @noreturn + */ +stock void Color_ChatClearSubject() +{ + chatSubject = CHATCOLOR_NOSUBJECT; +} + +/** + * Parses a chat string and converts all color tags to color codes. + * This is a very powerful function that works recursively over the color information + * table. The support colors are hardcoded, but can be overriden for each game by + * creating the file gamedata/smlib_colors.games.txt. + * + * @param str Chat String + * @param subject Output Buffer + * @param size Output Buffer size + * @return Returns a value for the subject + */ +stock int Color_ParseChatText(const char[] str, char[] buffer, int size) +{ + bool inBracket = false; + int x = 0, x_buf = 0, x_tag = 0, subject = CHATCOLOR_NOSUBJECT; + + size--; + char sTag[10] = "", // This should be able to hold "\x08RRGGBBAA"\0 + colorCode[10] = "", // This should be able to hold "\x08RRGGBBAA"\0 + currentColor[10] = "\x01"; // Initialize with normal color + + // Every chat message has to start with a + // color code, otherwise it will ignore all colors. + buffer[x_buf++] = '\x01'; + + while (str[x] != '\0') { + + if (size == x_buf) { + break; + } + + char character = str[x++]; + + if (inBracket) { + // We allow up to 9 characters in the tag (#RRGGBBAA) + if (character == '}' || x_tag > 9) { + inBracket = false; + sTag[x_tag] = '\0'; + x_tag = 0; + + if (character == '}') { + Color_TagToCode(sTag, subject, colorCode); + + if (colorCode[0] == '\0') { + // We got an unknown tag, ignore this + // and forward it to the buffer. + + // Terminate buffer with \0 so Format can handle it. + buffer[x_buf] = '\0'; + x_buf = Format(buffer, size, "%s{%s}", buffer, sTag); + + // We 'r done here + continue; + } + else if (!StrEqual(colorCode, currentColor)) { + // If we are already using this color, + // we don't need to set it again. + + // Write the color code to our buffer. + // x_buf will be increased by the number of cells written. + x_buf += strcopy(buffer[x_buf], size - x_buf, colorCode); + + // Remember the current color. + strcopy(currentColor, sizeof(currentColor), colorCode); + } + } + else { + // If the tag character limit exceeds 9, + // we have to do something. + + // Terminate buffer with \0 so Format can handle it. + buffer[x_buf] = '\0'; + x_buf = Format(buffer, size, "%s{%s%c", buffer, sTag, character); + } + } + else if (character == '{' && !x_tag) { + buffer[x_buf++] = '{'; + inBracket = false; + } + else { + sTag[x_tag++] = character; + } + } + else if (character == '{') { + inBracket = true; + } + else { + buffer[x_buf++] = character; + } + } + + // Write remaining text to the buffer, + // if we have been inside brackets. + if (inBracket) { + buffer[x_buf] = '\0'; + x_buf = Format(buffer, size, "%s{%s", buffer, sTag); + } + + buffer[x_buf] = '\0'; + + return subject; +} + +/** + * Converts a chat color tag to its code character. + * + * @param tag Color Tag String. + * @param subject Subject variable to pass + * @param result The result as character sequence (string). This will be \0 if the tag is unkown. + * @noreturn + */ +stock void Color_TagToCode(const char[] tag, int &subject=-1, char result[10]) +{ + // Check if the tag starts with a '#'. + // We will handle it has RGB(A)-color code then. + if (tag[0] == '#') { + int length_tag = strlen(tag); + switch (length_tag - 1) { + // #RGB -> \07RRGGBB + case 3: { + FormatEx( + result, sizeof(result), "\x07%c%c%c%c%c%c", + tag[1], tag[1], tag[2], tag[2], tag[3], tag[3] + ); + } + // #RGBA -> \08RRGGBBAA + case 4: { + FormatEx( + result, sizeof(result), "\x08%c%c%c%c%c%c%c%c", + tag[1], tag[1], tag[2], tag[2], tag[3], tag[3], tag[4], tag[4] + ); + } + // #RRGGBB -> \07RRGGBB + case 6: { + FormatEx(result, sizeof(result), "\x07%s", tag[1]); + } + // #RRGGBBAA -> \08RRGGBBAA + case 8: { + FormatEx(result, sizeof(result), "\x08%s", tag[1]); + } + default: { + result[0] = '\0'; + } + } + + } + else { + // Try to handle this string as color name + int n = Array_FindString(chatColorTags, sizeof(chatColorTags), tag); + + // Check if this tag is invalid + if (n == -1) { + result[0] = '\0'; + return; + } + + // Check if the color is actually supported 'n stuff. + Color_GetChatColorInfo(n, subject); + + result[0] = chatColorInfo[n][ChatColorInfo_Code]; + result[1] = '\0'; + } + +} + +/** + * Strips all color control characters in a string. + * The Output buffer can be the same as the input buffer. + * Original code by Psychonic, thanks. + * + * @param input Input String. + * @param output Output String. + * @param size Max Size of the Output string + * @noreturn + */ +stock void Color_StripFromChatText(const char[] input, char[] output, int size) +{ + int x = 0; + for (int i=0; input[i] != '\0'; i++) { + + if (x+1 == size) { + break; + } + + char character = input[i]; + + if (character > 0x08) { + output[x++] = character; + } + } + + output[x] = '\0'; +} + +/** + * Checks the gamename and sets default values. + * For example if some colors are supported, or + * if a game uses another color code for a specific color. + * All those hardcoded default values can be overriden in + * smlib's color gamedata file. + * + * @noreturn + */ +static stock void Color_ChatInitialize() +{ + static bool initialized = false; + + if (initialized) { + return; + } + + initialized = true; + + char gameFolderName[32]; + GetGameFolderName(gameFolderName, sizeof(gameFolderName)); + + chatColorInfo[ChatColor_Black][ChatColorInfo_Supported] = false; + + if (strncmp(gameFolderName, "left4dead", 9, false) != 0 && + !StrEqual(gameFolderName, "cstrike", false) && + !StrEqual(gameFolderName, "tf", false)) + { + chatColorInfo[ChatColor_Lightgreen][ChatColorInfo_Supported]= false; + chatColorInfo[ChatColor_Gray][ChatColorInfo_Supported] = false; + } + + if (StrEqual(gameFolderName, "tf", false)) { + chatColorInfo[ChatColor_Black][ChatColorInfo_Supported] = true; + + chatColorInfo[ChatColor_Gray][ChatColorInfo_Code] = '\x01'; + chatColorInfo[ChatColor_Gray][ChatColorInfo_SubjectType] = ChatColorSubjectType_none; + } + else if (strncmp(gameFolderName, "left4dead", 9, false) == 0) { + chatColorInfo[ChatColor_Red][ChatColorInfo_SubjectType] = view_as(3); + chatColorInfo[ChatColor_RedBlue][ChatColorInfo_SubjectType] = view_as(3); + chatColorInfo[ChatColor_Blue][ChatColorInfo_SubjectType] = view_as(2); + chatColorInfo[ChatColor_BlueRed][ChatColorInfo_SubjectType] = view_as(2); + + chatColorInfo[ChatColor_Orange][ChatColorInfo_Code] = '\x04'; + chatColorInfo[ChatColor_Green][ChatColorInfo_Code] = '\x05'; + } + else if (StrEqual(gameFolderName, "hl2mp", false)) { + chatColorInfo[ChatColor_Red][ChatColorInfo_SubjectType] = view_as(3); + chatColorInfo[ChatColor_RedBlue][ChatColorInfo_SubjectType] = view_as(3); + chatColorInfo[ChatColor_Blue][ChatColorInfo_SubjectType] = view_as(2); + chatColorInfo[ChatColor_BlueRed][ChatColorInfo_SubjectType] = view_as(2); + chatColorInfo[ChatColor_Black][ChatColorInfo_Supported] = true; + + checkTeamPlay = true; + } + else if (StrEqual(gameFolderName, "dod", false)) { + chatColorInfo[ChatColor_Gray][ChatColorInfo_Code] = '\x01'; + chatColorInfo[ChatColor_Gray][ChatColorInfo_SubjectType] = ChatColorSubjectType_none; + + chatColorInfo[ChatColor_Black][ChatColorInfo_Supported] = true; + chatColorInfo[ChatColor_Orange][ChatColorInfo_Supported] = false; + } + + if (GetUserMessageId("SayText2") == INVALID_MESSAGE_ID) { + isSayText2_supported = false; + } + + char path_gamedata[PLATFORM_MAX_PATH]; + BuildPath(Path_SM, path_gamedata, sizeof(path_gamedata), "gamedata/%s.txt", SMLIB_COLORS_GAMEDATAFILE); + + if (FileExists(path_gamedata)) { + Handle gamedata = null; + + if ((gamedata = LoadGameConfigFile(SMLIB_COLORS_GAMEDATAFILE)) != null) { + + char keyName[32], buffer[6]; + + for (int i=0; i < sizeof(chatColorNames); i++) { + + Format(keyName, sizeof(keyName), "%s_code", chatColorNames[i]); + if (GameConfGetKeyValue(gamedata, keyName, buffer, sizeof(buffer))) { + chatColorInfo[i][ChatColorInfo_Code] = StringToInt(buffer); + } + + Format(keyName, sizeof(keyName), "%s_alternative", chatColorNames[i]); + if (GameConfGetKeyValue(gamedata, keyName, buffer, sizeof(buffer))) { + chatColorInfo[i][ChatColorInfo_Alternative] = buffer[0]; + } + + Format(keyName, sizeof(keyName), "%s_supported", chatColorNames[i]); + if (GameConfGetKeyValue(gamedata, keyName, buffer, sizeof(buffer))) { + chatColorInfo[i][ChatColorInfo_Supported] = StrEqual(buffer, "true"); + } + + Format(keyName, sizeof(keyName), "%s_subjecttype", chatColorNames[i]); + if (GameConfGetKeyValue(gamedata, keyName, buffer, sizeof(buffer))) { + chatColorInfo[i][ChatColorInfo_SubjectType] = view_as(StringToInt(buffer)); + } + } + + if (GameConfGetKeyValue(gamedata, "checkteamplay", buffer, sizeof(buffer))) { + checkTeamPlay = StrEqual(buffer, "true"); + } + + delete gamedata; + } + } + + mp_teamplay = FindConVar("mp_teamplay"); +} + +/** + * Checks if the passed color index is actually supported + * for the current game. If not, the index will be overwritten + * The color resolving works recursively until a valid color is found. + * + * @param index + * @param subject A client index or CHATCOLOR_NOSUBJECT + * @return new subject client index for team colors + */ +static stock int Color_GetChatColorInfo(int &index, int &subject=CHATCOLOR_NOSUBJECT) +{ + Color_ChatInitialize(); + + if (index == -1) { + index = 0; + } + + while (!chatColorInfo[index][ChatColorInfo_Supported]) { + + int alternative = chatColorInfo[index][ChatColorInfo_Alternative]; + + if (alternative == -1) { + index = 0; + break; + } + + index = alternative; + } + + if (index == -1) { + index = 0; + } + + int newSubject = CHATCOLOR_NOSUBJECT; + ChatColorSubjectType type = chatColorInfo[index][ChatColorInfo_SubjectType]; + + switch (type) { + + case ChatColorSubjectType_none: { + } + case ChatColorSubjectType_player: { + newSubject = chatSubject; + } + case ChatColorSubjectType_undefined: { + newSubject = -1; + } + case ChatColorSubjectType_world: { + newSubject = 0; + } + default: { + + if (!checkTeamPlay || mp_teamplay.BoolValue) { + + if (subject > 0 && subject <= MaxClients) { + + if (GetClientTeam(subject) == view_as(type)) { + newSubject = subject; + } + } + else if (subject == CHATCOLOR_NOSUBJECT) { + int client = Team_GetAnyClient(view_as(type)); + + if (client != -1) { + newSubject = client; + } + } + } + } + } + + if (type > ChatColorSubjectType_none && + ((subject != CHATCOLOR_NOSUBJECT && subject != newSubject) || newSubject == CHATCOLOR_NOSUBJECT || !isSayText2_supported)) + { + index = chatColorInfo[index][ChatColorInfo_Alternative]; + newSubject = Color_GetChatColorInfo(index, subject); + } + + // Only set the subject if there is no subject set already. + if (subject == CHATCOLOR_NOSUBJECT) { + subject = newSubject; + } + + return newSubject; +} diff --git a/include/smlib/concommands.inc b/include/smlib/concommands.inc new file mode 100644 index 0000000..175fab7 --- /dev/null +++ b/include/smlib/concommands.inc @@ -0,0 +1,47 @@ +#if defined _smlib_concommands_included + #endinput +#endif +#define _smlib_concommands_included + +#include +#include + +/** + * Checks if a ConCommand has one or more flags set. + * + * @param command ConCommand name. + * @param flags Flags to check. + * @return True if flags are set, false otherwise. + */ +stock bool ConCommand_HasFlags(const char[] command, const int flags) +{ + return view_as(GetCommandFlags(command) & flags); +} + +/** + * Adds one or more flags to a ConCommand. + * + * @param command ConCommand name. + * @param flags Flags to add. + * @noreturn + */ +stock void ConCommand_AddFlags(const char[] command, const int flags) +{ + int newFlags = GetCommandFlags(command); + newFlags |= flags; + SetCommandFlags(command, newFlags); +} + +/** + * Removes one ore more flags from a ConCommand. + * + * @param command ConCommand name. + * @param flags Flags to remove + * @noreturn + */ +stock void ConCommand_RemoveFlags(const char[] command, const int flags) +{ + int newFlags = GetCommandFlags(command); + newFlags &= ~flags; + SetCommandFlags(command, newFlags); +} diff --git a/include/smlib/convars.inc b/include/smlib/convars.inc new file mode 100644 index 0000000..cc17e01 --- /dev/null +++ b/include/smlib/convars.inc @@ -0,0 +1,72 @@ +#if defined _smlib_convars_included + #endinput +#endif +#define _smlib_convars_included + +#include + +/** + * Checks if a ConVar has one or more flags set. + * + * @param convar ConVar Handle. + * @param flags Flags to check. + * @return True if flags are set, false otherwise. + */ +stock bool Convar_HasFlags(ConVar convar, int flags) +{ + return view_as(convar.Flags & flags); +} + +/** + * Adds one or more flags to a ConVar. + * + * @param convar ConVar Handle. + * @param flags Flags to add. + * @noreturn + */ +stock void Convar_AddFlags(ConVar convar, int flags) +{ + int newFlags = convar.Flags; + newFlags |= flags; + convar.Flags = newFlags; +} + +/** + * Removes one ore more flags from a ConVar. + * + * @param convar ConVar Handle. + * @param flags Flags to remove + * @noreturn + */ +stock void Convar_RemoveFlags(ConVar convar, int flags) +{ + int newFlags = convar.Flags; + newFlags &= ~flags; + convar.Flags = newFlags; +} + +/** + * Checks if a String is a valid ConVar or + * Console Command name. + * + * @param name String Name. + * @return True if the name specified is a valid ConVar or console command name, false otherwise. + */ +stock bool Convar_IsValidName(const char[] name) +{ + if (name[0] == '\0') { + return false; + } + + int n=0; + while (name[n] != '\0') { + + if (!IsValidConVarChar(name[n])) { + return false; + } + + n++; + } + + return true; +} diff --git a/include/smlib/crypt.inc b/include/smlib/crypt.inc new file mode 100644 index 0000000..25471ba --- /dev/null +++ b/include/smlib/crypt.inc @@ -0,0 +1,629 @@ +#if defined _smlib_crypt_included + #endinput +#endif +#define _smlib_crypt_included + +#include + +/********************************************************************************** + * + * Base64 Encoding/Decoding Functions + * All Credits to to SirLamer & ScriptCoderPro + * Taken from http://forums.alliedmods.net/showthread.php?t=101764 + * + ***********************************************************************************/ + +// The Base64 encoding table +static const char base64_sTable[] = + // 0000000000111111111122222222223333333333444444444455555555556666 + // 0123456789012345678901234567890123456789012345678901234567890123 + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +// The Base64 decoding table +static const int base64_decodeTable[] = { +// 0 1 2 3 4 5 6 7 8 9 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 9 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 10 - 19 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20 - 29 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 30 - 39 + 0, 0, 0, 62, 0, 0, 0, 63, 52, 53, // 40 - 49 + 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, // 50 - 59 + 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, // 60 - 69 + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, // 70 - 79 + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 80 - 89 + 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, // 90 - 99 + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, // 100 - 109 + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, // 110 - 119 + 49, 50, 51, 0, 0, 0, 0, 0, 0, 0, // 120 - 129 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 130 - 139 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 140 - 149 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 150 - 159 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 160 - 169 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 170 - 179 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 180 - 189 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 190 - 199 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 200 - 209 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 210 - 219 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 220 - 229 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 230 - 239 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 240 - 249 + 0, 0, 0, 0, 0, 0 // 250 - 256 +}; + +/* + * For some reason the standard demands a string in 24-bit (3 character) intervals. + * This fill character is used to identify unused bytes at the end of the string. + */ +static const int base64_cFillChar = '='; + +// The conversion characters between the standard and URL-compliance Base64 protocols +static const char base64_mime_chars[] = "+/="; +static const char base64_url_chars[] = "-_."; + +/* + * Encodes a string or binary data into Base64 + * + * @param sString The input string or binary data to be encoded. + * @param sResult The storage buffer for the Base64-encoded result. + * @param len The maximum length of the storage buffer, in characters/bytes. + * @param sourcelen (optional): The number of characters or length in bytes to be read from the input source. + * This is not needed for a text string, but is important for binary data since there is no end-of-line character. + * @return The length of the written Base64 string, in bytes. + */ +stock int Crypt_Base64Encode(const char[] sString, char[] sResult, int len, int sourcelen=0) +{ + int nLength; // The string length to be read from the input + int resPos; // The string position in the result buffer + + // If the read length was specified, use it; otherwise, pull the string length from the input. + if (sourcelen > 0) { + nLength = sourcelen; + } + else { + nLength = strlen(sString); + } + + // Loop through and generate the Base64 encoded string + // NOTE: This performs the standard encoding process. Do not manipulate the logic within this loop. + for (int nPos = 0; nPos < nLength; nPos++) { + int cCode; + + cCode = (sString[nPos] >> 2) & 0x3f; + + resPos += FormatEx(sResult[resPos], len - resPos, "%c", base64_sTable[cCode]); + + cCode = (sString[nPos] << 4) & 0x3f; + if (++nPos < nLength) { + cCode |= (sString[nPos] >> 4) & 0x0f; + } + resPos += FormatEx(sResult[resPos], len - resPos, "%c", base64_sTable[cCode]); + + if ( nPos < nLength ) { + cCode = (sString[nPos] << 2) & 0x3f; + if (++nPos < nLength) { + cCode |= (sString[nPos] >> 6) & 0x03; + } + + resPos += FormatEx(sResult[resPos], len - resPos, "%c", base64_sTable[cCode]); + } + else { + nPos++; + resPos += FormatEx(sResult[resPos], len - resPos, "%c", base64_cFillChar); + } + + if (nPos < nLength) { + cCode = sString[nPos] & 0x3f; + resPos += FormatEx(sResult[resPos], len - resPos, "%c", base64_sTable[cCode]); + } + else { + resPos += FormatEx(sResult[resPos], len - resPos, "%c", base64_cFillChar); + } + } + + return resPos; +} + + +/* + * Decodes a Base64 string. + * + * @param sString The input string in compliant Base64 format to be decoded. + * @param sResult The storage buffer for the decoded text strihg or binary data. + * @param len The maximum length of the storage buffer, in characters/bytes. + * @return The length of the decoded data, in bytes. + */ +stock int Crypt_Base64Decode(const char[] sString, char[] sResult, int len) +{ + int nLength = strlen(sString); // The string length to be read from the input + int resPos; // The string position in the result buffer + + // Loop through and generate the Base64 encoded string + // NOTE: This performs the standard encoding process. Do not manipulate the logic within this loop. + for (int nPos = 0; nPos < nLength; nPos++) { + + int c, c1; + + c = base64_decodeTable[sString[nPos++]]; + c1 = base64_decodeTable[sString[nPos]]; + + c = (c << 2) | ((c1 >> 4) & 0x3); + + resPos += FormatEx(sResult[resPos], len - resPos, "%c", c); + + if (++nPos < nLength) { + + c = sString[nPos]; + + if (c == base64_cFillChar) + break; + + c = base64_decodeTable[sString[nPos]]; + c1 = ((c1 << 4) & 0xf0) | ((c >> 2) & 0xf); + + resPos += FormatEx(sResult[resPos], len - resPos, "%c", c1); + } + + if (++nPos < nLength) { + + c1 = sString[nPos]; + + if (c1 == base64_cFillChar) + break; + + c1 = base64_decodeTable[sString[nPos]]; + c = ((c << 6) & 0xc0) | c1; + + resPos += FormatEx(sResult[resPos], len - resPos, "%c", c); + } + } + + return resPos; +} + + +/* + * Converts a standards-compliant Base64 string to the commonly accepted URL-compliant alternative. + * Note: The result will be the same length as the input string as long as the output buffer is large enough. + * + * @param sString The standards-compliant Base64 input string to converted. + * @param sResult The storage buffer for the URL-compliant result. + * @param len The maximum length of the storage buffer in characters/bytes. + * @return Number of cells written. + */ +stock int Crypt_Base64MimeToUrl(const char[] sString, char[] sResult, int len) +{ + int chars_len = sizeof(base64_mime_chars); // Length of the two standards vs. URL character lists + int nLength; // The string length to be read from the input + int temp_char; // Buffer character + + nLength = strlen(sString); + + char[] sTemp = new char[nLength+1]; // Buffer string + + // Loop through string + for (int i = 0; i < nLength; i++) { + temp_char = sString[i]; + + for (int j = 0; j < chars_len; j++) { + + if(temp_char == base64_mime_chars[j]) { + temp_char = base64_url_chars[j]; + break; + } + } + + sTemp[i] = temp_char; + } + + sTemp[nLength] = '\0'; + + return strcopy(sResult, len, sTemp); +} + +/* + * Base64UrlToMime(char[] sResult, int len, const char[] sString, int sourcelen) + * Converts a URL-compliant Base64 string to the standards-compliant version. + * Note: The result will be the same length as the input string as long as the output buffer is large enough. + * + * @param sString The URL-compliant Base64 input string to converted. + * @param sResult The storage buffer for the standards-compliant result. + * @param len The maximum length of the storage buffer in characters/bytes. + * @return Number of cells written. + */ +stock int Crypt_Base64UrlToMime(const char[] sString, char[] sResult, int len) +{ + int chars_len = sizeof(base64_mime_chars); // Length of the two standards vs. URL character lists + int nLength; // The string length to be read from the input + int temp_char; // Buffer character + + nLength = strlen(sString); + + char[] sTemp = new char[nLength+1]; // Buffer string + + // Loop through string + for (int i = 0; i < nLength; i++) { + temp_char = sString[i]; + for (int j = 0; j < chars_len; j++) { + if (temp_char == base64_url_chars[j]) { + temp_char = base64_mime_chars[j]; + break; + } + } + + sTemp[i] = temp_char; + } + + sTemp[nLength] = '\0'; + + return strcopy(sResult, len, sTemp); +} + +/********************************************************************************** + * + * MD5 Encoding Functions + * All Credits go to sslice + * RSA Data Security, Inc. MD5 Message Digest Algorithm + * Taken from http://forums.alliedmods.net/showthread.php?t=67683 + * + ***********************************************************************************/ + +/* + * Calculate the md5 hash of a string. + * + * @param str Input String + * @param output Output String Buffer + * @param maxlen Size of the Output String Buffer + * @noreturn + */ +stock void Crypt_MD5(const char[] str, char[] output, int maxlen) +{ + int x[2]; + int buf[4]; + int input[64]; + int i, ii; + + int len = strlen(str); + + // MD5Init + x[0] = x[1] = 0; + buf[0] = 0x67452301; + buf[1] = 0xefcdab89; + buf[2] = 0x98badcfe; + buf[3] = 0x10325476; + + // MD5Update + int update[16]; + + update[14] = x[0]; + update[15] = x[1]; + + int mdi = (x[0] >>> 3) & 0x3F; + + if ((x[0] + (len << 3)) < x[0]) { + x[1] += 1; + } + + x[0] += len << 3; + x[1] += len >>> 29; + + int c = 0; + while (len--) { + input[mdi] = str[c]; + mdi += 1; + c += 1; + + if (mdi == 0x40) { + + for (i = 0, ii = 0; i < 16; ++i, ii += 4) + { + update[i] = (input[ii + 3] << 24) | (input[ii + 2] << 16) | (input[ii + 1] << 8) | input[ii]; + } + + // Transform + MD5Transform(buf, update); + + mdi = 0; + } + } + + // MD5Final + int padding[64] = { + 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 + }; + + int inx[16]; + inx[14] = x[0]; + inx[15] = x[1]; + + mdi = (x[0] >>> 3) & 0x3F; + + len = (mdi < 56) ? (56 - mdi) : (120 - mdi); + update[14] = x[0]; + update[15] = x[1]; + + mdi = (x[0] >>> 3) & 0x3F; + + if ((x[0] + (len << 3)) < x[0]) { + x[1] += 1; + } + + x[0] += len << 3; + x[1] += len >>> 29; + + c = 0; + while (len--) { + input[mdi] = padding[c]; + mdi += 1; + c += 1; + + if (mdi == 0x40) { + + for (i = 0, ii = 0; i < 16; ++i, ii += 4) { + update[i] = (input[ii + 3] << 24) | (input[ii + 2] << 16) | (input[ii + 1] << 8) | input[ii]; + } + + // Transform + MD5Transform(buf, update); + + mdi = 0; + } + } + + for (i = 0, ii = 0; i < 14; ++i, ii += 4) { + inx[i] = (input[ii + 3] << 24) | (input[ii + 2] << 16) | (input[ii + 1] << 8) | input[ii]; + } + + MD5Transform(buf, inx); + + int digest[16]; + for (i = 0, ii = 0; i < 4; ++i, ii += 4) { + digest[ii] = (buf[i]) & 0xFF; + digest[ii + 1] = (buf[i] >>> 8) & 0xFF; + digest[ii + 2] = (buf[i] >>> 16) & 0xFF; + digest[ii + 3] = (buf[i] >>> 24) & 0xFF; + } + + FormatEx(output, maxlen, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", + digest[0], digest[1], digest[2], digest[3], digest[4], digest[5], digest[6], digest[7], + digest[8], digest[9], digest[10], digest[11], digest[12], digest[13], digest[14], digest[15]); +} + +static stock void MD5Transform_FF(int &a, int &b, int &c, int &d, int x, int s, int ac) +{ + a += (((b) & (c)) | ((~b) & (d))) + x + ac; + a = (((a) << (s)) | ((a) >>> (32-(s)))); + a += b; +} + +static stock void MD5Transform_GG(int &a, int &b, int &c, int &d, int x, int s, int ac) +{ + a += (((b) & (d)) | ((c) & (~d))) + x + ac; + a = (((a) << (s)) | ((a) >>> (32-(s)))); + a += b; +} + +static stock void MD5Transform_HH(int &a, int &b, int &c, int &d, int x, int s, int ac) +{ + a += ((b) ^ (c) ^ (d)) + x + ac; + a = (((a) << (s)) | ((a) >>> (32-(s)))); + a += b; +} + +static stock void MD5Transform_II(int &a, int &b, int &c, int &d, int x, int s, int ac) +{ + a += ((c) ^ ((b) | (~d))) + x + ac; + a = (((a) << (s)) | ((a) >>> (32-(s)))); + a += b; +} + +static stock void MD5Transform(int[] buf, int[] input){ + int a = buf[0]; + int b = buf[1]; + int c = buf[2]; + int d = buf[3]; + + MD5Transform_FF(a, b, c, d, input[0], 7, 0xd76aa478); + MD5Transform_FF(d, a, b, c, input[1], 12, 0xe8c7b756); + MD5Transform_FF(c, d, a, b, input[2], 17, 0x242070db); + MD5Transform_FF(b, c, d, a, input[3], 22, 0xc1bdceee); + MD5Transform_FF(a, b, c, d, input[4], 7, 0xf57c0faf); + MD5Transform_FF(d, a, b, c, input[5], 12, 0x4787c62a); + MD5Transform_FF(c, d, a, b, input[6], 17, 0xa8304613); + MD5Transform_FF(b, c, d, a, input[7], 22, 0xfd469501); + MD5Transform_FF(a, b, c, d, input[8], 7, 0x698098d8); + MD5Transform_FF(d, a, b, c, input[9], 12, 0x8b44f7af); + MD5Transform_FF(c, d, a, b, input[10], 17, 0xffff5bb1); + MD5Transform_FF(b, c, d, a, input[11], 22, 0x895cd7be); + MD5Transform_FF(a, b, c, d, input[12], 7, 0x6b901122); + MD5Transform_FF(d, a, b, c, input[13], 12, 0xfd987193); + MD5Transform_FF(c, d, a, b, input[14], 17, 0xa679438e); + MD5Transform_FF(b, c, d, a, input[15], 22, 0x49b40821); + + MD5Transform_GG(a, b, c, d, input[1], 5, 0xf61e2562); + MD5Transform_GG(d, a, b, c, input[6], 9, 0xc040b340); + MD5Transform_GG(c, d, a, b, input[11], 14, 0x265e5a51); + MD5Transform_GG(b, c, d, a, input[0], 20, 0xe9b6c7aa); + MD5Transform_GG(a, b, c, d, input[5], 5, 0xd62f105d); + MD5Transform_GG(d, a, b, c, input[10], 9, 0x02441453); + MD5Transform_GG(c, d, a, b, input[15], 14, 0xd8a1e681); + MD5Transform_GG(b, c, d, a, input[4], 20, 0xe7d3fbc8); + MD5Transform_GG(a, b, c, d, input[9], 5, 0x21e1cde6); + MD5Transform_GG(d, a, b, c, input[14], 9, 0xc33707d6); + MD5Transform_GG(c, d, a, b, input[3], 14, 0xf4d50d87); + MD5Transform_GG(b, c, d, a, input[8], 20, 0x455a14ed); + MD5Transform_GG(a, b, c, d, input[13], 5, 0xa9e3e905); + MD5Transform_GG(d, a, b, c, input[2], 9, 0xfcefa3f8); + MD5Transform_GG(c, d, a, b, input[7], 14, 0x676f02d9); + MD5Transform_GG(b, c, d, a, input[12], 20, 0x8d2a4c8a); + + MD5Transform_HH(a, b, c, d, input[5], 4, 0xfffa3942); + MD5Transform_HH(d, a, b, c, input[8], 11, 0x8771f681); + MD5Transform_HH(c, d, a, b, input[11], 16, 0x6d9d6122); + MD5Transform_HH(b, c, d, a, input[14], 23, 0xfde5380c); + MD5Transform_HH(a, b, c, d, input[1], 4, 0xa4beea44); + MD5Transform_HH(d, a, b, c, input[4], 11, 0x4bdecfa9); + MD5Transform_HH(c, d, a, b, input[7], 16, 0xf6bb4b60); + MD5Transform_HH(b, c, d, a, input[10], 23, 0xbebfbc70); + MD5Transform_HH(a, b, c, d, input[13], 4, 0x289b7ec6); + MD5Transform_HH(d, a, b, c, input[0], 11, 0xeaa127fa); + MD5Transform_HH(c, d, a, b, input[3], 16, 0xd4ef3085); + MD5Transform_HH(b, c, d, a, input[6], 23, 0x04881d05); + MD5Transform_HH(a, b, c, d, input[9], 4, 0xd9d4d039); + MD5Transform_HH(d, a, b, c, input[12], 11, 0xe6db99e5); + MD5Transform_HH(c, d, a, b, input[15], 16, 0x1fa27cf8); + MD5Transform_HH(b, c, d, a, input[2], 23, 0xc4ac5665); + + MD5Transform_II(a, b, c, d, input[0], 6, 0xf4292244); + MD5Transform_II(d, a, b, c, input[7], 10, 0x432aff97); + MD5Transform_II(c, d, a, b, input[14], 15, 0xab9423a7); + MD5Transform_II(b, c, d, a, input[5], 21, 0xfc93a039); + MD5Transform_II(a, b, c, d, input[12], 6, 0x655b59c3); + MD5Transform_II(d, a, b, c, input[3], 10, 0x8f0ccc92); + MD5Transform_II(c, d, a, b, input[10], 15, 0xffeff47d); + MD5Transform_II(b, c, d, a, input[1], 21, 0x85845dd1); + MD5Transform_II(a, b, c, d, input[8], 6, 0x6fa87e4f); + MD5Transform_II(d, a, b, c, input[15], 10, 0xfe2ce6e0); + MD5Transform_II(c, d, a, b, input[6], 15, 0xa3014314); + MD5Transform_II(b, c, d, a, input[13], 21, 0x4e0811a1); + MD5Transform_II(a, b, c, d, input[4], 6, 0xf7537e82); + MD5Transform_II(d, a, b, c, input[11], 10, 0xbd3af235); + MD5Transform_II(c, d, a, b, input[2], 15, 0x2ad7d2bb); + MD5Transform_II(b, c, d, a, input[9], 21, 0xeb86d391); + + buf[0] += a; + buf[1] += b; + buf[2] += c; + buf[3] += d; +} + +/********************************************************************************** + * + * RC4 Encoding Functions + * All Credits go to SirLamer and Raydan + * Taken from http://forums.alliedmods.net/showthread.php?t=101834 + * + ***********************************************************************************/ + +/* + * Encrypts a text string using RC4. + * Note: This function is NOT binary safe. + * Use EncodeRC4Binary to encode binary data. + * + * @param input The source data to be encrypted. + * @param pwd The password/key used to encode and decode the data. + * @param output The encoded result. + * @param maxlen The maximum length of the output buffer. + * + * @noreturn + */ +stock void Crypt_RC4Encode(const char[] input, const char[] pwd, char[] output, int maxlen) +{ + int pwd_len,str_len,i,j,a,k; + int key[256]; + int box[256]; + int tmp; + + pwd_len = strlen(pwd); + str_len = strlen(input); + + if (pwd_len > 0 && str_len > 0) { + + for (i=0; i < 256; i++) { + key[i] = pwd[i%pwd_len]; + box[i]=i; + } + + i=0; j=0; + + for (; i < 256; i++) { + j = (j + box[i] + key[i]) % 256; + tmp = box[i]; + box[i] = box[j]; + box[j] = tmp; + } + + i=0; j=0; a=0; + + for (; i < str_len; i++) { + a = (a + 1) % 256; + j = (j + box[a]) % 256; + tmp = box[a]; + box[a] = box[j]; + box[j] = tmp; + k = box[((box[a] + box[j]) % 256)]; + FormatEx(output[2*i], maxlen-2*i, "%02x", input[i] ^ k); + } + } +} + +/* + * Encrypts binary data using RC4. + * + * @param input The source data to be encrypted. + * @param str_len The length of the source data. + * @param pwd The password/key used to encode and decode the data. + * @param output The encoded result. + * @param maxlen The maximum length of the output buffer. + * @return Number of written bits, -1 if unsuccessful + */ +stock int Crypt_RC4EncodeBinary(const char[] input, int str_len, const char[] pwd, char[] output, int maxlen) +{ + int pwd_len,i,j,a,k; + int key[256]; + int box[256]; + int tmp; + + pwd_len = strlen(pwd); + + if (pwd_len > 0 && str_len > 0) { + + for(i=0;i<256;i++) { + key[i] = pwd[i%pwd_len]; + box[i]=i; + } + + i=0; j=0; + + for (; i < 256; i++) { + j = (j + box[i] + key[i]) % 256; + tmp = box[i]; + box[i] = box[j]; + box[j] = tmp; + } + + i=0; j=0; a=0; + + if (str_len+1 > maxlen) { + str_len = maxlen - 1; + } + + for(; i < str_len; i++) { + a = (a + 1) % 256; + j = (j + box[a]) % 256; + tmp = box[a]; + box[a] = box[j]; + box[j] = tmp; + k = box[((box[a] + box[j]) % 256)]; + FormatEx(output[i], maxlen-i, "%c", input[i] ^ k); + } + + /* + * i = number of written bits (remember increment occurs at end of for loop, and THEN it fails the loop condition) + * Since we're working with binary data, the calling function should not depend on the escape + * character, but putting it here prevents crashes in case someone tries to read the data like a string + */ + output[i] = '\0'; + + return i; + } + else { + return -1; + } +} diff --git a/include/smlib/debug.inc b/include/smlib/debug.inc new file mode 100644 index 0000000..1bb91e5 --- /dev/null +++ b/include/smlib/debug.inc @@ -0,0 +1,30 @@ +#if defined _smlib_debug_included + #endinput +#endif +#define _smlib_debug_included + +#include + +/** + * Prints the values of a static Float-Array to the server console. + * + * @param array Static Float-Array. + * @param size Size of the Array. + * @noreturn + */ +stock void Debug_FloatArray(const float[] array, int size=3) +{ + char output[64] = ""; + + for (int i=0; i < size; ++i) { + + if (i > 0 && i < size) { + StrCat(output, sizeof(output), ", "); + + } + + Format(output, sizeof(output), "%s%f", output, array[i]); + } + + PrintToServer("[DEBUG] Vector[%d] = { %s }", size, output); +} diff --git a/include/smlib/desktop.ini b/include/smlib/desktop.ini new file mode 100644 index 0000000..dce88a3 --- /dev/null +++ b/include/smlib/desktop.ini @@ -0,0 +1,5 @@ +[.ShellClassInfo] +InfoTip=This folder is shared online. +IconFile=C:\Program Files\Google\Drive\googledrivesync.exe +IconIndex=16 + \ No newline at end of file diff --git a/include/smlib/dynarrays.inc b/include/smlib/dynarrays.inc new file mode 100644 index 0000000..5ab446a --- /dev/null +++ b/include/smlib/dynarrays.inc @@ -0,0 +1,24 @@ +#if defined _smlib_dynarray_included + #endinput +#endif +#define _smlib_dynarray_included + +#include + +/** + * Retrieves a cell value from an array. + * This is a wrapper around the Sourcemod Function GetArrayCell, + * but it casts the result as bool + * + * @param array ArrayList. + * @param index Index in the array. + * @param block Optionally specify which block to read from + * (useful if the blocksize > 0). + * @param asChar Optionally read as a byte instead of a cell. + * @return Value read. + * @error Invalid array, invalid index, or invalid block. + */ +stock bool DynArray_GetBool(ArrayList array, int index, int block=0, bool asChar=false) +{ + return view_as(array.Get(index, block, asChar)); +} diff --git a/include/smlib/edicts.inc b/include/smlib/edicts.inc new file mode 100644 index 0000000..c63babd --- /dev/null +++ b/include/smlib/edicts.inc @@ -0,0 +1,127 @@ +#if defined _smlib_edicts_included + #endinput +#endif +#define _smlib_edicts_included + +#include +#include + +/* + * Finds an edict by it's name + * It only finds the first occurence. + * + * @param name Name of the entity you want so search. + * @return Edict Index or INVALID_ENT_REFERENCE if no entity was found. + */ +stock int Edict_FindByName(const char[] name) +{ + int maxEntities = GetMaxEntities(); + for (int edict=0; edict < maxEntities; edict++) { + + if (!IsValidEdict(edict)) { + continue; + } + + if (Entity_NameMatches(edict, name)) { + return edict; + } + } + + return INVALID_ENT_REFERENCE; +} + +/* + * Finds an edict by its HammerID. + * The newer version of Valve's Hammer editor + * sets a unique ID for each entity in a map. + * It only finds the first occurence. + * + * @param hammerId Hammer editor ID + * @return Edict Index or INVALID_ENT_REFERENCE if no entity was found. + */ +stock int Edict_FindByHammerId(int hammerId) +{ + int maxEntities = GetMaxEntities(); + for (int edict=0; edict < maxEntities; edict++) { + + if (!IsValidEdict(edict)) { + continue; + } + + if (Entity_GetHammerId(edict) == hammerId) { + return edict; + } + } + + return INVALID_ENT_REFERENCE; +} + +/** + * Searches for the closest edict in relation to the given origin + * + * @param vecOrigin_center 3 dimensional origin array + * @param clientsOnly True if you only want to search for clients + * @param ignoreEntity Ignore this entity + * @return Edict Index or INVALID_ENT_REFERENCE if no entity was found. + */ +stock int Edict_GetClosest(float vecOrigin_center[3], bool clientsOnly=false, int ignoreEntity=-1) +{ + float vecOrigin_edict[3]; + float smallestDistance = 0.0; + int closestEdict = INVALID_ENT_REFERENCE; + + int maxEntities; + + if (clientsOnly) { + maxEntities = MaxClients; + } + else { + maxEntities = GetMaxEntities(); + } + + for (int edict=1; edict <= maxEntities; edict++) { + + if (!IsValidEdict(edict)) { + continue; + } + + if (ignoreEntity >= 0 && edict == ignoreEntity) { + continue; + } + + if (GetEntSendPropOffs(edict, "m_vecOrigin") == -1) { + continue; + } + + Entity_GetAbsOrigin(edict, vecOrigin_edict); + + float edict_distance = GetVectorDistance(vecOrigin_center, vecOrigin_edict, true); + + if (edict_distance < smallestDistance || smallestDistance == 0.0) { + smallestDistance = edict_distance; + closestEdict = edict; + } + } + + return closestEdict; +} + +/** + * Searches for the closest edict in relation to the given edict. + * + * @param edict Edict index + * @param clientsOnly True if you only want to search for clients + * @return The closest edict or INVALID_ENT_REFERENCE + */ +stock int Edict_GetClosestToEdict(int edict, bool clientsOnly=false) +{ + float vecOrigin[3]; + + if (GetEntSendPropOffs(edict, "m_vecOrigin") == -1) { + return INVALID_ENT_REFERENCE; + } + + Entity_GetAbsOrigin(edict, vecOrigin); + + return Edict_GetClosest(vecOrigin, clientsOnly, edict); +} diff --git a/include/smlib/effects.inc b/include/smlib/effects.inc new file mode 100644 index 0000000..0844b11 --- /dev/null +++ b/include/smlib/effects.inc @@ -0,0 +1,734 @@ +#if defined _smlib_effects_included + #endinput +#endif +#define _smlib_effects_included + +#include +#include +#include +#include +#include +#include +#include +#include + + + +// Entity Dissolve types +enum DissolveType +{ + DISSOLVE_NORMAL = 0, + DISSOLVE_ELECTRICAL, + DISSOLVE_ELECTRICAL_LIGHT, + DISSOLVE_CORE +}; + +/** + * Dissolves a player + * + * @param client Client Index. + * @param dissolveType Dissolve Type, use the DissolveType enum. + * @param magnitude How strongly to push away from the center. + * @return True on success, otherwise false. + */ +stock bool Effect_DissolveEntity(int entity, DissolveType dissolveType=DISSOLVE_NORMAL, int magnitude=1) +{ + int env_entity_dissolver = CreateEntityByName("env_entity_dissolver"); + + if (env_entity_dissolver == -1) { + return false; + } + + Entity_PointAtTarget(env_entity_dissolver, entity); + SetEntProp(env_entity_dissolver, Prop_Send, "m_nDissolveType", view_as(dissolveType)); + SetEntProp(env_entity_dissolver, Prop_Send, "m_nMagnitude", magnitude); + AcceptEntityInput(env_entity_dissolver, "Dissolve"); + Entity_Kill(env_entity_dissolver); + + return true; +} + +/** + * Dissolves a player's Ragdoll + * + * @param client Client Index. + * @param dissolveType Dissolve Type, use the DissolveType enum. + * @return True on success, otherwise false. + */ +stock bool Effect_DissolvePlayerRagDoll(int client, DissolveType dissolveType=DISSOLVE_NORMAL) +{ + int m_hRagdoll = GetEntPropEnt(client, Prop_Send, "m_hRagdoll"); + + if (m_hRagdoll == -1) { + return false; + } + + return Effect_DissolveEntity(m_hRagdoll, dissolveType); +} + +typedef EffectCallback = function void (int entity, any data); + +/** + * Fades an entity in our out. + * You can specifiy a callback function which will get called + * when the fade is finished. + * Important: The callback will be called if it is passed, + * no matter if the entity is still valid or not. That means you + * have to check if the entity is valid yourself. + * + * @param entity Entity Index. + * @param fadeOut Optional: Fade the entity out (true) or in (false). + * @param kill Optional: If to kill the entity when the fade is finished. + * @param fast Optional: Fade the entity fast (~0.7 secs) or slow (~3 secs) + * @param callback Optional: You can specify a callback Function that will get called when the fade is finished. + * @param data Optional: You can pass any data to the callback. + * @noreturn + */ +stock void Effect_Fade(int entity, bool fadeOut=true, bool kill=false, bool fast=true, EffectCallback callback=INVALID_FUNCTION, any data=0) +{ + float timerTime = 0.0; + + if (fast) { + timerTime = 0.6; + + if (fadeOut) { + SetEntityRenderFx(entity, RENDERFX_FADE_FAST); + } + else { + SetEntityRenderFx(entity, RENDERFX_SOLID_FAST); + } + } + else { + timerTime = 3.0; + + if (fadeOut) { + SetEntityRenderFx(entity, RENDERFX_FADE_SLOW); + } + else { + SetEntityRenderFx(entity, RENDERFX_SOLID_SLOW); + } + } + + ChangeEdictState(entity, GetEntSendPropOffs(entity, "m_nRenderFX", true)); + + if (kill || callback != INVALID_FUNCTION) { + DataPack dataPack; + CreateDataTimer(timerTime, _smlib_Timer_Effect_Fade, dataPack, TIMER_FLAG_NO_MAPCHANGE | TIMER_DATA_HNDL_CLOSE); + + dataPack.WriteCell(EntIndexToEntRef(entity)); + dataPack.WriteCell(kill); + dataPack.WriteFunction(callback); + dataPack.WriteCell(data); + dataPack.Reset(); + } +} + +/** + * Fades the entity in. + * A wrapper function around Effect_Fade(). + * + * @param entity Entity Index. + * @param fast Optional: Fade the entity fast (~0.7 secs) or slow (~3 secs) + * @param callback Optional: You can specify a callback Function that will get called when the fade is finished. + * @param data Optional: You can pass any data to the callback. + * @noreturn + */ +stock void Effect_FadeIn(int entity, bool fast=true, EffectCallback callback=INVALID_FUNCTION, any data=0) +{ + Effect_Fade(entity, false, false, fast, callback, data); +} + +/** + * Fades the entity out. + * A wrapper function around Effect_Fade(). + * + * @param entity Entity Index. + * @param fadeOut Optional: Fade the entity out (true) or in (false). + * @param kill Optional: If to kill the entity when the fade is finished. + * @param fast Optional: Fade the entity fast (~0.7 secs) or slow (~3 secs) + * @param callback Optional: You can specify a callback Function that will get called when the fade is finished. + * @param data Optional: You can pass any data to the callback. + * @noreturn + */ +stock void Effect_FadeOut(int entity, bool kill=false, bool fast=true, EffectCallback callback=INVALID_FUNCTION, any data=0) +{ + Effect_Fade(entity, true, kill, fast, callback, data); +} + +public Action _smlib_Timer_Effect_Fade(Handle timer, DataPack dataPack) +{ + dataPack.Reset(); + int entity = dataPack.ReadCell(); + int kill = dataPack.ReadCell(); + Function callback = view_as(dataPack.ReadFunction()); + any data = view_as(dataPack.ReadCell()); + + if (callback != INVALID_FUNCTION) { + Call_StartFunction(null, callback); + Call_PushCell(entity); + Call_PushCell(data); + Call_Finish(); + } + + if (kill && IsValidEntity(entity)) { + Entity_Kill(entity); + } + + return Plugin_Stop; +} + +/** + * Sends a boxed beam effect to one player. + * + * Ported from eventscripts vecmath library. + * + * @param client The client to show the box to. + * @param bottomCorner One bottom corner of the box. + * @param upperCorner One upper corner of the box. + * @param modelIndex Precached model index. + * @param haloIndex Precached model index. + * @param startFrame Initital frame to render. + * @param frameRate Beam frame rate. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param fadeLength Beam fade time duration. + * @param amplitude Beam amplitude. + * @param color Color array (r, g, b, a). + * @param speed Speed of the beam. + * @noreturn + */ +stock void Effect_DrawBeamBoxToClient( + int client, + const float bottomCorner[3], + const float upperCorner[3], + int modelIndex, + int haloIndex, + int startFrame=0, + int frameRate=30, + float life=5.0, + float width=5.0, + float endWidth=5.0, + int fadeLength=2, + float amplitude=1.0, + const int color[4]={ 255, 0, 0, 255 }, + int speed=0 +) { + int clients[1]; + clients[0] = client; + Effect_DrawBeamBox(clients, 1, bottomCorner, upperCorner, modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); +} + +/** + * Sends a boxed beam effect to all players. + * + * Ported from eventscripts vecmath library. + * + * @param bottomCorner One bottom corner of the box. + * @param upperCorner One upper corner of the box. + * @param modelIndex Precached model index. + * @param haloIndex Precached model index. + * @param startFrame Initital frame to render. + * @param frameRate Beam frame rate. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param fadeLength Beam fade time duration. + * @param amplitude Beam amplitude. + * @param color Color array (r, g, b, a). + * @param speed Speed of the beam. + * @noreturn + */ +stock void Effect_DrawBeamBoxToAll( + const float bottomCorner[3], + const float upperCorner[3], + int modelIndex, + int haloIndex, + int startFrame=0, + int frameRate=30, + float life=5.0, + float width=5.0, + float endWidth=5.0, + int fadeLength=2, + float amplitude=1.0, + const int color[4]={ 255, 0, 0, 255 }, + int speed=0 +) +{ + int[] clients = new int[MaxClients]; + int numClients = Client_Get(clients, CLIENTFILTER_INGAME); + + Effect_DrawBeamBox(clients, numClients, bottomCorner, upperCorner, modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); +} + +/** + * Sends a boxed beam effect to a list of players. + * + * Ported from eventscripts vecmath library. + * + * @param clients An array of clients to show the box to. + * @param numClients Number of players in the array. + * @param bottomCorner One bottom corner of the box. + * @param upperCorner One upper corner of the box. + * @param modelIndex Precached model index. + * @param haloIndex Precached model index. + * @param startFrame Initital frame to render. + * @param frameRate Beam frame rate. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param fadeLength Beam fade time duration. + * @param amplitude Beam amplitude. + * @param color Color array (r, g, b, a). + * @param speed Speed of the beam. + * @noreturn + */ +stock void Effect_DrawBeamBox( + int[] clients, + int numClients, + const float bottomCorner[3], + const float upperCorner[3], + int modelIndex, + int haloIndex, + int startFrame=0, + int frameRate=30, + float life=5.0, + float width=5.0, + float endWidth=5.0, + int fadeLength=2, + float amplitude=1.0, + const int color[4]={ 255, 0, 0, 255 }, + int speed=0 +) { + // Create the additional corners of the box + float corners[8][3]; + + for (int i=0; i < 4; i++) { + Array_Copy(bottomCorner, corners[i], 3); + Array_Copy(upperCorner, corners[i+4], 3); + } + + corners[1][0] = upperCorner[0]; + corners[2][0] = upperCorner[0]; + corners[2][1] = upperCorner[1]; + corners[3][1] = upperCorner[1]; + corners[4][0] = bottomCorner[0]; + corners[4][1] = bottomCorner[1]; + corners[5][1] = bottomCorner[1]; + corners[7][0] = bottomCorner[0]; + + // Draw all the edges + + // Horizontal Lines + // Bottom + for (int i=0; i < 4; i++) { + int j = ( i == 3 ? 0 : i+1 ); + TE_SetupBeamPoints(corners[i], corners[j], modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); + TE_Send(clients, numClients); + } + + // Top + for (int i=4; i < 8; i++) { + int j = ( i == 7 ? 4 : i+1 ); + TE_SetupBeamPoints(corners[i], corners[j], modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); + TE_Send(clients, numClients); + } + + // All Vertical Lines + for (int i=0; i < 4; i++) { + TE_SetupBeamPoints(corners[i], corners[i+4], modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); + TE_Send(clients, numClients); + } +} + +/** + * Sends a boxed beam effect to one player. + * + * Ported from eventscripts vecmath library. + * + * @param client The client to show the box to. + * @param origin Origin/center of the box. + * @param mins Min size Vector + * @param maxs Max size Vector + * @param angles Angles used to rotate the box. + * @param modelIndex Precached model index. + * @param haloIndex Precached model index. + * @param startFrame Initital frame to render. + * @param frameRate Beam frame rate. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param fadeLength Beam fade time duration. + * @param amplitude Beam amplitude. + * @param color Color array (r, g, b, a). + * @param speed Speed of the beam. + * @noreturn + */ +stock void Effect_DrawBeamBoxRotatableToClient( + int client, + const float origin[3], + const float mins[3], + const float maxs[3], + const float angles[3], + int modelIndex, + int haloIndex, + int startFrame=0, + int frameRate=30, + float life=5.0, + float width=5.0, + float endWidth=5.0, + int fadeLength=2, + float amplitude=1.0, + const int color[4]={ 255, 0, 0, 255 }, + int speed=0 +) { + int clients[1]; + clients[0] = client; + Effect_DrawBeamBoxRotatable(clients, 1, origin, mins, maxs, angles, modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); +} + + + +/** + * Sends a boxed beam effect to all players. + * + * Ported from eventscripts vecmath library. + * + * @param origin Origin/center of the box. + * @param mins Min size Vector + * @param maxs Max size Vector + * @param angles Angles used to rotate the box. + * @param modelIndex Precached model index. + * @param haloIndex Precached model index. + * @param startFrame Initital frame to render. + * @param frameRate Beam frame rate. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param fadeLength Beam fade time duration. + * @param amplitude Beam amplitude. + * @param color Color array (r, g, b, a). + * @param speed Speed of the beam. + * @noreturn + */ +stock void Effect_DrawBeamBoxRotatableToAll( + const float origin[3], + const float mins[3], + const float maxs[3], + const float angles[3], + int modelIndex, + int haloIndex, + int startFrame=0, + int frameRate=30, + float life=5.0, + float width=5.0, + float endWidth=5.0, + int fadeLength=2, + float amplitude=1.0, + const int color[4]={ 255, 0, 0, 255 }, + int speed=0 +) +{ + int[] clients = new int[MaxClients]; + int numClients = Client_Get(clients, CLIENTFILTER_INGAME); + + Effect_DrawBeamBoxRotatable(clients, numClients, origin, mins, maxs, angles, modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); +} + +/** + * Sends a boxed beam effect to a list of players. + * + * Ported from eventscripts vecmath library. + * + * @param clients An array of clients to show the box to. + * @param numClients Number of players in the array. + * @param origin Origin/center of the box. + * @param mins Min size Vector + * @param maxs Max size Vector + * @param angles Angles used to rotate the box. + * @param modelIndex Precached model index. + * @param haloIndex Precached model index. + * @param startFrame Initital frame to render. + * @param frameRate Beam frame rate. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param fadeLength Beam fade time duration. + * @param amplitude Beam amplitude. + * @param color Color array (r, g, b, a). + * @param speed Speed of the beam. + * @noreturn + */ +stock void Effect_DrawBeamBoxRotatable( + int[] clients, + int numClients, + const float origin[3], + const float mins[3], + const float maxs[3], + const float angles[3], + int modelIndex, + int haloIndex, + int startFrame=0, + int frameRate=30, + float life=5.0, + float width=5.0, + float endWidth=5.0, + int fadeLength=2, + float amplitude=1.0, + const int color[4]={ 255, 0, 0, 255 }, + int speed=0 +) { + // Create the additional corners of the box + float corners[8][3]; + Array_Copy(mins, corners[0], 3); + Math_MakeVector(maxs[0], mins[1], mins[2], corners[1]); + Math_MakeVector(maxs[0], maxs[1], mins[2], corners[2]); + Math_MakeVector(mins[0], maxs[1], mins[2], corners[3]); + Math_MakeVector(mins[0], mins[1], maxs[2], corners[4]); + Math_MakeVector(maxs[0], mins[1], maxs[2], corners[5]); + Array_Copy(maxs, corners[6], 3); + Math_MakeVector(mins[0], maxs[1], maxs[2], corners[7]); + + // Rotate all edges + for (int i=0; i < sizeof(corners); i++) { + Math_RotateVector(corners[i], angles, corners[i]); + } + + // Apply world offset (after rotation) + for (int i=0; i < sizeof(corners); i++) { + AddVectors(origin, corners[i], corners[i]); + } + + // Draw all the edges + // Horizontal Lines + // Bottom + for (int i=0; i < 4; i++) { + int j = ( i == 3 ? 0 : i+1 ); + TE_SetupBeamPoints(corners[i], corners[j], modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); + TE_Send(clients, numClients); + } + + // Top + for (int i=4; i < 8; i++) { + int j = ( i == 7 ? 4 : i+1 ); + TE_SetupBeamPoints(corners[i], corners[j], modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); + TE_Send(clients, numClients); + } + + // All Vertical Lines + for (int i=0; i < 4; i++) { + TE_SetupBeamPoints(corners[i], corners[i+4], modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, color, speed); + TE_Send(clients, numClients); + } +} + +/** + * Displays the given axis of rotation as beam effect to one player. + * + * @param client The client to show the box to. + * @param origin Origin/center of the box. + * @param angles Angles used to rotate the box. + * @param length The length in each direction. + * @param modelIndex Precached model index. + * @param haloIndex Precached model index. + * @param startFrame Initital frame to render. + * @param frameRate Beam frame rate. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param fadeLength Beam fade time duration. + * @param amplitude Beam amplitude. + * @param color Color array (r, g, b, a). + * @param speed Speed of the beam. + * @noreturn + */ +stock void Effect_DrawAxisOfRotationToClient( + int client, + const float origin[3], + const float angles[3], + const float length[3], + int modelIndex, + int haloIndex, + int startFrame=0, + int frameRate=30, + float life=5.0, + float width=5.0, + float endWidth=5.0, + int fadeLength=2, + float amplitude=1.0, + int speed=0 +) { + int clients[1]; + clients[0] = client; + Effect_DrawAxisOfRotation(clients, 1, origin, angles, length, modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, speed); +} + +/** + * Displays the given axis of rotation as beam effect to all players. + * + * @param origin Origin/center of the box. + * @param angles Angles used to rotate the box. + * @param length The length in each direction. + * @param modelIndex Precached model index. + * @param haloIndex Precached model index. + * @param startFrame Initital frame to render. + * @param frameRate Beam frame rate. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param fadeLength Beam fade time duration. + * @param amplitude Beam amplitude. + * @param color Color array (r, g, b, a). + * @param speed Speed of the beam. + * @noreturn + */ +stock void Effect_DrawAxisOfRotationToAll( + const float origin[3], + const float angles[3], + const float length[3], + int modelIndex, + int haloIndex, + int startFrame=0, + int frameRate=30, + float life=5.0, + float width=5.0, + float endWidth=5.0, + int fadeLength=2, + float amplitude=1.0, + int speed=0 +) +{ + int[] clients = new int[MaxClients]; + int numClients = Client_Get(clients, CLIENTFILTER_INGAME); + + Effect_DrawAxisOfRotation(clients, numClients, origin, angles, length, modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, speed); +} + +/** + * Displays the given axis of rotation as beam effect to a list of players. + * + * @param clients An array of clients to show the box to. + * @param numClients Number of players in the array. + * @param origin Origin/center of the box. + * @param angles Angles used to rotate the box. + * @param length The length in each direction. + * @param modelIndex Precached model index. + * @param haloIndex Precached model index. + * @param startFrame Initital frame to render. + * @param frameRate Beam frame rate. + * @param life Time duration of the beam. + * @param width Initial beam width. + * @param endWidth Final beam width. + * @param fadeLength Beam fade time duration. + * @param amplitude Beam amplitude. + * @param color Color array (r, g, b, a). + * @param speed Speed of the beam. + * @noreturn + */ +stock void Effect_DrawAxisOfRotation( + int[] clients, + int numClients, + const float origin[3], + const float angles[3], + const float length[3], + int modelIndex, + int haloIndex, + int startFrame=0, + int frameRate=30, + float life=5.0, + float width=5.0, + float endWidth=5.0, + int fadeLength=2, + float amplitude=1.0, + int speed=0 +) { + // Create the additional corners of the box + float xAxis[3], yAxis[3], zAxis[3]; + xAxis[0] = length[0]; + yAxis[1] = length[1]; + zAxis[2] = length[2]; + + // Rotate all edges + Math_RotateVector(xAxis, angles, xAxis); + Math_RotateVector(yAxis, angles, yAxis); + Math_RotateVector(zAxis, angles, zAxis); + + // Apply world offset (after rotation) + AddVectors(origin, xAxis, xAxis); + AddVectors(origin, yAxis, yAxis); + AddVectors(origin, zAxis, zAxis); + + // Draw all + TE_SetupBeamPoints(origin, xAxis, modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, {255, 0, 0, 255}, speed); + TE_Send(clients, numClients); + + TE_SetupBeamPoints(origin, yAxis, modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, {0, 255, 0, 255}, speed); + TE_Send(clients, numClients); + + TE_SetupBeamPoints(origin, zAxis, modelIndex, haloIndex, startFrame, frameRate, life, width, endWidth, fadeLength, amplitude, {0, 0, 255, 255}, speed); + TE_Send(clients, numClients); +} + + +/** + * Creates an env_sprite. + * + * @param origin Origin of the Sprite. + * @param modelIndex Precached model index. + * @param color Color array (r, g, b, a). + * @param scale Scale (Note: many materials ignore a lower value than 0.25). + * @param targetName Targetname of the sprite. + * @param parent Entity Index of this sprite's parent in the movement hierarchy. + * @param renderMode Render mode (use the enum). + * @param renderFx Render fx (use the enum). + * @param glowProxySize Radius size of the glow when to be rendered, if inside a geometry. Ex: a block 2x2x2 units big, if the glowProxySize is between 0.0 and 2.0 the sprite will not be rendered, even if the actual size of the sprite is bigger, everything above 2.0 will render the sprite. Using an abnormal high value will render Sprites trough walls. + * @param frameRate Sprite frame rate. + * @param hdrColorScale Float value to multiply sprite color by when running with HDR. + * @param receiveShadows When false then this prevents the sprite from receiving shadows. + * @return Entity Index of the created Sprite. + */ +stock int Effect_EnvSprite( + float origin[3], + int modelIndex, + const int color[4]={255, 255, 255, 255}, + float scale=0.25, + const char targetName[MAX_NAME_LENGTH]="", + int parent=-1, + RenderMode renderMode=RENDER_WORLDGLOW, + RenderFx renderFx=RENDERFX_NONE, + float glowProxySize=2.0, + float framerate=10.0, + float hdrColorScale=1.0, + bool receiveShadows = true +) { + int entity = Entity_Create("env_sprite"); + + if (entity == INVALID_ENT_REFERENCE) { + return INVALID_ENT_REFERENCE; + } + + DispatchKeyValue (entity, "disablereceiveshadows", (receiveShadows) ? "0" : "1"); + DispatchKeyValueFloat (entity, "framerate", framerate); + DispatchKeyValueFloat (entity, "GlowProxySize", glowProxySize); + DispatchKeyValue (entity, "spawnflags", "1"); + DispatchKeyValueFloat (entity, "HDRColorScale", hdrColorScale); + DispatchKeyValue (entity, "maxdxlevel", "0"); + DispatchKeyValue (entity, "mindxlevel", "0"); + DispatchKeyValueFloat (entity, "scale", scale); + + DispatchSpawn(entity); + + SetEntityRenderMode(entity, renderMode); + SetEntityRenderColor(entity, color[0], color[1], color[2], color[3]); + SetEntityRenderFx(entity, renderFx); + + Entity_SetName(entity, targetName); + Entity_SetModelIndex(entity, modelIndex); + Entity_SetAbsOrigin(entity, origin); + + if (parent != -1) { + Entity_SetParent(entity, parent); + } + + return entity; +} \ No newline at end of file diff --git a/include/smlib/entities.inc b/include/smlib/entities.inc new file mode 100644 index 0000000..4650b84 --- /dev/null +++ b/include/smlib/entities.inc @@ -0,0 +1,2141 @@ +#if defined _smlib_entities_included + #endinput +#endif +#define _smlib_entities_included + +#include +#include +#include +// Sourcemod 1.9+ compatibility +#tryinclude + +/** + * Macro for iterating trough all children (entities it is parent of) of an entity. + * + * @param 1 Entity Index of the parent. + * @param 2 Name of the children entity index variable (will be only valid in the loop). + */ +#define LOOP_CHILDREN(%1,%2) for (int %2=Entity_GetNextChild(%1); %2 != INVALID_ENT_REFERENCE; %2=Entity_GetNextChild(%1, ++%2)) + +/* + * Checks if an entity is valid and exists. + * + * @param entity Entity Index. + * @return True if the entity is valid, false otherwise. + */ +stock bool Entity_IsValid(int entity) +{ + return IsValidEntity(entity); +} + +/** + * Finds an entity by its name. + * You can optionally specify the classname to search for. + * Note: If the classname is specified it uses The Sourcemod native + * function FindEntityByClassname() which uses the engine's + * linked entity list for finding entities. This might be + * cheaper, use this if you call this function very often. + * + * @param name Name of the entity you want so search. + * @param className Optional: Classname of the entity + * @return Entity index or INVALID_ENT_REFERENCE if not matching entity was found. + */ +stock int Entity_FindByName(const char[] name, const char className[]="") +{ + if (className[0] == '\0') { + // Hack: Double the limit to gets none-networked entities too. + int realMaxEntities = GetMaxEntities() * 2; + for (int entity=0; entity < realMaxEntities; entity++) { + + if (!IsValidEntity(entity)) { + continue; + } + + if (Entity_NameMatches(entity, name)) { + return entity; + } + } + } + else { + int entity = INVALID_ENT_REFERENCE; + while ((entity = FindEntityByClassname(entity, className)) != INVALID_ENT_REFERENCE) { + + if (Entity_NameMatches(entity, name)) { + return entity; + } + } + } + + return INVALID_ENT_REFERENCE; +} + +/** + * Finds an entity by its HammerID. + * The newer version of Valve's Hammer editor + * sets a unique ID for each entity in a map. + * It only finds the first occurence. + * Note: If the classname is specified it uses The Sourcemod native + * function FindEntityByClassname() which uses the engine's + * linked entity list for finding entities. This might be + * cheaper, use this if you call this function very often. + * + * @param hammerId Hammer editor ID + * @param className Optional: Classname of the entity + * @return Edict Index or INVALID_ENT_REFERENCE if no entity was found. + */ +stock int Entity_FindByHammerId(int hammerId, const char className[]="") +{ + if (className[0] == '\0') { + // Hack: Double the limit to gets none-networked entities too. + int realMaxEntities = GetMaxEntities() * 2; + for (int entity=0; entity < realMaxEntities; entity++) { + + if (!IsValidEntity(entity)) { + continue; + } + + if (Entity_GetHammerId(entity) == hammerId) { + return entity; + } + } + } + else { + int entity = INVALID_ENT_REFERENCE; + while ((entity = FindEntityByClassname(entity, className)) != INVALID_ENT_REFERENCE) { + + if (Entity_GetHammerId(entity) == hammerId) { + return entity; + } + } + } + + return INVALID_ENT_REFERENCE; +} + +/** + * Searches for an entity by classname. + * This is a wrapper around FindEntityByClassname + * and has been added for completion. + * + * @param startEnt The entity index after which to begin searching from. Use -1 to start from the first entity. + * @param classname Classname of the entity to find. + * @return Entity index >= 0 if found, -1 otherwise. + */ +stock int Entity_FindByClassName(int startEntity, const char[] className) +{ + return FindEntityByClassname(startEntity, className); +} + +/** + * Checks if an entity (partially) matches a specific entity class. + * + * @param entity Entity Index. + * @param className Classname String. + * @param partialMatch If to do a partial classname check. + * @return True if the classname matches, false otherwise. + */ +stock bool Entity_ClassNameMatches(int entity, const char[] className, bool partialMatch=false) +{ + char entity_className[64]; + Entity_GetClassName(entity, entity_className, sizeof(entity_className)); + + if (partialMatch) { + return (StrContains(entity_className, className) != -1); + } + + return StrEqual(entity_className, className); +} + +/** + * Checks if an entity matches a name + * + * @param entity Entity Index. + * @param class Name String. + * @return True if the name matches, false otherwise. + */ +stock bool Entity_NameMatches(int entity, const char[] name) +{ + char entity_name[128]; + Entity_GetName(entity, entity_name, sizeof(entity_name)); + + return StrEqual(name, entity_name); +} + +/** + * Gets the Name of an entity. + * + * @param entity Entity index. + * @param buffer Return/Output buffer. + * @param size Max size of buffer. + * @return Number of non-null bytes written. + */ +stock int Entity_GetName(int entity, char[] buffer, int size) +{ + return GetEntPropString(entity, Prop_Data, "m_iName", buffer, size); +} + +/** + * Sets the Name of an entity. + * + * @param entity Entity index. + * @param name The name you want to give. + * @return True on success, false otherwise. + */ +stock bool Entity_SetName(int entity, const char[] name, any ...) +{ + char format[128]; + VFormat(format, sizeof(format), name, 3); + + return DispatchKeyValue(entity, "targetname", format); +} + +/** + * Gets the Classname of an entity. + * This is like GetEdictClassname(), except it works for ALL + * entities, not just edicts. + * + * @param entity Entity index. + * @param buffer Return/Output buffer. + * @param size Max size of buffer. + * @return Number of non-null bytes written. + */ +stock int Entity_GetClassName(int entity, char[] buffer, int size) +{ + return GetEntPropString(entity, Prop_Data, "m_iClassname", buffer, size); +} + +/** + * Sets the Classname of an entity. + * + * @param entity Entity index. + * @param name The name you want to give. + * @return True on success, false otherwise. + */ +stock bool Entity_SetClassName(int entity, const char[] className) +{ + return DispatchKeyValue(entity, "classname", className); +} + +/** + * Gets the Target name of an other entity + * + * @param entity Entity index. + * @param buffer Return/Output buffer. + * @param size Max size of buffer. + * @return Number of non-null bytes written. + */ +stock int Entity_GetTargetName(int entity, char[] buffer, int size) +{ + return GetEntPropString(entity, Prop_Data, "m_target", buffer, size); +} + +/** + * Sets the Target name of an other Entity + * + * @param entity Entity index. + * @param name The target name you want to set + * @return True on success, false otherwise. + */ +stock bool Entity_SetTargetName(int entity, const char[] name, any ...) +{ + char format[128]; + VFormat(format, sizeof(format), name, 3); + + return DispatchKeyValue(entity, "target", format); +} + +/** + * Gets the Global Name of an entity. + * + * @param entity Entity index. + * @param buffer Return/Output buffer. + * @param size Max size of buffer. + * @return Number of non-null bytes written. + */ +stock int Entity_GetGlobalName(int entity, char[] buffer, int size) +{ + return GetEntPropString(entity, Prop_Data, "m_iGlobalname", buffer, size); +} + +/** + * Sets the Global Name of an entity. + * + * @param entity Entity index. + * @param name The global name you want to set. + * @return True on success, false otherwise. + */ +stock bool Entity_SetGlobalName(int entity, const char[] name, any ...) +{ + char format[128]; + VFormat(format, sizeof(format), name, 3); + + return DispatchKeyValue(entity, "globalname", format); +} + +/** + * Gets the Parent name of an entity. + * + * @param entity Entity index. + * @param buffer Return/Output buffer. + * @param size Max size of buffer. + * @return Number of non-null bytes written. + */ +stock int Entity_GetParentName(int entity, char[] buffer, int size) +{ + return GetEntPropString(entity, Prop_Data, "m_iParent", buffer, size); +} + +/** + * Sets the Parent name of an entity. + * + * @param entity Entity index. + * @param name The parent name you want to set. + * @return True on success, false otherwise. + */ +stock bool Entity_SetParentName(int entity, const char[] name, any ...) +{ + char format[128]; + VFormat(format, sizeof(format), name, 3); + + return DispatchKeyValue(entity, "parentname", format); +} + +/** + * Gets the Hammer-ID of an entity. + * The Hammer Editor gives every entity a unique ID. + * Note: Old maps don't have Hammer-ID's set for entities + * + * @param entity Entity index. + * @return Hammer ID. + */ +stock int Entity_GetHammerId(int entity) +{ + return GetEntProp(entity, Prop_Data, "m_iHammerID"); +} + +/** + * Gets the radius (m_flRadius) of an entity. + * + * @param entity Entity index. + * @return Radius + */ +stock float Entity_GetRadius(int entity) +{ + return GetEntPropFloat(entity, Prop_Data, "m_flRadius"); +} + +/** + * Sets the radius (m_flRadius) of an entity. + * + * @param entity Entity index. + * @param radius Radius value + * @noreturn + */ +stock void Entity_SetRadius(int entity, float radius) +{ + SetEntPropFloat(entity, Prop_Data, "m_flRadius", radius); +} + +/** + * Gets the Mins of an entity. + * + * @param entity Entity index. + * @param vec Vector. + * @noreturn + */ +stock void Entity_GetMinSize(int entity, float vec[3]) +{ + GetEntPropVector(entity, Prop_Send, "m_vecMins", vec); +} + +/** + * Sets the Mins of an entity. + * + * @param entity Entity index. + * @param vec Vector. + * @noreturn + */ +stock void Entity_SetMinSize(int entity, float vecMins[3]) +{ + SetEntPropVector(entity, Prop_Send, "m_vecMins", vecMins); +} + +/** + * Gets the Mins of an entity. + * This functions isn't safe to use, use Entity_SetMinMaxSize() instead. + * + * @param entity Entity index + * @param vec return vector. + * @noreturn + */ +stock void Entity_GetMaxSize(int entity, float vec[3]) +{ + GetEntPropVector(entity, Prop_Send, "m_vecMaxs", vec); +} + +/** + * Sets the Maxs of an entity. + * This functions isn't safe to use, use Entity_SetMinMaxSize() instead. + * + * @param entity Entity index. + * @param vec Vector. + * @noreturn + */ +stock void Entity_SetMaxSize(int entity, float vecMaxs[3]) +{ + SetEntPropVector(entity, Prop_Send, "m_vecMaxs", vecMaxs); +} + +/** + * Sets the Min and Max Size of an entity. + * Code is taken from HL2SDK and rewritten for Sourcemod. + * + * @param entity Entity index. + * @param vecMins Min size Vector + * @param vecMaxs Max size Vector + * @noreturn + */ +stock void Entity_SetMinMaxSize(int entity, float vecMins[3], float vecMaxs[3]) +{ + // Taken from hl2sdk-ob-valve\game\server\util.cpp SetMinMaxSize() + // Todo: Replace this by a SDK call + for (int i=0; i<3; i++) { + + if (vecMins[i] > vecMaxs[i]) { + ThrowError("Error: mins[%d] > maxs[%d] of entity %d", i, i, EntRefToEntIndex(entity)); + } + } + + float m_vecMins[3], m_vecMaxs[3]; + Entity_GetMinSize(entity, m_vecMins); + Entity_GetMaxSize(entity, m_vecMaxs); + + if (Math_VectorsEqual(m_vecMins, vecMins) && Math_VectorsEqual(m_vecMaxs, vecMaxs)) { + return; + } + + Entity_SetMinSize(entity, vecMins); + Entity_SetMaxSize(entity, vecMaxs); + + float vecSize[3]; + SubtractVectors(vecMaxs, vecMins, vecSize); + Entity_SetRadius(entity, GetVectorLength(vecSize) * 0.5); + + Entity_MarkSurrBoundsDirty(entity); +} + +/* + * Spawn Flags + * Many entities define their specific spawnflags, check the HL2SDK. + */ + +/* + * Phys prop spawnflags + * Taken from hl2sdk-ob-valve\game\shared\props_shared.h + */ +#define SF_PHYSPROP_START_ASLEEP 0x000001 +#define SF_PHYSPROP_DONT_TAKE_PHYSICS_DAMAGE 0x000002 // this prop can't be damaged by physics collisions +#define SF_PHYSPROP_DEBRIS 0x000004 +#define SF_PHYSPROP_MOTIONDISABLED 0x000008 // motion disabled at startup (flag only valid in spawn - motion can be enabled via input) +#define SF_PHYSPROP_TOUCH 0x000010 // can be 'crashed through' by running player (plate glass) +#define SF_PHYSPROP_PRESSURE 0x000020 // can be broken by a player standing on it +#define SF_PHYSPROP_ENABLE_ON_PHYSCANNON 0x000040 // enable motion only if the player grabs it with the physcannon +#define SF_PHYSPROP_NO_ROTORWASH_PUSH 0x000080 // The rotorwash doesn't push these +#define SF_PHYSPROP_ENABLE_PICKUP_OUTPUT 0x000100 // If set, allow the player to +USE this for the purposes of generating an output +#define SF_PHYSPROP_PREVENT_PICKUP 0x000200 // If set, prevent +USE/Physcannon pickup of this prop +#define SF_PHYSPROP_PREVENT_PLAYER_TOUCH_ENABLE 0x000400 // If set, the player will not cause the object to enable its motion when bumped into +#define SF_PHYSPROP_HAS_ATTACHED_RAGDOLLS 0x000800 // Need to remove attached ragdolls on enable motion/etc +#define SF_PHYSPROP_FORCE_TOUCH_TRIGGERS 0x001000 // Override normal debris behavior and respond to triggers anyway +#define SF_PHYSPROP_FORCE_SERVER_SIDE 0x002000 // Force multiplayer physics object to be serverside +#define SF_PHYSPROP_RADIUS_PICKUP 0x004000 // For Xbox, makes small objects easier to pick up by allowing them to be found +#define SF_PHYSPROP_ALWAYS_PICK_UP 0x100000 // Physcannon can always pick this up, no matter what mass or constraints may apply. +#define SF_PHYSPROP_NO_COLLISIONS 0x200000 // Don't enable collisions on spawn +#define SF_PHYSPROP_IS_GIB 0x400000 // Limit # of active gibs + +/* + * Physbox Spawnflags. Start at 0x01000 to avoid collision with CBreakable's + * Taken from hl2sdk-ob-valve\game\server\physobj.h + */ +#define SF_PHYSBOX_ASLEEP 0x01000 +#define SF_PHYSBOX_IGNOREUSE 0x02000 +#define SF_PHYSBOX_DEBRIS 0x04000 +#define SF_PHYSBOX_MOTIONDISABLED 0x08000 +#define SF_PHYSBOX_USEPREFERRED 0x10000 +#define SF_PHYSBOX_ENABLE_ON_PHYSCANNON 0x20000 +#define SF_PHYSBOX_NO_ROTORWASH_PUSH 0x40000 // The rotorwash doesn't push these +#define SF_PHYSBOX_ENABLE_PICKUP_OUTPUT 0x80000 +#define SF_PHYSBOX_ALWAYS_PICK_UP 0x100000 // Physcannon can always pick this up, no matter what mass or constraints may apply. +#define SF_PHYSBOX_NEVER_PICK_UP 0x200000 // Physcannon will never be able to pick this up. +#define SF_PHYSBOX_NEVER_PUNT 0x400000 // Physcannon will never be able to punt this object. +#define SF_PHYSBOX_PREVENT_PLAYER_TOUCH_ENABLE 0x800000 // If set, the player will not cause the object to enable its motion when bumped into + +/* + * Spawnflags for func breakable + * Taken from hl2sdk-ob-valve\game\server\func_break.h + */ +#define SF_BREAK_TRIGGER_ONLY 0x0001 // may only be broken by trigger +#define SF_BREAK_TOUCH 0x0002 // can be 'crashed through' by running player (plate glass) +#define SF_BREAK_PRESSURE 0x0004 // can be broken by a player standing on it +#define SF_BREAK_PHYSICS_BREAK_IMMEDIATELY 0x0200 // the first physics collision this breakable has will immediately break it +#define SF_BREAK_DONT_TAKE_PHYSICS_DAMAGE 0x0400 // this breakable doesn't take damage from physics collisions +#define SF_BREAK_NO_BULLET_PENETRATION 0x0800 // don't allow bullets to penetrate + +/* + * Spawnflags for func_pushable (it's also func_breakable, so don't collide with those flags) + * Taken from hl2sdk-ob-valve\game\server\func_break.h + */ +#define SF_PUSH_BREAKABLE 0x0080 +#define SF_PUSH_NO_USE 0x0100 // player cannot +use pickup this ent + +/** + * Gets the Spawnflags of an entity. + * + * @param entity Entity index. + * @return Spawnflags value + */ +stock int Entity_GetSpawnFlags(int entity) +{ + return GetEntProp(entity, Prop_Data, "m_spawnflags"); +} + +/** + * Sets the Spawnflags of an entity. + * + * @param entity Entity index. + * @param flags Flags value + * @noreturn + */ +stock void Entity_SetSpawnFlags(int entity, int flags) +{ + SetEntProp(entity, Prop_Data, "m_spawnflags", flags); +} + +/** + * Adds Spawnflags to an entity. + * + * @param entity Entity index. + * @param flags Flags value + * @noreturn + */ +stock void Entity_AddSpawnFlags(int entity, int flags) +{ + int spawnFlags = Entity_GetSpawnFlags(entity); + spawnFlags |= flags; + Entity_SetSpawnFlags(entity, spawnFlags); +} + +/** + * Removes Spawnflags from an entity. + * + * @param entity Entity index. + * @param flags Flags value + * @noreturn + */ +stock void Entity_RemoveSpawnFlags(int entity, int flags) +{ + int spawnFlags = Entity_GetSpawnFlags(entity); + spawnFlags &= ~flags; + Entity_SetSpawnFlags(entity, spawnFlags); +} + +/** + * Clears all Spawnflags of an entity. + * + * @param entity Entity index. + * @noreturn + */ +stock void Entity_ClearSpawnFlags(int entity) +{ + Entity_SetSpawnFlags(entity, 0); +} + +/** + * Returns whether the entity has specific Spawnflags. + * + * @param entity Entity index. + * @param flags Flags value. + * @return True if the entity has the spawnflags set, false otherwise. + */ +stock bool Entity_HasSpawnFlags(int entity, int flags) +{ + return view_as(Entity_GetSpawnFlags(entity) & flags); +} + +/* + * Entity flags, CBaseEntity::m_iEFlags + * Taken from: hl2sdk-ob-valve\game\shared\shareddefs.h + */ +enum Entity_Flags +{ + EFL_KILLME = (1<<0), // This entity is marked for death -- This allows the game to actually delete ents at a safe time + EFL_DORMANT = (1<<1), // Entity is dormant, no updates to client + EFL_NOCLIP_ACTIVE = (1<<2), // Lets us know when the noclip command is active. + EFL_SETTING_UP_BONES = (1<<3), // Set while a model is setting up its bones. + EFL_KEEP_ON_RECREATE_ENTITIES = (1<<4), // This is a special entity that should not be deleted when we restart entities only + + EFL_HAS_PLAYER_CHILD= (1<<4), // One of the child entities is a player. + + EFL_DIRTY_SHADOWUPDATE = (1<<5), // Client only- need shadow manager to update the shadow... + EFL_NOTIFY = (1<<6), // Another entity is watching events on this entity (used by teleport) + + // The default behavior in ShouldTransmit is to not send an entity if it doesn't + // have a model. Certain entities want to be sent anyway because all the drawing logic + // is in the client DLL. They can set this flag and the engine will transmit them even + // if they don't have a model. + EFL_FORCE_CHECK_TRANSMIT = (1<<7), + + EFL_BOT_FROZEN = (1<<8), // This is set on bots that are frozen. + EFL_SERVER_ONLY = (1<<9), // Non-networked entity. + EFL_NO_AUTO_EDICT_ATTACH = (1<<10), // Don't attach the edict; we're doing it explicitly + + // Some dirty bits with respect to abs computations + EFL_DIRTY_ABSTRANSFORM = (1<<11), + EFL_DIRTY_ABSVELOCITY = (1<<12), + EFL_DIRTY_ABSANGVELOCITY = (1<<13), + EFL_DIRTY_SURR_COLLISION_BOUNDS = (1<<14), + EFL_DIRTY_SPATIAL_PARTITION = (1<<15), +// UNUSED = (1<<16), + + EFL_IN_SKYBOX = (1<<17), // This is set if the entity detects that it's in the skybox. + // This forces it to pass the "in PVS" for transmission. + EFL_USE_PARTITION_WHEN_NOT_SOL = (1<<18), // Entities with this flag set show up in the partition even when not solid + EFL_TOUCHING_FLUID = (1<<19), // Used to determine if an entity is floating + + // FIXME: Not really sure where I should add this... + EFL_IS_BEING_LIFTED_BY_BARNACLE = (1<<20), + EFL_NO_ROTORWASH_PUSH = (1<<21), // I shouldn't be pushed by the rotorwash + EFL_NO_THINK_FUNCTION = (1<<22), + EFL_NO_GAME_PHYSICS_SIMULATION = (1<<23), + + EFL_CHECK_UNTOUCH = (1<<24), + EFL_DONTBLOCKLOS = (1<<25), // I shouldn't block NPC line-of-sight + EFL_DONTWALKON = (1<<26), // NPC;s should not walk on this entity + EFL_NO_DISSOLVE = (1<<27), // These guys shouldn't dissolve + EFL_NO_MEGAPHYSCANNON_RAGDOLL = (1<<28), // Mega physcannon can't ragdoll these guys. + EFL_NO_WATER_VELOCITY_CHANGE = (1<<29), // Don't adjust this entity's velocity when transitioning into water + EFL_NO_PHYSCANNON_INTERACTION = (1<<30), // Physcannon can't pick these up or punt them + EFL_NO_DAMAGE_FORCES = (1<<31), // Doesn't accept forces from physics damage +}; + +/** + * Gets the Entity flags (m_iEFlags) of an entity. + * + * @param entity Entity index. + * @return Entity flags value + */ +stock Entity_Flags Entity_GetEFlags(int entity) +{ + return view_as(GetEntProp(entity, Prop_Data, "m_iEFlags")); +} + +/** + * Sets the entity's Entity flags (m_iEFlags). + * + * @param entity Entity index. + * @param flags Flags value + * @noreturn + */ +stock void Entity_SetEFlags(int entity, Entity_Flags flags) +{ + SetEntProp(entity, Prop_Data, "m_iEFlags", flags); +} + +/** + * Adds Entity flags (m_iEFlags) to an entity. + * + * @param entity Entity index. + * @param flags Flags value + * @noreturn + */ +stock void Entity_AddEFlags(int entity, Entity_Flags flags) +{ + Entity_Flags setFlags = Entity_GetEFlags(entity); + setFlags |= flags; + Entity_SetEFlags(entity, setFlags); +} + +/** + * Removes Entity flags (m_iEFlags) from an entity. + * + * @param entity Entity index. + * @param flags Flags value + * @noreturn + */ +stock void Entity_RemoveEFlags(int entity, Entity_Flags flags) +{ + Entity_Flags setFlags = Entity_GetEFlags(entity); + setFlags &= ~flags; + Entity_SetEFlags(entity, setFlags); +} + +/** + * Checks if the entity has specific Entity flags (m_iEFlags) set. + * + * @param entity Entity index. + * @param flags Flags value + * @return True if the flags are set, false otherwise. + */ +stock bool Entity_HasEFlags(int entity, Entity_Flags flags) +{ + Entity_Flags currentEFlags = Entity_GetEFlags(entity); + + return view_as(currentEFlags & flags); +} + +/** + * Marks the surrounding bounds of an entity as outdated. + * You normally call this when a collision setting has changed. + * + * @param entity Entity index. + * @noreturn + */ +stock void Entity_MarkSurrBoundsDirty(int entity) +{ + Entity_AddEFlags(entity, EFL_DIRTY_SURR_COLLISION_BOUNDS); +} + +/* + * CBaseEntity::m_fFlags Functions + * Use the FL_ Defines (FL_ONGROUND, ...) or + * special entity specific flags. + * Note: The flag FL_AIMTARGET probably doesn't work as + * we have current no way of adding/removing it to the AimTarget List. + */ + +/** + * Gets the Flags of an entity. + * + * @param entity Entity Index. + * @return Entity Flags. + */ +stock int Entity_GetFlags(int entity) +{ + return GetEntProp(entity, Prop_Data, "m_fFlags"); +} + +/** + * Sets the Flags of an entity. + * + * @param entity Entity index. + * @param flags New Flags value + * @noreturn + */ +stock void Entity_SetFlags(int entity, int flags) +{ + SetEntProp(entity, Prop_Data, "m_fFlags", flags); +} + +/** + * Adds Flags to the entity + * + * @param entity Entity index. + * @param flags Flags to add + * @noreturn + */ +stock void Entity_AddFlags(int entity, int flags) +{ + int setFlags = Entity_GetFlags(entity); + setFlags |= flags; + Entity_SetFlags(entity, flags); +} + +/** + * Removes flags from the entity + * + * @param entity Entity index. + * @param flags Flags to remove + * @noreturn + */ +stock void Entity_RemoveFlags(int entity, int flags) +{ + int setFlags = Entity_GetFlags(entity); + setFlags &= ~flags; + Entity_SetFlags(entity, setFlags); +} + +/** + * Toggles the specified flag on the entity. + * Adds the flag to the entity if it doesn't exists + * or removes it otherwise. + * + * @param entity Entity index. + * @param flags Flag to Toggle + * @noreturn + */ +stock void Entity_ToggleFlag(int entity, int flag) +{ + int setFlag = Entity_GetFlags(entity); + setFlag ^= flag; + Entity_SetFlags(entity, setFlag); +} + +/** + * Removes all flags from the entity + * + * @param entity Entity index. + * @noreturn + */ +stock void Entity_ClearFlags(int entity) +{ + Entity_SetFlags(entity, 0); +} + +/* edict->solid values + * NOTE: Some movetypes will cause collisions independent of SOLID_NOT/SOLID_TRIGGER when the entity moves + * SOLID only effects OTHER entities colliding with this one when they move - UGH! + * + * Solid type basically describes how the bounding volume of the object is represented + * NOTE: These numerical values are used in the FGD by the prop code (see prop_dynamic) + * Taken from: hl2sdk-ob-valve\public\const.h + */ + +enum SolidFlags_t +{ + FSOLID_CUSTOMRAYTEST = 0x0001, // Ignore solid type + always call into the entity for ray tests + FSOLID_CUSTOMBOXTEST = 0x0002, // Ignore solid type + always call into the entity for swept box tests + FSOLID_NOT_SOLID = 0x0004, // Are we currently not solid? + FSOLID_TRIGGER = 0x0008, // This is something may be collideable but fires touch functions + // even when it's not collideable (when the FSOLID_NOT_SOLID flag is set) + FSOLID_NOT_STANDABLE = 0x0010, // You can't stand on this + FSOLID_VOLUME_CONTENTS = 0x0020, // Contains volumetric contents (like water) + FSOLID_FORCE_WORLD_ALIGNED = 0x0040, // Forces the collision rep to be world-aligned even if it's SOLID_BSP or SOLID_VPHYSICS + FSOLID_USE_TRIGGER_BOUNDS = 0x0080, // Uses a special trigger bounds separate from the normal OBB + FSOLID_ROOT_PARENT_ALIGNED = 0x0100, // Collisions are defined in root parent's local coordinate space + FSOLID_TRIGGER_TOUCH_DEBRIS = 0x0200, // This trigger will touch debris objects + + FSOLID_MAX_BITS = 10 +}; + +/** + * Gets the solid flags of the entity + * + * @param entity Entity index. + * @return Solid Flags. + */ +stock SolidFlags_t Entity_GetSolidFlags(int entity) +{ + return view_as(GetEntProp(entity, Prop_Data, "m_usSolidFlags", 2)); +} + +/** + * Sets the solid flags of the entity + * + * @param entity Entity index. + * @param flags Solid Flags. + * @noreturn + */ +stock void Entity_SetSolidFlags(int entity, SolidFlags_t flags) +{ + SolidFlags_t oldFlags = Entity_GetSolidFlags(entity); + flags = flags & view_as(0xFFFF); + + if (oldFlags == flags) { + return; + } + + SetEntProp(entity, Prop_Data, "m_usSolidFlags", flags, 2); + + // These two flags, if changed, can produce different surrounding bounds + if ((oldFlags & (FSOLID_FORCE_WORLD_ALIGNED | FSOLID_USE_TRIGGER_BOUNDS)) != + (flags & (FSOLID_FORCE_WORLD_ALIGNED | FSOLID_USE_TRIGGER_BOUNDS))) + { + Entity_MarkSurrBoundsDirty(entity); + } +} + +/** + * Adds solid flags to the entity + * + * @param entity Entity index. + * @param flags Solid Flags. + * @noreturn + */ +stock void Entity_AddSolidFlags(int entity, SolidFlags_t flags) +{ + SolidFlags_t newFlags = Entity_GetSolidFlags(entity); + newFlags |= flags; + Entity_SetSolidFlags(entity, newFlags); +} + +/** + * Removes solid flags from the entity. + * + * @param entity Entity index. + * @param flags Solid Flags. + * @noreturn + */ +stock void Entity_RemoveSolidFlags(int entity, SolidFlags_t flags) +{ + SolidFlags_t newFlags = Entity_GetSolidFlags(entity); + newFlags &= ~flags; + Entity_SetSolidFlags(entity, newFlags); +} + +/** + * Removes all solid flags from the entity. + * + * @param entity Entity index. + * @noreturn + */ +stock void Entity_ClearSolidFlags(int entity) +{ + Entity_SetSolidFlags(entity, view_as(0)); +} + +/** + * Checks whether certain solid flags are set on the entity. + * + * @param entity Entity index. + * @param flags Solid Flags. + * @return True if the specified flags are set, false otherwise. + */ +stock bool Entity_SolidFlagsSet(int entity, SolidFlags_t flagMask) +{ + return view_as(Entity_GetSolidFlags(entity) & flagMask); +} + +enum SolidType_t +{ + SOLID_NONE = 0, // no solid model + SOLID_BSP = 1, // a BSP tree + SOLID_BBOX = 2, // an AABB + SOLID_OBB = 3, // an OBB (not implemented yet) + SOLID_OBB_YAW = 4, // an OBB, constrained so that it can only yaw + SOLID_CUSTOM = 5, // Always call into the entity for tests + SOLID_VPHYSICS = 6, // solid vphysics object, get vcollide from the model and collide with that + SOLID_LAST, +}; + +/** + * Gets the solidity type of the entity + * + * @param entity Entity index. + * @return Solid Type + */ +stock SolidType_t Entity_GetSolidType(int entity) +{ + return view_as(GetEntProp(entity, Prop_Data, "m_nSolidType", 1)); +} + +/** + * Sets the solidity type of the entity + * + * @param entity Entity index. + * @param Solid Type value. + * @noreturn + */ +stock void Entity_SetSolidType(int entity, SolidType_t value) +{ + SetEntProp(entity, Prop_Send, "m_nSolidType", value, 1); + Entity_MarkSurrBoundsDirty(entity); +} + +/** + * Checks whether the entity is solid or not. + * + * @param entity Entity index. + * @return True if the entity is solid, false otherwise. + */ +stock bool Entity_IsSolid(int entity) +{ + return (Entity_GetSolidType(entity) != SOLID_NONE && + !Entity_SolidFlagsSet(entity, FSOLID_NOT_SOLID)); +} + +/** + * Retrieves the model path of a given entity. + * Returns "*num" for Brush entities. + * + * @param entity entity reference or index + * @param model buffer String for the model + * @param size max size of buffer string + * @return Number of non-null bytes written. + */ +stock int Entity_GetModel(int entity, char[] buffer, int size) +{ + return GetEntPropString(entity, Prop_Data, "m_ModelName", buffer, size); +} + +/** + * Sets the model to a given entity. + * Be sure it has been precached. + * This is an alias for SetEntityModel() + * + * @param entity Entity index + * @param model Model name + * @noreturn + */ +stock void Entity_SetModel(int entity, const char[] model) +{ + SetEntityModel(entity, model); +} + +/** + * Gets the entity's model index, if it has one set. + * + * @param entity Entity index. + * @return The Entity's model index + */ +stock int Entity_GetModelIndex(int entity) +{ + return GetEntProp(entity, Prop_Data, "m_nModelIndex", 2); +} + +/** + * Sets the entity's model index (must be precached) + * + * @param entity Entity index. + * @param index Model Index. + * @noreturn + */ +stock void Entity_SetModelIndex(int entity, int index) +{ + SetEntProp(entity, Prop_Data, "m_nModelIndex", index, 2); +} + +/** +* Sets the entity's maxspeed to the given value (in units per second) +* +* @param entity Entity index +* @param maxspeed the maximum speed the entity can move +* @noreturn +*/ +stock void Entity_SetMaxSpeed(int entity, float value) +{ + SetEntPropFloat(entity, Prop_Data, "m_flMaxspeed", value); +} + +/* + * Collision groups + * Taken from hl2sdk-ob-valve/public/const.h + */ +enum Collision_Group_t +{ + COLLISION_GROUP_NONE = 0, + COLLISION_GROUP_DEBRIS, // Collides with nothing but world and static stuff + COLLISION_GROUP_DEBRIS_TRIGGER, // Same as debris, but hits triggers + COLLISION_GROUP_INTERACTIVE_DEB, // Collides with everything except other interactive debris or debris + COLLISION_GROUP_INTERACTIVE, // Collides with everything except interactive debris or debris + COLLISION_GROUP_PLAYER, + COLLISION_GROUP_BREAKABLE_GLASS, + COLLISION_GROUP_VEHICLE, + COLLISION_GROUP_PLAYER_MOVEMENT, // For HL2, same as Collision_Group_Player, for + // TF2, this filters out other players and CBaseObjects + COLLISION_GROUP_NPC, // Generic NPC group + COLLISION_GROUP_IN_VEHICLE, // for any entity inside a vehicle + COLLISION_GROUP_WEAPON, // for any weapons that need collision detection + COLLISION_GROUP_VEHICLE_CLIP, // vehicle clip brush to restrict vehicle movement + COLLISION_GROUP_PROJECTILE, // Projectiles! + COLLISION_GROUP_DOOR_BLOCKER, // Blocks entities not permitted to get near moving doors + COLLISION_GROUP_PASSABLE_DOOR, // Doors that the player shouldn't collide with + COLLISION_GROUP_DISSOLVING, // Things that are dissolving are in this group + COLLISION_GROUP_PUSHAWAY, // Nonsolid on client and server, pushaway in player code + + COLLISION_GROUP_NPC_ACTOR, // Used so NPCs in scripts ignore the player. + COLLISION_GROUP_NPC_SCRIPTED // USed for NPCs in scripts that should not collide with each other +}; + +/** + * Gets the collision group of an entity. + * + * @param entity entity index + * @return Entity collision group. + */ +stock Collision_Group_t Entity_GetCollisionGroup(int entity) +{ + return view_as(GetEntProp(entity, Prop_Data, "m_CollisionGroup")); +} + +/** + * Sets the collision group of an entity. + * + * @param entity entity index + * @param value the new collision group. + * @noreturn + */ +stock void Entity_SetCollisionGroup(int entity, Collision_Group_t value) +{ + SetEntProp(entity, Prop_Data, "m_CollisionGroup", value); +} + +/** + * Functions for getting / setting the origin (position) of an entity. + * Go to http://developer.valvesoftware.com/wiki/Origin + * if you want to learn more about origins + */ + +/** + * Gets the Absolute Origin (position) of an entity. + * + * @param entity Entity index. + * @param vec 3 dimensional vector array. + * @noreturn + */ +stock void Entity_GetAbsOrigin(int entity, float vec[3]) +{ + GetEntPropVector(entity, Prop_Send, "m_vecOrigin", vec); +} + +/** + * Sets the Absolute Origin (position) of an entity. + * + * @param entity Entity index. + * @param vec 3 dimensional vector array. + * @noreturn + */ +stock void Entity_SetAbsOrigin(int entity, float vec[3]) +{ + // We use TeleportEntity to set the origin more safely + // Todo: Replace this with a call to UTIL_SetOrigin() or CBaseEntity::SetLocalOrigin() + TeleportEntity(entity, vec, NULL_VECTOR, NULL_VECTOR); +} + +/** + * Functions for getting / setting the angles (rotation) of an entity. + * http://developer.valvesoftware.com/wiki/Angles + * if you want to learn more about angles + */ + +/** + * Gets the Angles of an entity + * + * @param entity Entity index. + * @param vec 3 dimensional vector array. + * @noreturn + */ +stock void Entity_GetAbsAngles(int entity, float vec[3]) +{ + GetEntPropVector(entity, Prop_Data, "m_angAbsRotation", vec); +} + +/** + * Sets the Angles of an entity + * + * @param entity Entity index. + * @param vec 3 dimensional vector array. + * @noreturn + */ +stock void Entity_SetAbsAngles(int entity, float vec[3]) +{ + // We use TeleportEntity to set the angles more safely + // Todo: Replace this with a call to CBaseEntity::SetLocalAngles() + TeleportEntity(entity, NULL_VECTOR, vec, NULL_VECTOR); +} + +/** + * Functions for getting / setting the velocity of an entity. + * Go to http://developer.valvesoftware.com/wiki/Velocity + * if you want to learn more about the different kind of velocities. + */ + +/** + * Gets the Local velocity of an entity. + * The local velocity is the velocity generated by the entity. + * + * @param entity Entity index. + * @param vel An 3 dim array + * @noreturn + */ +stock void Entity_GetLocalVelocity(int entity, float vec[3]) +{ + GetEntPropVector(entity, Prop_Data, "m_vecVelocity", vec); +} + +/** + * Sets the Local velocity of an entity. + * The local velocity is the velocity generated by the entity. + * Only use this if you know what you are doing, + * the entity can overwrite this value on next frame. + * + * @param entity Entity index. + * @param vel An 3 dim array + * @noreturn + */ +stock void Entity_SetLocalVelocity(int entity, const float vec[3]) +{ + SetEntPropVector(entity, Prop_Data, "m_vecVelocity", vec); +} + +/** + * Gets the Base velocity of an entity. + * The base velocity is the velocity applied + * to the entity from other sources . + * + * @param entity Entity index. + * @param vel An 3 dim array + * @noreturn + */ +stock void Entity_GetBaseVelocity(int entity, float vec[3]) +{ + GetEntPropVector(entity, Prop_Data, "m_vecBaseVelocity", vec); +} + +/** + * Sets the Base velocity of an entity. + * The base velocity is the velocity applied + * to the entity from other sources . + * + * @param entity Entity index. + * @param vel An 3 dim array + * @noreturn + */ +stock void Entity_SetBaseVelocity(int entity, const float vec[3]) +{ + SetEntPropVector(entity, Prop_Data, "m_vecBaseVelocity", vec); +} + +/** + * Gets the Absolute velocity of an entity. + * The absolute velocity is the sum of the local + * and base velocities. It's the actual value used to move. + * + * @param entity Entity index. + * @param vel An 3 dim array + * @noreturn + */ +stock void Entity_GetAbsVelocity(int entity, float vec[3]) +{ + GetEntPropVector(entity, Prop_Data, "m_vecAbsVelocity", vec); +} + +/** + * Sets the Absolute velocity of an entity. + * The absolute velocity is the sum of the local + * and base velocities. It's the actual value used to move. + * + * @param entity Entity index. + * @param vel An 3 dim array + * @noreturn + */ +stock void Entity_SetAbsVelocity(int entity, const float vec[3]) +{ + // We use TeleportEntity to set the velocity more safely + // Todo: Replace this with a call to CBaseEntity::SetAbsVelocity() + TeleportEntity(entity, NULL_VECTOR, NULL_VECTOR, vec); +} + +/** + * Returns true if the entity is locked. + * + * @param entity Entity index. + * @return True if locked otherwise false. + */ +stock bool Entity_IsLocked(int entity) +{ + return view_as(GetEntProp(entity, Prop_Data, "m_bLocked", 1)); +} + +/** + * Locks an entity. + * + * @param entity Entity index. + * @noreturn + */ +stock void Entity_Lock(int entity) +{ + SetEntProp(entity, Prop_Data, "m_bLocked", 1, 1); +} +/** + * Unlocks an entity. + * + * @param entity Entity index. + * @noreturn + */ +stock void Entity_UnLock(int entity) +{ + SetEntProp(entity, Prop_Data, "m_bLocked", 0, 1); +} + +/** + * Gets the health of an entity. + * + * @param entity entity index. + * @return current health points + */ +stock int Entity_GetHealth(int entity) +{ + return GetEntProp(entity, Prop_Data, "m_iHealth"); +} + +/** + * Sets the health of an entity. + * + * @param entity entity index. + * @param value health to set (anything above 511 will overload) + * @return Amount of health set + */ +stock int Entity_SetHealth(int entity, int value, bool ignoreMax=false, bool kill=true) +{ + int health = value; + + if (!ignoreMax) { + int maxHealth = Entity_GetMaxHealth(entity); + + if (health > maxHealth) { + health = maxHealth; + } + } + + if (health < 0) { + health = 0; + } + + SetEntProp(entity, Prop_Data, "m_iHealth", health); + + if (health <= 0) { + Entity_Kill(entity); + } + + return health; +} + +/** + * Add health to an entity + * + * @param entity entity index + * @param value health to add + * @return returns the new health value set + */ +stock int Entity_AddHealth(int entity, int value, bool ignoreMax=false, bool kill=true) +{ + int health = Entity_GetHealth(entity); + + health += value; + + return Entity_SetHealth(entity, health, ignoreMax, kill); +} + +/** + * Takes health from an entity + * + * @param entity entity index + * @param value health to add + * @return returns the new health value set + */ +stock int Entity_TakeHealth(int entity, int value, bool ignoreMax=false, bool kill=true) +{ + int health = Entity_GetHealth(entity); + + health -= value; + + return Entity_SetHealth(entity, health, ignoreMax, kill); +} + +/** + * Get the max health of an entity + * + * @param entity Entity Index + * @return Max health points + */ +stock int Entity_GetMaxHealth(int entity) +{ + return GetEntProp(entity, Prop_Data, "m_iMaxHealth"); +} + + +/** + * Set the max health of an entity. + * + * @param entity Entity index + * @param value Max health to set (anything above 511 will overload) + * @return Value max health was set to + */ +stock int Entity_SetMaxHealth(int entity, int value) +{ + SetEntProp(entity, Prop_Data, "m_iMaxHealth", value); + return value; +} + +/** + * Returns the Float distance between an entity + * and a vector origin. + * + * @param entity Entity Index. + * @param target Vector Origin. + * @return Distance Float value. + */ +stock float Entity_GetDistanceOrigin(int entity, const float vec[3]) +{ + float entityVec[3]; + Entity_GetAbsOrigin(entity, entityVec); + + return GetVectorDistance(entityVec, vec); +} + +/** + * Returns the Float distance between two entities. + * Both entities must be valid. + * + * @param entity Entity Index. + * @param target Target Entity Index. + * @return Distance Float value. + */ +stock float Entity_GetDistance(int entity, int target) +{ + float targetVec[3]; + Entity_GetAbsOrigin(target, targetVec); + + return Entity_GetDistanceOrigin(entity, targetVec); +} + +/** + * Checks if the given 2 entitys are within a given range. + * + * @param entity Entity Index. + * @param target Target Entity Index. + * @param distance Max Float distance. + * @return True if the given entities are closer than the given distance value, false otherwise. + */ +stock bool Entity_InRange(int entity, int target, float distance) +{ + if (Entity_GetDistance(entity, target) > distance) { + return false; + } + + return true; +} + +/** + * Enables the motion of an entity. + * + * @param entity Entity index. + * @return True on success, false otherwise + */ +stock bool Entity_EnableMotion(int entity) +{ + return AcceptEntityInput(entity, "enablemotion"); +} + +/** + * Disables the motion of an entity. + * + * @param entity Entity index. + * @return True on success, false otherwise + */ +stock bool Entity_DisableMotion(int entity) +{ + return AcceptEntityInput(entity, "disablemotion"); +} + +/** + * Freezes an entity by setting the FL_FROZEN flag. + * + * @param entity Entity index. + * @noreturn + */ +stock void Entity_Freeze(int entity) +{ + Entity_AddFlags(entity, FL_FROZEN); +} + +/** + * Unfreezes an entity by removing the FL_FROZEN flag. + * + * @param entity Entity index. + * @noreturn + */ +stock void Entity_UnFreeze(int entity) +{ + Entity_RemoveFlags(entity, FL_FROZEN); +} + + +/** + * This function points an entity to another with the targetname + * and name. Useful for allot of entities like trigger_teleport. + * If the name is not specified it will be generated automatically. + * + * @param entity Entity index. + * @param target Target entity index. + * @param Optional: target name + * @noreturn + */ +stock void Entity_PointAtTarget(int entity, int target, const char name[]="") +{ + char targetName[128]; + Entity_GetTargetName(entity, targetName, sizeof(targetName)); + + if (name[0] == '\0') { + + if (targetName[0] == '\0') { + // Let's generate our own name + Format( + targetName, + sizeof(targetName), + "_smlib_Entity_PointAtTarget:%d", + target + ); + } + } + else { + strcopy(targetName, sizeof(targetName), name); + } + + Entity_SetTargetName(entity, targetName); + Entity_SetName(target, targetName); +} + +/** + * This function points a point_hurt entity to another damage target entity.. + * and name. Useful for allot of entities like trigger_teleport. + * If the name is not specified it will be generated automatically. + * + * @param entity Entity index. + * @param target Target entity index. + * @param Optional: target name + * @noreturn + */ +stock void Entity_PointHurtAtTarget(int entity, int target, const char[] name="") +{ + char targetName[128]; + Entity_GetTargetName(entity, targetName, sizeof(targetName)); + + if (name[0] == '\0') { + + if (targetName[0] == '\0') { + // Let's generate our own name + Format( + targetName, + sizeof(targetName), + "_smlib_Entity_PointHurtAtTarget:%d", + target + ); + } + } + else { + strcopy(targetName, sizeof(targetName), name); + } + + DispatchKeyValue(entity, "DamageTarget", targetName); + Entity_SetName(target, targetName); +} + +/** + * Checks if an entity is a player or not. + * No checks are done if the entity is actually valid, + * the player is connected or ingame. + * + * @param entity Entity index. + * @return True if the entity is a player, false otherwise. + */ +stock bool Entity_IsPlayer(int entity) +{ + if (entity < 1 || entity > MaxClients) { + return false; + } + + return true; +} + +/** + * Creates an entity by classname. + * + * @param className Classname String. + * @param ForceEdictIndex Edict Index to use. + * @return Entity Index or INVALID_ENT_REFERENCE if the slot is already in use. + */ +stock int Entity_Create(const char[] className, int ForceEdictIndex=-1) +{ + if (ForceEdictIndex != -1 && Entity_IsValid(ForceEdictIndex)) { + return INVALID_ENT_REFERENCE; + } + + return CreateEntityByName(className, ForceEdictIndex); +} + +/** + * Kills an entity on the next frame (delayed). + * It is safe to use with entity loops. + * If the entity is is player ForcePlayerSuicide() is called. + * + * @param kenny Entity index. + * @param killChildren When true, kennys children are killed too. + * @return True on success, false otherwise. + */ +stock bool Entity_Kill(int kenny, bool killChildren=false) +{ + if (Entity_IsPlayer(kenny)) { + // Oh My God! They Killed Kenny!! + ForcePlayerSuicide(kenny); + return true; + } + + if(killChildren){ + return AcceptEntityInput(kenny, "KillHierarchy"); + } + else { + return AcceptEntityInput(kenny, "Kill"); + } +} + +/** + * Kills all entities with the given networked classname. + * It is safe to use with entity loops. + * If the entity is is player ForcePlayerSuicide() is called. + * + * @param className Entity Network Class to search for. + * @return Number of entities killed. + */ +stock int Entity_KillAllByClassName(const char[] className) +{ + int x = 0; + + int entity = INVALID_ENT_REFERENCE; + while ((entity = FindEntityByClassname(entity, className)) != INVALID_ENT_REFERENCE) { + AcceptEntityInput(entity, "kill"); + x++; + } + + return x; +} + +/** + * Gets the owner of an entity. + * For example the owner of a weapon entity. + * + * @param entity Entity index. + * @return Ground Entity or -1 + */ +stock int Entity_GetOwner(int entity) +{ + return GetEntPropEnt(entity, Prop_Data, "m_hOwnerEntity"); +} + +/** + * Sets the owner of an entity. + * For example the owner of a weapon entity. + * + * @param entity Entity index. + * @noreturn + */ +stock void Entity_SetOwner(int entity, int newOwner) +{ + SetEntPropEnt(entity, Prop_Send, "m_hOwnerEntity", newOwner); +} + +/** + * Get's the ground entity this entity stands on. + * + * @param entity Entity index. + * @return Ground Entity or -1 + */ +stock int Entity_GetGroundEntity(int entity) +{ + return GetEntPropEnt(entity, Prop_Data, "m_hGroundEntity"); +} + +/* + * Damage definitions + */ + +#if !defined DMG_GENERIC + +#define DMG_GENERIC 0 // generic damage was done +#define DMG_CRUSH (1 << 0) // crushed by falling or moving object. + // NOTE: It's assumed crush damage is occurring as a result of physics collision, so no extra physics force is generated by crush damage. + // DON'T use DMG_CRUSH when damaging entities unless it's the result of a physics collision. You probably want DMG_CLUB instead. +#define DMG_BULLET (1 << 1) // shot +#define DMG_SLASH (1 << 2) // cut, clawed, stabbed +#define DMG_BURN (1 << 3) // heat burned +#define DMG_VEHICLE (1 << 4) // hit by a vehicle +#define DMG_FALL (1 << 5) // fell too far +#define DMG_BLAST (1 << 6) // explosive blast damage +#define DMG_CLUB (1 << 7) // crowbar, punch, headbutt +#define DMG_SHOCK (1 << 8) // electric shock +#define DMG_SONIC (1 << 9) // sound pulse shockwave +#define DMG_ENERGYBEAM (1 << 10) // laser or other high energy beam +#define DMG_PREVENT_PHYSICS_FORCE (1 << 11) // Prevent a physics force +#define DMG_NEVERGIB (1 << 12) // with this bit OR'd in, no damage type will be able to gib victims upon death +#define DMG_ALWAYSGIB (1 << 13) // with this bit OR'd in, any damage type can be made to gib victims upon death. +#define DMG_DROWN (1 << 14) // Drowning + + +#define DMG_PARALYZE (1 << 15) // slows affected creature down +#define DMG_NERVEGAS (1 << 16) // nerve toxins, very bad +#define DMG_POISON (1 << 17) // blood poisoning - heals over time like drowning damage +#define DMG_RADIATION (1 << 18) // radiation exposure +#define DMG_DROWNRECOVER (1 << 19) // drowning recovery +#define DMG_ACID (1 << 20) // toxic chemicals or acid burns +#define DMG_SLOWBURN (1 << 21) // in an oven + +#define DMG_REMOVENORAGDOLL (1<<22) // with this bit OR'd in, no ragdoll will be created, and the target will be quietly removed. + // use this to kill an entity that you've already got a server-side ragdoll for + +#define DMG_PHYSGUN (1<<23) // Hit by manipulator. Usually doesn't do any damage. +#define DMG_PLASMA (1<<24) // Shot by Cremator +#define DMG_AIRBOAT (1<<25) // Hit by the airboat's gun + +#define DMG_DISSOLVE (1<<26) // Dissolving! +#define DMG_BLAST_SURFACE (1<<27) // A blast on the surface of water that cannot harm things underwater +#define DMG_DIRECT (1<<28) +#define DMG_BUCKSHOT (1<<29) // not quite a bullet. Little, rounder, different. + +#endif + +/** + * Does damage to an entity. + * This is a powerful function that allows you to specify + * who the attacker is, the damage type and also what weapon + * should be displayed in the hud kill message. + * Note that for entities that fire another entity (RPG's, Crossbow's, + * you have to pass the bullet's class, not the weapon's class ! + * It hasn't been tested how expensive this function is, as it + * uses the entity point_hurt. + * If you need a cheaper function use Entity_RemoveHealth(). + * + * @param entity Entity index. + * @param damage Amount of damage. + * @param attacker Entity Index of the attacker. + * @param damageType Use the DMG_ definations. + * @param fakeClassName Classname to fake, you can set this if you + * want a specific weapon to be shown in the HUD kill message. + * @return True on success, false otherwise. + */ +stock bool Entity_Hurt(int entity, int damage, int attacker=0, int damageType=DMG_GENERIC, const char fakeClassName[]="") +{ + static int point_hurt = INVALID_ENT_REFERENCE; + + if (point_hurt == INVALID_ENT_REFERENCE || !IsValidEntity(point_hurt)) { + point_hurt = EntIndexToEntRef(Entity_Create("point_hurt")); + + if (point_hurt == INVALID_ENT_REFERENCE) { + return false; + } + + DispatchSpawn(point_hurt); + } + + AcceptEntityInput(point_hurt, "TurnOn"); + SetEntProp(point_hurt, Prop_Data, "m_nDamage", damage); + SetEntProp(point_hurt, Prop_Data, "m_bitsDamageType", damageType); + Entity_PointHurtAtTarget(point_hurt, entity); + + if (fakeClassName[0] != '\0') { + Entity_SetClassName(point_hurt, fakeClassName); + } + + AcceptEntityInput(point_hurt, "Hurt", attacker); + AcceptEntityInput(point_hurt, "TurnOff"); + + if (fakeClassName[0] != '\0') { + Entity_SetClassName(point_hurt, "point_hurt"); + } + + return true; +} + +/* + * Gets the parent entity of an entity. + * + * @param entity Entity Index. + * @return Entity Index of the parent. + */ +stock int Entity_GetParent(int entity) +{ + return GetEntPropEnt(entity, Prop_Data, "m_pParent"); +} + +/* + * Clears the parent of an entity. + * + * @param entity Entity Index. + */ +stock void Entity_ClearParent(int entity) +{ + SetVariantString(""); + AcceptEntityInput(entity, "ClearParent"); +} + +/* + * Sets the parent entity of an entity. + * + * @param entity Entity Index. + * @param parentEntity Entity Index of the new parent. + * @noreturn + */ +stock void Entity_SetParent(int entity, int parentEntity) +{ + SetVariantString("!activator"); + AcceptEntityInput(entity, "SetParent", parentEntity); +} + + +/* + * Callback for Change_OverTime. + * Note that every parameter is a reference and can be changed during this callback. + * You can get the elapsed time since start by multiply tick with currentCall. + * + * @param entity Entity Index. + * @param interval The current interval from the current game time to execute the next call of this function. + * @param currentCall The current call number (0 is the 1st call at 0.0 seconds, 1 the 2nd call at tick*1 seconds, ...). + * @return When true this callback will be called again at the next defined tick, otherwise it won't. + */ +typedef Entity_ChangeOverTimeCallback = function bool (int &entity, float &interval, int ¤tCall); + +/* + * Creates a timer and provides a callback to change various things about an entity over time. + * + * @param entity Entity Index. + * @param interval Interval from the current game time to execute the given function. + * @noreturn + */ +stock void Entity_ChangeOverTime(int entity, float interval=0.1, Entity_ChangeOverTimeCallback valueCallback) +{ + DataPack dataPack = new DataPack(); + dataPack.WriteCell(EntIndexToEntRef(entity)); + dataPack.WriteFloat(interval); + dataPack.WriteCell(0); + dataPack.WriteFunction(valueCallback); + dataPack.Reset(); + __smlib_Timer_ChangeOverTime(null,dataPack); +} + +public Action __smlib_Timer_ChangeOverTime(Handle Timer, DataPack dataPack) +{ + int entity = EntRefToEntIndex(dataPack.ReadCell()); + if(!Entity_IsValid(entity)){ + return Plugin_Stop; + } + + float interval = dataPack.ReadFloat(); + int currentCall = dataPack.ReadCell(); + + Function callback = dataPack.ReadFunction(); + + any result; + Call_StartFunction(null, callback); + Call_PushCellRef(entity); + Call_PushFloatRef(interval); + Call_PushCellRef(currentCall); + Call_Finish(result); + + if(result == false){ + return Plugin_Stop; + } + + dataPack.Reset(true); + dataPack.WriteCell(EntIndexToEntRef(entity)); + dataPack.WriteFloat(interval); + dataPack.WriteCell(currentCall+1); + dataPack.WriteFunction(callback); + dataPack.Reset(); + CreateTimer(interval,__smlib_Timer_ChangeOverTime,dataPack); + return Plugin_Stop; +} + + +/** + * Gets the next child, entity is parent of. + * + * @param client Entity Index (of Parent) + * @param start Start Index. + * @return Entity Index or -1 if no entity was found. + */ +stock int Entity_GetNextChild(int parent, int start=0) +{ + for (int entity=start; entity <= 2048; entity++) { + + if (!Entity_IsValid(entity)) { + continue; + } + + if (entity > 0 && entity <= MaxClients && !IsClientConnected(entity)) { + continue; + } + + if (Entity_GetParent(entity) == parent) { + return entity; + } + } + + return INVALID_ENT_REFERENCE; +} +/** + * Gets the move/open direction of an entity (only available for func_door*, prop_door* and func_movelinear). + * Ex: if vec[2] is 1.0 a func_door moves straight up. + * + * @param entity Entity index. + * @param vec Vector. + * @noreturn + */ +stock void Entity_GetMoveDirection(int entity, float vec[3]) +{ + GetEntPropVector(entity, Prop_Data, "m_vecMoveDir", vec); +} +/** + * Sets the move/open direction of an entity (only available for func_door*, prop_door* and func_movelinear). + * Ex: if vec[2] is 1.0 a func_door moves straight up. + * + * @param entity Entity index. + * @param vec Vector. + * @noreturn + */ +stock void Entity_SetMoveDirection(int entity, const float vec[3]) +{ + SetEntPropVector(entity, Prop_Data, "m_vecMoveDir", vec); +} + +/** + * Returns if the entity will force close (won't be blockable by players and/or objects) or not when triggered to move. + * + * @param entity Entity index. + * @return True if the door will force close, otherwise false. + */ +stock bool Entity_GetForceClose(int entity) +{ + return view_as(GetEntProp(entity, Prop_Data, "m_bForceClosed")); +} + +/** + * Sets if the door should force close (souldn't be blockable by players and/or objects) or not when triggered to move. + * + * @param entity Entity index. + * @param forceClose If true the door will force close, otherwise it won't. + * @noreturn + */ +stock void Entity_SetForceClose(int entity, bool forceClose) +{ + SetEntProp(entity, Prop_Data, "m_bForceClosed", forceClose); +} + +/** + * Gets the speed of a moving entity (like doors: open close speed). + * + * @param entity Entity index. + * @return Speed of the entity. + */ +stock float Entity_GetSpeed(int entity) +{ + return GetEntPropFloat(entity, Prop_Data, "m_flSpeed"); +} + +/** + * Sets how fast an entity moves (like doors: open close speed). + * + * @param entity Entity index. + * @param speed The new speed of the entity. + * @noreturn + */ +stock void Entity_SetSpeed(int entity, float speed) +{ + SetEntPropFloat(entity, Prop_Data, "m_flSpeed", speed); +} + +/** + * Gets the damage of a moving entity when blocked (like doors when open or close and players and/or objects are between the entity and something else). + * Note: Negative values add health to the blocking entity. + * + * @param entity Entity index. + * @return Damage. + */ +stock float Entity_GetBlockDamage(int entity) +{ + return GetEntPropFloat(entity, Prop_Data, "m_flBlockDamage"); +} + +/** + * Sets the damage of a moving entity when blocked (like doors when open or close and players and/or objects are between the entity and something else). + * Note: Negative values add health to the blocking entity. + * + * @param entity Entity index. + * @param damage Damage. + * @noreturn + */ +stock void Entity_SetBlockDamage(int entity, float damage) +{ + SetEntPropFloat(entity, Prop_Data, "m_flBlockDamage", damage); +} + +/** + * Returns if the given entity is disabled or not. + * + * @param entity Entity index. + * @return True if entity is disabled, otherwise false. + */ +stock bool Entity_IsDisabled(int entity) +{ + return view_as(GetEntProp(entity, Prop_Data, "m_bDisabled", 1)); +} + +/** + * Disables the given entity. + * + * @param entity Entity index. + * @return True if successful otherwise false. + */ +stock bool Entity_Disable(int entity) +{ + return AcceptEntityInput(entity, "Disable"); +} + +/** + * Enables the given entity. + * + * @param entity Entity index. + * @return True if successful otherwise false. + */ +stock bool Entity_Enable(int entity) +{ + return AcceptEntityInput(entity, "Enable"); +} + + +// settings for m_takedamage taken from hl2sdk-ob-valve\game\shared\shareddefs.h +#define DAMAGE_NO 0 +#define DAMAGE_EVENTS_ONLY 1 // Call damage functions, but don't modify health +#define DAMAGE_YES 2 +#define DAMAGE_AIM 3 + +/** + * Sets the mode for an entity to take damage. + * Note: This is used to give a client god mode (DAMAGE_NO). + * + * @param entity Entity index. + * @param value Mode, use DAMAGE_* defines. + * @noreturn + */ +stock void Entity_SetTakeDamage(int entity, int value) +{ + SetEntProp(entity, Prop_Data, "m_takedamage", value, 1); +} + +/** + * Gets the mode for an entity to take damage. + * Note: When the return value is DAMAGE_NO then the client is using godmode. + * + * @param entity Entity index. + * @return Take damage mode (DAMAGE_*). + */ +stock int Entity_GetTakeDamage(int entity) +{ + return GetEntProp(entity, Prop_Data, "m_takedamage", 1); +} + +/** + * Sets the minimum of damage required to hurt this entity. + * Example: This is used to block any damage done by projectile weapons against a gun ship in Half-Life 2. + * + * @param entity Entity index. + * @param minDamage Minimum required damage. + * @noreturn + */ +stock void Entity_SetMinHealthDamage(int entity, int minDamage) +{ + SetEntProp(entity, Prop_Data, "m_iMinHealthDmg", minDamage); +} + +/** + * Gets the minimum of damage required to hurt this entity. + * Example: This is used to block any damage done by projectile weapons against a gun ship in Half-Life 2. + * + * @param entity Entity index. + * @return Minimum required damage. + */ +stock int Entity_GetMinHealthDamage(int entity) +{ + return GetEntProp(entity, Prop_Data, "m_iMinHealthDmg"); +} + +/** + * Gets an entity's color. + * + * @param entity Entity index + * @param color 4 dimensional array where [r,g,b,a] values are stored + * @noreturn + * @error Invalid entity index, or lack of mod compliance. + */ +stock void Entity_GetRenderColor(int entity, int color[4]) +{ + static bool gotconfig = false; + static char prop[32]; + + if (!gotconfig) { + Handle gc = LoadGameConfigFile("core.games"); + bool exists = GameConfGetKeyValue(gc, "m_clrRender", prop, sizeof(prop)); + delete gc; + + if (!exists) { + strcopy(prop, sizeof(prop), "m_clrRender"); + } + + gotconfig = true; + } + + int offset = GetEntSendPropOffs(entity, prop); + + if (offset <= 0) { + ThrowError("SetEntityRenderColor not supported by this mod"); + } + + for (int i=0; i < 4; i++) { + color[i] = GetEntData(entity, offset + i + 1, 1); + } +} + +/** + * Sets an entity's color. + * Doesn't change the value, if set to -1. + * + * @param entity Entity index + * @param r Amount of red (0-255) + * @param g Amount of green (0-255) + * @param b Amount of blue (0-255) + * @param a Amount of alpha (0-255) + * @noreturn + * @error Invalid entity index, or lack of mod compliance. + */ +stock void Entity_SetRenderColor(int entity, int r=-1, int g=-1, int b=-1, int a=-1) +{ + static bool gotconfig = false; + static char prop[32]; + + if (!gotconfig) { + Handle gc = LoadGameConfigFile("core.games"); + bool exists = GameConfGetKeyValue(gc, "m_clrRender", prop, sizeof(prop)); + delete gc; + + if (!exists) { + strcopy(prop, sizeof(prop), "m_clrRender"); + } + + gotconfig = true; + } + + int offset = GetEntSendPropOffs(entity, prop); + + if (offset <= 0) { + ThrowError("SetEntityRenderColor not supported by this mod"); + } + + if(r != -1) { + SetEntData(entity, offset, r, 1, true); + } + + if(g != -1) { + SetEntData(entity, offset + 1, g, 1, true); + } + + if(b != -1) { + SetEntData(entity, offset + 2, b, 1, true); + } + + if(a != -1) { + SetEntData(entity, offset + 3, a, 1, true); + } +} + +/** + * Sends the 'addouput' command to an entity. + * + * @param entity Entity Index. + * @param input Input command. + * @param activator Entity index which initiated the sequence of actions (-1 for a NULL entity). + * @param caller Entity index from which this event is sent (-1 for a NULL entity). + * @param outputid Unknown. + * @return True if successful, otherwise false. + */ +stock bool Entity_AddOutput(int entity, const char[] input, int activator=-1, int caller=-1, int outputid=0) +{ + SetVariantString(input); + return AcceptEntityInput(entity, "addoutput", activator, caller, outputid); +} diff --git a/include/smlib/files.inc b/include/smlib/files.inc new file mode 100644 index 0000000..235117d --- /dev/null +++ b/include/smlib/files.inc @@ -0,0 +1,453 @@ +#if defined _smlib_files_included + #endinput +#endif +#define _smlib_files_included + +#include +#include +#include + +/** + * Gets the Base name of a path. + * Examples: + * blub.txt -> "blub.txt" + * /sourcemod/extensions/example.ext.so -> "example.ext.so" + * + * @param path File path + * @param buffer String buffer array + * @param size Size of string buffer + * @noreturn + */ +stock void File_GetBaseName(const char[] path, char[] buffer, int size) +{ + if (path[0] == '\0') { + buffer[0] = '\0'; + return; + } + + int pos_start = FindCharInString(path, '/', true); + + if (pos_start == -1) { + pos_start = FindCharInString(path, '\\', true); + } + + pos_start++; + + strcopy(buffer, size, path[pos_start]); +} + +/** + * Gets the Directory of a path (without the file name). + * Does not work with "." as the path. + * Examples: + * blub.txt -> "blub.txt" + * /sourcemod/extensions/example.ext.so -> "example.ext.so" + * + * @param path File path + * @param buffer String buffer array + * @param size Size of string buffer + * @noreturn + */ +stock void File_GetDirName(const char[] path, char[] buffer, int size) +{ + if (path[0] == '\0') { + buffer[0] = '\0'; + return; + } + + int pos_start = FindCharInString(path, '/', true); + + if (pos_start == -1) { + pos_start = FindCharInString(path, '\\', true); + + if (pos_start == -1) { + buffer[0] = '\0'; + return; + } + } + + strcopy(buffer, size, path); + buffer[pos_start] = '\0'; +} + +/** + * Gets the File name of a path. + * blub.txt -> "blub" + * /sourcemod/extensions/example.ext.so -> "example.ext" + * + * @param path File path + * @param buffer String buffer array + * @param size Size of string buffer + * @noreturn + */ +stock void File_GetFileName(const char[] path, char[] buffer, int size) +{ + if (path[0] == '\0') { + buffer[0] = '\0'; + return; + } + + File_GetBaseName(path, buffer, size); + + int pos_ext = FindCharInString(buffer, '.', true); + + if (pos_ext != -1) { + buffer[pos_ext] = '\0'; + } +} + +/** + * Gets the Extension of a file. + * Examples: + * blub.inc.txt -> "txt" + * /sourcemod/extensions/example.ext.so -> "so" + * + * @param path Path String + * @param buffer String buffer array + * @param size Max length of string buffer + * @noreturn + */ +stock void File_GetExtension(const char[] path, char[] buffer, int size) +{ + int extpos = FindCharInString(path, '.', true); + + if (extpos == -1) { + buffer[0] = '\0'; + return; + } + + strcopy(buffer, size, path[++extpos]); +} + +/** + * Adds a path to the downloadables network string table. + * This can be a file or directory and also works recursed. + * You can optionally specify file extensions that should be ignored. + * Bz2 and ztmp are automatically ignored. + * It only adds files that actually exist. + * You can also specify a wildcard * after the ., very useful for models. + * This forces a client to download the file if they do not already have it. + * + * @param path Path String + * @param recursive Whether to do recursion or not. + * @param ignoreExts Optional: 2 dimensional String array.You can define it like this: char ignore[][] = { ".ext1", ".ext2" }; + * @param size This should be set to the number of file extensions in the ignoreExts array (sizeof(ignore) for the example above) + * @noreturn + */ + +// Damn you SourcePawn :( I didn't want to +char _smlib_empty_twodimstring_array[][] = { { '\0' } }; +stock void File_AddToDownloadsTable(const char[] path, bool recursive=true, const char ignoreExts[][]=_smlib_empty_twodimstring_array, int size=0) +{ + if (path[0] == '\0') { + return; + } + + if (FileExists(path)) { + + char fileExtension[4]; + File_GetExtension(path, fileExtension, sizeof(fileExtension)); + + if (StrEqual(fileExtension, "bz2", false) || StrEqual(fileExtension, "ztmp", false)) { + return; + } + + if (Array_FindString(ignoreExts, size, fileExtension) != -1) { + return; + } + + char path_new[PLATFORM_MAX_PATH]; + strcopy(path_new, sizeof(path_new), path); + ReplaceString(path_new, sizeof(path_new), "//", "/"); + + AddFileToDownloadsTable(path_new); + } + else if (recursive && DirExists(path)) { + + char dirEntry[PLATFORM_MAX_PATH]; + DirectoryListing __dir = OpenDirectory(path); + + while (__dir.GetNext(dirEntry, sizeof(dirEntry))) { + + if (StrEqual(dirEntry, ".") || StrEqual(dirEntry, "..")) { + continue; + } + + Format(dirEntry, sizeof(dirEntry), "%s/%s", path, dirEntry); + File_AddToDownloadsTable(dirEntry, recursive, ignoreExts, size); + } + + delete __dir; + } + else if (FindCharInString(path, '*', true)) { + + char fileExtension[4]; + File_GetExtension(path, fileExtension, sizeof(fileExtension)); + + if (StrEqual(fileExtension, "*")) { + + char dirName[PLATFORM_MAX_PATH], fileName[PLATFORM_MAX_PATH], dirEntry[PLATFORM_MAX_PATH]; + + File_GetDirName(path, dirName, sizeof(dirName)); + File_GetFileName(path, fileName, sizeof(fileName)); + StrCat(fileName, sizeof(fileName), "."); + + DirectoryListing __dir = OpenDirectory(dirName); + while (__dir.GetNext(dirEntry, sizeof(dirEntry))) { + + if (StrEqual(dirEntry, ".") || StrEqual(dirEntry, "..")) { + continue; + } + + if (strncmp(dirEntry, fileName, strlen(fileName)) == 0) { + Format(dirEntry, sizeof(dirEntry), "%s/%s", dirName, dirEntry); + File_AddToDownloadsTable(dirEntry, recursive, ignoreExts, size); + } + } + + delete __dir; + } + } + + return; +} + + +/* + * Adds all files/paths in the given text file to the download table. + * Recursive mode enabled, see File_AddToDownloadsTable() + * Comments are allowed ! Supported comment types are ; // # + * + * @param path Path to the .txt file. + * @noreturn + */ +stock void File_ReadDownloadList(const char[] path) +{ + File file = OpenFile(path, "r"); + + if (file == null) { + return; + } + + char buffer[PLATFORM_MAX_PATH]; + while (!file.EndOfFile()) { + file.ReadLine(buffer, sizeof(buffer)); + + int pos; + pos = StrContains(buffer, "//"); + if (pos != -1) { + buffer[pos] = '\0'; + } + + pos = StrContains(buffer, "#"); + if (pos != -1) { + buffer[pos] = '\0'; + } + + pos = StrContains(buffer, ";"); + if (pos != -1) { + buffer[pos] = '\0'; + } + + TrimString(buffer); + + if (buffer[0] == '\0') { + continue; + } + + File_AddToDownloadsTable(buffer); + } + + delete file; +} + +/* + * Attempts to load a translation file and optionally unloads the plugin if the file + * doesn't exist (also prints an error message). + * + * @param file Filename of the translations file (eg. .phrases). + * @param setFailState If true, it sets the failstate if the translations file doesn't exist + * @return True on success, false otherwise (only if setFailState is set to false) + */ +stock bool File_LoadTranslations(const char[] file, const bool setFailState=false) +{ + char path[PLATFORM_MAX_PATH]; + + BuildPath(Path_SM, path, sizeof(path), "translations/%s", file); + + if (FileExists(path)) { + LoadTranslations(file); + return true; + } + + Format(path, sizeof(path), "%s.txt", path); + + if (!FileExists(path)) { + + if (setFailState) { + SetFailState("Unable to locate translation file (%s).", path); + } + + return false; + } + + LoadTranslations(file); + + return true; +} + +/* + * Reads the contents of a given file into a string buffer in binary mode. + * + * @param path Path to the file + * @param buffer String buffer + * @param size If -1, reads until a null terminator is encountered in the file. Otherwise, read_count bytes are read into the buffer provided. In this case the buffer is not explicitly null terminated, and the buffer will contain any null terminators read from the file. + * @return Number of characters written to the buffer, or -1 if an error was encountered. + */ +stock int File_ToString(const char[] path, char[] buffer, int size) +{ + File file = OpenFile(path, "rb"); + + if (file == null) { + buffer[0] = '\0'; + return -1; + } + + int num_bytes_written = file.ReadString(buffer, size); + delete file; + + return num_bytes_written; +} + +/* + * Writes a string into a file in binary mode. + * + * @param file Path to the file + * @param str String to write + * @return True on success, false otherwise + */ +stock bool File_StringToFile(const char[] path, char[] str) +{ + File file = OpenFile(path, "wb"); + + if (file == null) { + return false; + } + + bool success = file.WriteString(str, false); + delete file; + + return success; +} + +/* + * Copies file source to destination + * Based on code of javalia: + * http://forums.alliedmods.net/showthread.php?t=159895 + * + * @param source Input file + * @param destination Output file + */ +stock bool File_Copy(const char[] source, const char[] destination) +{ + File file_source = OpenFile(source, "rb"); + + if (file_source == null) { + return false; + } + + File file_destination = OpenFile(destination, "wb"); + + if (file_destination == null) { + delete file_source; + return false; + } + + int buffer[32]; + int cache; + + while (!file_source.EndOfFile()) { + cache = file_source.Read(buffer, 32, 1); + file_destination.Write(buffer, cache, 1); + } + + delete file_source; + delete file_destination; + + return true; +} + +/* + * Recursively copies (the content) of a directory or file specified + * by "path" to "destination". + * Note that because of Sourcemod API limitations this currently does not + * takeover the file permissions (it leaves them default). + * Links will be resolved. + * + * @param path Source path + * @param destination Destination directory (This can only be a directory) + * @param stop_on_error Optional: Set to true to stop on error (ie can't read a file) + * @param dirMode Optional: File mode for directories that will be created (Default = 0755), don't forget to convert FROM octal + */ +stock bool File_CopyRecursive(const char[] path, const char[] destination, bool stop_on_error=false, int dirMode=493) +{ + if (FileExists(path)) { + return File_Copy(path, destination); + } + else if (DirExists(path)) { + return Sub_File_CopyRecursive(path, destination, stop_on_error, FileType_Directory, dirMode); + } + else { + return false; + } +} + +static stock bool Sub_File_CopyRecursive(const char[] path, const char[] destination, bool stop_on_error=false, FileType fileType, int dirMode) +{ + if (fileType == FileType_File) { + return File_Copy(path, destination); + } + else if (fileType == FileType_Directory) { + + if (!CreateDirectory(destination, dirMode) && stop_on_error) { + return false; + } + + DirectoryListing directory = OpenDirectory(path); + + if (directory == null) { + return false; + } + + char source_buffer[PLATFORM_MAX_PATH], destination_buffer[PLATFORM_MAX_PATH]; + FileType type; + + while (directory.GetNext(source_buffer, sizeof(source_buffer), type)) { + + if (StrEqual(source_buffer, "..") || StrEqual(source_buffer, ".")) { + continue; + } + + Format(destination_buffer, sizeof(destination_buffer), "%s/%s", destination, source_buffer); + Format(source_buffer, sizeof(source_buffer), "%s/%s", path, source_buffer); + + if (type == FileType_File) { + File_Copy(source_buffer, destination_buffer); + } + else if (type == FileType_Directory) { + + if (!File_CopyRecursive(source_buffer, destination_buffer, stop_on_error, dirMode) && stop_on_error) { + delete directory; + return false; + } + } + } + + delete directory; + } + else if (fileType == FileType_Unknown) { + return false; + } + + return true; +} diff --git a/include/smlib/game.inc b/include/smlib/game.inc new file mode 100644 index 0000000..ab3298f --- /dev/null +++ b/include/smlib/game.inc @@ -0,0 +1,58 @@ +#if defined _smlib_game_included + #endinput +#endif +#define _smlib_game_included + +#include +#include +#include + +/* + * End's the game and displays the scoreboard with intermission time. + * + * @noparam + * @return True on success, false otherwise + */ +stock bool Game_End() +{ + int game_end = FindEntityByClassname(-1, "game_end"); + + if (game_end == -1) { + game_end = CreateEntityByName("game_end"); + + if (game_end == -1) { + ThrowError("Unable to find or create entity \"game_end\""); + } + } + + return AcceptEntityInput(game_end, "EndGame"); +} + +/* + * End's the current round, allows specifying the winning + * team and more. + * This function currently works in TF2 only (it uses the game_round_win entity). + * + * @param team The winning Team, pass 0 for Sudden Death mode (no winning team) + * @param forceMapReset If to force the map to reset during the force respawn after the round is over. + * @param switchTeams If to switch the teams when the game is going to be reset. + * @return True on success, false otherwise + */ +stock bool Game_EndRound(int team=0, bool forceMapReset=false, bool switchTeams=false) +{ + int game_round_win = FindEntityByClassname(-1, "game_round_win"); + + if (game_round_win == -1) { + game_round_win = CreateEntityByName("game_round_win"); + + if (game_round_win == -1) { + ThrowError("Unable to find or create entity \"game_round_win\""); + } + } + + DispatchKeyValue(game_round_win, "TeamNum" , (team ? "true" : "false")); + DispatchKeyValue(game_round_win, "force_map_reset" , (forceMapReset? "true" : "false")); + DispatchKeyValue(game_round_win, "switch_teams" , (switchTeams ? "true" : "false")); + + return AcceptEntityInput(game_round_win, "RoundWin"); +} diff --git a/include/smlib/general.inc b/include/smlib/general.inc new file mode 100644 index 0000000..2f125d2 --- /dev/null +++ b/include/smlib/general.inc @@ -0,0 +1,251 @@ +#if defined _smlib_general_included + #endinput +#endif +#define _smlib_general_included + +#include +#include +#include + +#define TIME_TO_TICKS(%1) ( (int)( 0.5 + (float)(%1) / GetTickInterval() ) ) +#define TICKS_TO_TIME(%1) ( GetTickInterval() * %1 ) +#define ROUND_TO_TICKS(%1) ( TICK_INTERVAL * TIME_TO_TICKS( %1 ) ) + +/* + * Precaches the given model. + * It's best to call this OnMapStart(). + * + * @param material Path of the material to precache. + * @return Returns the material index, INVALID_STRING_INDEX on error. + */ +stock int PrecacheMaterial(const char[] material) +{ + static int materialNames = INVALID_STRING_TABLE; + + if (materialNames == INVALID_STRING_TABLE) { + if ((materialNames = FindStringTable("Materials")) == INVALID_STRING_TABLE) { + return INVALID_STRING_INDEX; + } + } + + int index = FindStringIndex2(materialNames, material); + if (index == INVALID_STRING_INDEX) { + int numStrings = GetStringTableNumStrings(materialNames); + if (numStrings >= GetStringTableMaxStrings(materialNames)) { + return INVALID_STRING_INDEX; + } + + AddToStringTable(materialNames, material); + index = numStrings; + } + + return index; +} + +/* + * Checks if the material is precached. + * + * @param material Path of the material. + * @return True if it is precached, false otherwise. + */ +stock bool IsMaterialPrecached(const char[] material) +{ + static int materialNames = INVALID_STRING_TABLE; + + if (materialNames == INVALID_STRING_TABLE) { + if ((materialNames = FindStringTable("Materials")) == INVALID_STRING_TABLE) { + return false; + } + } + + return (FindStringIndex2(materialNames, material) != INVALID_STRING_INDEX); +} + +/* + * Precaches the given particle system. + * It's best to call this OnMapStart(). + * Code based on Rochellecrab's, thanks. + * + * @param particleSystem Name of the particle system to precache. + * @return Returns the particle system index, INVALID_STRING_INDEX on error. + */ +stock int PrecacheParticleSystem(const char[] particleSystem) +{ + static int particleEffectNames = INVALID_STRING_TABLE; + + if (particleEffectNames == INVALID_STRING_TABLE) { + if ((particleEffectNames = FindStringTable("ParticleEffectNames")) == INVALID_STRING_TABLE) { + return INVALID_STRING_INDEX; + } + } + + int index = FindStringIndex2(particleEffectNames, particleSystem); + if (index == INVALID_STRING_INDEX) { + int numStrings = GetStringTableNumStrings(particleEffectNames); + if (numStrings >= GetStringTableMaxStrings(particleEffectNames)) { + return INVALID_STRING_INDEX; + } + + AddToStringTable(particleEffectNames, particleSystem); + index = numStrings; + } + + return index; +} + +/* + * Checks if the particle system is precached. + * + * @param material Name of the particle system + * @return True if it is precached, false otherwise. + */ +stock bool IsParticleSystemPrecached(const char[] particleSystem) +{ + static int particleEffectNames = INVALID_STRING_TABLE; + + if (particleEffectNames == INVALID_STRING_TABLE) { + if ((particleEffectNames = FindStringTable("ParticleEffectNames")) == INVALID_STRING_TABLE) { + return false; + } + } + + return (FindStringIndex2(particleEffectNames, particleSystem) != INVALID_STRING_INDEX); +} + +/* + * Searches for the index of a given string in a string table. + * + * @param table String table name. + * @param str String to find. + * @return String index if found, INVALID_STRING_INDEX otherwise. + */ +stock int FindStringIndexByTableName(const char[] table, const char[] str) +{ + int tableIndex = INVALID_STRING_TABLE; + if ((tableIndex = FindStringTable("ParticleEffectNames")) == INVALID_STRING_TABLE) { + return INVALID_STRING_INDEX; + } + + return FindStringIndex2(tableIndex, str); +} + +/* + * Rewrite of FindStringIndex, because in my tests + * FindStringIndex failed to work correctly. + * Searches for the index of a given string in a string table. + * + * @param tableidx A string table index. + * @param str String to find. + * @return String index if found, INVALID_STRING_INDEX otherwise. + */ +stock int FindStringIndex2(int tableidx, const char[] str) +{ + char buf[1024]; + + int numStrings = GetStringTableNumStrings(tableidx); + for (int i=0; i < numStrings; i++) { + ReadStringTable(tableidx, i, buf, sizeof(buf)); + + if (StrEqual(buf, str)) { + return i; + } + } + + return INVALID_STRING_INDEX; +} + +/* + * Converts a long IP to a dotted format String. + * + * @param ip IP Long + * @param buffer String Buffer (size = 16) + * @param size String Buffer size + * @noreturn + */ +stock void LongToIP(int ip, char[] buffer, int size) +{ + Format( + buffer, size, + "%d.%d.%d.%d", + (ip >> 24) & 0xFF, + (ip >> 16) & 0xFF, + (ip >> 8 ) & 0xFF, + ip & 0xFF + ); +} + +/* + * Converts a dotted format String IP to a long. + * + * @param ip IP String + * @return Long IP + */ +stock int IPToLong(const char[] ip) +{ + char pieces[4][4]; + + if (ExplodeString(ip, ".", pieces, sizeof(pieces), sizeof(pieces[])) != 4) { + return 0; + } + + return ( + StringToInt(pieces[0]) << 24 | + StringToInt(pieces[1]) << 16 | + StringToInt(pieces[2]) << 8 | + StringToInt(pieces[3]) + ); +} + +static int localIPRanges[] = +{ + 10 << 24, // 10. + 127 << 24 | 1 , // 127.0.0.1 + 127 << 24 | 16 << 16, // 127.16. + 192 << 24 | 168 << 16, // 192.168. +}; + +/* + * Checks whether an IP is a private/internal IP + * + * @param ip IP Long + * @return True if the IP is local, false otherwise. + */ +stock bool IsIPLocal(int ip) +{ + int range, bits, move; + bool matches; + + for (int i=0; i < sizeof(localIPRanges); i++) { + + range = localIPRanges[i]; + matches = true; + + for (int j=0; j < 4; j++) { + move = j * 8; + bits = (range >> move) & 0xFF; + + if (bits && bits != ((ip >> move) & 0xFF)) { + matches = false; + } + } + + if (matches) { + return true; + } + } + + return false; +} + +/* + * Closes the given hindle and sets it to null. + * + * @param handle handle + * @noreturn + */ +stock void ClearHandle(Handle &handle) +{ + if (handle != null) { + delete handle; + } +} diff --git a/include/smlib/math.inc b/include/smlib/math.inc new file mode 100644 index 0000000..dbd0f0b --- /dev/null +++ b/include/smlib/math.inc @@ -0,0 +1,344 @@ +#if defined _smlib_math_included + #endinput +#endif +#define _smlib_math_included + +#include + +#define SIZE_OF_INT 2147483647 // without 0 +#define INT_MAX_DIGITS 10 + +#define GAMEUNITS_TO_METERS 0.01905 +#define METERS_TO_GAMEUNITS 52.49343832020997 +#define METERS_TO_FEET 3.2808399 +#define FEET_TO_METERS 0.3048 +#define KILOMETERS_TO_MILES 0.62137 + +enum VecAngle +{ + ANG_ALPHA, + ANG_BETA, + ANG_GAMMA +} + +/** + * Makes a negative integer number to a positive integer number. + * This is faster than Sourcemod's native FloatAbs() for integers. + * Use FloatAbs() for Float numbers. + * + * @param number A number that can be positive or negative. + * @return Positive number. + */ +stock any Math_Abs(any value) +{ + return (value ^ (value >> 31)) - (value >> 31); +} + +/** + * Checks if 2 vectors are equal. + * You can specfiy a tolerance, which is the maximum distance at which vectors are considered equals + * + * @param vec1 First vector (3 dim array) + * @param vec2 Second vector (3 dim array) + * @param tolerance If you want to check that those vectors are somewhat even. 0.0 means they are 100% even if this function returns true. + * @return True if vectors are equal, false otherwise. + */ +stock bool Math_VectorsEqual(float vec1[3], float vec2[3], float tolerance=0.0) +{ + float distance = GetVectorDistance(vec1, vec2, true); + + return distance <= (tolerance * tolerance); +} + +/** + * Sets the given value to min + * if the value is smaller than the given. + * + * @param value Value + * @param min Min Value used as lower border + * @return Correct value not lower than min + */ +stock any Math_Min(any value, any min) +{ + if (value < min) { + value = min; + } + + return value; +} + +/** + * Sets the given value to max + * if the value is greater than the given. + * + * @param value Value + * @param max Max Value used as upper border + * @return Correct value not upper than max + */ +stock any Math_Max(any value, any max) +{ + if (value > max) { + value = max; + } + + return value; +} + +/** + * Makes sure a value is within a certain range and + * returns the value. + * If the value is outside the range it is set to either + * min or max, if it is inside the range it will just return + * the specified value. + * + * @param value Value + * @param min Min value used as lower border + * @param max Max value used as upper border + * @return Correct value not lower than min and not greater than max. + */ +stock any Math_Clamp(any value, any min, any max) +{ + value = Math_Min(value, min); + value = Math_Max(value, max); + + return value; +} + +/* + * Checks if the value is within the given bounds (min & max). + * + * @param value The value you want to check. + * @param min The lower border. + * @param max The upper border. + * @return True if the value is within bounds (bigger or equal min / smaller or equal max), false otherwise. + */ +stock bool Math_IsInBounds(any value, any min, any max) +{ + if (value < min || value > max) { + return false; + } + + return true; +} + +/** + * Let's the specified value "overflow" if it is outside the given limit. + * This is like with integers when it reaches a value above the max possible + * integer size. + * + * @param value Value + * @param min Min value used as lower border + * @param max Max value used as upper border + * @return Overflowed number + */ +stock any Math_Overflow(any value, any min, any max) +{ + return (value % max) + min; +} + +/** + * Returns a random, uniform Integer number in the specified (inclusive) range. + * This is safe to use multiple times in a function. + * The seed is set automatically for each plugin. + * Rewritten by MatthiasVance, thanks. + * + * @param min Min value used as lower border + * @param max Max value used as upper border + * @return Random Integer number between min and max + */ +stock int Math_GetRandomInt(int min, int max) +{ + int random = GetURandomInt(); + + if (random == 0) { + random++; + } + + return RoundToCeil(float(random) / (float(SIZE_OF_INT) / float(max - min + 1))) + min - 1; +} + +/** + * Returns a random, uniform Float number in the specified (inclusive) range. + * This is safe to use multiple times in a function. + * The seed is set automatically for each plugin. + * + * @param min Min value used as lower border + * @param max Max value used as upper border + * @return Random Float number between min and max + */ +stock float Math_GetRandomFloat(float min, float max) +{ + return (GetURandomFloat() * (max - min)) + min; +} + +/** + * Gets the percentage of amount in all as Integer where + * amount and all are numbers and amount usually + * is a subset of all. + * + * @param value Integer value + * @param all Integer value + * @return An Integer value between 0 and 100 (inclusive). + */ +stock int Math_GetPercentage(int value, int all) { + return RoundToNearest((float(value) / float(all)) * 100.0); +} + +/** + * Gets the percentage of amount in all as Float where + * amount and all are numbers and amount usually + * is a subset of all. + * + * @param value Float value + * @param all Float value + * @return A Float value between 0.0 and 100.0 (inclusive). + */ +stock float Math_GetPercentageFloat(float value, float all) { + return (value / all) * 100.0; +} + +/* + * Moves the start vector on a direct line to the end vector by the given scale. + * Note: If scale is 0.0 the output will be the same as the start vector and if scale is 1.0 the output vector will be the same as the end vector. + * Exmaple usage: Move an entity to another entity but only 12 units: Vector_MoveVector(entity1Origin,entity2Origin,(12.0 / GetVectorDistance(entity1Origin,entity2Origin)),newEntity1Origin); now only teleport your entity to newEntity1Origin. + * + * @param start The start vector where the imagined line starts. + * @param end The end vector where the imagined line ends. + * @param scale The position on the line 0.0 is the start 1.0 is the end. + * @param output Output vector + * @noreturn + */ +stock void Math_MoveVector(const float start[3], const float end[3], float scale, float output[3]) +{ + SubtractVectors(end,start,output); + ScaleVector(output,scale); + AddVectors(start,output,output); +} + +/** + * Puts x, y and z into a vector. + * + * @param x Float value. + * @param y Float value. + * @param z Float value. + * @param result Output vector. + * @noreturn + */ +stock void Math_MakeVector(const float x, const float y, const float z, float result[3]) +{ + result[0] = x; + result[1] = y; + result[2] = z; +} + +/** + * Rotates a vector around its zero-point. + * Note: As example you can rotate mins and maxs of an entity and then add its origin to mins and maxs to get its bounding box in relation to the world and its rotation. + * When used with players use the following angle input: + * angles[0] = 0.0; + * angles[1] = 0.0; + * angles[2] = playerEyeAngles[1]; + * + * @param vec Vector to rotate. + * @param angles How to rotate the vector. + * @param result Output vector. + * @noreturn + */ +stock void Math_RotateVector(const float vec[3], const float angles[3], float result[3]) +{ + // First the angle/radiant calculations + float rad[3]; + // I don't really know why, but the alpha, beta, gamma order of the angles are messed up... + // 2 = xAxis + // 0 = yAxis + // 1 = zAxis + rad[0] = DegToRad(angles[2]); + rad[1] = DegToRad(angles[0]); + rad[2] = DegToRad(angles[1]); + + // Pre-calc function calls + float cosAlpha = Cosine(rad[0]); + float sinAlpha = Sine(rad[0]); + float cosBeta = Cosine(rad[1]); + float sinBeta = Sine(rad[1]); + float cosGamma = Cosine(rad[2]); + float sinGamma = Sine(rad[2]); + + // 3D rotation matrix for more information: http://en.wikipedia.org/wiki/Rotation_matrix#In_three_dimensions + float x = vec[0], y = vec[1], z = vec[2]; + float newX, newY, newZ; + newY = cosAlpha*y - sinAlpha*z; + newZ = cosAlpha*z + sinAlpha*y; + y = newY; + z = newZ; + + newX = cosBeta*x + sinBeta*z; + newZ = cosBeta*z - sinBeta*x; + x = newX; + z = newZ; + + newX = cosGamma*x - sinGamma*y; + newY = cosGamma*y + sinGamma*x; + x = newX; + y = newY; + + // Store everything... + result[0] = x; + result[1] = y; + result[2] = z; +} + +/** + * Converts Source Game Units to metric Meters + * + * @param units Float value + * @return Meters as Float value. + */ +stock float Math_UnitsToMeters(float units) +{ + return (units * GAMEUNITS_TO_METERS); +} + +/** + * Converts Source Game Units to Meters + * + * @param units Float value + * @return Feet as Float value. + */ +stock float Math_UnitsToFeet(float units) +{ + return (Math_UnitsToMeters(units) * METERS_TO_FEET); +} + +/** + * Converts Source Game Units to Centimeters + * + * @param units Float value + * @return Centimeters as Float value. + */ +stock float Math_UnitsToCentimeters(float units) +{ + return (Math_UnitsToMeters(units) * 100.0); +} + +/** + * Converts Source Game Units to Kilometers + * + * @param units Float value + * @return Kilometers as Float value. + */ +stock float Math_UnitsToKilometers(float units) +{ + return (Math_UnitsToMeters(units) / 1000.0); +} + +/** + * Converts Source Game Units to Miles + * + * @param units Float value + * @return Miles as Float value. + */ +stock float Math_UnitsToMiles(float units) +{ + return (Math_UnitsToKilometers(units) * KILOMETERS_TO_MILES); +} diff --git a/include/smlib/menus.inc b/include/smlib/menus.inc new file mode 100644 index 0000000..1546875 --- /dev/null +++ b/include/smlib/menus.inc @@ -0,0 +1,38 @@ +#if defined _smlib_menus_included + #endinput +#endif +#define _smlib_menus_included + +#include +#include + +/** + * Adds an option to a menu with a String display but an integer + * identifying the option. + * + * @param menu Handle to the menu + * @param value Integer value for the option + * @param display Display text for the menu + * @noreturn + */ +stock void Menu_AddIntItem(Menu menu, any value, char[] display) +{ + char buffer[INT_MAX_DIGITS + 1]; + IntToString(value, buffer, sizeof(buffer)); + menu.AddItem(buffer, display); +} + +/** + * Retrieves an integer-value choice from a menu, where the + * menu's information strings were created as integers. + * + * @param menu Handle to the menu + * @param param2 The item position selected from the menu. + * @return Integer choice from the menu, or 0 if the integer could not be parsed. + */ +stock any Menu_GetIntItem(Menu menu, any param2) +{ + char buffer[INT_MAX_DIGITS + 1]; + menu.GetItem(param2, buffer, sizeof(buffer)); + return StringToInt(buffer); +} diff --git a/include/smlib/server.inc b/include/smlib/server.inc new file mode 100644 index 0000000..35c871d --- /dev/null +++ b/include/smlib/server.inc @@ -0,0 +1,135 @@ +#if defined _smlib_server_included + #endinput +#endif +#define _smlib_server_included + +#include +#include + +/* + * Gets the server's public/external (default) or + * private/local (usually server's behind a NAT) IP. + * If your server is behind a NAT Router, you need the SteamTools + * extension available at http://forums.alliedmods.net/showthread.php?t=129763 + * to get the public IP. has to be included BEFORE . + * If the server is not behind NAT, the public IP is the same as the private IP. + * + * @param public Set to true to retrieve the server's public/external IP, false otherwise. + * @return Long IP or 0 if the IP couldn't be retrieved. + */ +stock int Server_GetIP(bool public_=true) +{ + int ip = 0; + + static ConVar cvHostip; + + if (cvHostip == null) { + cvHostip = FindConVar("hostip"); + MarkNativeAsOptional("Steam_GetPublicIP"); + } + + if (cvHostip != null) { + ip = cvHostip.IntValue; + } + + if (ip != 0 && IsIPLocal(ip) == public_) { + ip = 0; + } + +#if defined _steamtools_included + if (ip == 0) { + if (CanTestFeatures() && GetFeatureStatus(FeatureType_Native, "Steam_GetPublicIP") == FeatureStatus_Available) { + int octets[4]; + Steam_GetPublicIP(octets); + + ip = + octets[0] << 24 | + octets[1] << 16 | + octets[2] << 8 | + octets[3]; + + if (IsIPLocal(ip) == public_) { + ip = 0; + } + } + } +#endif + + return ip; +} + +/* + * Gets the server's public/external (default) or + * private/local (usually server's behind a NAT) as IP String in dotted format. + * If your server is behind a NAT Router, you need the SteamTools + * extension available at http://forums.alliedmods.net/showthread.php?t=129763 + * to get the public IP. has to be included BEFORE . + * If the public IP couldn't be found, an empty String is returned. + * If the server is not behind NAT, the public IP is the same as the private IP. + * + * @param buffer String buffer (size=16) + * @param size String buffer size. + * @param public Set to true to retrieve the server's public/external IP, false otherwise. + * @return True on success, false otherwise. + */ +stock bool Server_GetIPString(char[] buffer, int size, bool public_=true) +{ + int ip; + + if ((ip = Server_GetIP(public_)) == 0) { + buffer[0] = '\0'; + return false; + } + + LongToIP(ip, buffer, size); + + return true; +} + +/* + * Gets the server's local port. + * + * @noparam + * @return The server's port, 0 if there is no port. + */ +stock int Server_GetPort() +{ + static ConVar cvHostport; + + if (cvHostport == null) { + cvHostport = FindConVar("hostport"); + } + + if (cvHostport == null) { + return 0; + } + + int port = cvHostport.IntValue; + + return port; +} + +/* + * Gets the server's hostname + * + * @param hostname String buffer + * @param size String buffer size + * @return True on success, false otherwise. + */ +stock bool Server_GetHostName(char[] buffer, int size) +{ + static ConVar cvHostname; + + if (cvHostname == null) { + cvHostname = FindConVar("hostname"); + } + + if (cvHostname == null) { + buffer[0] = '\0'; + return false; + } + + cvHostname.GetString(buffer, size); + + return true; +} diff --git a/include/smlib/sql.inc b/include/smlib/sql.inc new file mode 100644 index 0000000..360b71a --- /dev/null +++ b/include/smlib/sql.inc @@ -0,0 +1,108 @@ +#if defined _smlib_sql_included + #endinput +#endif +#define _smlib_sql_included + +#include +#include + +/** + * Executes a threaded SQL Query (See: SQL_TQuery) + * This function supports the printf Syntax. + * + * + * @param database A database Handle. + * @param callback Callback; database is in "owner" and the query Handle is passed in "hndl". + * @param data Extra data value to pass to the callback. + * @param format Query string, printf syntax supported + * @param priority Priority queue to use + * @param ... Variable number of format parameters. + * @noreturn + */ +stock void SQL_TQueryF(Database database, SQLTCallback callback, any data, DBPriority priority=DBPrio_Normal, const char[] format, any ...) { + + if (database == null) { + ThrowError("[SMLIB] Error: Invalid database handle."); + return; + } + + char query[16384]; + VFormat(query, sizeof(query), format, 6); + + SQL_TQuery(database, callback, query, data, priority); +} + +/** + * Fetches an integer from a field in the current row of a result set (See: SQL_FetchInt) + * + * @param query A query (or statement) Handle. + * @param field The field index (starting from 0). + * @param result Optional variable to store the status of the return value. + * @return An integer value. + * @error Invalid query Handle or field index, invalid + * type conversion requested from the database, + * or no current result set. + */ +stock int SQL_FetchIntByName(Handle query, char[] fieldName, DBResult &result=DBVal_Error) { + + int fieldNum; + SQL_FieldNameToNum(query, fieldName, fieldNum); + + return SQL_FetchInt(query, fieldNum, result); +} + +/** + * Fetches a bool from a field in the current row of a result set (See: SQL_FetchInt) + * + * @param query A query (or statement) Handle. + * @param field The field index (starting from 0). + * @param result Optional variable to store the status of the return value. + * @return A bool value. + * @error Invalid query Handle or field index, invalid + * type conversion requested from the database, + * or no current result set. + */ +stock bool SQL_FetchBoolByName(Handle query, char[] fieldName, DBResult &result=DBVal_Error) { + + return view_as(SQL_FetchIntByName(query, fieldName, result)); +} + +/** + * Fetches a float from a field in the current row of a result set. (See: SQL_FetchFloat) + * + * @param query A query (or statement) Handle. + * @param field The field index (starting from 0). + * @param result Optional variable to store the status of the return value. + * @return A float value. + * @error Invalid query Handle or field index, invalid + * type conversion requested from the database, + * or no current result set. + */ +stock float SQL_FetchFloatByName(Handle query, char[] fieldName, DBResult &result=DBVal_Error) { + + int fieldNum; + SQL_FieldNameToNum(query, fieldName, fieldNum); + + return SQL_FetchFloat(query, fieldNum, result); +} + +/** + * Fetches a string from a field in the current row of a result set. (See: SQL_FetchString) + * + * @param query A query (or statement) Handle. + * @param field The field index (starting from 0). + * @param buffer String buffer. + * @param maxlength Maximum size of the string buffer. + * @param result Optional variable to store the status of the return value. + * @return Number of bytes written. + * @error Invalid query Handle or field index, invalid + * type conversion requested from the database, + * or no current result set. + */ +stock int SQL_FetchStringByName(Handle query, char[] fieldName, char[] buffer, int maxlength, DBResult &result=DBVal_Error) { + + int fieldNum; + SQL_FieldNameToNum(query, fieldName, fieldNum); + + return SQL_FetchString(query, fieldNum, buffer, maxlength, result); +} diff --git a/include/smlib/strings.inc b/include/smlib/strings.inc new file mode 100644 index 0000000..32f1d29 --- /dev/null +++ b/include/smlib/strings.inc @@ -0,0 +1,233 @@ +#if defined _smlib_strings_included + #endinput +#endif +#define _smlib_strings_included + +#include +#include + +/** + * Checks if the string is numeric. + * This correctly handles + - . in the String. + * + * @param str String to check. + * @return True if the String is numeric, false otherwise.. + */ +stock bool String_IsNumeric(const char[] str) +{ + int x=0; + int dotsFound=0; + int numbersFound=0; + + if (str[x] == '+' || str[x] == '-') { + x++; + } + + while (str[x] != '\0') { + + if (IsCharNumeric(str[x])) { + numbersFound++; + } + else if (str[x] == '.') { + dotsFound++; + + if (dotsFound > 1) { + return false; + } + } + else { + return false; + } + + x++; + } + + if (!numbersFound) { + return false; + } + + return true; +} + +/** + * Trims a string by removing the specified chars from beginning and ending. + * Removes all ' ', '\t', '\r', '\n' characters by default. + * The Output String can be the same as the Input String. + * + * @param str Input String. + * @param output Output String (Can be the as the input). + * @param size Size of the output String. + * @param chars Characters to remove. + * @noreturn + */ +stock void String_Trim(const char[] str, char[] output, int size, const char chrs[]=" \t\r\n") +{ + int x=0; + while (str[x] != '\0' && FindCharInString(chrs, str[x]) != -1) { + x++; + } + + x = strcopy(output, size, str[x]); + x--; + + while (x >= 0 && FindCharInString(chrs, output[x]) != -1) { + x--; + } + + output[++x] = '\0'; +} + +/** + * Removes a list of strings from a string. + * + * @param buffer Input/Ourput buffer. + * @param removeList A list of strings which should be removed from buffer. + * @param size Number of Strings in the List. + * @param caseSensitive If true, comparison is case sensitive. If false (default), comparison is case insensitive. + * @noreturn + */ +stock void String_RemoveList(char[] buffer, char[][] removeList, int size, bool caseSensitive=false) +{ + for (int i=0; i < size; i++) { + ReplaceString(buffer, SIZE_OF_INT, removeList[i], "", caseSensitive); + } +} + +/** + * Converts the whole String to lower case. + * Only works with alphabetical characters (not ÖÄÜ) because Sourcemod suxx ! + * The Output String can be the same as the Input String. + * + * @param input Input String. + * @param output Output String. + * @param size Max Size of the Output string + * @noreturn + */ +stock void String_ToLower(const char[] input, char[] output, int size) +{ + size--; + + int x=0; + while (input[x] != '\0' && x < size) { + + output[x] = CharToLower(input[x]); + + x++; + } + + output[x] = '\0'; +} + +/** + * Converts the whole String to upper case. + * Only works with alphabetical characters (not öäü) because Sourcemod suxx ! + * The Output String can be the same as the Input String. + * + * @param input Input String. + * @param output Output String. + * @param size Max Size of the Output string + * @noreturn + */ +stock void String_ToUpper(const char[] input, char[] output, int size) +{ + size--; + + int x=0; + while (input[x] != '\0' && x < size) { + + output[x] = CharToUpper(input[x]); + + x++; + } + + output[x] = '\0'; +} + +/** + * Generates a random string. + * + * + * @param buffer String Buffer. + * @param size String Buffer size (must be length+1) + * @param length Number of characters being generated. + * @param chrs String for specifying the characters used for random character generation. + * By default it will use all letters of the alphabet (upper and lower) and all numbers. + * If you pass an empty String, it will use all readable ASCII characters (33 - 126) + * @noreturn + */ +stock void String_GetRandom(char[] buffer, int size, int length=32, const char chrs[]="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234556789") +{ + int random, len; + size--; + + if (chrs[0] != '\0') { + len = strlen(chrs) - 1; + } + + int n = 0; + while (n < length && n < size) { + + if (chrs[0] == '\0') { + random = Math_GetRandomInt(33, 126); + buffer[n] = random; + } + else { + random = Math_GetRandomInt(0, len); + buffer[n] = chrs[random]; + } + + n++; + } + + buffer[length] = '\0'; +} + +/** + * Checks if string str starts with subString. + * + * + * @param str String to check + * @param subString Sub-String to check in str + * @return True if str starts with subString, false otherwise. + */ +stock bool String_StartsWith(const char[] str, const char[] subString) +{ + int n = 0; + while (subString[n] != '\0') { + + if (str[n] == '\0' || str[n] != subString[n]) { + return false; + } + + n++; + } + + return true; +} + +/** + * Checks if string str ends with subString. + * + * + * @param str String to check + * @param subString Sub-String to check in str + * @return True if str ends with subString, false otherwise. + */ +stock bool String_EndsWith(const char[] str, const char[] subString) +{ + int n_str = strlen(str) - 1; + int n_subString = strlen(subString) - 1; + + if(n_str < n_subString) { + return false; + } + + while (n_str != 0 && n_subString != 0) { + + if (str[n_str--] != subString[n_subString--]) { + return false; + } + } + + return true; +} diff --git a/include/smlib/teams.inc b/include/smlib/teams.inc new file mode 100644 index 0000000..5917f69 --- /dev/null +++ b/include/smlib/teams.inc @@ -0,0 +1,318 @@ +#if defined _smlib_teams_included + #endinput +#endif +#define _smlib_teams_included + +#include +#include +#include + +#define MAX_TEAMS 32 // Max number of teams in a game +#define MAX_TEAM_NAME_LENGTH 32 // Max length of a team's name + +// Team Defines +#define TEAM_INVALID -1 +#define TEAM_UNASSIGNED 0 +#define TEAM_SPECTATOR 1 +#define TEAM_ONE 2 +#define TEAM_TWO 3 +#define TEAM_THREE 4 +#define TEAM_FOUR 5 + +/* + * If one team is empty its assumed single team mode is enabled and the game won't start. + * + * @noparam + * @return True if one team is empty, false otherwise. + */ +stock bool Team_HaveAllPlayers(bool countFakeClients=true) { + + int teamCount = GetTeamCount(); + for (int i=2; i < teamCount; i++) { + + if (Team_GetClientCount(i, ((countFakeClients) ? CLIENTFILTER_ALL : CLIENTFILTER_NOBOTS)) == 0) { + return false; + } + } + + return true; +} + +/* + * Returns the client count of the players in a team. + * + * @param team Team Index. + * @param flags Client Filter Flags (Use the CLIENTFILTER_ constants). + * @return Client count in the server. + */ +stock int Team_GetClientCount(int team, int flags=0) +{ + flags |= CLIENTFILTER_INGAME; + + int numClients = 0; + for (int client=1; client <= MaxClients; client++) { + + if (!Client_MatchesFilter(client, flags)) { + continue; + } + + if (GetClientTeam(client) == team) { + numClients++; + } + } + + return numClients; +} + +/* + * Returns the client counts of the first two teams (eg.: Terrorists - Counter). + * Use this function for optimization if you have to get the counts of both teams, + * otherwise use Team_GetClientCount(). + * + * @param team1 Pass an integer variable by reference + * @param team2 Pass an integer variable by reference + * @param flags Client Filter Flags (Use the CLIENTFILTER_ constants). + * @noreturn + */ +stock void Team_GetClientCounts(int &team1=0, int &team2=0, int flags=0) +{ + flags |= CLIENTFILTER_INGAME; + + for (int client=1; client <= MaxClients; client++) { + + if (!Client_MatchesFilter(client, flags)) { + continue; + } + + if (GetClientTeam(client) == TEAM_ONE) { + team1++; + } + else if (GetClientTeam(client) == TEAM_TWO) { + team2++; + } + } +} + +/* + * Gets the name of a team. + * Don't call this before OnMapStart() + * + * @param index Team Index. + * @param str String buffer + * @param size String Buffer Size + * @return True on success, false otherwise + */ +stock bool Team_GetName(int index, char[] str, int size) +{ + int edict = Team_GetEdict(index); + + if (edict == -1) { + str[0] = '\0'; + return false; + } + + GetEntPropString(edict, Prop_Send, "m_szTeamname", str, size); + + return true; +} + +/* + * Changes a team's name. + * Use this carefully ! + * Only set the teamname OnMapStart() or OnEntityCreated() + * when no players are ingame, otherwise it can crash the server. + * + * @param index Team Index. + * @param name New Name String + * @return True on success, false otherwise + */ +stock bool Team_SetName(int index, const char[] name) +{ + int edict = Team_GetEdict(index); + + if (edict == -1) { + return false; + } + + SetEntPropString(edict, Prop_Send, "m_szTeamname", name); + ChangeEdictState(edict, GetEntSendPropOffs(edict, "m_szTeamname", true)); + + return true; +} + +/* + * Changes a team's score. + * Don't use this before OnMapStart(). + * + * @param index Team Index. + * @return Team Score or -1 if the team is not valid. + */ +stock int Team_GetScore(int index) +{ + int edict = Team_GetEdict(index); + + if (edict == -1) { + return -1; + } + + return GetEntProp(edict, Prop_Send, "m_iScore"); +} + +/* + * Changes a team's score. + * Don't use this before OnMapStart(). + * + * @param index Team Index. + * @param score Score value. + * @return True on success, false otherwise + */ +stock bool Team_SetScore(int index, int score) +{ + int edict = Team_GetEdict(index); + + if (edict == -1) { + return false; + } + + SetEntProp(edict, Prop_Send, "m_iScore", score); + + ChangeEdictState(edict, GetEntSendPropOffs(edict, "m_iScore", true)); + + return true; +} + +/* + * Gets a team's edict (*team_manager) Team Index. + * Don't call this before OnMapStart() + * + * @param edict Edict + * @return Team Index + */ +stock int Team_EdictGetNum(int edict) +{ + return GetEntProp(edict, Prop_Send, "m_iTeamNum"); +} + +/* + * Check's whether the index is a valid team index or not. + * Don't call this before OnMapStart() + * + * @param index Index. + * @return True if the Index is a valid team, false otherwise. + */ +stock bool Team_IsValid(int index) +{ + return (Team_GetEdict(index) != -1); +} + +/* + * Gets a team's edict (team_manager) Team Index. + * Don't call this before OnMapStart() + * + * @param index Edict + * @return Team Index + */ +stock int Team_EdictIsValid(int edict) +{ + return GetEntProp(edict, Prop_Send, "m_iTeamNum"); +} + +/* + * Gets a team's edict (team_manager). + * This function caches found team edicts. + * Don't call this before OnMapStart() + * + * @param index Team Index. + * @return Team edict or -1 if not found + */ +stock int Team_GetEdict(int index) +{ + static int teams[MAX_TEAMS] = { INVALID_ENT_REFERENCE, ... }; + + if (index < 0 || index > MAX_TEAMS) { + return -1; + } + + int edict = teams[index]; + if (Entity_IsValid(edict)) { + return edict; + } + + bool foundTeamManager = false; + + int maxEntities = GetMaxEntities(); + for (int entity=MaxClients+1; entity < maxEntities; entity++) { + + if (!IsValidEntity(entity)) { + continue; + } + + if (Entity_ClassNameMatches(entity, "team_manager", true)) { + foundTeamManager = true; + } + // Do not continue when no team managers are found anymore (for optimization) + else if (foundTeamManager) { + return -1; + } + else { + continue; + } + + int num = Team_EdictGetNum(entity); + + if (num >= 0 && num <= MAX_TEAMS) { + teams[num] = EntIndexToEntRef(entity); + } + + if (num == index) { + return entity; + } + } + + return -1; +} + +/* + * Trys to find a client in the specified team. + * This function is NOT random, it returns the first + * or the cached player (Use Client_GetRandom() instead). + * + * @param index Team Index. + * @return Client Index or -1 if no client was found in the specified team. + */ +stock int Team_GetAnyClient(int index) +{ + static int client_cache[MAX_TEAMS] = -1; + int client; + + if (index > 0) { + client = client_cache[index]; + + if (client > 0 && client <= MaxClients) { + + if (IsClientInGame(client) && GetClientTeam(client) == index) { + return client; + } + } + else { + client = -1; + } + } + + for (client=1; client <= MaxClients; client++) { + + if (!IsClientInGame(client)) { + continue; + } + + if (GetClientTeam(client) != index) { + continue; + } + + client_cache[index] = client; + + return client; + } + + return -1; +} diff --git a/include/smlib/vehicles.inc b/include/smlib/vehicles.inc new file mode 100644 index 0000000..ea18157 --- /dev/null +++ b/include/smlib/vehicles.inc @@ -0,0 +1,141 @@ +#if defined _smlib_vehicles_included + #endinput +#endif +#define _smlib_vehicles_included + +#include +#include +#include +#include + +/** + * Returns the vehicle's driver. + * If there is no driver in the vehicle, -1 is returned. + * + * @param vehicle Entity index. + * @return Client index, or -1 if there is no driver. + */ +stock int Vehicle_GetDriver(int vehicle) +{ + int m_hVehicle = GetEntPropEnt(vehicle, Prop_Send, "m_hPlayer"); + + return m_hVehicle; +} + +/** + * Returns whether there is a driver in the vehicle or not. + * + * @param vehicle Entity index. + * @return True if the vehicle has a driver, false otherwise + */ +stock bool Vehicle_HasDriver(int vehicle) +{ + return !(Vehicle_GetDriver(vehicle) == -1); +} + +/** + * Kicks the driver ouf of the vehicle + * + * @param vehicle Entity index. + * @return True on success, false otherwise. + */ +stock bool Vehicle_ExitDriver(int vehicle) +{ + if (!Vehicle_HasDriver(vehicle)) { + return false; + } + + return AcceptEntityInput(vehicle, "ExitVehicle"); +} + +/** + * Start's the vehicle's engine + * + * @param vehicle Entity index. + * @return True on success, false otherwise. + */ +stock bool Vehicle_TurnOn(int vehicle) +{ + + return AcceptEntityInput(vehicle, "TurnOn"); +} + +/** + * Shuts down the vehicle's engine + * + * @param vehicle Entity index. + * @return True on success, false otherwise. + */ +stock bool Vehicle_TurnOff(int vehicle) +{ + + return AcceptEntityInput(vehicle, "TurnOff"); +} + +/** + * Locks the vehicle. + * + * @param vehicle Entity index. + * @return True on success, false otherwise. + */ +stock bool Vehicle_Lock(int vehicle) +{ + + return AcceptEntityInput(vehicle, "Lock"); +} + +/** + * Unlocks the vehicle. + * + * @param vehicle Entity index. + * @return True on success, false otherwise. + */ +stock bool Vehicle_Unlock(int vehicle) +{ + + return AcceptEntityInput(vehicle, "Unlock"); +} + +/** + * Returns wether the entity is a valid vehicle or not. + * + * @param vehicle Entity index. + * @return True if it is a valid vehicle, false otherwise. + */ +stock bool Vehicle_IsValid(int vehicle) +{ + if (!Entity_IsValid(vehicle)) { + return false; + } + + return Entity_ClassNameMatches(vehicle, "prop_vehicle", true); +} + +/** + * Reads the vehicle script from a vehicle. + * This script contains all the vehicle settings like its speed + * and that stuff. + * + * @param vehicle Entity index. + * @param buffer String Buffer. + * @param size String Buffer size. + * @noreturn + */ +stock bool Vehicle_GetScript(int vehicle, char[] buffer, int size) +{ + GetEntPropString(vehicle, Prop_Data, "m_vehicleScript", buffer, size); +} + +/** + * Sets the script of a vehicle. + * This script contains all the vehicle settings like its speed + * and that stuff. + * + * @param vehicle Entity index. + * @param buffer Vehicle Script path. + * @noreturn + */ +stock bool Vehicle_SetScript(int vehicle, char[] script) +{ + DispatchKeyValue(vehicle, "vehiclescript", script); +} diff --git a/include/smlib/weapons.inc b/include/smlib/weapons.inc new file mode 100644 index 0000000..006935b --- /dev/null +++ b/include/smlib/weapons.inc @@ -0,0 +1,403 @@ +#if defined _smlib_weapons_included + #endinput +#endif +#define _smlib_weapons_included + +#include +#include +#include + +#define MAX_WEAPON_OFFSET 64 +#define MAX_WEAPON_SLOTS 6 // hud item selection slots +#define MAX_WEAPON_POSITIONS 20 // max number of items within a slot +#define MAX_WEAPONS 48 // Max number of weapons availabl +#define WEAPON_NOCLIP -1 // clip sizes set to this tell the weapon it doesn't use a clip +#define MAX_AMMO_TYPES 32 +#define MAX_AMMO_SLOTS 32 // not really slots + +#define MAX_WEAPON_STRING 80 +#define MAX_WEAPON_PREFIX 16 +#define MAX_WEAPON_AMMO_NAME 32 + +/* + * Gets the owner (usually a client) of the weapon + * + * @param weapon Weapon Entity. + * @return Owner of the weapon or INVALID_ENT_REFERENCE if the weapon has no owner. + */ +stock int Weapon_GetOwner(int weapon) +{ + return GetEntPropEnt(weapon, Prop_Data, "m_hOwner"); +} + +/* + * Sets the owner (usually a client) of the weapon + * + * @param weapon Weapon Entity. + * @param entity Entity Index. + * @noreturn + */ +stock void Weapon_SetOwner(int weapon, int entity) +{ + SetEntPropEnt(weapon, Prop_Data, "m_hOwner", entity); +} + +/* + * Checks whether the entity is a valid weapon or not. + * + * @param weapon Weapon Entity. + * @return True if the entity is a valid weapon, false otherwise. + */ +stock bool Weapon_IsValid(int weapon) +{ + if (!IsValidEdict(weapon)) { + return false; + } + + return Entity_ClassNameMatches(weapon, "weapon_", true); +} + +/* + * Create's a weapon and spawns it in the world at the specified location. + * + * @param className Classname String of the weapon to spawn + * @param absOrigin Absolute Origin Vector where to spawn the weapon. + * @param absAngles Absolute Angles Vector. + * @return Weapon Index of the created weapon or INVALID_ENT_REFERENCE on error. + */ +stock int Weapon_Create(const char[] className, float absOrigin[3], float absAngles[3]) +{ + int weapon = Entity_Create(className); + + if (weapon == INVALID_ENT_REFERENCE) { + return INVALID_ENT_REFERENCE; + } + + Entity_SetAbsOrigin(weapon, absOrigin); + Entity_SetAbsAngles(weapon, absAngles); + + DispatchSpawn(weapon); + + return weapon; +} + +/* + * Create's a weapon and spawns it in the world at the specified location. + * + * @param className Classname String of the weapon to spawn + * @param absOrigin Absolute Origin Vector where to spawn the weapon. + * @param absAngles Absolute Angles Vector. + * @return Weapon Index of the created weapon or INVALID_ENT_REFERENCE on error. + */ +stock int Weapon_CreateForOwner(int client, const char[] className) +{ + float absOrigin[3], absAngles[3]; + Entity_GetAbsOrigin(client, absOrigin); + Entity_GetAbsAngles(client, absAngles); + + int weapon = Weapon_Create(className, absOrigin, absAngles); + + if (weapon == INVALID_ENT_REFERENCE) { + return INVALID_ENT_REFERENCE; + } + + Entity_SetOwner(weapon, client); + + return weapon; +} + +/* + * Gets the weapon's subtype. + * The subtype is only used when a player has multiple weapons of the same type. + * + * @param weapon Weapon Entity. + * @return Subtype of the weapon. + */ +stock int Weapon_GetSubType(int weapon, int value) +{ + return GetEntProp(weapon, Prop_Data, "m_iSubType"); +} + +/* + * Is the weapon currently reloading ? + * + * @param weapon Weapon Entity. + * @return True if weapon is currently reloading, false if not. + */ +stock bool Weapon_IsReloading(int weapon) +{ + return view_as(GetEntProp(weapon, Prop_Data, "m_bInReload")); +} + +/* + * Weapon m_iState + */ +#define WEAPON_IS_ONTARGET 0x40 +#define WEAPON_NOT_CARRIED 0 // Weapon is on the ground +#define WEAPON_IS_CARRIED_BY_PLAYER 1 // This client is carrying this weapon. +#define WEAPON_IS_ACTIVE 2 // This client is carrying this weapon and it's the currently held weapon + +/* + * Get's the state of the weapon. + * This returns whether the weapon is currently carried by a client, + * if it is active and if it is on a target. + * + * @param weapon Weapon Entity. + * @return Weapon State. + */ +stock int Weapon_GetState(int weapon) +{ + return GetEntProp(weapon, Prop_Data, "m_iState"); +} + +/* + * Returns whether the weapon can fire primary ammo under water. + * + * @param weapon Weapon Entity. + * @return True or False. + */ +stock bool Weapon_FiresUnderWater(int weapon) +{ + return view_as(GetEntProp(weapon, Prop_Data, "m_bFiresUnderwater")); +} + +/* + * Sets if the weapon can fire primary ammo under water. + * + * @param weapon Weapon Entity. + * @param can True or False. + * @noreturn + */ +stock void Weapon_SetFiresUnderWater(int weapon, bool can=true) +{ + SetEntProp(weapon, Prop_Data, "m_bFiresUnderwater", view_as(can)); +} + +/* + * Returns whether the weapon can fire secondary ammo under water. + * + * @param weapon Weapon Entity. + * @return True or False. + */ +stock bool Weapon_FiresUnderWaterAlt(int weapon) +{ + return view_as(GetEntProp(weapon, Prop_Data, "m_bAltFiresUnderwater")); +} + +/* + * Sets if the weapon can fire secondary ammo under water. + * + * @param weapon Weapon Entity. + * @param can True or False. + * @noreturn + */ +stock void Weapon_SetFiresUnderWaterAlt(int weapon, bool can=true) +{ + SetEntProp(weapon, Prop_Data, "m_bAltFiresUnderwater", view_as(can)); +} + +/* + * Gets the primary ammo Type (int offset) + * + * @param weapon Weapon Entity. + * @return Primary ammo type value. + */ +stock int Weapon_GetPrimaryAmmoType(int weapon) +{ + return GetEntProp(weapon, Prop_Data, "m_iPrimaryAmmoType"); +} + +/* + * Sets the primary ammo Type (int offset) + * + * @param weapon Weapon Entity. + * @param type Primary ammo type value. + * @noreturn + */ +stock void Weapon_SetPrimaryAmmoType(int weapon, int type) +{ + SetEntProp(weapon, Prop_Data, "m_iPrimaryAmmoType", type); +} + +/* + * Gets the secondary ammo Type (int offset) + * + * @param weapon Weapon Entity. + * @return Secondary ammo type value. + */ +stock int Weapon_GetSecondaryAmmoType(int weapon) +{ + return GetEntProp(weapon, Prop_Data, "m_iSecondaryAmmoType"); +} + +/* + * Sets the secondary ammo Type (int offset) + * + * @param weapon Weapon Entity. + * @param type Secondary ammo type value. + * @noreturn + */ +stock void Weapon_SetSecondaryAmmoType(int weapon, int type) +{ + SetEntProp(weapon, Prop_Data, "m_iSecondaryAmmoType", type); +} + +/* + * Gets the primary clip count of a weapon. + * + * @param weapon Weapon Entity. + * @return Primary Clip count. + */ +stock int Weapon_GetPrimaryClip(int weapon) +{ + return GetEntProp(weapon, Prop_Data, "m_iClip1"); +} + +/* + * Sets the primary clip count of a weapon. + * + * @param weapon Weapon Entity. + * @param value Clip Count value. + * @noreturn + */ +stock void Weapon_SetPrimaryClip(int weapon, int value) +{ + SetEntProp(weapon, Prop_Data, "m_iClip1", value); +} + +/* + * Gets the secondary clip count of a weapon. + * + * @param weapon Weapon Entity. + * @return Secondy Clip count. + */ +stock int Weapon_GetSecondaryClip(int weapon) +{ + return GetEntProp(weapon, Prop_Data, "m_iClip2"); +} + +/* + * Sets the secondary clip count of a weapon. + * + * @param weapon Weapon Entity. + * @param value Clip Count value. + * @noreturn + */ +stock void Weapon_SetSecondaryClip(int weapon, int value) +{ + SetEntProp(weapon, Prop_Data, "m_iClip2", value); +} + +/* + * Sets the primary & secondary clip count of a weapon. + * + * @param weapon Weapon Entity. + * @param primary Primary Clip Count value. + * @param secondary Primary Clip Count value. + * @noreturn + */ +stock void Weapon_SetClips(int weapon, int primary, int secondary) +{ + Weapon_SetPrimaryClip(weapon, primary); + Weapon_SetSecondaryClip(weapon, secondary); +} + +/* + * Gets the primary ammo count of a weapon. + * This is only used when the weapon is not carried + * by a player to give a player ammo when he picks up + * the weapon. + * + * @param weapon Weapon Entity. + * @return Primary Ammo Count. + */ +stock int Weapon_GetPrimaryAmmoCount(int weapon) +{ + return GetEntProp(weapon, Prop_Data, "m_iPrimaryAmmoCount"); +} + +/* + * Sets the primary ammo count of a weapon. + * This is only used when the weapon is not carried + * by a player to give a player ammo when he picks up + * the weapon. + * + * @param weapon Weapon Entity. + * @param value Primary Ammo Count. + * @noreturn + */ +stock void Weapon_SetPrimaryAmmoCount(int weapon, int value) +{ + SetEntProp(weapon, Prop_Data, "m_iPrimaryAmmoCount", value); +} + +/* + * Gets the secondary ammo count of a weapon. + * This is only used when the weapon is not carried + * by a player to give a player ammo when he picks up + * the weapon. + * + * @param weapon Weapon Entity. + * @return Secondary Ammo Count. + */ +stock int Weapon_GetSecondaryAmmoCount(int weapon) +{ + return GetEntProp(weapon, Prop_Data, "m_iSecondaryAmmoCount"); +} + +/* + * Sets the secodary ammo count of a weapon. + * This is only used when the weapon is not carried + * by a player to give a player ammo when he picks up + * the weapon. + * + * @param weapon Weapon Entity. + * @param value Secondary Ammo Count. + * @noreturn + */ +stock void Weapon_SetSecondaryAmmoCount(int weapon, int value) +{ + SetEntProp(weapon, Prop_Data, "m_iSecondaryAmmoCount", value); +} + +/* + * Sets both, the primary & the secondary ammo count of a weapon. + * This is only used when the weapon is not carried + * by a player to give a player ammo when he picks up + * the weapon. + * + * @param weapon Weapon Entity. + * @value primary Primary Ammo Count. + * @value secondary Secondary Ammo Count. + * @noreturn + */ +stock void Weapon_SetAmmoCounts(int weapon, int primary, int secondary) +{ + Weapon_SetPrimaryAmmoCount(weapon, primary); + Weapon_SetSecondaryAmmoCount(weapon, secondary); +} + +/* + * Gets the Model Index of the weapon's view model. + * + * @param weapon Weapon Entity. + * @return View Model Index. + */ +stock int Weapon_GetViewModelIndex(int weapon) +{ + return GetEntProp(weapon, Prop_Data, "m_nViewModelIndex"); +} + +/* + * Sets the Model Index of the weapon's view model. + * You can get the Model Index by precaching a model with PrecacheModel(). + * + * @param weapon Weapon Entity. + * @param index Model Index. + * @noreturn + */ +stock void Weapon_SetViewModelIndex(int weapon, int index) +{ + SetEntProp(weapon, Prop_Data, "m_nViewModelIndex", index); + ChangeEdictState(weapon, FindDataMapInfo(weapon, "m_nViewModelIndex")); +} diff --git a/include/smlib/world.inc b/include/smlib/world.inc new file mode 100644 index 0000000..68100d4 --- /dev/null +++ b/include/smlib/world.inc @@ -0,0 +1,17 @@ +#if defined _smlib_world_included + #endinput +#endif +#define _smlib_world_included + +#include + +/* + * Gets the world's max size + * + * @param vec Vector buffer + * @noreturn + */ +stock void World_GetMaxs(float vec[3]) { + + GetEntPropVector(0, Prop_Data, "m_WorldMaxs", vec); +} From aeca1a842ce05f9fadf1d9ff4bffd6cdaf47d5bc Mon Sep 17 00:00:00 2001 From: hermansimensen Date: Sun, 24 May 2020 23:15:40 +0200 Subject: [PATCH 7/9] Add style to keyswitch log --- shavit-bash2.sp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/shavit-bash2.sp b/shavit-bash2.sp index 3862fe7..13e7f72 100644 --- a/shavit-bash2.sp +++ b/shavit-bash2.sp @@ -2274,7 +2274,14 @@ stock void RecordKeySwitch(int client, int button, int oppositeButton, int btype positivePct = float(positiveCount) / float(MAX_FRAMES_KEYSWITCH); timingPct = float(timingCount) / float(MAX_FRAMES_KEYSWITCH); - AnticheatLog(client, "key switch %d, avg: %.2f, dev: %.2f, p: %.2f％, nullPct: %.2f, Timing: %.1f%%", btype, mean, sd, positivePct * 100, nullPct * 100, timingPct * 100); + char sStyle[32]; + #if defined TIMER + int style = Shavit_GetBhopStyle(client); + Shavit_GetStyleStrings(style, sStyleName, g_sStyleStrings[style].sStyleName, sizeof(stylestrings_t::sStyleName)); + FormatEx(sStyle, sizeof(sStyle), "%s", g_sStyleStrings[style].sStyleName) + #endif + + //AnticheatLog(client, "key switch %d, avg: %.2f, dev: %.2f, p: %.2f％, nullPct: %.2f, Timing: %.1f%%", btype, mean, sd, positivePct * 100, nullPct * 100, timingPct * 100); if(IsClientInGame(client) && g_hAntiNull.BoolValue) { // Add a delay to the kick in case they are using an obvious strafehack that would ban them anyway From 2b6dc7cf8bf5615f69a27176c83764bf07c0b18b Mon Sep 17 00:00:00 2001 From: hermansimensen Date: Sun, 24 May 2020 23:16:28 +0200 Subject: [PATCH 8/9] add style to keyswitch log --- shavit-bash2.sp | 1 + 1 file changed, 1 insertion(+) diff --git a/shavit-bash2.sp b/shavit-bash2.sp index 13e7f72..f51b2a6 100644 --- a/shavit-bash2.sp +++ b/shavit-bash2.sp @@ -2282,6 +2282,7 @@ stock void RecordKeySwitch(int client, int button, int oppositeButton, int btype #endif //AnticheatLog(client, "key switch %d, avg: %.2f, dev: %.2f, p: %.2f％, nullPct: %.2f, Timing: %.1f%%", btype, mean, sd, positivePct * 100, nullPct * 100, timingPct * 100); + AnticheatLog(client, "key switch %d, avg: %.2f, dev: %.2f, p: %.2f％, nullPct: %.2f, Timing: %.1f , Style: %s", btype, mean, sd, positivePct * 100, nullPct * 100, timingPct * 100, sStyle); if(IsClientInGame(client) && g_hAntiNull.BoolValue) { // Add a delay to the kick in case they are using an obvious strafehack that would ban them anyway From b2954b334374b5eb8b23f02742dfdfe0836380bd Mon Sep 17 00:00:00 2001 From: hermansimensen Date: Tue, 26 May 2020 23:03:29 +0200 Subject: [PATCH 9/9] Ban/Kick logging + optimizations --- README.md | 1 + shavit-bash2.sp | 28 +++++++++++++++++----------- 2 files changed, 18 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 2e20cf9..2792356 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,7 @@ bash_banlength - lets you set banlength bash_autoban - disable/enable automatic banning. bash_discord - Enable/Disable discord logging bash_discord_webhook - The url for the discord webhook. +bash_discord_only_bans - If enabled, only kicks and bans will be printed to the discord log. ``` ### Depencenies diff --git a/shavit-bash2.sp b/shavit-bash2.sp index f51b2a6..d97aff0 100644 --- a/shavit-bash2.sp +++ b/shavit-bash2.sp @@ -31,7 +31,7 @@ public Plugin myinfo = author = "Blacky, edited by carnifex", description = "Detects strafe hackers", version = "2.0", - url = "http://steamcommunity.com/id/blaackyy/" + url = "https://github.com/hermansimensen/bash2" }; // Definitions @@ -184,7 +184,10 @@ ConVar g_hAntiNull; ConVar g_hAutoban; ConVar g_hLogToDiscord; ConVar g_hWebhook; +ConVar g_hOnlyPrintBan; bool g_bAdminMode[MAXPLAYERS + 1]; +char g_sHostName[128]; +char g_sWebhook[255]; //shavit stylesettings_t g_aStyleSettings[STYLE_LIMIT]; @@ -203,6 +206,7 @@ public void OnPluginStart() g_hAntiNull = CreateConVar("bash_antinull", "0", "Punish for null movement stats", _, true, 0.0, true, 1.0); g_hLogToDiscord = CreateConVar("bash_discord", "0", "Print anticheat logs to discord server.", _, true, 0.0, true, 1.0); g_hWebhook = CreateConVar("bash_discord_webhook", "https://discordapp.com/api/webhooks/xxxxxx", _); + g_hOnlyPrintBan = CreateConVar("bash_discord_only_bans", "0", "If enabled, only kicks and bans will be printed to the discord log.", _, true, 0.0, true, 1.0); //HookUserMessage(umVGUIMenu, OnVGUIMenu, true); @@ -343,7 +347,11 @@ public MRESReturn Hook_DHooks_Teleport(int client, Handle hParams) void AutoBanPlayer(int client) { if(g_hAutoban.BoolValue && IsClientInGame(client) && !IsClientInKickQueue(client)) + { ServerCommand("sm_ban #%d %s Cheating", GetClientUserId(client), g_sBanLength); + PrintToDiscord(client, "Banned for cheating."); + + } } float g_fLag_LastCheckTime; @@ -415,16 +423,11 @@ stock bool PrintToDiscord(int client, const char[] log, any ...) if(g_bDiscordLoaded) { #if defined DISCORD - char webhook[255]; - GetConVarString(g_hWebhook, webhook, 255); char clientName[32]; GetClientName(client, clientName, 32); - char hostName[128]; - GetConVarString(FindConVar("hostname"), hostName, 128); - - DiscordWebHook hook = new DiscordWebHook(webhook); + DiscordWebHook hook = new DiscordWebHook(g_sWebhook); hook.SlackMode = true; hook.SetUsername("BASH 2.0"); @@ -432,11 +435,11 @@ stock bool PrintToDiscord(int client, const char[] log, any ...) MessageEmbed Embed = new MessageEmbed(); Embed.SetColor("#ff2222"); - Embed.SetTitle(hostName); + Embed.SetTitle(g_sHostName); char steamid[65]; char playerName[512]; - GetClientAuthId(client, AuthId_SteamID64, steamid, sizeof( steamid )); + GetClientAuthId(client, AuthId_SteamID64, steamid, sizeof(steamid)); Format(playerName, sizeof(playerName), "[%N](http://www.steamcommunity.com/profiles/%s)", client, steamid); Embed.AddField("Player", playerName, true); @@ -458,7 +461,7 @@ stock bool AnticheatLog(int client, const char[] log, any ...) VFormat(buffer, sizeof(buffer), log, 3); PrintToAdmins("%N %s", client, buffer); - if(g_hLogToDiscord.BoolValue && LibraryExists("discord-api")) { + if(g_hLogToDiscord.BoolValue && LibraryExists("discord-api") && !g_hOnlyPrintBan.BoolValue) { PrintToDiscord(client, buffer); } @@ -566,6 +569,8 @@ public Action Timer_MOTD(Handle timer, any data) public void OnMapStart() { + GetConVarString(FindConVar("hostname"), g_sHostName, 128); + GetConVarString(g_hWebhook, g_sWebhook, 255); CreateTimer(0.2, Timer_UpdateYaw, _, TIMER_REPEAT | TIMER_FLAG_NO_MAPCHANGE); if(g_bLateLoad) @@ -2282,7 +2287,7 @@ stock void RecordKeySwitch(int client, int button, int oppositeButton, int btype #endif //AnticheatLog(client, "key switch %d, avg: %.2f, dev: %.2f, p: %.2f％, nullPct: %.2f, Timing: %.1f%%", btype, mean, sd, positivePct * 100, nullPct * 100, timingPct * 100); - AnticheatLog(client, "key switch %d, avg: %.2f, dev: %.2f, p: %.2f％, nullPct: %.2f, Timing: %.1f , Style: %s", btype, mean, sd, positivePct * 100, nullPct * 100, timingPct * 100, sStyle); + AnticheatLog(client, "key switch %d, avg: %.2f, dev: %.2f, p: %.2f％, nullPct: %.2f, Timing: %.1f, Style: %s", btype, mean, sd, positivePct * 100, nullPct * 100, timingPct * 100, sStyle); if(IsClientInGame(client) && g_hAntiNull.BoolValue) { // Add a delay to the kick in case they are using an obvious strafehack that would ban them anyway @@ -2299,6 +2304,7 @@ public Action Timer_NullKick(Handle timer, int userid) if(client != 1) { KickClient(client, "Kicked for potentional movement config"); + PrintToDiscord(client, "Kicked for potential movement config."); } }