mirror of
https://github.com/Jackzmc/sourcemod-plugins.git
synced 2025-05-06 18:03:21 +00:00
772 lines
No EOL
22 KiB
SourcePawn
772 lines
No EOL
22 KiB
SourcePawn
#pragma semicolon 1
|
|
#pragma newdecls required
|
|
|
|
//#define DEBUG
|
|
|
|
#define PLUGIN_VERSION "1.0"
|
|
// #define DEBUG_BLOCKERS 1
|
|
// #define FORCE_ENABLED 1
|
|
// #define DEBUG_LOG_MAPSTART 1
|
|
|
|
#include <sourcemod>
|
|
#include <sdktools>
|
|
#include <left4dhooks>
|
|
#include <sceneprocessor>
|
|
#if defined DEBUG_BLOCKERS
|
|
#include <smlib/effects>
|
|
int g_iLaserIndex;
|
|
#endif
|
|
//#include <sdkhooks>
|
|
|
|
public Plugin myinfo =
|
|
{
|
|
name = "L4D2 Hide & Seek",
|
|
author = "jackzmc",
|
|
description = "",
|
|
version = PLUGIN_VERSION,
|
|
url = ""
|
|
};
|
|
|
|
/*
|
|
script g_ModeScript.DeepPrintTable(g_ModeScript.MutationState)
|
|
{
|
|
MapName = "c6m2_bedlam"
|
|
StartActive = true
|
|
CurrentSlasher = ([1] player)
|
|
MapTime = 480
|
|
StateTick = 464
|
|
LastGiveAdren = 10
|
|
ModeName = "hideandseek"
|
|
Tick = 484
|
|
CurrentStage = 3
|
|
SlasherLastStumbled = 0
|
|
}
|
|
*/
|
|
|
|
#define SOUND_SUSPENSE_1 "custom/suspense1.mp3"
|
|
#define SOUND_SUSPENSE_1_FAST "custom/suspense1fast.mp3"
|
|
|
|
enum GameState {
|
|
State_Unknown = -1,
|
|
State_Startup,
|
|
State_Hiding,
|
|
State_Restarting,
|
|
State_Hunting
|
|
}
|
|
|
|
static char gamemode[32], currentMap[64];
|
|
static bool isEnabled, lateLoaded;
|
|
|
|
static bool isPendingPlay[MAXPLAYERS+1];
|
|
static bool isNavBlockersEnabled = true, isPropsEnabled = true;
|
|
static bool isNearbyPlaying[MAXPLAYERS+1];
|
|
static bool wasThirdPersonVomitted[MAXPLAYERS+1];
|
|
static bool gameOver;
|
|
static int currentSeeker;
|
|
static int currentPlayers = 0;
|
|
|
|
static const float DEFAULT_SCALE[3] = { 5.0, 5.0, 5.0 };
|
|
static float spawnpoint[3];
|
|
static bool hasSpawnpoint;
|
|
|
|
static ArrayList entities;
|
|
static ArrayList inputs;
|
|
|
|
static KeyValues kv;
|
|
static StringMap mapConfigs;
|
|
static StringMap mapInputs;
|
|
static Handle suspenseTimer, thirdPersonTimer;
|
|
|
|
// TODO: Disable weapon drop
|
|
|
|
enum struct EntityConfig {
|
|
float origin[3];
|
|
float rotation[3];
|
|
char type[32];
|
|
char model[64];
|
|
float scale[3];
|
|
}
|
|
|
|
public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max) {
|
|
lateLoaded = late;
|
|
return APLRes_Success;
|
|
}
|
|
|
|
public void OnPluginStart() {
|
|
EngineVersion g_Game = GetEngineVersion();
|
|
if(g_Game != Engine_Left4Dead2) {
|
|
SetFailState("This plugin is for L4D2 only.");
|
|
}
|
|
|
|
kv = new KeyValues("EntityConfig");
|
|
|
|
char sPath[PLATFORM_MAX_PATH];
|
|
BuildPath(Path_SM, sPath, sizeof(sPath), "data/hideandseek.cfg");
|
|
|
|
if(!FileExists(sPath) || !kv.ImportFromFile(sPath)) {
|
|
delete kv;
|
|
SetFailState("Could not load entity config from data/hideandseek.cfg");
|
|
}
|
|
|
|
mapConfigs = new StringMap();
|
|
mapInputs = new StringMap();
|
|
|
|
ConVar hGamemode = FindConVar("mp_gamemode");
|
|
hGamemode.GetString(gamemode, sizeof(gamemode));
|
|
hGamemode.AddChangeHook(Event_GamemodeChange);
|
|
Event_GamemodeChange(hGamemode, gamemode, gamemode);
|
|
|
|
if(lateLoaded) {
|
|
int seeker = GetSlasher();
|
|
if(seeker > -1) {
|
|
currentSeeker = seeker;
|
|
PrintToServer("[H&S] Late load, found seeker %N", currentSeeker);
|
|
}
|
|
if(IsGameSoloOrPlayersLoading()) {
|
|
Handle timer = CreateTimer(10.0, Timer_KeepWaiting, _, TIMER_REPEAT);
|
|
TriggerTimer(timer);
|
|
PrintToServer("[H&S] Late load, player(s) are connecting, or solo. Waiting...");
|
|
SetState(State_Startup);
|
|
}
|
|
}
|
|
|
|
RegConsoleCmd("sm_joingame", Command_Join, "Joins or joins someone else");
|
|
RegAdminCmd("sm_hs_blockers", Command_ToggleBlockers, ADMFLAG_KICK, "Toggle nav blockers");
|
|
RegAdminCmd("sm_hs_props", Command_ToggleProps, ADMFLAG_KICK, "Toggle props");
|
|
RegAdminCmd("sm_hs_clear", Command_Clear, ADMFLAG_KICK, "Toggle props");
|
|
|
|
}
|
|
|
|
public Action OnClientSayCommand(int client, const char[] command, const char[] sArgs) {
|
|
if(isEnabled) {
|
|
if(!StrEqual(command, "say")) { //Is team message
|
|
if(currentSeeker <= 0 || currentSeeker == client) {
|
|
return Plugin_Continue;
|
|
}
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
if(IsClientConnected(i) && IsClientInGame(i) && i != currentSeeker)
|
|
PrintToChat(i, "[Hiders] %N: %s", client, sArgs);
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
}
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
ArrayList LoadConfigForMap(const char[] map) {
|
|
if (kv.JumpToKey(map)) {
|
|
ArrayList configs = new ArrayList(sizeof(EntityConfig));
|
|
ArrayList entInputs = new ArrayList(ByteCountToCells(64));
|
|
if(kv.JumpToKey("ents")) {
|
|
kv.GotoFirstSubKey();
|
|
do {
|
|
EntityConfig config;
|
|
kv.GetVector("origin", config.origin, NULL_VECTOR);
|
|
kv.GetVector("rotation", config.rotation, NULL_VECTOR);
|
|
kv.GetString("type", config.type, sizeof(config.type), "env_physics_blocker");
|
|
kv.GetString("model", config.model, sizeof(config.model), "");
|
|
if(config.model[0] != '\0')
|
|
Format(config.model, sizeof(config.model), "models/%s", config.model);
|
|
kv.GetVector("scale", config.scale, DEFAULT_SCALE);
|
|
|
|
configs.PushArray(config);
|
|
} while (kv.GotoNextKey());
|
|
// Both JumpToKey and GotoFirstSubKey both traverse, i guess, go back
|
|
kv.GoBack();
|
|
kv.GoBack();
|
|
}
|
|
if(kv.JumpToKey("inputs")) {
|
|
// Use 'false' to propery grab
|
|
// "key" "value" in a section
|
|
kv.GotoFirstSubKey(false);
|
|
static char buffer[64];
|
|
do {
|
|
kv.GetSectionName(buffer, sizeof(buffer));
|
|
entInputs.PushString(buffer);
|
|
|
|
kv.GetString(NULL_STRING, buffer, sizeof(buffer));
|
|
entInputs.PushString(buffer);
|
|
} while (kv.GotoNextKey(false));
|
|
kv.GoBack();
|
|
}
|
|
|
|
if(kv.GetVector("spawnpoint", spawnpoint)) {
|
|
hasSpawnpoint = true;
|
|
} else {
|
|
hasSpawnpoint = false;
|
|
}
|
|
// Store ArrayList<EntityConfig> handle
|
|
mapConfigs.SetValue(map, configs);
|
|
// Discard entInputs if unused
|
|
if(entInputs.Length > 0)
|
|
mapInputs.SetValue(map, entInputs);
|
|
else
|
|
delete entInputs;
|
|
return configs;
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public Action Command_Clear(int client, int args) {
|
|
if(args > 0) {
|
|
static char arg[16];
|
|
GetCmdArg(1, arg, sizeof(arg));
|
|
if(StrEqual(arg, "props")) {
|
|
EntFire("hsprop", "kill");
|
|
ReplyToCommand(client, "Removed all custom gamemode props");
|
|
return Plugin_Continue;
|
|
} else if(StrEqual(arg, "blockers")) {
|
|
EntFire("hsblockers", "kill");
|
|
ReplyToCommand(client, "Removed all custom gamemode blockers");
|
|
return Plugin_Continue;
|
|
|
|
}
|
|
}
|
|
ReplyToCommand(client, "Specify 'props' or 'blockers'");
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
public Action Command_ToggleBlockers(int client, int args) {
|
|
if(isNavBlockersEnabled) {
|
|
EntFire("hsblocker", "Disable");
|
|
ReplyToCommand(client, "Disabled all custom gamemode blockers");
|
|
} else {
|
|
EntFire("hsblocker", "Enable");
|
|
ReplyToCommand(client, "Enabled all custom gamemode blockers");
|
|
}
|
|
isNavBlockersEnabled = !isNavBlockersEnabled;
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action Command_ToggleProps(int client, int args) {
|
|
if(isPropsEnabled) {
|
|
EntFire("hsprop", "Disable");
|
|
EntFire("hsprop", "DisableCollision");
|
|
ReplyToCommand(client, "Disabled all custom gamemode props");
|
|
} else {
|
|
EntFire("hsprop", "Enable");
|
|
EntFire("hsprop", "EnableCollision");
|
|
ReplyToCommand(client, "Enabled all custom gamemode props");
|
|
}
|
|
isPropsEnabled = !isPropsEnabled;
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action Command_Join(int client, int args) {
|
|
static float tpLoc[3];
|
|
if(args == 1) {
|
|
GetClientAbsOrigin(client, tpLoc);
|
|
static char arg1[32];
|
|
GetCmdArg(1, arg1, sizeof(arg1));
|
|
char target_name[MAX_TARGET_LENGTH];
|
|
int target_list[MAXPLAYERS], target_count;
|
|
bool tn_is_ml;
|
|
if ((target_count = ProcessTargetString(
|
|
arg1,
|
|
client,
|
|
target_list,
|
|
MAXPLAYERS,
|
|
0,
|
|
target_name,
|
|
sizeof(target_name),
|
|
tn_is_ml)) <= 0)
|
|
{
|
|
/* This function replies to the admin with a failure message */
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
for (int i = 0; i < target_count; i++) {
|
|
int target = target_list[i];
|
|
if(GetClientTeam(target) != 2) {
|
|
ChangeClientTeam(target, 2);
|
|
L4D_RespawnPlayer(target);
|
|
TeleportEntity(target, tpLoc, NULL_VECTOR, NULL_VECTOR);
|
|
isPendingPlay[client] = false;
|
|
CheatCommand(target, "give", "knife");
|
|
}
|
|
}
|
|
ReplyToCommand(client, "Joined %s", target_name);
|
|
} else {
|
|
if(currentSeeker == client) {
|
|
ReplyToCommand(client, "You are already in-game as a seeker.");
|
|
return Plugin_Handled;
|
|
}
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
if(IsClientConnected(i) && IsClientInGame(i) && GetClientTeam(i) == 2 && IsPlayerAlive(i)) {
|
|
GetClientAbsOrigin(i, tpLoc);
|
|
break;
|
|
}
|
|
}
|
|
isPendingPlay[client] = false;
|
|
ChangeClientTeam(client, 2);
|
|
L4D_RespawnPlayer(client);
|
|
TeleportEntity(client, tpLoc, NULL_VECTOR, NULL_VECTOR);
|
|
CheatCommand(client, "give", "knife");
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public void OnClientConnected(int client) {
|
|
if(!IsFakeClient(client)) {
|
|
currentPlayers++;
|
|
if(isEnabled) {
|
|
GameState state = GetState();
|
|
if(currentPlayers == 1 && state == State_Startup) {
|
|
CreateTimer(10.0, Timer_KeepWaiting, _, TIMER_REPEAT);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Action Timer_KeepWaiting(Handle h) {
|
|
L4D2_ExecVScriptCode("g_ModeScript.MutationState.StateTick = -40");
|
|
SetState(State_Startup);
|
|
PrintHintTextToAll("Waiting for players to join...");
|
|
return IsGameSoloOrPlayersLoading() ? Plugin_Continue : Plugin_Stop;
|
|
}
|
|
|
|
public void OnClientDisconnect(int client) {
|
|
if(!IsFakeClient(client))
|
|
currentPlayers--;
|
|
}
|
|
|
|
|
|
public void OnMapStart() {
|
|
if(!isEnabled) return;
|
|
|
|
char map[64];
|
|
GetCurrentMap(map, sizeof(map));
|
|
|
|
if(!StrEqual(currentMap, map)) {
|
|
strcopy(currentMap, sizeof(currentMap), map);
|
|
static char mapTime[16];
|
|
L4D2_GetVScriptOutput("g_ModeScript.MutationState.MapTime", mapTime, sizeof(mapTime));
|
|
PrintToServer("[H&S] Map %s has a time of %s seconds", map, mapTime);
|
|
|
|
|
|
if(!mapConfigs.GetValue(map, entities)) {
|
|
entities = LoadConfigForMap(map);
|
|
}
|
|
mapInputs.GetValue(map, inputs);
|
|
}
|
|
|
|
#if defined DEBUG_BLOCKERS
|
|
g_iLaserIndex = PrecacheModel("materials/sprites/laserbeam.vmt");
|
|
#endif
|
|
PrecacheSound(SOUND_SUSPENSE_1);
|
|
PrecacheSound(SOUND_SUSPENSE_1_FAST);
|
|
AddFileToDownloadsTable("sound/custom/suspense1.mp3");
|
|
AddFileToDownloadsTable("sound/custom/suspense1fast.mp3");
|
|
|
|
if(lateLoaded) {
|
|
lateLoaded = false;
|
|
SetupEntities();
|
|
}
|
|
}
|
|
|
|
public Action L4D2_OnChangeFinaleStage(int &finaleType, const char[] arg) {
|
|
if(isEnabled) {
|
|
finaleType = 0;
|
|
return Plugin_Changed;
|
|
}
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
|
|
public void Event_GamemodeChange(ConVar cvar, const char[] oldValue, const char[] newValue) {
|
|
cvar.GetString(gamemode, sizeof(gamemode));
|
|
#if defined FORCE_ENABLED
|
|
isEnabled = true;
|
|
PrintToServer("[H&S] Force-enabled debug");
|
|
#else
|
|
isEnabled = StrEqual(gamemode, "hideandseek", false);
|
|
#endif
|
|
if(isEnabled) {
|
|
HookEvent("round_end", Event_RoundEnd);
|
|
HookEvent("round_start", Event_RoundStart);
|
|
HookEvent("item_pickup", Event_ItemPickup);
|
|
HookEvent("player_death", Event_PlayerDeath);
|
|
SetupEntities();
|
|
CreateTimer(15.0, Timer_RoundStart);
|
|
if(suspenseTimer != null)
|
|
delete suspenseTimer;
|
|
suspenseTimer = CreateTimer(20.0, Timer_Music, _, TIMER_REPEAT);
|
|
if(thirdPersonTimer != null)
|
|
delete thirdPersonTimer;
|
|
thirdPersonTimer = CreateTimer(1.0, Timer_CheckPlayers, _, TIMER_REPEAT);
|
|
} else if(!lateLoaded) {
|
|
UnhookEvent("round_end", Event_RoundEnd);
|
|
UnhookEvent("round_start", Event_RoundStart);
|
|
UnhookEvent("item_pickup", Event_ItemPickup);
|
|
UnhookEvent("player_death", Event_PlayerDeath);
|
|
delete suspenseTimer;
|
|
delete thirdPersonTimer;
|
|
}
|
|
}
|
|
|
|
|
|
public void Event_PlayerDeath(Event event, const char[] name, bool dontBroadcast) {
|
|
int client = GetClientOfUserId(event.GetInt("userid"));
|
|
if(!gameOver && client && GetClientTeam(client) == 2) {
|
|
int alive = 0;
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
if(IsClientConnected(i) && IsClientInGame(i) && GetClientTeam(i) == 2 && IsPlayerAlive(i)) {
|
|
alive++;
|
|
}
|
|
}
|
|
if(client == currentSeeker) {
|
|
PrintToChatAll("Hiders win!");
|
|
gameOver = true;
|
|
} else {
|
|
if(alive == 2) {
|
|
PrintToChatAll("One hider remains.");
|
|
} else if(alive == 1) {
|
|
// Player died and not seeker, therefore seeker killed em
|
|
if(client != currentSeeker) {
|
|
PrintToChatAll("Seeker %N won!", currentSeeker);
|
|
} else {
|
|
PrintToChatAll("Hiders win! The last survivor was %N!", client);
|
|
|
|
}
|
|
gameOver = true;
|
|
} else if(alive > 2 && client != currentSeeker) {
|
|
PrintToChatAll("%d hiders remain", alive - 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void OnClientPutInServer(int client) {
|
|
if(isEnabled && !IsFakeClient(client)) {
|
|
ChangeClientTeam(client, 1);
|
|
isPendingPlay[client] = true;
|
|
isNearbyPlaying[client] = false;
|
|
PrintToChatAll("%N will play next round", client);
|
|
}
|
|
}
|
|
|
|
public void Event_ItemPickup(Event event, const char[] name, bool dontBroadcast) {
|
|
int client = GetClientOfUserId(event.GetInt("userid"));
|
|
if(client && client > 0 && currentSeeker != client) {
|
|
static char item[32];
|
|
event.GetString("item", item, sizeof(item));
|
|
if(StrEqual(item, "melee")) {
|
|
int entity = GetPlayerWeaponSlot(client, 1);
|
|
GetEntPropString(entity, Prop_Data, "m_strMapSetScriptName", item, sizeof(item));
|
|
if(StrEqual(item, "fireaxe")) {
|
|
gameOver = false;
|
|
currentSeeker = GetSlasher();
|
|
if(currentSeeker != client) {
|
|
PrintToChatAll("[H&S] Seeker does not equal axe-receiver. Possible seeker: %N", client);
|
|
}
|
|
if(currentSeeker == -1) {
|
|
PrintToServer("[H&S] ERROR: GetSlasher() returned -1");
|
|
currentSeeker = client;
|
|
}
|
|
PrintToChatAll("%N is the seeker", currentSeeker);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Event_RoundStart(Event event, const char[] name, bool dontBroadcast) {
|
|
if(hasSpawnpoint) {
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
if(IsClientConnected(i) && IsClientInGame(i)) {
|
|
TeleportEntity(i, spawnpoint, NULL_VECTOR, NULL_VECTOR);
|
|
}
|
|
}
|
|
}
|
|
SetupEntities();
|
|
CreateTimer(15.0, Timer_RoundStart);
|
|
|
|
}
|
|
|
|
public void Event_RoundEnd(Event event, const char[] name, bool dontBroadcast) {
|
|
currentSeeker = 0;
|
|
static float tpLoc[3];
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
if(IsClientConnected(i) && IsClientInGame(i) && GetClientTeam(i) == 2 && IsPlayerAlive(i)) {
|
|
GetClientAbsOrigin(i, tpLoc);
|
|
break;
|
|
}
|
|
}
|
|
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
isNearbyPlaying[i] = false;
|
|
if(isPendingPlay[i]) {
|
|
if(IsClientConnected(i) && IsClientInGame(i)) {
|
|
ChangeClientTeam(i, 2);
|
|
L4D_RespawnPlayer(i);
|
|
TeleportEntity(i, tpLoc, NULL_VECTOR, NULL_VECTOR);
|
|
}
|
|
isPendingPlay[i] = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public Action Timer_CheckPlayers(Handle h) {
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
if(IsClientConnected(i) && IsClientInGame(i) && GetClientTeam(i) == 2 && IsPlayerAlive(i) && i != currentSeeker)
|
|
QueryClientConVar(i, "cam_collision", QueryClientConVarCallback);
|
|
}
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
public void QueryClientConVarCallback(QueryCookie cookie, int client, ConVarQueryResult result, const char[] sCvarName, const char[] bCvarValue) {
|
|
int value = 0;
|
|
if (result == ConVarQuery_Okay && StringToIntEx(bCvarValue, value) > 0 && value == 0) {
|
|
wasThirdPersonVomitted[client] = true;
|
|
PrintHintText(client, "Third person is disabled in this mode");
|
|
// L4D_OnITExpired(client);
|
|
// L4D_CTerrorPlayer_OnVomitedUpon(client, client);
|
|
float random = GetRandomFloat();
|
|
if(random < 0.3)
|
|
PerformScene(client, "Playerareaclear");
|
|
else if(random <= 0.6)
|
|
PerformScene(client, "PlayerLaugh");
|
|
else
|
|
PerformScene(client, "PlayerDeath");
|
|
} else if(wasThirdPersonVomitted[client]) {
|
|
wasThirdPersonVomitted[client] = false;
|
|
L4D_OnITExpired(client);
|
|
}
|
|
}
|
|
|
|
public Action Timer_Music(Handle h) {
|
|
static float seekerLoc[3];
|
|
static float playerLoc[3];
|
|
if(currentSeeker > 0) {
|
|
GetClientAbsOrigin(currentSeeker, seekerLoc);
|
|
GameState state = GetState();
|
|
if(state == State_Hunting) {
|
|
EmitSoundToClient(currentSeeker, SOUND_SUSPENSE_1, currentSeeker, SNDCHAN_AUTO, SNDLEVEL_NORMAL, SND_CHANGEPITCH, 0.2, 90, currentSeeker, seekerLoc, seekerLoc, true);
|
|
}
|
|
}
|
|
int playerCount;
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
if(IsClientConnected(i) && IsClientInGame(i) && i != currentSeeker) {
|
|
|
|
playerCount++;
|
|
GetClientAbsOrigin(i, playerLoc);
|
|
float dist = GetVectorDistance(seekerLoc, playerLoc, true);
|
|
if(dist <= 250000.0) {
|
|
StopSound(i, SNDCHAN_AUTO, SOUND_SUSPENSE_1);
|
|
EmitSoundToClient(i, SOUND_SUSPENSE_1_FAST, i, SNDCHAN_AUTO, SNDLEVEL_NORMAL, SND_CHANGEPITCH, 1.0, 100, currentSeeker, seekerLoc, playerLoc, true);
|
|
isNearbyPlaying[i] = true;
|
|
} else if(dist <= 1000000.0) {
|
|
EmitSoundToClient(i, SOUND_SUSPENSE_1, i, SNDCHAN_AUTO, SNDLEVEL_NORMAL, SND_CHANGEPITCH, 0.2, 90, currentSeeker, seekerLoc, playerLoc, true);
|
|
isNearbyPlaying[i] = true;
|
|
StopSound(i, SNDCHAN_AUTO, SOUND_SUSPENSE_1_FAST);
|
|
} else if(isNearbyPlaying[i]) {
|
|
isNearbyPlaying[i] = false;
|
|
StopSound(i, SNDCHAN_AUTO, SOUND_SUSPENSE_1_FAST);
|
|
StopSound(i, SNDCHAN_AUTO, SOUND_SUSPENSE_1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return Plugin_Continue;
|
|
}
|
|
public Action Timer_RoundStart(Handle h) {
|
|
CreateTimer(0.1, Timer_CheckWeapons);
|
|
CreateTimer(10.0, Timer_CheckWeapons);
|
|
int entity = INVALID_ENT_REFERENCE;
|
|
while ((entity = FindEntityByClassname(entity, "func_button")) != INVALID_ENT_REFERENCE) {
|
|
AcceptEntityInput(entity, "Press");
|
|
}
|
|
entity = INVALID_ENT_REFERENCE;
|
|
while ((entity = FindEntityByClassname(entity, "func_brush")) != INVALID_ENT_REFERENCE) {
|
|
AcceptEntityInput(entity, "Kll");
|
|
}
|
|
PrintToServer("[H&S] Pressing buttons");
|
|
return Plugin_Continue;
|
|
}
|
|
public Action Timer_CheckWeapons(Handle h) {
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
if(IsClientConnected(i) && IsClientInGame(i) && GetClientTeam(i) == 2 && IsPlayerAlive(i)) {
|
|
// Check if has no melee:
|
|
if(GetPlayerWeaponSlot(i, 1) == -1) {
|
|
CheatCommand(i, "give", "knife");
|
|
}
|
|
int item = GetPlayerWeaponSlot(i, 0);
|
|
if(item != -1) AcceptEntityInput(item, "Kill");
|
|
}
|
|
}
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
stock int CreateEnvBlockerBox(const float pos[3], bool enabled = true) {
|
|
int entity = CreateEntityByName("env_physics_blocker");
|
|
DispatchKeyValue(entity, "targetname", "hsblocker");
|
|
DispatchKeyValue(entity, "initialstate", "1");
|
|
DispatchKeyValue(entity, "BlockType", "0");
|
|
TeleportEntity(entity, pos, NULL_VECTOR, NULL_VECTOR);
|
|
DispatchSpawn(entity);
|
|
if(enabled)
|
|
AcceptEntityInput(entity, "Enable");
|
|
return entity;
|
|
}
|
|
|
|
stock int CreateEnvBlockerScaled(const char[] entClass, const float pos[3], const float scale[3] = { 5.0, 5.0, 5.0 }, bool enabled = true) {
|
|
int entity = CreateEntityByName(entClass);
|
|
DispatchKeyValue(entity, "targetname", "hsblocker");
|
|
DispatchKeyValue(entity, "initialstate", "1");
|
|
DispatchKeyValue(entity, "BlockType", "0");
|
|
static float mins[3];
|
|
mins = scale;
|
|
NegateVector(mins);
|
|
DispatchKeyValueVector(entity, "boxmins", mins);
|
|
DispatchKeyValueVector(entity, "boxmaxs", scale);
|
|
DispatchKeyValueVector(entity, "mins", mins);
|
|
DispatchKeyValueVector(entity, "maxs", scale);
|
|
|
|
TeleportEntity(entity, pos, NULL_VECTOR, NULL_VECTOR);
|
|
DispatchSpawn(entity);
|
|
SetEntPropVector(entity, Prop_Send, "m_vecMaxs", scale);
|
|
SetEntPropVector(entity, Prop_Send, "m_vecMins", mins);
|
|
if(enabled)
|
|
AcceptEntityInput(entity, "Enable");
|
|
#if defined DEBUG_BLOCKERS
|
|
Effect_DrawBeamBoxRotatableToAll(pos, mins, scale, NULL_VECTOR, g_iLaserIndex, 0, 0, 0, 150.0, 0.1, 0.1, 0, 0.0, {0, 255, 0, 255}, 0);
|
|
#endif
|
|
#if defined DEBUG_LOG_MAPSTART
|
|
PrintToServer("spawn blocker scaled %.1f %.1f %.1f scale [%.0f %.0f %.0f]", pos[0], pos[1], pos[2], scale[0], scale[1], scale[2]);
|
|
#endif
|
|
return entity;
|
|
}
|
|
|
|
stock int CreatePropDynamic(const char[] model, const float pos[3], const float ang[3]) {
|
|
return CreateProp("prop_dynamic", model, pos, ang);
|
|
}
|
|
|
|
stock int CreatePropPhysics(const char[] model, const float pos[3], const float ang[3]) {
|
|
return CreateProp("prop_physics", model, pos, ang);
|
|
}
|
|
|
|
stock int CreateProp(const char[] entClass, const char[] model, const float pos[3], const float ang[3]) {
|
|
int entity = CreateEntityByName(entClass);
|
|
DispatchKeyValue(entity, "model", model);
|
|
DispatchKeyValue(entity, "solid", "6");
|
|
DispatchKeyValue(entity, "targetname", "hsprop");
|
|
DispatchKeyValue(entity, "disableshadows", "1");
|
|
TeleportEntity(entity, pos, ang, NULL_VECTOR);
|
|
DispatchSpawn(entity);
|
|
#if defined DEBUG_LOG_MAPSTART
|
|
PrintToServer("spawn prop %.1f %.1f %.1f model %s", pos[0], pos[1], pos[2], model[7]);
|
|
#endif
|
|
return entity;
|
|
}
|
|
|
|
stock void CheatCommand(int client, const char[] command, const char[] argument1) {
|
|
int userFlags = GetUserFlagBits(client);
|
|
SetUserFlagBits(client, ADMFLAG_ROOT);
|
|
int flags = GetCommandFlags(command);
|
|
SetCommandFlags(command, flags & ~FCVAR_CHEAT);
|
|
FakeClientCommand(client, "%s %s", command, argument1);
|
|
SetCommandFlags(command, flags);
|
|
SetUserFlagBits(client, userFlags);
|
|
}
|
|
|
|
stock void EntFire(const char[] name, const char[] input) {
|
|
static char targetname[64];
|
|
for(int i = MAXPLAYERS + 1; i <= GetMaxEntities(); i++) {
|
|
if(IsValidEntity(i) && IsValidEdict(i)) {
|
|
GetEntPropString(i, Prop_Data, "m_iName", targetname, sizeof(targetname));
|
|
if(StrEqual(targetname, name)) {
|
|
AcceptEntityInput(i, input);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SetupEntities() {
|
|
if(entities != null) {
|
|
PrintToServer("[H&S] Found map entity config, deploying %d entities", entities.Length);
|
|
for(int i = 0; i < entities.Length; i++) {
|
|
EntityConfig config;
|
|
entities.GetArray(i, config);
|
|
|
|
if(config.model[0] != '\0') PrecacheModel(config.model);
|
|
|
|
if(StrEqual(config.type, "env_physics_blocker")) {
|
|
CreateEnvBlockerScaled(config.type, config.origin, config.scale, isNavBlockersEnabled);
|
|
} else {
|
|
CreateProp(config.type, config.model, config.origin, config.rotation);
|
|
}
|
|
}
|
|
|
|
static char key[64];
|
|
static char value[64];
|
|
if(inputs != null) {
|
|
for(int i = 0; i < inputs.Length - 1; i += 2) {
|
|
inputs.GetString(i, key, sizeof(key));
|
|
inputs.GetString(i + 1, value, sizeof(value));
|
|
EntFire(key, value);
|
|
#if defined DEBUG_LOG_MAPSTART
|
|
PrintToServer("[H&S] EntFire: %s %s", key, value);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|
|
|
|
GameState GetState() {
|
|
if(!isEnabled) return State_Unknown;
|
|
static char buffer[4];
|
|
L4D2_GetVScriptOutput("g_ModeScript.MutationState.CurrentStage", buffer, sizeof(buffer));
|
|
int stage = -1;
|
|
if(StringToIntEx(buffer, stage) > 0) {
|
|
return view_as<GameState>(stage);
|
|
} else {
|
|
return State_Unknown;
|
|
}
|
|
}
|
|
|
|
int GetSlasher() {
|
|
if(!isEnabled) return -1;
|
|
static char buffer[8];
|
|
L4D2_GetVScriptOutput("g_ModeScript.MutationState.CurrentSlasher ? g_ModeScript.MutationState.CurrentSlasher.GetPlayerUserId() : -1", buffer, sizeof(buffer));
|
|
int uid = StringToInt(buffer);
|
|
if(uid > 0) {
|
|
return GetClientOfUserId(uid);
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int GetTick() {
|
|
if(!isEnabled) return -1;
|
|
static char buffer[4];
|
|
L4D2_GetVScriptOutput("g_ModeScript.MutationState.StateTick", buffer, sizeof(buffer));
|
|
int value = -1;
|
|
if(StringToIntEx(buffer, value) > 0) {
|
|
return value;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
bool SetState(GameState state) {
|
|
if(!isEnabled) return false;
|
|
static char buffer[64];
|
|
Format(buffer, sizeof(buffer), "g_ModeScript.MutationState.CurrentStage = %d", view_as<int>(state));
|
|
return L4D2_ExecVScriptCode(buffer);
|
|
}
|
|
|
|
bool IsGameSoloOrPlayersLoading() {
|
|
int connecting, ingame;
|
|
for(int i = 1; i <= MaxClients; i++) {
|
|
if(IsClientConnected(i)) {
|
|
if(IsClientInGame(i))
|
|
ingame++;
|
|
else
|
|
connecting++;
|
|
}
|
|
}
|
|
return connecting > 0 || ingame == 1;
|
|
} |