AlliedModders

AlliedModders (https://forums.alliedmods.net/index.php)
-   Plugin/Gameplay Ideas and Requests (https://forums.alliedmods.net/forumdisplay.php?f=60)
-   -   After death (https://forums.alliedmods.net/showthread.php?t=320020)

ApoziX 12-01-2019 09:45

After death
 
When I do !friendly then I suicide I am still friendly but the ghost effect stays only on cosmetics and not on the body. +rep for helpers
I think its on public void OnPlayerSpawned
Code:

#pragma newdecls required
#pragma semicolon 1

#define CONTENT_URL "https://github.com/NGSNetwork/sm-plugins/raw/master/"
#define RELOAD_ON_UPDATE 1

#include <tf2_stocks>
#include <sdkhooks>
#include <morecolors>
#include <clientprefs>

#undef REQUIRE_PLUGIN
#include <ngsupdater>
#include <ngsutils>
#tryinclude <goomba>
#tryinclude <rtd>

#define CHAT_PREFIX "{aqua}[FZG]{default}"
#define CHAT_PREFIX_SPACE "{aqua}[FZG]{default} "
#define CHAT_PREFIX_NOCOLOR "[FZG]"
#define CHAT_NAME "{aqua}Friendly Mode{default}"

#define DEFAULT_BLOCKED_WEAPONCLASSES "tf_weapon_flamethrower,tf_weapon_medigun,tf_weapon_lunchbox,tf_weapon_buff_item,tf_weapon_wrench"
/* Default blocked weapon classes are:
        tf_weapon_flamethrower        - Pyro's flamethrowers, to prevent airblasting
        tf_weapon_medigun                - Medic's Mediguns, to prevent healing
        tf_weapon_lunchbox                - Heavy's snacks, to prevent healing through sandvich throwing
        tf_weapon_buff_item                - Soldier's buffing secondary weapons
        tf_weapon_wrench                - Engie's wrenches, to prevent refilling/repairing/upgrading non-Friendly buildings
*/
#define DEFAULT_BLOCKED_WEAPONS "656,447,44,58,1083,222,305,1079,528,997"
/* Default blocked weapons are:
        656  - Holiday Punch, to prevent taunt forcing
        447  - Disciplinary Action, to prevent speed buff
        44  - Sandman, to prevent ball stun
        58  - Jarate, to prevent mini-crits
        1083 - Festive Jarate, to prevent mini-crits
        1105 - The Self-Aware Beauty Mark
        222  - Mad Milk, to prevent healing
        1121 - Mutated Milk, to prevent healing
        305  - Crusader's Crossbow, to prevent healing
        1079 - Festive Crusader's Crossbow, to prevent healing
        997  - Rescue Ranger, to prevent repairing non-Friendly buildings
        528  - Short Circuit, to prevent projectile destruction
*/
#define DEFAULT_WHITELISTED_WEAPONS "594,159,433"
/* Default whitelisted weapons are:
        594  - Phlogistinator, cannot airblast
        159  - Dalokohs Bar, cannot be thrown
        433  - Fishcake, cannot be thrown
*/
#define DEFAULT_BLOCKED_TAUNTS "37,1003,304,56,1005,142"
/* Default taunt-blocked weapons are:
        37  - Ubersaw
        1003 - Festive Ubersaw
        304  - Amputator
        56  - Huntsman
        1005 - Festive Huntsman
        142  - Gunslinger
*/

enum f_invulnmode {
        INVULNMODE_GODMODE = 0,
        INVULNMODE_GOD = 0,
        INVULNMODE_BUDDAH = 1,
        INVULNMODE_BUDDHA = 1,
        INVULNMODE_MORTAL = 2,
};

int FriendlyPlayerCount;

bool IsFriendly[MAXPLAYERS+1];
bool RequestedChange[MAXPLAYERS+1];
bool IsAdmin[MAXPLAYERS+1];
bool RFETRIZ[MAXPLAYERS+1];
bool IsInSpawn[MAXPLAYERS+1];
bool IsLocked[MAXPLAYERS+1];
float ToggleTimer[MAXPLAYERS+1];
float AfkTime[MAXPLAYERS+1];
int p_lastbtnstate[MAXPLAYERS+1];

ConVar cvar_enabled;
ConVar cvar_logging;
ConVar cvar_maxfriendlies;
ConVar cvar_delay;
ConVar cvar_afklimit;
ConVar cvar_afkinterval;

ConVar cvar_action_h;
ConVar cvar_action_f;
ConVar cvar_action_h_spawn;
ConVar cvar_action_f_spawn;
ConVar cvar_remember;
ConVar cvar_goomba;
ConVar cvar_blockrtd;
//ConVar cvar_botignore;
//ConVar cvar_settransmit;

ConVar cvar_stopcap;
ConVar cvar_stopintel;
ConVar cvar_ammopack;
ConVar cvar_healthpack;
ConVar cvar_money;
ConVar cvar_spellbook;
ConVar cvar_pumpkin;
ConVar cvar_airblastkill;
ConVar cvar_funcbutton;
ConVar cvar_usetele;

ConVar cvar_blockweps_black;
int g_blockweps_black[255];
ConVar cvar_blockweps_classes;
char g_blockweps_classes[255][64];
ConVar cvar_blockweps_white;
int g_blockweps_white[255];
ConVar cvar_blocktaunt;
int g_blocktaunt[255];

ConVar cvar_invuln_p;
ConVar cvar_invuln_s;
ConVar cvar_invuln_d;
ConVar cvar_invuln_t;

ConVar cvar_notarget_p;
ConVar cvar_notarget_s;
ConVar cvar_notarget_d;
ConVar cvar_notarget_t;

ConVar cvar_noblock_p;
ConVar cvar_noblock_s;
ConVar cvar_noblock_d;
ConVar cvar_noblock_t;

ConVar cvar_alpha_p;
ConVar cvar_alpha_w;
ConVar cvar_alpha_wep;
ConVar cvar_alpha_s;
ConVar cvar_alpha_d;
ConVar cvar_alpha_t;
ConVar cvar_alpha_proj;

ConVar cvar_nobuild_s;
ConVar cvar_nobuild_d;
ConVar cvar_nobuild_t;
ConVar cvar_killbuild_h_s;
ConVar cvar_killbuild_h_d;
ConVar cvar_killbuild_h_t;
ConVar cvar_killbuild_f_s;
ConVar cvar_killbuild_f_d;
ConVar cvar_killbuild_f_t;


Handle h_timer_afkcheck;

Handle hfwd_CanToggleFriendly;
Handle hfwd_FriendlyPre;
Handle hfwd_Friendly;
Handle hfwd_FriendlyPost;
Handle hfwd_HostilePre;
Handle hfwd_Hostile;
Handle hfwd_HostilePost;
Handle hfwd_RefreshPre;
Handle hfwd_Refresh;
Handle hfwd_RefreshPost;
Handle hfwd_FriendlySpawn;
Handle hfwd_FriendlyEnable;
Handle hfwd_FriendlyDisable;
Handle hfwd_FriendlyLoad;
Handle hfwd_FriendlyUnload;

Handle g_hWeaponReset;

Handle g_hFriendlyEnabled;
Handle g_hFriendlyLockEnabled;

int g_minigunoffsetstate;


public Plugin myinfo = {
        name = "[FZG] Friendly Mode",
        author = "Derek D. Howard / TheXeon",
        description = "Allows players to become invulnerable to damage from other players, while also being unable to attack other players.",
        version = "1.6.1",
        url = "http://forums.alliedmods.net/showthread.php?t=213205"
}

public APLRes AskPluginLoad2(Handle hMyself, bool bLate, char[] strError, int iErr_Max)
{
        char strGame[32];
        GetGameFolderName(strGame, sizeof(strGame));
        if (!StrEqual(strGame, "tf")) {
                Format(strError, iErr_Max, "This plugin only works for Team Fortress 2");
                return APLRes_Failure;
        }
        CreateNative("TF2Friendly_IsFriendly", Native_CheckIfFriendly);
        CreateNative("TF2Friendly_SetFriendly", Native_SetFriendly);
        CreateNative("TF2Friendly_IsLocked", Native_CheckIfFriendlyLocked);
        CreateNative("TF2Friendly_SetLock", Native_SetFriendlyLock);
        CreateNative("TF2Friendly_IsAdmin", Native_CheckIfFriendlyAdmin);
        CreateNative("TF2Friendly_SetAdmin", Native_SetFriendlyAdmin);
        CreateNative("TF2Friendly_RefreshFriendly", Native_RefreshFriendly);
        CreateNative("TF2Friendly_IsPluginEnabled", Native_CheckPluginEnabled);
        RegPluginLibrary("[TF2] Friendly Mode");

        return APLRes_Success;
}

public void OnPluginStart()
{
        g_minigunoffsetstate = FindSendPropInfo("CTFMinigun", "m_iWeaponState");

        LoadTranslations("common.phrases");

        for (int client = 1; client <= MaxClients; client++) {
                if (IsValidClient(client)) {
                        OnClientPutInServer(client);
                }
        }

        cvar_enabled = CreateConVar("sm_friendly_enabled", "1", "(0/1) Enables/Disables Friendly Mode", _, true, 0.0, true, 1.0);

        cvar_logging = CreateConVar("sm_friendly_logging", "2", "(0/1/2/3) 0 = No logging, 1 = Log admins targeting others, 2 = (1 + Log players using sm_friendly), 3 = (2 + list all players affected by admin commands).", _, true, 0.0, true, 3.0);
        cvar_maxfriendlies = CreateConVar("sm_friendly_maxfriendlies", "32", "(Any positive integer) This sets a limit how many players can simultaneously be Friendly.", _, true, 0.0);
        cvar_delay = CreateConVar("sm_friendly_delay", "5.0", "(Any non-negative value) How long, in seconds, must a player wait after changing modes until he can use sm_friendly again?", _, true, 0.0);
        cvar_afklimit = CreateConVar("sm_friendly_afklimit", "300", "(Any non-negative integer) Time in seconds players can be AFK before being moved out of Friendly mode. Set to 0 to disable.", _, true, 0.0);
        cvar_afkinterval = CreateConVar("sm_friendly_afkinterval", "1.0", "Time in seconds between AFK checks. This should be a very low value, between 0.1 and 5.0, and should only be as high as 5.0 if you notice that the checks are causing lag.", _, true, 0.1, true, 5.0);

        cvar_action_h = CreateConVar("sm_friendly_action_h", "-2", "(Any integer, -2 or greater) What action to take on living players who want to become Hostile? See this plugin's thread for details.", _, true, -2.0);
        cvar_action_f = CreateConVar("sm_friendly_action_f", "-2", "(Any integer, -2 or greater) What action to take on living players who want to become Friendly? See this plugin's thread for details.", _, true, -2.0);
        cvar_action_h_spawn = CreateConVar("sm_friendly_action_h_spawn", "0", "(Any integer, -2 or greater) Same as sm_friendly_action_h, but applies to players in a spawn room.", _, true, -2.0);
        cvar_action_f_spawn = CreateConVar("sm_friendly_action_f_spawn", "0", "(Any integer, -2 or greater) Same as sm_friendly_action_f, but applies to players in a spawn room.", _, true, -2.0);
        cvar_remember = CreateConVar("sm_friendly_remember", "0", "(0/1) If enabled, a player who somehow dies while Friendly be Friendly upon respawn.", _, true, 0.0, true, 1.0);
        cvar_goomba = CreateConVar("sm_friendly_goomba", "1", "(0/1) If enabled, Goomba Stomp will follow the same damage rules of Friendly mode as regular attacks.", _, true, 0.0, true, 1.0);
        cvar_blockrtd = CreateConVar("sm_friendly_blockrtd", "1", "(0/1) If enabled, Friendly players will be unable to activate Roll The Dice.", _, true, 0.0, true, 1.0);
        //cvar_botignore = CreateConVar("sm_friendly_botignore", "1", "(0/1) If enabled, friendly players will be invisible to bots.", _, true, 0.0, true, 1.0);
        //cvar_settransmit = CreateConVar("sm_friendly_settransmit", "0", "(0/1/2) 0 = Disabled, 1 = Friendlies will be invisible to non-Friendlies, 2 = No visibility between Friendlies and non-Friendlies", _);

        cvar_stopcap = CreateConVar("sm_friendly_stopcap", "1", "(0/1) If enabled, Friendly players will be unable to cap points or push carts.", _, true, 0.0, true, 1.0);
        cvar_stopintel = CreateConVar("sm_friendly_stopintel", "1", "(0/1) If enabled, Friendly players will be unable to grab the intel.", _, true, 0.0, true, 1.0);
        cvar_ammopack = CreateConVar("sm_friendly_ammopack", "1", "(0/1) If enabled, Friendly players will be unable to pick up ammo boxes, dropped weapons, or Sandman balls.", _, true, 0.0, true, 1.0);
        cvar_healthpack = CreateConVar("sm_friendly_healthpack", "1", "(0/1) If enabled, Friendly players will be unable to pick up health boxes or sandviches.", _, true, 0.0, true, 1.0);
        cvar_spellbook = CreateConVar("sm_friendly_spellbook", "1", "(0/1) If enabled, Friendly players will be unable to pick up spellbooks.", _, true, 0.0, true, 1.0);
        cvar_money = CreateConVar("sm_friendly_money", "1", "(0/1) If enabled, Friendly players will be unable to pick up MvM money.", _, true, 0.0, true, 1.0);
        cvar_pumpkin = CreateConVar("sm_friendly_pumpkin", "1", "(0/1) If enabled, Friendly players will be unable to blow up pumpkins.", _, true, 0.0, true, 1.0);
        cvar_airblastkill = CreateConVar("sm_friendly_airblastkill", "1", "(0/1) If enabled, Friendly projectiles will vanish upon being airblasted by non-Friendly pyros.", _, true, 0.0, true, 1.0);
        cvar_funcbutton = CreateConVar("sm_friendly_funcbutton", "0", "(0/1) If enabled, Friendly projectiles will be unable to trigger func_buttons by damaging them.", _, true, 0.0, true, 1.0);
        cvar_usetele = CreateConVar("sm_friendly_usetele", "3", "(0/1/2/3) who can use what teleporter? See thread for usage.", _, true, 0.0, true, 3.0);

        cvar_blockweps_classes = CreateConVar("sm_friendly_blockwep_classes", "-2", "What weapon classes to block? Set to 0 to disable, 1 to use defaults, or enter a custom list here, seperated by commas.", _);
        cvar_blockweps_black = CreateConVar("sm_friendly_blockweps", "-2", "What weapon index definiteion numbers to block? Set to 0 to disable, 1 to use defaults, or enter a custom list here, seperated by commas.", _);
        cvar_blockweps_white = CreateConVar("sm_friendly_blockweps_whitelist", "-2", "What weapon index definiteion numbers to whitelist? Set to 0 to disable, 1 to use defaults, or enter a custom list here, seperated by commas.", _);
        cvar_blocktaunt = CreateConVar("sm_friendly_blocktaunt", "-2", "What weapon index definition numbers to block taunting with? Set to 0 to disable, 1 to use defaults, or enter a custom list here, seperated by commas.", _);

        cvar_invuln_p = CreateConVar("sm_friendly_invuln", "1", "(0/1/2/3) 0 = Friendly players have full godmode. 1 = Buddha. 2 = Only invulnerable to other players. 3 = Invuln to other players AND himself.", _, true, 0.0, true, 3.0);
        cvar_invuln_s = CreateConVar("sm_friendly_invuln_s", "1", "(0/1/2) 0 = Disabled, 1 = Friendly sentries will be invulnerable to other players, 2 = Friendly sentries have full Godmode.", _, true, 0.0, true, 2.0);
        cvar_invuln_d = CreateConVar("sm_friendly_invuln_d", "1", "(0/1/2) 0 = Disabled, 1 = Friendly dispensers will be invulnerable to other players, 2 = Friendly dispensers have full Godmode.", _, true, 0.0, true, 2.0);
        cvar_invuln_t = CreateConVar("sm_friendly_invuln_t", "1", "(0/1/2) 0 = Disabled, 1 = Friendly teleporters will be invulnerable to other players, 2 = Friendly teleporters have full Godmode.", _, true, 0.0, true, 2.0);

        cvar_notarget_p = CreateConVar("sm_friendly_notarget", "1", "(0/1/2/3) If enabled, a Friendly player will be invisible to sentries, immune to airblasts, etc.", _, true, 0.0, true, 3.0);
        cvar_notarget_s = CreateConVar("sm_friendly_notarget_s", "1", "(0/1) If enabled, a Friendly player's sentry will be invisible to enemy sentries.", _, true, 0.0, true, 1.0);
        cvar_notarget_d = CreateConVar("sm_friendly_notarget_d", "1", "(0/1) If enabled, a Friendly player's dispenser will be invisible to enemy sentries. Friendly dispensers will have their healing act buggy.", _, true, 0.0, true, 1.0);
        cvar_notarget_t = CreateConVar("sm_friendly_notarget_t", "1", "(0/1) If enabled, a Friendly player's teleporters will be invisible to enemy sentries.", _, true, 0.0, true, 1.0);

        cvar_alpha_p = CreateConVar("sm_friendly_alpha", "80", "(Any integer, -1 thru 255) Sets the transparency of Friendly players. -1 disables this feature.", _, true, -1.0, true, 255.0);
        cvar_alpha_w = CreateConVar("sm_friendly_alpha_w", "80", "(Any integer, -1 thru 255) Sets the transparency of Friendly players' cosmetics. -1 disables this feature.", _, true, -1.0, true, 255.0);
        cvar_alpha_wep = CreateConVar("sm_friendly_alpha_wep", "80", "(Any integer, -1 thru 255) Sets the transparency of Friendly players' weapons. -1 disables this feature.", _, true, -1.0, true, 255.0);
        cvar_alpha_s = CreateConVar("sm_friendly_alpha_s", "80", "(Any integer, -1 thru 255) Sets the transparency of Friendly sentries. -1 disables this feature.", _, true, -1.0, true, 255.0);
        cvar_alpha_d = CreateConVar("sm_friendly_alpha_d", "80", "(Any integer, -1 thru 255) Sets the transparency of Friendly dispensers. -1 disables this feature.", _, true, -1.0, true, 255.0);
        cvar_alpha_t = CreateConVar("sm_friendly_alpha_t", "80", "(Any integer, -1 thru 255) Sets the transparency of Friendly teleporters. -1 disables this feature.", _, true, -1.0, true, 255.0);
        cvar_alpha_proj = CreateConVar("sm_friendly_alpha_proj", "80", "(Any integer, -1 thru 255) Sets the transparency of Friendly players' projectiles. -1 disables this feature.", _, true, -1.0, true, 255.0);

        cvar_noblock_p = CreateConVar("sm_friendly_noblock", "2", "(0/1/2/3) Sets the collision group of Friendly players, see the forum thread for details.", _, true, 0.0, true, 3.0);
        cvar_noblock_s = CreateConVar("sm_friendly_noblock_s", "3", "(0/1/2/3) Sets the collision group of Friendly sentries, see the forum thread for details.", _, true, 0.0, true, 3.0);
        cvar_noblock_d = CreateConVar("sm_friendly_noblock_d", "3", "(0/1/2/3) Sets the collision group of Friendly dispensers, see the forum thread for details.", _, true, 0.0, true, 3.0);
        cvar_noblock_t = CreateConVar("sm_friendly_noblock_t", "3", "(0/1/2/3) Sets the collision group of Friendly teleporters, see the forum thread for details.", _, true, 0.0, true, 3.0);

        cvar_killbuild_h_s = CreateConVar("sm_friendly_killsentry", "1", "(0/1) When enabled, a Friendly Engineer's sentry will vanish upon becoming hostile.", _, true, 0.0, true, 1.0);
        cvar_killbuild_h_d = CreateConVar("sm_friendly_killdispenser", "1", "(0/1) When enabled, a Friendly Engineer's dispenser will vanish upon becoming hostile.", _, true, 0.0, true, 1.0);
        cvar_killbuild_h_t = CreateConVar("sm_friendly_killtele", "1", "(0/1) When enabled, a Friendly Engineer's teleporters will vanish upon becoming hostile.", _, true, 0.0, true, 1.0);
        cvar_killbuild_f_s = CreateConVar("sm_friendly_killsentry_f", "1", "(0/1) When enabled, an Engineer's sentry will vanish upon becoming Friendly.", _, true, 0.0, true, 1.0);
        cvar_killbuild_f_d = CreateConVar("sm_friendly_killdispenser_f", "1", "(0/1) When enabled, an Engineer's dispenser will vanish upon becoming Friendly.", _, true, 0.0, true, 1.0);
        cvar_killbuild_f_t = CreateConVar("sm_friendly_killtele_f", "1", "(0/1) When enabled, an Engineer's teleporters will vanish upon becoming Friendly.", _, true, 0.0, true, 1.0);
        cvar_nobuild_s = CreateConVar("sm_friendly_nobuild_s", "0", "(0/1) When enabled, a Friendly engineer will not be able to build sentries.", _, true, 0.0, true, 1.0);
        cvar_nobuild_d = CreateConVar("sm_friendly_nobuild_d", "0", "(0/1) When enabled, a Friendly engineer will not be able to build dispensers.", _, true, 0.0, true, 1.0);
        cvar_nobuild_t = CreateConVar("sm_friendly_nobuild_t", "0", "(0/1) a Friendly engineer will not be able to build teleporters.", _, true, 0.0, true, 1.0);

        RegAdminCmd("sm_friendly", UseFriendlyCmd, 0, "Toggles Friendly Mode");
        RegAdminCmd("sm_unfriendly", UseFriendlyCmd, 0, "Toggles Friendly Mode, made for the confused");
        RegAdminCmd("sm_friendly_admin", UseAdminCmd, ADMFLAG_BAN, "Toggles Friendly Admin Mode");
        RegAdminCmd("sm_friendly_a", UseAdminCmd2, 0, _);
        RegAdminCmd("sm_friendly_lock", UseLockCmd, ADMFLAG_BAN, "Blocks a player from using sm_friendly (with no arguments).");
        RegAdminCmd("sm_friendly_l", UseLockCmd2, 0, _);

        HookEvent("player_spawn", OnPlayerSpawned);
        HookEvent("player_builtobject", Object_Built);
        HookEvent("player_sapped_object", Object_Sapped);
        HookEvent("post_inventory_application", Inventory_App);
        HookEvent("object_deflected", Airblast);

        AutoExecConfig(true, "friendly");

        AddNormalSoundHook(Hook_NormalSound);

        AddCommandListener(TauntCmd, "taunt");
        AddCommandListener(TauntCmd, "+taunt");

        AddCommandListener(OnClientSpeaks, "say");
        AddCommandListener(OnClientSpeaks, "say_team");

        AddMultiTargetFilter("@friendly", TargetFriendlies, "Friendly players", false);
        AddMultiTargetFilter("@friendlies", TargetFriendlies, "Friendly players", false);
        AddMultiTargetFilter("@!friendly", TargetHostiles, "non-Friendly players", false);
        AddMultiTargetFilter("@!friendlies", TargetHostiles, "non-Friendly players", false);
        AddMultiTargetFilter("@friendlyadmins", TargetFriendlyAdmins, "players in Friendly Admin mode", false);
        AddMultiTargetFilter("@!friendlyadmins", TargetFriendlyNonAdmins, "players not in Friendly Admin mode", false);
        AddMultiTargetFilter("@friendlylocked", TargetFriendlyLocked, "Friendly-locked players", false);
        AddMultiTargetFilter("@!friendlylocked", TargetFriendlyUnlocked, "non Friendly-locked players", false);

        hfwd_CanToggleFriendly = CreateGlobalForward("TF2Friendly_CanToggleFriendly", ET_Event, Param_Cell);
        hfwd_FriendlyPre = CreateGlobalForward("TF2Friendly_OnEnableFriendly_Pre", ET_Ignore, Param_Cell);
        hfwd_Friendly = CreateGlobalForward("TF2Friendly_OnEnableFriendly", ET_Ignore, Param_Cell);
        hfwd_FriendlyPost = CreateGlobalForward("TF2Friendly_OnEnableFriendly_Post", ET_Ignore, Param_Cell);
        hfwd_HostilePre = CreateGlobalForward("TF2Friendly_OnDisableFriendly_Pre", ET_Ignore, Param_Cell);
        hfwd_Hostile = CreateGlobalForward("TF2Friendly_OnDisableFriendly", ET_Ignore, Param_Cell);
        hfwd_HostilePost = CreateGlobalForward("TF2Friendly_OnDisableFriendly_Post", ET_Ignore, Param_Cell);
        hfwd_RefreshPre = CreateGlobalForward("TF2Friendly_OnRefreshFriendly_Pre", ET_Ignore, Param_Cell);
        hfwd_Refresh = CreateGlobalForward("TF2Friendly_OnRefreshFriendly", ET_Ignore, Param_Cell);
        hfwd_RefreshPost = CreateGlobalForward("TF2Friendly_OnRefreshFriendly_Post", ET_Ignore, Param_Cell);
        hfwd_FriendlySpawn = CreateGlobalForward("TF2Friendly_OnFriendlySpawn", ET_Ignore, Param_Cell);
        hfwd_FriendlyEnable = CreateGlobalForward("TF2Friendly_OnPluginEnabled", ET_Ignore);
        hfwd_FriendlyDisable = CreateGlobalForward("TF2Friendly_OnPluginDisabled", ET_Ignore);
        hfwd_FriendlyLoad = CreateGlobalForward("TF2Friendly_OnPluginLoaded", ET_Ignore);
        hfwd_FriendlyUnload = CreateGlobalForward("TF2Friendly_OnPluginUnloaded", ET_Ignore);

        g_hFriendlyEnabled = RegClientCookie("friendly", "If in friendly or not.", CookieAccess_Private);
        g_hFriendlyLockEnabled = RegClientCookie("friendlylocked", "If in friendly lock or not.", CookieAccess_Private);

        char file[PLATFORM_MAX_PATH];
        BuildPath(Path_SM, file, sizeof(file), "gamedata/friendly.txt");
        if (FileExists(file)) {
                Handle hConf = LoadGameConfigFile("friendly");
                if (hConf != null) {
                        StartPrepSDKCall(SDKCall_Entity);
                        PrepSDKCall_SetFromConf(hConf, SDKConf_Virtual, "WeaponReset");
                        g_hWeaponReset = EndPrepSDKCall();
                        if(g_hWeaponReset == null) {
                                LogError("Could not initialize call for CTFWeaponBase::WeaponReset. Plugin will not be able to reset weapons before switching!");
                        }
                }
                CloseHandle(hConf);
        }
        else {
                LogError("Could not read gamedata/friendly.txt. Plugin will not be able to reset weapons before switching!");
        }
        for (int i = 1; i < MaxClients; i++)
    {
        if (!AreClientCookiesCached(i))
        {
            continue;
        }

        OnClientCookiesCached(i);
    }
}

public void OnClientCookiesCached(int client)
{
        char sFriendlyValue[8];
        char sFriendlyLockValue[8];

        GetClientCookie(client, g_hFriendlyEnabled, sFriendlyValue, sizeof(sFriendlyValue));
        GetClientCookie(client, g_hFriendlyLockEnabled, sFriendlyLockValue, sizeof(sFriendlyLockValue));

        if (StringToInt(sFriendlyValue) == 1) IsFriendly[client] = true;
        if (StringToInt(sFriendlyLockValue) == 1) IsLocked[client] = true;
}

public void OnConfigsExecuted() {
        cvarChange(null, "0", "0");

        Call_StartForward(hfwd_FriendlyLoad);
        Call_Finish();
}

public Action UseFriendlyCmd(int client, int args)
{
        int numargs = GetCmdArgs();
        int[] target = new int[MaxClients];
        char target_name[MAX_TARGET_LENGTH];
        int direction = -1;
        int method = 0;
        int numtargets;
        if (!cvar_enabled.BoolValue) {
                CReplyToCommand(client, "%s Friendly Mode is currently disabled.", CHAT_PREFIX);
                return Plugin_Handled;
        }
        if (numargs == 0 || !CheckCommandAccess(client, "sm_friendly_targetothers", ADMFLAG_BAN, true)) {
                UseFriendlyOnSelf(client);
                return Plugin_Handled;
        }
        if (numargs > 3) {
                CReplyToCommand(client, "%s Usage: \"sm_friendly [target] [-1/0/1] [1]\"", CHAT_PREFIX);
                return Plugin_Handled;
        }
        if (numargs >= 1) {
                char arg1[64];
                bool tn_is_ml;
                GetCmdArg(1, arg1, sizeof(arg1));
                if ((numtargets = ProcessTargetString(arg1, client, target, MaxClients, 0, target_name, sizeof(target_name), tn_is_ml)) <= 0) {
                        ReplyToTargetError(client, numtargets);
                        return Plugin_Handled;
                }
        }
        if (numargs >= 2) {
                char arg2[2];
                GetCmdArg(2, arg2, sizeof(arg2));
                direction = StringToInt(arg2);
                if (!(direction == -1 || direction == 0 || direction == 1)) {
                        CReplyToCommand(client, "%s Second argument must be either 0 or 1. 0 to disable Friendly, or 1 to enable.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
        }
        if (numargs == 3) {
                char arg3[2];
                GetCmdArg(3, arg3, sizeof(arg3));
                method = StringToInt(arg3);
                if (!(method == 1 || method == 0)) {
                        CReplyToCommand(client, "%s Third argument must be either 0 or 1. 0 to toggle Friendly instantly, or 1 to slay the player.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
        }
        if (numtargets == 1) {
                int singletarget = target[0];
                if (IsFriendly[singletarget] && direction == 1) {
                        CReplyToCommand(client, "%s That player is already Friendly!", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (!IsFriendly[singletarget] && direction == 0) {
                        CReplyToCommand(client, "%s That player is already non-Friendly.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
        }
        int count;
        if (direction == -1) {
                for (int i = 0; i < numtargets; i++) {
                        int currenttarget = target[i];
                        if (IsFriendly[currenttarget]) {
                                MakeClientHostile(currenttarget);
                                count++;
                                if (currenttarget != client) {
                                        CPrintToChat(currenttarget, "%s An admin has forced you out of Friendly Mode.", CHAT_PREFIX);
                                }
                                if (method == 1 && !IsAdmin[currenttarget]) {
                                        KillPlayer(currenttarget);
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" disabled Friendly mode on \"%L\".", client, currenttarget);
                                }
                        }
                        else {
                                MakeClientFriendly(currenttarget);
                                count++;
                                if (currenttarget != client) {
                                        CPrintToChat(currenttarget, "%s An admin has forced you into Friendly Mode.", CHAT_PREFIX);
                                }
                                if (IsPlayerAlive(currenttarget)) {
                                        if (method == 1 && !IsAdmin[currenttarget]) {
                                                KillPlayer(currenttarget);
                                                if (!cvar_remember.BoolValue) {
                                                        RFETRIZ[currenttarget] = true;
                                                }
                                        }
                                }
                                else {
                                        if (!cvar_remember.BoolValue) {
                                                RFETRIZ[currenttarget] = true;
                                        }
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" enabled Friendly mode on \"%L\".", client, currenttarget);
                                }
                        }
                }
                if (count < 1) {
                        CReplyToCommand(client, "%s No players were affected.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (numtargets > 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Toggled Friendly on %s, affecting %i players.", target_name, count);
                        if (cvar_logging.IntValue > 0 && cvar_logging.IntValue < 3) {
                                LogAction(client, -1, "\"%L\" toggled Friendly mode on %s.", client, target_name);
                        }
                        else if (cvar_logging.IntValue >= 3) {
                                LogAction(client, -1, "\"%L\" toggled Friendly mode on %s, affecting the previous %i players.", client, target_name, count);
                        }
                }
                else if (numtargets == 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Toggled Friendly on %s.", target_name);
                }
        }
        if (direction == 1) {
                for (int i = 0; i < numtargets; i++) {
                        int currenttarget = target[i];
                        if (!IsFriendly[currenttarget]) {
                                MakeClientFriendly(currenttarget);
                                count++;
                                if (currenttarget != client) {
                                        CPrintToChat(currenttarget, "%s An admin has forced you into Friendly Mode.", CHAT_PREFIX);
                                }
                                if (IsPlayerAlive(currenttarget)) {
                                        if (method == 1 && !IsAdmin[currenttarget]) {
                                                KillPlayer(currenttarget);
                                                if (!cvar_remember.BoolValue) {
                                                        RFETRIZ[currenttarget] = true;
                                                }
                                        }
                                }
                                else {
                                        if (!cvar_remember.BoolValue) {
                                                RFETRIZ[currenttarget] = true;
                                        }
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" enabled Friendly mode on \"%L\".", client, currenttarget);
                                }
                        }
                }
                if (count < 1) {
                        CReplyToCommand(client, "%s No players were affected.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (numtargets > 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Enabled Friendly on %s, affecting %i players.", target_name, count);
                        if (cvar_logging.IntValue > 0 && cvar_logging.IntValue < 3) {
                                LogAction(client, -1, "\"%L\" enabled Friendly mode on %s.", client, target_name);
                        }
                        else if (cvar_logging.IntValue >= 3) {
                                LogAction(client, -1, "\"%L\" enabled Friendly mode on %s, affecting the previous %i players.", client, target_name, count);
                        }
                }
                else if (numtargets == 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Enabled Friendly on %s.", target_name);
                }
        }
        if (direction == 0) {
                for (int i = 0; i < numtargets; i++) {
                        int currenttarget = target[i];
                        if (IsFriendly[currenttarget]) {
                                MakeClientHostile(currenttarget);
                                count++;
                                if (currenttarget != client) {
                                        CPrintToChat(currenttarget, "%s An admin has forced you out of Friendly Mode.", CHAT_PREFIX);
                                }
                                if (method == 1 && !IsAdmin[currenttarget]) {
                                        KillPlayer(currenttarget);
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" disabled Friendly mode on \"%L\".", client, currenttarget);
                                }
                        }
                }
                if (count < 1) {
                        CReplyToCommand(client, "%s No players were affected.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (numtargets > 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Disabled Friendly on %s, affecting %i players.", target_name, count);
                        if (cvar_logging.IntValue > 0 && cvar_logging.IntValue < 3) {
                                LogAction(client, -1, "\"%L\" disabled Friendly mode on %s.", client, target_name);
                        }
                        else if (cvar_logging.IntValue >= 3) {
                                LogAction(client, -1, "\"%L\" disabled Friendly mode on %s, affecting the previous %i players.", client, target_name, count);
                        }
                }
                else if (numtargets == 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Disabled Friendly on %s.", target_name);
                }
        }
        return Plugin_Handled;
}

void UseFriendlyOnSelf(const int client) {
        if (client == 0) {
                CReplyToCommand(client, "%s Not a valid client. You must be in the game to use sm_friendly.", CHAT_PREFIX);
                return;
        }
        if (IsLocked[client]) {
                CReplyToCommand(client, "%s You are locked out of toggling Friendly mode!", CHAT_PREFIX);
                return;
        }
        if (GetForwardFunctionCount(hfwd_CanToggleFriendly) > 0) {
                Call_StartForward(hfwd_CanToggleFriendly);
                Call_PushCell(client);
                Action result = Plugin_Continue;
                Call_Finish(result);
                if (result != Plugin_Continue) {
                        return;
                }
        }
        float time = GetEngineTime();
        if (time < ToggleTimer[client]) {
                CReplyToCommand(client, "%s You must wait %d seconds.", CHAT_PREFIX, RoundToCeil(ToggleTimer[client] - time));
                return;
        }
        if (IsPlayerAlive(client)) {
                if (RequestedChange[client]) {
                        RequestedChange[client] = false;
                        CReplyToCommand(client, "%s You will not toggle Friendly mode upon respawning.", CHAT_PREFIX);
                }
                else {
                        int action;
                        if (IsFriendly[client]) {
                                if (IsInSpawn[client]) {
                                        action = cvar_action_h_spawn.IntValue;
                                }
                                else {
                                        action = cvar_action_h.IntValue;
                                }
                                if (IsAdmin[client]) {
                                        MakeClientHostile(client);
                                        CReplyToCommand(client, "%s You are no longer Friendly.", CHAT_PREFIX);
                                        FakeClientCommand(client, "voicemenu 2 1"); //"Battle Cry"
                                        if (cvar_logging.IntValue >= 2) {
                                                LogAction(client, -1, "\"%L\" deactivated Friendly mode.", client);
                                        }
                                }
                                else if (action == -2) {
                                        CReplyToCommand(client, "%s You will not be Friendly upon respawning.", CHAT_PREFIX);
                                        RequestedChange[client] = true;
                                }
                                else if (action == -1) {
                                        CReplyToCommand(client, "%s You will not be Friendly upon respawning.", CHAT_PREFIX);
                                        RequestedChange[client] = true;
                                        FakeClientCommand(client, "voicemenu 0 7"); //"No"
                                        KillPlayer(client);
                                }
                                else if (action == 0) {
                                        MakeClientHostile(client);
                                        CReplyToCommand(client, "%s You are no longer Friendly.", CHAT_PREFIX);
                                        FakeClientCommand(client, "voicemenu 2 1"); //"Battle Cry"
                                        if (cvar_logging.IntValue >= 2) {
                                                LogAction(client, -1, "\"%L\" deactivated Friendly mode.", client);
                                        }
                                }
                                else if (action > 0) {
                                        MakeClientHostile(client);
                                        SlapPlayer(client, action);
                                        CReplyToCommand(client, "%s You are no longer Friendly, but took damage because of the switch!", CHAT_PREFIX);
                                        if (cvar_logging.IntValue >= 2) {
                                                LogAction(client, -1, "\"%L\" deactivated Friendly mode.", client);
                                        }
                                }
                        }
                        else {
                                if (IsInSpawn[client]) {
                                        action = cvar_action_f_spawn.IntValue;
                                }
                                else {
                                        action = cvar_action_f.IntValue;
                                }
                                if (IsAdmin[client]) {
                                        MakeClientFriendly(client);
                                        CReplyToCommand(client, "%s You are now Friendly.", CHAT_PREFIX);
                                        FakeClientCommand(client, "voicemenu 2 4"); //"Positive"
                                        if (cvar_logging.IntValue >= 2) {
                                                LogAction(client, -1, "\"%L\" activated Friendly mode.", client);
                                        }
                                }
                                else if (action == -2) {
                                        CReplyToCommand(client, "%s You will be Friendly upon respawning.", CHAT_PREFIX);
                                        RequestedChange[client] = true;
                                }
                                else if (action == -1) {
                                        CReplyToCommand(client, "%s You will be Friendly upon respawning.", CHAT_PREFIX);
                                        RequestedChange[client] = true;
                                        FakeClientCommand(client, "voicemenu 0 7"); //"No"
                                        KillPlayer(client);
                                }
                                else if (action == 0) {
                                        if (FriendlyPlayerCount < cvar_maxfriendlies.IntValue) {
                                                if (cvar_logging.IntValue >= 2) {
                                                        LogAction(client, -1, "\"%L\" activated Friendly mode.", client);
                                                }
                                                MakeClientFriendly(client);
                                                CReplyToCommand(client, "%s You are now Friendly.", CHAT_PREFIX);
                                                FakeClientCommand(client, "voicemenu 2 4"); //"Positive"
                                        }
                                        else {
                                                CReplyToCommand(client, "%s There are too many Friendly players already!", CHAT_PREFIX);
                                        }
                                }
                                else if (action > 0) {
                                        if (FriendlyPlayerCount < cvar_maxfriendlies.IntValue) {
                                                if (cvar_logging.IntValue >= 2) {
                                                        LogAction(client, -1, "\"%L\" activated Friendly mode.", client);
                                                }
                                                MakeClientFriendly(client);
                                                CReplyToCommand(client, "%s You were made Friendly, but took damage because of the switch!", CHAT_PREFIX);
                                                SlapPlayer(client, action);
                                        }
                                        else {
                                                CReplyToCommand(client, "%s There are too many Friendly players already!", CHAT_PREFIX);
                                        }
                                }
                        }
                }
        }
        else {
                if (RequestedChange[client]) {
                        RequestedChange[client] = false;
                        CReplyToCommand(client, "%s You will not toggle Friendly mode upon respawning.", CHAT_PREFIX);
                        if (IsFriendly[client] && !cvar_remember.BoolValue) {
                                RFETRIZ[client] = true;
                        }
                }
                else {
                        RequestedChange[client] = true;
                        CReplyToCommand(client, "%s You will toggle Friendly mode upon respawning.", CHAT_PREFIX);
                        RFETRIZ[client] = false;
                }
        }
}

public Action UseAdminCmd(int client, int args) {
        int target[MAXPLAYERS];
        char target_name[MAX_TARGET_LENGTH];
        int direction = -1;
        int numtargets;
        if (!cvar_enabled.BoolValue) {
                CReplyToCommand(client, "%s Friendly Mode is currently disabled.", CHAT_PREFIX);
                return Plugin_Handled;
        }
        int numargs = GetCmdArgs();
        if (numargs == 0 || !CheckCommandAccess(client, "sm_friendly_admin_targetothers", ADMFLAG_ROOT, true)) {
                if (client != 0) {
                        if (IsAdmin[client]) {
                                IsAdmin[client] = false;
                                CShowActivity2(client, CHAT_PREFIX_SPACE, "Disabled Friendly Admin mode.");
                                if (cvar_logging.IntValue > 0) {
                                        LogAction(client, -1, "\"%L\" disabled Friendly Admin mode.", client);
                                }
                                if (cvar_stopintel.BoolValue && IsFriendly[client]) {
                                        FakeClientCommand(client, "dropitem");
                                }
                        }
                        else {
                                IsAdmin[client] = true;
                                CShowActivity2(client, CHAT_PREFIX_SPACE, "Enabled Friendly Admin mode.");
                                if (cvar_logging.IntValue > 0) {
                                        LogAction(client, -1, "\"%L\" activated Friendly Admin mode.", client);
                                }
                        }
                }
                else {
                        CReplyToCommand(client, "%s Not a valid client.", CHAT_PREFIX);
                }
                return Plugin_Handled;
        }
        if (numargs > 3) {
                CReplyToCommand(client, "%s Usage: \"sm_friendly_admin [target] [-1/0/1]\"", CHAT_PREFIX);
                return Plugin_Handled;
        }
        if (numargs >= 1) {
                char arg1[64];
                bool tn_is_ml;
                GetCmdArg(1, arg1, sizeof(arg1));
                if ((numtargets = ProcessTargetString(arg1, client, target, sizeof(target), 0, target_name, sizeof(target_name), tn_is_ml)) <= 0) {
                        ReplyToTargetError(client, numtargets);
                        return Plugin_Handled;
                }
        }
        if (numargs >= 2) {
                char arg2[2];
                GetCmdArg(2, arg2, sizeof(arg2));
                direction = StringToInt(arg2);
                if (!(direction == -1 || direction == 0 || direction == 1)) {
                        CReplyToCommand(client, "%s Second argument must be 0, 1, or -1. 0 to disable Friendly Admin, 1 to enable, -1 to toggle.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
        }
        if (numtargets == 1) {
                int singletarget = target[0];
                if (IsAdmin[singletarget] && direction == 1) {
                        CReplyToCommand(client, "%s That player is already in Friendly Admin mode!", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (!IsAdmin[singletarget] && direction == 0) {
                        CReplyToCommand(client, "%s That player is already not in Friendly Admin mode!.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
        }
        int count;
        if (direction == -1) {
                for (int i = 0; i < numtargets; i++) {
                        int currenttarget = target[i];
                        if (IsAdmin[currenttarget]) {
                                IsAdmin[currenttarget] = false;
                                count++;
                                if (currenttarget != client) {
                                        CPrintToChat(currenttarget, "%s An admin has forced you out of Friendly Admin mode.", CHAT_PREFIX);
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" disabled Friendly Admin mode on \"%L\".", client, currenttarget);
                                }
                                if (cvar_stopintel.BoolValue && IsFriendly[currenttarget]) {
                                        FakeClientCommand(currenttarget, "dropitem");
                                }
                        }
                        else {
                                IsAdmin[currenttarget] = true;
                                count++;
                                if (currenttarget != client) {
                                        CPrintToChat(currenttarget, "%s An admin has forced you into Friendly Admin Mode.", CHAT_PREFIX);
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" enabled Friendly Admin mode on \"%L\".", client, currenttarget);
                                }
                        }
                }
                if (count < 1) {
                        CReplyToCommand(client, "%s No players were affected.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (numtargets > 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Toggled Friendly Admin on %s, affecting %i players.", target_name, count);
                        if (cvar_logging.IntValue > 0 && cvar_logging.IntValue < 3) {
                                LogAction(client, -1, "\"%L\" toggled Friendly Admin mode on %s.", client, target_name);
                        }
                        else if (cvar_logging.IntValue >= 3) {
                                LogAction(client, -1, "\"%L\" toggled Friendly Admin mode on %s, affecting the previous %i players.", client, target_name, count);
                        }
                }
                else if (numtargets == 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Toggled Friendly Admin mode on %s.", target_name);
                }
        }
        if (direction == 1) {
                for (int i = 0; i < numtargets; i++) {
                        int currenttarget = target[i];
                        if (!IsAdmin[currenttarget]) {
                                IsAdmin[currenttarget] = true;
                                count++;
                                if (currenttarget != client) {
                                        CPrintToChat(currenttarget, "%s An admin has forced you into Friendly Admin mode.", CHAT_PREFIX);
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" enabled Friendly mode on \"%L\".", client, currenttarget);
                                }
                        }
                }
                if (count < 1) {
                        CReplyToCommand(client, "%s No players were affected.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (numtargets > 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Enabled Friendly Admin on %s, affecting %i players.", target_name, count);
                        if (cvar_logging.IntValue > 0 && cvar_logging.IntValue < 3) {
                                LogAction(client, -1, "\"%L\" enabled Friendly Admin mode on %s.", client, target_name);
                        }
                        else if (cvar_logging.IntValue >= 3) {
                                LogAction(client, -1, "\"%L\" enabled Friendly Admin mode on %s, affecting the previous %i players.", client, target_name, count);
                        }
                }
                else if (numtargets == 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Enabled Friendly Admin on %s.", target_name);
                }
        }
        if (direction == 0) {
                for (int i = 0; i < numtargets; i++) {
                        int currenttarget = target[i];
                        if (IsAdmin[currenttarget]) {
                                IsAdmin[currenttarget] = false;
                                count++;
                                if (currenttarget != client) {
                                        CPrintToChat(currenttarget, "%s An admin has forced you out of Friendly Admin mode.", CHAT_PREFIX);
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" disabled Friendly Admin mode on \"%L\".", client, currenttarget);
                                }
                                if (cvar_stopintel.BoolValue && IsFriendly[currenttarget]) {
                                        FakeClientCommand(currenttarget, "dropitem");
                                }
                        }
                }
                if (count < 1) {
                        CReplyToCommand(client, "%s No players were affected.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (numtargets > 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Disabled Friendly Admin on %s, affecting %i players.", target_name, count);
                        if (cvar_logging.IntValue > 0 && cvar_logging.IntValue < 3) {
                                LogAction(client, -1, "\"%L\" disabled Friendly Admin mode on %s.", client, target_name);
                        }
                        else if (cvar_logging.IntValue >= 3) {
                                LogAction(client, -1, "\"%L\" disabled Friendly Admin mode on %s, affecting the previous %i players.", client, target_name, count);
                        }
                }
                else if (numtargets == 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Disabled Friendly Admin on %s.", target_name);
                }
        }
        return Plugin_Handled;
}

public Action UseLockCmd(int client, int args) {
        int target[MAXPLAYERS];
        char target_name[MAX_TARGET_LENGTH];
        int direction = -1;
        int numtargets;
        if (!cvar_enabled.BoolValue) {
                CReplyToCommand(client, "%s Friendly Mode is currently disabled.", CHAT_PREFIX);
                return Plugin_Handled;
        }
        int numargs = GetCmdArgs();
        if (numargs == 0 || numargs > 2) {
                CReplyToCommand(client, "%s Usage: \"sm_friendly_lock [target] [-1/0/1]\"", CHAT_PREFIX);
                return Plugin_Handled;
        }
        if (numargs >= 1) {
                char arg1[64];
                bool tn_is_ml;
                GetCmdArg(1, arg1, sizeof(arg1));
                if ((numtargets = ProcessTargetString(arg1, client, target, sizeof(target), 0, target_name, sizeof(target_name), tn_is_ml)) <= 0) {
                        ReplyToTargetError(client, numtargets);
                        return Plugin_Handled;
                }
        }
        if (numargs >= 2) {
                char arg2[2];
                GetCmdArg(2, arg2, sizeof(arg2));
                direction = StringToInt(arg2);
                if (!(direction == -1 || direction == 0 || direction == 1)) {
                        CReplyToCommand(client, "%s Second argument must be 0, 1, or -1. 0 to disable Friendly Lock, 1 to enable, -1 to toggle.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
        }
        if (numtargets == 1) {
                int singletarget = target[0];
                if (IsLocked[singletarget] && direction == 1) {
                        CReplyToCommand(client, "%s That player is already Friendly Locked!", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (!IsLocked[singletarget] && direction == 0) {
                        CReplyToCommand(client, "%s That player is already not Friendly Locked!.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
        }
        int count;
        if (direction == -1) {
                for (int i = 0; i < numtargets; i++) {
                        int currenttarget = target[i];
                        if (IsLocked[currenttarget]) {
                                IsLocked[currenttarget] = false;
                                count++;
                                if (AreClientCookiesCached(currenttarget))
                                {
                                        SetClientCookie(currenttarget, g_hFriendlyLockEnabled, "0");
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" disabled Friendly Lock on \"%L\".", client, currenttarget);
                                }
                        }
                        else {
                                IsLocked[currenttarget] = true;
                                count++;
                                if (AreClientCookiesCached(currenttarget))
                                {
                                        SetClientCookie(currenttarget, g_hFriendlyLockEnabled, "1");
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" enabled Friendly Lock on \"%L\".", client, currenttarget);
                                }
                        }
                }
                if (count < 1) {
                        CReplyToCommand(client, "%s No players were affected.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (numtargets > 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Toggled Friendly Lock on %s, affecting %i players.", target_name, count);
                        if (cvar_logging.IntValue > 0 && cvar_logging.IntValue < 3) {
                                LogAction(client, -1, "\"%L\" toggled Friendly Lock on %s.", client, target_name);
                        }
                        else if (cvar_logging.IntValue >= 3) {
                                LogAction(client, -1, "\"%L\" toggled Friendly Lock on %s, affecting the previous %i players.", client, target_name, count);
                        }
                }
                else if (numtargets == 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Toggled Friendly Lock on %s.", target_name);
                }
        }
        if (direction == 1) {
                for (int i = 0; i < numtargets; i++) {
                        int currenttarget = target[i];
                        if (!IsLocked[currenttarget]) {
                                IsLocked[currenttarget] = true;
                                count++;
                                if (AreClientCookiesCached(currenttarget))
                                {
                                        SetClientCookie(currenttarget, g_hFriendlyLockEnabled, "1");
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" enabled Friendly Lock on \"%L\".", client, currenttarget);
                                }
                        }
                }
                if (count < 1) {
                        CReplyToCommand(client, "%s No players were affected.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (numtargets > 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Enabled Friendly Lock on %s, affecting %i players.", target_name, count);
                        if (cvar_logging.IntValue > 0 && cvar_logging.IntValue < 3) {
                                LogAction(client, -1, "\"%L\" enabled Friendly Lock on %s.", client, target_name);
                        }
                        else if (cvar_logging.IntValue >= 3) {
                                LogAction(client, -1, "\"%L\" enabled Friendly Lock on %s, affecting the previous %i players.", client, target_name, count);
                        }
                }
                else if (numtargets == 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Enabled Friendly Lock on %s.", target_name);
                }
        }
        if (direction == 0) {
                for (int i = 0; i < numtargets; i++) {
                        int currenttarget = target[i];
                        if (IsLocked[currenttarget]) {
                                IsLocked[currenttarget] = false;
                                count++;
                                if (AreClientCookiesCached(currenttarget))
                                {
                                        SetClientCookie(currenttarget, g_hFriendlyLockEnabled, "0");
                                }
                                if (cvar_logging.IntValue >= 3 || (cvar_logging.IntValue > 0 && numtargets == 1)) {
                                        LogAction(client, currenttarget, "\"%L\" disabled Friendly Lock on \"%L\".", client, currenttarget);
                                }
                        }
                }
                if (count < 1) {
                        CReplyToCommand(client, "%s No players were affected.", CHAT_PREFIX);
                        return Plugin_Handled;
                }
                if (numtargets > 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Disabled Friendly Lock on %s, affecting %i players.", target_name, count);
                        if (cvar_logging.IntValue > 0 && cvar_logging.IntValue < 3) {
                                LogAction(client, -1, "\"%L\" disabled Friendly Lock on %s.", client, target_name);
                        }
                        else if (cvar_logging.IntValue >= 3) {
                                LogAction(client, -1, "\"%L\" disabled Friendly Lock on %s, affecting the previous %i players.", client, target_name, count);
                        }
                }
                else if (numtargets == 1) {
                        CShowActivity2(client, CHAT_PREFIX_SPACE, "Disabled Friendly Lock on %s.", target_name);
                }
        }
        return Plugin_Handled;
}

public void OnPlayerSpawned(Handle event, const char[] name, bool dontBroadcast) {
        int client = GetClientOfUserId(GetEventInt(event, "userid"));
        char sValue[8];
        GetClientCookie(client, g_hFriendlyLockEnabled, sValue, sizeof(sValue));
        if (StringToInt(sValue) == 1) IsLocked[client] = true;

        if (RFETRIZ[client] || (IsLocked[client] && IsFriendly[client])) {
                CPrintToChat(client, "%s You are still Friendly.", CHAT_PREFIX);
                RequestedChange[client] = false;
                RFETRIZ[client] = false;
                // Inventory_App should take care of things from here
        }
        else if (RequestedChange[client]) {
                if (IsFriendly[client]) {
                        MakeClientHostile(client);
                        if (cvar_logging.IntValue >= 2) {
                                LogAction(client, -1, "\"%L\" deactivated Friendly mode on spawn.", client);
                        }
                        CPrintToChat(client, "%s You are no longer Friendly.", CHAT_PREFIX);
                }
                else {
                        if (FriendlyPlayerCount < cvar_maxfriendlies.IntValue) {
                                MakeClientFriendly(client);
                                CPrintToChat(client, "%s You are now Friendly.", CHAT_PREFIX);
                                if (cvar_logging.IntValue >= 2) {
                                        LogAction(client, -1, "\"%L\" activated Friendly mode on spawn.", client);
                                }
                        }
                        else {
                                CPrintToChat(client, "%s There are too many Friendly players already!", CHAT_PREFIX);
                        }
                }
        }
        else {
                if (IsFriendly[client]) {
                        if (cvar_remember.IntValue) {
                                CPrintToChat(client, "%s You are still Friendly.", CHAT_PREFIX);
                                RequestedChange[client] = false;
                                // Inventory_App should take care of things from here
                        }
                        else {
                                MakeClientHostile(client);
                                CPrintToChat(client, "%s You have been taken out of Friendly mode because you respawned.", CHAT_PREFIX);
                                if (cvar_logging.IntValue >= 2) {
                                        LogAction(client, -1, "\"%L\" deactivated Friendly mode due to a respawn.", client);
                                }
                        }
                }
        }
        if (IsFriendly[client] && GetForwardFunctionCount(hfwd_FriendlySpawn) > 0) {
                Call_StartForward(hfwd_FriendlySpawn);
                Call_PushCell(client);
                Call_Finish();
        }
}

public Action UseAdminCmd2(int client, int args) {
        if (CheckCommandAccess(client, "sm_friendly_admin", ADMFLAG_BAN)) {
                UseAdminCmd(client, args);
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action UseLockCmd2(int client, int args) {
        if (CheckCommandAccess(client, "sm_friendly_lock", ADMFLAG_BAN)) {
                UseLockCmd(client, args);
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action OnClientCommand(int client, int args) {
        AfkTime[client] = 0.0;
        return Plugin_Continue;
}

public Action OnClientSpeaks(int client, const char[] strCommand, int iArgs) {
        AfkTime[client] = 0.0;
        return Plugin_Continue;
}

public void OnClientPutInServer(int client) {
        SDKHook(client, SDKHook_OnTakeDamage, OnTakeDamage);
        SDKHook(client, SDKHook_WeaponSwitch, OnWeaponSwitch);
        //SDKHook(client, SDKHook_SetTransmit, Hook_SetTransmit);
}

public void OnClientDisconnect_Post(int client) {
        if (IsFriendly[client]) {
                FriendlyPlayerCount--;
        }
        IsFriendly[client] = false;
        RequestedChange[client] = false;
        IsAdmin[client] = false;
        IsLocked[client] = false;
        RFETRIZ[client] = false;
        IsInSpawn[client] = false;
        ToggleTimer[client] = 0.0;
        AfkTime[client] = 0.0;
        p_lastbtnstate[client] = 0;
}

void MakeClientHostile(const int client) {

        float time = GetEngineTime();
        ToggleTimer[client] = time + cvar_delay.FloatValue;

        if (GetForwardFunctionCount(hfwd_HostilePre) > 0) {
                Call_StartForward(hfwd_HostilePre);
                Call_PushCell(client);
                Call_Finish();
        }

        if (GetForwardFunctionCount(hfwd_Hostile) > 0) {
                Call_StartForward(hfwd_Hostile);
                Call_PushCell(client);
                Call_Finish();
        }

        FriendlyPlayerCount--;
        IsFriendly[client] = false;
        RequestedChange[client] = false;
        RFETRIZ[client] = false;
        MakeBuildingsHostile(client);
        DestroyStickies(client);
        if (cvar_invuln_p.IntValue < 2) {
                ApplyInvuln(client, INVULNMODE_MORTAL);
        }
        if (cvar_notarget_p.IntValue > 0) {
                SetNotarget(client, false);
        }
        if (cvar_noblock_p.IntValue > 0) {
                ApplyNoblock(client, true);
        }
        if (cvar_alpha_p.IntValue > -1) {
                SetEntityRenderMode(client, RENDER_NORMAL);
                SetEntityRenderColor(client, _, _, _, _);
        }
        if (cvar_alpha_w.IntValue > -1) {
                SetWearableInvis(client, false);
        }
        if (cvar_alpha_wep.IntValue > -1) {
                SetWeaponInvis(client, false);
        }
        /* if (cvar_botignore.BoolValue) {
                SetBotIgnore(client, false);
        } */

        if (GetForwardFunctionCount(hfwd_HostilePost) > 0) {
                Call_StartForward(hfwd_HostilePost);
                Call_PushCell(client);
                Call_Finish();
        }

        if (AreClientCookiesCached(client))
        {
                SetClientCookie(client, g_hFriendlyEnabled, "0");
        }
}

void MakeClientFriendly(const int client) {

        float time = GetEngineTime();
        ToggleTimer[client] = time + cvar_delay.FloatValue;

        if (GetForwardFunctionCount(hfwd_FriendlyPre) > 0) {
                Call_StartForward(hfwd_FriendlyPre);
                Call_PushCell(client);
                Call_Finish();
        }

        if (GetForwardFunctionCount(hfwd_Friendly) > 0) {
                Call_StartForward(hfwd_Friendly);
                Call_PushCell(client);
                Call_Finish();
        }

        FriendlyPlayerCount++;
        MakeBuildingsFriendly(client);
        ReapplyFriendly(client);
        RemoveMySappers(client);
        MakeStickiesFriendly(client);
        RequestedChange[client] = false;
        RFETRIZ[client] = false;
        ForceWeaponSwitches(client);
        if (cvar_stopintel.BoolValue && !IsAdmin[client]) {
                FakeClientCommand(client, "dropitem");
        }

        if (GetForwardFunctionCount(hfwd_FriendlyPost) > 0) {
                Call_StartForward(hfwd_FriendlyPost);
                Call_PushCell(client);
                Call_Finish();
        }

        if (AreClientCookiesCached(client))
        {
                SetClientCookie(client, g_hFriendlyEnabled, "1");
        }
}

public void Inventory_App(Handle event, const char[] name, bool dontBroadcast) {
        int client = GetClientOfUserId(GetEventInt(event, "userid"));
        if (IsFriendly[client]) {
                ReapplyFriendly(client);
        }
}

void ReapplyFriendly(const int client) {

        if (GetForwardFunctionCount(hfwd_RefreshPre) > 0) {
                Call_StartForward(hfwd_RefreshPre);
                Call_PushCell(client);
                Call_Finish();
        }

        if (GetForwardFunctionCount(hfwd_Refresh) > 0) {
                Call_StartForward(hfwd_Refresh);
                Call_PushCell(client);
                Call_Finish();
        }

        IsFriendly[client] = true;
        if (cvar_invuln_p.IntValue == 0) {
                ApplyInvuln(client, INVULNMODE_GOD);
        }
        if (cvar_invuln_p.IntValue == 1) {
                ApplyInvuln(client, INVULNMODE_BUDDHA);
        }
        if (cvar_notarget_p.IntValue > 0) {
                SetNotarget(client, true);
        }
        if (cvar_noblock_p.IntValue > 0) {
                ApplyNoblock(client, false);
        }
        if (cvar_alpha_p.IntValue > -1) {
                SetEntityRenderMode(client, RENDER_TRANSCOLOR);
                SetEntityRenderColor(client, 255, 0, 255, _);
        }
        if (cvar_alpha_w.IntValue > -1) {
                SetWearableInvis(client);
        }
        if (cvar_alpha_wep.IntValue > -1) {
                SetWeaponInvis(client);
        }
        /* if (cvar_botignore.BoolValue) {
                SetBotIgnore(client, true);
        } */

        if (GetForwardFunctionCount(hfwd_RefreshPost) > 0) {
                Call_StartForward(hfwd_RefreshPost);
                Call_PushCell(client);
                Call_Finish();
        }
}

public Action OnTakeDamage(int client, int &attacker, int &inflictor, float &damage, int &damagetype, int &weapon, float damageForce[3], float damagePosition[3]) {
        if (!IsValidClient(attacker) || (client == attacker && cvar_invuln_p.IntValue != 3)) {
                return Plugin_Continue;
        }
        if ((IsFriendly[attacker] || IsFriendly[client]) && !IsAdmin[attacker]) {
                damage = 0.0;
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

void ApplyNoblock(int entity, bool remove) {
        int cvarValue;
        int normalValue;
        if (IsValidEntity(entity))
        {
                if (IsValidClient(entity)) {
                        cvarValue = cvar_noblock_p.IntValue;
                        normalValue = 5;
                }
                else {
                        char classname[64];
                        if (!GetEntityClassname(entity, classname, sizeof(classname))) {
                                return;
                        }
                        else if (StrEqual(classname, "obj_sentrygun")) {
                                cvarValue = cvar_noblock_s.IntValue;
                                normalValue = 21;
                        }
                        else if (StrEqual(classname, "obj_dispenser")) {
                                cvarValue = cvar_noblock_d.IntValue;
                                normalValue = 21;
                        }
                        else if (StrEqual(classname, "obj_teleporter")) {
                                cvarValue = cvar_noblock_t.IntValue;
                                normalValue = 22;
                        }
                }
                if (cvarValue == 0 || remove) {
                        SetEntProp(entity, Prop_Send, "m_CollisionGroup", normalValue);
                }
                else if (cvarValue == 1) {
                        SetEntProp(entity, Prop_Send, "m_CollisionGroup", 2);
                }
                else if (cvarValue == 2) {
                        SetEntProp(entity, Prop_Send, "m_CollisionGroup", 10);
                }
                else if (cvarValue == 3) {
                        SetEntProp(entity, Prop_Send, "m_CollisionGroup", 1);
                }
        }
}

void ApplyInvuln(int entity, f_invulnmode mode) {
        if (IsValidEntity(entity)) SetEntProp(entity, Prop_Data, "m_takedamage", mode, 1);
}


void SetNotarget(int ent, bool apply) {
        int flags;
        if (IsValidEntity(ent))
        {
                if (apply) {
                        flags = GetEntityFlags(ent)|FL_NOTARGET;
                }
                else {
                        flags = GetEntityFlags(ent)&~FL_NOTARGET;
                }
                SetEntityFlags(ent, flags);
        }
}

/* SetBotIgnore(int client, bool apply) {
        if (apply) {
                TF2_AddCondition(client, TFCond_StealthedUserBuffFade, -1.0);
        }
        else {
                TF2_RemoveCondition(client, TFCond_StealthedUserBuffFade);
        }
}
public void TF2_OnConditionRemoved(int client, TFCond condition) {
        if (cvar_botignore && IsFriendly[client] && condition == TFCond_StealthedUserBuffFade) {
                SetBotIgnore(client, true);
        }
} */


public Action Player_AFKCheck(Handle htimer) {
        if (cvar_afklimit.FloatValue > 0) {
                for (int client = 1; client <= MaxClients; client++) {
                        if (IsValidClient(client, _, true)) {
                                if (p_lastbtnstate[client] != GetClientButtons(client)) {
                                        p_lastbtnstate[client] = GetClientButtons(client);
                                        AfkTime[client] = 0.0;
                                        continue;
                                }
                                if (!IsFriendly[client] || IsLocked[client]) {
                                        AfkTime[client] = 0.0;
                                        continue;
                                }
                                if (cvar_afklimit.FloatValue && (AfkTime[client] += cvar_afkinterval.FloatValue) > cvar_afklimit.FloatValue) {
                                        AfkTime[client] = 0.0;
                                        MakeClientHostile(client);
                                        KillPlayer(client);
                                        CPrintToChat(client, "%s You have been removed from Friendly mode for being AFK too long.", CHAT_PREFIX);
                                        if (cvar_logging.IntValue >= 2) {
                                                LogAction(-1, -1, "\"%L\" was removed from Friendly Mode for being AFK too long.", client);
                                        }
                                }
                        }
                }
        }
        return Plugin_Continue;
}

void RestartAFKTimer() {
        if (h_timer_afkcheck != INVALID_HANDLE) {
                KillTimer(h_timer_afkcheck);
                h_timer_afkcheck = INVALID_HANDLE;
        }
        for (int client = 1; client <= MaxClients; client++) {
                AfkTime[client] = 0.0;
        }
        h_timer_afkcheck = CreateTimer(cvar_afkinterval.FloatValue, Player_AFKCheck, INVALID_HANDLE, TIMER_REPEAT);
}

void DestroyStickies(const int client) {
    int sticky = -1;
    while ((sticky = FindEntityByClassname(sticky, "tf_projectile_pipe_remote"))!=INVALID_ENT_REFERENCE) {
        if (!IsValidEntity(sticky)) {
            continue;
        }
        if (GetEntPropEnt(sticky, Prop_Send, "m_hThrower") == client) {
            AcceptEntityInput(sticky, "Kill");
        }
    }
}

void MakeStickiesFriendly(const int client) {
        int sticky = -1;
        while ((sticky = FindEntityByClassname(sticky, "tf_projectile_pipe_remote"))!=INVALID_ENT_REFERENCE) {
                if (IsValidEntity(sticky) && (GetEntPropEnt(sticky, Prop_Send, "m_hThrower") == client)) {
                        if (cvar_alpha_proj.IntValue >= 0 && cvar_alpha_proj.IntValue <= 255) {
                                SetEntityRenderMode(sticky, RENDER_TRANSCOLOR);
                                SetEntityRenderColor(sticky, 255, 0, 255, _);
                        }
                }
        }
}

void KillPlayer(const int client) {
        if (IsPlayerAlive(client)) {
                ForcePlayerSuicide(client);
                if (IsPlayerAlive(client)) {
                        SlapPlayer(client, 99999, false);
                        if (IsPlayerAlive(client)) {
                                SDKHooks_TakeDamage(client, client, client, 99999.0);
                                if (IsPlayerAlive(client)) {
                                        CreateTimer(0.1, ForceRespawnImmortalPlayer, GetClientUserId(client));
                                }
                        }
                }
        }
}
public Action ForceRespawnImmortalPlayer(Handle timer, any userid) {
        int client = GetClientOfUserId(userid);
        if (client == 0) {
                return;
        }
        if (IsPlayerAlive(client)) { TF2_RespawnPlayer(client); }
}

public void OnPluginEnd() {
        for (int client = 1; client <= MaxClients; client++) {
                if (IsFriendly[client]) {
                        CPrintToChat(client, "%s Plugin has been unloaded or restarted.", CHAT_PREFIX);
                        MakeClientHostile(client);
                        if (IsAdmin[client]) { continue; }
                        int action;
                        if (IsInSpawn[client]) {
                                action = cvar_action_h_spawn.IntValue;
                        }
                        else {
                                action = cvar_action_h.IntValue;
                        }
                        if (action < 0) {
                                KillPlayer(client);
                        }
                        else if (action > 0) {
                                SlapPlayer(client, action);
                        }
                }
        }
        RemoveMultiTargetFilter("@friendly", TargetFriendlies);
        RemoveMultiTargetFilter("@friendlies", TargetFriendlies);
        RemoveMultiTargetFilter("@!friendly", TargetHostiles);
        RemoveMultiTargetFilter("@!friendlies", TargetHostiles);
        RemoveMultiTargetFilter("@friendlyadmins", TargetFriendlyAdmins);
        RemoveMultiTargetFilter("@!friendlyadmins", TargetFriendlyNonAdmins);
        RemoveMultiTargetFilter("@friendlylocked", TargetFriendlyLocked);
        RemoveMultiTargetFilter("@!friendlylocked", TargetFriendlyUnlocked);

        if (GetForwardFunctionCount(hfwd_FriendlyUnload) > 0) {
                Call_StartForward(hfwd_FriendlyUnload);
                Call_Finish();
        }
}

public void Airblast(Handle event, char[] name, bool dontBroadcast) {
        int pyro = GetClientOfUserId(GetEventInt(event, "userid"));
        int pitcher = GetClientOfUserId(GetEventInt(event, "ownerid"));
        //int weaponid = GetEventInt(event, "weaponid");
        int entity = GetEventInt(event, "object_entindex");
        if (!IsValidClient(pyro) || !IsValidClient(pitcher) || !IsValidEntity(entity)) {
                return;
        }
        char classname[64];
        if (!GetEntityClassname(entity, classname, sizeof(classname))) {
                return;
        }
        if (!(StrEqual(classname, "tf_projectile_pipe_remote") || StrEqual(classname, "player"))) {
                if (IsFriendly[pitcher] && !IsFriendly[pyro] && cvar_airblastkill.BoolValue) {
                        AcceptEntityInput(entity, "Kill");
                }
        }
}

/* public Action Hook_SetTransmit(int entity, int client) {
        if (cvar_settransmit.IntValue == 0 || !IsValidClient(entity) || !IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (cvar_settransmit.IntValue > 0 && !IsFriendly[client] && IsFriendly[entity]) {
                return Plugin_Handled;
        }
        if (cvar_settransmit.IntValue == 2 && IsFriendly[client] && !IsFriendly[entity]) {
                return Plugin_Handled;
        }
        return Plugin_Continue;
} */

public void OnEntityCreated(int entity, const char[] classname) {
        if (cvar_ammopack.BoolValue) {
                if (StrContains(classname, "item_ammopack_", false) != -1) {
                        SDKHook(entity, SDKHook_StartTouch, OnAmmoPackTouch);
                        SDKHook(entity, SDKHook_Touch, OnAmmoPackTouch);
                }
                if (StrEqual(classname, "tf_ammo_pack", false)) {
                        SDKHook(entity, SDKHook_StartTouch, OnAmmoPackTouch);
                        SDKHook(entity, SDKHook_Touch, OnAmmoPackTouch);
                        SDKHook(entity, SDKHook_Spawn, OnAmmoPackSpawned);
                }
                if (StrEqual(classname, "tf_projectile_stun_ball", false)) {
                        SDKHook(entity, SDKHook_StartTouch, OnAmmoPackTouch);
                        SDKHook(entity, SDKHook_Touch, OnAmmoPackTouch);
                }
        }
        if (cvar_healthpack.BoolValue) {
                if (StrContains(classname, "item_healthkit_", false) != -1) {
                        SDKHook(entity, SDKHook_StartTouch, OnHealthPackTouch);
                        SDKHook(entity, SDKHook_Touch, OnHealthPackTouch);
                }
        }
        if (cvar_money.BoolValue) {
                if (StrContains(classname, "item_currencypack_", false) != -1) {
                        SDKHook(entity, SDKHook_StartTouch, OnMoneyTouch);
                        SDKHook(entity, SDKHook_Touch, OnMoneyTouch);
                }
        }
        if (cvar_spellbook.BoolValue) {
                if (StrContains(classname, "tf_spell_pickup", false) != -1) {
                        SDKHook(entity, SDKHook_StartTouch, OnSpellTouch);
                        SDKHook(entity, SDKHook_Touch, OnSpellTouch);
                }
        }
        if (cvar_stopcap.BoolValue) {
                if (StrEqual(classname, "trigger_capture_area", false)) {
                        SDKHook(entity, SDKHook_StartTouch, OnCPTouch );
                        SDKHook(entity, SDKHook_Touch, OnCPTouch );
                }
        }
        if (cvar_stopintel.BoolValue) {
                if (StrEqual(classname, "item_teamflag", false)) {
                        SDKHook(entity, SDKHook_StartTouch, OnFlagTouch );
                        SDKHook(entity, SDKHook_Touch, OnFlagTouch );
                }
        }
        if (cvar_pumpkin.BoolValue) {
                if (StrEqual(classname, "tf_pumpkin_bomb", false)) {
                        SDKHook(entity, SDKHook_OnTakeDamage, PumpkinTakeDamage);
                }
        }
        if (StrEqual(classname, "tf_projectile_pipe_remote", false)) {
                SDKHook(entity, SDKHook_OnTakeDamage, StickyTakeDamage);
        }
        if (cvar_funcbutton.BoolValue) {
                if (StrEqual(classname, "func_button", false)) {
                        SDKHook(entity, SDKHook_OnTakeDamage, ButtonTakeDamage);
                        SDKHook(entity, SDKHook_Use, ButtonUsed);
                }
        }
        if (StrEqual(classname, "func_respawnroom", false)) {
                SDKHook(entity, SDKHook_Touch, SpawnTouch);
                SDKHook(entity, SDKHook_EndTouch, SpawnEndTouch);
        }
        if (cvar_notarget_p.IntValue > 1) {
                if (StrEqual(classname, "func_regenerate", false)) {
                        SDKHook(entity, SDKHook_StartTouch, CabinetStartTouch);
                        SDKHook(entity, SDKHook_EndTouch, CabinetEndTouch);
                        if (cvar_notarget_p.IntValue == 3) {
                                SDKHook(entity, SDKHook_Touch, CabinetTouch);
                        }
                }
        }
        /* if (cvar_settransmit.IntValue > 0) {
                if (StrEqual(classname, "tf_weapon_minigun", false)) {
                        int flags = GetEdictFlags(entity)|FL_EDICT_FULLCHECK;
                        flags = flags|FL_EDICT_DONTSEND;
                        SetEdictFlags(entity, flags);
                }
        } */
        if (cvar_alpha_proj.IntValue >= 0 && cvar_alpha_proj.IntValue <= 255) {
                if (StrEqual(classname, "tf_projectile_arrow", false) ||
                        StrEqual(classname, "tf_projectile_ball_ornament", false) ||
                        //StrEqual(classname, "tf_projectile_energy_ball", false) ||
                        //StrEqual(classname, "tf_projectile_energy_ring", false) ||
                        StrEqual(classname, "tf_projectile_flare", false) ||
                        StrEqual(classname, "tf_projectile_healing_bolt", false) ||
                        StrEqual(classname, "tf_projectile_jar", false) ||
                        StrEqual(classname, "tf_projectile_jar_milk", false) ||
                        StrEqual(classname, "tf_projectile_pipe", false) ||
                        StrEqual(classname, "tf_projectile_pipe_remote", false) ||
                        StrEqual(classname, "tf_projectile_rocket", false) ||
                        //StrEqual(classname, "tf_projectile_sentryrocket", false) ||
                        StrEqual(classname, "tf_projectile_stun_ball", false) ||
                        //StrEqual(classname, "tf_projectile_syringe", false) ||
                        StrEqual(classname, "tf_projectile_cleaver", false)) {
                        SDKHook(entity, SDKHook_Spawn, OnProjectileSpawned);
                }
        }
}

public void OnProjectileSpawned(int projectile) {
        int client = GetEntPropEnt(projectile, Prop_Data, "m_hOwnerEntity");
        if (!IsValidClient(client)) {
                return;
        }
        if (IsFriendly[client]) {
                SetEntityRenderMode(projectile, RENDER_TRANSCOLOR);
                SetEntityRenderColor(projectile, 255, 0, 255, _);
        }
}

public void OnAmmoPackSpawned(int entity) {
        int client = GetEntPropEnt(entity, Prop_Data, "m_hOwnerEntity");
        if (!IsValidClient(client)) {
                return;
        }
        if (IsFriendly[client] && cvar_ammopack.BoolValue) {
                AcceptEntityInput(entity, "Kill");
        }
}

void HookThings() {
        int ent = -1;
        while ((ent = FindEntityByClassname(ent, "obj_sentrygun")) != -1) {
                SDKHook(ent, SDKHook_OnTakeDamage, BuildingTakeDamage);
        }
        ent = -1;
        while ((ent = FindEntityByClassname(ent, "obj_dispenser")) != -1) {
                SDKHook(ent, SDKHook_OnTakeDamage, BuildingTakeDamage);
        }
        ent = -1;
        while ((ent = FindEntityByClassname(ent, "obj_teleporter")) != -1) {
                SDKHook(ent, SDKHook_OnTakeDamage, BuildingTakeDamage);
        }
        ent = -1;
        while ((ent = FindEntityByClassname(ent, "func_respawnroom")) != -1) {
                SDKHook(ent, SDKHook_Touch, SpawnTouch);
                SDKHook(ent, SDKHook_EndTouch, SpawnEndTouch);
        }
        /* if (cvar_settransmit.IntValue > 0) {
                ent = -1;
                while ((ent = FindEntityByClassname(ent, "tf_weapon_minigun")) != -1) {
                        int flags = GetEdictFlags(ent)|FL_EDICT_FULLCHECK;
                        flags = flags|FL_EDICT_DONTSEND;
                        SetEdictFlags(ent, flags);
                }
        } */
}

public Action CabinetStartTouch(int point, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (IsFriendly[client] && cvar_notarget_p.IntValue > 1) {
                SetNotarget(client, false);
        }
        return Plugin_Continue;
}

public Action CabinetTouch(int point, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (IsFriendly[client] && cvar_notarget_p.IntValue == 3) {
                SetNotarget(client, false);
        }
        return Plugin_Continue;
}

public Action CabinetEndTouch(int point, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (IsFriendly[client] && cvar_notarget_p.IntValue > 1) {
                SetNotarget(client, true);
        }
        return Plugin_Continue;
}

public Action OnCPTouch(int point, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (IsFriendly[client] && cvar_stopcap.BoolValue && !IsAdmin[client]) {
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action TF2_OnPlayerTeleport(int client, int teleporter, bool &result) {
        if (cvar_usetele.IntValue == 0 || !IsValidClient(client)) {
                return Plugin_Continue;
        }
        int engie = GetEntPropEnt(teleporter, Prop_Send, "m_hBuilder");
        if (engie == client || !IsValidClient(engie)) {
                return Plugin_Continue;
        }
        if (cvar_usetele.IntValue & 1 && IsFriendly[client] && !IsFriendly[engie]) {
                result = false;
                return Plugin_Handled;
        }
        if (cvar_usetele.IntValue & 2 && !IsFriendly[client] && IsFriendly[engie]) {
                result = false;
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action OnFlagTouch(int point, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (IsFriendly[client] && cvar_stopintel.BoolValue && !IsAdmin[client]) {
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action OnHealthPackTouch(int point, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (IsFriendly[client] && cvar_healthpack.BoolValue && !IsAdmin[client]) {
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action OnAmmoPackTouch(int point, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (IsFriendly[client] && cvar_ammopack.BoolValue && !IsAdmin[client]) {
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action OnMoneyTouch(int point, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (IsFriendly[client] && cvar_money.BoolValue && !IsAdmin[client]) {
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action OnSpellTouch(int point, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (IsFriendly[client] && cvar_spellbook.BoolValue && !IsAdmin[client]) {
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action PumpkinTakeDamage(int pumpkin, int &attacker, int &inflictor, float &damage, int &damagetype, int &weapon, float damageForce[3], float damagePosition[3]) {
        if (!IsValidClient(attacker)) {
                return Plugin_Continue;
        }
        if (IsFriendly[attacker] && cvar_pumpkin.BoolValue && !IsAdmin[attacker]) {
                damage = 0.0;
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action ButtonTakeDamage(int button, int &attacker, int &inflictor, float &damage, int &damagetype, int &weapon, float damageForce[3], float damagePosition[3]) {
        if (!IsValidClient(attacker)) {
                return Plugin_Continue;
        }
        if (IsFriendly[attacker] && cvar_funcbutton.BoolValue && !IsAdmin[attacker]) {
                damage = 0.0;
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action ButtonUsed(int entity, int activator, int caller, UseType type, float value) {
        if (!IsValidClient(activator)) {
                return Plugin_Continue;
        }
        if (IsFriendly[activator] && cvar_funcbutton.BoolValue && !IsAdmin[activator]) {
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action StickyTakeDamage(int sticky, int &attacker, int &inflictor, float &damage, int &damagetype, int &weapon, float damageForce[3], float damagePosition[3]) {
        if (!IsValidClient(attacker)) {
                return Plugin_Continue;
        }
        if ((IsFriendly[attacker]) && !IsAdmin[attacker]) {
                damage = 0.0;
                return Plugin_Handled;
        }
        int demoman = GetEntPropEnt(sticky, Prop_Send, "m_hThrower");
        if (!IsValidClient(demoman)) {
                return Plugin_Continue;
        }
        if (IsFriendly[demoman]) {
                damage = 0.0;
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public Action SpawnTouch(int spawn, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        if (GetEntProp(spawn, Prop_Send, "m_iTeamNum") == GetClientTeam(client)) {
                IsInSpawn[client] = true;
        }
        return Plugin_Continue;
}

public Action SpawnEndTouch(int spawn, int client) {
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        IsInSpawn[client] = false;
        return Plugin_Continue;
}


/* ///////////////////////////////////////////////////////////////////////////////////////
Engie Building shit. Code modified from the following plugins:
forums.alliedmods.net/showthread.php?t=171518
forums.alliedmods.net/showthread.php?p=1553549
*/

public Action Object_Built(Handle event, const char[] name, bool dontBroadcast) {
        int client = GetClientOfUserId(GetEventInt(event, "userid"));
        if (!IsValidClient(client)) {
                return Plugin_Continue;
        }
        int building = GetEventInt(event, "index");
        SDKHook(building, SDKHook_OnTakeDamage, BuildingTakeDamage);
        if (IsFriendly[client]) {
                int buildtype = GetEventInt(event, "object"); //dispenser 0, tele 1, sentry 2
                if (buildtype == 2) {
                        if (cvar_nobuild_s.BoolValue && !IsAdmin[client]) {
                                AcceptEntityInput(building, "Kill");
                                CPrintToChat(client, "%s You cannot build sentries while Friendly!", CHAT_PREFIX);
                        }
                        else {
                                if (cvar_invuln_s.IntValue == 2) {
                                        ApplyInvuln(building, INVULNMODE_GOD);
                                }
                                if (cvar_noblock_s.IntValue > 0) {
                                        ApplyNoblock(building, false);
                                }
                                if (cvar_notarget_s.BoolValue) {
                                        SetNotarget(building, true);
                                }
                                if (cvar_alpha_s.IntValue > -1) {
                                        SetEntityRenderMode(building, RENDER_TRANSCOLOR);
                                        SetEntityRenderColor(building, 255, 0, 255, _);
                                }
                        }
                }
                else if (buildtype == 0) {
                        if (cvar_nobuild_d.BoolValue && !IsAdmin[client]) {
                                AcceptEntityInput(building, "Kill");
                                CPrintToChat(client, "%s You cannot build dispensers while Friendly!", CHAT_PREFIX);
                        }
                        else {
                                if (cvar_invuln_d.IntValue == 2) {
                                        ApplyInvuln(building, INVULNMODE_GOD);
                                }
                                if (cvar_noblock_d.IntValue > 0) {
                                        ApplyNoblock(building, false);
                                }
                                if (cvar_notarget_d.BoolValue) {
                                        SetNotarget(building, true);
                                }
                                if (cvar_alpha_d.IntValue > -1) {
                                        SetEntityRenderMode(building, RENDER_TRANSCOLOR);
                                        SetEntityRenderColor(building, 255, 0, 255, _);
                                }
                        }
                }
                else if (buildtype == 1) {
                        if (cvar_nobuild_t.BoolValue && !IsAdmin[client]) {
                                AcceptEntityInput(building, "Kill");
                                CPrintToChat(client, "%s You cannot build teleporters while Friendly!", CHAT_PREFIX);
                        }
                        else {
                                if (cvar_invuln_t.IntValue == 2) {
                                        ApplyInvuln(building, INVULNMODE_GOD);
                                }
                                if (cvar_noblock_t.IntValue > 0) {
                                        ApplyNoblock(building, false);
                                }
                                if (cvar_notarget_t.BoolValue) {
                                        SetNotarget(building, true);
                                }
                                if (cvar_alpha_t.IntValue > -1) {
                                        SetEntityRenderMode(building, RENDER_TRANSCOLOR);
                                        SetEntityRenderColor(building, 255, 0, 255, _);
                                }
                        }
                }
        }
        return Plugin_Continue;
}

void MakeBuildingsFriendly(const int client) {
        int sentrygun = -1;
        int dispenser = -1;
        int teleporter = -1;
        while ((sentrygun = FindEntityByClassname(sentrygun, "obj_sentrygun"))!=INVALID_ENT_REFERENCE) {
                if (IsValidEntity(sentrygun) && (GetEntPropEnt(sentrygun, Prop_Send, "m_hBuilder") == client)) {
                        if (cvar_killbuild_f_s.BoolValue && !IsAdmin[client]) {
                                AcceptEntityInput(sentrygun, "Kill");
                        }
                        else {
                                if (cvar_invuln_s.IntValue == 1) {
                                        RemoveActiveSapper(sentrygun, false);
                                }
                                else if (cvar_invuln_s.IntValue == 2) {
                                        ApplyInvuln(sentrygun, INVULNMODE_GOD);
                                        RemoveActiveSapper(sentrygun, true);
                                }
                                if (cvar_noblock_s.IntValue > 0) {
                                        ApplyNoblock(sentrygun, false);
                                }
                                if (cvar_notarget_s.BoolValue) {
                                        SetNotarget(sentrygun, true);
                                }
                                if (cvar_alpha_s.IntValue > -1) {
                                        SetEntityRenderMode(sentrygun, RENDER_TRANSCOLOR);
                                        SetEntityRenderColor(sentrygun, 255, 0, 255, _);
                                }
                        }
                }
        }
        while ((dispenser = FindEntityByClassname(dispenser, "obj_dispenser"))!=INVALID_ENT_REFERENCE) {
                if (IsValidEntity(dispenser) && (GetEntPropEnt(dispenser, Prop_Send, "m_hBuilder") == client)) {
                        if (cvar_killbuild_f_d.BoolValue && !IsAdmin[client]) {
                                AcceptEntityInput(dispenser, "Kill");
                        }
                        else {
                                if (cvar_invuln_d.IntValue == 1) {
                                        RemoveActiveSapper(dispenser, false);
                                }
                                else if (cvar_invuln_d.IntValue == 2) {
                                        ApplyInvuln(dispenser, INVULNMODE_GOD);
                                        RemoveActiveSapper(dispenser, true);
                                }
                                if (cvar_noblock_d.IntValue > 0) {
                                        ApplyNoblock(dispenser, false);
                                }
                                if (cvar_notarget_d.BoolValue) {
                                        SetNotarget(dispenser, true);
                                }
                                if (cvar_alpha_d.IntValue > -1) {
                                        SetEntityRenderMode(dispenser, RENDER_TRANSCOLOR);
                                        SetEntityRenderColor(dispenser, 255, 0, 255, _);
                                }
                        }
                }
        }
        while ((teleporter = FindEntityByClassname(teleporter, "obj_teleporter"))!=INVALID_ENT_REFERENCE) {
                if (IsValidEntity(teleporter) && (GetEntPropEnt(teleporter, Prop_Send, "m_hBuilder") == client)) {
                        if (cvar_killbuild_f_t.BoolValue && !IsAdmin[client]) {
                                AcceptEntityInput(teleporter, "Kill");
                        }
                        else {
                                if (cvar_invuln_t.IntValue == 1) {
                                        RemoveActiveSapper(teleporter, false);
                                }
                                else if (cvar_invuln_t.IntValue == 2) {
                                        ApplyInvuln(teleporter, INVULNMODE_GOD);
                                        RemoveActiveSapper(teleporter, true);
                                }
                                if (cvar_noblock_t.IntValue > 0) {
                                        ApplyNoblock(teleporter, false);
                                }
                                if (cvar_notarget_t.BoolValue) {
                                        SetNotarget(teleporter, true);
                                }
                                if (cvar_alpha_t.IntValue > -1) {
                                        SetEntityRenderMode(teleporter, RENDER_TRANSCOLOR);
                                        SetEntityRenderColor(teleporter, 255, 0, 255, _);
                                }
                        }
                }
        }
}


void MakeBuildingsHostile(const int client) {
        int sentrygun = -1;
        int dispenser = -1;
        int teleporter = -1;
        while ((sentrygun = FindEntityByClassname(sentrygun, "obj_sentrygun"))!=INVALID_ENT_REFERENCE) {
                if (IsValidEntity(sentrygun) && (GetEntPropEnt(sentrygun, Prop_Send, "m_hBuilder") == client)) {
                        if (cvar_killbuild_h_s.BoolValue && !IsAdmin[client]) {
                                AcceptEntityInput(sentrygun, "Kill");
                        }
                        else {
                                if (cvar_invuln_s.IntValue == 2) {
                                        ApplyInvuln(sentrygun, INVULNMODE_MORTAL);
                                }
                                if (cvar_noblock_s.IntValue > 0) {
                                        ApplyNoblock(sentrygun, true);
                                }
                                if (cvar_notarget_s.BoolValue) {
                                        SetNotarget(sentrygun, false);
                                }
                                if (cvar_alpha_s.IntValue != -1) {
                                        SetEntityRenderMode(sentrygun, RENDER_NORMAL);
                                        SetEntityRenderColor(sentrygun, _, _, _, _);
                                }
                        }
                }
        }
        while ((dispenser = FindEntityByClassname(dispenser, "obj_dispenser"))!=INVALID_ENT_REFERENCE) {
                if (IsValidEntity(dispenser) && (GetEntPropEnt(dispenser, Prop_Send, "m_hBuilder") == client)) {
                        if (cvar_killbuild_h_d.BoolValue && !IsAdmin[client]) {
                                AcceptEntityInput(dispenser, "Kill");
                        }
                        else {
                                if (cvar_invuln_d.IntValue == 2) {
                                        ApplyInvuln(dispenser, INVULNMODE_MORTAL);
                                }
                                if (cvar_noblock_d.IntValue > 0) {
                                        ApplyNoblock(dispenser, true);
                                }
                                if (cvar_notarget_d.BoolValue) {
                                        SetNotarget(dispenser, false);
                                }
                                if (cvar_alpha_d.IntValue != -1) {
                                        SetEntityRenderMode(dispenser, RENDER_NORMAL);
                                        SetEntityRenderColor(dispenser, _, _, _, _);
                                }
                        }
                }
        }
        while ((teleporter = FindEntityByClassname(teleporter, "obj_teleporter"))!=INVALID_ENT_REFERENCE) {
                if (IsValidEntity(teleporter) && (GetEntPropEnt(teleporter, Prop_Send, "m_hBuilder") == client)) {
                        if (cvar_killbuild_h_t.BoolValue && !IsAdmin[client]) {
                                AcceptEntityInput(teleporter, "Kill");
                        }
                        else {
                                if (cvar_invuln_t.IntValue == 2) {
                                        ApplyInvuln(teleporter, INVULNMODE_MORTAL);
                                }
                                if (cvar_noblock_t.IntValue > 0) {
                                        ApplyNoblock(teleporter, true);
                                }
                                if (cvar_notarget_t.BoolValue) {
                                        SetNotarget(teleporter, false);
                                }
                                if (cvar_alpha_t.IntValue != -1) {
                                        SetEntityRenderMode(teleporter, RENDER_NORMAL);
                                        SetEntityRenderColor(teleporter, _, _, _, _);
                                }
                        }
                }
        }
}

public Action BuildingTakeDamage(int building, int &attacker, int &inflictor, float &damage, int &damagetype) {
        int engie = GetEntPropEnt(building, Prop_Send, "m_hBuilder");
        char classname[64];
        if (!GetEntityClassname(building, classname, sizeof(classname))) {
                return Plugin_Continue;
        }
        if (!IsValidClient(attacker) || !IsValidClient(engie)) {
                return Plugin_Continue;
        }
        if (!IsAdmin[attacker]) {
                if (StrEqual(classname, "obj_sentrygun", false)) {
                        if (IsFriendly[attacker] || (IsFriendly[engie] && cvar_invuln_s.IntValue > 0)) {
                                damage = 0.0;
                                return Plugin_Handled;
                        }
                }
                else if (StrEqual(classname, "obj_dispenser", false)) {
                        if (IsFriendly[attacker] || (IsFriendly[engie] && cvar_invuln_d.IntValue > 0)) {
                                damage = 0.0;
                                return Plugin_Handled;
                        }
                }
                else if (StrEqual(classname, "obj_teleporter", false)) {
                        if (IsFriendly[attacker] || (IsFriendly[engie] && cvar_invuln_t.IntValue > 0)) {
                                damage = 0.0;
                                return Plugin_Handled;
                        }
                }
        }
        return Plugin_Continue;
}

public Action Object_Sapped(Handle event, const char[] name, bool dontBroadcast) {
        int spy = GetClientOfUserId(GetEventInt(event, "userid"));
        int sapper = GetEventInt(event, "sapperid");
        if (IsFriendly[spy] && !IsAdmin[spy]) {
                AcceptEntityInput(sapper, "Kill");
                return Plugin_Continue;
        }
        int engie = GetClientOfUserId(GetEventInt(event, "ownerid"));
        int building = GetEventInt(event, "object"); //dispenser 0, tele 1, sentry 2
        if (IsFriendly[engie]) {
                if (building == 0) {
                        if (cvar_invuln_d.IntValue == 2 || (cvar_invuln_d.IntValue == 1 && !IsAdmin[spy])) {
                                AcceptEntityInput(sapper, "Kill");
                        }
                        else if (cvar_invuln_d.IntValue == 0 || (cvar_invuln_d.IntValue == 1 && IsAdmin[spy])) {
                                SDKHook(sapper, SDKHook_OnTakeDamage, SapperTakeDamage);
                        }
                }
                else if (building == 1) {
                        if (cvar_invuln_t.IntValue == 2 || (cvar_invuln_t.IntValue == 1 && !IsAdmin[spy])) {
                                AcceptEntityInput(sapper, "Kill");
                        }
                        else if (cvar_invuln_t.IntValue == 0 || (cvar_invuln_t.IntValue == 1 && IsAdmin[spy])) {
                                SDKHook(sapper, SDKHook_OnTakeDamage, SapperTakeDamage);
                        }
                }
                else if (building == 2) {
                        if (cvar_invuln_s.IntValue == 2 || (cvar_invuln_s.IntValue == 1 && !IsAdmin[spy])) {
                                AcceptEntityInput(sapper, "Kill");
                        }
                        else if (cvar_invuln_s.IntValue == 0 || (cvar_invuln_s.IntValue == 1 && IsAdmin[spy])) {
                                SDKHook(sapper, SDKHook_OnTakeDamage, SapperTakeDamage);
                        }
                }
        }
        else {
                SDKHook(sapper, SDKHook_OnTakeDamage, SapperTakeDamage);
        }
        return Plugin_Continue;
}

public Action SapperTakeDamage(int sapper, int &attacker, int &inflictor, float &damage, int &damagetype) {
        int homewrecker = attacker;
        int building = GetEntPropEnt(sapper, Prop_Send, "m_hBuiltOnEntity");
        int engie = GetEntPropEnt(building, Prop_Send, "m_hBuilder");
        if (!IsValidClient(attacker)) {
                return Plugin_Continue;
        }
        if (!IsAdmin[homewrecker] && IsFriendly[homewrecker] && !IsFriendly[engie]) {
                damage = 0.0;
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

public void RemoveActiveSapper(int building, bool ignoreadmin) {
        int sapper = -1;
        while ((sapper = FindEntityByClassname(sapper, "obj_attachment_sapper"))!=INVALID_ENT_REFERENCE) {
                if (IsValidEntity(sapper) && (GetEntPropEnt(sapper, Prop_Send, "m_hBuiltOnEntity") == building)) {
                        int spy = GetEntPropEnt(sapper, Prop_Send, "m_hBuilder");
                        if (ignoreadmin || !IsAdmin[spy]) {
                                AcceptEntityInput(sapper, "Kill");
                        }
                }
        }
}

public void RemoveMySappers(int client) {
        if (!IsAdmin[client]) {
                int sapper = -1;
                while ((sapper = FindEntityByClassname(sapper, "obj_attachment_sapper"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(sapper) && GetEntPropEnt(sapper, Prop_Send, "m_hBuilder") == client) {
                                AcceptEntityInput(sapper, "Kill");
                        }
                }
        }
}

public Action Hook_NormalSound(int clients[64], int &numClients, char sample[PLATFORM_MAX_PATH], int &entity, int &channel, float &volume, int &level, int &pitch, int &flags) {
        char classname[23];
        GetEntityClassname(entity, classname, sizeof(classname));
        if (StrEqual(classname, "obj_attachment_sapper")) {
                if (!IsValidEntity(GetEntPropEnt(entity, Prop_Send, "m_hBuiltOnEntity"))) {
                        return Plugin_Stop;
                }
        }
        return Plugin_Continue;
}

/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
The following code was borrowed from FlaminSarge's Ghost Mode plugin: forums.alliedmods.net/showthread.php?t=183266
This code makes wearables change alpha if sm_friendly_alpha_w is higher than -1 */

stock void SetWearableInvis(int client, bool set = true) {
        int i = -1;
        while ((i = FindEntityByClassname(i, "tf_wearable")) != -1) {
                if (GetEntPropEnt(i, Prop_Send, "m_hOwnerEntity") == client && !GetEntProp(i, Prop_Send, "m_bDisguiseWearable")) {
                        SetEntityRenderMode(i, set ? RENDER_TRANSCOLOR : RENDER_NORMAL);
                        SetEntityRenderColor(i, 255, 0, 255, _);
                }
        }
        i = -1;
        while ((i = FindEntityByClassname(i, "tf_wearable_demoshield")) != -1) {
                if (GetEntPropEnt(i, Prop_Send, "m_hOwnerEntity") == client && !GetEntProp(i, Prop_Send, "m_bDisguiseWearable")) {
                        SetEntityRenderMode(i, set ? RENDER_TRANSCOLOR : RENDER_NORMAL);
                        SetEntityRenderColor(i, 255, 0, 255, _);
                }
        }
        while ((i = FindEntityByClassname(i, "tf_powerup_bottle")) != -1) {
                if (GetEntPropEnt(i, Prop_Send, "m_hOwnerEntity") == client && !GetEntProp(i, Prop_Send, "m_bDisguiseWearable")) {
                        SetEntityRenderMode(i, set ? RENDER_TRANSCOLOR : RENDER_NORMAL);
                        SetEntityRenderColor(i, 255, 0, 255, _);
                }
        }
}


stock void SetWeaponInvis(int client, bool set = true) {
        for (int i = 0; i < 5; i++) {
                int entity = GetPlayerWeaponSlot(client, i);
                if (entity != -1) {
                        SetEntityRenderMode(entity, RENDER_TRANSCOLOR);
                        SetEntityRenderColor(entity, 255, 0, 255, _);
                }
        }
}


/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
Goomba Stomp Integration */

public Action OnStomp(int attacker, int victim, float &damageMultiplier, float &damageBonus, float &JumpPower) {
        if ((IsFriendly[attacker] || IsFriendly[victim]) && !IsAdmin[attacker] && cvar_goomba.BoolValue) {
                return Plugin_Handled;
        }
        return Plugin_Continue;
}

/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
RTD Integration */

public Action RTD_CanRollDice(int client) {
        if (IsFriendly[client] && !IsAdmin[client] && cvar_blockrtd.BoolValue) {
                CPrintToChat(client, "%s You cannot RTD while Friendly!", CHAT_PREFIX);
                return Plugin_Handled;
        }
        return Plugin_Continue;
}


/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
Begin code relevant to weaponblocker and tauntblocker */

public Action OnWeaponSwitch(int client, int weapon) {
        if (!IsFriendly[client] || IsAdmin[client] || !IsValidEdict(weapon)) {
                return Plugin_Continue;
        }
        if (IsWeaponBlocked(weapon)) {
                return Plugin_Handled;
        }
        else {
                return Plugin_Continue;
        }
}

stock bool IsWeaponBlocked(int weapon) {
        char weaponClass[64];
        if (!GetEntityClassname(weapon, weaponClass, sizeof(weaponClass))) {
                return false;
        }
        int weaponIndex = GetEntProp(weapon, Prop_Send, "m_iItemDefinitionIndex");
        bool blocked = false;
        for (int i = 0; i < sizeof(g_blockweps_classes) && !blocked && !StrEqual(g_blockweps_classes[i], "-1"); i++) {
                if (StrEqual(g_blockweps_classes[i], weaponClass)) {
                        blocked = true;
                }
        }
        if (blocked) {
                for (int i = 0; i < sizeof(g_blockweps_white) && g_blockweps_white[i] != -1; i++) {
                        if (g_blockweps_white[i] == weaponIndex) {
                                return false;
                        }
                }
                return true;
        }
        else {
                for (int i = 0; i < sizeof(g_blockweps_black) && g_blockweps_black[i] != -1; i++) {
                        if (g_blockweps_black[i] == weaponIndex) {
                                return true;
                        }
                }
                return false;
        }
}

public Action TauntCmd(int client, const char[] strCommand, int iArgs) {
        if (IsFriendly[client] && !IsAdmin[client]) {
                int weapon = GetEntPropEnt(client, Prop_Send, "m_hActiveWeapon");
                if (IsValidEntity(weapon)) {
                        int weaponIndex = GetEntProp(weapon, Prop_Send, "m_iItemDefinitionIndex");
                        for (int i = 0; i < sizeof(g_blocktaunt) && g_blocktaunt[i] != -1; i++) {
                                if (g_blocktaunt[i] == weaponIndex) {
                                        return Plugin_Handled;
                                }
                        }
                }
        }
        return Plugin_Continue;
}


void ForceWeaponSwitches(const int client) {
        if (!IsPlayerAlive(client) || IsAdmin[client]) {
                return;
        }
        int curwep = GetEntPropEnt(client, Prop_Send, "m_hActiveWeapon");
        if (!IsValidEntity(curwep) || !IsWeaponBlocked(curwep)) {
                return;
        }

        if (g_minigunoffsetstate > 0) {
                char curwepclass[32];
                GetEntityClassname(curwep, curwepclass, sizeof(curwepclass));
                if (StrEqual(curwepclass, "tf_weapon_minigun")) {
                        SetEntData(curwep, g_minigunoffsetstate, 0);
                        if (TF2_IsPlayerInCondition(client, TFCond_Slowed)) {
                                TF2_RemoveCondition(client, TFCond_Slowed);
                        }
                }
        }

        for (int i = 0; i <= 5; i++) {
                int weapon = GetPlayerWeaponSlot(client, i);
                if (!IsValidEdict(weapon)) {
                        continue;
                }
                if (curwep == weapon) {
                        continue;
                }
                if (IsWeaponBlocked(weapon)) {
                        continue;
                }
                char classname[64];
                if (GetEntityClassname(weapon, classname, sizeof(classname))) {
                        if (StrEqual(classname, "tf_weapon_invis")
                        ||  StrEqual(classname, "tf_weapon_builder")) {
                                continue;
                        }
                        else {
                                if (g_hWeaponReset != INVALID_HANDLE) {
                                        SDKCall(g_hWeaponReset, curwep);
                                }
                                SetEntPropEnt(client, Prop_Data, "m_hActiveWeapon", weapon);
                                ChangeEdictState(client, FindDataMapInfo(client, "m_hActiveWeapon"));
                                return;
                        }
                }
        }
        for (int i = 0; i <= 5; i++) {
                int weapon = GetPlayerWeaponSlot(client, i);
                if (!IsValidEdict(weapon)) {
                        continue;
                }
                if (IsWeaponBlocked(weapon)) {
                        TF2_RemoveWeaponSlot(client, i);
                }
        }
}

/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
Targeting Filters */

public bool TargetFriendlies(const char[] pattern, Handle clients) {
        for (int client = 1; client <= MaxClients; client++) {
                if (IsFriendly[client]) {
                        PushArrayCell(clients, client);
                }
        }
        return true;
}
public bool TargetHostiles(const char[] pattern, Handle clients) {
        for (int client = 1; client <= MaxClients; client++) {
                if (IsValidClient(client) && !IsFriendly[client]) {
                        PushArrayCell(clients, client);
                }
        }
        return true;
}
public bool TargetFriendlyAdmins(const char[] pattern, Handle clients) {
        for (int client = 1; client <= MaxClients; client++) {
                if (IsAdmin[client]) {
                        PushArrayCell(clients, client);
                }
        }
        return true;
}
public bool TargetFriendlyNonAdmins(const char[] pattern, Handle clients) {
        for (int client = 1; client <= MaxClients; client++) {
                if (IsValidClient(client) && !IsAdmin[client]) {
                        PushArrayCell(clients, client);
                }
        }
        return true;
}
public bool TargetFriendlyLocked(const char[] pattern, Handle clients) {
        for (int client = 1; client <= MaxClients; client++) {
                if (IsLocked[client]) {
                        PushArrayCell(clients, client);
                }
        }
        return true;
}
public bool TargetFriendlyUnlocked(const char[] pattern, Handle clients) {
        for (int client = 1; client <= MaxClients; client++) {
                if (IsValidClient(client) && !IsLocked[client]) {
                        PushArrayCell(clients, client);
                }
        }
        return true;
}

/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
Natives */

public int Native_CheckIfFriendly(Handle plugin, int numParams) {
        int client = GetNativeCell(1);

        if (client < 1 || client > MaxClients) {
                ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client index %i", client);
                return false;
        }
        if (!IsClientInGame(client)) {
                ThrowNativeError(SP_ERROR_PARAM, "Client %i is not in game!", client);
                return false;
        }
        if (IsFriendly[client]) {
                return true;
        }
        else {
                return false;
        }
}

public int Native_CheckIfFriendlyLocked(Handle plugin, int numParams) {
        int client = GetNativeCell(1);

        if (client < 1 || client > MaxClients) {
                ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client index %i", client);
                return false;
        }
        if (!IsClientInGame(client)) {
                ThrowNativeError(SP_ERROR_PARAM, "Client %i is not in game!", client);
                return false;
        }
        if (IsLocked[client]) {
                return true;
        }
        else {
                return false;
        }
}

public int Native_CheckIfFriendlyAdmin(Handle plugin, int numParams) {
        int client = GetNativeCell(1);

        if (client < 1 || client > MaxClients) {
                ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client index %i", client);
                return false;
        }
        if (!IsClientInGame(client)) {
                ThrowNativeError(SP_ERROR_PARAM, "Client %i is not in game!", client);
                return false;
        }
        if (IsAdmin[client]) {
                return true;
        }
        else {
                return false;
        }
}

public int Native_SetFriendly(Handle plugin, int numParams) {
        int client = GetNativeCell(1);
        int direction = GetNativeCell(2);
        int action = GetNativeCell(3);

        if (client < 1 || client > MaxClients) {
                ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client index %i", client);
                return -3;
        }
        if (!IsClientInGame(client)) {
                ThrowNativeError(SP_ERROR_PARAM, "Client %i is not in game!", client);
                return -2;
        }
        if ((IsFriendly[client] && direction > 0) || (!IsFriendly[client] && direction == 0)) {
                return -1;
                //Client is already in the requested Friendly state
        }
        if (IsFriendly[client] && (direction <= 0)) {
                MakeClientHostile(client);
                if (action < 0 && IsPlayerAlive(client)) {
                        KillPlayer(client);
                }
                else if (action > 0 && IsPlayerAlive(client)) {
                        SlapPlayer(client, action);
                        if (!IsPlayerAlive(client)) {
                                return 2;
                        }
                }
                return 0;
        }
        if (!IsFriendly[client] && (direction != 0)) {
                MakeClientFriendly(client);
                if (action < 0 && IsPlayerAlive(client)) {
                        KillPlayer(client);
                        if (!cvar_remember.BoolValue) {
                                RFETRIZ[client] = true;
                        }
                }
                else if (action > 0 && IsPlayerAlive(client)) {
                        SlapPlayer(client, action);
                        if (!IsPlayerAlive(client)) {
                                if (!cvar_remember.BoolValue) {
                                        RFETRIZ[client] = true;
                                }
                                return 3;
                        }

                }
                return 1;
        }
        return -4;
}

public int Native_SetFriendlyLock(Handle plugin, int numParams) {
        int client = GetNativeCell(1);
        int direction = GetNativeCell(2);

        if (client < 1 || client > MaxClients) {
                ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client index %i", client);
                return -3;
        }
        if (!IsClientInGame(client)) {
                ThrowNativeError(SP_ERROR_PARAM, "Client %i is not in game!", client);
                return -2;
        }
        if ((IsLocked[client] && direction > 0) || (!IsLocked[client] && direction == 0)) {
                return -1;
                //Client is already in the requested Friendly state
        }
        if (IsLocked[client] && (direction <= 0)) {
                IsLocked[client] = false;
                return 0;
        }
        if (!IsLocked[client] && (direction != 0)) {
                IsLocked[client] = true;
                return 1;
        }
        return -4;
}

public int Native_SetFriendlyAdmin(Handle plugin, int numParams) {
        int client = GetNativeCell(1);
        int direction = GetNativeCell(2);

        if (client < 1 || client > MaxClients) {
                ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client index %i", client);
                return -3;
        }
        if (!IsClientInGame(client)) {
                ThrowNativeError(SP_ERROR_PARAM, "Client %i is not in game!", client);
                return -2;
        }
        if ((IsAdmin[client] && direction > 0) || (!IsAdmin[client] && direction == 0)) {
                return -1;
                //Client is already in the requested Friendly state
        }
        if (IsAdmin[client] && (direction <= 0)) {
                IsAdmin[client] = false;
                return 0;
        }
        if (!IsAdmin[client] && (direction != 0)) {
                IsAdmin[client] = true;
                return 1;
        }
        return -4;
}

public int Native_RefreshFriendly(Handle plugin, int numParams) {
        int client = GetNativeCell(1);

        if (client < 1 || client > MaxClients) {
                ThrowNativeError(SP_ERROR_PARAM, "Invalid client or client index %i", client);
                return -3;
        }
        if (!IsClientInGame(client)) {
                ThrowNativeError(SP_ERROR_PARAM, "Client %i is not in game!", client);
                return -2;
        }
        if (!IsFriendly[client]) {
                ThrowNativeError(SP_ERROR_PARAM, "Cannot refresh Friendly Mode! Client %N is not Friendly!", client);
                return -1;
        }
        ReapplyFriendly(client);
        return 1;
}

public int Native_CheckPluginEnabled(Handle plugin, int numParams) {
        return cvar_enabled.BoolValue;
}

/* ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
Begin code relevant to caching convars */

public void cvarChange(Handle hHandle, const char[] strOldValue, const char[] strNewValue) {
        if (hHandle == cvar_enabled || hHandle == INVALID_HANDLE) {
                static bool oldValue;
                if (hHandle != INVALID_HANDLE) {
                        if (cvar_enabled.BoolValue && !oldValue) {
                                if (GetForwardFunctionCount(hfwd_FriendlyEnable) > 0) {
                                        Call_StartForward(hfwd_FriendlyEnable);
                                        Call_Finish();
                                }
                                if (cvar_logging.IntValue > 0) {
                                        LogAction(-1, -1, "Friendly mode plugin was enabled.");
                                }
                                CPrintToChatAll("%s An admin has re-enabled Friendly Mode. Type {olive}/friendly{default} to use.", CHAT_PREFIX);
                        }
                        else if (!cvar_enabled.BoolValue && oldValue) {
                                if (cvar_logging.IntValue > 0) {
                                        LogAction(-1, -1, "Friendly mode plugin was disabled. All players forced out of Friendly mode.");
                                }
                                CPrintToChatAll("%s An admin has disabled Friendly Mode.", CHAT_PREFIX);
                                for (int client = 1; client <= MaxClients; client++) {
                                        if (IsClientInGame(client) && IsFriendly[client]) {
                                                MakeClientHostile(client);
                                                if (!IsAdmin[client]) {
                                                        int action;
                                                        if (IsInSpawn[client]) {
                                                                action = cvar_action_h_spawn.IntValue;
                                                        }
                                                        else {
                                                                action = cvar_action_h.IntValue;
                                                        }
                                                        if (action < 0) {
                                                                KillPlayer(client);
                                                        } if (action > 0) {
                                                                SlapPlayer(client, action);
                                                        }
                                                }
                                        }
                                }
                                if (GetForwardFunctionCount(hfwd_FriendlyDisable) > 0) {
                                        Call_StartForward(hfwd_FriendlyDisable);
                                        Call_Finish();
                                }
                        }
                }
                oldValue = cvar_enabled.BoolValue;
        }
        if (hHandle == cvar_afklimit || hHandle == cvar_afkinterval || hHandle == INVALID_HANDLE) {
                RestartAFKTimer();
        }
        /* if (hHandle == cvar_botignore || hHandle == INVALID_HANDLE) {
                bool oldValue = cvar_botignore;
                cvar_botignore = GetConVarBool(cvar_botignore);
                if (hHandle != INVALID_HANDLE) {
                        if (cvar_botignore && !oldValue) {
                                for (int client = 1; client <= MaxClients; client++) {
                                        if (IsClientInGame(client) && IsFriendly[client]) {
                                                SetBotIgnore(client, true);
                                        }
                                }
                        }
                        else if (!cvar_botignore && oldValue) {
                                for (int client = 1; client <= MaxClients; client++) {
                                        if (IsClientInGame(client) && IsFriendly[client]) {
                                                SetBotIgnore(client, false);
                                        }
                                }
                        }
                }
        } */
        if (hHandle == cvar_stopcap || hHandle == INVALID_HANDLE) {
                int ent = -1;
                if (cvar_stopcap.BoolValue) {
                        while ((ent = FindEntityByClassname(ent, "trigger_capture_area"))!=INVALID_ENT_REFERENCE) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnCPTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnCPTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnCPTouch);
                                SDKHook(ent, SDKHook_Touch, OnCPTouch);
                        }
                }
                else {
                        while ((ent = FindEntityByClassname(ent, "trigger_capture_area"))!=INVALID_ENT_REFERENCE) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnCPTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnCPTouch);
                        }
                }
        }
        if (hHandle == cvar_stopintel || hHandle == INVALID_HANDLE) {
                int ent = -1;
                if (cvar_stopintel.BoolValue) {
                        while ((ent = FindEntityByClassname(ent, "item_teamflag"))!=INVALID_ENT_REFERENCE) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnFlagTouch );
                                SDKUnhook(ent, SDKHook_Touch, OnFlagTouch );
                                SDKHook(ent, SDKHook_StartTouch, OnFlagTouch );
                                SDKHook(ent, SDKHook_Touch, OnFlagTouch );
                        }
                }
                else {
                        while ((ent = FindEntityByClassname(ent, "item_teamflag"))!=INVALID_ENT_REFERENCE) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnFlagTouch );
                                SDKUnhook(ent, SDKHook_Touch, OnFlagTouch );
                        }
                }
        }
        if (hHandle == cvar_ammopack || hHandle == INVALID_HANDLE) {
                int ent = -1;
                if (cvar_ammopack.BoolValue) {
                        while ((ent = FindEntityByClassname(ent, "item_ammopack_full")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_ammopack_medium")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_ammopack_small")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "tf_ammo_pack")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "tf_projectile_stun_ball")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKHook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                }
                else {
                        while ((ent = FindEntityByClassname(ent, "item_ammopack_full")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_ammopack_medium")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_ammopack_small")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "tf_ammo_pack")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "tf_projectile_stun_ball")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnAmmoPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnAmmoPackTouch);
                        }
                }
        }
        if (hHandle == cvar_healthpack || hHandle == INVALID_HANDLE) {
                int ent = -1;
                if (cvar_healthpack.BoolValue) {
                        while ((ent = FindEntityByClassname(ent, "item_healthkit_full")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnHealthPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnHealthPackTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnHealthPackTouch);
                                SDKHook(ent, SDKHook_Touch, OnHealthPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_healthkit_medium")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnHealthPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnHealthPackTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnHealthPackTouch);
                                SDKHook(ent, SDKHook_Touch, OnHealthPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_healthkit_small")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnHealthPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnHealthPackTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnHealthPackTouch);
                                SDKHook(ent, SDKHook_Touch, OnHealthPackTouch);
                        }
                }
                else {
                        while ((ent = FindEntityByClassname(ent, "item_healthkit_full")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnHealthPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnHealthPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_healthkit_medium")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnHealthPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnHealthPackTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_healthkit_small")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnHealthPackTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnHealthPackTouch);
                        }
                }
        }
        if (hHandle == cvar_money || hHandle == INVALID_HANDLE) {
                int ent = -1;
                if (cvar_money.BoolValue) {
                        while ((ent = FindEntityByClassname(ent, "item_currencypack_large")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnMoneyTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnMoneyTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnMoneyTouch);
                                SDKHook(ent, SDKHook_Touch, OnMoneyTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_currencypack_medium")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnMoneyTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnMoneyTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnMoneyTouch);
                                SDKHook(ent, SDKHook_Touch, OnMoneyTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_currencypack_small")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnMoneyTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnMoneyTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnMoneyTouch);
                                SDKHook(ent, SDKHook_Touch, OnMoneyTouch);
                        }
                }
                else {
                        while ((ent = FindEntityByClassname(ent, "item_currencypack_large")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnMoneyTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnMoneyTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_currencypack_medium")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnMoneyTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnMoneyTouch);
                        }
                        ent = -1;
                        while ((ent = FindEntityByClassname(ent, "item_currencypack_small")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnMoneyTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnMoneyTouch);
                        }
                }
        }
        if (hHandle == cvar_spellbook || hHandle == INVALID_HANDLE) {
                int ent = -1;
                if (cvar_spellbook.BoolValue) {
                        while ((ent = FindEntityByClassname(ent, "item_currencypack_large")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnSpellTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnSpellTouch);
                                SDKHook(ent, SDKHook_StartTouch, OnSpellTouch);
                                SDKHook(ent, SDKHook_Touch, OnSpellTouch);
                        }
                }
                else {
                        while ((ent = FindEntityByClassname(ent, "item_currencypack_large")) != -1) {
                                SDKUnhook(ent, SDKHook_StartTouch, OnSpellTouch);
                                SDKUnhook(ent, SDKHook_Touch, OnSpellTouch);
                        }
                }
        }
        if (hHandle == cvar_pumpkin || hHandle == INVALID_HANDLE) {
                int ent = -1;
                if (cvar_pumpkin.BoolValue) {
                        while ((ent = FindEntityByClassname(ent, "tf_pumpkin_bomb"))!=INVALID_ENT_REFERENCE) {
                                SDKUnhook(ent, SDKHook_OnTakeDamage, PumpkinTakeDamage);
                                SDKHook(ent, SDKHook_OnTakeDamage, PumpkinTakeDamage);
                        }
                }
                else {
                        while ((ent = FindEntityByClassname(ent, "tf_pumpkin_bomb"))!=INVALID_ENT_REFERENCE) {
                                SDKUnhook(ent, SDKHook_OnTakeDamage, PumpkinTakeDamage);
                        }
                }
        }
        if (hHandle == cvar_funcbutton || hHandle == INVALID_HANDLE) {
                int ent = -1;
                if (cvar_funcbutton.BoolValue) {
                        while ((ent = FindEntityByClassname(ent, "func_button"))!=INVALID_ENT_REFERENCE) {
                                SDKUnhook(ent, SDKHook_OnTakeDamage, ButtonTakeDamage);
                                SDKUnhook(ent, SDKHook_Use, ButtonUsed);
                                SDKHook(ent, SDKHook_OnTakeDamage, ButtonTakeDamage);
                                SDKHook(ent, SDKHook_Use, ButtonUsed);
                        }
                }
                else {
                        while ((ent = FindEntityByClassname(ent, "func_button"))!=INVALID_ENT_REFERENCE) {
                                SDKUnhook(ent, SDKHook_OnTakeDamage, ButtonTakeDamage);
                                SDKUnhook(ent, SDKHook_Use, ButtonUsed);
                        }
                }
        }
        if (hHandle == cvar_invuln_p) {
                for (int client = 1; client <= MaxClients; client++) {
                        if (IsClientInGame(client) && IsFriendly[client]) {
                                switch (cvar_invuln_p.IntValue) {
                                        case 0: ApplyInvuln(client, INVULNMODE_GOD);
                                        case 1:ApplyInvuln(client, INVULNMODE_BUDDHA);
                                        default: ApplyInvuln(client, INVULNMODE_MORTAL);
                                }
                        }
                }
        }
        if (hHandle == cvar_invuln_s || hHandle == INVALID_HANDLE) {
                int sentry = -1;
                while ((sentry = FindEntityByClassname(sentry, "obj_sentrygun"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(sentry)) {
                                int engie = GetEntPropEnt(sentry, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie)&& IsFriendly[engie]) {
                                        if (cvar_invuln_s.IntValue < 2) {
                                                ApplyInvuln(sentry, INVULNMODE_MORTAL);
                                                RemoveActiveSapper(sentry, false);
                                        }
                                        else if (cvar_invuln_s.IntValue == 2) {
                                                ApplyInvuln(sentry, INVULNMODE_GOD);
                                                RemoveActiveSapper(sentry, true);
                                        }
                                }
                        }
                }
        }
        if (hHandle == cvar_invuln_d || hHandle == INVALID_HANDLE) {
                int dispenser = -1;
                while ((dispenser = FindEntityByClassname(dispenser, "obj_dispenser"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(dispenser)) {
                                int engie = GetEntPropEnt(dispenser, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        if (cvar_invuln_d.IntValue < 2) {
                                                ApplyInvuln(dispenser, INVULNMODE_MORTAL);
                                                RemoveActiveSapper(dispenser, false);
                                        }
                                        else if (cvar_invuln_d.IntValue == 2) {
                                                ApplyInvuln(dispenser, INVULNMODE_GOD);
                                                RemoveActiveSapper(dispenser, true);
                                        }
                                }
                        }
                }
        }
        if (hHandle == cvar_invuln_t || hHandle == INVALID_HANDLE) {
                int teleporter = -1;
                while ((teleporter = FindEntityByClassname(teleporter, "obj_teleporter"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(teleporter)) {
                                int engie = GetEntPropEnt(teleporter, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        if (cvar_invuln_t.IntValue < 2) {
                                                ApplyInvuln(teleporter, INVULNMODE_MORTAL);
                                                RemoveActiveSapper(teleporter, false);
                                        }
                                        else if (cvar_invuln_t.IntValue == 2) {
                                                ApplyInvuln(teleporter, INVULNMODE_GOD);
                                                RemoveActiveSapper(teleporter, true);
                                        }
                                }
                        }
                }
        }
        if (hHandle == cvar_notarget_p || hHandle == INVALID_HANDLE) {
                for (int client = 1; client <= MaxClients; client++) {
                        if (IsClientInGame(client) && IsFriendly[client]) {
                                if (cvar_notarget_p.IntValue > 0) SetNotarget(client, true);
                                else SetNotarget(client, false);
                        }
                }
                int entity = -1;
                while ((entity = FindEntityByClassname(entity, "func_regenerate"))!=INVALID_ENT_REFERENCE) {
                        SDKUnhook(entity, SDKHook_StartTouch, CabinetStartTouch);
                        SDKUnhook(entity, SDKHook_EndTouch, CabinetEndTouch);
                        SDKUnhook(entity, SDKHook_Touch, CabinetTouch);
                        if (cvar_notarget_p.IntValue > 1) {
                                SDKHook(entity, SDKHook_StartTouch, CabinetStartTouch);
                                SDKHook(entity, SDKHook_EndTouch, CabinetEndTouch);
                                if (cvar_notarget_p.IntValue == 3) {
                                        SDKHook(entity, SDKHook_Touch, CabinetTouch);
                                }
                        }
                }
        }
        if (hHandle == cvar_notarget_s) {
                int sentry = -1;
                while ((sentry = FindEntityByClassname(sentry, "obj_sentrygun"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(sentry)) {
                                int engie = GetEntPropEnt(sentry, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        SetNotarget(sentry, cvar_notarget_s.BoolValue);
                                }
                        }
                }
        }
        if (hHandle == cvar_notarget_d) {
                int dispenser = -1;
                while ((dispenser = FindEntityByClassname(dispenser, "obj_dispenser"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(dispenser)) {
                                int engie = GetEntPropEnt(dispenser, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        SetNotarget(dispenser, cvar_notarget_d.BoolValue);
                                }
                        }
                }
        }
        if (hHandle == cvar_notarget_t) {
                int teleporter = -1;
                while ((teleporter = FindEntityByClassname(teleporter, "obj_teleporter"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(teleporter)) {
                                int engie = GetEntPropEnt(teleporter, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        SetNotarget(teleporter, cvar_notarget_t.BoolValue);
                                }
                        }
                }
        }
        if (hHandle == cvar_noblock_p) {
                for (int client = 1; client <= MaxClients; client++) {
                        if (IsClientInGame(client) && IsFriendly[client]) {
                                ApplyNoblock(client, (cvar_noblock_p.IntValue != 0));
                        }
                }
        }
        if (hHandle == cvar_noblock_s) {
                int sentry = -1;
                while ((sentry = FindEntityByClassname(sentry, "obj_sentrygun"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(sentry)) {
                                int engie = GetEntPropEnt(sentry, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        ApplyNoblock(sentry, (cvar_noblock_s.IntValue != 0));
                                }
                        }
                }
        }
        if (hHandle == cvar_noblock_d) {
                int dispenser = -1;
                while ((dispenser = FindEntityByClassname(dispenser, "obj_dispenser"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(dispenser)) {
                                int engie = GetEntPropEnt(dispenser, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        ApplyNoblock(dispenser, (cvar_noblock_d.IntValue != 0));
                                }
                        }
                }
        }
        if (hHandle == cvar_noblock_t) {
                int teleporter = -1;
                while ((teleporter = FindEntityByClassname(teleporter, "obj_teleporter"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(teleporter)) {
                                int engie = GetEntPropEnt(teleporter, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        ApplyNoblock(teleporter, (cvar_noblock_t.IntValue != 0));
                                }
                        }
                }
        }
        if (hHandle == cvar_alpha_p) {
                for (int client = 1; client <= MaxClients; client++) {
                        if (IsClientInGame(client) && IsFriendly[client]) {
                                if (cvar_alpha_p.IntValue >= 0 && cvar_alpha_p.IntValue <= 255) {
                                        SetEntityRenderMode(client, RENDER_TRANSCOLOR);
                                        SetEntityRenderColor(client, 255, 0, 255, _);
                                }
                                else {
                                        SetEntityRenderMode(client, RENDER_NORMAL);
                                        SetEntityRenderColor(client, _, _, _, _);
                                }
                        }
                }
        }
        if (hHandle == cvar_alpha_w) {
                for (int client = 1; client <= MaxClients; client++) {
                        if (IsClientInGame(client) && IsFriendly[client]) {
                                if (cvar_alpha_w.IntValue >= 0 && cvar_alpha_w.IntValue <= 255)
                                        SetWearableInvis(client);
                                else SetWearableInvis(client, false);
                        }
                }
        }
        if (hHandle == cvar_alpha_wep) {
                for (int client = 1; client <= MaxClients; client++) {
                        if (IsClientInGame(client) && IsFriendly[client]) {
                                if (cvar_alpha_wep.IntValue >= 0 && cvar_alpha_wep.IntValue <= 255)
                                        SetWeaponInvis(client);
                                else SetWeaponInvis(client, false);
                        }
                }
        }
        if (hHandle == cvar_alpha_s) {
                int sentry = -1;
                while ((sentry = FindEntityByClassname(sentry, "obj_sentrygun"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(sentry)) {
                                int engie = GetEntPropEnt(sentry, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        if (cvar_alpha_s.IntValue >= 0) {
                                                SetEntityRenderMode(sentry, RENDER_TRANSCOLOR);
                                                SetEntityRenderColor(sentry, 255, 0, 255, _);
                                        }
                                        else {
                                                SetEntityRenderMode(sentry, RENDER_NORMAL);
                                                SetEntityRenderColor(sentry, _, _, _, _);
                                        }
                                }
                        }
                }
        }
        if (hHandle == cvar_alpha_d) {
                int dispenser = -1;
                while ((dispenser = FindEntityByClassname(dispenser, "obj_dispenser"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(dispenser)) {
                                int engie = GetEntPropEnt(dispenser, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        if (cvar_alpha_d.IntValue >= 0) {
                                                SetEntityRenderMode(dispenser, RENDER_TRANSCOLOR);
                                                SetEntityRenderColor(dispenser, 255, 0, 255, _);
                                        }
                                        else {
                                                SetEntityRenderMode(dispenser, RENDER_NORMAL);
                                                SetEntityRenderColor(dispenser, _, _, _, _);
                                        }
                                }
                        }
                }
        }
        if (hHandle == cvar_alpha_t) {
                int teleporter = -1;
                while ((teleporter = FindEntityByClassname(teleporter, "obj_teleporter"))!=INVALID_ENT_REFERENCE) {
                        if (IsValidEntity(teleporter)) {
                                int engie = GetEntPropEnt(teleporter, Prop_Send, "m_hBuilder");
                                if (IsValidClient(engie) && IsFriendly[engie]) {
                                        if (cvar_alpha_t.IntValue >= 0) {
                                                SetEntityRenderMode(teleporter, RENDER_TRANSCOLOR);
                                                SetEntityRenderColor(teleporter, 255, 0, 255, _);
                                        }
                                        else {
                                                SetEntityRenderMode(teleporter, RENDER_NORMAL);
                                                SetEntityRenderColor(teleporter, _, _, _, _);
                                        }
                                }
                        }
                }
        }
        if (hHandle == cvar_blockweps_black || hHandle == INVALID_HANDLE) {
                char strWeaponsBlack[255];
                cvar_blockweps_black.GetString(strWeaponsBlack, sizeof(strWeaponsBlack));
                if (StrEqual(strWeaponsBlack, "-2")) {
                        g_blockweps_black[0] = -1;
                }
                else {
                        char strWeaponsBlack2[255][8];
                        if (StrEqual(strWeaponsBlack, "-1")) {
                                strWeaponsBlack = DEFAULT_BLOCKED_WEAPONS;
                        }
                        int numweps = ExplodeString(strWeaponsBlack, ",", strWeaponsBlack2, sizeof(strWeaponsBlack2), sizeof(strWeaponsBlack2[]));
                        for (int i=0; i < sizeof(g_blockweps_black) && i < numweps; i++) {
                                g_blockweps_black[i] = StringToInt(strWeaponsBlack2[i]);
                        }
                        g_blockweps_black[numweps] = -1;
                }
        }
        if (hHandle == cvar_blockweps_white || hHandle == INVALID_HANDLE) {
                char strWeaponsWhite[255];
                cvar_blockweps_white.GetString(strWeaponsWhite, sizeof(strWeaponsWhite));
                if (StrEqual(strWeaponsWhite, "-2")) {
                        g_blockweps_white[0] = -1;
                }
                else {
                        char strWeaponsWhite2[255][8];
                        if (StrEqual(strWeaponsWhite, "-1")) {
                                strWeaponsWhite = DEFAULT_WHITELISTED_WEAPONS;
                        }
                        int numweps = ExplodeString(strWeaponsWhite, ",", strWeaponsWhite2, sizeof(strWeaponsWhite2), sizeof(strWeaponsWhite2[]));
                        for (int i=0; i < sizeof(g_blockweps_white) && i < numweps; i++) {
                                g_blockweps_white[i] = StringToInt(strWeaponsWhite2[i]);
                        }
                        g_blockweps_white[numweps] = -1;
                }
        }
        if (hHandle == cvar_blockweps_classes || hHandle == INVALID_HANDLE) {
                char strWeaponsClass[256];
                cvar_blockweps_classes.GetString(strWeaponsClass, sizeof(strWeaponsClass));
                if (StrEqual(strWeaponsClass, "-2")) {
                        g_blockweps_classes[0] = "-1";
                }
                else {
                        if (StrEqual(strWeaponsClass, "-1")) {
                                strWeaponsClass = DEFAULT_BLOCKED_WEAPONCLASSES;
                        }
                        int numclasses = ExplodeString(strWeaponsClass, ",", g_blockweps_classes, sizeof(g_blockweps_classes), sizeof(g_blockweps_classes[]));
                        g_blockweps_classes[numclasses] = "-1";
                }
        }
        if (hHandle == cvar_blocktaunt || hHandle == INVALID_HANDLE) {
                char strWeaponsTaunt[255];
                cvar_blocktaunt.GetString(strWeaponsTaunt, sizeof(strWeaponsTaunt));
                if (StrEqual(strWeaponsTaunt, "-2")) {
                        g_blocktaunt[0] = -1;
                }
                else {
                        char strWeaponsTaunt2[255][8];
                        if (StrEqual(strWeaponsTaunt, "-1")) {
                                strWeaponsTaunt = DEFAULT_BLOCKED_TAUNTS;
                        }
                        int numweps = ExplodeString(strWeaponsTaunt, ",", strWeaponsTaunt2, sizeof(strWeaponsTaunt2), sizeof(strWeaponsTaunt2[]));
                        for (int i=0; i < sizeof(g_blocktaunt) && i < numweps; i++) {
                                g_blocktaunt[i] = StringToInt(strWeaponsTaunt2[i]);
                        }
                        g_blocktaunt[numweps] = -1;
                }
        }
        if (hHandle == INVALID_HANDLE) {
                HookCvars();
                HookThings();
        }
}

void HookCvars() {
        HookConVarChange(cvar_enabled, cvarChange);
        HookConVarChange(cvar_afklimit, cvarChange);
        HookConVarChange(cvar_afkinterval, cvarChange);
        //HookConVarChange(cvar_botignore, cvarChange);
        HookConVarChange(cvar_stopcap, cvarChange);
        HookConVarChange(cvar_stopintel, cvarChange);
        HookConVarChange(cvar_ammopack, cvarChange);
        HookConVarChange(cvar_healthpack, cvarChange);
        HookConVarChange(cvar_money, cvarChange);
        HookConVarChange(cvar_spellbook, cvarChange);
        HookConVarChange(cvar_pumpkin, cvarChange);
        HookConVarChange(cvar_funcbutton, cvarChange);
        HookConVarChange(cvar_blockweps_classes, cvarChange);
        HookConVarChange(cvar_blockweps_black, cvarChange);
        HookConVarChange(cvar_blockweps_white, cvarChange);
        HookConVarChange(cvar_blocktaunt, cvarChange);
        HookConVarChange(cvar_invuln_p, cvarChange);
        HookConVarChange(cvar_invuln_s, cvarChange);
        HookConVarChange(cvar_invuln_d, cvarChange);
        HookConVarChange(cvar_invuln_t, cvarChange);
        HookConVarChange(cvar_notarget_p, cvarChange);
        HookConVarChange(cvar_notarget_s, cvarChange);
        HookConVarChange(cvar_notarget_d, cvarChange);
        HookConVarChange(cvar_notarget_t, cvarChange);
        HookConVarChange(cvar_alpha_p, cvarChange);
        HookConVarChange(cvar_alpha_w, cvarChange);
        HookConVarChange(cvar_alpha_wep, cvarChange);
        HookConVarChange(cvar_alpha_s, cvarChange);
        HookConVarChange(cvar_alpha_d, cvarChange);
        HookConVarChange(cvar_alpha_t, cvarChange);
        HookConVarChange(cvar_noblock_p, cvarChange);
        HookConVarChange(cvar_noblock_s, cvarChange);
        HookConVarChange(cvar_noblock_d, cvarChange);
        HookConVarChange(cvar_noblock_t, cvarChange);
}



All times are GMT -4. The time now is 04:54.

Powered by vBulletin®
Copyright ©2000 - 2024, vBulletin Solutions, Inc.