mirror of
https://github.com/Jackzmc/sourcemod-plugins.git
synced 2025-05-05 19:53:20 +00:00
1323 lines
No EOL
32 KiB
SourcePawn
1323 lines
No EOL
32 KiB
SourcePawn
/*
|
|
* Left 4 DHooks Direct - Stock Functions
|
|
* Copyright (C) 2024 Silvers
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#if defined _l4d_silver_included
|
|
#endinput
|
|
#endif
|
|
#define _l4d_silver_included
|
|
|
|
#pragma newdecls required
|
|
|
|
#include <sdktools>
|
|
#include <sdkhooks>
|
|
|
|
#tryinclude <left4dhooks_anim>
|
|
#tryinclude <left4dhooks_stocks>
|
|
#tryinclude <left4dhooks_lux_library>
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================================================
|
|
// ENUMS
|
|
// ====================================================================================================
|
|
enum
|
|
{
|
|
L4D_TEAM_UNASSIGNED = 0,
|
|
L4D_TEAM_SPECTATOR = 1,
|
|
L4D_TEAM_SURVIVOR = 2,
|
|
L4D_TEAM_INFECTED = 3,
|
|
L4D_TEAM_FOUR = 4
|
|
}
|
|
|
|
enum
|
|
{
|
|
L4D_WEAPON_SLOT_PRIMARY = 0,
|
|
L4D_WEAPON_SLOT_SECONDARY = 1,
|
|
L4D_WEAPON_SLOT_GRENADE = 2,
|
|
L4D_WEAPON_SLOT_MEDKIT = 3, // L4D2: Also upgrade ammo packs and defibrillator
|
|
L4D_WEAPON_SLOT_PILLS = 4, // L4D2: Also Adrenaline
|
|
L4D_WEAPON_SLOT_CARRIED = 5 // Physics props such as GasCan etc.
|
|
}
|
|
|
|
enum
|
|
{
|
|
L4D1_ZOMBIE_CLASS_SMOKER = 1,
|
|
L4D1_ZOMBIE_CLASS_BOOMER = 2,
|
|
L4D1_ZOMBIE_CLASS_HUNTER = 3,
|
|
L4D1_ZOMBIE_CLASS_WITCH = 4,
|
|
L4D1_ZOMBIE_CLASS_TANK = 5
|
|
}
|
|
|
|
enum
|
|
{
|
|
L4D2_ZOMBIE_CLASS_SMOKER = 1,
|
|
L4D2_ZOMBIE_CLASS_BOOMER = 2,
|
|
L4D2_ZOMBIE_CLASS_HUNTER = 3,
|
|
L4D2_ZOMBIE_CLASS_SPITTER = 4,
|
|
L4D2_ZOMBIE_CLASS_JOCKEY = 5,
|
|
L4D2_ZOMBIE_CLASS_CHARGER = 6,
|
|
L4D2_ZOMBIE_CLASS_WITCH = 7,
|
|
L4D2_ZOMBIE_CLASS_TANK = 8
|
|
}
|
|
|
|
enum
|
|
{
|
|
SERVER_OS_WINDOWS = 0,
|
|
SERVER_OS_LINUX = 1,
|
|
}
|
|
|
|
// Thanks to "Dragokas":
|
|
enum // m_eDoorState
|
|
{
|
|
DOOR_STATE_CLOSED,
|
|
DOOR_STATE_OPENING_IN_PROGRESS,
|
|
DOOR_STATE_OPENED,
|
|
DOOR_STATE_CLOSING_IN_PROGRESS
|
|
}
|
|
|
|
// Thanks to "Dragokas":
|
|
enum // m_spawnflags
|
|
{
|
|
DOOR_FLAG_STARTS_OPEN = 1,
|
|
DOOR_FLAG_STARTS_LOCKED = 2048,
|
|
DOOR_FLAG_SILENT = 4096,
|
|
DOOR_FLAG_USE_CLOSES = 8192,
|
|
DOOR_FLAG_SILENT_NPC = 16384,
|
|
DOOR_FLAG_IGNORE_USE = 32768,
|
|
DOOR_FLAG_UNBREAKABLE = 524288
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ====================================================================================================
|
|
// STOCKS
|
|
// ====================================================================================================
|
|
|
|
// ==================================================
|
|
// ENGINE STOCKS
|
|
// ==================================================
|
|
static EngineVersion g_iEngine;
|
|
|
|
/**
|
|
* @brief Returns if the server is running on the Left 4 Dead series engine
|
|
*
|
|
* @return Returns true if the server is running on the Left 4 Dead series
|
|
*/
|
|
stock bool L4D_IsEngineLeft4Dead()
|
|
{
|
|
if( g_iEngine == Engine_Unknown )
|
|
{
|
|
g_iEngine = GetEngineVersion();
|
|
}
|
|
|
|
return (g_iEngine == Engine_Left4Dead || g_iEngine == Engine_Left4Dead2);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns if the server is running on Left 4 Dead 1
|
|
*
|
|
* @return Returns true if server is running on Left 4 Dead 1
|
|
*/
|
|
stock bool L4D_IsEngineLeft4Dead1()
|
|
{
|
|
if( g_iEngine == Engine_Unknown )
|
|
{
|
|
g_iEngine = GetEngineVersion();
|
|
}
|
|
|
|
return g_iEngine == Engine_Left4Dead;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns if the server is running on Left 4 Dead 2
|
|
*
|
|
* @return Returns true if server is running on Left 4 Dead 2
|
|
*/
|
|
stock bool L4D_IsEngineLeft4Dead2()
|
|
{
|
|
if( g_iEngine == Engine_Unknown )
|
|
{
|
|
g_iEngine = GetEngineVersion();
|
|
}
|
|
|
|
return g_iEngine == Engine_Left4Dead2;
|
|
}
|
|
|
|
|
|
|
|
// ==================================================
|
|
// DOOR STOCKS
|
|
// ==================================================
|
|
|
|
/**
|
|
* @brief Returns the specified door state. Uses the "DOOR_STATE_*" enum
|
|
*
|
|
* @param entity The "prop_door*" entity to check
|
|
*
|
|
* @return the "DOOR_STATE_*" value
|
|
*/
|
|
stock int L4D_GetDoorState(int entity)
|
|
{
|
|
return GetEntProp(entity, Prop_Data, "m_eDoorState");
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the specified door flags. Uses the "DOOR_FLAG_*" enum
|
|
*
|
|
* @param entity The "prop_door*" entity to check
|
|
*
|
|
* @return the "DOOR_FLAG_*" value
|
|
*/
|
|
stock int L4D_GetDoorFlag(int entity)
|
|
{
|
|
return GetEntProp(entity, Prop_Data, "m_spawnflags");
|
|
}
|
|
|
|
|
|
|
|
// ==================================================
|
|
// ENTITY STOCKS
|
|
// ==================================================
|
|
|
|
/**
|
|
* @brief Returns a players current weapon, or -1 if none.
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return weapon entity index or -1 if none
|
|
*/
|
|
stock int L4D_GetPlayerCurrentWeapon(int client)
|
|
{
|
|
return GetEntPropEnt(client, Prop_Send, "m_hActiveWeapon");
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the Custom Ability entity of a Special Infected
|
|
* @remarks Returns the entity of "ability_vomit" (Boomer), "ability_lunge" (Hunter), "ability_tongue" (Smoker), "ability_charge" (Charger), "ability_ride" (Jockey), "ability_spit" (Spitter), "ability_throw" (Tank)
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return entity index or -1 if none
|
|
*/
|
|
stock int L4D_GetPlayerCustomAbility(int client)
|
|
{
|
|
return GetEntPropEnt(client, Prop_Send, "m_customAbility");
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the players Use Action Target
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return entity index or -1 if none
|
|
*/
|
|
stock int L4D_GetPlayerUseTarget(int client)
|
|
{
|
|
return GetEntPropEnt(client, Prop_Send, "m_useActionTarget");
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the parent of an entity
|
|
*
|
|
* @param client Entity index to check
|
|
*
|
|
* @return entity index or -1 if none
|
|
*/
|
|
stock int L4D_EntityParent(int entity)
|
|
{
|
|
return GetEntPropEnt(entity, Prop_Data, "m_pParent");
|
|
}
|
|
|
|
/**
|
|
* @brief Checks if a player is using any mounted weapon (minigun or 50cal)
|
|
*
|
|
* @param client Client to check
|
|
*
|
|
* @return true if using a mounted weapon, false otherwise
|
|
*/
|
|
stock bool IsUsingMinigun(int client)
|
|
{
|
|
return ((GetEntProp(client, Prop_Send, "m_usingMountedWeapon") > 0) || (GetEntProp(client, Prop_Send, L4D_IsEngineLeft4Dead2() ? "m_usingMountedGun" : "m_usingMinigun") > 0));
|
|
}
|
|
|
|
/**
|
|
* @brief Stops a client using a mounted weapon
|
|
*
|
|
* @param client Entity index to check
|
|
*
|
|
* @return entity index or -1 if none
|
|
*/
|
|
stock void StopUsingMinigun(int client)
|
|
{
|
|
if( IsUsingMinigun(client) )
|
|
{
|
|
int entity = GetEntPropEnt(client, Prop_Send, "m_hUseEntity");
|
|
if( entity > 0 && entity < 2048 )
|
|
{
|
|
SetEntPropEnt(entity, Prop_Send, "m_owner", -1);
|
|
}
|
|
|
|
SetEntProp(client, Prop_Send, L4D_IsEngineLeft4Dead2() ? "m_usingMountedGun" : "m_usingMinigun", 0);
|
|
SetEntProp(client, Prop_Send, "m_usingMountedWeapon", 0);
|
|
SetEntPropEnt(client, Prop_Send, "m_hUseEntity", -1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Returns if a player is on fire
|
|
*
|
|
* @param client Client index to check
|
|
*
|
|
* @return true on fire, false otherwise
|
|
*/
|
|
stock bool L4D_IsPlayerOnFire(int client)
|
|
{
|
|
if( GetEntProp(client, Prop_Data, "m_fFlags") & FL_ONFIRE ) return true;
|
|
else return false;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns if a player is burning
|
|
*
|
|
* @param client Client index to check
|
|
*
|
|
* @return true on burning, false otherwise
|
|
*/
|
|
stock bool L4D_IsPlayerBurning(int client)
|
|
{
|
|
float fBurning = GetEntPropFloat(client, Prop_Send, "m_burnPercent");
|
|
return (fBurning > 0.0) ? true : false;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns true if a physics object or alarmed car can be moved by the tank
|
|
*
|
|
* @param entity Entity index to check
|
|
*
|
|
* @return true if it can be moved, false otherwise
|
|
*/
|
|
stock bool L4D_IsTankProp(int entity)
|
|
{
|
|
static char classname[16];
|
|
|
|
GetEdictClassname(entity, classname, sizeof(classname));
|
|
|
|
if( strcmp(classname, "prop_physics") == 0 )
|
|
{
|
|
if( GetEntProp(entity, Prop_Send, "m_hasTankGlow") )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else if( strcmp(classname, "prop_car_alarm") == 0 )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
// ==================================================
|
|
// COMMON INFECTED STOCKS
|
|
// ==================================================
|
|
|
|
/**
|
|
* @brief Creates a panic event mob horde
|
|
* @remarks Subject to horde cooldown timer
|
|
* @remarks Can probably reset the timer with either "L4D_ResetMobTimer();" native or using "L4D2CT_MobSpawnTimer" with the timer natives.
|
|
*
|
|
* @noreturn
|
|
*/
|
|
stock void L4D_ForcePanicEvent()
|
|
{
|
|
static EngineVersion engine;
|
|
|
|
if( engine == Engine_Unknown )
|
|
{
|
|
engine = GetEngineVersion();
|
|
}
|
|
|
|
if( engine == Engine_Left4Dead2 )
|
|
{
|
|
static int director = INVALID_ENT_REFERENCE;
|
|
|
|
if( director == INVALID_ENT_REFERENCE || EntRefToEntIndex(director) == INVALID_ENT_REFERENCE )
|
|
{
|
|
director = FindEntityByClassname(-1, "info_director");
|
|
if( director != INVALID_ENT_REFERENCE )
|
|
{
|
|
director = EntIndexToEntRef(director);
|
|
}
|
|
}
|
|
|
|
if( director != INVALID_ENT_REFERENCE )
|
|
{
|
|
AcceptEntityInput(director, "ForcePanicEvent");
|
|
return;
|
|
}
|
|
}
|
|
|
|
int flags = GetCommandFlags("director_force_panic_event");
|
|
SetCommandFlags("director_force_panic_event", flags & ~FCVAR_CHEAT);
|
|
ServerCommand("director_force_panic_event");
|
|
SetCommandFlags("director_force_panic_event", flags);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the current number of common infected
|
|
*
|
|
* @return entity index or -1 if none
|
|
*/
|
|
stock int L4D_GetCommonsCount()
|
|
{
|
|
int entity = -1;
|
|
int count;
|
|
while( (entity = FindEntityByClassname(entity, "infected")) != INVALID_ENT_REFERENCE )
|
|
{
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* @brief Spawns a Common Infected at the given position
|
|
*
|
|
* @param vPos Origin vector to spawn at
|
|
* @param vAng Angles vector to spawn at (optional)
|
|
*
|
|
* @return entity index or -1 on failure
|
|
*/
|
|
stock int L4D_SpawnCommonInfected(float vPos[3], float vAng[3] = { 0.0, 0.0, 0.0 })
|
|
{
|
|
int entity = CreateEntityByName("infected");
|
|
if( entity != -1 )
|
|
{
|
|
TeleportEntity(entity, vPos, vAng, NULL_VECTOR);
|
|
DispatchSpawn(entity);
|
|
}
|
|
|
|
return entity;
|
|
}
|
|
|
|
|
|
|
|
// ==================================================
|
|
// INFECTED: GET VICTIM
|
|
// ==================================================
|
|
|
|
/**
|
|
* @brief Returns the Survivor victim when pinned by a Hunter
|
|
*
|
|
* @param client Client ID of the Special Infected player to check
|
|
*
|
|
* @return Victim client index, or 0 if none
|
|
*/
|
|
stock int L4D_GetVictimHunter(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_pounceVictim")) > 0 )
|
|
return attacker;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the Survivor victim when pinned by a Smoker
|
|
*
|
|
* @param client Client ID of the Special Infected player to check
|
|
*
|
|
* @return Victim client index, or 0 if none
|
|
*/
|
|
stock int L4D_GetVictimSmoker(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_tongueVictim")) > 0 )
|
|
return attacker;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the Survivor victim when pinned by a Charger
|
|
*
|
|
* @param client Client ID of the Special Infected player to check
|
|
*
|
|
* @return Victim client index, or 0 if none
|
|
*/
|
|
// L4D2 only.
|
|
stock int L4D_GetVictimCharger(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_pummelVictim")) > 0 )
|
|
return attacker;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the Survivor victim when carried by a Charger
|
|
*
|
|
* @param client Client ID of the Special Infected player to check
|
|
*
|
|
* @return Victim client index, or 0 if none
|
|
*/
|
|
// L4D2 only.
|
|
stock int L4D_GetVictimCarry(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_carryVictim")) > 0 )
|
|
return attacker;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the Survivor victim when pinned by a Jockey
|
|
*
|
|
* @param client Client ID of the Special Infected player to check
|
|
*
|
|
* @return Victim client index, or 0 if none
|
|
*/
|
|
// L4D2 only.
|
|
stock int L4D_GetVictimJockey(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_jockeyVictim")) > 0 )
|
|
return attacker;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// ==================================================
|
|
// SURVIVOR: GET ATTACKER
|
|
// ==================================================
|
|
|
|
/**
|
|
* @brief Returns a Survivors attacker when pinned by a Hunter
|
|
*
|
|
* @param client Client ID of the Survivor player to check
|
|
*
|
|
* @return Attacker client index, or 0 if none
|
|
*/
|
|
stock int L4D_GetAttackerHunter(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_pounceAttacker")) > 0 )
|
|
return attacker;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a Survivors attacker when pinned by a Smoker
|
|
*
|
|
* @param client Client ID of the Survivor player to check
|
|
*
|
|
* @return Attacker client index, or 0 if none
|
|
*/
|
|
stock int L4D_GetAttackerSmoker(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_tongueOwner")) > 0 )
|
|
return attacker;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a Survivors attacker when pummelled by a Charger
|
|
*
|
|
* @param client Client ID of the Survivor player to check
|
|
*
|
|
* @return Attacker client index, or 0 if none
|
|
*/
|
|
// L4D2 only.
|
|
stock int L4D_GetAttackerCharger(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_pummelAttacker")) > 0 )
|
|
return attacker;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a Survivors attacker when carried by a Charger
|
|
*
|
|
* @param client Client ID of the Survivor player to check
|
|
*
|
|
* @return Attacker client index, or 0 if none
|
|
*/
|
|
// L4D2 only.
|
|
stock int L4D_GetAttackerCarry(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_carryAttacker")) > 0 )
|
|
return attacker;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a Survivors attacker when pinned by a Jockey
|
|
*
|
|
* @param client Client ID of the Survivor player to check
|
|
*
|
|
* @return Attacker client index, or 0 if none
|
|
*/
|
|
// L4D2 only.
|
|
stock int L4D_GetAttackerJockey(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_jockeyAttacker")) > 0 )
|
|
return attacker;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// ==================================================
|
|
// PINNED CHECKS
|
|
// ==================================================
|
|
|
|
/**
|
|
* @brief Returns the attacker when a Survivor is pinned by a Special Infected
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Attacker client index, or 0 if none
|
|
*/
|
|
stock int L4D_GetPinnedInfected(int client)
|
|
{
|
|
int attacker;
|
|
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_pounceAttacker")) > 0 )
|
|
return attacker;
|
|
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_tongueOwner")) > 0 )
|
|
return attacker;
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_jockeyAttacker")) > 0 )
|
|
return attacker;
|
|
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_pummelAttacker")) > 0 )
|
|
return attacker;
|
|
|
|
if( (attacker = GetEntPropEnt(client, Prop_Send, "m_carryAttacker")) > 0 )
|
|
return attacker;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the victim when a Survivor is pinned by a Special Infected
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Attacker client index, or 0 if none
|
|
*/
|
|
stock int L4D_GetPinnedSurvivor(int client)
|
|
{
|
|
int class = GetEntProp(client, Prop_Send, "m_zombieClass");
|
|
int victim;
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
switch( class )
|
|
{
|
|
case 1: victim = GetEntPropEnt(client, Prop_Send, "m_tongueVictim");
|
|
case 3: victim = GetEntPropEnt(client, Prop_Send, "m_pounceVictim");
|
|
case 5: victim = GetEntPropEnt(client, Prop_Send, "m_jockeyVictim");
|
|
case 6:
|
|
{
|
|
victim = GetEntPropEnt(client, Prop_Send, "m_pummelVictim");
|
|
if( victim < 1 ) victim = GetEntPropEnt(client, Prop_Send, "m_carryVictim");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch( class )
|
|
{
|
|
case 1: victim = GetEntPropEnt(client, Prop_Send, "m_tongueVictim");
|
|
case 3: victim = GetEntPropEnt(client, Prop_Send, "m_pounceVictim");
|
|
}
|
|
}
|
|
|
|
if( victim > 0 )
|
|
return victim;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns true when someone is being carried/pummelled by more than 1 Charger
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Returns true when someone is being carried/pummelled by more than 1 Charger
|
|
*/
|
|
// L4D2 only.
|
|
stock bool L4D2_IsMultiCharged(int victim)
|
|
{
|
|
if( !L4D_IsEngineLeft4Dead2() )
|
|
ThrowError("Stock only supports L4D2.");
|
|
|
|
int count;
|
|
|
|
for( int i = 1; i <= MaxClients; i++ )
|
|
{
|
|
if( !IsClientInGame(i) )
|
|
continue;
|
|
|
|
else if( GetClientTeam(i) != 3 )
|
|
continue;
|
|
|
|
else if( L4D2_GetPlayerZombieClass(i) != L4D2ZombieClass_Charger )
|
|
continue;
|
|
|
|
if( L4D_GetVictimCarry(i) == victim || L4D_GetVictimCharger(i) == victim )
|
|
count++;
|
|
}
|
|
|
|
return count >= 2;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns if a Survivor is pinned by a Special Infected
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Returns true if pinned, false otherwise
|
|
*/
|
|
stock bool L4D_IsPlayerPinned(int client)
|
|
{
|
|
return L4D_GetPinnedInfected(client) != 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns if a Survivor is being attacked in the Smokers arms
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Returns true if player has reached the Smoker, false otherwise
|
|
*/
|
|
stock bool L4D_HasReachedSmoker(int client)
|
|
{
|
|
// m_isHangingFromTongue sometimes returns 1 when still being dragged, using this instead
|
|
return GetEntProp(client, Prop_Send, "m_reachedTongueOwner", 1) == 1;
|
|
}
|
|
|
|
|
|
|
|
// ==================================================
|
|
// CHARGER STOCKS - Written by "Forgetest"
|
|
// ==================================================
|
|
#define QueuedPummel_Victim 0
|
|
#define QueuedPummel_StartTime 4
|
|
#define QueuedPummel_Attacker 8
|
|
|
|
/**
|
|
* @brief Internally used to get offset to the start of queued pummel field.
|
|
*
|
|
* @return Offset into CTerrorPlayer to the start of queued pummel props
|
|
*/
|
|
static stock int L4D2_OffsQueuedPummelInfo()
|
|
{
|
|
static int m_hQueuedPummelVictim = -1;
|
|
if( m_hQueuedPummelVictim == -1 )
|
|
m_hQueuedPummelVictim = FindSendPropInfo("CTerrorPlayer", "m_pummelAttacker") + 4;
|
|
|
|
return m_hQueuedPummelVictim;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the timestamp when the queued pummel begins.
|
|
*
|
|
* @param client Client ID of the charger to check
|
|
*
|
|
* @return timestamp or -1.0 if no queued pummel
|
|
*/
|
|
stock float L4D2_GetQueuedPummelStartTime(int charger)
|
|
{
|
|
return GetEntDataFloat(charger, L4D2_OffsQueuedPummelInfo() + QueuedPummel_StartTime);
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the timestamp when the queued pummel begins.
|
|
*
|
|
* @param client Client ID of the charger to check
|
|
* @param timestamp Timestamp to set
|
|
*
|
|
* @noreturn
|
|
*/
|
|
stock void L4D2_SetQueuedPummelStartTime(int charger, float timestamp)
|
|
{
|
|
SetEntDataFloat(charger, L4D2_OffsQueuedPummelInfo() + QueuedPummel_StartTime, timestamp);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns if a Charger is in a queued pummel.
|
|
*
|
|
* @param charger Client ID of the charger to check
|
|
*
|
|
* @return true if in queued pummel, false otherwise
|
|
*/
|
|
stock bool L4D2_IsInQueuedPummel(int charger)
|
|
{
|
|
float flTimestamp = L4D2_GetQueuedPummelStartTime(charger);
|
|
|
|
return flTimestamp != -1.0 && flTimestamp > GetGameTime();
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the victim of a Charger in a queued pummel.
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return client index or -1 if none
|
|
*/
|
|
stock int L4D2_GetQueuedPummelVictim(int client)
|
|
{
|
|
return GetEntDataEnt2(client, L4D2_OffsQueuedPummelInfo() + QueuedPummel_Victim);
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the victim of a Charger in a queued pummel.
|
|
*
|
|
* @param client Client ID of the player to set
|
|
* @param target Client ID of the target to set
|
|
*
|
|
* @noreturn
|
|
*/
|
|
stock void L4D2_SetQueuedPummelVictim(int client, int target)
|
|
{
|
|
SetEntDataEnt2(client, L4D2_OffsQueuedPummelInfo() + QueuedPummel_Victim, target);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the attacker of a Survivor in a queued pummel.
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return client index or -1 if none
|
|
*/
|
|
stock int L4D2_GetQueuedPummelAttacker(int client)
|
|
{
|
|
return GetEntDataEnt2(client, L4D2_OffsQueuedPummelInfo() + QueuedPummel_Attacker);
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the attacker of a Survivor in a queued pummel.
|
|
*
|
|
* @param client Client ID of the player to set
|
|
* @param target Client ID of the target to set
|
|
*
|
|
* @noreturn
|
|
*/
|
|
stock void L4D2_SetQueuedPummelAttacker(int client, int target)
|
|
{
|
|
SetEntDataEnt2(client, L4D2_OffsQueuedPummelInfo() + QueuedPummel_Attacker, target);
|
|
}
|
|
|
|
|
|
|
|
// ==================================================
|
|
// LEDGE HANG STOCKS
|
|
// ==================================================
|
|
|
|
/**
|
|
* @brief Returns if a Survivor is hanging from a ledge
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Returns true if hanging, false otherwise
|
|
*/
|
|
stock bool L4D_IsPlayerHangingFromLedge(int client)
|
|
{
|
|
return GetEntProp(client, Prop_Send, "m_isHangingFromLedge", 1) == 1;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns if a Survivor can ledge hang
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Returns true if can hang, false otherwise
|
|
*/
|
|
stock bool L4D_CanPlayerLedgeHang(int client)
|
|
{
|
|
// Get address
|
|
static int addy = -1;
|
|
if( addy == -1 )
|
|
{
|
|
/*
|
|
See the function "CTerrorPlayer::InputDisableLedgeHang"
|
|
On Windows: this[16417] = 0;
|
|
m_bWasPresentAtSurvivalStart offset == 16388
|
|
16388 + 29 = 16417
|
|
Offset unlikely to change unless netprops are added/removed/changed - which is very unlikely
|
|
*/
|
|
addy = FindSendPropInfo("CTerrorPlayer", "m_bWasPresentAtSurvivalStart") + 29;
|
|
}
|
|
|
|
return GetEntData(client, addy, 1) == 1;
|
|
}
|
|
|
|
/**
|
|
* @brief Allow a Survivor to ledge hang
|
|
*
|
|
* @param client Client ID of the player to affect
|
|
*
|
|
* @noreturn
|
|
*/
|
|
stock void L4D_LedgeHangEnable(int client)
|
|
{
|
|
AcceptEntityInput(client, "EnableLedgeHang");
|
|
}
|
|
|
|
/**
|
|
* @brief Disallow a Survivor to ledge hang
|
|
*
|
|
* @param client Client ID of the player to affect
|
|
*
|
|
* @noreturn
|
|
*/
|
|
stock void L4D_LedgeHangDisable(int client)
|
|
{
|
|
AcceptEntityInput(client, "DisableLedgeHang");
|
|
}
|
|
|
|
/**
|
|
* @brief Checks if a Survivor is currently staggering
|
|
*
|
|
* @param client Client ID of the player to affect
|
|
*
|
|
* @return Returns true if player is staggering, false otherwise
|
|
*/
|
|
// Updated more accurate version thanks to "HarryPotter" for providing.
|
|
stock bool L4D_IsPlayerStaggering(int client)
|
|
{
|
|
static int Activity = -1;
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
Activity = PlayerAnimState.FromPlayer(client).GetMainActivity();
|
|
|
|
switch( Activity )
|
|
{
|
|
case L4D2_ACT_TERROR_SHOVED_FORWARD_MELEE, // 633, 634, 635, 636: stumble
|
|
L4D2_ACT_TERROR_SHOVED_BACKWARD_MELEE,
|
|
L4D2_ACT_TERROR_SHOVED_LEFTWARD_MELEE,
|
|
L4D2_ACT_TERROR_SHOVED_RIGHTWARD_MELEE:
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Activity = L4D1_GetMainActivity(client);
|
|
|
|
switch( Activity )
|
|
{
|
|
case L4D1_ACT_TERROR_SHOVED_FORWARD, // 1145, 1146, 1147, 1148: stumble
|
|
L4D1_ACT_TERROR_SHOVED_BACKWARD,
|
|
L4D1_ACT_TERROR_SHOVED_LEFTWARD,
|
|
L4D1_ACT_TERROR_SHOVED_RIGHTWARD:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static int m_iQueuedStaggerType = -1;
|
|
if( m_iQueuedStaggerType == -1 )
|
|
m_iQueuedStaggerType = FindSendPropInfo("CTerrorPlayer", "m_staggerDist") + 4;
|
|
|
|
if( GetEntData(client, m_iQueuedStaggerType, 4) == -1 )
|
|
{
|
|
if( GetGameTime() >= GetEntPropFloat(client, Prop_Send, "m_staggerTimer", 1) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static float vStgDist[3], vOrigin[3];
|
|
GetEntPropVector(client, Prop_Send, "m_staggerStart", vStgDist);
|
|
GetEntPropVector(client, Prop_Send, "m_vecOrigin", vOrigin);
|
|
|
|
static float fStgDist2;
|
|
fStgDist2 = GetEntPropFloat(client, Prop_Send, "m_staggerDist");
|
|
|
|
return GetVectorDistance(vStgDist, vOrigin) <= fStgDist2;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
stock int L4D1_GetMainActivity(int client)
|
|
{
|
|
static int s_iOffs_m_eCurrentMainSequenceActivity = -1;
|
|
if( s_iOffs_m_eCurrentMainSequenceActivity == -1 )
|
|
s_iOffs_m_eCurrentMainSequenceActivity = FindSendPropInfo("CTerrorPlayer", "m_iProgressBarDuration") + 476;
|
|
|
|
return LoadFromAddress(GetEntityAddress(client) + view_as<Address>(s_iOffs_m_eCurrentMainSequenceActivity), NumberType_Int32);
|
|
}
|
|
|
|
/* OLD VERSION (Before being updated by "HarryPotter")
|
|
stock bool L4D_IsPlayerStaggering(int client)
|
|
{
|
|
static int m_iQueuedStaggerType = -1;
|
|
if( m_iQueuedStaggerType == -1 )
|
|
m_iQueuedStaggerType = FindSendPropInfo("CTerrorPlayer", "m_staggerDist") + 4;
|
|
|
|
if( GetEntData(client, m_iQueuedStaggerType, 4) == -1 )
|
|
{
|
|
if( GetGameTime() >= GetEntPropFloat(client, Prop_Send, "m_staggerTimer", 1) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static float vStgDist[3], vOrigin[3];
|
|
GetEntPropVector(client, Prop_Send, "m_staggerStart", vStgDist);
|
|
GetEntPropVector(client, Prop_Send, "m_vecOrigin", vOrigin);
|
|
|
|
static float fStgDist2;
|
|
fStgDist2 = GetEntPropFloat(client, Prop_Send, "m_staggerDist");
|
|
|
|
return GetVectorDistance(vStgDist, vOrigin) <= fStgDist2;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
// ==================================================
|
|
// INCAP and REVIVE STOCKS
|
|
// ==================================================
|
|
/**
|
|
* @brief Set a Survivors incapacitated netprop
|
|
* @remarks When setting to false can make a Survivor have 300 health (the incapped health value)
|
|
*
|
|
* @param client Client ID of the player to affect
|
|
* @param incap True to incap, false to remove incap (not the proper way of reviving from incap, probably bypasses revive event)
|
|
*
|
|
* @noreturn
|
|
*/
|
|
stock void L4D_SetPlayerIncapped(int client, bool incap)
|
|
{
|
|
SetEntProp(client, Prop_Send, "m_isIncapacitated", incap ? 1 : 0);
|
|
}
|
|
|
|
/**
|
|
* @brief Incap a Survivor by giving them 100.0 damage
|
|
*
|
|
* @param client Client ID of the player to affect
|
|
* @param attacker Optionally set the attacker to credit them for the incap
|
|
*
|
|
* @noreturn
|
|
*/
|
|
stock void L4D_SetPlayerIncappedDamage(int client, int attacker = 0)
|
|
{
|
|
SDKHooks_TakeDamage(client, attacker, attacker, 100.0);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a Survivors revive target
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Target client index, or 0 if none
|
|
*/
|
|
stock int L4D_GetPlayerReviveTarget(int client)
|
|
{
|
|
int target = GetEntPropEnt(client, Prop_Send, "m_reviveTarget");
|
|
if( target > 0 )
|
|
return target;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns an incapacitated Survivor's reviver
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Reviver client index, or 0 if none
|
|
*/
|
|
stock int L4D_GetPlayerReviveOwner(int client)
|
|
{
|
|
int target = GetEntPropEnt(client, Prop_Send, "m_reviveOwner");
|
|
if( target > 0 )
|
|
return target;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Stops a Survivor reviving someone
|
|
* @remarks Prevents accidental freezing of player who tried to revive you
|
|
* @remarks Thanks to "Dragokas" for the stock
|
|
*
|
|
* @param client Client ID of the player to affect
|
|
*
|
|
* @noreturn
|
|
*/
|
|
stock void L4D_StopReviveAction(int client)
|
|
{
|
|
int owner_save = -1;
|
|
int target_save = -1;
|
|
int owner = GetEntPropEnt(client, Prop_Send, "m_reviveOwner"); // when you reviving somebody, this is -1. When somebody revive you, this is somebody's id
|
|
int target = GetEntPropEnt(client, Prop_Send, "m_reviveTarget"); // when you reviving somebody, this is somebody's id. When somebody revive you, this is -1
|
|
|
|
SetEntPropEnt(client, Prop_Send, "m_reviveOwner", -1);
|
|
SetEntPropEnt(client, Prop_Send, "m_reviveTarget", -1);
|
|
|
|
if( owner != -1 ) // we must reset flag for both - for you, and who you revive
|
|
{
|
|
SetEntPropEnt(owner, Prop_Send, "m_reviveOwner", -1);
|
|
SetEntPropEnt(owner, Prop_Send, "m_reviveTarget", -1);
|
|
owner_save = owner;
|
|
}
|
|
|
|
if( target != -1 )
|
|
{
|
|
SetEntPropEnt(target, Prop_Send, "m_reviveOwner", -1);
|
|
SetEntPropEnt(target, Prop_Send, "m_reviveTarget", -1);
|
|
target_save = target;
|
|
}
|
|
|
|
if( L4D_IsEngineLeft4Dead2() )
|
|
{
|
|
owner = GetEntPropEnt(client, Prop_Send, "m_useActionOwner"); // used when healing e.t.c.
|
|
target = GetEntPropEnt(client, Prop_Send, "m_useActionTarget");
|
|
SetEntPropEnt(client, Prop_Send, "m_useActionOwner", -1);
|
|
SetEntPropEnt(client, Prop_Send, "m_useActionTarget", -1);
|
|
|
|
if( owner != -1 )
|
|
{
|
|
SetEntPropEnt(owner, Prop_Send, "m_useActionOwner", -1);
|
|
SetEntPropEnt(owner, Prop_Send, "m_useActionTarget", -1);
|
|
owner_save = owner;
|
|
}
|
|
|
|
if( target > 0 && target <= MaxClients )
|
|
{
|
|
SetEntPropEnt(target, Prop_Send, "m_useActionOwner", -1);
|
|
SetEntPropEnt(target, Prop_Send, "m_useActionTarget", -1);
|
|
target_save = target;
|
|
}
|
|
|
|
SetEntProp(client, Prop_Send, "m_iCurrentUseAction", 0);
|
|
SetEntPropFloat(client, Prop_Send, "m_flProgressBarDuration", 0.0);
|
|
|
|
if( owner_save != -1 )
|
|
{
|
|
SetEntProp(owner_save, Prop_Send, "m_iCurrentUseAction", 0);
|
|
SetEntPropFloat(owner_save, Prop_Send, "m_flProgressBarDuration", 0.0);
|
|
}
|
|
|
|
if( target_save != -1 )
|
|
{
|
|
SetEntProp(target_save, Prop_Send, "m_iCurrentUseAction", 0);
|
|
SetEntPropFloat(target_save, Prop_Send, "m_flProgressBarDuration", 0.0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
owner = GetEntPropEnt(client, Prop_Send, "m_healOwner"); // used when healing
|
|
target = GetEntPropEnt(client, Prop_Send, "m_healTarget");
|
|
SetEntPropEnt(client, Prop_Send, "m_healOwner", -1);
|
|
SetEntPropEnt(client, Prop_Send, "m_healTarget", -1);
|
|
|
|
if( owner != -1 )
|
|
{
|
|
SetEntPropEnt(owner, Prop_Send, "m_healOwner", -1);
|
|
SetEntPropEnt(owner, Prop_Send, "m_healTarget", -1);
|
|
owner_save = owner;
|
|
}
|
|
|
|
if( target != -1 )
|
|
{
|
|
SetEntPropEnt(target, Prop_Send, "m_healOwner", -1);
|
|
SetEntPropEnt(target, Prop_Send, "m_healTarget", -1);
|
|
target_save = target;
|
|
}
|
|
|
|
SetEntProp(client, Prop_Send, "m_iProgressBarDuration", 0);
|
|
|
|
if( owner_save != -1 )
|
|
{
|
|
SetEntProp(owner_save, Prop_Send, "m_iProgressBarDuration", 0);
|
|
}
|
|
|
|
if( target_save != -1 )
|
|
{
|
|
SetEntProp(target_save, Prop_Send, "m_iProgressBarDuration", 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Returns if a Survivor is incapacitated
|
|
*
|
|
* @param client Client ID of the player to check
|
|
*
|
|
* @return Returns true if incapacitated, false otherwise
|
|
*/
|
|
#pragma deprecated Use L4D_IsPlayerIncapacitated instead
|
|
stock bool L4D_IsPlayerIncapped(int client)
|
|
{
|
|
return GetEntProp(client, Prop_Send, "m_isIncapacitated", 1) != 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ==================================================
|
|
// GET CLIENT STOCKS
|
|
// ==================================================
|
|
|
|
/**
|
|
* @brief Returns a random client in-game
|
|
*
|
|
* @return Client index or 0 if none
|
|
*/
|
|
stock int GetAnyRandomClient()
|
|
{
|
|
int client;
|
|
ArrayList aClients = new ArrayList();
|
|
|
|
for( int i = 1; i <= MaxClients; i++ )
|
|
{
|
|
if( IsClientInGame(i) )
|
|
{
|
|
aClients.Push(i);
|
|
}
|
|
}
|
|
|
|
if( aClients.Length > 0 )
|
|
{
|
|
SetRandomSeed(GetGameTickCount());
|
|
client = aClients.Get(GetRandomInt(0, aClients.Length - 1));
|
|
}
|
|
|
|
delete aClients;
|
|
|
|
return client;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a random Survivor
|
|
*
|
|
* @param alive -1 = Any. 0 = Only dead players. 1 = Only alive players
|
|
* @param bots -1 = Any. 0 - Only real players. 1 = Only fake players
|
|
*
|
|
* @return Client index or 0 if none
|
|
*/
|
|
stock int GetRandomSurvivor(int alive = -1, int bots = -1)
|
|
{
|
|
return GetRandomClient(2, alive, bots);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a random Special Infected
|
|
*
|
|
* @param alive -1 = Any. 0 = Only dead players. 1 = Only alive players
|
|
* @param bots -1 = Any. 0 - Only real players. 1 = Only fake players
|
|
*
|
|
* @return Client index or 0 if none
|
|
*/
|
|
stock int GetRandomInfected(int alive = -1, int bots = -1)
|
|
{
|
|
return GetRandomClient(3, alive, bots);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns a random client in game
|
|
*
|
|
* @param team -1 = Any. 1=Spectators, 2=Survivors, 3=Special Infected, 5=Survivors and Special Infected (team > 1)
|
|
* @param alive -1 = Any. 0 = Only dead players. 1 = Only alive players
|
|
* @param bots -1 = Any. 0 - Only real players. 1 = Only fake players
|
|
*
|
|
* @return Client index or 0 if none
|
|
*/
|
|
stock int GetRandomClient(int team = -1, int alive = -1, int bots = -1)
|
|
{
|
|
ArrayList aClients = new ArrayList();
|
|
|
|
for( int i = 1; i <= MaxClients; i++ )
|
|
{
|
|
if( IsClientInGame(i) && (team == -1 || (team == 5 && GetClientTeam(i) > 1) || GetClientTeam(i) == team) && (alive == -1 || IsPlayerAlive(i) == view_as<bool>(alive)) && (bots == -1 || IsFakeClient(i) == view_as<bool>(bots)) )
|
|
{
|
|
aClients.Push(i);
|
|
}
|
|
}
|
|
|
|
int client;
|
|
|
|
if( aClients.Length > 0 )
|
|
{
|
|
SetRandomSeed(GetGameTickCount());
|
|
client = aClients.Get(GetRandomInt(0, aClients.Length - 1));
|
|
}
|
|
|
|
delete aClients;
|
|
|
|
return client;
|
|
} |