AlliedModders

AlliedModders (https://forums.alliedmods.net/index.php)
-   Plugin/Gameplay Ideas and Requests (https://forums.alliedmods.net/forumdisplay.php?f=60)
-   -   [REQ] Changeable Hook Command Cvar (https://forums.alliedmods.net/showthread.php?t=264966)

spancer35 06-23-2015 21:22

[REQ] Changeable Hook Command Cvar
 
Hello everyone. I want changeable hook command with cvar like that

original plugin : https://forums.alliedmods.net/showthread.php?p=1839628

Code:

+hook(working)
sm_cvar sm_hgr_hook_command "example"
Unknown Command "+hook"
Unknown Command "-hook"
+example(working)

Somebody can edit this plugin :/

PHP Code:

/**
 * ==========================================================================
 * SourceMod Hook Grab Rope for Source
 *
 * SourceMod Forums URL:
 * https://forums.alliedmods.net/showthread.php?t=201154
 *
 * by Sheepdude and SumGuy14
 *
 * Allows admins (or all players) to hook on to walls, grab other players, or swing on a rope
 *
 */

#include <sourcemod>
#include <sdktools>
#include <hgr>

#pragma semicolon 1

#define PLUGIN_VERSION "1.1.4"

public Plugin:myinfo 
{
    
name "Hook Grab Rope",
    
author "Sheepdude, SumGuy14",
    
description "Allows admins (or all players) to hook on to walls, grab other players, or swing on a rope",
    
version PLUGIN_VERSION,
    
url "http://www.clan-psycho.com"
};

// General handles
new Handle:h_cvarAnnounce;
new 
Handle:h_cvarSoundAmplify;
new 
Handle:h_cvarOverrideMode;
new 
Handle:h_cvarRopeOldMode;
new 
Handle:h_cvarUpButton;
new 
Handle:h_cvarDownButton;

// Hook handles
new Handle:h_cvarHookEnable;
new 
Handle:h_cvarHookAdminOnly;
new 
Handle:h_cvarHookFreeze;
new 
Handle:h_cvarHookSlide;
new 
Handle:h_cvarHookSpeed;
new 
Handle:h_cvarHookInitWidth;
new 
Handle:h_cvarHookEndWidth;
new 
Handle:h_cvarHookAmplitude;
new 
Handle:h_cvarHookBeamColor;
new 
Handle:h_cvarHookRed;
new 
Handle:h_cvarHookGreen;
new 
Handle:h_cvarHookBlue;
new 
Handle:h_cvarHookAlpha;
new 
Handle:h_cvarHookSound;

// Grab handles
new Handle:h_cvarGrabEnable;
new 
Handle:h_cvarGrabAdminOnly;
new 
Handle:h_cvarGrabFreeze;
new 
Handle:h_cvarGrabSlide;
new 
Handle:h_cvarGrabSpeed;
new 
Handle:h_cvarGrabInitWidth;
new 
Handle:h_cvarGrabEndWidth;
new 
Handle:h_cvarGrabAmplitude;
new 
Handle:h_cvarGrabBeamColor;
new 
Handle:h_cvarGrabRed;
new 
Handle:h_cvarGrabGreen;
new 
Handle:h_cvarGrabBlue;
new 
Handle:h_cvarGrabAlpha;
new 
Handle:h_cvarGrabSound;

// Rope handles
new Handle:h_cvarRopeEnable;
new 
Handle:h_cvarRopeAdminOnly;
new 
Handle:h_cvarRopeFreeze;
new 
Handle:h_cvarRopeSlide;
new 
Handle:h_cvarRopeSpeed;
new 
Handle:h_cvarRopeInitWidth;
new 
Handle:h_cvarRopeEndWidth;
new 
Handle:h_cvarRopeAmplitude;
new 
Handle:h_cvarRopeBeamColor;
new 
Handle:h_cvarRopeRed;
new 
Handle:h_cvarRopeGreen;
new 
Handle:h_cvarRopeBlue;
new 
Handle:h_cvarRopeAlpha;
new 
Handle:h_cvarRopeSound;

// Forward handles
new Handle:FwdClientHook;
new 
Handle:FwdClientGrabSearch;
new 
Handle:FwdClientGrab;
new 
Handle:FwdClientRope;

// HGR variables
new g_cvarSoundAmplify;
new 
bool:g_cvarAnnounce;
new 
bool:g_cvarOverrideMode;
new 
bool:g_cvarRopeOldMode;
new 
bool:g_cvarFreeze[3];
new 
bool:g_cvarSlide[3];
new 
bool:g_cvarEnable[3];
new 
bool:g_cvarAdminOnly[3];
new 
Float:g_cvarSpeed[3];
new 
Float:g_cvarInitWidth[3];
new 
Float:g_cvarEndWidth[3];
new 
Float:g_cvarAmplitude[3];
new 
g_cvarBeamColor[3];
new 
g_cvarBeamRed[3];
new 
g_cvarBeamGreen[3];
new 
g_cvarBeamBlue[3];
new 
g_cvarBeamAlpha[3];
new 
String:g_cvarSound[3][64];

// Client status arrays
new bool:g_Status[MAXPLAYERS+1][3]; // Is client using hook, grab, or rope
new bool:g_AllowedClients[MAXPLAYERS+1][3]; // Does client have hook, grab, or rope access
new bool:g_Grabbed[MAXPLAYERS+1]; // Is client being grabbed
new bool:g_Backward[MAXPLAYERS+1]; // Is client hooking backward or forward
new bool:g_Attracting[MAXPLAYERS+1][2]; // Is client pushing or pulling grab target
new bool:g_Climbing[MAXPLAYERS+1][2]; // Is client ascending or descending rope
new bool:g_TRIgnore[MAXPLAYERS+1]; // Used to ignore traceray collisions with originating player
new Float:g_Gravity[MAXPLAYERS+1]; // Used to reset client gravity to previous value
new Float:g_MaxSpeed[MAXPLAYERS+1]; // Used to reset grab target speed after being slowed

// HGR Arrays
new g_Targetindex[MAXPLAYERS+1][4];
new 
Float:g_Location[MAXPLAYERS+1][4][3];
new 
Float:g_Distance[MAXPLAYERS+1][4];

// Button bitstrings
new g_cvarUpButton;
new 
g_cvarDownButton;

// Freezetime variables
new bool:g_HookedFreeze;
new 
bool:g_HookedRoundStart;
new 
bool:g_Frozen[3];

// Offset variables
new OriginOffset;
new 
GetVelocityOffset_x;
new 
GetVelocityOffset_y;
new 
GetVelocityOffset_z;

// Precache variables
new precache_laser;

enum HGRAction
{
    
Hook 0/** User is using hook */
    
Grab 1/** User is using grab */
    
Rope 2/** User is using rope */
};

enum HGRAccess
{
    
Give 0/** Gives access to user */
    
Take 1/** Takes access from user */
};

public 
OnPluginStart()
{
    
// Load Translation Files
    
LoadTranslations("common.phrases");
    
LoadTranslations("hookgrabrope.phrases");
    
    
PrintToServer("----------------|         [HGR] %t        |---------------""Loading");
    
    
// Create global forwards
    
FwdClientHook CreateGlobalForward("HGR_OnClientHook"ET_HookParam_Cell);
    
FwdClientGrabSearch CreateGlobalForward("HGR_OnClientGrabSearch"ET_HookParam_Cell);
    
FwdClientGrab CreateGlobalForward("HGR_OnClientGrab"ET_HookParam_Cell);
    
FwdClientRope CreateGlobalForward("HGR_OnClientRope"ET_HookParam_Cell);
    
    
// Hook events
    
HookEventEx("player_spawn"PlayerSpawnEvent);
    
g_HookedFreeze HookEventEx("round_freeze_end"RoundFreezeEndEvent);
    
g_HookedRoundStart HookEventEx("round_start"RoundStartEvent);

    
// Register client commands
    
RegConsoleCmd("+hook"HookCmd);
    
RegConsoleCmd("-hook"UnHookCmd);
    
RegConsoleCmd("hook_toggle"HookToggle);

    
RegConsoleCmd("+grab"GrabCmd);
    
RegConsoleCmd("-grab"DropCmd);
    
RegConsoleCmd("grab_toggle"GrabToggle);

    
RegConsoleCmd("+rope"RopeCmd);
    
RegConsoleCmd("-rope"DetachCmd);
    
RegConsoleCmd("rope_toggle"RopeToggle);
    
    
RegConsoleCmd("+push"PushCmd);
    
RegConsoleCmd("-push"UnPushCmd);
    
RegConsoleCmd("push_toggle"HookToggle);

    
// Register admin cmds
    
RegAdminCmd("sm_hgr_givehook"GiveHookADMFLAG_GENERIC);
    
RegAdminCmd("sm_hgr_takehook"TakeHookADMFLAG_GENERIC);

    
RegAdminCmd("sm_hgr_givegrab"GiveGrabADMFLAG_GENERIC);
    
RegAdminCmd("sm_hgr_takegrab"TakeGrabADMFLAG_GENERIC);

    
RegAdminCmd("sm_hgr_giverope"GiveRopeADMFLAG_GENERIC);
    
RegAdminCmd("sm_hgr_takerope"TakeRopeADMFLAG_GENERIC);

    
// Find offsets
    
OriginOffset FindSendPropOffs("CBaseEntity""m_vecOrigin");
    if(
OriginOffset == -1)
        
SetFailState("[HGR] Error: Failed to find the origin offset, aborting");

    
GetVelocityOffset_x FindSendPropOffs("CBasePlayer""m_vecVelocity[0]");
    if(
GetVelocityOffset_x == -1)
        
SetFailState("[HGR] Error: Failed to find the velocity_x offset, aborting");

    
GetVelocityOffset_y FindSendPropOffs("CBasePlayer""m_vecVelocity[1]");
    if(
GetVelocityOffset_y == -1)
        
SetFailState("[HGR] Error: Failed to find the velocity_y offset, aborting");

    
GetVelocityOffset_z FindSendPropOffs("CBasePlayer""m_vecVelocity[2]");
    if(
GetVelocityOffset_z == -1)
        
SetFailState("[HGR] Error: Failed to find the velocity_z offset, aborting");

    
// Public convar
    
CreateConVar("sm_hgr_version"PLUGIN_VERSION"[HGR] Plugin version"FCVAR_DONTRECORD|FCVAR_NOTIFY|FCVAR_PLUGIN|FCVAR_REPLICATED|FCVAR_SPONLY);

    
// General convars
    
h_cvarAnnounce      CreateConVar("sm_hgr_announce""1""Enable plugin announcements, 1 - enable, 0 - disable"0true0.0true1.0);
    
h_cvarSoundAmplify  CreateConVar("sm_hgr_sound_amplify""3""Control the sound effect volume, 0 - No Sound, 1 - Quiet, 5 - Loud"0true0.0true5.0);
    
h_cvarOverrideMode  CreateConVar("sm_hgr_overridemode""0""If enabled, only players who have manually been given access can use plugin"0true0.0true1.0);
    
h_cvarRopeOldMode   CreateConVar("sm_hgr_rope_oldmode""0""Use the old rope type, 1 - Use old type, 0 - Don't use old type"0true0.0true1.0);
    
h_cvarUpButton      CreateConVar("sm_hgr_upbutton""IN_JUMP""Button to use for ascending rope, hooking forward, and pushing grab target");
    
h_cvarDownButton    CreateConVar("sm_hgr_downbutton""IN_DUCK""Button to use for descending rope, hooking backward, and pulling grab target");

    
// Hook convars
    
h_cvarHookEnable    CreateConVar("sm_hgr_hook_enable""1""This will enable the hook feature of this plugin"FCVAR_NOTIFYtrue0.0true1.0);
    
h_cvarHookAdminOnly CreateConVar("sm_hgr_hook_adminonly""1""If 1, only admins can use hook"0true0.0true1.0);
    
h_cvarHookFreeze    CreateConVar("sm_hgr_hook_freeze_enable""0""Allow players to hook during freezetime, 1 - Allow, 0 - Disallow"0true0.0true1.0);
    
h_cvarHookSlide     CreateConVar("sm_hgr_hook_slide_enable""1""Allow players to reverse the direction of the hook, 1 - Allow, 0 - Disallow"0true0.0true1.0);
    
h_cvarHookSpeed     CreateConVar("sm_hgr_hook_speed""5.0""The speed of the player using hook"0true0.0true100.0);
    
h_cvarHookInitWidth CreateConVar("sm_hgr_hook_initwidth""5.0""The initial width of the hook beam"0true0.0true100.0);
    
h_cvarHookEndWidth  CreateConVar("sm_hgr_hook_endwidth""5.0""The end width of the hook beam"0true0.0true100.0);
    
h_cvarHookAmplitude CreateConVar("sm_hgr_hook_amplitude""0.0""The amplitude of the hook beam"0true0.0true100.0);
    
h_cvarHookBeamColor CreateConVar("sm_hgr_hook_color""2""The color of the hook, 0 = White, 1 = Team color, 2 = custom, 3 = Reverse team color"0true0.0true3.0);
    
h_cvarHookRed       CreateConVar("sm_hgr_hook_red""255""The red component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarHookGreen     CreateConVar("sm_hgr_hook_green""0""The green component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarHookBlue      CreateConVar("sm_hgr_hook_blue""0""The blue component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarHookAlpha     CreateConVar("sm_hgr_hook_alpha""255""The alpha component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarHookSound     CreateConVar("sm_hgr_hook_sound""hgr/hookhit.mp3""Location of hook sound effect relative to /sound/music/");

    
// Grab convars
    
h_cvarGrabEnable    CreateConVar("sm_hgr_grab_enable""1""This will enable the grab feature of this plugin"FCVAR_NOTIFYtrue0.0true1.0);
    
h_cvarGrabAdminOnly CreateConVar("sm_hgr_grab_adminonly""1""If 1, only admins can use grab"0true0.0true1.0);
    
h_cvarGrabFreeze    CreateConVar("sm_hgr_grab_freeze_enable""0""Allow players to grab during freezetime, 1 - Allow, 0 - Disallow"0true0.0true1.0);
    
h_cvarGrabSlide     CreateConVar("sm_hgr_grab_slide_enable""1""Allow players to push or pull grab target, 1 - Allow, 0 - Disallow"0true0.0true1.0);
    
h_cvarGrabSpeed     CreateConVar("sm_hgr_grab_speed""5.0""The speed of the grabbers target"0true0.0true100.0);
    
h_cvarGrabInitWidth CreateConVar("sm_hgr_grab_initwidth""1.0""The initial width of the grab beam"0true0.0true100.0);
    
h_cvarGrabEndWidth  CreateConVar("sm_hgr_grab_endwidth""10.0""The end width of the grab beam"0true0.0true100.0);
    
h_cvarGrabAmplitude CreateConVar("sm_hgr_grab_amplitude""0.0""The amplitude of the grab beam"0true0.0true100.0);
    
h_cvarGrabBeamColor CreateConVar("sm_hgr_grab_color""2""The color of the grab beam, 0 = White, 1 = Team color, 2 = custom, 3 = Reverse team color"0true0.0true3.0);
    
h_cvarGrabRed       CreateConVar("sm_hgr_grab_red""0""The red component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarGrabGreen     CreateConVar("sm_hgr_grab_green""0""The green component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarGrabBlue      CreateConVar("sm_hgr_grab_blue""255""The blue component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarGrabAlpha     CreateConVar("sm_hgr_grab_alpha""255""The alpha component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarGrabSound     CreateConVar("sm_hgr_grab_sound""hgr/hookhit.mp3""Location of grab sound effect relative to /sound/music/");

    
// Rope convars
    
h_cvarRopeEnable    CreateConVar("sm_hgr_rope_enable""1""This will enable the rope feature of this plugin"FCVAR_NOTIFYtrue0.0true1.0);
    
h_cvarRopeAdminOnly CreateConVar("sm_hgr_rope_adminonly""1""If 1, only admins can use rope"0true0.0true1.0);
    
h_cvarRopeFreeze    CreateConVar("sm_hgr_rope_freeze_enable""0""Allow players to rope during freezetime, 1 - Allow, 0 - Disallow"0true0.0true1.0);
    
h_cvarRopeSlide     CreateConVar("sm_hgr_rope_slide_enable""1""Allow players to slide up or down rope, 1 - Allow, 0 - Disallow"0true0.0true1.0);
    
h_cvarRopeSpeed     CreateConVar("sm_hgr_rope_speed""5.0""The speed of the player using rope"0true0.0true100.0);
    
h_cvarRopeInitWidth CreateConVar("sm_hgr_rope_initwidth""3.0""The initial width of the rope beam"0true0.0true100.0);
    
h_cvarRopeEndWidth  CreateConVar("sm_hgr_rope_endwidth""3.0""The end width of the rope beam"0true0.0true100.0);
    
h_cvarRopeAmplitude CreateConVar("sm_hgr_rope_amplitude""0.0""The amplitude of the rope beam"0true0.0true100.0);
    
h_cvarRopeBeamColor CreateConVar("sm_hgr_rope_color""2""The color of the rope, 0 = White, 1 = Team color, 2 = custom, 3 = Reverse team color"0true0.0true3.0);
    
h_cvarRopeRed       CreateConVar("sm_hgr_rope_red""0""The red component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarRopeGreen     CreateConVar("sm_hgr_rope_green""255""The green component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarRopeBlue      CreateConVar("sm_hgr_rope_blue""0""The blue component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarRopeAlpha     CreateConVar("sm_hgr_rope_alpha""255""The alpha component of the beam (Only if you are using a custom color)"0true0.0true255.0);
    
h_cvarRopeSound     CreateConVar("sm_hgr_rope_sound""hgr/hookhit.mp3""Location of rope sound effect relative to /sound/music/");
    
    
// General convar changes
    
HookConVarChange(h_cvarAnnounceConvarChanged);
    
HookConVarChange(h_cvarSoundAmplifyConvarChanged);
    
HookConVarChange(h_cvarOverrideModeConvarChanged);
    
HookConVarChange(h_cvarRopeOldModeConvarChanged);
    
HookConVarChange(h_cvarUpButtonConvarChanged);
    
HookConVarChange(h_cvarDownButtonConvarChanged);
    
    
// Hook convar changes
    
HookConVarChange(h_cvarHookEnableConvarChanged);
    
HookConVarChange(h_cvarHookAdminOnlyConvarChanged);
    
HookConVarChange(h_cvarHookFreezeConvarChanged);
    
HookConVarChange(h_cvarHookSlideConvarChanged);
    
HookConVarChange(h_cvarHookSpeedConvarChanged);
    
HookConVarChange(h_cvarHookInitWidthConvarChanged);
    
HookConVarChange(h_cvarHookEndWidthConvarChanged);
    
HookConVarChange(h_cvarHookAmplitudeConvarChanged);
    
HookConVarChange(h_cvarHookBeamColorConvarChanged);
    
HookConVarChange(h_cvarHookRedConvarChanged);
    
HookConVarChange(h_cvarHookGreenConvarChanged);
    
HookConVarChange(h_cvarHookBlueConvarChanged);
    
HookConVarChange(h_cvarHookAlphaConvarChanged);
    
HookConVarChange(h_cvarHookSoundConvarChanged);
    
    
// Grab convar changes
    
HookConVarChange(h_cvarGrabEnableConvarChanged);
    
HookConVarChange(h_cvarGrabAdminOnlyConvarChanged);
    
HookConVarChange(h_cvarGrabFreezeConvarChanged);
    
HookConVarChange(h_cvarGrabSlideConvarChanged);
    
HookConVarChange(h_cvarGrabSpeedConvarChanged);
    
HookConVarChange(h_cvarGrabInitWidthConvarChanged);
    
HookConVarChange(h_cvarGrabEndWidthConvarChanged);
    
HookConVarChange(h_cvarGrabAmplitudeConvarChanged);
    
HookConVarChange(h_cvarGrabBeamColorConvarChanged);
    
HookConVarChange(h_cvarGrabRedConvarChanged);
    
HookConVarChange(h_cvarGrabGreenConvarChanged);
    
HookConVarChange(h_cvarGrabBlueConvarChanged);
    
HookConVarChange(h_cvarGrabAlphaConvarChanged);
    
HookConVarChange(h_cvarGrabSoundConvarChanged);
    
    
// Rope convar changes
    
HookConVarChange(h_cvarRopeEnableConvarChanged);
    
HookConVarChange(h_cvarRopeAdminOnlyConvarChanged);
    
HookConVarChange(h_cvarRopeFreezeConvarChanged);
    
HookConVarChange(h_cvarRopeSlideConvarChanged);
    
HookConVarChange(h_cvarRopeSpeedConvarChanged);
    
HookConVarChange(h_cvarRopeInitWidthConvarChanged);
    
HookConVarChange(h_cvarRopeEndWidthConvarChanged);
    
HookConVarChange(h_cvarRopeAmplitudeConvarChanged);
    
HookConVarChange(h_cvarRopeBeamColorConvarChanged);
    
HookConVarChange(h_cvarRopeRedConvarChanged);
    
HookConVarChange(h_cvarRopeGreenConvarChanged);
    
HookConVarChange(h_cvarRopeBlueConvarChanged);
    
HookConVarChange(h_cvarRopeAlphaConvarChanged);
    
HookConVarChange(h_cvarRopeSoundConvarChanged);
  
    
// Auto-generate configuration file
    
AutoExecConfig(true"hookgrabrope");

    
PrintToServer("----------------|         [HGR] %t         |---------------""Loaded");
}

public 
APLRes:AskPluginLoad2(Handle:myselfbool:lateString:error[], err_max)
{
    
decl String:file[PLATFORM_MAX_PATH];
    
BuildPath(Path_SMfilesizeof(file), "plugins/hookgrabrope.smx");
    if(!
FileExists(file))
    {
        
SetFailState("ERROR: Cannot find required plugin hookgrabrope.smx");
        return 
APLRes_Failure;
    }
    
RegPluginLibrary("hookgrabrope");
    
    
// Access natives
    
CreateNative("HGR_Access"__Access);
    
CreateNative("HGR_ClientAccess"__ClientAccess);
    
    
// Status bools
    
CreateNative("HGR_IsHooking"__IsHooking);
    
CreateNative("HGR_IsGrabbing"__IsGrabbing);
    
CreateNative("HGR_IsBeingGrabbed"__IsBeingGrabbed);
    
CreateNative("HGR_IsRoping"__IsRoping);
    
CreateNative("HGR_IsPushing"__IsPushing);
    
CreateNative("HGR_IsAttracting"__IsAttracting);
    
CreateNative("HGR_IsRepelling"__IsRepelling);
    
CreateNative("HGR_IsAscending"__IsAscending);
    
CreateNative("HGR_IsDescending"__IsDescending);
    
    
// Information natives
    
CreateNative("HGR_GetHookLocation"__GetHookLocation);
    
CreateNative("HGR_GetGrabLocation"__GetGrabLocation);
    
CreateNative("HGR_GetRopeLocation"__GetRopeLocation);
    
CreateNative("HGR_GetPushLocation"__GetPushLocation);
    
CreateNative("HGR_GetHookDistance"__GetHookDistance);
    
CreateNative("HGR_GetGrabDistance"__GetGrabDistance);
    
CreateNative("HGR_GetRopeDistance"__GetRopeDistance);
    
CreateNative("HGR_GetPushDistance"__GetPushDistance);
    
CreateNative("HGR_GetHookTarget"__GetHookTarget);
    
CreateNative("HGR_GetGrabTarget"__GetGrabTarget);
    
CreateNative("HGR_GetRopeTarget"__GetRopeTarget);
    
CreateNative("HGR_GetPushTarget"__GetPushTarget);
    
    
// Action overrides
    
CreateNative("HGR_ForceHook"__ForceHook);
    
CreateNative("HGR_ForceGrab"__ForceGrab);
    
CreateNative("HGR_ForceRope"__ForceRope);
    
CreateNative("HGR_ForcePush"__ForcePush);
    
CreateNative("HGR_StopHook"__StopHook);
    
CreateNative("HGR_StopGrab"__StopGrab);
    
CreateNative("HGR_StopRope"__StopRope);
    
    return 
APLRes_Success;
}

/**********
 *Forwards*
***********/

public OnConfigsExecuted()
{
    
UpdateAllConvars();
    
// Precache models
    
precache_laser PrecacheModel("materials/sprites/laserbeam.vmt");
    
    
// Precache sounds
    
if(g_cvarSoundAmplify 0// Don't download sounds if sound is disabled
    
{
        for(new 
HGRAction:Hook<= Ropei++)
        {
            
Format(g_cvarSound[i], sizeof(g_cvarSound[]), "music/%s"g_cvarSound[i]);
            
decl String:path[64];
            
Format(pathsizeof(path), "sound/%s"g_cvarSound[i]);
            
AddFileToDownloadsTable(path);
            
PrecacheSound(g_cvarSound[i], true);
        }
    }
}

public 
bool:OnClientConnect(clientString:rejectmsg[], maxlen)
{
    
// Initialize variables for special plugin access when clients connect
    
ResetAccess(client);
    return 
true;
}

public 
OnClientDisconnect(client)
{
    
// Disable special plugin access for client when they disconnect
    
ResetAccess(client);
}

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

public __Access(Handle:pluginnumParams)
{
    
decl String:client[64];
    
GetNativeString(1clientsizeof(client));
    new 
HGRAccess:access GetNativeCell(2);
    new 
HGRAction:action GetNativeCell(3);
    return 
Access(clientaccessaction);
}

public 
__ClientAccess(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    new 
HGRAccess:access GetNativeCell(2);
    new 
HGRAction:action GetNativeCell(3);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    return 
ClientAccess(clientaccessaction) == 1;
}

public 
__IsHooking(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    return 
g_Status[client][Hook];
}

public 
__IsGrabbing(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    return 
g_Status[client][Grab];
}

public 
__IsBeingGrabbed(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    return 
g_Grabbed[client];
}

public 
__IsRoping(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    return 
g_Status[client][Rope];
}

public 
__IsPushing(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Hook])
        return 
g_Backward[client];
    return 
false;
}

public 
__IsAttracting(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Grab])
        return 
g_Attracting[client][1];
    return 
false;
}

public 
__IsRepelling(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Grab])
        return 
g_Attracting[client][0];
    return 
false;
}

public 
__IsAscending(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Rope])
        return 
g_Climbing[client][0];
    return 
false;
}

public 
__IsDescending(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Rope])
        return 
g_Climbing[client][1];
    return 
false;
}

public 
__GetHookLocation(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Hook])
    {
        
SetNativeArray(2g_Location[client][0], 3);
        return 
true;
    }
    return 
false;
}

public 
__GetGrabLocation(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Grab])
    {
        new 
Float:buffer[3];
        
GetEntityOrigin(g_Targetindex[client][Grab], buffer);
        
SetNativeArray(2buffer3);
        return 
true;
    }
    else
        return 
false;
}

public 
__GetRopeLocation(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Rope])
    {
        
SetNativeArray(2g_Location[client][2], 3);
        return 
true;
    }
    else
        return 
false;
}

public 
__GetPushLocation(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Hook])
    {
        
SetNativeArray(2g_Location[client][3], 3);
        return 
true;
    }
    else
        return 
false;
}

public 
__GetHookDistance(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Hook])
        return 
_:g_Distance[client][0];
    else
        return -
1;
}

public 
__GetGrabDistance(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Grab])
        return 
_:g_Distance[client][1];
    else
        return -
1;
}

public 
__GetRopeDistance(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Rope])
        return 
_:g_Distance[client][2];
    else
        return -
1;
}

public 
__GetPushDistance(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Hook])
        return 
_:g_Distance[client][3];
    else
        return -
1;
}

public 
__GetHookTarget(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Hook])
        return 
g_Targetindex[client][Hook];
    else
        return -
1;
}

public 
__GetGrabTarget(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Grab])
        return 
g_Targetindex[client][Grab];
    else
        return -
1;
}

public 
__GetRopeTarget(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Rope])
        return 
g_Targetindex[client][Rope];
    else
        return -
1;
}

public 
__GetPushTarget(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Hook])
        return 
g_Targetindex[client][3];
    else
        return -
1;
}

public 
__ForceHook(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(!
g_Status[client][Hook] && !g_Status[client][Grab] && !g_Status[client][Rope] && !g_Grabbed[client])
    {
        
HookCmd(client0);
        return 
true;
    }
    return 
false;
}

public 
__ForceGrab(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(!
g_Status[client][Hook] && !g_Status[client][Grab] && !g_Status[client][Rope] && !g_Grabbed[client])
    {
        
GrabCmd(client0);
        return 
true;
    }
    return 
false;
}

public 
__ForceRope(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(!
g_Status[client][Hook] && !g_Status[client][Grab] && !g_Status[client][Rope] && !g_Grabbed[client])
    {
        
RopeCmd(client0);
        return 
true;
    }
    return 
false;
}

public 
__ForcePush(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(!
g_Status[client][Hook] && !g_Status[client][Grab] && !g_Status[client][Rope] && !g_Grabbed[client])
    {
        
PushCmd(client0);
        return 
true;
    }
    return 
false;
}

public 
__StopHook(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Hook])
    {
        
UnHookCmd(client0);
        return 
true;
    }
    return 
false;
}

public 
__StopGrab(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Grab])
    {
        
DropCmd(client0);
        return 
true;
    }
    return 
false;
}

public 
__StopRope(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Rope])
    {
        
DetachCmd(client0);
        return 
true;
    }
    return 
false;
}

public 
__StopPush(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if(
client || client MaxClients)
        return 
ThrowNativeError(SP_ERROR_NATIVE"Invalid client index [%d]"client);
    else if(!
IsClientInGame(client))
        return 
ThrowNativeError(SP_ERROR_NATIVE"Client is not currently ingame [%d]"client);
    if(
g_Status[client][Hook] && g_Backward[client])
    {
        
DetachCmd(client0);
        return 
true;
    }
    return 
false;
}

/********
 *Events*
*********/

public OnGameFrame()
{
    for (new 
1<= MaxClientsi++)
    {
        if (
IsClientInGame(i) && IsPlayerAlive(i))
        {
            new 
cl_buttons GetClientButtons(i);
            if(
g_Status[i][Hook] && g_cvarSlide[Hook])
            {
                if(
cl_buttons g_cvarUpButton && g_Backward[i])
                {
                    
SetEntityMoveType(iMOVETYPE_WALK);
                    
g_Backward[i] = false// Hook in forward direction if client is jumping
                
}
                else if(
cl_buttons g_cvarDownButton && !g_Backward[i])
                {
                    
SetEntityMoveType(iMOVETYPE_WALK);
                    
g_Backward[i] = true// Hook in reverse direction if client is crouching
                
}
            }
            else if(
g_Status[i][Grab] && g_cvarSlide[Grab])
            {
                if(
cl_buttons g_cvarUpButton)
                {
                    if(!
g_Attracting[i][0])
                    {
                        
g_Attracting[i][0] = true// Repel grab target away from client while jumping
                        
g_Attracting[i][1] = false;
                    }
                }
                else
                {
                    if(
g_Attracting[i][0])
                        
g_Attracting[i][0] = false// Tell plugin client is no longer repelling grab target while no longer jumping
                    
if(cl_buttons g_cvarDownButton)
                    {
                        if(!
g_Attracting[i][1])
                            
g_Attracting[i][1] = true// Attract grab target toward client while crouching
                    
}
                    else if(
g_Attracting[i][1])
                        
g_Attracting[i][1] = false// Tell plugin client is no longer attracting grab target while no longer crouching
                
}
            }
            else if(
g_Status[i][Rope] && g_cvarSlide[Rope])
            {
                if(
cl_buttons g_cvarUpButton)
                {
                    if(!
g_Climbing[i][0])
                    {
                        
g_Climbing[i][0] = true// Ascend rope while jumping
                        
g_Climbing[i][1] = false;
                    }
                }
                else
                {
                    if(
g_Climbing[i][0])
                        
g_Climbing[i][0] = false// Tell plugin client is no longer ascending rope while not jumping
                    
if(cl_buttons g_cvarDownButton)
                    {
                        if(!
g_Climbing[i][1])
                            
g_Climbing[i][1] = true// Descend rope while crouching
                    
}
                    else if(
g_Climbing[i][1])
                        
g_Climbing[i][1] = false// Tell plugin client is no longer descending rope while not crouching
                
}
            }
        }
    }
}

public 
PlayerSpawnEvent(Handle:event, const String:name[], bool:dontBroadcast)
{
    new 
client GetClientOfUserId(GetEventInt(event,"userid"));
    if(
IsFakeClient(client))
        return;
    
    
// Tell plugin that the client isn't using any of its features
    
g_Status[client][Hook] = false;
    
g_Status[client][Grab] = false;
    
g_Status[client][Rope] = false;
    
g_Grabbed[client] = false;
    
g_Backward[client] = false;
    
g_Attracting[client][0] = false;
    
g_Attracting[client][1] = false;
    
g_Climbing[client][0] = false;
    
g_Climbing[client][1] = false;
    
g_Targetindex[client][0] = -1;
    
g_Targetindex[client][1] = -1;
    
g_Targetindex[client][2] = -1;
    
g_Targetindex[client][3] = -1;
    if(
g_cvarAnnounce)
    {    
        
decl String:buffer[128];
        
Format(buffersizeof(buffer), "\x01\x0B\x04[HGR]\x01 %t\x04 ""Enabled");
        if(
HasAccess(clientHook))
            
Format(buffersizeof(buffer), "%s[+Hook] "buffer);
        if(
HasAccess(clientGrab))
            
Format(buffersizeof(buffer), "%s[+Grab] "buffer);
        if(
HasAccess(clientRope))
            
Format(buffersizeof(buffer), "%s[+Rope]"buffer);
        
PrintToChat(clientbuffer);
    }
}

public 
RoundStartEvent(Handle:event, const String:name[], bool:dontBroadcast)
{
    
// Tell plugin whether players can use hook grab rope during freezetime
    
if(g_HookedFreeze)
    {
        for(new 
HGRAction:Hook<= Ropei++)
            
g_Frozen[i] = g_cvarFreeze[i];
    }
    else
    {
        for(new 
HGRAction:Hook<= Ropek++)
            
g_Frozen[k] = true;
    }
}

public 
RoundFreezeEndEvent(Handle:event, const String:name[], bool:dontBroadcast)
{
    
// Freezetime has ended
    
for(new HGRAction:Hook<= Ropei++)
        
g_Frozen[i] = true;
}

/******************
 *Console Commands*
*******************/

public Action:HookCmd(clientargs)
{
    
g_Backward[client] = false;
    
Action_Hook(client);
    return 
Plugin_Handled;
}

public 
Action:UnHookCmd(clientargs)
{
    if(
IsPlayerAlive(client))
        
Action_UnHook(client);
    return 
Plugin_Handled;
}

public 
Action:HookToggle(clientargs)
{
    if(
g_Status[client][Hook])
        
g_Status[client][Hook] = false;
    else
    {
        
g_Backward[client] = false;
        
Action_Hook(client);
    }
    return 
Plugin_Handled;
}
    
public 
Action:GrabCmd(clientargs)
{
    
Action_Grab(client);
    return 
Plugin_Handled;
}

public 
Action:DropCmd(clientargs)
{
    if(
IsPlayerAlive(client))
        
Action_Drop(client);
    return 
Plugin_Handled;
}

public 
Action:GrabToggle(clientargs)
{
    if(
g_Status[client][Grab])
        
g_Status[client][Grab] = false;
    else
        
Action_Grab(client);
    return 
Plugin_Handled;
}

public 
Action:RopeCmd(clientargs)
{
    
Action_Rope(client); 
    return 
Plugin_Handled;
}

public 
Action:DetachCmd(clientargs)
{
    if(
IsPlayerAlive(client))
        
Action_Detach(client);
    return 
Plugin_Handled;
}

public 
Action:RopeToggle(clientargs)
{
    if(
g_Status[client][Rope])
        
g_Status[client][Rope] = false;
    else
        
Action_Rope(client);
    return 
Plugin_Handled;
}

public 
Action:PushCmd(clientargs)
{
    
g_Backward[client] = true;
    
Action_Hook(client);
    return 
Plugin_Handled;
}

public 
Action:UnPushCmd(clientargs)
{
    if(
IsPlayerAlive(client))
    {
        
g_Backward[client] = false;
        
Action_UnHook(client);
    }
    return 
Plugin_Handled;
}

public 
Action:PushToggle(clientargs)
{
    if(
g_Status[client][Hook])
    {
        
g_Backward[client] = false;
        
g_Status[client][Hook] = false;
    }
    else
    {
        
g_Backward[client] = true;
        
Action_Hook(client);
    }
    return 
Plugin_Handled;
}

/****************
 *Admin Commands*
*****************/

public Action:GiveHook(clientargs)
{
    if(
args 0)
    {
        
decl String:target[64];
        
GetCmdArg(1targetsizeof(target));
        if(
Access(targetGiveHook) == 0)
        {
            new 
targetindex FindTarget(clienttarget);
            if(
targetindex 0)
            {
                
ClientAccess(targetindexGiveHook);
                
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %N"client"Admin Give""hook"targetindex);
            }
        }
        else
            
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %s"client"Admin Give""hook"target);
    }
    else
        
ReplyToCommand(client,"\x01\x0B\x04[HGR] Usage:\x01 sm_hgr_givehook <@all/@t/@ct/partial name>");
    return 
Plugin_Handled;
}

public 
Action:TakeHook(clientargs)
{
    if(
args 0)
    {
        
decl String:target[64];
        
GetCmdArg(1targetsizeof(target));
        if(
Access(targetTakeHook) == 0)
        {
            new 
targetindex FindTarget(clienttarget);
            if(
targetindex 0)
            {
                
ClientAccess(targetindexTakeHook);
                
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %N"client"Admin Take""hook"targetindex);
            }
        }
        else
            
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %s"client"Admin Take""hook"target);
    }
    else
        
ReplyToCommand(client,"\x01\x0B\x04[HGR] Usage:\x01 sm_hgr_givehook <@all/@t/@ct/partial name>");
    return 
Plugin_Handled;
}

public 
Action:GiveGrab(clientargs)
{
    if(
args 0)
    {
        
decl String:target[64];
        
GetCmdArg(1targetsizeof(target));
        if(
Access(targetGiveGrab) == 0)
        {
            new 
targetindex FindTarget(clienttarget);
            if(
targetindex 0)
            {
                
ClientAccess(targetindexGiveGrab);
                
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %N"client"Admin Give""grab"targetindex);
            }
        }
        else
            
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %s"client"Admin Give""grab"target);
    }
    else
        
ReplyToCommand(client,"\x01\x0B\x04[HGR] Usage:\x01 sm_hgr_givehook <@all/@t/@ct/partial name>");
    return 
Plugin_Handled;
}

public 
Action:TakeGrab(clientargs)
{
    if(
args 0)
    {
        
decl String:target[64];
        
GetCmdArg(1targetsizeof(target));
        if(
Access(targetTakeGrab) == 0)
        {
            new 
targetindex FindTarget(clienttarget);
            if(
targetindex 0)
            {
                
ClientAccess(targetindexTakeGrab);
                
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %N"client"Admin Take""grab"targetindex);
            }
        }
        else
            
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %s"client"Admin Take""grab"target);
    }
    else
        
ReplyToCommand(client,"\x01\x0B\x04[HGR] Usage:\x01 sm_hgr_givehook <@all/@t/@ct/partial name>");
    return 
Plugin_Handled;
}

public 
Action:GiveRope(clientargs)
{
    if(
args 0)
    {
        
decl String:target[64];
        
GetCmdArg(1targetsizeof(target));
        if(
Access(targetGiveRope) == 0)
        {
            new 
targetindex FindTarget(clienttarget);
            if(
targetindex 0)
            {
                
ClientAccess(targetindexGiveRope);
                
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %N"client"Admin Give""rope"targetindex);
            }
        }
        else
            
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %s"client"Admin Give""rope"target);
    }
    else
        
ReplyToCommand(client,"\x01\x0B\x04[HGR] Usage:\x01 sm_hgr_givehook <@all/@t/@ct/partial name>");
    return 
Plugin_Handled;
}

public 
Action:TakeRope(clientargs)
{
    if(
args 0)
    {
        
decl String:target[64];
        
GetCmdArg(1targetsizeof(target));
        if(
Access(targetTakeRope) == 0)
        {
            new 
targetindex FindTarget(clienttarget);
            if(
targetindex 0)
            {
                
ClientAccess(targetindexTakeRope);
                
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %N"client"Admin Take""rope"targetindex);
            }
        }
        else
            
ShowActivity2(client"\x01\x0B\x04[HGR]\x01 ""%N %t %s"client"Admin Take""rope"target);
    }
    else
        
ReplyToCommand(client,"\x01\x0B\x04[HGR] Usage:\x01 sm_hgr_givehook <@all/@t/@ct/partial name>");
    return 
Plugin_Handled;
}

/********
 *Access*
*********/

public Access(const String:target[], HGRAccess:accessHGRAction:action)
{
    new 
clients[MAXPLAYERS];
    new 
count FindMatchingPlayers(targetclients);
    if(
count == 0)
        return 
0;
    for(new 
0countx++)
        
ClientAccess(clients[x], accessaction);
    return 
count;
}

public 
ClientAccess(clientHGRAccess:accessHGRAction:action)
{
    if(
IsFakeClient(client))
        return 
0;
    
decl String:actionName[64];
    if(
action == Hook)
        
actionName "Hook";
    else if(
action == Grab)
        
actionName "Grab";
    else if(
action == Rope)
        
actionName "Rope";
    if(
access == Give)
    {
        
g_AllowedClients[client][action] = true;
        if(
IsClientInGame(client))
            
PrintToChat(client"\x01\x0B\x04[HGR]\x01 %t""Given Access"actionName);
    }
    else
    {
        
g_AllowedClients[client][action] = false;
        if(
IsClientInGame(client))
            
PrintToChat(client"\x01\x0B\x04[HGR]\x01 %t""Taken Access"actionName);
    }
    return 
1;
}

public 
bool:HasAccess(clientHGRAction:action)
{
    
// Hook, Grab, or Rope is disabled
    
if(!g_cvarEnable[action])
        return 
false;
    
// If Override Mode is active, client only has access if it has been given to him
    
if(g_cvarOverrideMode)
        return 
g_AllowedClients[client][action];
    
// Check for admin flags if selected HGR action is admin only
    
if(g_cvarAdminOnly[action])
    {
        
decl String:actionName[24];
        if(
action == Hook)
            
actionName "+hook";
        else if(
action == Grab)
            
actionName "+grab";
        else if(
action == Rope)
            
actionName "+rope";
        if(
CheckCommandAccess(clientactionNameADMFLAG_GENERICtrue))
            return 
true;
        
// If user does not have proper admin access, check if admin
        // has specially allowed the client to use HGR anyway
        
else
            return 
g_AllowedClients[client][action];
    }
    return 
true;
}

/*********
 *Convars*
**********/

public ConvarChanged(Handle:cvar, const String:oldVal[], const String:newVal[])
{
    
// General convars
    
if(cvar == h_cvarAnnounce)
        
g_cvarAnnounce        GetConVarBool(h_cvarAnnounce);
    else if(
cvar == h_cvarSoundAmplify)
        
g_cvarSoundAmplify    GetConVarInt(h_cvarSoundAmplify);
    else if(
cvar == h_cvarOverrideMode)
        
g_cvarOverrideMode    GetConVarBool(h_cvarOverrideMode);
    else if(
cvar == h_cvarRopeOldMode)
        
g_cvarRopeOldMode     GetConVarBool(h_cvarRopeOldMode);
    else if(
cvar == h_cvarUpButton)
        
g_cvarUpButton        GetButtonBitString(newVal<< 1);
    else if(
cvar == h_cvarDownButton)
        
g_cvarDownButton      GetButtonBitString(newVal<< 2);

    
// Hook convars
    
else if(cvar == h_cvarHookEnable)
        
g_cvarEnable[Hook]    = GetConVarBool(h_cvarHookEnable);
    else if(
cvar == h_cvarHookAdminOnly)
        
g_cvarAdminOnly[Hook] = GetConVarBool(h_cvarHookAdminOnly);
    else if(
cvar == h_cvarHookFreeze)
        
g_cvarFreeze[Hook]    = GetConVarBool(h_cvarHookFreeze);
    else if(
cvar == h_cvarHookSlide)
        
g_cvarSlide[Hook]     = GetConVarBool(h_cvarHookSlide);
    else if(
cvar == h_cvarHookSpeed)
        
g_cvarSpeed[0]        = GetConVarFloat(h_cvarHookSpeed);
    else if(
cvar == h_cvarHookInitWidth)
        
g_cvarInitWidth[0]    = GetConVarFloat(h_cvarHookInitWidth);
    else if(
cvar == h_cvarHookEndWidth)
        
g_cvarEndWidth[0]     = GetConVarFloat(h_cvarHookEndWidth);
    else if(
cvar == h_cvarHookAmplitude)
        
g_cvarAmplitude[0]    = GetConVarFloat(h_cvarHookAmplitude);
    else if(
cvar == h_cvarHookBeamColor)
        
g_cvarBeamColor[Hook] = GetConVarInt(h_cvarHookBeamColor);
    else if(
cvar == h_cvarHookRed)
        
g_cvarBeamRed[Hook]   = GetConVarInt(h_cvarHookRed);
    else if(
cvar == h_cvarHookGreen)
        
g_cvarBeamGreen[Hook] = GetConVarInt(h_cvarHookGreen);
    else if(
cvar == h_cvarHookBlue)
        
g_cvarBeamBlue[Hook]  = GetConVarInt(h_cvarHookBlue);
    else if(
cvar == h_cvarHookAlpha)
        
g_cvarBeamAlpha[Hook] = GetConVarInt(h_cvarHookAlpha);
    else if(
cvar == h_cvarHookSound)
        
GetConVarString(h_cvarHookSoundg_cvarSound[Hook], sizeof(g_cvarSound[]));

    
// Grab convars
    
else if(cvar == h_cvarGrabEnable)
        
g_cvarEnable[Grab]    = GetConVarBool(h_cvarGrabEnable);
    else if(
cvar == h_cvarGrabAdminOnly)
        
g_cvarAdminOnly[Grab] = GetConVarBool(h_cvarGrabAdminOnly);
    else if(
cvar == h_cvarGrabFreeze)
        
g_cvarFreeze[Grab]    = GetConVarBool(h_cvarGrabFreeze);
    else if(
cvar == h_cvarGrabSlide)
        
g_cvarSlide[Grab]     = GetConVarBool(h_cvarGrabSlide);
    else if(
cvar == h_cvarGrabSpeed)
        
g_cvarSpeed[1]        = GetConVarFloat(h_cvarGrabSpeed);
    else if(
cvar == h_cvarGrabInitWidth)
        
g_cvarInitWidth[1]    = GetConVarFloat(h_cvarGrabInitWidth);
    else if(
cvar == h_cvarGrabEndWidth)
        
g_cvarEndWidth[1]     = GetConVarFloat(h_cvarGrabEndWidth);
    else if(
cvar == h_cvarGrabAmplitude)
        
g_cvarAmplitude[1]    = GetConVarFloat(h_cvarGrabAmplitude);
    else if(
cvar == h_cvarGrabBeamColor)
        
g_cvarBeamColor[Grab] = GetConVarInt(h_cvarGrabBeamColor);
    else if(
cvar == h_cvarGrabRed)
        
g_cvarBeamRed[Grab]   = GetConVarInt(h_cvarGrabRed);
    else if(
cvar == h_cvarGrabGreen)
        
g_cvarBeamGreen[Grab] = GetConVarInt(h_cvarGrabGreen);
    else if(
cvar == h_cvarGrabBlue)
        
g_cvarBeamBlue[Grab]  = GetConVarInt(h_cvarGrabBlue);
    else if(
cvar == h_cvarGrabAlpha)
        
g_cvarBeamAlpha[Grab] = GetConVarInt(h_cvarGrabAlpha);
    else if(
cvar == h_cvarGrabSound)
        
GetConVarString(h_cvarGrabSoundg_cvarSound[Grab], sizeof(g_cvarSound[]));

    
// Rope convars
    
else if(cvar == h_cvarRopeEnable)
        
g_cvarEnable[Rope]    = GetConVarBool(h_cvarRopeEnable);
    else if(
cvar == h_cvarRopeAdminOnly)
        
g_cvarAdminOnly[Rope] = GetConVarBool(h_cvarRopeAdminOnly);
    else if(
cvar == h_cvarRopeFreeze)
        
g_cvarFreeze[Rope]    = GetConVarBool(h_cvarRopeFreeze);
    else if(
cvar == h_cvarRopeSlide)
        
g_cvarSlide[Rope]     = GetConVarBool(h_cvarRopeSlide);
    else if(
cvar == h_cvarRopeSpeed)
        
g_cvarSpeed[2]        = GetConVarFloat(h_cvarRopeSpeed);
    else if(
cvar == h_cvarRopeInitWidth)
        
g_cvarInitWidth[2]    = GetConVarFloat(h_cvarRopeInitWidth);
    else if(
cvar == h_cvarRopeEndWidth)
        
g_cvarEndWidth[2]     = GetConVarFloat(h_cvarRopeEndWidth);
    else if(
cvar == h_cvarRopeAmplitude)
        
g_cvarAmplitude[2]    = GetConVarFloat(h_cvarRopeAmplitude);
    else if(
cvar == h_cvarRopeBeamColor)
        
g_cvarBeamColor[Rope] = GetConVarInt(h_cvarRopeBeamColor);
    else if(
cvar == h_cvarRopeRed)
        
g_cvarBeamRed[Rope]   = GetConVarInt(h_cvarRopeRed);
    else if(
cvar == h_cvarRopeGreen)
        
g_cvarBeamGreen[Rope] = GetConVarInt(h_cvarRopeGreen);
    else if(
cvar == h_cvarRopeBlue)
        
g_cvarBeamBlue[Rope]  = GetConVarInt(h_cvarRopeBlue);
    else if(
cvar == h_cvarRopeAlpha)
        
g_cvarBeamAlpha[Rope] = GetConVarInt(h_cvarRopeAlpha);
    else if(
cvar == h_cvarRopeSound)
        
GetConVarString(h_cvarRopeSoundg_cvarSound[Rope], sizeof(g_cvarSound[]));
}

public 
UpdateAllConvars()
{
    
// General convars
    
g_cvarAnnounce        GetConVarBool(h_cvarAnnounce);
    
g_cvarSoundAmplify    GetConVarInt(h_cvarSoundAmplify);
    
g_cvarOverrideMode    GetConVarBool(h_cvarOverrideMode);
    
g_cvarRopeOldMode     GetConVarBool(h_cvarRopeOldMode);
    
decl String:UpButton[24];
    
GetConVarString(h_cvarUpButtonUpButtonsizeof(UpButton));
    
g_cvarUpButton GetButtonBitString(UpButton<< 1);
    
decl String:DownButton[24];
    
GetConVarString(h_cvarDownButtonDownButtonsizeof(DownButton));
    
g_cvarDownButton GetButtonBitString(DownButton<< 2);

    
// Hook convars
    
g_cvarEnable[Hook]    = GetConVarBool(h_cvarHookEnable);
    
g_cvarAdminOnly[Hook] = GetConVarBool(h_cvarHookAdminOnly);
    
g_cvarFreeze[Hook]    = GetConVarBool(h_cvarHookFreeze);
    
g_cvarSlide[Hook]     = GetConVarBool(h_cvarHookSlide);
    
g_cvarSpeed[0]        = GetConVarFloat(h_cvarHookSpeed);
    
g_cvarInitWidth[0]    = GetConVarFloat(h_cvarHookInitWidth);
    
g_cvarEndWidth[0]     = GetConVarFloat(h_cvarHookEndWidth);
    
g_cvarAmplitude[0]    = GetConVarFloat(h_cvarHookAmplitude);
    
g_cvarBeamColor[Hook] = GetConVarInt(h_cvarHookBeamColor);
    
g_cvarBeamRed[Hook]   = GetConVarInt(h_cvarHookRed);
    
g_cvarBeamGreen[Hook] = GetConVarInt(h_cvarHookGreen);
    
g_cvarBeamBlue[Hook]  = GetConVarInt(h_cvarHookBlue);
    
g_cvarBeamAlpha[Hook] = GetConVarInt(h_cvarHookAlpha);
    
GetConVarString(h_cvarHookSoundg_cvarSound[Hook], sizeof(g_cvarSound[]));

    
// Grab convars
    
g_cvarEnable[Grab]    = GetConVarBool(h_cvarGrabEnable);
    
g_cvarAdminOnly[Grab] = GetConVarBool(h_cvarGrabAdminOnly);
    
g_cvarFreeze[Grab]    = GetConVarBool(h_cvarGrabFreeze);
    
g_cvarSlide[Grab]     = GetConVarBool(h_cvarGrabSlide);
    
g_cvarSpeed[1]        = GetConVarFloat(h_cvarGrabSpeed);
    
g_cvarInitWidth[1]    = GetConVarFloat(h_cvarGrabInitWidth);
    
g_cvarEndWidth[1]     = GetConVarFloat(h_cvarGrabEndWidth);
    
g_cvarAmplitude[1]    = GetConVarFloat(h_cvarGrabAmplitude);
    
g_cvarBeamColor[Grab] = GetConVarInt(h_cvarGrabBeamColor);
    
g_cvarBeamRed[Grab]   = GetConVarInt(h_cvarGrabRed);
    
g_cvarBeamGreen[Grab] = GetConVarInt(h_cvarGrabGreen);
    
g_cvarBeamBlue[Grab]  = GetConVarInt(h_cvarGrabBlue);
    
g_cvarBeamAlpha[Grab] = GetConVarInt(h_cvarGrabAlpha);
    
GetConVarString(h_cvarGrabSoundg_cvarSound[Grab], sizeof(g_cvarSound[]));

    
// Rope convars
    
g_cvarEnable[Rope]    = GetConVarBool(h_cvarRopeEnable);
    
g_cvarAdminOnly[Rope] = GetConVarBool(h_cvarRopeAdminOnly);
    
g_cvarFreeze[Rope]    = GetConVarBool(h_cvarRopeFreeze);
    
g_cvarSlide[Rope]     = GetConVarBool(h_cvarRopeSlide);
    
g_cvarSpeed[2]        = GetConVarFloat(h_cvarRopeSpeed);
    
g_cvarInitWidth[2]    = GetConVarFloat(h_cvarRopeInitWidth);
    
g_cvarEndWidth[2]     = GetConVarFloat(h_cvarRopeEndWidth);
    
g_cvarAmplitude[2]    = GetConVarFloat(h_cvarRopeAmplitude);
    
g_cvarBeamColor[Rope] = GetConVarInt(h_cvarRopeBeamColor);
    
g_cvarBeamRed[Rope]   = GetConVarInt(h_cvarRopeRed);
    
g_cvarBeamGreen[Rope] = GetConVarInt(h_cvarRopeGreen);
    
g_cvarBeamBlue[Rope]  = GetConVarInt(h_cvarRopeBlue);
    
g_cvarBeamAlpha[Rope] = GetConVarInt(h_cvarRopeAlpha);
    
GetConVarString(h_cvarRopeSoundg_cvarSound[Rope], sizeof(g_cvarSound[]));
    
    
// Freezetime variables
    
for(new HGRAction:Hook<= Ropei++)
    {
        if(!
g_HookedRoundStart || !g_HookedFreeze)
            
g_Frozen[i] = true;
        else
            
g_Frozen[i] = g_cvarFreeze[i];
    }
}

public 
GetBeamColor(clientHGRAction:actioncolor[4])
{
    
// Custom beam color
    
if(g_cvarBeamColor[action] == 2)
    {
        
color[0] = g_cvarBeamRed[action];
        
color[1] = g_cvarBeamGreen[action];
        
color[2] = g_cvarBeamBlue[action];
        
color[3] = g_cvarBeamAlpha[action];
    }
    
// Teamcolor beam color
    
else if(g_cvarBeamColor[action] == 1)
    {
        if(
GetClientTeam(client) == 2)
        {
            
color[0]=255;color[1]=0;color[2]=0;color[3]=255;
        }
        else if(
GetClientTeam(client) == 3)
        {
            
color[0]=0;color[1]=0;color[2]=255;color[3]=255;
        }
    }
    
// Reverse teamcolor beam color
    
else if(g_cvarBeamColor[action] == 3)
    {
        if(
GetClientTeam(client) == 3)
        {
            
color[0]=255;color[1]=0;color[2]=0;color[3]=255;
        }
        else if(
GetClientTeam(client) == 2)
        {
            
color[0]=0;color[1]=0;color[2]=255;color[3]=255;
        }
    }
    
// White beam color
    
else
    {
        
color[0]=255;color[1]=255;color[2]=255;color[3]=255;
    }
}

/******
 *Hook*
*******/

public Action_Hook(client)
{
    if(
g_cvarEnable[Hook] && g_Frozen[Hook])
    {
        if( 
client &&
            
client <= MaxClients &&
            
IsPlayerAlive(client) &&
            !
g_Status[client][Hook] &&
            !
g_Status[client][Rope] &&
            !
g_Grabbed[client])
        {
            if(
HasAccess(clientHook))
            {
                
// Init variables
                
new Float:clientloc[3], Float:clientang[3];
                
GetClientEyePosition(clientclientloc);
                
GetClientEyeAngles(clientclientang);
                
                
// Hook traceray
                
TR_TraceRayFilter(clientlocclientangMASK_SOLIDRayType_InfiniteTraceRayTryToHit); // Create a ray that tells where the player is looking
                
TR_GetEndPosition(g_Location[client][0]); // Get the end xyz coordinate of where a player is looking
                
g_Targetindex[client][Hook] = TR_GetEntityIndex(); // Set hook end target
                
g_Distance[client][0] = GetVectorDistance(clientlocg_Location[client][0]); // Get hook distance
                
                // Push traceray
                
decl Float:temp[3];
                
GetAngleVectors(clientangtempNULL_VECTORNULL_VECTOR);
                
NegateVector(temp);
                
GetVectorAngles(tempclientang);
                
TR_TraceRayFilter(clientlocclientangMASK_SOLIDRayType_InfiniteTraceRayTryToHit); // Create a ray in opposite direction where player is looking
                
TR_GetEndPosition(g_Location[client][3]); // Get the end xyz coordinate opposite of where a player is looking
                
g_Targetindex[client][3] = TR_GetEntityIndex(); // Set push end target
                
g_Distance[client][3] = GetVectorDistance(clientlocg_Location[client][3]); // Get push distance
                
                // Change client status
                
g_Gravity[client] = GetEntityGravity(client);
                
g_Status[client][Hook] = true// Tell plugin the player has landed hook
                
                // Call hook forward
                
new ret;
                
Call_StartForward(FwdClientHook);
                
Call_PushCell(client);
                
Call_Finish(ret);
                if(
ret)
                {
                    
Action_UnHook(client);
                    return;
                }
                
                
// Finish hooking
                
SetEntityGravity(client0.0); // Set gravity to 0 so client floats in a straight line
                
EmitSoundFromOrigin(g_cvarSound[Hook], g_Location[client][0]); // Emit sound from where the hook landed
                
Hook_Push(client);
                
CreateTimer(0.1HookingclientTIMER_REPEAT); // Create hooking loop
            
}
            else
                
PrintToChat(client,"\x01\x0B\x04[HGR]\x01 %t\x04 hook""No Permission");
        }
        else if(
client && client <= MaxClients && IsPlayerAlive(client))
            
PrintToChat(client,"\x01\x0B\x04[HGR]\x01 %t""Error");
    }
    else
        
PrintToChat(client,"\x01\x0B\x04[HGR] Hook\x01 %t""Disabled");
}

public 
Hook_Push(client)
{
    
// Init variables
    
new Float:clientloc[3], Float:velocity[3];
    
GetClientEyePosition(clientclientloc); // Get the xyz coordinate of the player
    
    // Calculate velocity vector
    
if(!g_Backward[client])
        
SubtractVectors(g_Location[client][0], clientlocvelocity);
    else
        
SubtractVectors(g_Location[client][3], clientlocvelocity);
    
NormalizeVector(velocityvelocity);
    
ScaleVector(velocityg_cvarSpeed[0] * 140.0);
    
    
// Create beam effect
    
new color[4];
    
clientloc[2] -= 18.0;
    
GetBeamColor(clientHookcolor);
    
BeamEffect(clientlocg_Location[client][0], 0.2g_cvarInitWidth[0], g_cvarEndWidth[0], colorg_cvarAmplitude[0], 0);
        
    
// Move player
    
TeleportEntity(clientNULL_VECTORNULL_VECTORvelocity); // Push the client
    
    // If client has reached the end of the hook
    
g_Distance[client][0] = GetVectorDistance(clientlocg_Location[client][0]);
    if(
g_Distance[client][0] < 40.0 && !g_Backward[client])
    {
        
SetEntityMoveType(clientMOVETYPE_NONE); // Freeze client
        
SetEntityGravity(clientg_Gravity[client]); // Set gravity to normal
    
}
    
    
// If client has reached the end of the push
    
new Float:pdistance GetVectorDistance(clientlocg_Location[client][3]);
    if(
pdistance 40.0 && g_Backward[client])
    {
        
SetEntityMoveType(clientMOVETYPE_NONE); // Freeze client
        
SetEntityGravity(clientg_Gravity[client]); // Set gravity to normal
    
}
}

public 
Action:Hooking(Handle:timerany:client)
{
    if( 
IsClientInGame(client) &&
        
IsPlayerAlive(client) &&
        
g_Status[client][Hook] &&
        !
g_Grabbed[client])
    {
        
Hook_Push(client);
        return 
Plugin_Continue;
    }
    else
    {
        
Action_UnHook(client);
        return 
Plugin_Stop// Stop the timer
    
}
}

public 
Action_UnHook(client)
{
    if( 
IsClientInGame(client) &&
        
IsPlayerAlive(client) &&
        
g_Status[client][Hook] )
    {
        
g_Status[client][Hook] = false// Tell plugin the client is not hooking
        
g_Targetindex[client][Hook] = -1// Tell plugin that the hook is not attached to an entity
        
SetEntityGravity(clientg_Gravity[client]); // Set gravity to normal
        
SetEntityMoveType(clientMOVETYPE_WALK); // Unfreeze client
    
}
}

/******
 *Grab*
*******/

public Action_Grab(client)
{
    if(
g_cvarEnable[Grab] && g_Frozen[Grab])
    {
        if( 
client &&
            
client <= MaxClients &&
            
IsPlayerAlive(client) &&
            !
g_Status[client][Grab] &&
            !
g_Grabbed[client])
        {
            if(
HasAccess(clientGrab))
            {
                
g_Status[client][Grab] = true// Tell plugin the seeker is grabbing a player
                
                // Call grab search forward
                
new ret;
                
Call_StartForward(FwdClientGrabSearch);
                
Call_PushCell(client);
                
Call_Finish(ret);
                if(
ret)
                {
                    
g_Status[client][Grab] = false;
                    return;
                }
                
                
// Start grab search timer
                
CreateTimer(0.1GrabSearchclientTIMER_REPEAT); // Start a timer that searches for a client to grab
            
}
            else
                
PrintToChat(client,"\x01\x0B\x04[HGR]\x01 %t\x04 grab.""No Permission");
        }
        else if(
client && client <= MaxClients && IsPlayerAlive(client))
            
PrintToChat(client"\x01\x0B\x04[HGR]\x01 %t""Error");
    }
    else
        
PrintToChat(client"\x01\x0B\x04[HGR] Grab\x01 %t""Disabled");
}

public 
Action:GrabSearch(Handle:timerany:client)
{
    
PrintCenterText(client"%t""Searching"); // Tell client the plugin is searching for a target
    
if( client &&
        
IsClientInGame(client) &&
        
IsPlayerAlive(client) &&
        
g_Status[client][Grab] &&
        !
g_Grabbed[client])
    {
        
// Init variables
        
new Float:clientloc[3], Float:clientang[3];
        
GetClientEyePosition(clientclientloc);
        
GetClientEyeAngles(clientclientang);
        
        
// Grab search traceray
        
TR_TraceRayFilter(clientlocclientangMASK_ALLRayType_InfiniteTraceRayGrabEnt); // Create a ray that tells where the player is looking
        
g_Targetindex[client][Grab] = TR_GetEntityIndex(); // Set the seekers targetindex to the person he picked up
        
        // Found a player or object
        
if(g_Targetindex[client][Grab] > && IsValidEntity(g_Targetindex[client][Grab]))
        {
            
// Init variables
            
new Float:targetloc[3];
            
GetEntityOrigin(g_Targetindex[client][Grab], targetloc); // Find the target's xyz coordinate
            
g_Distance[client][1] = GetVectorDistance(targetlocclientloc); // Tell plugin the distance between the two to maintain
            
if( g_Targetindex[client][Grab] > &&
                
g_Targetindex[client][Grab] <= MaxClients &&
                
IsClientInGame(g_Targetindex[client][Grab]))
            {
                
g_MaxSpeed[client] = GetEntPropFloat(clientProp_Send"m_flMaxspeed");
                
g_Grabbed[g_Targetindex[client][Grab]] = true// If target is a player, tell plugin player is being grabbed
                
SetEntPropFloat(g_Targetindex[client][Grab], Prop_Send"m_flMaxspeed"0.01); // Slow grab target
            
}
            
            
// Call grab forward
            
new ret;
            
Call_StartForward(FwdClientGrab);
            
Call_PushCell(client);
            
Call_Finish(ret);
            if(
ret)
            {
                
Action_Drop(client);
                return 
Plugin_Stop;
            }
            
            
// Finish grabbing
            
EmitSoundFromOrigin(g_cvarSound[Grab], targetloc); // Emit sound from the entity being grabbed
            
CreateTimer(0.05GrabbingclientTIMER_REPEAT); // Start a repeating timer that will reposition the target in the grabber's crosshairs
            
return Plugin_Stop// Stop the search timer
        
}
    }
    else
    {
        
Action_Drop(client);
        return 
Plugin_Stop// Stop the timer
    
}
    return 
Plugin_Continue;
}

public 
Action:Grabbing(Handle:timerany:client)
{
    
PrintCenterText(client"%t""Found");
    if( 
IsClientInGame(client) &&
        
IsPlayerAlive(client) &&
        
g_Status[client][Grab] &&
        !
g_Grabbed[client] &&
        
IsValidEntity(g_Targetindex[client][Grab]))
    {
        if( 
g_Targetindex[client][Grab] > MaxClients ||
            
g_Targetindex[client][Grab] > &&
            
g_Targetindex[client][Grab] <= MaxClients &&
            
IsClientInGame(g_Targetindex[client][Grab]) &&
            
IsPlayerAlive(g_Targetindex[client][Grab]))
        {
            
// Init variables
            
new Float:clientloc[3], Float:clientang[3], Float:targetloc[3], Float:velocity[3];
            
GetClientEyePosition(clientclientloc);
            
GetClientEyeAngles(clientclientang);
            
GetEntityOrigin(g_Targetindex[client][Grab], targetloc);

            
// Grab traceray
            
g_TRIgnore[client] = true;
            
TR_TraceRayFilter(clientlocclientangMASK_ALLRayType_InfiniteTraceRayTryToHit); // Find where the player is aiming
            
TR_GetEndPosition(velocity); // Get the end position of the trace ray
            
g_TRIgnore[client] = false;
            
            
// Calculate velocity vector
            
SubtractVectors(velocityclientlocvelocity);
            
NormalizeVector(velocityvelocity);
            if(
g_Attracting[client][0])
                
g_Distance[client][1] += g_cvarSpeed[1] * 10.0;
            else if(
g_Attracting[client][1])
            {
                
g_Distance[client][1] -= g_cvarSpeed[1] * 10.0;
                if(
g_Distance[client][1] <= 30.0)
                    
g_Distance[client][1] = 30.0;
            }
            
ScaleVector(velocityg_Distance[client][1]);
            
AddVectors(velocityclientlocvelocity);
            
SubtractVectors(velocitytargetlocvelocity);
            
ScaleVector(velocityg_cvarSpeed[1] * 5);
            
            
// Move grab target
            
TeleportEntity(g_Targetindex[client][Grab], NULL_VECTORNULL_VECTORvelocity);
            
            
// Make a beam from grabber to grabbed
            
new color[4];
            if(
g_Targetindex[client][Grab] <= MaxClients)
                
targetloc[2] += 45;
            
clientloc[2] -= 5;
            
GetBeamColor(clientGrabcolor);
            
BeamEffect(clientloctargetloc0.2g_cvarInitWidth[1], g_cvarEndWidth[1], colorg_cvarAmplitude[1], 0);
        }
        else
        {
            
Action_Drop(client);
            return 
Plugin_Stop// Stop the timer
        
}
    }
    else
    {
        
Action_Drop(client);
        return 
Plugin_Stop// Stop the timer
    
}
    return 
Plugin_Continue;
}

public 
Action_Drop(client)
{
    if( 
IsClientInGame(client) &&
        
IsPlayerAlive(client) &&
        
g_Status[client][Grab] )
    {
        
g_Status[client][Grab] = false// Tell plugin the grabber has dropped his target
        
if(g_Targetindex[client][Grab] > 0)
        {
            
PrintCenterText(client"%t""Dropped");
            if( 
g_Targetindex[client][Grab] > &&
                
g_Targetindex[client][Grab] <= MaxClients &&
                
IsClientInGame(g_Targetindex[client][Grab]))
            {
                
g_Grabbed[g_Targetindex[client][Grab]] = false// Tell plugin the target is no longer being grabbed
                
SetEntPropFloat(g_Targetindex[client][Grab], Prop_Send"m_flMaxspeed"g_MaxSpeed[client]); // Set speed back to normal
            
}
            
g_Targetindex[client][Grab] = -1;
        }
        else
            
PrintCenterText(client"%t""Not Found");
    }
}

/******
 *Rope*
*******/

public Action_Rope(client)
{
    if(
g_cvarEnable[Rope] && g_Frozen[Rope])
    {
        if( 
client &&
            
client <= MaxClients &&
            
IsPlayerAlive(client) &&
            !
g_Status[client][Rope] &&
            !
g_Status[client][Hook] &&
            !
g_Grabbed[client])
        {
        if(
HasAccess(client,Rope))
        {
            
// Init variables
            
new Float:clientloc[3], Float:clientang[3];
            
GetClientEyePosition(clientclientloc); // Get the position of the player's eyes
            
GetClientEyeAngles(clientclientang); // Get the angle the player is looking
            
            // Rope traceray
            
TR_TraceRayFilter(clientlocclientangMASK_ALLRayType_InfiniteTraceRayTryToHit); // Create a ray that tells where the player is looking
            
TR_GetEndPosition(g_Location[client][2]); // Get the end xyz coordinate of where a player is looking
            
g_Targetindex[client][Rope] = TR_GetEntityIndex();
            
            
// Change client status
            
g_Status[client][Rope] = true// Tell plugin the player is roping
            
g_Distance[client][2] = GetVectorDistance(clientlocg_Location[client][2]);
            
            
// Call rope forward
            
new ret;
            
Call_StartForward(FwdClientRope);
            
Call_PushCell(client);
            
Call_Finish(ret);
            if(
ret)
            {
                
Action_Detach(client);
                return;
            }
            
            
// Finish roping
            
EmitSoundFromOrigin(g_cvarSound[Rope], g_Location[client][2]); // Emit sound from the end of the rope
            
CreateTimer(0.1RopingclientTIMER_REPEAT); // Create roping loop
        
}
        else
            
PrintToChat(client,"\x01\x0B\x04[HGR]\x01 %t\x04 rope.""No Permission");
        }
        else if(
client && client <= MaxClients && IsPlayerAlive(client))
            
PrintToChat(client,"\x01\x0B\x04[HGR]\x01 %t""Error");
    }
    else
        
PrintToChat(client,"\x01\x0B\x04[HGR] Rope\x01 %t""Disabled");
}

public 
Action:Roping(Handle:timer,any:client)
{
    if( 
IsClientInGame(client) &&
        
g_Status[client][Rope] &&
        
IsPlayerAlive(client) &&
        !
g_Grabbed[client])
    {
        
// Init variables
        
new Float:clientloc[3], Float:velocity[3], Float:direction[3], Float:ascension[3], Float:climb 3.0;
        
GetClientEyePosition(clientclientloc);
        
SubtractVectors(g_Location[client][2], clientlocdirection);
        if(
g_Climbing[client][0])
        {
                
climb *= g_cvarSpeed[2];
                
g_Distance[client][2] -= climb;
                if(
g_Distance[client][2] <= 10.0)
                    
g_Distance[client][2] = 10.0;
            }
            else if(
g_Climbing[client][1])
            {
                
climb *= -g_cvarSpeed[2];
                
g_Distance[client][2] -= climb;
            }
            else
                
climb 0.0;
        
        
// Don't move player if rope is slack
        
if(g_cvarRopeOldMode || GetVectorLength(direction) - >= g_Distance[client][2])
        {
            
// Calculate velocity vector
            
GetVelocity(clientvelocity);
            
NormalizeVector(directiondirection);
            
ascension[0] = direction[0] * climb;
            
ascension[1] = direction[1] * climb;
            
ascension[2] = direction[2] * climb;
            
ScaleVector(directiong_cvarSpeed[2] * 60.0);
            
velocity[0] += direction[0] + ascension[0];
            
velocity[1] += direction[1] + ascension[1];
            if(
ascension[2] > 0.0)
                
velocity[2] += direction[2] + ascension[2]; // Move client up if they are climbing the rope
            
if(g_Location[client][2][2] - clientloc[2] >= g_Distance[client][2] && velocity[2] < 0.0)
                
velocity[2] *= -1// Reverse vertical component of velocity if rope is taut
            
TeleportEntity(clientNULL_VECTORNULL_VECTORvelocity);
        }
        
        
// Create beam effect
        
new color[4];
        
clientloc[2] -= 10;
        
GetBeamColor(clientRopecolor);
        
BeamEffect(clientlocg_Location[client][2], 0.2g_cvarInitWidth[2], g_cvarEndWidth[2], colorg_cvarAmplitude[2], 0);
    }
    else
    {
        
Action_Detach(client);
        return 
Plugin_Stop// Stop the timer
    
}
    return 
Plugin_Continue;
}

public 
Action_Detach(client)
{
    if( 
IsClientInGame(client) &&
        
IsPlayerAlive(client) &&
        
g_Status[client][Rope] )
    {
        
g_Status[client][Rope] = false// Tell plugin the client is not hooking
        
g_Targetindex[client][Rope] = -1;
    }
}

/***************
 *Trace Filters*
****************/

public bool:TraceRayTryToHit(entitymask)
{
    
// Check if the beam hit a player and tell it to keep tracing if it did
    
if(entity && entity <= MaxClients)
        return 
false;
    return 
true;
}

public 
bool:TraceRayGrabEnt(entitymask)
{
    
// Check if the beam hit an entity other than the grabber, and stop if it does
    
if(entity 0)
    {
        if(
entity MaxClients
            return 
true;
        if(
entity <= MaxClients && !g_Status[entity][Grab] && !g_Grabbed[entity] && !g_TRIgnore[entity])
            return 
true;
    }
    return 
false;
}

/*********
 *Helpers*
**********/

public EmitSoundFromOrigin(const String:sound[], const Float:orig[3])
{
    
// Amplify sound
    
for(new 0g_cvarSoundAmplifyi++)
        
EmitSoundToAll(soundSOUND_FROM_WORLDSNDCHAN_AUTOSNDLEVEL_NORMALSND_NOFLAGSSNDVOL_NORMALSNDPITCH_NORMAL, -1origNULL_VECTORtrue0.0);
}

public 
GetEntityOrigin(entityFloat:output[3])
{
    
GetEntDataVector(entityOriginOffsetoutput);
}

public 
GetVelocity(clientFloat:output[3])
{
    
output[0] = GetEntDataFloat(clientGetVelocityOffset_x);
    
output[1] = GetEntDataFloat(clientGetVelocityOffset_y);
    
output[2] = GetEntDataFloat(clientGetVelocityOffset_z);
}

public 
ResetAccess(client)
{
    
g_AllowedClients[client][0] = false;
    
g_AllowedClients[client][1] = false;
    
g_AllowedClients[client][2] = false;
}

public 
FindMatchingPlayers(const String:matchstr[], clients[])
{
    new 
0;
    if(
StrEqual(matchstr"@all"false))
    {
        for(new 
1<= MaxClientsx++)
        {
            if(
IsClientInGame(x))
            {
                
clients[k] = x;
                
k++;
            }
        }
    }
    else if(
StrEqual(matchstr"@t"false))
    {
        for(new 
1<= MaxClientsx++)
        {
            if(
IsClientInGame(x) && GetClientTeam(x) == 2)
            {
                
clients[k] = x;
                
k++;
            }
        }
    }
    else if(
StrEqual(matchstr"@ct"false))
    {
        for(new 
1<= MaxClientsx++)
        {
            if(
IsClientInGame(x) && GetClientTeam(x) == 3)
            {
                
clients[k] = x;
                
k++;
            }
        }
    }
    return 
k;
}

public 
GetButtonBitString(const String:matchstr[], def)
{
    if(
StrEqual(matchstr"IN_ATTACK"))
        return 
<< 0;
    else if(
StrEqual(matchstr"IN_JUMP"))
        return 
<< 1;
    else if(
StrEqual(matchstr"IN_DUCK"))
        return 
<< 2;
    else if(
StrEqual(matchstr"IN_FORWARD"))
        return 
<< 3;
    else if(
StrEqual(matchstr"IN_BACK"))
        return 
<< 4;
    else if(
StrEqual(matchstr"IN_USE"))
        return 
<< 5;
    else if(
StrEqual(matchstr"IN_CANCEL"))
        return 
<< 6;
    else if(
StrEqual(matchstr"IN_LEFT"))
        return 
<< 7;
    else if(
StrEqual(matchstr"IN_RIGHT"))
        return 
<< 8;
    else if(
StrEqual(matchstr"IN_MOVELEFT"))
        return 
<< 9;
    else if(
StrEqual(matchstr"IN_MOVERIGHT"))
        return 
<< 10;
    else if(
StrEqual(matchstr"IN_ATTACK2"))
        return 
<< 11;
    else if(
StrEqual(matchstr"IN_RUN"))
        return 
<< 12;
    else if(
StrEqual(matchstr"IN_RELOAD"))
        return 
<< 13;
    else if(
StrEqual(matchstr"IN_ALT1"))
        return 
<< 14;
    else if(
StrEqual(matchstr"IN_ALT2"))
        return 
<< 15;
    else if(
StrEqual(matchstr"IN_SCORE"))
        return 
<< 16;
    else if(
StrEqual(matchstr"IN_SPEED"))
        return 
<< 17;
    else if(
StrEqual(matchstr"IN_WALK"))
        return 
<< 18;
    else if(
StrEqual(matchstr"IN_ZOOM"))
        return 
<< 19;
    else if(
StrEqual(matchstr"IN_WEAPON1"))
        return 
<< 20;
    else if(
StrEqual(matchstr"IN_WEAPON2"))
        return 
<< 21;
    else if(
StrEqual(matchstr"IN_BULLRUSH"))
        return 
<< 22;
    else if(
StrEqual(matchstr"IN_GRENADE1"))
        return 
<< 23;
    else if(
StrEqual(matchstr"IN_GRENADE2"))
        return 
<< 24;
    return 
def;
}

/*********
 *Effects*
**********/

public BeamEffect(Float:startvec[3], Float:endvec[3], Float:lifeFloat:widthFloat:endwidth, const color[4], Float:amplitude,speed)
{
    
TE_SetupBeamPoints(startvecendvecprecache_laser0066lifewidthendwidth0amplitudecolorspeed);
    
TE_SendToAll();



thank you just create cvar for hook command that is enough for me!


All times are GMT -4. The time now is 05:16.

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