> > > > >

Поиск ultimate killstreak advanced

Статус
В этой теме нельзя размещать новые ответы.
Сообщения
2
Рейтинг
-1
#1
Мне нужен такой
Kills Streak Sounds

3 Frags -> TRIPLE KILL
5 Frags -> MULTI KILL
6 Frags -> RAMPAGE
7 Frags -> KILLING SPREE
9 Frags -> DOMINATING
11 Frags -> UNSTOPPABLE
13 Frags -> MEGA KILL
15 Frags -> ULTRA KILL
16 Frags -> EAGLE EYE
17 Frags -> OWNAGE
18 Frags -> LUDICROUS KILL
19 Frags -> HEAD HUNTER
20 Frags -> WICKED SICK
21 Frags -> MONSTER KILL
23 Frags -> HOLY SHIT
24 Frags -> G O D L I K E
KILL MSG должен появятся с левой стороны с задержкой после килла
 
 
Сообщения
2
Рейтинг
-1
#5
AcE, Там MSG kill на середине монитора показывает , мне нужен с что бы с левой стороны показывал + с задержкой на 5 сек после килла
 
 
Сообщения
31
Рейтинг
4
#6
ELYOR, в чем проблема то? исправить настройки отображения нельзя что ли? в гугле есть статейки на счет настройки hud сообщений! за тебя это делать никто не будет! подбирать координаты) если только платно.
вот тебе в помощь https://dev-cs.ru/threads/1342/#post-40803
 
Последнее редактирование:
2  
Сообщения
2
Рейтинг
-1
#7
Не могу разобраться помогите, мне нужен HUD MSG что бы с левой стороны показывал + с задержкой на 5 сек после килла
/*************************************************************************************
******* PRAGMA ***********************************************************************
*************************************************************************************/

// WHETHER OR NOT TO FORCE ';' AFTER EACH LINE
//
// #pragma semicolon 1

// WHETHER OR NOT TO INCREASE MEMORY FOR THIS SCRIPT
//
#pragma dynamic 524288 // 128 * 128 * 32

// WHETHER OR NOT TO USE '\' AS A CONTROL CHARACTER
// INSTEAD OF THE DEFAULT ONE, WHICH IS '^'
//
// #pragma ctrlchar '\'

// SETS THE TAB SIZE ('\t' AND ' ') TO 0
// GLOBALLY
//
#pragma tabsize 0

// REQUIRES XSTATS MODULE IF AVAILABLE
//
#pragma reqclass xstats

// XSTATS DEFAULTS
//
#pragma defclasslib xstats csx
#pragma defclasslib xstats dodx
#pragma defclasslib xstats tfcx
#pragma defclasslib xstats tsx


/*************************************************************************************
******* HEADERS **********************************************************************
*************************************************************************************/

// AMX MOD X HEADER FILES
//
#include < amxmodx >
#include < amxmisc >

// FAKE META HEADER FILE
//
#include < fakemeta >


/*************************************************************************************
******* DEFINITIONS ******************************************************************
*************************************************************************************/

// SECONDS DELAY TO SHOW THE INFORMATION MESSAGE REGARDING '/SOUNDS' COMMAND
// AFTER THE PLAYER JOINS THE GAME SERVER
//
#define QS_PLUGIN_INFORMATION_DELAY ( 6.0 ) // 6

// HUD MESSAGE'S MAXIMUM LENGTH
//
#define QS_HUD_MESSAGE_MAX_LENGTH ( 384 ) // 384

// CENTERED HUD MESSAGE'S "X" POSITION
//
#define QS_HUD_MESSAGE_X_POSITION ( -1.0 ) // -1

// HUD MESSAGE'S HOLD TIME (SECONDS TO BE DISPLAYED)
//
#define QS_HUD_MESSAGE_HOLD_TIME ( 5.0 ) // 5

// PLUGIN'S VERSION
//
#define QS_PLUGIN_VERSION ( "5.0" ) // "5"

// INVALID PLAYER
//
#define QS_INVALID_PLAYER ( 0x000000FF ) // 255

// MAXIMUM PLAYERS
//
#define QS_MAX_PLAYERS ( 32 ) // 32

// MAXIMUM BYTE (8 BIT)
//
#define QS_MAX_BYTE ( 0x000000FF ) // 255

// INVALID TEAM
//
#define QS_INVALID_TEAM ( 0x000000FF ) // 255

// [ MONSTER KILL, MULTI KILL, UNSTOPPABLE, .. ] HUD MESSAGE'S "Y" (VERTICAL) POSITION
//
#define QS_STREAK_Y_POSITION ( 0.2215 ) // .2215

// [ SUICIDE, KNIFE, GRENADE, .. ] HUD MESSAGE'S "Y" (VERTICAL) POSITION
//
#define QS_MINOR_EVENTS_Y_POSITION ( 0.2415 ) // .2415

// [ PREPARE TO FIGHT, .. ] HUD MESSAGE'S "Y" (VERTICAL) POSITION
//
#define QS_ROUND_START_Y_POSITION ( 0.2615 ) // .2615

// [ FLAWLESS VICTORY EVENT ] HUD MESSAGE'S "Y" (VERTICAL) POSITION
//
#define QS_FLAWLESS_Y_POSITION ( 0.2815 ) // .2815

// [ HATTRICK ( THE LEADER OF THE ROUND ) ] HUD MESSAGE'S "Y" (VERTICAL) POSITION
//
#define QS_HATTRICK_Y_POSITION ( 0.2015 ) // .2015

// 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_bPluginEnabled = 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// REVENGE MESSAGE FOR VICTIM (IF ENABLED)
//
new g_RevengeMsgVictim [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// FLAWLESS TEAM NAME FOR TEAM [1]
//
new g_FlawlessTeamName_1 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// FLAWLESS TEAM NAME FOR TEAM [2]
//
new g_FlawlessTeamName_2 [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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_Weapon = 0;

// CACHED HIT PLACE
//
new g_Place = 0;

// CACHED TEAM KILL BOOLEAN
//
new g_TeamKill = 0;


/**
* PLAYERS RELATED
*/

// MAXIMUM PLAYERS
//
new g_MaxPlayers = 0;

// TOTAL KILLS PER PLAYER PER LIFE
// RESETS ON PLAYER DEATH
//
new g_Kills [ QS_MAX_PLAYERS + 1 ];

// TOTAL KILLS PER PLAYER PER ROUND
// RESETS NEXT ROUND
//
new g_KillsThisRound [ QS_MAX_PLAYERS + 1 ];

// HLTV
//
new bool: g_bHLTV [ QS_MAX_PLAYERS + 1 ];

// BOT
//
new bool: g_bBOT [ QS_MAX_PLAYERS + 1 ];

// CONNECTED
//
new bool: g_bConnected [ QS_MAX_PLAYERS + 1 ];

// NAME
//
new g_Name [ QS_MAX_PLAYERS + 1 ] [ 32 ];

// REVENGE KILL NAME STAMP
//
new g_RevengeStamp [ QS_MAX_PLAYERS + 1 ] [ 32 ];

// SOUNDS DISABLED PER PLAYER
//
new bool: g_bDisabled [ QS_MAX_PLAYERS + 1 ];

// LAST KILL TIME STAMP (GAME TIME)
//
new Float: g_fLastKillTimeStamp [ QS_MAX_PLAYERS + 1 ];


/*************************************************************************************
******* FORWARDS *********************************************************************
*************************************************************************************/

// PLUG-IN NATIVES
//
public plugin_natives ( )
{
// SETS MODULE FILTER
//
set_module_filter ( "QS_Module_Filter" );
}

// FILTERS MODULE
//
public QS_Module_Filter ( Module [ ] )
{
// XSTATS
//
if ( equali ( Module, "XStats" ) )
{
// LOAD
//
return PLUGIN_HANDLED;
}

// OK
//
return PLUGIN_CONTINUE;
}

// plugin_precache()
// THE RIGHT MOMENT FOR INI FILES
// AND PRECACHING DATA
//
public plugin_precache ( )
{
// GETS MOD NAME
//
QS_CheckMod ( );

// CREATES ARRAYS FIRST
//
g_pHShot = ArrayCreate ( 256 );
g_pSuicide = ArrayCreate ( 256 );
g_pGrenade = ArrayCreate ( 256 );
g_pTKill = ArrayCreate ( 256 );
g_pKnife = ArrayCreate ( 256 );
g_pFBlood = ArrayCreate ( 256 );
g_pRStart = ArrayCreate ( 256 );
g_pDKill = ArrayCreate ( 256 );
g_pHattrick = ArrayCreate ( 256 );
g_pFlawless = ArrayCreate ( 256 );
g_pRevenge = ArrayCreate ( 256 );
g_pKStreakSounds = ArrayCreate ( 256 );
g_pKStreakMessages = ArrayCreate ( QS_HUD_MESSAGE_MAX_LENGTH );
g_pKStreakRequiredKills = ArrayCreate ( 8 );

// READS FILE
//
__Load ( );

// PRECACHES NOTHING
// IF PLUG-IN IS OFF
//
if ( !g_bPluginEnabled )
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 [ 256 ];

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 );
}
}

// plugin_end()
// PLUG-IN 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 );
}

// plugin_init()
// PLUG-IN STARTS
// THE RIGHT MOMENT TO REGISTER STUFF
//
public plugin_init ( )
{
// GETS MOD NAME
//
QS_CheckMod ( );

// REGISTERS CONSOLE VARIABLE
//
new pCVar = register_cvar ( "advanced_quake_sounds", QS_PLUGIN_VERSION, ( FCVAR_SERVER | FCVAR_EXTDLL | FCVAR_UNLOGGED | FCVAR_SPONLY ) );

// SETS CONSOLE VARIABLE STRING
//
if ( pCVar )
set_pcvar_string ( pCVar, QS_PLUGIN_VERSION );

// STOPS HERE IF THE PLUG-IN IS DISABLED
//
if ( !g_bPluginEnabled )
{
// REGISTERS PLUG-IN
//
register_plugin ( "ADV. QUAKE SOUNDS (DISABLED)", QS_PLUGIN_VERSION, "HATTRICK (HTTRCKCLDHKS)" );

return;
}

// REGISTERS PLUG-IN
//
register_plugin ( "ADV. QUAKE SOUNDS (ENABLED)", QS_PLUGIN_VERSION, "HATTRICK (HTTRCKCLDHKS)" );

// 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 ( );

// CHECKS WHETHER XSTATS MODULE IS LOADED
//
if ( !module_exists ( "xstats" ) )
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 ( );
}

// plugin_cfg()
// PLUG-IN EXECUTES THE CONFIGURATION FILES
// THE RIGHT MOMENT TO RE-LOAD THE SETTINGS
//
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;
}

// client_infochanged ( Player )
// EXECUTES WHEN CLIENT CHANGES INFORMATION
//
public client_infochanged ( Player )
{
static Name [ 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", Name, charsmax ( Name ) );

// UPDATES IF NEEDED
//
g_Name [ Player ] = Name;
}
}

// client_disconnected(Player)
// EXECUTES AFTER CLIENT DISCONNECTS
//
public client_disconnected ( Player )
{
// NO MORE KILLS
//
g_Kills [ Player ] = g_KillsThisRound [ Player ] = 0;

// NO MORE TRUE DATA
//
g_bHLTV [ Player ] = g_bBOT [ Player ] = g_bDisabled [ Player ] = g_bConnected [ Player ] = false;

// NO MORE VALID STRINGS
//
QS_ClearString ( g_Name [ Player ] );
QS_ClearString ( g_RevengeStamp [ Player ] );
}

// client_command(Player)
// 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, "/Sounds", 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 ];
}
}
}

// client_putinserver(Player)
// 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_KillsThisRound [ Player ] = 0;

// CONNECTED
//
g_bConnected [ Player ] = true;

// SETTINGS ON
//
g_bDisabled [ Player ] = false;

// NO REVENGE STAMP YET
//
QS_ClearString ( g_RevengeStamp [ Player ] );

// PRINTS INFORMATION FOR VALID PLAYERS ONLY
//
if ( !g_bBOT [ Player ] && !g_bHLTV [ Player ] )
set_task ( QS_PLUGIN_INFORMATION_DELAY, "QuakeSoundsInfo", Player );
}

// PRINTS INFORMATION TO PLAYER
//
public QuakeSoundsInfo ( 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 THE DEATH MESSAGE EVENT
//
public client_death ( Killer, Victim, Weapon, Place, TeamKill )
{
// CACHES WEAPON ID
//
g_Weapon = Weapon;

// CACHES HIT PLACE
//
g_Place = Place;

// CACHES TEAM KILL
//
g_TeamKill = TeamKill;
}

// WHEN ROUND RE-STARTS
//
public OnRRestart ( )
{
static Player;
for ( Player = 1; Player <= g_MaxPlayers; Player ++ )
{
// CLEARS DATA
//
g_Kills [ Player ] = 0;
g_KillsThisRound [ Player ] = 0;

QS_ClearString ( g_RevengeStamp [ Player ] );
}
}

// 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_MAX_BYTE );
if ( g_bRandomGreen ) g_Green = random_num ( 0, QS_MAX_BYTE );
if ( g_bRandomBlue ) g_Blue = random_num ( 0, QS_MAX_BYTE );

set_hudmessage ( g_Red, g_Green, g_Blue, QS_HUD_MESSAGE_X_POSITION, QS_ROUND_START_Y_POSITION, _, _, QS_HUD_MESSAGE_HOLD_TIME );
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_ROUND ], g_RStartMsg );
}

QS_ClientCommand ( 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_KillsThisRound [ 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 THE LEADER'S ID
//
static Leader;
Leader = __Leader ( );

// IF ANY
//
if ( Leader != QS_INVALID_PLAYER )
{
if ( g_bRandomRed ) g_Red = random_num ( 0, QS_MAX_BYTE );
if ( g_bRandomGreen ) g_Green = random_num ( 0, QS_MAX_BYTE );
if ( g_bRandomBlue ) g_Blue = random_num ( 0, QS_MAX_BYTE );

if ( g_KillsThisRound [ Leader ] >= g_MinimumKillsForHattrick )
{
if ( g_bHattrickMsg )
{
set_hudmessage ( g_Red, g_Green, g_Blue, QS_HUD_MESSAGE_X_POSITION, QS_HATTRICK_Y_POSITION, _, _, QS_HUD_MESSAGE_HOLD_TIME );
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_EVENT ], g_HattrickMsg, g_Name [ Leader ] );
}

QS_ClientCommand ( 0, "SPK ^"%a^"", ArrayGetStringHandle ( g_pHattrick, random_num ( 0, g_HattrickSize - 1 ) ) );
}
}
}

// PREPARES FLAWLESS
//
public __Flawless ( )
{
static aliveTeam_1, aliveTeam_2;
static allTeam_1, allTeam_2;

if ( g_bRandomRed ) g_Red = random_num ( 0, QS_MAX_BYTE );
if ( g_bRandomGreen ) g_Green = random_num ( 0, QS_MAX_BYTE );
if ( g_bRandomBlue ) g_Blue = random_num ( 0, QS_MAX_BYTE );

aliveTeam_1 = __Players ( true, 1 );
aliveTeam_2 = __Players ( true, 2 );

allTeam_1 = aliveTeam_1 + __Players ( false, 1 );
allTeam_2 = aliveTeam_2 + __Players ( false, 2 );

set_hudmessage ( g_Red, g_Green, g_Blue, QS_HUD_MESSAGE_X_POSITION, QS_FLAWLESS_Y_POSITION, _, _, QS_HUD_MESSAGE_HOLD_TIME );

if ( allTeam_1 == aliveTeam_1 )
{
if ( g_bFlawlessMsg )
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_ROUND ], g_FlawlessMsg, g_FlawlessTeamName_1 );

QS_ClientCommand ( 0, "SPK ^"%a^"", ArrayGetStringHandle ( g_pFlawless, random_num ( 0, g_FlawlessSize - 1 ) ) );
}

else if ( allTeam_2 == aliveTeam_2 )
{
if ( g_bFlawlessMsg )
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_ROUND ], g_FlawlessMsg, g_FlawlessTeamName_2 );

QS_ClientCommand ( 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;

if ( g_bDeathMsgOnly )
g_Weapon = g_Place = g_TeamKill = 0;

// FIRES
//
set_task ( 0.0, "__DeathMsg" );
}
}

// WHEN A PLAYER DIES
// THIS IS EXECUTED AFTER XSTATS MODULE "client_death" FORWARD
//
public __DeathMsg ( )
{
// DECLARES THE HIT PLACE AND THE WEAPON ID
//
static Place, Weapon;

// SETS THE DECLARED VARIABLES TO ZERO
//
Place = Weapon = 0;

// PREPARES THE WEAPON ID AND THE HIT PLACE
//
if ( g_bConnected [ g_Victim ] )
get_user_attacker ( g_Victim, Weapon, Place );

// POSSIBLE WEAPON ID FIX
//
if ( g_Weapon < 1 )
{
if ( Weapon < 1 )
{
if ( g_bConnected [ g_Killer ] )
g_Weapon = get_user_weapon ( g_Killer );
}

else
g_Weapon = Weapon;
}

// POSSIBLE HIT PLACE FIX
//
if ( g_Place < 1 && Place > 0 )
g_Place = Place;

// PREPARES TEAM KILL BOOLEAN IF NEEDED
//
if ( g_bDeathMsgOnly && g_bConnected [ g_Killer ] && g_bConnected [ g_Victim ] )
g_TeamKill = ( get_user_team ( g_Killer ) == get_user_team ( g_Victim ) ) ? 1 : 0;

// PROCESSES DEATH
//
__Death ( g_Killer, g_Victim, g_Weapon, g_Place, g_TeamKill );
}


/*************************************************************************************
******* FUNCTIONS ********************************************************************
*************************************************************************************/

// PROCESSES CLIENT DEATH STUFF FOR ALL MODS
//
__Death ( Killer, Victim, Weapon, Place, TeamKill )
{
// VARIABLES
//
static Iterator = 0, Float: fGameTime = 0.0, WeaponName [ 32 ], Sound [ 256 ], Message [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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_MAX_BYTE );
if ( g_bRandomGreen ) g_Green = random_num ( 0, QS_MAX_BYTE );
if ( g_bRandomBlue ) g_Blue = random_num ( 0, QS_MAX_BYTE );

// PREPARES HUD MESSAGE
//
set_hudmessage ( g_Red, g_Green, g_Blue, QS_HUD_MESSAGE_X_POSITION, QS_MINOR_EVENTS_Y_POSITION, _, _, QS_HUD_MESSAGE_HOLD_TIME );

// REVENGE KILLER STAMP
//
if ( g_bRevenge )
g_RevengeStamp [ Victim ] = g_Name [ Killer ];

// SUICIDE
//
if ( Victim == Killer )
{
if ( g_bSuicide )
{
if ( g_bSuicideMsg )
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_EVENT ], g_SuicideMsg, g_Name [ Victim ] );

QS_ClientCommand ( 0, "SPK ^"%a^"", ArrayGetStringHandle ( g_pSuicide, random_num ( 0, g_SuicideSize - 1 ) ) );
}

if ( g_bHattrick )
g_KillsThisRound [ Victim ] --;
}

// NORMAL DEATH
//
else
{
if ( g_bKStreak )
g_Kills [ Killer ] ++;

if ( g_bHattrick )
g_KillsThisRound [ Killer ] ++;

// WEAPON NAME
//
if ( Weapon > 0 )
get_weaponname ( Weapon, WeaponName, charsmax ( WeaponName ) );

// NO WEAPON
//
else
QS_ClearString ( WeaponName );

if ( g_bRevenge && equali ( g_Name [ Victim ], g_RevengeStamp [ Killer ] ) )
{
QS_ClearString ( g_RevengeStamp [ Killer ] );

if ( g_bRevengeMsgKiller )
QS_ShowHudMsg ( Killer, g_pHudMsg [ HUDMSG_EVENT ], g_RevengeMsgKiller, g_Name [ Victim ] );

if ( g_bRevengeMsgVictim && !g_bRevengeOnlyKiller )
QS_ShowHudMsg ( Victim, g_pHudMsg [ HUDMSG_EVENT ], g_RevengeMsgVictim, g_Name [ Killer ] );

QS_ClientCommand ( Killer, "SPK ^"%a^"", ArrayGetStringHandle ( g_pRevenge, random_num ( 0, g_RevengeSize - 1 ) ) );

if ( !g_bRevengeOnlyKiller )
QS_ClientCommand ( Victim, "SPK ^"%a^"", ArrayGetStringHandle ( g_pRevenge, random_num ( 0, g_RevengeSize - 1 ) ) );
}

if ( g_bHShot && Place == HIT_HEAD )
{
if ( g_bHShotMsg )
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_EVENT ], g_HShotMsg, g_Name [ Killer ], g_Name [ Victim ] );

QS_ClientCommand ( 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_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_EVENT ], g_FBloodMsg, g_Name [ Killer ] );

QS_ClientCommand ( 0, "SPK ^"%a^"", ArrayGetStringHandle ( g_pFBlood, random_num ( 0, g_FBloodSize - 1 ) ) );
}

if ( g_bTKill && TeamKill > 0 )
{
if ( g_bTKillMsg )
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_EVENT ], g_TKillMsg, g_Name [ Killer ] );

QS_ClientCommand ( 0, "SPK ^"%a^"", ArrayGetStringHandle ( g_pTKill, random_num ( 0, g_TKillSize - 1 ) ) );
}

if ( g_bGrenade && ( containi ( WeaponName, "RECK" ) != -1 || \
containi ( WeaponName, "ROCK" ) != -1 || \
containi ( WeaponName, "MK" ) != -1 || \
containi ( WeaponName, "GRANATE" ) != -1 || \
containi ( WeaponName, "BOMB" ) != -1 || \
containi ( WeaponName, "GREN" ) != -1 || \
containi ( WeaponName, "PIAT" ) != -1 || \
containi ( WeaponName, "BAZOOKA" ) != -1 || \
containi ( WeaponName, "PANZER" ) != -1 ) )
{
if ( g_bGrenadeMsg )
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_EVENT ], g_GrenadeMsg, g_Name [ Killer ], g_Name [ Victim ] );

QS_ClientCommand ( 0, "SPK ^"%a^"", ArrayGetStringHandle ( g_pGrenade, random_num ( 0, g_GrenadeSize - 1 ) ) );
}

if ( g_bKnife && ( containi ( WeaponName, "KNIFE" ) != -1 || \
containi ( WeaponName, "SPADE" ) != -1 || \
containi ( WeaponName, "SATCHEL" ) != -1 ) )
{
if ( g_bKnifeMsg )
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_EVENT ], g_KnifeMsg, g_Name [ Killer ], g_Name [ Victim ] );

QS_ClientCommand ( 0, "SPK ^"%a^"", ArrayGetStringHandle ( g_pKnife, random_num ( 0, g_KnifeSize - 1 ) ) );
}

if ( g_bDKill )
{
// GAME TIME
//
fGameTime = get_gametime ( );

if ( g_fLastKillTimeStamp [ Killer ] > fGameTime )
{
if ( g_bDKillMsg )
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_EVENT ], g_DKillMsg, g_Name [ Killer ], g_Name [ Victim ] );

QS_ClientCommand ( 0, "SPK ^"%a^"", ArrayGetStringHandle ( g_pDKill, random_num ( 0, g_DKillSize - 1 ) ) );
}

g_fLastKillTimeStamp [ Killer ] = fGameTime + 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 THE 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 [ 1024 ], Key [ 256 ], Value [ 768 ], Type [ 512 ], Sound [ 256 ], RequiredKills [ 8 ], Dummy [ 4 ], Message [ QS_HUD_MESSAGE_MAX_LENGTH ];

// 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_bPluginEnabled = 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" ) ) copy ( g_HShotMsg, charsmax ( g_HShotMsg ), Value );
else if ( equali ( Key, "SUICIDE HUDMSG" ) ) copy ( g_SuicideMsg, charsmax ( g_SuicideMsg ), Value );
else if ( equali ( Key, "NADE HUDMSG" ) ) copy ( g_GrenadeMsg, charsmax ( g_GrenadeMsg ), Value );
else if ( equali ( Key, "TEAMKILL HUDMSG" ) ) copy ( g_TKillMsg, charsmax ( g_TKillMsg ), Value );
else if ( equali ( Key, "KNIFE HUDMSG" ) ) copy ( g_KnifeMsg, charsmax ( g_KnifeMsg ), Value );
else if ( equali ( Key, "FIRSTBLOOD HUDMSG" ) ) copy ( g_FBloodMsg, charsmax ( g_FBloodMsg ), Value );
else if ( equali ( Key, "ROUNDSTART HUDMSG" ) ) copy ( g_RStartMsg, charsmax ( g_RStartMsg ), Value );
else if ( equali ( Key, "DOUBLEKILL HUDMSG" ) ) copy ( g_DKillMsg, charsmax ( g_DKillMsg ), Value );
else if ( equali ( Key, "HATTRICK HUDMSG" ) ) copy ( g_HattrickMsg, charsmax ( g_HattrickMsg ), Value );
else if ( equali ( Key, "FLAWLESS VICTORY HUDMSG" ) ) copy ( g_FlawlessMsg, charsmax ( g_FlawlessMsg ), Value );
else if ( equali ( Key, "REVENGE KILLER MESSAGE" ) ) copy ( g_RevengeMsgKiller, charsmax ( g_RevengeMsgKiller ), Value );
else if ( equali ( Key, "REVENGE VICTIM MESSAGE" ) ) copy ( g_RevengeMsgVictim, charsmax ( g_RevengeMsgVictim ), Value );
else if ( equali ( Key, "TERRO TEAM NAME" ) ) copy ( g_FlawlessTeamName_1, charsmax ( g_FlawlessTeamName_1 ), Value );
else if ( equali ( Key, "CT TEAM NAME" ) ) copy ( g_FlawlessTeamName_2, charsmax ( g_FlawlessTeamName_2 ), Value );
}

// CLOSES
//
fclose ( pFile );
}

// DISPLAYS KILLS STREAK GLOBALLY
//
__Display ( Killer, Message [ ], Sound [ ] )
{
if ( g_bRandomRed ) g_Red = random_num ( 0, QS_MAX_BYTE );
if ( g_bRandomGreen ) g_Green = random_num ( 0, QS_MAX_BYTE );
if ( g_bRandomBlue ) g_Blue = random_num ( 0, QS_MAX_BYTE );

set_hudmessage ( g_Red, g_Green, g_Blue, QS_HUD_MESSAGE_X_POSITION, QS_STREAK_Y_POSITION, _, _, QS_HUD_MESSAGE_HOLD_TIME );
QS_ShowHudMsg ( 0, g_pHudMsg [ HUDMSG_STREAK ], Message, g_Name [ Killer ] );

QS_ClientCommand ( 0, "SPK ^"%s^"", Sound );
}

// RETRIEVES PLAYERS COUNT
// bAlive [ TRUE/ FALSE ]
// Team [ QS_INVALID_TEAM / 1 / 2 / 3 ]
//
__Players ( bool: bAlive, Team = QS_INVALID_TEAM )
{
// PLAYERS COUNT
//
static Total, Player;

// ITERATES BETWEEN PLAYERS
//
for ( Total = 0, Player = 1; Player <= g_MaxPlayers; Player ++ )
{
// CONNECTED, NOT HLTV, IN SPECIFIED TEAM AND ALIVE/ DEAD
//
if ( g_bConnected [ Player ] && !g_bHLTV [ Player ] && \
( Team != QS_INVALID_TEAM && ( 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_INVALID_PLAYER" IF THERE IS NO LEADER
//
__Leader ( )
{
// DECLARES VARIABLES
//
static Leader, Kills, Client;

// ITERATES BETWEEN CLIENTS
//
for ( Client = 1, Leader = QS_INVALID_PLAYER, Kills = 0; 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_KillsThisRound [ Client ] > Kills )
{
// THIS IS THE NEW LEADER
//
Kills = g_KillsThisRound [ Client ];
Leader = Client;
}
}
}

// GETS LEADER ID
//
return Leader;
}

// PROCESSES HUD MESSAGE
//
QS_ShowHudMsg ( Target, pObject, Rules [ ], any: ... )
{
// ARGUMENT FORMAT
//
static Buffer [ QS_HUD_MESSAGE_MAX_LENGTH ], 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_ClientCommand ( 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 );
}
}
}

// CLEARS STRING
//
QS_ClearString ( String [ ] )
{
String [ 0 ] = EOS;
}

// CHECKS MOD
//
QS_CheckMod ( )
{
if ( g_ModName [ 0 ] == EOS )
get_modname ( g_ModName, charsmax ( g_ModName ) );
}
 
Сообщения
851
Рейтинг
938
#8
ELYOR, в блоке дефайнов полностью все настройки есть, даже с комментариями.
Минус за то что не уважаете правила форума и не вставляете код в специальный бб-код
 
1  
Сообщения
851
Рейтинг
938
#10
2  
Статус
В этой теме нельзя размещать новые ответы.

Пользователи, читающие эту тему

Сейчас на форуме нет ни одного пользователя.

Похожие темы

Ответы
82
Просмотры
9.518
Ответы
28
Просмотры
2.274
Ответы
13
Просмотры
397
> > > > >