2483 lines
65 KiB
SourcePawn
2483 lines
65 KiB
SourcePawn
#pragma semicolon 1
|
|
|
|
#include <sourcemod>
|
|
#include <sdktools>
|
|
#include <sdkhooks>
|
|
#include <tf2_stocks>
|
|
#include <morecolors>
|
|
#include <autoexecconfig>
|
|
#include <boss_spawns>
|
|
|
|
#define PLUGIN_NAME "[TF2] Boss Spawns"
|
|
#define PLUGIN_VERSION "1.1.0"
|
|
#define PLUGIN_TAG "[BossSpawns]"
|
|
|
|
#define MAX_ENTITY_LIMIT 4096
|
|
|
|
Handle g_hConVars[7];
|
|
char g_sPluginTag[256];
|
|
|
|
Float g_fPositionCache[3];
|
|
Float g_fBoundMin;
|
|
Float g_fBoundMax;
|
|
|
|
char g_sBoundMin[32];
|
|
char g_sBoundMax[32];
|
|
|
|
int g_iTrackEntity = -1;
|
|
int g_iHealthBar = -1;
|
|
|
|
bool g_bIsSkeletonKingSpawning;
|
|
int g_iSkeletonKingSpawner = -1;
|
|
|
|
bool g_bInvisible[MAX_ENTITY_LIMIT + 1];
|
|
int g_bMapStarted;
|
|
|
|
char g_sSkeletonKingSounds[9][PLATFORM_MAX_PATH] =
|
|
{
|
|
"vo/halloween_mann_brothers/sf13_blutarch_enemies10.mp3",
|
|
"vo/halloween_mann_brothers/sf13_blutarch_enemies11.mp3",
|
|
"vo/halloween_mann_brothers/sf13_blutarch_enemies12.mp3",
|
|
"vo/halloween_mann_brothers/sf13_blutarch_enemies13.mp3",
|
|
"vo/halloween_mann_brothers/sf13_blutarch_enemies13.mp3",
|
|
"vo/halloween_mann_brothers/sf13_redmond_enemies05.mp3",
|
|
"vo/halloween_mann_brothers/sf13_redmond_enemies06.mp3",
|
|
"vo/halloween_mann_brothers/sf13_redmond_enemies07.mp3",
|
|
"vo/halloween_mann_brothers/sf13_redmond_enemies08.mp3"
|
|
};
|
|
|
|
char g_sMerasmusSounds[13][PLATFORM_MAX_PATH] =
|
|
{
|
|
"vo/halloween_merasmus/sf12_hide_idles_demo01.mp3",
|
|
"vo/halloween_merasmus/sf12_magic_backfire06.mp3",
|
|
"vo/halloween_merasmus/sf12_magic_backfire07.mp3",
|
|
"vo/halloween_merasmus/sf12_magic_backfire23.mp3",
|
|
"vo/halloween_merasmus/sf12_magic_backfire29.mp3",
|
|
"vo/halloween_merasmus/sf12_magicwords11.mp3",
|
|
"misc/halloween/merasmus_appear.mp3",
|
|
"misc/halloween/merasmus_death.mp3",
|
|
"misc/halloween/merasmus_disappear.mp3",
|
|
"misc/halloween/merasmus_float.mp3",
|
|
"misc/halloween/merasmus_hiding_explode.mp3",
|
|
"misc/halloween/merasmus_spell.mp3",
|
|
"misc/halloween/merasmus_stun.mp3"
|
|
};
|
|
|
|
char g_sHorsemannSounds[6][PLATFORM_MAX_PATH] =
|
|
{
|
|
"ui/halloween_boss_summon_rumble.mp3",
|
|
"vo/halloween_boss/knight_dying.mp3",
|
|
"vo/halloween_boss/knight_spawn.mp3",
|
|
"vo/halloween_boss/knight_alert.mp3",
|
|
"weapons/halloween_boss/knight_axe_hit.mp3",
|
|
"weapons/halloween_boss/knight_axe_miss.mp3"
|
|
};
|
|
|
|
char g_sMonoculusSounds[15][PLATFORM_MAX_PATH] =
|
|
{
|
|
"vo/halloween_eyeball/eyeball_biglaugh01.mp3",
|
|
"vo/halloween_eyeball/eyeball_boss_pain01.mp3",
|
|
"vo/halloween_eyeball/eyeball_teleport01.mp3",
|
|
"ui/halloween_boss_summon_rumble.mp3",
|
|
"ui/halloween_boss_chosen_it.mp3",
|
|
"ui/halloween_boss_defeated_fx.mp3",
|
|
"ui/halloween_boss_defeated.mp3",
|
|
"ui/halloween_boss_player_becomes_it.mp3",
|
|
"ui/halloween_boss_summoned_fx.mp3",
|
|
"ui/halloween_boss_summoned.mp3",
|
|
"ui/halloween_boss_tagged_other_it.mp3",
|
|
"ui/halloween_boss_escape.mp3",
|
|
"ui/halloween_boss_escape_sixty.mp3",
|
|
"ui/halloween_boss_escape_ten.mp3",
|
|
"ui/halloween_boss_tagged_other_it.mp3"
|
|
};
|
|
|
|
/*char g_sGhostSounds[16][PLATFORM_MAX_PATH] =
|
|
{
|
|
"vo/halloween_moan1.mp3",
|
|
"vo/halloween_moan2.mp3",
|
|
"vo/halloween_moan3.mp3",
|
|
"vo/halloween_moan4.mp3",
|
|
"vo/halloween_boo1.mp3",
|
|
"vo/halloween_boo2.mp3",
|
|
"vo/halloween_boo3.mp3",
|
|
"vo/halloween_boo4.mp3",
|
|
"vo/halloween_boo5.mp3",
|
|
"vo/halloween_boo6.mp3",
|
|
"vo/halloween_boo7.mp3",
|
|
"vo/halloween_haunted1.mp3",
|
|
"vo/halloween_haunted2.mp3",
|
|
"vo/halloween_haunted3.mp3",
|
|
"vo/halloween_haunted4.mp3",
|
|
"vo/halloween_haunted5.mp3"
|
|
};*/
|
|
|
|
char g_sGhostMoanSounds[4][PLATFORM_MAX_PATH] =
|
|
{
|
|
"vo/halloween_moan1.mp3",
|
|
"vo/halloween_moan2.mp3",
|
|
"vo/halloween_moan3.mp3",
|
|
"vo/halloween_moan4.mp3"
|
|
};
|
|
|
|
char g_sGhostBooSounds[7][PLATFORM_MAX_PATH] =
|
|
{
|
|
"vo/halloween_boo1.mp3",
|
|
"vo/halloween_boo2.mp3",
|
|
"vo/halloween_boo3.mp3",
|
|
"vo/halloween_boo4.mp3",
|
|
"vo/halloween_boo5.mp3",
|
|
"vo/halloween_boo6.mp3",
|
|
"vo/halloween_boo7.mp3"
|
|
};
|
|
|
|
char g_sGhostEffectSounds[5][PLATFORM_MAX_PATH] =
|
|
{
|
|
"vo/halloween_haunted1.mp3",
|
|
"vo/halloween_haunted2.mp3",
|
|
"vo/halloween_haunted3.mp3",
|
|
"vo/halloween_haunted4.mp3",
|
|
"vo/halloween_haunted5.mp3"
|
|
};
|
|
|
|
public Plugin myinfo =
|
|
{
|
|
name = PLUGIN_NAME,
|
|
author = "abrandnewday, reworked by Keith Warren (Drixevel)",
|
|
description = "Simple plugin to allow server operators to spawn bosses.",
|
|
version = PLUGIN_VERSION,
|
|
url = "http://www.drixevel.com/"
|
|
}
|
|
|
|
public APLRes AskPluginLoad2(Handle myself, bool late, char[] error, int err_max)
|
|
{
|
|
if (GetEngineVersion() != Engine_TF2)
|
|
{
|
|
Format(error, err_max, "This plugin only works for Team Fortress 2.");
|
|
return APLRes_Failure;
|
|
}
|
|
|
|
CreateNative("TF2_SpawnHatman", Native_SpawnHatman);
|
|
CreateNative("TF2_SpawnEyeboss", Native_SpawnEyeboss);
|
|
CreateNative("TF2_SpawnMerasmus", Native_SpawnMerasmus);
|
|
CreateNative("TF2_SpawnSkeleton", Native_SpawnSkeleton);
|
|
CreateNative("TF2_SpawnSkeletonKing", Native_SpawnSkeletonKing);
|
|
CreateNative("TF2_SpawnGhost", Native_SpawnGhost);
|
|
|
|
RegPluginLibrary("boss_spawns");
|
|
return APLRes_Success;
|
|
}
|
|
|
|
public void OnPluginStart()
|
|
{
|
|
LoadTranslations("common.phrases");
|
|
LoadTranslations("BossSpawns.phrases");
|
|
|
|
g_hConVars[0] = CreateConVar("sm_bossspawns_version", PLUGIN_VERSION, PLUGIN_NAME, FCVAR_REPLICATED|FCVAR_NOTIFY|FCVAR_PLUGIN|FCVAR_SPONLY|FCVAR_DONTRECORD);
|
|
g_hConVars[1] = CreateConVar("sm_bossspawns_status", "1", "Status of the plugin: (1 = on, 0 = off)", FCVAR_PLUGIN, true, 0.0, true, 1.0);
|
|
g_hConVars[2] = CreateConVar("sm_bossspawns_hitboxes", "1", "Enable hitbox scaling on spawned bosses: (1 = on, 0 = off)", FCVAR_PLUGIN, true, 0.0, true, 1.0);
|
|
g_hConVars[3] = CreateConVar("sm_bossspawns_bounds", "0.1, 5.0", "Lower (optional) and upper bounds for resizing, separated with a comma.", FCVAR_PLUGIN);
|
|
g_hConVars[4] = CreateConVar("sm_bossspawns_spawnsounds", "1", "Enable spawn sounds for bosses: (1 = on, 0 = off)", FCVAR_PLUGIN, true, 0.0, true, 1.0);
|
|
g_hConVars[5] = CreateConVar("sm_bossspawns_chattag", "{gold}[BossSpawns]", "Tag for plugin to use: (Uses color tags, max 64 characters)");
|
|
g_hConVars[6] = CreateConVar("sm_bossspawns_verbose", "1", "Enable spawn verbose messages: (1 = on, 0 = off)", FCVAR_PLUGIN, true, 0.0, true, 1.0);
|
|
|
|
AutoExecConfig();
|
|
|
|
for (new i = 0; i < sizeof(g_hConVars); i++)
|
|
{
|
|
HookConVarChange(g_hConVars[i], HandleCvars);
|
|
}
|
|
|
|
RegAdminCmd("sm_hatman", Command_SpawnHatman, ADMFLAG_GENERIC, "Spawns the Horsemann - Usage: sm_hatman <scale> <glow 0/1>");
|
|
RegAdminCmd("sm_eyeboss", Command_SpawnEyeBoss, ADMFLAG_GENERIC, "Spawns the MONOCULUS! - Usage: sm_eyeboss <scale> <glow 0/1>");
|
|
RegAdminCmd("sm_eyeboss_red", Command_SpawnEyeBossRED, ADMFLAG_GENERIC, "Spawns the RED Spectral MONOCULUS! - Usage: sm_eyeboss_red <scale> <glow 0/1>");
|
|
RegAdminCmd("sm_eyeboss_blue", Command_SpawnEyeBossBLU, ADMFLAG_GENERIC, "Spawns the BLU Spectral MONOCULUS! - Usage: sm_eyeboss_blue <scale> <glow 0/1>");
|
|
RegAdminCmd("sm_merasmus", Command_SpawnMerasmus, ADMFLAG_GENERIC, "Spawns Merasmus - Usage: sm_merasmus <scale> <glow 0/1>");
|
|
RegAdminCmd("sm_skelegreen", Command_SpawnGreenSkeleton, ADMFLAG_GENERIC, "Spawns a Green Skeleton - Usage: sm_skelegreen <scale> <glow 0/1>");
|
|
RegAdminCmd("sm_skelered", Command_SpawnREDSkeleton, ADMFLAG_GENERIC, "Spawns a RED Skeleton - Usage: sm_skelered <scale> <glow 0/1>");
|
|
RegAdminCmd("sm_skeleblue", Command_SpawnBLUSkeleton, ADMFLAG_GENERIC, "Spawns a BLU Skeleton - Usage: sm_skeleblue <scale> <glow 0/1>");
|
|
RegAdminCmd("sm_skeleking", Command_SpawnSkeletonKing, ADMFLAG_GENERIC, "Spawns a Skeleton King - Usage: sm_skeleking <scale> <glow 0/1>");
|
|
RegAdminCmd("sm_ghost", Command_SpawnGhost, ADMFLAG_GENERIC, "Spawns a Ghost - Usage: sm_ghost <scale> <glow 0/1>");
|
|
|
|
RegAdminCmd("sm_slayhatman", Command_SlayHatman, ADMFLAG_GENERIC, "Slays all Horsemenn on the map - Usage: sm_slayhatman");
|
|
RegAdminCmd("sm_slayeyeboss", Command_SlayEyeBoss, ADMFLAG_GENERIC, "Slays all MONOCULUS! on the map - Usage: sm_slayeyeboss");
|
|
RegAdminCmd("sm_slayeyeboss_red", Command_SlayEyeBossRED, ADMFLAG_GENERIC, "Slays all RED Spectral MONOCULUS! on the map - Usage: sm_slayeyeboss_red");
|
|
RegAdminCmd("sm_slayeyeboss_blue", Command_SlayEyeBossBLU, ADMFLAG_GENERIC, "Slays all BLU Spectral MONOCULUS! on the map - Usage: sm_slayeyeboss_blue");
|
|
RegAdminCmd("sm_slaymerasmus", Command_SlayMerasmus, ADMFLAG_GENERIC, "Slays all Merasmus on the map - Usage: sm_slaymerasmus");
|
|
RegAdminCmd("sm_slayskelegreen", Command_SlayGreenSkeleton, ADMFLAG_GENERIC, "Slays all Green Skeletons on the map - Usage: sm_slayskelegreen");
|
|
RegAdminCmd("sm_slayskelered", Command_SlayREDSkeleton, ADMFLAG_GENERIC, "Slays all RED Skeletons on the map - Usage: sm_slayskelered");
|
|
RegAdminCmd("sm_slayskeleblue", Command_SlayBLUSkeleton, ADMFLAG_GENERIC, "Slays all BLU Skeletons on the map - Usage: sm_slayskeleblue");
|
|
RegAdminCmd("sm_slayskeleking", Command_SlaySkeletonKing, ADMFLAG_GENERIC, "Slays all Skeleton Kings on the map - Usage: sm_slayskeleking");
|
|
RegAdminCmd("sm_slayghost", Command_SlayGhost, ADMFLAG_GENERIC, "Slays all Ghosts on the map - Usage: sm_slayghost");
|
|
}
|
|
|
|
public void OnConfigsExecuted()
|
|
{
|
|
PrintToServer("%s %t", PLUGIN_TAG, "console initializing");
|
|
|
|
ParseConVarToLimits(g_hConVars[3], g_sBoundMin, sizeof(g_sBoundMin), g_fBoundMin, g_sBoundMax, sizeof(g_sBoundMax), g_fBoundMax);
|
|
GetConVarString(g_hConVars[5], g_sPluginTag, sizeof(g_sPluginTag));
|
|
|
|
if (GetConVarBool(g_hConVars[1]))
|
|
{
|
|
PrintToServer("%s %t", PLUGIN_TAG, "console initialized");
|
|
PrintToServer("%s %t", PLUGIN_TAG, "console hitbox status", GetConVarBool(g_hConVars[2]) ? "ON" : "OFF");
|
|
}
|
|
}
|
|
|
|
public HandleCvars(Handle:cvar, const String:oldValue[], const String:newValue[])
|
|
{
|
|
new iNewValue = StringToInt(newValue);
|
|
|
|
if (cvar == g_hConVars[0])
|
|
{
|
|
Setg_hConVarstring(g_hConVars[0], PLUGIN_VERSION);
|
|
}
|
|
else if (cvar == g_hConVars[3])
|
|
{
|
|
ParseConVarToLimits(g_hConVars[3], g_sBoundMin, sizeof(g_sBoundMin), g_fBoundMin, g_sBoundMax, sizeof(g_sBoundMax), g_fBoundMax);
|
|
}
|
|
else if (cvar == g_hConVars[5])
|
|
{
|
|
strcopy(g_sPluginTag, sizeof(g_sPluginTag), newValue);
|
|
}
|
|
}
|
|
|
|
public void OnPluginEnd()
|
|
{
|
|
new entity;
|
|
|
|
while ((entity = FindEntityByClassname(entity, "headless_hatman")) != !IsValidEntity(entity))
|
|
{
|
|
Handle hEvent = CreateEvent("pumpkin_lord_killed", true);
|
|
FireEvent(hEvent);
|
|
AcceptEntityInput(entity, "Kill");
|
|
}
|
|
|
|
while ((entity = FindEntityByClassname(entity, "eyeball_boss")) != !IsValidEntity(entity))
|
|
{
|
|
Handle hEvent = CreateEvent("eyeball_boss_killed", true);
|
|
FireEvent(hEvent);
|
|
AcceptEntityInput(entity, "Kill");
|
|
}
|
|
|
|
while ((entity = FindEntityByClassname(entity, "merasmus")) != !IsValidEntity(entity))
|
|
{
|
|
Handle hEvent = CreateEvent("merasmus_killed", true);
|
|
FireEvent(hEvent);
|
|
AcceptEntityInput(entity, "Kill");
|
|
}
|
|
|
|
while ((entity = FindEntityByClassname(entity, "tf_zombie")) != !IsValidEntity(entity)) //Kills Skeleton King as well.
|
|
{
|
|
AcceptEntityInput(entity, "Kill");
|
|
}
|
|
|
|
while ((entity = FindEntityByClassname(entity, "simple_bot")) != !IsValidEntity(entity))
|
|
{
|
|
char sName[32];
|
|
GetEntPropString(entity, Prop_Data, "m_iName", sName, sizeof(sName));
|
|
|
|
if (StrEqual(sName, "SpawnedGhost"))
|
|
{
|
|
AcceptEntityInput(entity, "Kill");
|
|
}
|
|
}
|
|
}
|
|
|
|
void ParseConVarToLimits(Handle hConVar, char[] sMinString, int iMinLength, Float& fMin, char[] sMaxString, int iMaxLength, Float& fMax)
|
|
{
|
|
int iSplitResult;
|
|
|
|
char szBounds[256];
|
|
GetConVarString(hConVar, szBounds, sizeof(szBounds));
|
|
|
|
if ((iSplitResult = SplitString(szBounds, ",", sMinString, iMinLength)) != -1 && (fMin = StringToFloat(sMinString)) >= 0.0)
|
|
{
|
|
TrimString(sMinString);
|
|
strcopy(sMaxString, iMaxLength, szBounds[iSplitResult]);
|
|
}
|
|
else
|
|
{
|
|
strcopy(sMinString, iMinLength, "0.0");
|
|
fMin = 0.0;
|
|
strcopy(sMaxString, iMaxLength, szBounds);
|
|
}
|
|
|
|
TrimString(szMaxString);
|
|
fMax = StringToFloat(szMaxString);
|
|
|
|
int iMarkInMin = FindCharInString(sMinString, '.'), iMarkInMax = FindCharInString(sMaxString, '.');
|
|
Format(sMinString, iMinLength, "%s%s%s", (iMarkInMin == 0 ? "0" : ""), sMinString, (iMarkInMin == -1 ? ".0" : (iMarkInMin == (strlen(sMinString) - 1) ? "0" : "")));
|
|
Format(sMaxString, iMaxLength, "%s%s%s", (iMarkInMax == 0 ? "0" : ""), sMaxString, (iMarkInMax == -1 ? ".0" : (iMarkInMax == (strlen(sMaxString) - 1) ? "0" : "")));
|
|
|
|
if (fMin > fMax)
|
|
{
|
|
Float fTemp = fMax;
|
|
fMax = fMin;
|
|
fMin = fTemp;
|
|
}
|
|
}
|
|
|
|
/***************************************************/
|
|
//Spawn Commands
|
|
|
|
public Action:Command_SpawnHatman(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = 1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("headless_hatman", "", fScale, 0, 10.0, "0", bGlow ? true : false))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn the {unusual}Horseless Headless Horsemann!{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{mediumorchid}Horseless Headless Horsemann");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SpawnEyeBoss(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = 1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("eyeball_boss", "", fScale, 5, 50.0, "0", bGlow ? true : false))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn {unusual}MONOCULUS!{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{mythical}Monoculus");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SpawnEyeBossRED(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = 1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("eyeball_boss", "", fScale, 2, -25.0, "0", bGlow ? true : false))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn {red}RED Spectral MONOCULUS!{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{orangered}Red Spectral Monoculus");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SpawnEyeBossBLU(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = 1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("eyeball_boss", "", fScale, 1, -25.0, "0", bGlow ? true : false))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn {blue}BLU Spectral MONOCULUS!{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{cyan}Blue Spectral Monoculus");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SpawnMerasmus(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = 1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("merasmus", "", fScale, 0, 0.0, "0", bGlow ? true : false))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn {unusual}Merasmus!{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{limegreen}Merasmus");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SpawnGreenSkeleton(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = -1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("tf_zombie", "", fScale, 0, 0.0, "2", bGlow ? true : false))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn the {community}Green Skeleton{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{green}Green Skeleton");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SpawnREDSkeleton(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s%t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = -1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("tf_zombie", "", fScale, 2, 0.0, "0", bGlow ? true : false))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn the {red}RED Skeleton{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{red}Red Skeleton");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SpawnBLUSkeleton(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = -1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("tf_zombie", "", fScale, 3, 0.0, "1", bGlow ? true : false))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn the {blue}BLU Skeleton{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{blue}Blue Skeleton");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SpawnSkeletonKing(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = -1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("tf_zombie_spawner", "", fScale, 0, 0.0, "0", bGlow ? true : false, true))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn the {unusual}Skeleton King{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{unusual}Skeleton King");
|
|
|
|
if (GetConVarBool(g_hConVars[4]))
|
|
{
|
|
EmitSoundToAll(g_sSkeletonKingSounds[GetRandomInt(0, 8)], client, _, _, _, 1.0);
|
|
}
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SpawnGhost(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!IsClientInGame(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "Command is in-game only");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:szScale[5] = "0.0";
|
|
new String:sGlow[5] = "0";
|
|
|
|
new Float:fScale = -1.0;
|
|
new bool:bGlow = false;
|
|
|
|
if (args > 0)
|
|
{
|
|
GetCmdArg(1, szScale, sizeof(szScale));
|
|
TrimString(szScale);
|
|
|
|
GetCmdArg(2, sGlow, sizeof(sGlow));
|
|
TrimString(sGlow);
|
|
|
|
fScale = StringToFloat(szScale);
|
|
|
|
if (fScale <= 0.0)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size specified");
|
|
return Plugin_Handled;
|
|
}
|
|
else if (fScale < g_fBoundMin || fScale > g_fBoundMax)
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid size out of bounds", g_sBoundMin, g_sBoundMax);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (StrEqual(sGlow, "1"))
|
|
{
|
|
bGlow = true;
|
|
}
|
|
}
|
|
|
|
if (!SetTeleportEndPoint(client))
|
|
{
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "reply invalid spawn point");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (CheckEntityLimit(client))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if (!SpawnBoss("simple_bot", "SpawnedGhost", fScale, 0, 0.0, "0", bGlow ? true : false, false, true))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn a {unusual}Ghost{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, "{azure}Ghost");
|
|
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
ProcessActivity(client, const String:sBossName[])
|
|
{
|
|
if (GetConVarBool(g_hConVars[6]))
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, " %t", "spawned boss prefix message", sBossName);
|
|
CReplyToCommand(client, "%s %t", g_sPluginTag, "spawned boss prefix reply", sBossName);
|
|
}
|
|
|
|
LogAction(client, -1, "'%L' %t", client, "spawned boss prefix message", sBossName);
|
|
}
|
|
|
|
/***************************************************/
|
|
//Spawn Function
|
|
|
|
bool:SpawnBoss(const String:sEntityClass[], const String:sEntityName[], Float:scale = -1.0, team = 0, Float:offset = 0.0, String:skin[1] = "-1", bool:glow = false, bool:SkeletonKing = false, bool:Ghost = false)
|
|
{
|
|
new entity = CreateEntityByName(sEntityClass);
|
|
|
|
if (IsValidEntity(entity))
|
|
{
|
|
if (strlen(sEntityName) != 0)
|
|
{
|
|
DispatchKeyValue(entity, "targetname", sEntityName);
|
|
}
|
|
|
|
DispatchSpawn(entity);
|
|
|
|
if (scale != -1.0)
|
|
{
|
|
SetEntPropFloat(entity, Prop_Send, "m_flModelScale", scale);
|
|
|
|
if (GetConVarBool(g_hConVars[2]))
|
|
{
|
|
ResizeHitbox(entity, sEntityClass, scale);
|
|
}
|
|
|
|
g_fPositionCache[2] -= scale;
|
|
}
|
|
|
|
if (team != 0)
|
|
{
|
|
SetEntProp(entity, Prop_Send, "m_iTeamNum", team);
|
|
}
|
|
|
|
if (offset != 0.0)
|
|
{
|
|
g_fPositionCache[2] -= offset;
|
|
}
|
|
|
|
if (!StrEqual(skin, "-1"))
|
|
{
|
|
DispatchKeyValue(entity, "skin", skin);
|
|
}
|
|
|
|
if (glow)
|
|
{
|
|
SetEntProp(entity, Prop_Send, "m_bGlowEnabled", 1);
|
|
}
|
|
|
|
if (SkeletonKing)
|
|
{
|
|
SetEntProp(entity, Prop_Data, "m_nSkeletonType", 1);
|
|
AcceptEntityInput(entity, "Enable");
|
|
g_iSkeletonKingSpawner = entity;
|
|
g_bIsSkeletonKingSpawning = true;
|
|
}
|
|
|
|
if (Ghost)
|
|
{
|
|
SetEntProp(entity, Prop_Data, "m_takedamage", 0, 1);
|
|
SetEntProp(entity, Prop_Send, "m_CollisionGroup", 2);
|
|
}
|
|
|
|
TeleportEntity(entity, g_fPositionCache, NULL_VECTOR, NULL_VECTOR);
|
|
|
|
if (Ghost)
|
|
{
|
|
AttachParticle(entity, "ghost_appearation", _, 5.0);
|
|
SetEntityModel(entity, "models/props_halloween/ghost.mdl");
|
|
|
|
g_bInvisible[entity] = false;
|
|
|
|
CreateTimer(GetRandomFloat(5.0, 10.0), Timer_ToggleInvis, EntIndexToEntRef(entity));
|
|
|
|
new flags = GetEntityFlags(entity) | FL_NOTARGET;
|
|
SetEntityFlags(entity, flags);
|
|
|
|
SDKHook(entity, SDKHook_Touch, GhostThink);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/***************************************************/
|
|
//Ghost Functions (consolidating later)
|
|
|
|
public GhostThink(entity)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (CheckEntityLimit(0))
|
|
{
|
|
return;
|
|
}
|
|
|
|
static Float:flLastCall;
|
|
if (GetEngineTime() - 0.1 <= flLastCall)
|
|
{
|
|
return;
|
|
}
|
|
|
|
flLastCall = GetEngineTime();
|
|
|
|
if (IsValidEntity(entity) && !g_bInvisible[entity])
|
|
{
|
|
new Float:vecGhostOrigin[3];
|
|
GetEntPropVector(entity, Prop_Send, "m_vecOrigin", vecGhostOrigin);
|
|
|
|
for (new i = 1; i <= MaxClients; i++)
|
|
{
|
|
if (!IsClientInGame(i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
new Float:vecClientOrigin[3];
|
|
GetClientAbsOrigin(i, vecClientOrigin);
|
|
|
|
new Float:flDistance = GetVectorDistance(vecGhostOrigin, vecClientOrigin);
|
|
|
|
if (flDistance < 0)
|
|
{
|
|
flDistance *= -1.0;
|
|
}
|
|
|
|
if (flDistance <= 240.0)
|
|
{
|
|
ScarePlayer(entity, i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Action:Timer_ToggleInvis(Handle:timer, any:data)
|
|
{
|
|
new entity = EntRefToEntIndex(data);
|
|
|
|
if (entity != INVALID_ENT_REFERENCE && IsValidEntity(entity))
|
|
{
|
|
new String:sClass[32];
|
|
GetEntityClassname(entity, sClass, sizeof(sClass));
|
|
|
|
if (StrEqual(sClass, "simple_bot"))
|
|
{
|
|
switch (g_bInvisible[entity])
|
|
{
|
|
case true:
|
|
{
|
|
SetEntityModel(entity, "models/props_halloween/ghost.mdl");
|
|
AttachParticle(entity, "ghost_appearation", _, 5.0);
|
|
SetEntityRenderColor(entity, _, _, _, 255);
|
|
SetEntityRenderMode(entity, RENDER_NORMAL);
|
|
EmitSoundToAll(g_sGhostMoanSounds[GetRandomInt(0, sizeof(g_sGhostMoanSounds)-1)], entity);
|
|
EmitSoundToAll(g_sGhostEffectSounds[GetRandomInt(0, sizeof(g_sGhostEffectSounds)-1)], entity);
|
|
CreateTimer(GetRandomFloat(5.0, 10.0), Timer_ToggleInvis, EntIndexToEntRef(entity));
|
|
g_bInvisible[entity] = false;
|
|
}
|
|
case false:
|
|
{
|
|
AttachParticle(entity, "ghost_appearation", _, 5.0);
|
|
SetEntityRenderMode(entity, RENDER_TRANSCOLOR);
|
|
SetEntityRenderColor(entity, _, _, _, 0);
|
|
SetVariantString("ParticleEffectStop");
|
|
AcceptEntityInput(entity, "DispatchEffect");
|
|
EmitSoundToAll(g_sGhostEffectSounds[GetRandomInt(0, sizeof(g_sGhostEffectSounds)-1)], entity);
|
|
SetEntityModel(entity, "models/humans/group01/female_01.mdl");
|
|
CreateTimer(GetRandomFloat(60.0, 120.0), Timer_ToggleInvis, EntIndexToEntRef(entity));
|
|
g_bInvisible[entity] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
AttachParticle(iEntity, const String:strParticleEffect[], const String:strAttachPoint[] = "", Float:flZOffset = 0.0, Float:flSelfDestruct = 0.0)
|
|
{
|
|
if (!g_bMapStarted)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
new iParticle = CreateEntityByName("info_particle_system");
|
|
|
|
if (!IsValidEdict(iParticle))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
new Float:flPos[3];
|
|
GetEntPropVector(iEntity, Prop_Send, "m_vecOrigin", flPos);
|
|
flPos[2] += flZOffset;
|
|
|
|
TeleportEntity(iParticle, flPos, NULL_VECTOR, NULL_VECTOR);
|
|
|
|
DispatchKeyValue(iParticle, "targetname", "killme%dp@later");
|
|
DispatchKeyValue(iParticle, "effect_name", strParticleEffect);
|
|
DispatchSpawn(iParticle);
|
|
|
|
SetVariantString("!activator");
|
|
AcceptEntityInput(iParticle, "SetParent", iEntity);
|
|
ActivateEntity(iParticle);
|
|
|
|
if (strlen(strAttachPoint))
|
|
{
|
|
SetVariantString(strAttachPoint);
|
|
AcceptEntityInput(iParticle, "SetParentAttachmentMaintainOffset");
|
|
}
|
|
|
|
AcceptEntityInput(iParticle, "start");
|
|
|
|
if (flSelfDestruct > 0.0)
|
|
{
|
|
CreateTimer(flSelfDestruct, Timer_DeleteParticle, EntIndexToEntRef(iParticle));
|
|
}
|
|
|
|
return iParticle;
|
|
}
|
|
|
|
public Action:Timer_DeleteParticle(Handle:timer, any:data)
|
|
{
|
|
new iEntity = EntRefToEntIndex(data);
|
|
|
|
if (iEntity > MaxClients)
|
|
{
|
|
AcceptEntityInput(iEntity, "Kill");
|
|
}
|
|
}
|
|
|
|
ScarePlayer(entity, client)
|
|
{
|
|
static Float:flLastScare[MAXPLAYERS+1];
|
|
static Float:flLastBoo;
|
|
|
|
if (!IsValidEntity(entity) || !IsValidClient(client))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ((GetEngineTime() - 5.0) <= flLastScare[client])
|
|
{
|
|
return;
|
|
}
|
|
|
|
flLastScare[client] = GetEngineTime();
|
|
|
|
if (GetEngineTime() - 1.0 > flLastBoo)
|
|
{
|
|
flLastBoo = GetEngineTime();
|
|
EmitSoundToAll(g_sGhostBooSounds[ GetRandomInt(0, sizeof(g_sGhostBooSounds) - 1)], entity);
|
|
}
|
|
|
|
CreateTimer(0.5, Timer_StunPlayer, GetClientUserId(client));
|
|
}
|
|
|
|
public Action:Timer_StunPlayer(Handle:hTimer, any:data)
|
|
{
|
|
new client = GetClientOfUserId(data);
|
|
|
|
if (IsValidClient(client))
|
|
{
|
|
TF2_StunPlayer(client, 5.0, _, TF_STUNFLAGS_GHOSTSCARE);
|
|
}
|
|
}
|
|
|
|
/***************************************************/
|
|
//Slay Commands
|
|
|
|
public Action:Command_SlayHatman(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while ((entity = FindEntityByClassname(entity, "headless_hatman")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay the {unusual}Horseless Headless Horsemann{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new Handle:g_Event = CreateEvent("pumpkin_lord_killed", true);
|
|
FireEvent(g_Event);
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity2(client, g_sPluginTag, "{default}Slayed the {unusual}Horseless Headless Horsemann");
|
|
LogAction(client, -1, "\"%L\" slayed boss: Horseless Headless Horsemann", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {unusual}Horseless Headless Horsemann", g_sPluginTag);
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SlayEyeBoss(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while ((entity = FindEntityByClassname(entity, "eyeball_boss")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay the {unusual}MONOCULUS!{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new m_iTeamNum = GetEntProp(entity, Prop_Data, "m_iTeamNum");
|
|
if (m_iTeamNum == 5)
|
|
{
|
|
new Handle:g_Event = CreateEvent("eyeball_boss_killed", true);
|
|
FireEvent(g_Event);
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity2(client, g_sPluginTag, "{default}Slayed the {unusual}MONOCULUS!");
|
|
LogAction(client, -1, "\"%L\" slayed boss: MONOCULUS", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {unusual}MONOCULUS!", g_sPluginTag);
|
|
}
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SlayEyeBossRED(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while ((entity = FindEntityByClassname(entity, "eyeball_boss")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay the {red}RED Spectral MONOCULUS!{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new m_iTeamNum = GetEntProp(entity, Prop_Data, "m_iTeamNum");
|
|
if (m_iTeamNum == 2)
|
|
{
|
|
new Handle:g_Event = CreateEvent("eyeball_boss_killed", true);
|
|
FireEvent(g_Event);
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity2(client, g_sPluginTag, "{default}Slayed the {red}RED Spectral MONOCULUS!");
|
|
LogAction(client, -1, "\"%L\" slayed boss: RED Spectral MONOCULUS", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {red}RED Spectral MONOCULUS!", g_sPluginTag);
|
|
}
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SlayEyeBossBLU(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while ((entity = FindEntityByClassname(entity, "eyeball_boss")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay the {blue}BLU Spectral MONOCULUS!{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new m_iTeamNum = GetEntProp(entity, Prop_Data, "m_iTeamNum");
|
|
if (m_iTeamNum == 1)
|
|
{
|
|
new Handle:g_Event = CreateEvent("eyeball_boss_killed", true);
|
|
FireEvent(g_Event);
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity(client, g_sPluginTag, "{default}Slayed the {blue}BLU Spectral MONOCULUS!");
|
|
LogAction(client, -1, "\"%L\" slayed boss: BLU Spectral MONOCULUS", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {blue}BLU Spectral MONOCULUS!", g_sPluginTag);
|
|
}
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SlayMerasmus(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while((entity = FindEntityByClassname(entity, "merasmus")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay {unusual}Merasmus{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new Handle:g_Event = CreateEvent("merasmus_killed", true);
|
|
FireEvent(g_Event);
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity2(client, g_sPluginTag, "{default}Slayed {unusual}Merasmus!");
|
|
LogAction(client, -1, "\"%L\" slayed boss: Merasmus", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {unusual}Merasmus", g_sPluginTag);
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SlayGreenSkeleton(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while ((entity = FindEntityByClassname(entity, "tf_zombie")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay the {community}Green Skeleton{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new m_iTeamNum = GetEntProp(entity, Prop_Data, "m_iTeamNum");
|
|
if (m_iTeamNum == 3)
|
|
{
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity2(client, g_sPluginTag, "{default}Slayed the {community}Green Skeleton!");
|
|
LogAction(client, -1, "\"%L\" slayed boss: Green Skeleton", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {community}Green Skeleton", g_sPluginTag);
|
|
}
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SlayREDSkeleton(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while ((entity = FindEntityByClassname(entity, "tf_zombie")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay the {red}RED Skeleton{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new m_iTeamNum = GetEntProp(entity, Prop_Data, "m_iTeamNum");
|
|
if (m_iTeamNum == 1)
|
|
{
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity2(client, g_sPluginTag, "{default}Slayed the {red}RED Skeleton!");
|
|
LogAction(client, -1, "\"%L\" slayed boss: RED Skeleton", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {red}RED Skeleton", g_sPluginTag);
|
|
}
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SlayBLUSkeleton(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while ((entity = FindEntityByClassname(entity, "tf_zombie")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay the {blue}BLU Skeleton{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new m_iTeamNum = GetEntProp(entity, Prop_Data, "m_iTeamNum");
|
|
if (m_iTeamNum == 2)
|
|
{
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity2(client, g_sPluginTag, "{default}Slayed the {blue}BLU Skeleton!");
|
|
LogAction(client, -1, "\"%L\" slayed boss: BLU Skeleton", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {blue}BLU Skeleton", g_sPluginTag);
|
|
}
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SlaySkeletonKing(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while ((entity = FindEntityByClassname(entity, "tf_zombie")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay the {unusual}Skeleton King{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:sBuffer[32];
|
|
GetEntPropString(entity, Prop_Data, "m_iName", sBuffer, sizeof(sBuffer));
|
|
|
|
if (StrEqual(sBuffer, "SkeletonKing"))
|
|
{
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity2(client, g_sPluginTag, "{default}Slayed the {unusual}Skeleton King!");
|
|
LogAction(client, -1, "\"%L\" slayed boss: Skeleton King", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {unusual}Skeleton King", g_sPluginTag);
|
|
}
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_SlayGhost(client, args)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new entity = -1;
|
|
while ((entity = FindEntityByClassname(entity, "simple_bot")) != -1)
|
|
{
|
|
if (!IsValidEntity(entity))
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't slay the {unusual}Ghost{default} for some reason.", g_sPluginTag);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:sBuffer[32];
|
|
GetEntPropString(entity, Prop_Data, "m_iName", sBuffer, sizeof(sBuffer));
|
|
|
|
if (StrEqual(sBuffer, "SpawnedGhost"))
|
|
{
|
|
AcceptEntityInput(entity, "Kill");
|
|
|
|
CShowActivity2(client, g_sPluginTag, "{default}Slayed the {unusual}Ghost!");
|
|
LogAction(client, -1, "\"%L\" slayed boss: Ghost", client);
|
|
CReplyToCommand(client, "%s {default}You've slayed the {unusual}Ghost", g_sPluginTag);
|
|
}
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
/***************************************************/
|
|
|
|
SetTeleportEndPoint(client)
|
|
{
|
|
new Float:vAngles[3];
|
|
new Float:vOrigin[3];
|
|
new Float:vBuffer[3];
|
|
new Float:vStart[3];
|
|
new Float:Distance;
|
|
|
|
GetClientEyePosition(client,vOrigin);
|
|
GetClientEyeAngles(client, vAngles);
|
|
|
|
new Handle:trace = TR_TraceRayFilterEx(vOrigin, vAngles, MASK_SHOT, RayType_Infinite, TraceEntityFilterPlayer);
|
|
|
|
if (TR_DidHit(trace))
|
|
{
|
|
TR_GetEndPosition(vStart, trace);
|
|
GetVectorDistance(vOrigin, vStart, false);
|
|
Distance = -35.0;
|
|
GetAngleVectors(vAngles, vBuffer, NULL_VECTOR, NULL_VECTOR);
|
|
g_fPositionCache[0] = vStart[0] + (vBuffer[0]*Distance);
|
|
g_fPositionCache[1] = vStart[1] + (vBuffer[1]*Distance);
|
|
g_fPositionCache[2] = vStart[2] + (vBuffer[2]*Distance);
|
|
}
|
|
else
|
|
{
|
|
CloseHandle(trace);
|
|
return false;
|
|
}
|
|
|
|
CloseHandle(trace);
|
|
return true;
|
|
}
|
|
|
|
public bool:TraceEntityFilterPlayer(entity, contentsMask)
|
|
{
|
|
return entity > GetMaxClients() || !entity;
|
|
}
|
|
|
|
public OnEntityCreated(entity, const String:classname[])
|
|
{
|
|
if (StrEqual(classname, "monster_resource"))
|
|
{
|
|
g_iHealthBar = entity;
|
|
}
|
|
else if (g_iTrackEntity == -1 && StrEqual(classname, "headless_hatman"))
|
|
{
|
|
g_iTrackEntity = entity;
|
|
SDKHook(entity, SDKHook_SpawnPost, UpdateBossHealth);
|
|
SDKHook(entity, SDKHook_OnTakeDamagePost, OnHorsemannDamaged);
|
|
}
|
|
else if (g_iTrackEntity == -1 && StrEqual(classname, "eyeball_boss"))
|
|
{
|
|
g_iTrackEntity = entity;
|
|
SDKHook(entity, SDKHook_SpawnPost, UpdateBossHealth);
|
|
SDKHook(entity, SDKHook_OnTakeDamagePost, OnMonoculusDamaged);
|
|
}
|
|
else if (g_iTrackEntity == -1 && StrEqual(classname, "merasmus"))
|
|
{
|
|
g_iTrackEntity = entity;
|
|
SDKHook(entity, SDKHook_SpawnPost, UpdateBossHealth);
|
|
SDKHook(entity, SDKHook_OnTakeDamagePost, OnMerasmusDamaged);
|
|
}
|
|
else if (g_iTrackEntity == -1 && StrEqual(classname, "tf_zombie_spawner"))
|
|
{
|
|
g_iTrackEntity = entity;
|
|
SDKHook(entity, SDKHook_SpawnPost, UpdateBossHealth);
|
|
SDKHook(entity, SDKHook_OnTakeDamagePost, OnSkeletonKingDamaged);
|
|
}
|
|
|
|
if (StrEqual(classname, "tf_zombie") && g_bIsSkeletonKingSpawning)
|
|
{
|
|
DispatchKeyValue(entity, "targetname", "SkeletonKing");
|
|
|
|
if (IsValidEntity(g_iSkeletonKingSpawner))
|
|
{
|
|
AcceptEntityInput(g_iSkeletonKingSpawner, "kill");
|
|
g_iSkeletonKingSpawner = -1;
|
|
}
|
|
|
|
g_bIsSkeletonKingSpawning = false;
|
|
}
|
|
}
|
|
|
|
public OnEntityDestroyed(entity)
|
|
{
|
|
if (entity == -1) return;
|
|
else if (entity == g_iTrackEntity)
|
|
{
|
|
g_iTrackEntity = FindEntityByClassname(-1, "headless_hatman");
|
|
if (g_iTrackEntity == entity)
|
|
{
|
|
g_iTrackEntity = FindEntityByClassname(entity, "headless_hatman");
|
|
}
|
|
if (g_iTrackEntity > -1)
|
|
{
|
|
SDKHook(g_iTrackEntity, SDKHook_OnTakeDamagePost, OnHorsemannDamaged);
|
|
}
|
|
UpdateBossHealth(g_iTrackEntity);
|
|
}
|
|
else if (entity == g_iTrackEntity)
|
|
{
|
|
g_iTrackEntity = FindEntityByClassname(-1, "eyeball_boss");
|
|
if (g_iTrackEntity == entity)
|
|
{
|
|
g_iTrackEntity = FindEntityByClassname(entity, "eyeball_boss");
|
|
}
|
|
if (g_iTrackEntity > -1)
|
|
{
|
|
SDKHook(g_iTrackEntity, SDKHook_OnTakeDamagePost, OnMonoculusDamaged);
|
|
}
|
|
UpdateBossHealth(g_iTrackEntity);
|
|
}
|
|
else if (entity == g_iTrackEntity)
|
|
{
|
|
g_iTrackEntity = FindEntityByClassname(-1, "merasmus");
|
|
if (g_iTrackEntity == entity)
|
|
{
|
|
g_iTrackEntity = FindEntityByClassname(entity, "merasmus");
|
|
}
|
|
if (g_iTrackEntity > -1)
|
|
{
|
|
SDKHook(g_iTrackEntity, SDKHook_OnTakeDamagePost, OnMerasmusDamaged);
|
|
}
|
|
UpdateBossHealth(g_iTrackEntity);
|
|
}
|
|
else if (entity == g_iTrackEntity)
|
|
{
|
|
g_iTrackEntity = FindEntityByClassname(-1, "tf_zombie_spawner");
|
|
if (g_iTrackEntity == entity)
|
|
{
|
|
g_iTrackEntity = FindEntityByClassname(entity, "tf_zombie_spawner");
|
|
}
|
|
if (g_iTrackEntity > -1)
|
|
{
|
|
SDKHook(g_iTrackEntity, SDKHook_OnTakeDamagePost, OnSkeletonKingDamaged);
|
|
}
|
|
UpdateBossHealth(g_iTrackEntity);
|
|
}
|
|
}
|
|
|
|
public OnHorsemannDamaged(victim, attacker, inflictor, Float:damage, damagetype)
|
|
{
|
|
UpdateBossHealth(victim);
|
|
UpdateDeathEvent(victim);
|
|
}
|
|
|
|
public OnMonoculusDamaged(victim, attacker, inflictor, Float:damage, damagetype)
|
|
{
|
|
UpdateBossHealth(victim);
|
|
UpdateDeathEvent(victim);
|
|
}
|
|
|
|
public OnMerasmusDamaged(victim, attacker, inflictor, Float:damage, damagetype)
|
|
{
|
|
UpdateBossHealth(victim);
|
|
UpdateDeathEvent(victim);
|
|
}
|
|
|
|
public OnSkeletonKingDamaged(victim, attacker, inflictor, Float:damage, damagetype)
|
|
{
|
|
UpdateBossHealth(victim);
|
|
UpdateDeathEvent(victim);
|
|
}
|
|
|
|
public UpdateDeathEvent(entity)
|
|
{
|
|
if (IsValidEntity(entity))
|
|
{
|
|
new maxHP = GetEntProp(entity, Prop_Data, "m_iMaxHealth");
|
|
new HP = GetEntProp(entity, Prop_Data, "m_iHealth");
|
|
if (HP <= (maxHP * 0.75))
|
|
{
|
|
SetEntProp(entity, Prop_Data, "m_iHealth", 0);
|
|
if (HP <= -1)
|
|
{
|
|
SetEntProp(entity, Prop_Data, "m_takedamage", 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public UpdateBossHealth(entity)
|
|
{
|
|
if (g_iHealthBar == -1) return;
|
|
new percentage;
|
|
if (IsValidEntity(entity))
|
|
{
|
|
new maxHP = GetEntProp(entity, Prop_Data, "m_iMaxHealth");
|
|
new HP = GetEntProp(entity, Prop_Data, "m_iHealth");
|
|
if (HP <= 0)
|
|
{
|
|
percentage = 0;
|
|
}
|
|
else
|
|
{
|
|
percentage = RoundToCeil(float(HP) / (maxHP / 4) * 255);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
percentage = 0;
|
|
}
|
|
SetEntProp(g_iHealthBar, Prop_Send, "m_iBossHealthPercentageByte", percentage);
|
|
}
|
|
|
|
/***************************************************/
|
|
//Natives
|
|
|
|
public Native_SpawnHatman(Handle:plugin, numParams)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Plugin currently disabled.");
|
|
}
|
|
|
|
new client = GetNativeCell(1);
|
|
|
|
if (!IsValidClient(client))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Hatman, invalid client index.");
|
|
}
|
|
|
|
g_fPositionCache[0] = Float:GetNativeCell(2);
|
|
g_fPositionCache[1] = Float:GetNativeCell(3);
|
|
g_fPositionCache[2] = Float:GetNativeCell(4);
|
|
new Float:scale = Float:GetNativeCell(5);
|
|
new bool:bGlow = GetNativeCell(6);
|
|
new bool:bSpew = GetNativeCell(7);
|
|
|
|
if (SpawnBoss("headless_hatman", "", scale, 0, 10.0, "0", bGlow))
|
|
{
|
|
if (bSpew)
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned the {unusual}Horseless Headless Horsemann via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: Horseless Headless Horsemann", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned the {unusual}Horseless Headless Horsemann via natives!", g_sPluginTag);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bSpew)
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn the {unusual}Horseless Headless Horsemann!{default} for some reason via natives.", g_sPluginTag);
|
|
}
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Hatman, could not spawn Hatman.");
|
|
}
|
|
}
|
|
|
|
public Native_SpawnEyeboss(Handle:plugin, numParams)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Plugin currently disabled.");
|
|
}
|
|
|
|
new client = GetNativeCell(1);
|
|
|
|
if (!IsValidClient(client))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Eyeboss, invalid client index.");
|
|
}
|
|
|
|
g_fPositionCache[0] = Float:GetNativeCell(2);
|
|
g_fPositionCache[1] = Float:GetNativeCell(3);
|
|
g_fPositionCache[2] = Float:GetNativeCell(4);
|
|
new Float:scale = Float:GetNativeCell(5);
|
|
new bool:bGlow = GetNativeCell(6);
|
|
new bool:bSpew = GetNativeCell(7);
|
|
new type = GetNativeCell(8);
|
|
|
|
if (SpawnBoss("eyeball_boss", "", scale, type, 50.0, "0", bGlow))
|
|
{
|
|
if (bSpew)
|
|
{
|
|
switch (type)
|
|
{
|
|
case 0:
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned the {unusual}MONOCULUS via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: MONOCULUS", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned the {unusual}MONOCULUS via natives!", g_sPluginTag);
|
|
}
|
|
case 1:
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned the {red}RED Spectral MONOCULUS via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: RED Spectral MONOCULUS", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned the {red}RED Spectral MONOCULUS via natives!", g_sPluginTag);
|
|
}
|
|
case 2:
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned the {blue}BLU Spectral MONOCULUS via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: BLU Spectral MONOCULUS", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned the {blue}BLU Spectral MONOCULUS via natives!", g_sPluginTag);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (type)
|
|
{
|
|
case 0:
|
|
{
|
|
if (bSpew) CReplyToCommand(client, "%s {default}Couldn't spawn {unusual}MONOCULUS!{default} for some reason via natives.", g_sPluginTag);
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Eyeboss 'regular', could not spawn Eyeboss 'regular'.");
|
|
}
|
|
case 1:
|
|
{
|
|
if (bSpew) CReplyToCommand(client, "%s {default}Couldn't spawn {red}RED Spectral MONOCULUS!{default} for some reason via natives.", g_sPluginTag);
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Eyeboss 'red', could not spawn Eyeboss 'red'.");
|
|
}
|
|
case 2:
|
|
{
|
|
if (bSpew) CReplyToCommand(client, "%s {default}Couldn't spawn {blue}BLU Spectral MONOCULUS!{default} for some reason via natives.", g_sPluginTag);
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Eyeboss 'blue', could not spawn Eyeboss 'blue'.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Native_SpawnMerasmus(Handle:plugin, numParams)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Plugin currently disabled.");
|
|
}
|
|
|
|
new client = GetNativeCell(1);
|
|
|
|
if (!IsValidClient(client))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Merasmus, invalid client index.");
|
|
}
|
|
|
|
g_fPositionCache[0] = Float:GetNativeCell(2);
|
|
g_fPositionCache[1] = Float:GetNativeCell(3);
|
|
g_fPositionCache[2] = Float:GetNativeCell(4);
|
|
new Float:scale = Float:GetNativeCell(5);
|
|
new bool:bGlow = GetNativeCell(6);
|
|
new bool:bSpew = GetNativeCell(7);
|
|
|
|
if (SpawnBoss("merasmus", "", scale, 0, 0.0, "0", bGlow))
|
|
{
|
|
if (bSpew)
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned {unusual}Merasmus via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: Merasmus", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned {unusual}Merasmus via natives!", g_sPluginTag);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bSpew)
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn {unusual}Merasmus!{default} for some reason via natives.", g_sPluginTag);
|
|
}
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Merasmus, could not spawn Merasmus.");
|
|
}
|
|
}
|
|
|
|
public Native_SpawnSkeleton(Handle:plugin, numParams)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Plugin currently disabled.");
|
|
}
|
|
|
|
new client = GetNativeCell(1);
|
|
|
|
if (!IsValidClient(client))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Skeleton, invalid client index.");
|
|
}
|
|
|
|
g_fPositionCache[0] = Float:GetNativeCell(2);
|
|
g_fPositionCache[1] = Float:GetNativeCell(3);
|
|
g_fPositionCache[2] = Float:GetNativeCell(4);
|
|
new Float:scale = Float:GetNativeCell(5);
|
|
new bool:bGlow = GetNativeCell(6);
|
|
new bool:bSpew = GetNativeCell(7);
|
|
new type = GetNativeCell(8);
|
|
|
|
new String:sSkin[1] = "0";
|
|
IntToString(type, sSkin, sizeof(sSkin));
|
|
|
|
if (SpawnBoss("tf_zombie", "", scale, type, 0.0, sSkin, bGlow))
|
|
{
|
|
if (bSpew)
|
|
{
|
|
switch (type)
|
|
{
|
|
case 0:
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned a {community}Green Skeleton via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: Green Skeleton", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned {community}Green Skeleton via natives!", g_sPluginTag);
|
|
}
|
|
case 1:
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned a {red}RED Skeleton via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: RED Skeleton", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned {red}RED Skeleton via natives!", g_sPluginTag);
|
|
}
|
|
case 2:
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned a {blue}BLU Skeleton via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: BLU Skeleton", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned {blue}BLU Skeleton via natives!", g_sPluginTag);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (type)
|
|
{
|
|
case 0:
|
|
{
|
|
if (bSpew) CReplyToCommand(client, "%s {default}Couldn't spawn the {community}Green Skeleton{default} for some reason via natives.", g_sPluginTag);
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Eyeboss 'Green', could not spawn Eyeboss 'Green'.");
|
|
}
|
|
case 1:
|
|
{
|
|
if (bSpew) CReplyToCommand(client, "%s {default}Couldn't spawn the {red}RED Skeleton{default} for some reason via natives.", g_sPluginTag);
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Eyeboss 'Red', could not spawn Eyeboss 'Red'.");
|
|
}
|
|
case 2:
|
|
{
|
|
if (bSpew) CReplyToCommand(client, "%s {default}Couldn't spawn the {blue}BLU Skeleton{default} for some reason via natives.", g_sPluginTag);
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Eyeboss 'Blue', could not spawn Eyeboss 'Blue'.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Native_SpawnSkeletonKing(Handle:plugin, numParams)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Plugin currently disabled.");
|
|
}
|
|
|
|
new client = GetNativeCell(1);
|
|
|
|
if (!IsValidClient(client))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Skeleton King, invalid client index.");
|
|
}
|
|
|
|
g_fPositionCache[0] = Float:GetNativeCell(2);
|
|
g_fPositionCache[1] = Float:GetNativeCell(3);
|
|
g_fPositionCache[2] = Float:GetNativeCell(4);
|
|
new bool:bGlow = GetNativeCell(6);
|
|
new bool:bSpew = GetNativeCell(5);
|
|
|
|
if (SpawnBoss("tf_zombie_spawner", "", 1.0, 0, 0.0, "-1", bGlow, true))
|
|
{
|
|
if (bSpew)
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned a {unusual}Skeleton King via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: Skeleton King", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned {unusual}Skeleton King via natives!", g_sPluginTag);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bSpew)
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn the {unusual}Skeleton King{default} for some reason via natives.", g_sPluginTag);
|
|
}
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Skeleton King, could not spawn Skeleton King.");
|
|
}
|
|
}
|
|
|
|
public Native_SpawnGhost(Handle:plugin, numParams)
|
|
{
|
|
if (!GetConVarBool(g_hConVars[1]))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Plugin currently disabled.");
|
|
}
|
|
|
|
new client = GetNativeCell(1);
|
|
|
|
if (!IsValidClient(client))
|
|
{
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Ghost, invalid client index.");
|
|
}
|
|
|
|
g_fPositionCache[0] = Float:GetNativeCell(2);
|
|
g_fPositionCache[1] = Float:GetNativeCell(3);
|
|
g_fPositionCache[2] = Float:GetNativeCell(4);
|
|
new bool:bGlow = GetNativeCell(6);
|
|
new bool:bSpew = GetNativeCell(5);
|
|
|
|
if (SpawnBoss("simple_bot", "SpawnedGhost", 1.0, 0, 0.0, "-1", bGlow, false, true))
|
|
{
|
|
if (bSpew)
|
|
{
|
|
CShowActivity2(client, g_sPluginTag, "{default}Spawned a {unusual}Ghost via natives!");
|
|
LogAction(client, -1, "\"%L\" spawned boss via natives: Ghost", client);
|
|
CReplyToCommand(client, "%s {default}You've spawned {unusual}Ghost via natives!", g_sPluginTag);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bSpew)
|
|
{
|
|
CReplyToCommand(client, "%s {default}Couldn't spawn the {unusual}Ghost{default} for some reason via natives.", g_sPluginTag);
|
|
}
|
|
ThrowNativeError(SP_ERROR_INDEX, "Error spawning Ghost, could not spawn Ghost.");
|
|
}
|
|
}
|
|
|
|
/***************************************************/
|
|
|
|
bool:IsValidClient(i, bool:replay = true)
|
|
{
|
|
if (i <= 0 || i > MaxClients || !IsClientInGame(i) || GetEntProp(i, Prop_Send, "m_bIsCoaching")) return false;
|
|
if (replay && (IsClientSourceTV(i) || IsClientReplay(i))) return false;
|
|
return true;
|
|
}
|
|
|
|
bool:CheckEntityLimit(client)
|
|
{
|
|
if (GetEntityCount() >= GetMaxEntities() - 32)
|
|
{
|
|
CReplyToCommand(client, "%s {default}Too many entities have been spawned, reload the map.", g_sPluginTag);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
ResizeHitbox(entity, const String:sEntityClass[], Float:fScale = 1.0)
|
|
{
|
|
new Float:vecBossMin[3], Float:vecBossMax[3];
|
|
if (StrEqual(sEntityClass, "headless_hatman"))
|
|
{
|
|
vecBossMin[0] = -25.5, vecBossMin[1] = -38.5, vecBossMin[2] = -11.0;
|
|
vecBossMax[0] = 18.0, vecBossMax[1] = 38.0, vecBossMax[2] = 138.5;
|
|
}
|
|
else if (StrEqual(sEntityClass, "eyeball_boss"))
|
|
{
|
|
vecBossMin[0] = -50.0, vecBossMin[1] = -50.0, vecBossMin[2] = -50.0;
|
|
vecBossMax[0] = 50.0, vecBossMax[1] = 50.0, vecBossMax[2] = 50.0;
|
|
}
|
|
else if (StrEqual(sEntityClass, "merasmus"))
|
|
{
|
|
vecBossMin[0] = -58.5, vecBossMin[1] = -49.5, vecBossMin[2] = -30.5;
|
|
vecBossMax[0] = 92.5, vecBossMax[1] = 49.5, vecBossMax[2] = 190.5;
|
|
}
|
|
|
|
new Float:vecScaledBossMin[3], Float:vecScaledBossMax[3];
|
|
|
|
vecScaledBossMin = vecBossMin;
|
|
vecScaledBossMax = vecBossMax;
|
|
|
|
ScaleVector(vecScaledBossMin, fScale);
|
|
ScaleVector(vecScaledBossMax, fScale);
|
|
SetEntPropVector(entity, Prop_Send, "m_vecMins", vecScaledBossMin);
|
|
SetEntPropVector(entity, Prop_Send, "m_vecMaxs", vecScaledBossMax);
|
|
}
|
|
|
|
public OnMapEnd()
|
|
{
|
|
g_bMapStarted = false;
|
|
}
|
|
|
|
//Lets put this behemoth of a function at the bottom shall we... get it the hell out of the way.
|
|
public OnMapStart()
|
|
{
|
|
g_bMapStarted = true;
|
|
|
|
PrecacheModel("models/humans/group01/female_01.mdl", true); //Simple_bots default model
|
|
PrecacheModel("models/props_halloween/ghost.mdl", true); //Ghost model itself
|
|
PrecacheModel("ghost_appearation", true); //Ghost appear & disappear particle
|
|
|
|
g_iHealthBar = FindEntityByClassname(-1, "monster_resource");
|
|
if (g_iHealthBar == -1)
|
|
{
|
|
g_iHealthBar = CreateEntityByName("monster_resource");
|
|
if (g_iHealthBar != -1)
|
|
{
|
|
DispatchSpawn(g_iHealthBar);
|
|
}
|
|
}
|
|
|
|
PrecacheModel("models/bots/headless_hatman.mdl", true);
|
|
PrecacheModel("models/weapons/c_models/c_bigaxe/c_bigaxe.mdl", true);
|
|
PrecacheModel("models/bots/merasmus/merasmus.mdl", true);
|
|
PrecacheModel("models/prop_lakeside_event/bomb_temp.mdl", true);
|
|
PrecacheModel("models/prop_lakeside_event/bomb_temp_hat.mdl", true);
|
|
PrecacheModel("models/props_halloween/halloween_demoeye.mdl", true);
|
|
PrecacheModel("models/props_halloween/eyeball_projectile.mdl", true);
|
|
PrecacheModel("models/bots/skeleton_sniper/skeleton_sniper.mdl", true);
|
|
PrecacheModel("models/bots/skeleton_sniper_boss/skeleton_sniper_boss.mdl", true);
|
|
|
|
new i, String:sBuffer[PLATFORM_MAX_PATH];
|
|
|
|
for (i = 1; i <= 2; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_boss/knight_alert0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 1; i <= 4; i++)
|
|
{
|
|
new String:iString[PLATFORM_MAX_PATH];
|
|
Format(iString, sizeof(iString), "vo/halloween_boss/knight_attack0%d.mp3", i);
|
|
PrecacheSound(iString, true);
|
|
}
|
|
|
|
for (i = 1; i <= 2; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_boss/knight_death0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 1; i <= 4; i++)
|
|
{
|
|
new String:iString[PLATFORM_MAX_PATH];
|
|
Format(iString, sizeof(iString), "vo/halloween_boss/knight_laugh0%d.mp3", i);
|
|
PrecacheSound(iString, true);
|
|
}
|
|
|
|
for (i = 1; i <= 3; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_boss/knight_pain0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 1; i <= 3; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_eyeball/eyeball_laugh0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 1; i <= 3; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_eyeball/eyeball_mad0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 1; i <= 13; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_eyeball/eyeball0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_eyeball/eyeball%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i <= 17; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_appears0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_appears%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i <= 11; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_attacks0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_attacks%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i <= 54; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_bcon_headbomb0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_bcon_headbomb%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i <= 33; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_bcon_held_up0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_bcon_held_up%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 2; i <= 4; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_bcon_island0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 1; i <= 3; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_bcon_skullhat0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 1; i <= 2; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_combat_idle0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 1; i <= 12; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_defeated0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_defeated%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i <= 9; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_found0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 3; i <= 6; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_grenades0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 1; i <= 26; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_headbomb_hit0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_headbomb_hit%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i <= 19; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_hide_heal10%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_hide_heal1%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i <= 49; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_hide_idles0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_hide_idles%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i <= 16; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_leaving0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_leaving%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
for (i = 1; i <= 5; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_pain0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 4; i <= 8; i++)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_ranged_attack0%d.mp3", i);
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
|
|
for (i = 2; i <= 13; i++)
|
|
{
|
|
if (i < 10)
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_staff_magic0%d.mp3", i);
|
|
}
|
|
else
|
|
{
|
|
Format(sBuffer, sizeof(sBuffer), "vo/halloween_merasmus/sf12_staff_magic%d.mp3", i);
|
|
}
|
|
|
|
if (FileExists(sBuffer))
|
|
{
|
|
PrecacheSound(sBuffer, true);
|
|
}
|
|
}
|
|
|
|
PrecacheSounds(g_sHorsemannSounds, sizeof(g_sHorsemannSounds));
|
|
PrecacheSounds(g_sMonoculusSounds, sizeof(g_sMonoculusSounds));
|
|
PrecacheSounds(g_sMerasmusSounds, sizeof(g_sMerasmusSounds));
|
|
PrecacheSounds(g_sSkeletonKingSounds, sizeof(g_sSkeletonKingSounds));
|
|
//PrecacheSounds(g_sGhostSounds, sizeof(g_sSkeletonKingSounds));
|
|
PrecacheSounds(g_sGhostMoanSounds, sizeof(g_sGhostMoanSounds));
|
|
PrecacheSounds(g_sGhostBooSounds, sizeof(g_sGhostBooSounds));
|
|
PrecacheSounds(g_sGhostEffectSounds, sizeof(g_sGhostEffectSounds));
|
|
}
|
|
|
|
PrecacheSounds(const String:strSounds[][], iArraySize)
|
|
{
|
|
for (new i = 0; i < iArraySize; i++)
|
|
{
|
|
if (!PrecacheSound(strSounds[i]))
|
|
{
|
|
PrintToChatAll("Faild to precache sound: %s", strSounds[i]);
|
|
}
|
|
}
|
|
}
|