#include <amxmisc>
#include <amxmodx>
#include <fakemeta>
#include <fun>
#include <cstrike>
#include <hamsandwich>
#include <engine>
#include <nvault>
#include <vault>

#define PLUGIN "Knife-Mod"
#define VERSION "V1.5"
#define AUTHOR "Striker07"


/*////////////////// Credits: \\\\\\\\\\\\\\\\\\
// Pastout      For the use of his colorprint & Pointssystem
// ZP Dev Team      For the use of their leapjump code
// ConnorMcLeod     For the use of his Bhop Plugin
// SchlumPF     For the use of his Knife Distance plugin
// Exolent[jNr]     For making the save/load for saving perm items
*/

/*______________________________________________________________________________________________________________________
|Still to-do:                                                       |
|       - Perm Upgrade Endurance (faster slash & stab)                              |
|       - Making so that players can sell their perm items & skins                          |
|                                                           |
|Need help for:                                                     |
|       - Perm Upgrade Endurance (faster slash & stab)  [ fwd_Knife_PriAtk_Post & fwd_Knife_SecAtk_Post ]   |
|                                                               |
|______________________________________________________________________________________________________________________*/
/*  Includes:
        - A pointssystem
        - A knifeshop including skinsshop
        - Knifemodmenu
        - Give/take/reset tokens commands for admins
        - Knife distance meter from SchlumPF witch extra points for godlike and wicked sick kills
        - Cvars config file for easy configuration
        - Only nVault, NO mySQL support



*/

//  This you can customize to your needs. [

#define ADMIN_TOKENS        ADMIN_LEVEL_H   // access to give/take/set tokens
#define skin3           "vip"
#define skin4           "assassin_t"
#define skin5           "chucky"
#define skin6           "superleet"
#define skin7           "crysis_us"

new const g_szPluginPrefix[] = "Knife-Mod";

// Do NOT uncomment all 3 will not work... either uncomment SAVE_METHOD_NICK OR SAVE_METHOD_IP OR SAVE_METHOD_ID
// To save player data by nick, uncomment "//#define SAVE_METHOD_NICK"
//#define SAVE_METHOD_NICK
// To save player data by ip, uncomment "//#define SAVE_METHOD_IP"
//#define SAVE_METHOD_IP
// To save player data by id, uncomment "//#define SAVE_METHOD_ID"
#define SAVE_METHOD_ID

//  ] See cvars in the config file for further configuration


#define get_bit(%1,%2)      (%1 & 1<<(%2&31))
#define set_bit(%1,%2)      %1 |= (1<<(%2&31))
#define clear_bit(%1,%2)    %1 &= ~(1<<(%2&31))

new g_iMaxPlayers;
#define FIRST_PLAYER_ID 1
#define IsPlayer(%1) (FIRST_PLAYER_ID <= %1 <= g_iMaxPlayers)
new g_iMsgSayText;

#pragma semicolon 1

#define OFFSET_CAN_LONGJUMP    356 // VEN
#define BUNNYJUMP_MAX_SPEED_FACTOR 1.7
#define PLAYER_JUMP     6

#define m_flNextPrimaryAttack 46
#define m_flNextSecondaryAttack 47
#define OFFSET_LINUX_WEAPONS 4

enum AttackType
{
    STAB = 0,
    SLASH
};

enum TraceType
{
    TRACELINE = 0,
    TRACEHULL
};

enum Sound
{
    WICKEDSICK = 0,
    GODLIKE
};

enum HitData
{
    AttackType:iAttack,
    Float:flDistance,
    iHitgroup,
    iAttacker,
    iVictim
};

new g_szTraceType[TraceType][] =
{
    "TraceLine",
    "TraceHull"
};

new g_szSound[Sound][] =
{
    "misc/wickedsick.wav",
    "misc/godlike.wav"
};

new g_HitData[HitData];

new g_szHitgroup[8][] =
{
    "Full Body",
    "Head",
    "Chest",
    "Stomach",
    "Left Arm",
    "Right Arm",
    "Left Leg",
    "Right Leg"
};

const MAX_PLAYERS = 32;

#if defined SAVE_METHOD_NICK
new g_iAuth[MAX_PLAYERS+1][32];
#endif
#if defined SAVE_METHOD_IP
new g_iAuthIP[MAX_PLAYERS+1][32];
#endif
#if defined SAVE_METHOD_ID
new g_iAuthID[MAX_PLAYERS+1][32];
#endif

new g_vault;                // Open a new vault to store a players points.
new g_iPoints[MAX_PLAYERS+1];       // Amount of Points a player has
new g_bHeadShot[MAX_PLAYERS+1][MAX_PLAYERS+1];
new bitvault;

new Float:g_LeapLastTime[MAX_PLAYERS+1];
#define HITGROUP_HEAD 1


//Bhop code
new g_iCdWaterJumpTime[MAX_PLAYERS+1];
new bool:g_bAlive[MAX_PLAYERS+1];
new bool:g_bAutoBhop[MAX_PLAYERS+1];
new g_pcvarBhopStyle, g_pcvarAutoBhop, g_pcvarFallDamage;
new g_pcvarGravity;

new g_pRemoveBomb;

new knife_model[33];
new g_Menu;

//Shop

//extra items
new g_bHasBhop;
new g_bHasLeap;
new g_bHasNadePack;
new g_bHasLowGravity;
new g_bHasSpeed;

//perm upgrades
new g_bHasPermVital;
new g_bHasEndur;
new g_bHasPermGrav;
new g_bHasPermSpeed;
new g_bHasPermInvis;

//skins
new g_bHasSkin1;
new g_bHasSkin2;
new g_bHasSkin3;
new g_bHasSkin4;
new g_bHasSkin5;
new g_bHasSkin6;
new g_bHasSkin7;
new g_bChoseSkin1;
new g_bChoseSkin2;
new g_bChoseSkin3;
new g_bChoseSkin4;
new g_bChoseSkin5;
new g_bChoseSkin6;
new g_bChoseSkin7;
new g_bHasKnifeSkin1;
new g_bHasKnifeSkin2;
new g_bHasKnifeSkin3;
new g_bHasKnifeSkin4;
new g_bChoseKnifeSkin1;
new g_bChoseKnifeSkin2;
new g_bChoseKnifeSkin3;
new g_bChoseKnifeSkin4;

//new g_bHasDied;

/////////////////////////////////////////
////////////// Cvars ////////////////////
new km_tokens_kill; // Tokens per kill
new km_tokens_hskill;   // Tokens per headshot kill
new km_tokens_godlike;      // extra tokens for a godlike kill
new km_tokens_wickedsick;   // extra tokens for a wickedsick kill
//extra items
new km_cost_bhop;
new km_cost_leap;
new km_leap_force, km_leap_height, km_leap_cooldown;
new km_cost_nadepack;
new km_cost_lowgravity;
new km_val_lowgravity;
new km_cost_speed;
new km_val_speed;

// Permanent upgrades
new km_cost_permvitality;
new km_val_permvitality;
new km_cost_permendurance;
new km_val_permendurance;
new km_cost_permgravity;
new km_val_permgravity;
new km_cost_permspeed;
new km_val_permspeed;
new km_cost_perminvisibility;
new km_val_permvisibility;

// Skins
new km_cost_skin1;
//new km_skin1_folder;
new km_cost_skin2;
//new km_skin2_folder;
new km_cost_skin3;
//new km_skin3_folder;
new km_cost_skin4;
//new km_skin4_folder;
new km_cost_skin5;
//new km_skin5_folder;
new km_cost_skin6;
new km_cost_skin7;
new km_cost_knifeskin1;
new km_cost_knifeskin2;
new km_cost_knifeskin3;
new km_cost_knifeskin4;

//knife distance by SchlumPF
new bool:g_bKnifeHit;

new g_szNickname[33][32];

new g_pCVarFriendlyFire;

new g_pCVarSoundWickedSickStab;
new g_pCVarSoundGodlikeStab;
new g_pCVarSoundWickedSickSlash;
new g_pCVarSoundGodlikeSlash;

new g_pCVarHudColor;
new g_pCVarHudCoords;
new g_pCVarHudHoldtime;

new g_iSpray;
new g_iDrop;

new Float:modMeter = 32.00;

public plugin_init()
{
    register_plugin(PLUGIN, VERSION, AUTHOR);

    register_clcmd("say /knifeshop", "Knifeshop");
    register_clcmd("say knifeshop", "Knifeshop");
    register_clcmd("say /shop", "Knifeshop");
    register_clcmd("say shop", "Knifeshop");
    register_clcmd("say /knife", "display_knife");
    register_clcmd("say knife", "display_knife");
    register_clcmd("say /skins", "wear_skins_menu");
    register_clcmd("say skins", "wear_skins_menu");
    register_clcmd("say knifemodmenu", "knifemodmenu");
    register_clcmd("say /knifemodmenu", "knifemodmenu");
    register_clcmd("say kmmenu", "knifemodmenu");

    register_concmd("amx_take_tokens", "cmd_take_tokens", ADMIN_TOKENS, "<target> <amount>");
    register_concmd("amx_give_tokens", "cmd_give_tokens", ADMIN_TOKENS, "<target> <amount>");
    register_concmd("amx_reset_tokens", "cmd_reset_tokens", ADMIN_TOKENS, "<target>");
    register_concmd("amx_autobhop", "AdminCmd_Bhop", ADMIN_TOKENS, "<nick|#userid> <0|1>");

    register_forward(FM_PlayerPreThink, "fw_PlayerPreThink");
    register_forward(FM_UpdateClientData, "UpdateClientData");
    register_forward(FM_CmdStart, "CmdStart");
    register_forward( FM_TraceLine, "FM_TraceLine_Post", 1 );
    register_forward( FM_TraceHull, "FM_TraceHull_Post", 1 );
    RegisterHam(Ham_Weapon_PrimaryAttack, "weapon_knife", "fwd_Knife_PriAtk_Post", 1);
    RegisterHam(Ham_Weapon_SecondaryAttack, "weapon_knife", "fwd_Knife_SecAtk_Post", 1);
    RegisterHam(Ham_Player_Jump, "player", "Player_Jump");
    RegisterHam(Ham_Spawn, "player", "Fwd_PlayerSpawn_Post", 1);
    RegisterHam(Ham_Killed, "player", "Fwd_PlayerKilled_Pre", 0);
    RegisterHam(Ham_Killed, "player", "Check_Alive", 1);
    RegisterHam(Ham_TakeDamage, "player", "Ham_TakeDamage_player");
    RegisterHam(Ham_TraceAttack, "player", "Fwd_TraceAttack_Player_Post", 1);

    register_logevent("roundstart",2,"1=Round_Start");
    register_logevent("roundend",2,"1=Round_End");
    register_event( "Damage", "eventDamage", "b" );
    register_event("Money", "EventMoney", "b");
    register_event("CurWeapon","CurWeapon","be","1=1") ;

    g_Menu = register_menuid("Knife Models");
    register_menucmd(g_Menu, 1023, "knifemenu");

    g_pcvarGravity = get_cvar_pointer("sv_gravity"); //bhop code
    g_pCVarFriendlyFire = get_cvar_pointer( "mp_friendlyfire" );
    g_pRemoveBomb = register_cvar( "km_removebomb", "1" );

//  CVARS
    km_tokens_kill      = register_cvar( "km_tokens_kill", "3");
    km_tokens_hskill    = register_cvar( "km_tokens_hskill", "5");
    km_tokens_godlike   = register_cvar( "km_tokens_godlike", "4");
    km_tokens_wickedsick    = register_cvar( "km_tokens_wickedsick", "2");

    g_pcvarBhopStyle    = register_cvar( "bhop_style", "2"); // (1 : no slowdown, 2 : no speed limit)
    g_pcvarAutoBhop     = register_cvar( "bhop_auto", "1");
    g_pcvarFallDamage   = register_cvar( "mp_falldamage", "1.0");
    //extra items
    km_cost_bhop        = register_cvar( "km_cost_bhop", "15");
    km_cost_leap        = register_cvar( "km_cost_leap", "10");
    km_leap_force       = register_cvar( "km_leap_force", "500");
    km_leap_height      = register_cvar( "km_leap_height", "290");
    km_leap_cooldown    = register_cvar( "km_leap_cooldown", "2.3");
    km_cost_nadepack    = register_cvar( "km_cost_nadepack", "15");
    km_cost_lowgravity  = register_cvar( "km_cost_lowgravity", "8");
    km_val_lowgravity   = register_cvar( "km_val_lowgravity", "0.18"); // percentage of lower gravity to give(default; 800== 1 - amount = gravity the player will have (eg:1-0.15==0.85  =  800*0.85 = 680
    km_cost_speed       = register_cvar( "km_cost_speed", "8");
    km_val_speed        = register_cvar( "km_val_extra-speed", "78");
    // Permanent upgrades
    km_cost_permvitality    = register_cvar( "km_cost_permvitality", "300");
    km_val_permvitality = register_cvar( "km_val_permvitality", "25");
    km_cost_permendurance   = register_cvar( "km_cost_permendurance", "300");
    km_val_permendurance    = register_cvar( "km_val_permendurance", "0.1");
    km_cost_permgravity = register_cvar( "km_cost_permgravity", "250");
    km_val_permgravity  = register_cvar( "km_val_permgravity", "0.25");
    km_cost_permspeed   = register_cvar( "km_cost_permspeed", "300");
    km_val_permspeed    = register_cvar( "km_val_permspeed", "90");
    km_cost_perminvisibility = register_cvar( "km_cost_perminvisibility", "200");
    km_val_permvisibility   = register_cvar( "km_val_permvisibility", "59");
    // Skins
    km_cost_skin1       = register_cvar( "km_cost_skin1", "75");
    //km_skin1_folder       = register_cvar( "km_skin1_folder", "vip");
    km_cost_skin2       = register_cvar( "km_cost_skin2", "75");
    //km_skin2_folder       = register_cvar( "km_skin2_folder", "vip");
    km_cost_skin3       = register_cvar( "km_cost_skin3", "20");
    //km_skin3_folder       = register_cvar( "km_skin3_folder", "vip");
    km_cost_skin4       = register_cvar( "km_cost_skin4", "50");
    //km_skin4_folder       = register_cvar( "km_skin4_folder", "vip");
    km_cost_skin5       = register_cvar( "km_cost_skin5", "50");
    //km_skin5_folder       = register_cvar( "km_skin5_folder", "vip");
    km_cost_skin6       = register_cvar( "km_cost_skin6", "50");
    km_cost_skin7       = register_cvar( "km_cost_skin7", "50");
    km_cost_knifeskin1  = register_cvar( "km_cost_knifeskin1", "40");
    km_cost_knifeskin2  = register_cvar( "km_cost_knifeskin2", "20");
    km_cost_knifeskin3  = register_cvar( "km_cost_knifeskin3", "20");
    km_cost_knifeskin4  = register_cvar( "km_cost_knifeskin4", "20");
// knife distance
    g_pCVarSoundWickedSickStab   = register_cvar( "km_sound_wickedsick_stab", "0.925" );
    g_pCVarSoundGodlikeStab      = register_cvar( "km_sound_godlike_stab", "0.975" );
    g_pCVarSoundWickedSickSlash  = register_cvar( "km_sound_wickedsick_slash", "1.385" );
    g_pCVarSoundGodlikeSlash     = register_cvar( "km_sound_godlike_slash", "1.460" );

    g_pCVarHudColor          = register_cvar( "km_hud_color", "255 144 0" );
    g_pCVarHudCoords         = register_cvar( "km_hud_coords", "-0.75 -1.0" );
    g_pCVarHudHoldtime       = register_cvar( "km_hud_holdtime", "8.0" );
//------------------------------------------------------

    g_iMsgSayText       = get_user_msgid( "SayText" );
    g_iMaxPlayers       = get_maxplayers();

    #if defined SAVE_METHOD_NICK
    g_vault = nvault_open("km_tokens_nick");
    #endif
    #if defined SAVE_METHOD_IP
    g_vault = nvault_open("km_tokens_ip");
    #endif
    #if defined SAVE_METHOD_ID
    g_vault = nvault_open("km_tokens");
    #endif
    if(g_vault == INVALID_HANDLE)
        set_fail_state( "Error opening tokens Vault" );

    bitvault = nvault_open("bits_vault");
    if(bitvault == INVALID_HANDLE)
        set_fail_state( "Error opening bits Vault" );

    if( get_pcvar_num( g_pRemoveBomb ) )
    {
        remove_entity_name( "func_bomb_target" );
        remove_entity_name( "info_bomb_target" );
    }


    set_task(300.0, "kmodmsg", 0, _, _, "b");
}

public plugin_precache()
{
    precache_sound( g_szSound[WICKEDSICK] );
    precache_sound( g_szSound[GODLIKE] );

    g_iDrop = precache_model("sprites/blood.spr");
    g_iSpray = precache_model("sprites/bloodspray.spr");

    precache_model("models/knife-mod/v_butcher.mdl");
    precache_model("models/knife-mod/p_butcher.mdl");
    precache_model("models/knife-mod/v_machete.mdl");
    precache_model("models/knife-mod/p_machete.mdl");
    precache_model("models/knife-mod/darthmaul_knife.mdl");
    precache_model("models/knife-mod/darthmaul_p_knife.mdl");
    precache_model("models/knife-mod/v_katana.mdl");
    precache_model("models/knife-mod/p_katana.mdl");
    precache_model("models/knife-mod/v_supercut.mdl");
    precache_model("models/knife-mod/p_supercut.mdl");
    precache_model("models/v_knife.mdl");
    precache_model("models/p_knife.mdl");
    precache_model("models/knife-mod/v_knife_wolf.mdl");
    precache_model("models/knife-mod/v_light_blue.mdl");
    precache_model("models/knife-mod/p_light_blue.mdl");
    precache_model("models/knife-mod/v_light_green.mdl");
    precache_model("models/knife-mod/p_light_green.mdl");
    precache_model("models/knife-mod/v_light_pink.mdl");
    precache_model("models/knife-mod/p_light_pink.mdl");
    precache_model("models/knife-mod/v_light_turq.mdl");
    precache_model("models/knife-mod/p_light_turq.mdl");
    precache_model("models/knife-mod/v_light_red.mdl");
    precache_model("models/knife-mod/p_light_red.mdl");
    precache_model("models/knife-mod/v_knife_kujang.mdl");
    precache_model("models/knife-mod/p_knife_kujang.mdl");
    precache_model("models/knife-mod/v_baxe.mdl");
    precache_model("models/knife-mod/p_baxe.mdl");
    precache_model("models/knife-mod/v_knife_halo.mdl");
    precache_model("models/knife-mod/p_knife_halo.mdl");


}

public roundstart()
{
    static iPlayers[32], iNum, iPlayer, i;
    get_players( iPlayers, iNum );
    for( i = 0; i < iNum; i++ )
    {
        iPlayer = iPlayers[i];

        if(get_bit(g_bHasSpeed, iPlayer) )
            item_speed(iPlayer);
    }
    /* this plugin is tailord for mp_freezetime 0,
    if you work with freezetimes then you miht wanna replace some parts of the code in ham_playerspawn_post
    into here becous ham_playerspawn_post is called as soon as you respawn and event roundstart is called
    after the freezetime
        (fe: working with freezetime can influence the speed items)
    */
}

public roundend()
{
    /* Here you could reset bits from players who have bought extra items
       if you dont want the extra items to last until they die
    */
}

public plugin_end(){
    nvault_close(g_vault);
    nvault_close(bitvault);
}

public knifemodmenu(id)
{
    new menu = menu_create("\yKnifemodmenu", "knifemodmenu_handler");
    menu_additem(menu, "Free knife skins", "1");
    menu_additem(menu, "Tokens Shop Menu ", "2");
    menu_additem(menu, "Bought skins wardrobe", "3");

    menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, menu, 0);
}

public knifemodmenu_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);
        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            display_knife(id);

        }
        case 2:
        {
            Knifeshop(id);
        }
        case 3:
        {
            wear_skins_menu(id);
        }
    }

    menu_destroy(menu);
    return PLUGIN_HANDLED;
}


public display_knife(id) {

    new menuBody[512];
    add(menuBody, 511, "\yKnife Models\w^n^n");
    add(menuBody, 511, "1. Default knife ^n");
    add(menuBody, 511, "2. Butcher Knife ^n");
    add(menuBody, 511, "3. Machete  ^n");
    add(menuBody, 511, "4. Wolverine's Implants ^n");
    add(menuBody, 511, "5. Darth Maul Lightsaber ^n");
    add(menuBody, 511, "6. Supergutter ^n");
    add(menuBody, 511, "7. Katana  ^n^n");
    add(menuBody, 511, "0. Exit^n");

    new keys = ( 1<<0 | 1<<1 | 1<<2 | 1<<3 | 1<<4 | 1<<5 | 1<<6 /*| 1<<9*/);
    show_menu(id, keys, menuBody, -1, "Knife Models");

    return PLUGIN_HANDLED;
}

public knifemenu(id, key) {
    switch(key)
    {
            case 0: SetKnife(id , 0);
            case 1: SetKnife(id , 1);
            case 2: SetKnife(id , 2);
            case 3: SetKnife(id , 3);
            case 4: SetKnife(id , 4);
            case 5: SetKnife(id , 5);
            case 6: SetKnife(id , 6);
            default: return PLUGIN_HANDLED;
    }
    SaveKnife(id);
    return PLUGIN_HANDLED;
}

public SetKnife(id , Knife) {
    knife_model[id] = Knife;

    new Clip, Ammo, Weapon = get_user_weapon(id, Clip, Ammo);
    if ( Weapon != CSW_KNIFE )
        return PLUGIN_HANDLED;

    new vModel[56],pModel[56];

    switch(Knife)
    {
        case 0: {
            format(vModel,55,"models/v_knife.mdl");
            format(pModel,55,"models/p_knife.mdl");
        }
        case 1: {
            format(vModel,55,"models/knife-mod/v_butcher.mdl");
            format(pModel,55,"models/knife-mod/p_butcher.mdl");
        }
        case 2: {
            format(vModel,55,"models/knife-mod/v_machete.mdl");
            format(pModel,55,"models/knife-mod/p_machete.mdl");
        }
        case 3: {
            format(vModel,55,"models/knife-mod/v_knife_wolf.mdl");
        }
        case 4: {
            format(vModel,55,"models/knife-mod/darthmaul_knife.mdl");
            format(pModel,55,"models/knife-mod/darthmaul_p_knife.mdl");
        }
        case 5: {
            format(vModel,55,"models/knife-mod/v_supercut.mdl");
            format(pModel,55,"models/knife-mod/p_supercut.mdl");
        }
        case 6: {
            format(vModel,55,"models/knife-mod/v_katana.mdl");
            format(pModel,55,"models/knife-mod/p_katana.mdl");
        }
    }

    entity_set_string(id, EV_SZ_viewmodel, vModel);
    entity_set_string(id, EV_SZ_weaponmodel, pModel);

    return PLUGIN_HANDLED;
}

public CurWeapon(id)
{
    new weapon = get_user_weapon(id, _, _);
    // Set Knife Model
    if(!get_bit(g_bChoseKnifeSkin1, id) && !get_bit(g_bChoseKnifeSkin2, id) && !get_bit(g_bChoseKnifeSkin3, id) && !get_bit(g_bChoseKnifeSkin4, id) )
        SetKnife(id, knife_model[id]);
    if(weapon == CSW_KNIFE)
    {
        if(get_bit(g_bHasKnifeSkin1, id) && get_bit(g_bChoseKnifeSkin1, id) )
            knife_skin1(id);
        if(get_bit(g_bHasKnifeSkin2, id) && get_bit(g_bChoseKnifeSkin2, id) )
            knife_skin2(id);
        if(get_bit(g_bHasKnifeSkin3, id) && get_bit(g_bChoseKnifeSkin3, id) )
            knife_skin3(id);
        if(get_bit(g_bHasKnifeSkin4, id) && get_bit(g_bChoseKnifeSkin4, id) )
            knife_skin4(id);
    }


    if(get_bit(g_bHasSpeed, id) && get_bit(g_bHasNadePack, id) )
    {
        item_speed(id);
    }

    if(get_bit(g_bHasPermSpeed, id) && get_bit(g_bHasNadePack, id) )
    {
        Perm_Speed(id);
    }
    if(get_bit(g_bHasPermSpeed, id) && get_bit(g_bHasSpeed, id) && get_bit(g_bHasNadePack, id) )
    {
        item_speed(id);
        Perm_Speed(id);
    }
//First method for endur didnt work
    /*if(get_bit(g_bHasEndur, id) && get_user_weapon(id) == CSW_KNIFE )
    {
        new ent = fm_find_ent_by_owner(-1,"weapon_knife",id);

        new Float:N_Speed;
        if(ent)
        {
            N_Speed = 0.3; //get_pcvar_float(km_val_permendurance);
            new Float:Delay = get_pdata_float( ent, 46, 4) * N_Speed;
            set_pdata_float( ent, 46, Delay, 4);
            fnColorPrint(id, "test for endur");
        }
    }*/

    return PLUGIN_HANDLED;
}

public kmodmsg() {

    fnColorPrint(0, "Type ^4kmmenu ^1to open the knifemodmenu.");
}

public Knifeshop(id)
{
    new menu = menu_create("\yKnife-Mod Shopmenu", "Knifeshop_handler");

    menu_additem(menu, "Extra Items", "1");
    menu_additem(menu, "Upgrade kits \y\R[ PERM  ]         ", "2");
    menu_additem(menu, "Skins \y\R[ PERM  ]         ", "3");

    menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, menu, 0);
}

public Knifeshop_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);
        //Note that you will want to destroy the menu after they do something
        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    //heres the function that will give us that information (since it doesnt magicaly appear)
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            if(!is_user_alive(id))
            {
                fnColorPrint(id, "You must be alive to buy extra items");
                return PLUGIN_HANDLED;
            } else {
                item_menu(id);
            }
        }
        case 2:
        {
            perm_menu(id);
        }
        case 3:
        {
            skins_menu(id);
        }
    }

    menu_destroy(menu);
    return PLUGIN_HANDLED;
}

public item_menu(id)
{
    new menu = menu_create("\yExtra Items", "item_menu_handler");
    menu_additem(menu, "Bhopper \R\y[15 Tokens]", "1"/*, g_MenuCallback*/);
    menu_additem(menu, "Leap jumps \R\y[10 Tokens]", "2");
    menu_additem(menu, "grenade packs \R\y[15 Tokens]", "3");
    menu_additem(menu, "G-Boots \R\y[8 Tokens]", "4");
    menu_additem(menu, "Speeder \R\y[8 Tokens]", "5");

    menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, menu, 0);
}

public item_menu_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);
        if( is_user_connected(id) )
            Knifeshop(id);
        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            if(!is_user_alive(id))
            {
                fnColorPrint(id, "You can't buy extra items when you are dead.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(get_bit(g_bHasBhop, id))
            {
                fnColorPrint(id, "You already have this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_bhop) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }
            //setting the bit automaticly enables bhop
            set_bit(g_bHasBhop, id);
            menu_destroy(menu);

        }
        case 2:
        {
            if(!is_user_alive(id))
            {
                fnColorPrint(id, "You can't buy extra items when you are dead.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(get_bit(g_bHasLeap, id))
            {
                fnColorPrint(id, "You already have this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_leap) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }
            set_bit(g_bHasLeap, id);
            menu_destroy(menu);
        }
        case 3:
        {
            if(!is_user_alive(id))
            {
                fnColorPrint(id, "You can't buy extra items when you are dead.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(get_bit(g_bHasNadePack, id))
            {
                fnColorPrint(id, "You already have this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_nadepack) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }

            give_item(id, "weapon_hegrenade");
            give_item(id, "weapon_flashbang");
            give_item(id, "weapon_smokegrenade");
            set_bit(g_bHasNadePack, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_nadepack);
            cs_set_user_money(id, g_iPoints[id], 1);
            menu_destroy(menu);
        }
        case 4:
        {
            if(!is_user_alive(id))
            {
                fnColorPrint(id, "You can't buy extra items when you are dead.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(get_bit(g_bHasLowGravity, id))
            {
                fnColorPrint(id, "You already have this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_lowgravity) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }
            new Float:Gravity = get_user_gravity(id) - get_pcvar_float(km_val_lowgravity);
            set_user_gravity( id, Gravity );
            set_bit(g_bHasLowGravity, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_lowgravity);
            cs_set_user_money(id, g_iPoints[id], 1);
            menu_destroy(menu);
        }
        case 5:
        {
            if(!is_user_alive(id))
            {
                fnColorPrint(id, "You can't buy extra items when you are dead.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(get_bit(g_bHasSpeed, id))
            {
                fnColorPrint(id, "You already have this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_speed) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this item.");
                item_menu(id);
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasSpeed, id);
            g_iPoints[id] -= get_pcvar_num(km_cost_speed);
            cs_set_user_money(id, g_iPoints[id], 1);
            item_speed(id);

            menu_destroy(menu);
        }
    }
    return PLUGIN_HANDLED;
}

public item_speed(id)
{
    new Float:speed = get_user_maxspeed(id) + get_pcvar_num(km_val_speed);
    set_user_maxspeed(id , speed);
}

public perm_menu(id)
{
    new upgrade_menu = menu_create("\yPerm. Upgrades:", "perm_menu_handler");

    menu_additem(upgrade_menu, "Vitality (+25 HP) \R\y[300 Tokens]", "1");
    menu_additem(upgrade_menu, "Endurance (faster slash/stab)\R\y[300 Tokens]", "2");
    menu_additem(upgrade_menu, "Gravity \R\y[250 Tokens]", "3");
    menu_additem(upgrade_menu, "Speed  \R\y[300 Tokens]", "4");
    menu_additem(upgrade_menu, "Invisibility (semi visible) \R\y[200 Tokens]", "5");

    menu_setprop(upgrade_menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, upgrade_menu, 0);
}

public perm_menu_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);

        if( is_user_connected(id) )
            Knifeshop(id);

        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            if(get_bit(g_bHasPermVital, id))
            {
                fnColorPrint(id, "You already have this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_permvitality) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasPermVital, id);
            g_iPoints[id] -= get_pcvar_num(km_cost_permvitality);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            Perm_Vitality(id);

            menu_destroy(menu);

        }
        case 2:
        {
            if(get_bit(g_bHasEndur, id))
            {
                fnColorPrint(id, "You already have this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_permendurance) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasEndur, id);
            g_iPoints[id] -= get_pcvar_num(km_cost_permendurance);
            cs_set_user_money(id, g_iPoints[id], 1);
            savebits(id);
            //Perm_Endurance(id);

            menu_destroy(menu);
        }
        case 3:
        {
            if(get_bit(g_bHasPermGrav, id))
            {
                fnColorPrint(id, "You already have this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_permgravity) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasPermGrav, id);
            g_iPoints[id] -= get_pcvar_num(km_cost_permgravity);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            Perm_Gravity(id);

            menu_destroy(menu);
        }
        case 4:
        {
            if(get_bit(g_bHasPermSpeed, id))
            {
                fnColorPrint(id, "You already have this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_permspeed) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            set_bit(g_bHasPermSpeed, id);
            g_iPoints[id] -= get_pcvar_num(km_cost_permspeed);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            Perm_Speed(id);

            menu_destroy(menu);
        }
        case 5:
        {
            if(get_bit(g_bHasPermInvis, id))
            {
                fnColorPrint(id, "You already have this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_perminvisibility) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this upgrade.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            set_bit(g_bHasPermInvis, id);
            g_iPoints[id] -= get_pcvar_num(km_cost_perminvisibility);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            Perm_Invisiblity(id);

            menu_destroy(menu);
        }
    }
    return PLUGIN_HANDLED;
}

public Perm_Vitality(id)
{
    new HealthVal = get_user_health(id) + get_pcvar_num(km_val_permvitality);
    set_user_health(id, HealthVal);
}

/*Perm_Endurance(id)
{
    //I dont know how to do this, help is appreciated & credited
}*/

public Perm_Gravity(id)
{
    new Float:GravVal = get_user_gravity(id) - get_pcvar_float(km_val_permgravity);
    set_user_gravity(id, GravVal);
    fnColorPrint(id, "Your gravity upgrade has been activated.");

}

public Perm_Speed(id)
{
    new Float:Speed = get_user_maxspeed(id) + get_pcvar_num(km_val_permspeed);
    set_user_maxspeed(id , Speed);
}

public Perm_Invisiblity(id)
{
    new AlphaVal = get_pcvar_num(km_val_permvisibility);
    set_user_rendering(id,kRenderFxGlowShell,0,0,0,kRenderTransAlpha,AlphaVal);
    fnColorPrint(id, "Your invisibility upgrade has been activated.");
}

public skins_menu(id)
{
    /*if(!is_user_connected(id))
        return PLUGIN_HANDLED;
        */
    new menu = menu_create("\ySkin Shop", "skins_menu_handler");
    menu_additem(menu, "Extra Knife Skins", "1");
    menu_additem(menu, "Player Skins", "2");

    menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, menu, 0);
    //return PLUGIN_HANDLED;
}

public skins_menu_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);
        if( is_user_connected(id) )
            Knifeshop(id);
        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            knifeskins_menu(id);
        }
        case 2:
        {
            playerskins_menu(id);
        }
    }
    return PLUGIN_HANDLED;
}

public knifeskins_menu(id)
{
    new menu = menu_create("\yKnife Models Shop", "knifeskins_menu_handler");
    menu_additem(menu, "Random Jedi Lightsaber \R\y[40 Tokens]", "1");
    menu_additem(menu, "Kujang Knife  \R\y[20 Tokens]", "2");
    menu_additem(menu, "Battle Axe \R\y[20 Tokens]", "3");
    menu_additem(menu, "Halo Sword \R\y[20 Tokens]", "4");

    menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, menu, 0);
}

public knifeskins_menu_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);
        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            if(get_bit(g_bHasKnifeSkin1, id))
            {
                fnColorPrint(id, "You already have this Knife.");
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_knifeskin1) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this knife.");
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasKnifeSkin1, id);
            set_bit(g_bChoseKnifeSkin1, id);
            clear_bit(g_bChoseKnifeSkin2, id);
            clear_bit(g_bChoseKnifeSkin3, id);
            clear_bit(g_bChoseKnifeSkin4, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_knifeskin1);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            knife_skin1(id);

            menu_destroy(menu);

        }
        case 2:
        {
            if(get_bit(g_bHasKnifeSkin2, id))
            {
                fnColorPrint(id, "You already have this knife.");
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_knifeskin2) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this knife.");
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasKnifeSkin2, id);
            clear_bit(g_bChoseKnifeSkin1, id);
            set_bit(g_bChoseKnifeSkin2, id);
            clear_bit(g_bChoseKnifeSkin3, id);
            clear_bit(g_bChoseKnifeSkin4, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_knifeskin2);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            knife_skin2(id);

            menu_destroy(menu);
        }
        case 3:
        {
            if(get_bit(g_bHasKnifeSkin3, id))
            {
                fnColorPrint(id, "You already have this knife.");
                return PLUGIN_HANDLED;
            }

            if(g_iPoints[id] < get_pcvar_num(km_cost_knifeskin3) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this knife.");
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasKnifeSkin3, id);
            clear_bit(g_bChoseKnifeSkin1, id);
            clear_bit(g_bChoseKnifeSkin2, id);
            set_bit(g_bChoseKnifeSkin3, id);
            clear_bit(g_bChoseKnifeSkin4, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_knifeskin3);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            knife_skin3(id);

            menu_destroy(menu);
        }
        case 4:
        {
            if(get_bit(g_bHasKnifeSkin4, id))
            {
                fnColorPrint(id, "You already have this knife.");
                return PLUGIN_HANDLED;
            }

            if(g_iPoints[id] < get_pcvar_num(km_cost_knifeskin4) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this knife.");
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasKnifeSkin4, id);
            clear_bit(g_bChoseKnifeSkin1, id);
            clear_bit(g_bChoseKnifeSkin2, id);
            clear_bit(g_bChoseKnifeSkin3, id);
            set_bit(g_bChoseKnifeSkin4, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_knifeskin4);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            knife_skin4(id);

            menu_destroy(menu);
        }
    }
    return PLUGIN_HANDLED;
}

public knife_skin1(id)
{
    new iRandom = random_num( 1 , 5 );
    switch( iRandom )
    {
        case 1:
        {
            set_pev(id, pev_viewmodel2, "models/knife-mod/v_light_turq.mdl");
            set_pev(id, pev_weaponmodel2, "models/knife-mod/p_light_turq.mdl");
        }
        case 2:
        {
            set_pev(id, pev_viewmodel2, "models/knife-mod/v_light_blue.mdl");
            set_pev(id, pev_weaponmodel2, "models/knife-mod/p_light_blue.mdl");
        }
        case 3:
        {
            set_pev(id, pev_viewmodel2, "models/knife-mod/v_light_green.mdl");
            set_pev(id, pev_weaponmodel2, "models/knife-mod/p_light_green.mdl");
        }
        case 4:
        {
            set_pev(id, pev_viewmodel2, "models/knife-mod/v_light_pink.mdl");
            set_pev(id, pev_weaponmodel2, "models/knife-mod/p_light_pink.mdl");
        }
        case 5:
        {
            set_pev(id, pev_viewmodel2, "models/knife-mod/v_light_red.mdl");
            set_pev(id, pev_weaponmodel2, "models/knife-mod/p_light_red.mdl");
        }


    }
}

public knife_skin2(id)
{
    set_pev(id, pev_viewmodel2, "models/knife-mod/v_knife_kujang.mdl");
    set_pev(id, pev_weaponmodel2, "models/knife-mod/p_knife_kujang.mdl");
}

public knife_skin3(id)
{
    set_pev(id, pev_viewmodel2, "models/knife-mod/v_baxe.mdl");
    set_pev(id, pev_weaponmodel2, "models/knife-mod/p_baxe.mdl");
}

public knife_skin4(id)
{
    set_pev(id, pev_viewmodel2, "models/knife-mod/v_knife_halo.mdl");
    set_pev(id, pev_weaponmodel2, "models/knife-mod/p_knife_halo.mdl");
}

public playerskins_menu(id)
{
    new menu = menu_create("\ySkin Shop", "playerskins_menu_handler");
    menu_additem(menu, "Random T Skins \R\y[75 Tokens]", "1");
    menu_additem(menu, "Random CT Skins \R\y[75 Tokens]", "2");
    menu_additem(menu, "VIP   \R\y[ 20 Tokens]", "3");
    menu_additem(menu, "Assasin  \R\y[ 50 Tokens]", "4");
    menu_additem(menu, "Chucky \R\y[ 50 Tokens]", "5");
    menu_additem(menu, "Superleet \R\y[ 50 Tokens]", "6");
    menu_additem(menu, "Crysis Nanosuit \R\y[ 50 Tokens]", "7");

    menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, menu, 0);
    //return PLUGIN_HANDLED;
}

public playerskins_menu_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);
        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            if(get_bit(g_bHasSkin1, id))
            {
                fnColorPrint(id, "You already have this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_skin1) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasSkin1, id);
            set_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_skin1);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            perm_skin1(id);

            menu_destroy(menu);

        }
        case 2:
        {
            if(get_bit(g_bHasSkin2, id))
            {
                fnColorPrint(id, "You already have this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_skin2) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            set_bit(g_bHasSkin2, id);
            clear_bit(g_bChoseSkin1, id);
            set_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_skin2);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);
            perm_skin2(id);

            menu_destroy(menu);
        }
        case 3:
        {
            if(get_bit(g_bHasSkin3, id))
            {
                fnColorPrint(id, "You already have this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_skin3) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            cs_set_user_model(id,  skin3);
            set_bit(g_bHasSkin3, id);
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            set_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_skin3);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);

            menu_destroy(menu);
        }
        case 4:
        {
            if(get_bit(g_bHasSkin4, id))
            {
                fnColorPrint(id, "You already have this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_skin4) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            cs_set_user_model(id, skin4);
            set_bit(g_bHasSkin4, id);
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            set_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_skin4);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);

            menu_destroy(menu);
        }
        case 5:
        {
            if(get_bit(g_bHasSkin5, id))
            {
                fnColorPrint(id, "You already have this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_skin5) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            cs_set_user_model(id, skin5);
            set_bit(g_bHasSkin5, id);
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            set_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_skin5);
            cs_set_user_money(id, g_iPoints[id], 1);
            savebits(id);

            menu_destroy(menu);
        }
        case 6:
        {
            if(get_bit(g_bHasSkin6, id))
            {
                fnColorPrint(id, "You already have this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_skin6) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            cs_set_user_model(id, skin6);
            set_bit(g_bHasSkin6, id);
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            set_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_skin6);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);

            menu_destroy(menu);
        }
        case 7:
        {
            if(get_bit(g_bHasSkin7, id))
            {
                fnColorPrint(id, "You already have this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            if(g_iPoints[id] < get_pcvar_num(km_cost_skin7) )
            {
                fnColorPrint(id, "You have insufficient tokens to purchase this skin.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }

            cs_set_user_model(id, skin7);
            set_bit(g_bHasSkin7, id);
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            set_bit(g_bChoseSkin7, id);

            g_iPoints[id] -= get_pcvar_num(km_cost_skin7);
            cs_set_user_money(id, g_iPoints[id], 1);

            savebits(id);

            menu_destroy(menu);
        }
    }
    return PLUGIN_HANDLED;
}

public perm_skin1(id)
{
    new iRandom = random_num( 1 , 5 );
    switch( iRandom )
    {
        case 1: cs_set_user_model(id, "arctic");
        case 2: cs_set_user_model(id, "guerilla");
        case 3: cs_set_user_model(id, "leet");
        case 4: cs_set_user_model(id, "militia");
        case 5: cs_set_user_model(id, "terror");
    }
}

public perm_skin2(id)
{
    new iRandom = random_num( 1 , 5 );
    switch( iRandom )
    {
        case 1: cs_set_user_model(id, "urban");
        case 2: cs_set_user_model(id, "spetsnaz");
        case 3: cs_set_user_model(id, "sas");
        case 4: cs_set_user_model(id, "gsg9");
        case 5: cs_set_user_model(id, "gign");
    }
}

public wear_skins_menu(id)
{
    new menu = menu_create("\yWardrobe menu", "wear_skins_menu_handler");

    menu_additem(menu, "Bought Knife skins", "1");
    menu_additem(menu, "Bought Player skins", "5");

    menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, menu, 0);
}

public wear_skins_menu_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);

        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            wear_knifeskins_menu(id);
        }
        case 5:
        {
            wear_playerskins_menu(id);
        }
    }
    return PLUGIN_HANDLED;
}

public wear_knifeskins_menu(id)
{
    new menu = menu_create("\yKnife Skins Wardrobe", "wear_knifeskins_menu_handler");
    menu_additem(menu, "Random Jedi Lightsaber", "1");
    menu_additem(menu, "Scorpio Knife", "2");
    menu_additem(menu, "Battle Axe", "3");
    menu_additem(menu, "Halo Sword", "4");

    menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, menu, 0);
}

public wear_knifeskins_menu_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);
        if( is_user_connected(id) )
            wear_skins_menu(id);
        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            if(!get_bit(g_bHasKnifeSkin1, id))
            {
                fnColorPrint(id, "You can't use this skin unless you buy it.");
                wear_knifeskins_menu(id);
                return PLUGIN_HANDLED;
            }
            set_bit(g_bChoseKnifeSkin1, id);
            clear_bit(g_bChoseKnifeSkin2, id);
            clear_bit(g_bChoseKnifeSkin3, id);
            clear_bit(g_bChoseKnifeSkin4, id);
            knife_skin1(id);
            savebits(id);
            menu_destroy(menu);
        }
        case 2:
        {
            if(!get_bit(g_bHasKnifeSkin2, id))
            {
                fnColorPrint(id, "You can't use this skin unless you buy it.");
                wear_knifeskins_menu(id);
                return PLUGIN_HANDLED;
            }
            clear_bit(g_bChoseKnifeSkin1, id);
            set_bit(g_bChoseKnifeSkin2, id);
            clear_bit(g_bChoseKnifeSkin3, id);
            clear_bit(g_bChoseKnifeSkin4, id);
            knife_skin2(id);
            savebits(id);
            menu_destroy(menu);
        }
        case 3:
        {
            if(!get_bit(g_bHasKnifeSkin3, id))
            {
                fnColorPrint(id, "You can't use this skin unless you buy it.");
                wear_knifeskins_menu(id);
                return PLUGIN_HANDLED;
            }
            clear_bit(g_bChoseKnifeSkin1, id);
            clear_bit(g_bChoseKnifeSkin2, id);
            set_bit(g_bChoseKnifeSkin3, id);
            clear_bit(g_bChoseKnifeSkin4, id);
            knife_skin3(id);
            savebits(id);
            menu_destroy(menu);
        }
        case 4:
        {
            if(!get_bit(g_bHasKnifeSkin4, id))
            {
                fnColorPrint(id, "You can't use this skin unless you buy it.");
                wear_knifeskins_menu(id);
                return PLUGIN_HANDLED;
            }
            clear_bit(g_bChoseKnifeSkin1, id);
            clear_bit(g_bChoseKnifeSkin2, id);
            clear_bit(g_bChoseKnifeSkin3, id);
            set_bit(g_bChoseKnifeSkin4, id);
            knife_skin4(id);
            savebits(id);
            menu_destroy(menu);
        }
    }
    return PLUGIN_HANDLED;
}

public wear_playerskins_menu(id)
{
    new menu = menu_create("\yPlayer Skins Wardrobe", "wear_playerskins_menu_handler");
    menu_additem(menu, "Random T Skins", "1");
    menu_additem(menu, "Random CT Skins", "2");
    menu_additem(menu, "VIP", "3");
    menu_additem(menu, "Assassin", "4");
    menu_additem(menu, "Chucky ", "5");
    menu_additem(menu, "Superleet ", "6");
    menu_additem(menu, "Crysis Nanosuit ", "7");

    menu_setprop(menu, MPROP_EXIT, MEXIT_ALL);
    menu_display(id, menu, 0);
}

public wear_playerskins_menu_handler(id, menu, item)
{
    if( item == MENU_EXIT )
    {
        menu_destroy(menu);
        if( is_user_connected(id) )
            wear_skins_menu(id);
        return PLUGIN_HANDLED;
    }

    new data[6], szName[64];
    new access, callback;
    menu_item_getinfo(menu, item, access, data,charsmax(data), szName,charsmax(szName), callback);

    new key = str_to_num(data);

    switch(key)
    {
        case 1:
        {
            if(!get_bit(g_bHasSkin1, id))
            {
                fnColorPrint(id, "You can't wear this skin unless you buy it.");
                wear_playerskins_menu(id);
                return PLUGIN_HANDLED;
            }
            set_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);
            perm_skin1(id);
            menu_destroy(menu);
        }
        case 2:
        {
            if(!get_bit(g_bHasSkin2, id))
            {
                fnColorPrint(id, "You can't wear this skin unless you buy it.");
                wear_playerskins_menu(id);
                return PLUGIN_HANDLED;
            }
            clear_bit(g_bChoseSkin1, id);
            set_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);
            perm_skin2(id);
            menu_destroy(menu);
        }
        case 3:
        {
            if(!get_bit(g_bHasSkin3, id))
            {
                fnColorPrint(id, "You can't wear this skin unless you buy it.");
                wear_playerskins_menu(id);
                return PLUGIN_HANDLED;
            }
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            set_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);
            cs_set_user_model(id, skin3);
            menu_destroy(menu);
        }
        case 4:
        {
            if(!get_bit(g_bHasSkin4, id))
            {
                fnColorPrint(id, "You can't wear this skin unless you buy it.");
                wear_playerskins_menu(id);
                return PLUGIN_HANDLED;
            }
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            set_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);
            cs_set_user_model(id, skin4);
            menu_destroy(menu);
        }
        case 5:
        {
            if(!get_bit(g_bHasSkin5, id))
            {
                fnColorPrint(id, "You can't wear this skin unless you buy it.");
                wear_playerskins_menu(id);
                return PLUGIN_HANDLED;
            }
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            set_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);
            cs_set_user_model(id, skin5);
            menu_destroy(menu);
        }
        case 6:
        {
            if(!get_bit(g_bHasSkin6, id))
            {
                fnColorPrint(id, "You can't wear this skin unless you buy it.");
                wear_playerskins_menu(id);
                return PLUGIN_HANDLED;
            }
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            set_bit(g_bChoseSkin6, id);
            clear_bit(g_bChoseSkin7, id);
            cs_set_user_model(id, skin6);
            menu_destroy(menu);
        }
        case 7:
        {
            if(!get_bit(g_bHasSkin7, id))
            {
                fnColorPrint(id, "You can't wear this skin unless you buy it.");
                menu_destroy(menu);
                return PLUGIN_HANDLED;
            }
            clear_bit(g_bChoseSkin1, id);
            clear_bit(g_bChoseSkin2, id);
            clear_bit(g_bChoseSkin3, id);
            clear_bit(g_bChoseSkin4, id);
            clear_bit(g_bChoseSkin5, id);
            clear_bit(g_bChoseSkin6, id);
            set_bit(g_bChoseSkin7, id);
            cs_set_user_model(id, skin7);
            menu_destroy(menu);
        }
    }
    return PLUGIN_HANDLED;
}


public client_authorized(id) {
    if(!is_user_bot(id) && !is_user_hltv(id))
    {
        #if defined SAVE_METHOD_NICK
        get_user_name(id, g_iAuth[id], charsmax(g_iAuth));
        #endif
        #if defined SAVE_METHOD_IP
        get_user_ip(id, g_iAuthIP[id], charsmax(g_iAuthIP));
        #endif
        #if defined SAVE_METHOD_ID
        get_user_authid(id, g_iAuthID[id], charsmax(g_iAuthID));
        #endif

        GetData(id);
    }
    loadbits(id);
}

public client_infochanged( plr )
{
    static curName[32], newName[32];
    get_user_name( plr, curName, 31 );
    get_user_info( plr, "name", newName, 31 );

    if( !equal( newName, curName ) )
    {
        copy( g_szNickname[plr], 31, newName );
    }
}

public GetHudColor( &r, &g, &b )
{
    static color[16], piece[5];
    get_pcvar_string( g_pCVarHudColor, color, 15 );

    strbreak( color, piece, 4, color, 15 );
    r = str_to_num( piece );

    strbreak( color, piece, 4, color, 15 );
    g = str_to_num( piece );
    b = str_to_num( color );
}

public GetHudCoords( &Float:x, &Float:y )
{
    static coords[16], piece[10];
    get_pcvar_string( g_pCVarHudCoords, coords, 15 );

    strbreak( coords, piece, 9, coords, 15 );
    x = str_to_float( piece );
    y = str_to_float( coords );
}

public client_putinserver(id)
{
    LoadKnife(id);
}

public Fwd_PlayerSpawn_Post(const id)
{
    if (!is_user_alive(id))
        return HAM_HANDLED;

    strip_user_weapons( id );
    give_item( id, "weapon_knife" );

    g_bAlive[id] = bool:is_user_alive(id);

    if(get_bit(g_bHasNadePack, id) )
    {
        give_item(id, "weapon_hegrenade");
        give_item(id, "weapon_flashbang");
        give_item(id, "weapon_smokegrenade");
    }

    if(get_bit(g_bHasPermGrav, id) )
    {
        Perm_Gravity(id);
    }

    if(get_bit(g_bHasPermInvis, id) )
    {
        Perm_Invisiblity(id);
    }

    if(get_bit(g_bHasPermSpeed, id) )
    {
        set_task(1.0, "Perm_Speed", id);
        fnColorPrint(id, "Your speed upgrade has been activated.");
    }

    if(get_bit(g_bHasPermVital, id) )
    {
        Perm_Vitality(id);
    }

    if(get_bit(g_bHasSkin1, id) && get_bit(g_bChoseSkin1,id ) )
    {
        perm_skin1(id);
    }

    if(get_bit(g_bHasSkin2, id) && get_bit(g_bChoseSkin2,id ) )
    {
        perm_skin2(id);
    }

    if(get_bit(g_bHasSkin3, id) && get_bit(g_bChoseSkin3,id ))
    {
        cs_set_user_model(id, skin3);
    }

    if(get_bit(g_bHasSkin4, id) && get_bit(g_bChoseSkin4,id ) )
    {
        cs_set_user_model(id, skin4);
    }

    if(get_bit(g_bHasSkin5, id) && get_bit(g_bChoseSkin5,id ) )
    {
        cs_set_user_model(id, skin5);
    }

    if(get_bit(g_bHasSkin6, id) && get_bit(g_bChoseSkin6,id ) )
    {
        cs_set_user_model(id, skin6);
    }

    if(get_bit(g_bHasSkin7, id) && get_bit(g_bChoseSkin7,id ) )
    {
        cs_set_user_model(id, skin7);
    }

    //set_task(7.0, "reset_bit", id)

    return HAM_HANDLED;
}

/*public reset_bit(id)
{
    clear_bit(g_bHasDied, id);
}*/

public Fwd_TraceAttack_Player_Post(const victim, const attacker, Float:flDamage, Float:flDirection[3], const ptr, const iDamagebits)
{
    // Not a valid attacker / no victim
    if (!IsPlayer(attacker))
        return HAM_IGNORED;

    g_bHeadShot[attacker][victim] = bool:( get_tr2(ptr, TR_iHitgroup) == HITGROUP_HEAD );

    return HAM_IGNORED;
}

public Ham_TakeDamage_player(id, ent, idattacker, Float:damage, damagebits)
{
    if(get_bit(g_bHasBhop, id) )
    {
        if( damagebits != DMG_FALL )
            return HAM_IGNORED;

        damage *= get_pcvar_float(g_pcvarFallDamage);
        SetHamParamFloat(4, damage);
    }

    return HAM_HANDLED;
}

public CmdStart(id, uc_handle, seed)
{
    if(get_bit(g_bHasBhop, id) )
    {
        if( g_bAlive[id]
        &&  get_pcvar_num(g_pcvarBhopStyle)
        &&  get_uc(uc_handle, UC_Buttons) & IN_USE
        &&  pev(id, pev_flags) & FL_ONGROUND    )
        {
            static Float:fVelocity[3];
            pev(id, pev_velocity, fVelocity);
            fVelocity[0] *= 0.3;
            fVelocity[1] *= 0.3;
            fVelocity[2] *= 0.3;
            set_pev(id, pev_velocity, fVelocity);
        }
    }
}

public FM_TraceLine_Post( Float:vecSrc[3], Float:vecEnd[3], noMonsters, skipEnt, tr )
{
    if( !is_user_alive( skipEnt ) )
    {
        return FMRES_IGNORED;
    }

    if( get_user_weapon( skipEnt ) != CSW_KNIFE )
    {
        return FMRES_IGNORED;
    }

    static button;
    button = pev( skipEnt, pev_button );

    if( !( button & IN_ATTACK ) && !( button & IN_ATTACK2 ) )
    {
        return FMRES_IGNORED;
    }

    static Float:flFraction;
    get_tr2( tr, TR_flFraction, flFraction );

    if( flFraction >= 1.0 )
    {
        return FMRES_IGNORED;
    }

    static pHit;
    pHit = get_tr2( tr, TR_pHit );

    if( get_user_team( skipEnt ) == get_user_team( pHit ) && !get_pcvar_num( g_pCVarFriendlyFire ) )
    {
        return FMRES_IGNORED;
    }

    static Float:vecEndPos[3];
    get_tr2( tr, TR_vecEndPos, vecEndPos );

    static Float:distance;
    distance = vector_distance( vecSrc, vecEndPos );

    static Float:range;
    range = distance / flFraction; // vector_distance( vecSrc, vecEnd )

    if( 31.89 < range < 32.1 )
    {
        GetTraceData( tr, skipEnt, pHit, distance, STAB );
    }
    else if( 47.89 < range < 48.1 )
    {
        GetTraceData( tr, skipEnt, pHit,  distance, SLASH );
    }

    return FMRES_IGNORED;
}

public FM_TraceHull_Post( Float:vecSrc[3], Float:vecEnd[3], noMonsters, hull, skipEnt, tr )
{
    if( !is_user_alive( skipEnt ) )
    {
        return FMRES_IGNORED;
    }

    if( get_user_weapon( skipEnt ) != CSW_KNIFE )
    {
        return FMRES_IGNORED;
    }

    static Float:flFraction;
    get_tr2( tr, TR_flFraction, flFraction );

    if( flFraction >= 1.0 )
    {
        return FMRES_IGNORED;
    }

    static pHit;
    pHit = get_tr2( tr, TR_pHit );

    if( get_user_team( skipEnt ) == get_user_team( pHit ) && !get_pcvar_num( g_pCVarFriendlyFire ) )
    {
        return FMRES_IGNORED;
    }

    static Float:vecEndPos[3];
    get_tr2( tr, TR_vecEndPos, vecEndPos );

    static Float:distance;
    distance = vector_distance( vecSrc, vecEndPos );

    static Float:range;
    range = distance / flFraction; // vector_distance( vecSrc, vecEnd )

    if( 31.89 < range < 32.1 )
    {
        GetTraceData( tr, skipEnt, pHit, distance, STAB );
    }
    else if( 47.89 < range < 48.1 )
    {
        GetTraceData( tr, skipEnt, pHit, distance, SLASH );
    }

    return FMRES_IGNORED;
}

public GetTraceData( tr, attacker, victim, Float:distance, AttackType:attack )
{
    g_HitData[iAttack] = any:attack;
    g_HitData[flDistance] = any:distance;
    g_HitData[iHitgroup] = get_tr2( tr, TR_iHitgroup );
    g_HitData[iAttacker] = attacker;
    g_HitData[iVictim] = victim;

    g_bKnifeHit = true;
}

public eventDamage( )
{
    if( g_bKnifeHit )
    {
        g_bKnifeHit = false;

        static victim;
        victim = g_HitData[iVictim];

        if( !( 1 <= victim <= 32 ) )
        {
            return PLUGIN_CONTINUE;
        }

        static attacker;
        attacker = g_HitData[iAttacker];

        static Float:distance;
        distance = g_HitData[flDistance];

        static Float:health;
        pev( victim, pev_health, health );

        static r, g, b;
        GetHudColor( r, g, b );

        static Float:x, Float:y;
        GetHudCoords( x, y );

        set_hudmessage( r, g, b, x, y, 0, 0.0, get_pcvar_float( g_pCVarHudHoldtime ), 0.0, 0.0, 1 );

        if( g_HitData[iAttack] == STAB )
        {
            show_hudmessage( attacker, "Stab Stats (%s)^nDistance: %.3f meter (max: 1.0)^nHit: %s (%s)^nDamage: %i"\
                , g_szTraceType[TraceType:!g_HitData[iHitgroup]],\
                (distance/modMeter), g_szNickname[victim],\
                g_szHitgroup[g_HitData[iHitgroup]], pev( victim, pev_dmg_take ) );

            if( health < 0.0 )
            {
                fnColorPrint( 0, "^4%s ^1stabbed^3 %s ^1from^4 %.3f ^1meter ^3(%s)^1!",\
                    g_szNickname[attacker], g_szNickname[victim],\
                    (distance/modMeter), g_szHitgroup[g_HitData[iHitgroup]] );

                if( (distance/modMeter) >= get_pcvar_float( g_pCVarSoundGodlikeStab ) )
                {
                    fnColorPrint( 0, "^4 %s ^1has made a GodLike %s-stab kill on^3 %s^1!",\
                        g_szNickname[attacker],\
                        g_szHitgroup[g_HitData[iHitgroup]],\
                        g_szNickname[victim] );
                    client_cmd( 0, "spk %s", g_szSound[GODLIKE] );

                    new origin[3];
                    get_user_origin(victim, origin);
                    blood_effects(origin);

                    cs_set_user_money(attacker, g_iPoints[attacker] += get_pcvar_num(km_tokens_godlike), 1);
                    SaveData(attacker);

                }
                else if( (distance/modMeter) >= get_pcvar_float( g_pCVarSoundWickedSickStab ))
                {
                    fnColorPrint( 0, "^4 %s ^1has made a WickedSick %s-stab kill on^3 %s^1!",\
                        g_szNickname[attacker],\
                        g_szHitgroup[g_HitData[iHitgroup]],\
                        g_szNickname[victim] );
                    client_cmd( 0, "spk %s", g_szSound[WICKEDSICK] );

                    new origin[3];
                    get_user_origin(victim, origin);
                    blood_effects(origin);

                    cs_set_user_money(attacker, g_iPoints[attacker] += get_pcvar_num(km_tokens_wickedsick), 1);
                    SaveData(attacker);
                }
            }
        }
        else
        {
            show_hudmessage( attacker, "Slash Stats (%s)^nDistance: %.3f meter (max: 1.5)^nHit: %s (%s)^nDamage: %i"\
                , g_szTraceType[TraceType:!g_HitData[iHitgroup]],\
                (distance/modMeter), g_szNickname[victim],\
                g_szHitgroup[g_HitData[iHitgroup]], pev( victim, pev_dmg_take ) );

            if( health < 0.0 )
            {
                fnColorPrint( 0, "^4%s ^1slashed^3 %s ^1from^4 %.3f ^1meter ^3(%s)!",\
                    g_szNickname[attacker],\
                    g_szNickname[victim],\
                    (distance/modMeter), g_szHitgroup[g_HitData[iHitgroup]] );

                if( (distance/modMeter) >= get_pcvar_float( g_pCVarSoundGodlikeSlash ) )
                {
                    fnColorPrint( 0, "^4 %s ^1made a GodLike %s-slash kill on^3 %s^1!",\
                        g_szNickname[attacker],\
                        g_szHitgroup[g_HitData[iHitgroup]],\
                        g_szNickname[victim] );
                    client_cmd( 0, "spk %s", g_szSound[GODLIKE] );

                    new origin[3];
                    get_user_origin(victim, origin);
                    blood_effects(origin);

                    cs_set_user_money(attacker, g_iPoints[attacker] += get_pcvar_num(km_tokens_godlike), 1);
                    SaveData(attacker);
                }
                else if( (distance/modMeter) >= get_pcvar_float( g_pCVarSoundWickedSickSlash ) )
                {
                    fnColorPrint( 0, "^4 %s ^1has made a WickedSick %s-slash kill on^3 %s^1!",\
                        g_szNickname[attacker],\
                        g_szHitgroup[g_HitData[iHitgroup]],\
                        g_szNickname[victim] );
                    client_cmd( 0, "spk %s", g_szSound[WICKEDSICK] );

                    new origin[3];
                    get_user_origin(victim, origin);
                    blood_effects(origin);

                    cs_set_user_money(attacker, g_iPoints[attacker] += get_pcvar_num(km_tokens_wickedsick), 1);
                    SaveData(attacker);
                }
            }
        }
    }

    return PLUGIN_CONTINUE;
}

public Fwd_PlayerKilled_Pre(victim, attacker)
{
    if (is_user_connected(attacker) && is_user_alive(attacker) )
    {
        if(g_bHeadShot[attacker][victim])
        {
            g_bHeadShot[attacker][victim] = false;
            g_iPoints[attacker] += get_pcvar_num(km_tokens_hskill) ;
            cs_set_user_money(attacker, g_iPoints[attacker], 1);
        }
        else
        {
            g_iPoints[attacker] += get_pcvar_num(km_tokens_kill);
            cs_set_user_money(attacker, g_iPoints[attacker], 1);
        }
        SaveData(attacker);
    }

    if(get_bit(g_bHasBhop, victim))
        clear_bit(g_bHasBhop, victim);
    if(get_bit(g_bHasLeap, victim))
        clear_bit(g_bHasLeap, victim);
    if(get_bit(g_bHasNadePack, victim) )
    {
        clear_bit(g_bHasNadePack, victim);
    }
    if(get_bit(g_bHasLowGravity, victim))
        clear_bit(g_bHasLowGravity, victim);
    if(get_bit(g_bHasSpeed, victim))
        clear_bit(g_bHasSpeed, victim);

}

public Check_Alive(id)
{
    g_bAlive[id] = bool:is_user_alive(id);
}

public fwd_Knife_PriAtk_Post(ent)
{
    if(get_bit(g_bHasEndur, ent) )
    {
        static Float:Speed, Float:Primary, Float:Secondary;
        Speed = get_pcvar_float(km_val_permendurance);
        Primary = get_pdata_float(ent, m_flNextPrimaryAttack, OFFSET_LINUX_WEAPONS) * Speed;
        Secondary = get_pdata_float(ent, m_flNextSecondaryAttack, OFFSET_LINUX_WEAPONS) * Speed;

        set_pdata_float(ent, m_flNextPrimaryAttack, Primary, OFFSET_LINUX_WEAPONS);
        set_pdata_float(ent, m_flNextSecondaryAttack, Secondary, OFFSET_LINUX_WEAPONS);

    }
    return HAM_IGNORED;
}

public fwd_Knife_SecAtk_Post(ent)
{
    if(get_bit(g_bHasEndur, ent) )
    {
        static Float:Speed, Float:Primary, Float:Secondary;
        Speed = get_pcvar_float(km_val_permendurance);
        Primary = get_pdata_float(ent, m_flNextPrimaryAttack, OFFSET_LINUX_WEAPONS) * Speed;
        Secondary = get_pdata_float(ent, m_flNextSecondaryAttack, OFFSET_LINUX_WEAPONS) * Speed;

        set_pdata_float(ent, m_flNextPrimaryAttack, Primary, OFFSET_LINUX_WEAPONS);
        set_pdata_float(ent, m_flNextSecondaryAttack, Secondary, OFFSET_LINUX_WEAPONS);
    }
    return HAM_IGNORED;
}

public Player_Jump(id)
{
    if( !g_bAlive[id] )
    {
        return;
    }

    if(!get_bit(g_bHasBhop, id) )
    {
        return;
    }

    static iBhopStyle ; iBhopStyle = get_pcvar_num(g_pcvarBhopStyle);
    if(!iBhopStyle)
    {
        static iOldButtons ; iOldButtons = pev(id, pev_oldbuttons);
        if( (get_pcvar_num(g_pcvarAutoBhop) || g_bAutoBhop[id]) && iOldButtons & IN_JUMP && pev(id, pev_flags) & FL_ONGROUND)
        {
            iOldButtons &= ~IN_JUMP;
            set_pev(id, pev_oldbuttons, iOldButtons);
            set_pev(id, pev_gaitsequence, PLAYER_JUMP);
            set_pev(id, pev_frame, 0.0);
            return;
        }
        return;
    }

    if( g_iCdWaterJumpTime[id] )
    {
        client_print(id, print_center, "Water Jump !!!");
        return;
    }

    if( pev(id, pev_waterlevel) >= 2 )
    {
        return;
    }

    static iFlags ; iFlags = pev(id, pev_flags);
    if( !(iFlags & FL_ONGROUND) )
    {
        return;
    }

    static iOldButtons ; iOldButtons = pev(id, pev_oldbuttons);
    if( !get_pcvar_num(g_pcvarAutoBhop) && !g_bAutoBhop[id] && iOldButtons & IN_JUMP )
    {
        return;
    }

    // prevent the game from making the player jump
    // as supercede this forward just fails
    set_pev(id, pev_oldbuttons, iOldButtons | IN_JUMP);

    static Float:fVelocity[3];
    pev(id, pev_velocity, fVelocity);

    if(iBhopStyle == 1)
    {
        static Float:fMaxScaledSpeed;
        pev(id, pev_maxspeed, fMaxScaledSpeed);
        if(fMaxScaledSpeed > 0.0)
        {
            fMaxScaledSpeed *= BUNNYJUMP_MAX_SPEED_FACTOR;
            static Float:fSpeed;
            fSpeed = floatsqroot(fVelocity[0]*fVelocity[0] + fVelocity[1]*fVelocity[1] + fVelocity[2]*fVelocity[2]);
            if(fSpeed > fMaxScaledSpeed)
            {
                static Float:fFraction;
                fFraction = ( fMaxScaledSpeed / fSpeed ) * 0.65;
                fVelocity[0] *= fFraction;
                fVelocity[1] *= fFraction;
                fVelocity[2] *= fFraction;
            }
        }
    }

    static Float:fFrameTime, Float:fPlayerGravity;
    global_get(glb_frametime, fFrameTime);
    pev(id, pev_gravity, fPlayerGravity);

    new iLJ;
    if( (pev(id, pev_bInDuck) || iFlags & FL_DUCKING)
    &&  get_pdata_int(id, OFFSET_CAN_LONGJUMP)
    &&  pev(id, pev_button) & IN_DUCK
    &&  pev(id, pev_flDuckTime) )
    {
        static Float:fPunchAngle[3], Float:fForward[3];
        pev(id, pev_punchangle, fPunchAngle);
        fPunchAngle[0] = -5.0;
        set_pev(id, pev_punchangle, fPunchAngle);
        global_get(glb_v_forward, fForward);

        fVelocity[0] = fForward[0] * 560;
        fVelocity[1] = fForward[1] * 560;
        fVelocity[2] = 299.33259094191531084669989858532;
        iLJ = 1;
    }
    else
    {
        fVelocity[2] = 268.32815729997476356910084024775;
    }

    fVelocity[2] -= fPlayerGravity * fFrameTime * 0.5 * get_pcvar_num(g_pcvarGravity);

    set_pev(id, pev_velocity, fVelocity);

    set_pev(id, pev_gaitsequence, PLAYER_JUMP+iLJ);
    set_pev(id, pev_frame, 0.0);
}

public UpdateClientData(id, sendweapons, cd_handle)
{
    if(get_bit(g_bHasBhop, id) )
    {
        g_iCdWaterJumpTime[id] = get_cd(cd_handle, CD_WaterJumpTime);
    }
}

public fw_PlayerPreThink(id)
{
    // Not alive
    if (!is_user_alive(id))
        return;

    // Don't allow leap if player is frozen (e.g. freezetime)
    if (get_user_maxspeed(id) == 1.0 || !get_bit(g_bHasLeap, id) )
        return;

    static Float:cooldown, force, Float:height;

    if(get_bit(g_bHasLeap, id) ) {
        cooldown = get_pcvar_float(km_leap_cooldown);
        force = get_pcvar_num(km_leap_force);
        height = get_pcvar_float(km_leap_height);
    }

    static Float:current_time;
    current_time = get_gametime();

    // Cooldown not over yet
    if (current_time - g_LeapLastTime[id] < cooldown)
        return;

    // Not doing a longjump (don't perform check for bots, they leap automatically)
    if (!is_user_bot(id) && !(pev(id, pev_button) & (IN_JUMP | IN_DUCK) == (IN_JUMP | IN_DUCK)))
        return;

    // Not on ground or not enough speed
    if (!(pev(id, pev_flags) & FL_ONGROUND) || fm_get_speed(id) < 80)
        return;

    static Float:velocity[3];

    // Make velocity vector
    velocity_by_aim(id, force, velocity);

    // Set custom height
    velocity[2] = height;

    // Apply the new velocity
    set_pev(id, pev_velocity, velocity);

    // Update last leap time
    g_LeapLastTime[id] = current_time;
}

// Get entity's speed (from fakemeta_util)
stock fm_get_speed(entity)
{
    static Float:velocity[3];
    pev(entity, pev_velocity, velocity);

    return floatround(vector_length(velocity));
}

public client_disconnect(id)
{
    SaveData(id);
    savebits(id);
}

public EventMoney(id) {
    cs_set_user_money(id, g_iPoints[id], 1);
}

public AdminCmd_Bhop(id, level, cid)
{
    if(!cmd_access(id, level, cid, 2) )
    {
        return PLUGIN_HANDLED;
    }

    new szPlayer[32];
    read_argv(1, szPlayer, 31);
    new iPlayer = cmd_target(id, szPlayer, CMDTARGET_OBEY_IMMUNITY | CMDTARGET_ALLOW_SELF | CMDTARGET_NO_BOTS);

    if( !iPlayer )
    {
        return PLUGIN_HANDLED;
    }

    if( read_argc() < 3 )
    {
        g_bAutoBhop[iPlayer] = !g_bAutoBhop[iPlayer];
    }
    else
    {
        new arg2[2];
        read_argv(2, arg2, 1);
        if(arg2[0] == '1' && !g_bAutoBhop[iPlayer])
        {
            g_bAutoBhop[iPlayer] = true;
        }
        else if(arg2[0] == '0' && g_bAutoBhop[iPlayer])
        {
            g_bAutoBhop[iPlayer] = false;
        }
    }

    client_print(id, print_console, "Player %s autobhop is currently : %s", szPlayer, g_bAutoBhop[iPlayer] ? "On" : "Off");
    return PLUGIN_HANDLED;
}

/*================================================================================
 [Give/Take Tokens]
=================================================================================*/
public cmd_give_tokens(id,level,cid)
{
    if(!cmd_access(id,level,cid,3))
        return PLUGIN_HANDLED;

    new target[32], amount[21];

    read_argv(1, target, 31 );
    read_argv(2, amount, 20 );

    new player = cmd_target( id, target, 8 );

    if(!player)
        return PLUGIN_HANDLED;

    new admin_name[32]; get_user_name(id, admin_name, charsmax(admin_name));
    new player_name[32]; get_user_name(player, player_name, charsmax(player_name));
    new pointnum = str_to_num(amount);

    g_iPoints[player] += pointnum;
    cs_set_user_money(player, g_iPoints[player], 1);

    switch(get_cvar_num ("amx_show_activity"))
    {
        case 1: fnColorPrint( 0, "ADMIN %s gave %i tokens to %s.", admin_name, pointnum, player_name);
        case 2: fnColorPrint( 0, "ADMIN %s gave %i tokens to %s.", admin_name, pointnum, player_name);
    }

    fnColorPrint(player, "You received %i tokens.(Total: %i)", pointnum, g_iPoints[player]);
    SaveData(id);

    return PLUGIN_HANDLED;
}

public cmd_take_tokens(id,level,cid)
{
    if(!cmd_access (id, level, cid, 2))
        return PLUGIN_HANDLED;

    new target[32], amount[21];

    read_argv( 1, target, 31 );
    read_argv( 2, amount, 20 );

    new player = cmd_target( id, target, 8 );

    if(!player)
        return PLUGIN_HANDLED;

    new admin_name[32]; get_user_name(id, admin_name, charsmax(admin_name));
    new player_name[32]; get_user_name(player, player_name, charsmax(player_name));

    new pointnum = str_to_num( amount );

    if(g_iPoints[player] < pointnum)
    {
        fnColorPrint( id, "you can't take away more the he has (%i)", g_iPoints[player]);
        console_print( id, "you can't take away more the he has (%i)", g_iPoints[player]);
        return PLUGIN_HANDLED;
    }

    g_iPoints[player] -= pointnum;
    cs_set_user_money(player, g_iPoints[player], 1);

    switch(get_cvar_num("amx_show_activity"))
    {
        case 1: fnColorPrint( 0, "ADMIN %s took %i tokens from %s.", admin_name, pointnum, player_name);
        case 2: fnColorPrint( 0, "ADMIN %s took %i tokens from %s.", admin_name, pointnum, player_name);
    }

    fnColorPrint( player, "You lost %i tokens. (Total: %i)", pointnum, g_iPoints[player]);

    SaveData(id);

    return PLUGIN_HANDLED;
}

public cmd_reset_tokens(id,level,cid)
{
    if(!cmd_access(id,level,cid,2))
        return PLUGIN_HANDLED;

    new target[32];

    read_argv(1, target, 31);

    new player = cmd_target(id, target, 8);

    if(!player)
        return PLUGIN_HANDLED;

    new admin_name[32]; get_user_name(id, admin_name, charsmax(admin_name));
    new player_name[32]; get_user_name(player, player_name, charsmax(player_name));
    g_iPoints[player] = 0;
    cs_set_user_money(player, g_iPoints[player], 1);

    switch(get_cvar_num ("amx_show_activity"))
    {
        case 1: fnColorPrint( 0, "ADMIN %s has reset %s's tokens.", admin_name, player_name);
        case 2: fnColorPrint( 0, "ADMIN %s has reset %s's tokens.", admin_name, player_name);
    }

    fnColorPrint(player, "Your tokens have been reset.");

    SaveData(id);

    return PLUGIN_HANDLED;
}

/*================================================================================
 [Save/Load tokens]
=================================================================================*/
public SaveData(id)
{
    new vKey[32], vData[32];
    //Save their tokens
    #if defined SAVE_METHOD_NICK
    formatex(vKey, 31, "%s-tokens", g_iAuth[id]);
    #endif
    #if defined SAVE_METHOD_IP
    formatex(vKey, 31, "%s-tokens", g_iAuthIP[id]);
    #endif
    #if defined SAVE_METHOD_ID
    formatex(vKey, 31, "%s-tokens", g_iAuthID[id]);
    #endif

    formatex(vData, 31, "%i", g_iPoints[id]);
    nvault_set(g_vault, vKey , vData);
}

public GetData(id)
{
    new szKey[32];
    #if defined SAVE_METHOD_NICK
    formatex(szKey, 31, "%s-tokens", g_iAuth[id]);
    #endif
    #if defined SAVE_METHOD_IP
    formatex(szKey, 31, "%s-tokens", g_iAuthIP[id]);
    #endif
    #if defined SAVE_METHOD_ID
    formatex(szKey, 31, "%s-tokens", g_iAuthID[id]);
    #endif
    g_iPoints[id] = nvault_get( g_vault , szKey );
}

public SaveKnife(id)
{
    new authid[32];
    get_user_authid(id, authid, 31);

    new vaultkey[64];
    new vaultdata[64];

    format(vaultkey, 63, "KMOD_%s", authid);
    format(vaultdata, 63, "%d", knife_model[id]);
    set_vaultdata(vaultkey, vaultdata);
}

public LoadKnife(id)
{
    new authid[32];
    get_user_authid(id,authid,31);

    new vaultkey[64], vaultdata[64];

    format(vaultkey, 63, "KMOD_%s", authid);
    get_vaultdata(vaultkey, vaultdata, 63);
    knife_model[id] = str_to_num(vaultdata);

}

public savebits(id)
{
    new steamID[35];
    get_user_authid( id , steamID , charsmax( steamID ) );

    new data[64];
    formatex(data, charsmax(data), "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
        !!get_bit(g_bHasPermVital, id),
        !!get_bit(g_bHasEndur, id),
        !!get_bit(g_bHasPermGrav, id),
        !!get_bit(g_bHasPermSpeed, id),
        !!get_bit(g_bHasPermInvis, id),
        !!get_bit(g_bHasSkin1, id),
        !!get_bit(g_bHasSkin2, id),
        !!get_bit(g_bHasSkin3, id),
        !!get_bit(g_bHasSkin4, id),
        !!get_bit(g_bHasSkin5, id),
        !!get_bit(g_bHasKnifeSkin1, id),
        !!get_bit(g_bHasKnifeSkin2, id),
        !!get_bit(g_bHasKnifeSkin3, id),
        !!get_bit(g_bHasKnifeSkin4, id),
        !!get_bit(g_bChoseKnifeSkin1, id),
        !!get_bit(g_bChoseKnifeSkin2, id),
        !!get_bit(g_bChoseKnifeSkin3, id),
        !!get_bit(g_bChoseKnifeSkin4, id),
        !!get_bit(g_bHasSkin6, id),
        !!get_bit(g_bHasSkin7, id),
        !!get_bit(g_bChoseSkin1, id),
        !!get_bit(g_bChoseSkin2, id),
        !!get_bit(g_bChoseSkin3, id),
        !!get_bit(g_bChoseSkin4, id),
        !!get_bit(g_bChoseSkin5, id),
        !!get_bit(g_bChoseSkin6, id),
        !!get_bit(g_bChoseSkin7, id)
    );
    nvault_set(bitvault, steamID, data);
}

public loadbits(id)
{
    new steamID[35];
    get_user_authid( id , steamID , charsmax( steamID ) );

    new data[64];
    new bits[27][2];
    new timestamp;
    if(nvault_lookup(bitvault, steamID, data, charsmax(data), timestamp))
    {
        parse(data,
        bits[0], charsmax(bits[]),
            bits[1], charsmax(bits[]),
            bits[2], charsmax(bits[]),
            bits[3], charsmax(bits[]),
            bits[4], charsmax(bits[]),
        bits[5], charsmax(bits[]),
        bits[6], charsmax(bits[]),
        bits[7], charsmax(bits[]),
        bits[8], charsmax(bits[]),
            bits[9], charsmax(bits[]),
            bits[10], charsmax(bits[]),
            bits[11], charsmax(bits[]),
            bits[12], charsmax(bits[]),
        bits[13], charsmax(bits[]),
            bits[14], charsmax(bits[]),
            bits[15], charsmax(bits[]),
            bits[16], charsmax(bits[]),
            bits[17], charsmax(bits[]),
        bits[18], charsmax(bits[]),
        bits[19], charsmax(bits[]),
        bits[20], charsmax(bits[]),
            bits[21], charsmax(bits[]),
            bits[22], charsmax(bits[]),
            bits[23], charsmax(bits[]),
            bits[24], charsmax(bits[]),
        bits[25], charsmax(bits[]),
        bits[26], charsmax(bits[])
        );

        if(bits[0][0] == '1') set_bit(g_bHasPermVital, id);
        if(bits[1][0] == '1') set_bit(g_bHasEndur, id);
        if(bits[2][0] == '1') set_bit(g_bHasPermGrav, id);
        if(bits[3][0] == '1') set_bit(g_bHasPermSpeed, id);
        if(bits[4][0] == '1') set_bit(g_bHasPermInvis, id);
    if(bits[5][0] == '1') set_bit(g_bHasSkin1, id);
    if(bits[6][0] == '1') set_bit(g_bHasSkin2, id);
    if(bits[7][0] == '1') set_bit(g_bHasSkin3, id);
    if(bits[8][0] == '1') set_bit(g_bHasSkin4, id);
        if(bits[9][0] == '1') set_bit(g_bHasSkin5, id);
        if(bits[10][0] == '1') set_bit(g_bHasKnifeSkin1, id);
        if(bits[11][0] == '1') set_bit(g_bHasKnifeSkin2, id);
        if(bits[12][0] == '1') set_bit(g_bHasKnifeSkin3, id);
    if(bits[13][0] == '1') set_bit(g_bHasKnifeSkin4, id);
        if(bits[14][0] == '1') set_bit(g_bChoseKnifeSkin1, id);
        if(bits[15][0] == '1') set_bit(g_bChoseKnifeSkin2, id);
        if(bits[16][0] == '1') set_bit(g_bChoseKnifeSkin3, id);
        if(bits[17][0] == '1') set_bit(g_bChoseKnifeSkin4, id);
    if(bits[18][0] == '1') set_bit(g_bHasSkin6, id);
    if(bits[19][0] == '1') set_bit(g_bHasSkin7, id);
    if(bits[20][0] == '1') set_bit(g_bChoseSkin1, id);
    if(bits[21][0] == '1') set_bit(g_bChoseSkin2, id);
    if(bits[22][0] == '1') set_bit(g_bChoseSkin3, id);
    if(bits[23][0] == '1') set_bit(g_bChoseSkin4, id);
    if(bits[24][0] == '1') set_bit(g_bChoseSkin5, id);
    if(bits[25][0] == '1') set_bit(g_bChoseSkin6, id);
    if(bits[26][0] == '1') set_bit(g_bChoseSkin7, id);
    }
}

stock blood_effects(origin[3])
{
    message_begin(MSG_PVS, SVC_TEMPENTITY, origin);
    write_byte(TE_BLOODSPRITE);
    write_coord(origin[0]);
    write_coord(origin[1]);
    write_coord(origin[2]+20);
    write_short(g_iSpray);
    write_short(g_iDrop);
    write_byte(248);
    write_byte(30);
    message_end();

    message_begin(MSG_PVS, SVC_TEMPENTITY, origin);
    write_byte(TE_BLOODSTREAM);
    write_coord(origin[0]);
    write_coord(origin[1]);
    write_coord(origin[2]+30);
    write_coord(random_num(-20, 20));
    write_coord(random_num(-20, 20));
    write_coord(random_num(50, 300));
    write_byte(70);
    write_byte(random_num(100, 200));
    message_end();

    message_begin(MSG_PVS, SVC_TEMPENTITY, origin);
    write_byte(TE_PARTICLEBURST);
    write_coord(origin[0]);
    write_coord(origin[1]);
    write_coord(origin[2]);
    write_short(50);
    write_byte(70);
    write_byte(3);
    message_end();

    message_begin(MSG_PVS, SVC_TEMPENTITY, origin);
    write_byte(TE_BLOODSTREAM);
    write_coord(origin[0]);
    write_coord(origin[1]);
    write_coord(origin[2]+10);
    write_coord(random_num(-360, 360));
    write_coord(random_num(-360, 360));
    write_coord(-10);
    write_byte(70);
    write_byte(random_num(50, 100));
    message_end();
}

stock fnColorPrint(index, const Msg[], any:...) {
    new Buffer[190], Buffer2[192];
    formatex(Buffer2, charsmax(Buffer2), "^x04[%s] ^x01%s", g_szPluginPrefix, Msg);
    vformat(Buffer, charsmax(Buffer), Buffer2, 3);

    if (!index) {
        for (new i = 1; i <= g_iMaxPlayers; i++) {
            if (!is_user_connected(i))
                continue;

            message_begin(MSG_ONE_UNRELIABLE, g_iMsgSayText,_, i);
            write_byte(i);
            write_string(Buffer);
            message_end();
        }
    }
    else {
        if (!is_user_connected(index))
            return;

        message_begin(MSG_ONE, g_iMsgSayText,_, index);
        write_byte(index);
        write_string(Buffer);
        message_end();
    }
}