- Сообщения
- 264
- Реакции
- 80
- Помог
- 1 раз(а)
Доброго времени суток!
Для того что бы, избежать всякого рода ошибок, решил спросить.
Моя задача была в том, что бы звуки по умолчанию были выключены.
Просмотрев исходник плагина, нашёл и отключил. было: false стало: true
Вопрос, так я всё сделал или нет? Или нужно было, как то иначе? Благодарю всех за внимание!
Для того что бы, избежать всякого рода ошибок, решил спросить.
Моя задача была в том, что бы звуки по умолчанию были выключены.
Просмотрев исходник плагина, нашёл и отключил. было: false стало: true
Код:
// SETTINGS ON
//
g_bDisabled[Player] = true;Вопрос, так я всё сделал или нет? Или нужно было, как то иначе? Благодарю всех за внимание!
Код:
/*************************************************************************************
******* PRAGMA ***********************************************************************
*************************************************************************************/
// WHETHER OR NOT TO FORCE ';' AFTER EACH LINE
//
// #pragma semicolon 1
// WHETHER OR NOT TO INCREASE MEMORY FOR THIS SCRIPT
//
// #pragma dynamic 2097152
// WHETHER OR NOT TO USE '\' AS A CONTROL CHARACTER
// INSTEAD OF THE DEFAULT ONE, WHICH IS '^'
//
// #pragma ctrlchar '\'
// SETS TAB SIZE '\t', ' ' TO 0
// GLOBALLY
//
#pragma tabsize 0
/*************************************************************************************
******* HEADERS **********************************************************************
*************************************************************************************/
// AMX MOD X HEADER FILES
//
#include <amxmodx>
#include <amxmisc>
// FAKE META
//
#include <fakemeta>
// REQUIRES XSTATS MODULE IF AVAILABLE
//
#pragma reqclass xstats
// AUTO LOAD
//
#if !defined AMXMODX_NOAUTOLOAD
#pragma defclasslib xstats csx
#pragma defclasslib xstats dodx
#pragma defclasslib xstats tfcx
#pragma defclasslib xstats tsx
#endif
/*************************************************************************************
******* DEFINITIONS ******************************************************************
*************************************************************************************/
// CENTER HUD MESSAGE POSITION
//
#define QS_CENTERPOS (-1.0)
// VERSION
//
#define QS_VERSION "5.0"
// INVALID PLAYER
//
#define QS_INVALIDPLR (0xFF)
// MAXIMUM PLAYERS
//
#define QS_MAXPLRS (32)
// MAXIMUM BYTE (8 BIT)
//
#define QS_MAXBYTE (0xFF)
// INVALID TEAM
//
#define QS_INVALIDTEAM (0xFF)
// HUD MESSAGE PURPOSES
//
enum /* HUD MESSAGE PURPOSE */
{
HUDMSG_EVENT = 0,
HUDMSG_STREAK,
HUDMSG_ROUND,
HUDMSG_MAX
};
/*************************************************************************************
******* GLOBAL VARIABLES *************************************************************
*************************************************************************************/
// PLUG-IN ON/ OFF
//
new bool:g_bON = false;
/**
* HEAD SHOT
*/
// HEAD SHOT ON/ OFF
//
new bool:g_bHShot = false;
// HEAD SHOT MESSAGE ON/ OFF
new bool:g_bHShotMsg = false;
// HEAD SHOT MESSAGE
//
new g_HShotMsg[256];
// HEAD SHOT SOUNDS COUNT
//
new g_HShotSize = 0;
// HEAD SHOT ONLY FOR KILLER
//
new bool:g_bHShotOnlyKiller = false;
// HEAD SHOT SOUNDS CONTAINER
//
new Array:g_pHShot = Invalid_Array;
/**
* REVENGE
*/
// REVENGE ON/ OFF
//
new bool:g_bRevenge = false;
// REVENGE MESSAGE FOR KILLER ON/ OFF
//
new bool:g_bRevengeMsgKiller = false;
// REVENGE MESSAGE FOR VICTIM ON/ OFF
//
new bool:g_bRevengeMsgVictim = false;
// REVENGE MESSAGE FOR KILLER (IF ENABLED)
//
new g_RevengeMsgKiller[256];
// REVENGE MESSAGE FOR VICTIM (IF ENABLED)
//
new g_RevengeMsgVictim[256];
// REVENGE SOUNDS COUNT
//
new g_RevengeSize = 0;
// REVENGE ONLY FOR KILER
//
new bool:g_bRevengeOnlyKiller = false;
// REVENGE SOUNDS CONTAINER
//
new Array:g_pRevenge = Invalid_Array;
/**
* HATTRICK
* THE LEADER OF CURRENT ROUND
*/
// HATTRICK ON/ OFF
//
new bool:g_bHattrick = false;
// HATTRICK MESSAGE ON/ OFF
//
new bool:g_bHattrickMsg = false;
// HATTRICK MESSAGE
//
new g_HattrickMsg[256];
// HATTRICK SOUNDS COUNT
//
new g_HattrickSize = 0;
// MINIMUM KILLS REQUIRED FOR HATTRICK
//
new g_MinimumKillsForHattrick = 0;
// HATTRICK SOUNDS CONTAINER
//
new Array:g_pHattrick = Invalid_Array;
/**
* SUICIDE
*/
// SUICIDE ON/ OFF
//
new bool:g_bSuicide = false;
// SUICIDE MESSAGE ON/ OFF
//
new bool:g_bSuicideMsg = false;
// SUICIDE MESSAGE
//
new g_SuicideMsg[256];
// SUICIDE SOUNDS COUNT
//
new g_SuicideSize = 0;
// SUICIDE SOUNDS CONTAINER
//
new Array:g_pSuicide = Invalid_Array;
/**
* GRENADE
*/
// GRENADE ON/ OFF
//
new bool:g_bGrenade = false;
// GRENADE MESSAGE ON/ OFF
//
new bool:g_bGrenadeMsg = false;
// GRENADE KILL MESSAGE
//
new g_GrenadeMsg[256];
// GRENADE SOUNDS COUNT
//
new g_GrenadeSize = 0;
// GRENADE SOUNDS CONTAINER
//
new Array:g_pGrenade = Invalid_Array;
/**
* TEAM KILL
*/
// TEAM KILL ON/ OFF
//
new bool:g_bTKill = false;
// TEAM KILL MESSAGE ON/ OFF
//
new bool:g_bTKillMsg = false;
// TEAM KILL MESSAGE
//
new g_TKillMsg[256];
// TEAM KILL SOUNDS COUNT
//
new g_TKillSize = 0;
// TEAM KILL SOUNDS CONTAINER
//
new Array:g_pTKill = Invalid_Array;
/**
* KNIFE
*/
// KNIFE ON/ OFF
//
new bool:g_bKnife = false;
// KNIFE MESSAGE ON/ OFF
//
new bool:g_bKnifeMsg = false;
// KNIFE KILL MESSAGE
//
new g_KnifeMsg[256];
// KNIFE KILL SOUNDS COUNT
//
new g_KnifeSize = 0;
// KNIFE SOUNDS CONTAINER
//
new Array:g_pKnife = Invalid_Array;
/**
* FIRST BLOOD
*/
// FIRST BLOOD ON/ OFF
//
new bool:g_bFBlood = false;
// FIRST BLOOD MESSAGE ON/ OFF
//
new bool:g_bFBloodMsg = false;
// FIRST BLOOD MESSAGE
//
new g_FBloodMsg[256];
// FIRST BLOOD SOUNDS COUNT
//
new g_FBloodSize = 0;
// FIRST BLOOD VARIABLE
//
new g_FBlood = 0;
// FIRST BLOOD SOUNDS CONTAINER
//
new Array:g_pFBlood = Invalid_Array;
/**
* KILLS STREAK
*/
// KILLS STREAK ON/ OFF
//
new bool:g_bKStreak = false;
// KILL STREAK SOUNDS COUNT
//
new g_KStreakSoundsSize = 0;
// KILLS STREAK SOUNDS CONTAINER
//
new Array:g_pKStreakSounds = Invalid_Array;
// KILLS STREAK MESSAGES CONTAINER
//
new Array:g_pKStreakMessages = Invalid_Array;
// KILLS STREAK REQUIRED KILLS CONTAINER
//
new Array:g_pKStreakRequiredKills = Invalid_Array;
/**
* ROUND START
*/
// ROUND START ON/ OFF
//
new bool:g_bRStart = false;
// ROUND START MESSAGE ON/ OFF
//
new bool:g_bRStartMsg = false;
// ROUND START MESSAGE
//
new g_RStartMsg[256];
// ROUND START SOUNDS COUNT
//
new g_RStartSize = 0;
// ROUND START SOUNDS CONTAINER
//
new Array:g_pRStart = Invalid_Array;
/**
* DOUBLE KILL
*/
// DOUBLE KILL ON/ OFF
//
new bool:g_bDKill = false;
// DOUBLE KILL MESSAGE ON/ OFF
//
new bool:g_bDKillMsg = false;
// DOUBLE KILL MESSAGE
//
new g_DKillMsg[256];
// DOUBLE KILL SOUNDS COUNT
//
new g_DKillSize = 0;
// DOUBLE KILL SOUNDS CONTAINER
//
new Array:g_pDKill = Invalid_Array;
/**
* FLAWLESS
* IF A TEAM KILLS THE OTHER ONE W/ O GETTING ANY CASUALTIES
*/
// FLAWLESS ON/ OFF
//
new bool:g_bFlawless = false;
// FLAWLESS MESSAGE ON/ OFF
//
new bool:g_bFlawlessMsg = false;
// FLAWLESS MESSAGE
//
new g_FlawlessMsg[256];
// FLAWLESS TEAM NAME FOR TEAM [1]
//
new g_FlawlessTeamName_1[256];
// FLAWLESS TEAM NAME FOR TEAM [2]
//
new g_FlawlessTeamName_2[256];
// FLAWLESS SOUNDS COUNT
//
new g_FlawlessSize = 0;
// FLAWLESS SOUNDS CONTAINER
//
new Array:g_pFlawless = Invalid_Array;
/**
* HUD MESSAGE [TE_TEXTMESSAGE]
*/
// CHANNEL HANDLES
//
new g_pHudMsg[HUDMSG_MAX];
// RED
//
new g_Red = 0;
// RANDOM RED
//
new bool:g_bRandomRed = false;
// GREEN
//
new g_Green = 0;
// RANDOM GREEN
//
new bool:g_bRandomGreen = false;
// BLUE
//
new g_Blue = 0;
// RANDOM BLUE
//
new bool:g_bRandomBlue = false;
/**
* GAME RELATED
*/
// MOD NAME
//
new g_ModName[8];
// ON DEATHMSG
//
new bool:g_bOnDeathMsg = false;
// DEATHMSG BYTE STATUS
//
new g_DeathMsgByteStatus = 0;
// DEATHMSG ONLY AVAILABLE
//
new bool:g_bDeathMsgOnly = false;
// CACHED KILLER ID
//
new g_Killer = 0;
// CACHED VICTIM ID
//
new g_Victim = 0;
// CACHED WEAPON ID
//
new g_wpnID = 0;
// CACHED HIT PLACE
//
new g_Place = 0;
// CACHED TEAM KILL BOOLEAN
//
new g_TK = 0;
/**
* PLAYERS RELATED
*/
// MAXIMUM PLAYERS
//
new g_maxPlayers = 0;
// TOTAL KILLS PER PLAYER PER LIFE
// RESETS ON PLAYER DEATH
//
new g_Kills[QS_MAXPLRS + 1];
// TOTAL KILLS PER PLAYER PER ROUND
// RESETS NEXT ROUND
//
new g_RKills[QS_MAXPLRS + 1];
// HLTV
//
new bool:g_bHLTV[QS_MAXPLRS + 1];
// BOT
//
new bool:g_bBOT[QS_MAXPLRS + 1];
// CONNECTED
//
new bool:g_bConnected[QS_MAXPLRS + 1];
// NAME
//
new g_Name[QS_MAXPLRS + 1][32];
// REVENGE KILL NAME STAMP
//
new g_RevengeStamp[QS_MAXPLRS + 1][32];
// SOUNDS DISABLED PER PLAYER
//
new bool:g_bDisabled[QS_MAXPLRS + 1];
// LAST KILL TIME STAMP (GAME TIME)
//
new Float:g_fLastKillTimeStamp[QS_MAXPLRS + 1];
/*************************************************************************************
******* FORWARDS *********************************************************************
*************************************************************************************/
// PLUG-IN NATIVES
//
public plugin_natives()
{
// SETS MODULE FILTER
//
set_module_filter("Module_Filter");
// SETS NATIVE FILTER
//
set_native_filter("Native_Filter");
}
// FILTERS MODULE
//
public Module_Filter(const Module[])
{
// XSTATS
//
if (equali(Module, "xstats"))
{
// AVAILABLE FOR GAMES BELOW
//
if (equali(g_ModName, "CS", 2) || equali(g_ModName, "CZ", 2) || equali(g_ModName, "DOD", 3) || \
equali(g_ModName, "TFC", 3) || equali(g_ModName, "TS", 2))
return PLUGIN_CONTINUE;
// UNAVAILABLE
//
return PLUGIN_HANDLED;
}
// OK
//
return PLUGIN_CONTINUE;
}
// FILTERS NATIVE
//
public Native_Filter(const Name[], Id, bTrap)
{
// TRAP
//
return !bTrap ? PLUGIN_HANDLED : PLUGIN_CONTINUE;
}
// pfnSpawn()
// CALLED BEFORE "plugin_init"
// THE RIGHT MOMENT FOR INI FILES
// AND PRECACHING DATA
//
public plugin_precache()
{
// CREATES ARRAYS FIRST
//
g_pHShot = ArrayCreate(128);
g_pSuicide = ArrayCreate(128);
g_pGrenade = ArrayCreate(128);
g_pTKill = ArrayCreate(128);
g_pKnife = ArrayCreate(128);
g_pFBlood = ArrayCreate(128);
g_pRStart = ArrayCreate(128);
g_pDKill = ArrayCreate(128);
g_pHattrick = ArrayCreate(128);
g_pFlawless = ArrayCreate(128);
g_pRevenge = ArrayCreate(128);
g_pKStreakSounds = ArrayCreate(128);
g_pKStreakMessages = ArrayCreate(256);
g_pKStreakRequiredKills = ArrayCreate(8);
// READS FILE
//
__Load();
// PRECACHES NOTHING
// IF PLUG-IN IS OFF
//
if (!g_bON)
return;
// RETRIEVES SOUNDS COUNT
//
g_HShotSize = ArraySize(g_pHShot);
g_SuicideSize = ArraySize(g_pSuicide);
g_GrenadeSize = ArraySize(g_pGrenade);
g_TKillSize = ArraySize(g_pTKill);
g_KnifeSize = ArraySize(g_pKnife);
g_FBloodSize = ArraySize(g_pFBlood);
g_RStartSize = ArraySize(g_pRStart);
g_DKillSize = ArraySize(g_pDKill);
g_HattrickSize = ArraySize(g_pHattrick);
g_FlawlessSize = ArraySize(g_pFlawless);
g_RevengeSize = ArraySize(g_pRevenge);
g_KStreakSoundsSize = ArraySize(g_pKStreakSounds);
// DEFINES ITERATOR FOR FURTHER USE
//
new Iterator = 0;
// DEFINES SOUND FOR FURTHER USE
//
new Sound[128];
if (g_bHShot)
{
for (Iterator = 0; Iterator < g_HShotSize; Iterator++)
ArrayGetString(g_pHShot, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bSuicide)
{
for (Iterator = 0; Iterator < g_SuicideSize; Iterator++)
ArrayGetString(g_pSuicide, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bGrenade)
{
for (Iterator = 0; Iterator < g_GrenadeSize; Iterator++)
ArrayGetString(g_pGrenade, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bTKill)
{
for (Iterator = 0; Iterator < g_TKillSize; Iterator++)
ArrayGetString(g_pTKill, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bKnife)
{
for (Iterator = 0; Iterator < g_KnifeSize; Iterator++)
ArrayGetString(g_pKnife, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bFBlood)
{
for (Iterator = 0; Iterator < g_FBloodSize; Iterator++)
ArrayGetString(g_pFBlood, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bRStart)
{
for (Iterator = 0; Iterator < g_RStartSize; Iterator++)
ArrayGetString(g_pRStart, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bDKill)
{
for (Iterator = 0; Iterator < g_DKillSize; Iterator++)
ArrayGetString(g_pDKill, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bHattrick)
{
for (Iterator = 0; Iterator < g_HattrickSize; Iterator++)
ArrayGetString(g_pHattrick, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bFlawless)
{
for (Iterator = 0; Iterator < g_FlawlessSize; Iterator++)
ArrayGetString(g_pFlawless, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bRevenge)
{
for (Iterator = 0; Iterator < g_RevengeSize; Iterator++)
ArrayGetString(g_pRevenge, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
if (g_bKStreak)
{
for (Iterator = 0; Iterator < g_KStreakSoundsSize; Iterator++)
ArrayGetString(g_pKStreakSounds, Iterator, Sound, charsmax(Sound)), precache_sound(Sound);
}
}
// pfnServerDeactivate_Post()
// MAP ENDS
//
public plugin_end()
{
// DESTROYS ARRAYS
//
ArrayDestroy(g_pHShot);
ArrayDestroy(g_pSuicide);
ArrayDestroy(g_pGrenade);
ArrayDestroy(g_pTKill);
ArrayDestroy(g_pKnife);
ArrayDestroy(g_pFBlood);
ArrayDestroy(g_pRStart);
ArrayDestroy(g_pDKill);
ArrayDestroy(g_pHattrick);
ArrayDestroy(g_pFlawless);
ArrayDestroy(g_pRevenge);
ArrayDestroy(g_pKStreakSounds);
ArrayDestroy(g_pKStreakMessages);
ArrayDestroy(g_pKStreakRequiredKills);
}
// pfnServerActivate_Post()
// CALLED AFTER "plugin_precache"
// THE RIGHT MOMENT TO REGISTER STUFF
//
public plugin_init()
{
// REGISTERS PLUG-IN
//
register_plugin("ADV. QUAKE SOUNDS", QS_VERSION, "HATTRICK (HTTRCKCLDHKS)");
// REGISTERS CONSOLE VARIABLE
//
new pCVar = register_cvar("advanced_quake_sounds", QS_VERSION, FCVAR_SERVER | FCVAR_EXTDLL | FCVAR_UNLOGGED | FCVAR_SPONLY);
// SETS CONSOLE VARIABLE STRING
//
if (pCVar)
set_pcvar_string(pCVar, QS_VERSION);
// STOPS HERE IF THE PLUG-IN IS DISABLED
//
if (!g_bON)
return;
// REGISTERS FAKE META FORWARDS
//
register_forward(FM_MessageBegin, "OnMessageBegin", 1);
register_forward(FM_WriteByte, "OnWriteByte", 1);
register_forward(FM_MessageEnd, "OnMessageEnd", 1);
// GETS MAXIMUM PLAYERS
//
g_maxPlayers = get_maxplayers();
// GETS MOD NAME
//
get_modname(g_ModName, charsmax(g_ModName));
// DEATHMSG IS THE ONLY AVAILABLE FOR ESF, NS AND VALVE
// THESE MODS HAVE NO XSTATS MODULE
//
if (equali(g_ModName, "ESF", 3) || equali(g_ModName, "NS", 2) || equali(g_ModName, "VALVE"))
{
g_bDeathMsgOnly = true;
}
// COUNTER-STRIKE
//
if (equali(g_ModName, "CS", 2) || equali(g_ModName, "CZ", 2))
{
// ROUND RESTART
//
register_event("TextMsg", "OnRRestart", "a", "2&#Game_C", "2&#Game_w");
// ROUND START
//
register_logevent("OnRStart", 2, "1=Round_Start");
// ROUND END
//
register_logevent("OnREnd", 2, "1=Round_End");
}
// DAY OF DEFEAT
//
else if (equali(g_ModName, "DOD", 3))
{
// ROUND START
//
register_event("RoundState", "OnRStart", "a", "1=1");
// ROUND END
//
register_event("RoundState", "OnREnd", "a", "1=3", "1=4");
// DISABLES HATTRICK
//
g_bHattrick = false;
// DISABLES FLAWLESS
//
g_bFlawless = false;
}
// NO CS/ CZ OR DOD
//
else
{
// DISABLES TEAM KILL
//
g_bTKill = false;
// DISABLES HATTRICK
//
g_bHattrick = false;
// DISABLES FLAWLESS
//
g_bFlawless = false;
// DISABLES ROUND START
//
g_bRStart = false;
}
// HUD MESSAGE [TE_TEXTMESSAGE] CHANNEL HANDLES
//
g_pHudMsg[HUDMSG_STREAK] = CreateHudSyncObj();
g_pHudMsg[HUDMSG_EVENT] = CreateHudSyncObj();
g_pHudMsg[HUDMSG_ROUND] = CreateHudSyncObj();
}
// pfnServerActivate_Post()
// CALLED AFTER "plugin_init"
// THE RIGHT MOMENT FOR ACTUALIZING CONFIGURATIONS
//
public plugin_cfg()
{
/**
* MESSAGES ON/ OFF
*/
g_bHShotMsg = g_HShotMsg[0] ? true : false;
g_bSuicideMsg = g_SuicideMsg[0] ? true : false;
g_bGrenadeMsg = g_GrenadeMsg[0] ? true : false;
g_bTKillMsg = g_TKillMsg[0] ? true : false;
g_bKnifeMsg = g_KnifeMsg[0] ? true : false;
g_bFBloodMsg = g_FBloodMsg[0] ? true : false;
g_bRStartMsg = g_RStartMsg[0] ? true : false;
g_bDKillMsg = g_DKillMsg[0] ? true : false;
g_bHattrickMsg = g_HattrickMsg[0] ? true : false;
g_bFlawlessMsg = g_FlawlessMsg[0] ? true : false;
g_bRevengeMsgVictim = g_RevengeMsgVictim[0] ? true : false;
g_bRevengeMsgKiller = g_RevengeMsgKiller[0] ? true : false;
}
// pfnClientUserInfoChanged()
// EXECUTES WHEN CLIENT CHANGES INFORMATION
//
public client_infochanged(Player)
{
static NewName[32];
// PLAYER IS CONNECTED AND IT'S NOT A HLTV
//
if (g_bConnected[Player] && !g_bHLTV[Player])
{
// RETRIEVES NEW NAME (IF ANY)
//
get_user_info(Player, "name", NewName, charsmax(NewName));
// UPDATES IF NEEDED
//
if (!equali(NewName, g_Name[Player]))
g_Name[Player] = NewName;
}
}
// pfnClientDisconnect()
// EXECUTES WHEN CLIENT DISCONNECTS
//
public client_disconnect(Player)
{
// NO MORE KILLS
//
g_Kills[Player] = 0;
g_RKills[Player] = 0;
// NO MORE TRUE DATA
//
g_bHLTV[Player] = false;
g_bBOT[Player] = false;
g_bDisabled[Player] = false;
g_bConnected[Player] = false;
// NO MORE VALID STRINGS
//
g_Name[Player][0] = EOS;
g_RevengeStamp[Player][0] = EOS;
}
// pfnClientCommand()
// EXECUTES WHEN CLIENT TYPES
//
public client_command(Player)
{
static Argument[16];
// CONNECTED, NOT BOT AND NOT HLTV
//
if (g_bConnected[Player] && !g_bBOT[Player] && !g_bHLTV[Player])
{
// RETRIEVES THE ARGUMENT
//
read_argv(1, Argument, charsmax(Argument));
// CHECKS ARGUMENT
//
if (equali(Argument, "/qsmg", 7) || equali(Argument, "Sounds", 6))
{
// ENABLES/ DISABLES SOUNDS PER CLIENT
//
client_print(Player, print_chat, ">> QUAKE SOUNDS HAVE BEEN %s.", g_bDisabled[Player] ? "ENABLED" : "DISABLED");
g_bDisabled[Player] = !g_bDisabled[Player];
}
}
}
// pfnClientPutInServer()
// EXECUTES WHEN CLIENT JOINS
//
public client_putinserver(Player)
{
// RETRIEVES PLAYER NAME
//
get_user_name(Player, g_Name[Player], charsmax(g_Name[]));
// HLTV
//
g_bHLTV[Player] = bool:is_user_hltv(Player);
// BOT
//
g_bBOT[Player ] = bool:is_user_bot(Player);
// NO KILLS
//
g_Kills[Player] = 0;
g_RKills[Player] = 0;
// CONNECTED
//
g_bConnected[Player] = true;
// SETTINGS ON
//
g_bDisabled[Player] = true;
// NO REVENGE STAMP YET
//
g_RevengeStamp[Player][0] = EOS;
// PRINTS INFORMATION FOR VALID PLAYERS ONLY
//
if (!g_bBOT[Player] && !g_bHLTV[Player])
set_task(6.0, "QuakeSoundsPrint", Player);
}
// PRINTS INFORMATION TO PLAYER
//
public QuakeSoundsPrint(Player)
{
// ONLY IF CONNECTED
//
if (g_bConnected[Player])
client_print(Player, print_chat, ">> TYPE 'sounds' TO TURN QUAKE SOUNDS ON OR OFF.");
}
// EXECUTED ON PLAYER DEATH
// THIS IS ONLY REQUIRED FOR CS/ CZ, DOD, TS AND TFC
// THIS IS EXECUTED BEFORE DEATHMSG EVENT
//
public client_death(Killer, Victim, wpnID, Place, TK)
{
// CACHES WEAPON ID
//
g_wpnID = wpnID;
// CACHES HIT PLACE
//
g_Place = Place;
// CACHES TEAM KILL BOOLEAN
//
g_TK = TK;
}
// WHEN ROUND RESTARTS
//
public OnRRestart()
{
static Player;
for (Player = 1; Player <= g_maxPlayers; Player++)
{
// CLEARS DATA
//
g_Kills[Player] = 0;
g_RKills[Player] = 0;
g_RevengeStamp[Player][0] = EOS;
}
}
// WHEN ROUND STARTS
//
public OnRStart()
{
static Player;
// RESETS FIRST BLOOD
//
if (g_bFBlood)
g_FBlood = 0;
// PREPARES ROUND START EVENT
//
if (g_bRStart)
{
if (g_bRStartMsg)
{
if (g_bRandomRed) g_Red = random_num(0, QS_MAXBYTE);
if (g_bRandomGreen) g_Green = random_num(0, QS_MAXBYTE);
if (g_bRandomBlue) g_Blue = random_num(0, QS_MAXBYTE);
set_hudmessage(g_Red, g_Green, g_Blue, QS_CENTERPOS, 0.2615, _, _, 5.0);
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_ROUND], g_RStartMsg);
}
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pRStart, random_num(0, g_RStartSize - 1)));
}
// RESETS HATTRICK DATA
//
if (g_bHattrick)
{
for (Player = 1; Player <= g_maxPlayers; Player++)
g_RKills[Player] = 0;
}
}
// WHEN ROUND ENDS
//
public OnREnd()
{
// GETS HATTRICK READY
//
if (g_bHattrick) set_task(2.8, "__Hattrick");
// GETS FLAWLESS READY
//
if (g_bFlawless) set_task(1.2, "__Flawless");
}
// PREPARES HATTRICK
//
public __Hattrick()
{
// RETRIEVES LEADER ID
//
static Leader;
Leader = __Leader();
// IF ANY
//
if (Leader != QS_INVALIDPLR)
{
if (g_bRandomRed) g_Red = random_num(0, QS_MAXBYTE);
if (g_bRandomGreen) g_Green = random_num(0, QS_MAXBYTE);
if (g_bRandomBlue) g_Blue = random_num(0, QS_MAXBYTE);
if (g_RKills[Leader] >= g_MinimumKillsForHattrick)
{
if (g_bHattrickMsg)
{
set_hudmessage(g_Red, g_Green, g_Blue, QS_CENTERPOS, 0.2015, _, _, 5.0);
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_EVENT], g_HattrickMsg, g_Name[Leader]);
}
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pHattrick, random_num(0, g_HattrickSize - 1)));
}
}
}
// PREPARES FLAWLESS
//
public __Flawless()
{
if (g_bRandomRed) g_Red = random_num(0, QS_MAXBYTE);
if (g_bRandomGreen) g_Green = random_num(0, QS_MAXBYTE);
if (g_bRandomBlue) g_Blue = random_num(0, QS_MAXBYTE);
new aliveTeam_1 = __Players(true, 1);
new aliveTeam_2 = __Players(true, 2);
new allTeam_1 = aliveTeam_1 + __Players(false, 1);
new allTeam_2 = aliveTeam_2 + __Players(false, 2);
set_hudmessage(g_Red, g_Green, g_Blue, QS_CENTERPOS, 0.2815, _, _, 5.0);
if (allTeam_1 == aliveTeam_1)
{
if (g_bFlawlessMsg)
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_ROUND], g_FlawlessMsg, g_FlawlessTeamName_1);
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pFlawless, random_num(0, g_FlawlessSize - 1)));
}
else if (allTeam_2 == aliveTeam_2)
{
if (g_bFlawlessMsg)
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_ROUND], g_FlawlessMsg, g_FlawlessTeamName_2);
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pFlawless, random_num(0, g_FlawlessSize - 1)));
}
}
// pfnMessageBegin()
// FIRED WHEN A MESSAGE BEGINS
//
public OnMessageBegin(Destination, Type)
{
static deathMsg = 0;
// GETS DEATHMSG ID
//
if (deathMsg == 0)
deathMsg = get_user_msgid("DeathMsg");
// IF GLOBALLY SENT
//
if (deathMsg > 0 && Type == deathMsg && (Destination == MSG_ALL || Destination == MSG_BROADCAST))
{
g_bOnDeathMsg = true;
g_DeathMsgByteStatus = 0;
}
}
// pfnWriteByte()
// FIRED WHEN A BYTE IS BEING WRITTEN
//
public OnWriteByte(Byte)
{
// OUR DEATHMSG
//
if (g_bOnDeathMsg)
{
// GETS DATA
//
switch (++g_DeathMsgByteStatus)
{
case 1: g_Killer = Byte;
case 2: g_Victim = Byte;
}
}
}
// pfnMessageEnd()
// FIRED WHEN A MESSAGE ENDS
//
public OnMessageEnd()
{
// OUR DEATHMSG
//
if (g_bOnDeathMsg)
{
g_bOnDeathMsg = false;
g_DeathMsgByteStatus = 0;
// FIRES
//
set_task(0.0, "__DeathMsg");
}
}
// WHEN A PLAYER DIES
// THIS IS EXECUTED AFTER XSTATS MODULE "client_death" FORWARD
//
public __DeathMsg()
{
// HIT PLACE
//
new Place = 0;
// PREPARES WEAPON ID AND PLACE
//
if (g_wpnID < 1)
{
new wpnID = 0;
get_user_attacker(g_Victim, wpnID, Place);
// POSSIBLE FIX
//
if (wpnID < 1 && g_bConnected[g_Killer])
wpnID = get_user_weapon(g_Killer);
g_wpnID = wpnID;
}
// POSSIBLE HIT PLACE FIX
//
if (g_Place < 1 && Place > 0)
g_Place = Place;
// PREPARES TEAM KILL BOOLEAN
//
if (g_bDeathMsgOnly && g_bConnected[g_Killer])
g_TK = get_user_team(g_Killer) == get_user_team(g_Victim) ? 1 : 0;
// PROCESSES DEATH
//
__Death(g_Killer, g_Victim, g_wpnID, g_Place, g_TK);
}
/*************************************************************************************
******* FUNCTIONS ********************************************************************
*************************************************************************************/
// PROCESSES CLIENT DEATH FOR ALL MODS
//
__Death(Killer, Victim, wpnID, Place, TK)
{
// VARIABLES
//
static Iterator, Float:gameTime, Weapon[32], Sound[128], Message[256];
// RESETS KILLS FOR VICTIM
//
if (g_bKStreak)
g_Kills[Victim] = 0;
// INVALID KILLER (WORLD)
//
if (!g_bConnected[Killer])
return;
// PREPARES HUD MESSAGE COLOR
//
if (g_bRandomRed) g_Red = random_num(0, QS_MAXBYTE);
if (g_bRandomGreen) g_Green = random_num(0, QS_MAXBYTE);
if (g_bRandomBlue) g_Blue = random_num(0, QS_MAXBYTE);
// PREPARES HUD MESSAGE
//
set_hudmessage(g_Red, g_Green, g_Blue, QS_CENTERPOS, 0.2415, _, _, 5.0);
// REVENGE KILLER STAMP
//
if (g_bRevenge)
g_RevengeStamp[Victim] = g_Name[Killer];
// SUICIDE
//
if (Victim == Killer)
{
if (g_bSuicide)
{
if (g_bSuicideMsg)
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_EVENT], g_SuicideMsg, g_Name[Victim]);
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pSuicide, random_num(0, g_SuicideSize - 1)));
}
if (g_bHattrick)
g_RKills[Victim]--;
}
// NORMAL DEATH
//
else
{
if (g_bKStreak)
g_Kills[Killer]++;
if (g_bHattrick)
g_RKills[Killer]++;
// WEAPON NAME
//
if (wpnID > 0)
get_weaponname(wpnID, Weapon, charsmax(Weapon));
// NO WEAPON
//
else
Weapon[0] = EOS;
if (g_bRevenge && equali(g_Name[Victim], g_RevengeStamp[Killer]))
{
g_RevengeStamp[Killer][0] = EOS;
if (g_bRevengeMsgKiller)
qs_ShowSyncHudMsg(Killer, g_pHudMsg[HUDMSG_EVENT], g_RevengeMsgKiller, g_Name[Victim]);
if (g_bRevengeMsgVictim && !g_bRevengeOnlyKiller)
qs_ShowSyncHudMsg(Victim, g_pHudMsg[HUDMSG_EVENT], g_RevengeMsgVictim, g_Name[Killer]);
qs_client_cmd(Killer, "SPK ^"%a^"", ArrayGetStringHandle(g_pRevenge, random_num(0, g_RevengeSize - 1)));
if (!g_bRevengeOnlyKiller)
qs_client_cmd(Victim, "SPK ^"%a^"", ArrayGetStringHandle(g_pRevenge, random_num(0, g_RevengeSize - 1)));
}
if (g_bHShot && Place == HIT_HEAD)
{
if (g_bHShotMsg)
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_EVENT], g_HShotMsg, g_Name[Killer], g_Name[Victim]);
qs_client_cmd(g_bHShotOnlyKiller ? Killer : 0, "SPK ^"%a^"", ArrayGetStringHandle(g_pHShot, random_num(0, g_HShotSize - 1)));
}
if (g_bFBlood && ++g_FBlood == 1)
{
if (g_bFBloodMsg)
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_EVENT], g_FBloodMsg, g_Name[Killer]);
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pFBlood, random_num(0, g_FBloodSize - 1)));
}
if (g_bTKill && TK > 0)
{
if (g_bTKillMsg)
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_EVENT], g_TKillMsg, g_Name[Killer]);
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pTKill, random_num(0, g_TKillSize - 1)));
}
if (g_bGrenade && (containi(Weapon, "RECK") != -1 || containi(Weapon, "ROCK") != -1 || containi(Weapon, "MK") != -1 || \
containi(Weapon, "GRANATE") != -1 || containi(Weapon, "BOMB") != -1 || containi(Weapon, "GREN") != -1 || \
containi(Weapon, "PIAT") != -1 || containi(Weapon, "BAZOOKA") != -1 || containi(Weapon, "PANZER") != -1))
{
if (g_bGrenadeMsg)
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_EVENT], g_GrenadeMsg, g_Name[Killer], g_Name[Victim]);
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pGrenade, random_num(0, g_GrenadeSize - 1)));
}
if (g_bKnife && (containi(Weapon, "KNIFE") != -1 || containi(Weapon, "SPADE") != -1 || containi(Weapon, "SATCHEL") != -1))
{
if (g_bKnifeMsg)
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_EVENT], g_KnifeMsg, g_Name[Killer], g_Name[Victim]);
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pKnife, random_num(0, g_KnifeSize - 1)));
}
if (g_bDKill)
{
// GAME TIME
//
gameTime = get_gametime();
if (g_fLastKillTimeStamp[Killer] > gameTime)
{
if (g_bDKillMsg)
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_EVENT], g_DKillMsg, g_Name[Killer], g_Name[Victim]);
qs_client_cmd(0, "SPK ^"%a^"", ArrayGetStringHandle(g_pDKill, random_num(0, g_DKillSize - 1)));
}
g_fLastKillTimeStamp[Killer] = gameTime + 0.1;
}
if (g_bKStreak)
{
for (Iterator = 0; Iterator < g_KStreakSoundsSize; Iterator++)
{
if (g_Kills[Killer] == ArrayGetCell(g_pKStreakRequiredKills, Iterator))
{
ArrayGetString(g_pKStreakMessages, Iterator, Message, charsmax(Message));
ArrayGetString(g_pKStreakSounds, Iterator, Sound, charsmax(Sound));
__Display(Killer, Message, Sound);
break;
}
}
}
}
}
// LOADS FILE
//
__Load()
{
// PREPARES CONFIGURATIONS FILE DIRECTORY
//
new File[256];
get_configsdir(File, charsmax(File));
// APPENDS CONFIGURATIONS FILE NAME
//
add(File, charsmax(File), "/quakesounds.ini");
// OPENS FILE
//
new pFile = fopen(File, "r");
if (!pFile)
return;
// PREPARES FILE LINE
//
new Line[512], Key[64], Value[256], Type[32], Sound[128], RequiredKills[8], Dummy[4], Message[256];
// READS FILE
//
while (!feof(pFile))
{
// GETS LINE
//
fgets(pFile, Line, charsmax(Line));
// TRIMS LINE OFF
//
trim(Line);
// CHECK FOR VALIDITY
//
if (Line[0] == EOS || Line[0] == ';' || Line[0] == '#' || (Line[0] == '/' && Line[1] == '/'))
continue;
// SPLITS STRING IN TOKENS
//
strtok(Line, Key, charsmax(Key), Value, charsmax(Value), '=');
// TRIMS KEY
trim(Key);
// TRIMS VALUE
trim(Value);
//
// SETTINGS
//
if (equali(Key, "ENABLE/DISABLE PLUGIN")) g_bON = bool:str_to_num(Value);
else if (equali(Key, "HEADSHOT ONLY KILLER")) g_bHShotOnlyKiller = bool:str_to_num(Value);
else if (equali(Key, "MIN FRAGS FOR HATTRICK")) g_MinimumKillsForHattrick = str_to_num(Value);
else if (equali(Key, "REVENGE ONLY FOR KILLER")) g_bRevengeOnlyKiller = bool:str_to_num(Value);
//
// HUD MESSAGES
//
else if (equali(Key, "HUDMSG RED"))
{
if (equal(Value, "_")) g_bRandomRed = true;
else g_Red = str_to_num(Value);
}
else if (equali(Key, "HUDMSG GREEN"))
{
if (equal(Value, "_")) g_bRandomGreen = true;
else g_Green = str_to_num(Value);
}
else if (equali(Key, "HUDMSG BLUE"))
{
if (equal(Value, "_")) g_bRandomBlue = true;
else g_Blue = str_to_num(Value);
}
// KILLS STREAK SOUNDS
//
else if (equali(Key, "SOUND"))
{
parse(Value, Dummy, charsmax(Dummy), Type, charsmax(Type));
if (equali(Type, "REQUIREDKILLS"))
{
parse(Value, Dummy, charsmax(Dummy), Type, charsmax(Type), RequiredKills, charsmax(RequiredKills), \
Dummy, charsmax(Dummy), Sound, charsmax(Sound));
ArrayPushString(g_pKStreakSounds, Sound);
ArrayPushCell(g_pKStreakRequiredKills, str_to_num(RequiredKills));
}
else if (equali(Type, "MESSAGE"))
{
strtok(Value, Type, charsmax(Type), Message, charsmax(Message), '@');
trim(Message);
ArrayPushString(g_pKStreakMessages, Message);
}
}
//
// EVENTS ON/ OFF
//
else if (equali(Key, "KILLSTREAK EVENT")) g_bKStreak = bool:str_to_num(Value);
else if (equali(Key, "REVENGE EVENT")) g_bRevenge = bool:str_to_num(Value);
else if (equali(Key, "HEADSHOT EVENT")) g_bHShot = bool:str_to_num(Value);
else if (equali(Key, "SUICIDE EVENT")) g_bSuicide = bool:str_to_num(Value);
else if (equali(Key, "NADE EVENT")) g_bGrenade = bool:str_to_num(Value);
else if (equali(Key, "TEAMKILL EVENT")) g_bTKill = bool:str_to_num(Value);
else if (equali(Key, "KNIFE EVENT")) g_bKnife = bool:str_to_num(Value);
else if (equali(Key, "FIRSTBLOOD EVENT")) g_bFBlood = bool:str_to_num(Value);
else if (equali(Key, "ROUNDSTART EVENT")) g_bRStart = bool:str_to_num(Value);
else if (equali(Key, "DOUBLEKILL EVENT")) g_bDKill = bool:str_to_num(Value);
else if (equali(Key, "HATTRICK EVENT")) g_bHattrick = bool:str_to_num(Value);
else if (equali(Key, "FLAWLESS VICTORY")) g_bFlawless = bool:str_to_num(Value);
//
// EVENT SOUNDS
//
else if (equali(Key, "HEADSHOT SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pHShot, Key);
}
}
else if (equali(Key, "REVENGE SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pRevenge, Key);
}
}
else if (equali(Key, "SUICIDE SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pSuicide, Key);
}
}
else if (equali(Key, "NADE SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pGrenade, Key);
}
}
else if (equali(Key, "TEAMKILL SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pTKill, Key);
}
}
else if (equali(Key, "KNIFE SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pKnife, Key);
}
}
else if (equali(Key, "FIRSTBLOOD SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pFBlood, Key);
}
}
else if (equali(Key, "ROUNDSTART SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pRStart, Key);
}
}
else if (equali(Key, "DOUBLEKILL SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pDKill, Key);
}
}
else if (equali(Key, "HATTRICK SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pHattrick, Key);
}
}
else if (equali(Key, "FLAWLESS SOUNDS"))
{
while (Value[0] != EOS && strtok(Value, Key, charsmax(Key), Value, charsmax(Value), ','))
{
trim(Key), trim(Value);
ArrayPushString(g_pFlawless, Key);
}
}
//
// MESSAGE STRINGS
//
else if (equali(Key, "HEADSHOT HUDMSG")) g_HShotMsg = Value;
else if (equali(Key, "SUICIDE HUDMSG")) g_SuicideMsg = Value;
else if (equali(Key, "NADE HUDMSG")) g_GrenadeMsg = Value;
else if (equali(Key, "TEAMKILL HUDMSG")) g_TKillMsg = Value;
else if (equali(Key, "KNIFE HUDMSG")) g_KnifeMsg = Value;
else if (equali(Key, "FIRSTBLOOD HUDMSG")) g_FBloodMsg = Value;
else if (equali(Key, "ROUNDSTART HUDMSG")) g_RStartMsg = Value;
else if (equali(Key, "DOUBLEKILL HUDMSG")) g_DKillMsg = Value;
else if (equali(Key, "HATTRICK HUDMSG")) g_HattrickMsg = Value;
else if (equali(Key, "FLAWLESS VICTORY HUDMSG")) g_FlawlessMsg = Value;
else if (equali(Key, "REVENGE KILLER MESSAGE")) g_RevengeMsgKiller = Value;
else if (equali(Key, "REVENGE VICTIM MESSAGE")) g_RevengeMsgVictim = Value;
else if (equali(Key, "TERRO TEAM NAME")) g_FlawlessTeamName_1 = Value;
else if (equali(Key, "CT TEAM NAME")) g_FlawlessTeamName_2 = Value;
}
// CLOSES
//
fclose(pFile);
}
// DISPLAYS KILLS STREAK GLOBALLY
//
__Display(Killer, Message[], Sound[])
{
if (g_bRandomRed) g_Red = random_num(0, QS_MAXBYTE);
if (g_bRandomGreen) g_Green = random_num(0, QS_MAXBYTE);
if (g_bRandomBlue) g_Blue = random_num(0, QS_MAXBYTE);
set_hudmessage(g_Red, g_Green, g_Blue, QS_CENTERPOS, 0.2215, _, _, 5.0);
qs_ShowSyncHudMsg(0, g_pHudMsg[HUDMSG_STREAK], Message, g_Name[Killer]);
qs_client_cmd(0, "SPK ^"%s^"", Sound);
}
// RETRIEVES PLAYERS COUNT
// bAlive [TRUE/ FALSE]
// Team [QS_INVALIDTEAM/ 1/ 2/ 3]
//
__Players(bool:bAlive, Team = QS_INVALIDTEAM)
{
// PLAYERS COUNT
//
new Total = 0;
// ITERATES BETWEEN PLAYERS
//
for (new Player = 1; Player <= g_maxPlayers; Player++)
{
// CONNECTED, NOT HLTV, IN SPECIFIED TEAM AND ALIVE/ DEAD
//
if (g_bConnected[Player] && !g_bHLTV[Player] && (Team != QS_INVALIDTEAM && \
get_user_team(Player) == Team) && bAlive == bool:is_user_alive(Player))
{
// TOTAL = TOTAL + 1
//
Total++;
}
}
// GETS TOTAL
//
return Total;
}
// RETRIEVES THE LEADER OF THIS ROUND
// RETURNS "QS_INVALIDPLR" IF THERE IS NO LEADER
//
__Leader()
{
// GETS LEADER ID READY
//
new Leader = QS_INVALIDPLR;
// MOST KILLS
//
new Kills = 0;
// ITERATES BETWEEN CLIENTS
//
for (new Client = 1; Client <= g_maxPlayers; Client++)
{
// CONNECTED AND NOT HLTV
//
if (g_bConnected[Client] && !g_bHLTV[Client])
{
// HAS MANY KILLS THAN THE ONE PREVIOUSLY CHECKED
//
if (g_RKills[Client] > Kills)
{
// THIS IS THE NEW LEADER
//
Kills = g_RKills[Client];
Leader = Client;
}
}
}
// GETS LEADER ID
//
return Leader;
}
// PROCESSES HUD MESSAGE
//
qs_ShowSyncHudMsg(Target, pObject, Rules[], any:...)
{
// ARGUMENT FORMAT
//
static Buffer[256], Player;
vformat(Buffer, charsmax(Buffer), Rules, 4);
// SPECIFIED CLIENT
//
if (Target > 0 && g_bConnected[Target] && !g_bBOT[Target] && !g_bHLTV[Target] && !g_bDisabled[Target])
ShowSyncHudMsg(Target, pObject, Buffer);
// NO TARGET
//
else if (Target < 1)
{
for (Player = 1; Player <= g_maxPlayers; Player++)
{
if (g_bConnected[Player] && !g_bBOT[Player] && !g_bHLTV[Player] && !g_bDisabled[Player])
ShowSyncHudMsg(Player, pObject, Buffer);
}
}
}
// PROCESSES CLIENT COMMAND
//
qs_client_cmd(Target, Rules[], any:...)
{
// ARGUMENT FORMAT
//
static Buffer[256], Player;
vformat(Buffer, charsmax(Buffer), Rules, 3);
// SPECIFIED CLIENT
//
if (Target > 0 && g_bConnected[Target] && !g_bBOT[Target] && !g_bHLTV[Target] && !g_bDisabled[Target])
client_cmd(Target, Buffer);
// NO TARGET
//
else if (Target < 1)
{
for (Player = 1; Player <= g_maxPlayers; Player++)
{
if (g_bConnected[Player] && !g_bBOT[Player] && !g_bHLTV[Player] && !g_bDisabled[Player])
client_cmd(Player, Buffer);
}
}
}
