ultimate killstreak advanced

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