Raised This Month: $ Target: $400
 0% 

HNS XP Mod


Post New Thread Reply   
 
Thread Tools Display Modes
Author Message
GXLZPGX
Veteran Member
Join Date: Sep 2009
Old 05-02-2010 , 17:55   HNS XP Mod
Reply With Quote #1

I have absolutely no errors when there is one player in the server. But when 2 or more join it hits 4k ping and crashes. The server works fine without hnsxp.

PHP Code:
\// =================================================
// BEGIN EDITING HERE
// =================================================

// Should the plugin save player data in SQL database?
// To save player data in a vault, change "#define USING_SQL" to "//#define USING_SQL"
// To save player data in SQL, change "//#define USING_SQL" to "#define USING_SQL"

//#define USING_SQL

// The prefix in all of the plugin's messages

new const MESSAGE_TAG[] =        "[jG]";

// If the player hasn't ever been to your server, they will get this much xp to start with

#define ENTRY_XP            300

// These determine if these abilities should be enabled or disabled
// 1 = enabled
// 0 = disabled

#define ENABLE_GRENADE            1
#define ENABLE_FLASHBANG_1        1
#define ENABLE_FLASHBANG_2        1
#define ENABLE_SMOKEGRENADE        1
#define ENABLE_TERR_HEALTH        1
#define ENABLE_CT_HEALTH        1
#define ENABLE_TERR_ARMOR        1
#define ENABLE_CT_ARMOR            1
#define ENABLE_TERR_RESPAWN        1
#define ENABLE_CT_RESPAWN        1
#define ENABLE_TERR_NOFALL        1
#define ENABLE_CT_NOFALL        1

// The maximum level for each ability

#define MAXLEVEL_GRENADE        8
#define MAXLEVEL_FLASHBANG_1        4
#define MAXLEVEL_FLASHBANG_2        4
#define MAXLEVEL_SMOKEGRENADE        4
#define MAXLEVEL_TERR_HEALTH        10
#define MAXLEVEL_CT_HEALTH        5
#define MAXLEVEL_TERR_ARMOR        8
#define MAXLEVEL_CT_ARMOR        6
#define MAXLEVEL_TERR_RESPAWN        2
#define MAXLEVEL_CT_RESPAWN        2
#define MAXLEVEL_TERR_NOFALL        8
#define MAXLEVEL_CT_NOFALL        8

// The xp amount required to buy the first level

#define FIRST_XP_GRENADE        200
#define FIRST_XP_FLASHBANG_1        100
#define FIRST_XP_FLASHBANG_2        100
#define FIRST_XP_SMOKEGRENADE        200
#define FIRST_XP_TERR_HEALTH        100
#define FIRST_XP_CT_HEALTH        100
#define FIRST_XP_TERR_ARMOR        100
#define FIRST_XP_CT_ARMOR        100
#define FIRST_XP_TERR_RESPAWN        5000
#define FIRST_XP_CT_RESPAWN        2500
#define FIRST_XP_TERR_NOFALL        100
#define FIRST_XP_CT_NOFALL        100

// The maximum chance possible for this ability (happens when player has maximum level)

#define CHANCE_MAX_GRENADE        100
#define CHANCE_MAX_FLASHBANG_1        100
#define CHANCE_MAX_FLASHBANG_2        100
#define CHANCE_MAX_SMOKEGRENADE        100
#define CHANCE_MAX_TERR_RESPAWN        50
#define CHANCE_MAX_CT_RESPAWN        75
#define CHANCE_MAX_TERR_NOFALL        80
#define CHANCE_MAX_CT_NOFALL        80

// =================================================
// STOP EDITING HERE
// =================================================


#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <hamsandwich>
#include <fun>
#include <regex>
#include <hlsdk_const>
#include <chatcolor>

#if defined USING_SQL
#include <sqlx>

new Handle:g_sql_tuple;
#else
#include <nvault>

new g_vault;
#endif


new const VERSION[] =    "0.0.1";


#pragma semicolon 1

enum _:Grenades
{
    
NADE_HE,
    
NADE_FL1,
    
NADE_FL2,
    
NADE_SM
};

new const 
g_nade_enabled[Grenades] =
{
    
ENABLE_GRENADE,
    
ENABLE_FLASHBANG_1,
    
ENABLE_FLASHBANG_2,
    
ENABLE_SMOKEGRENADE
};

new const 
g_any_nade_enabled ENABLE_GRENADE ENABLE_FLASHBANG_1 ENABLE_FLASHBANG_2 ENABLE_SMOKEGRENADE;

new const 
g_nade_names[Grenades][] =
{
    
"HE Grenade",
    
"Flashbang #1",
    
"Flashbang #2",
    
"Frost Nade"
};

new const 
g_nade_classnames[Grenades][] =
{
    
"weapon_hegrenade",
    
"weapon_flashbang",
    
"weapon_flashbang",
    
"weapon_smokegrenade"
};

new const 
g_nade_maxlevels[Grenades] =
{
    
MAXLEVEL_GRENADE,
    
MAXLEVEL_FLASHBANG_1,
    
MAXLEVEL_FLASHBANG_2,
    
MAXLEVEL_SMOKEGRENADE
};

new const 
g_nade_first_xp[Grenades] =
{
    
FIRST_XP_GRENADE,
    
FIRST_XP_FLASHBANG_1,
    
FIRST_XP_FLASHBANG_2,
    
FIRST_XP_SMOKEGRENADE
};

new const 
g_nade_max_chance[Grenades] =
{
    
CHANCE_MAX_GRENADE,
    
CHANCE_MAX_FLASHBANG_1,
    
CHANCE_MAX_FLASHBANG_2,
    
CHANCE_MAX_SMOKEGRENADE
};

new const 
g_team_names[CsTeams][] =
{
    
"Spectator",
    
"Terrorist",
    
"Counter-Terrorist",
    
"Spectator"
};

new const 
g_health_enabled[CsTeams] =
{
    
0,
    
ENABLE_TERR_HEALTH,
    
ENABLE_CT_HEALTH,
    
0
};

new const 
g_any_health_enabled ENABLE_TERR_HEALTH ENABLE_CT_HEALTH;

new const 
g_health_names[CsTeams][] =
{
    
"",
    
"T Extra Health",
    
"CT Extra Health",
    
""
};

new const 
g_health_maxamount[CsTeams] =
{
    
0,
    
100,
    
100,
    
0
};

new const 
g_health_maxlevels[CsTeams] =
{
    
0,
    
MAXLEVEL_TERR_HEALTH,
    
MAXLEVEL_CT_HEALTH,
    
0
};

new const 
g_health_first_xp[CsTeams] =
{
    
0,
    
FIRST_XP_TERR_HEALTH,
    
FIRST_XP_CT_HEALTH,
    
0
};

new const 
g_armor_enabled[CsTeams] =
{
    
0,
    
ENABLE_TERR_ARMOR,
    
ENABLE_CT_ARMOR,
    
0
};

new const 
g_any_armor_enabled ENABLE_TERR_ARMOR ENABLE_CT_ARMOR;

new const 
g_armor_names[CsTeams][] =
{
    
"",
    
"T Armor",
    
"CT Armor",
    
""
};

new const 
g_armor_maxamount[CsTeams] =
{
    
0,
    
200,
    
150,
    
0
};

new const 
g_armor_maxlevels[CsTeams] =
{
    
0,
    
MAXLEVEL_TERR_ARMOR,
    
MAXLEVEL_CT_ARMOR,
    
0
};

new const 
g_armor_first_xp[CsTeams] =
{
    
0,
    
FIRST_XP_TERR_ARMOR,
    
FIRST_XP_CT_ARMOR,
    
0
};

new const 
g_respawn_enabled[CsTeams] =
{
    
0,
    
ENABLE_TERR_RESPAWN,
    
ENABLE_CT_RESPAWN,
    
0
};

new const 
g_any_respawn_enabled ENABLE_TERR_RESPAWN ENABLE_CT_RESPAWN;

new const 
g_respawn_names[CsTeams][] =
{
    
"",
    
"T Respawn Chance",
    
"CT Respawn Chance",
    
""
};

new const 
g_respawn_maxlevels[CsTeams] =
{
    
0,
    
MAXLEVEL_TERR_RESPAWN,
    
MAXLEVEL_CT_RESPAWN,
    
0
};

new const 
g_respawn_first_xp[CsTeams] =
{
    
0,
    
FIRST_XP_TERR_RESPAWN,
    
FIRST_XP_CT_RESPAWN,
    
0
};

new const 
g_respawn_max_chance[CsTeams] =
{
    
0,
    
CHANCE_MAX_TERR_RESPAWN,
    
CHANCE_MAX_CT_RESPAWN,
    
0
};

new const 
g_nofall_enabled[CsTeams] =
{
    
0,
    
ENABLE_TERR_NOFALL,
    
ENABLE_CT_NOFALL,
    
0
};

new const 
g_any_nofall_enabled ENABLE_TERR_NOFALL ENABLE_CT_NOFALL;

new const 
g_nofall_names[CsTeams][] =
{
    
"",
    
"T Fall Damage Reducer",
    
"CT Fall Damage Reducer",
    
""
};

new const 
g_nofall_maxlevels[CsTeams] =
{
    
0,
    
MAXLEVEL_TERR_NOFALL,
    
MAXLEVEL_CT_NOFALL,
    
0
};

new const 
g_nofall_first_xp[CsTeams] =
{
    
0,
    
FIRST_XP_TERR_NOFALL,
    
FIRST_XP_CT_NOFALL,
    
0
};

new const 
g_nofall_max_chance[CsTeams] =
{
    
0,
    
CHANCE_MAX_TERR_NOFALL,
    
CHANCE_MAX_CT_NOFALL,
    
0
};

#define ANY_ABILITY_ENABLED (g_any_nade_enabled || g_any_health_enabled || g_any_armor_enabled || g_any_respawn_enabled || g_any_nofall_enabled)

new g_authid[33][35];

new 
g_xp[33];

new 
g_first_time[33];
#if defined USING_SQL
new g_loaded_data[33];
#endif

new g_used_revive[33];

new 
g_nade_level[33][Grenades];
new 
g_armor_level[33][CsTeams];
new 
g_respawn_level[33][CsTeams];
new 
g_health_level[33][CsTeams];
new 
g_nofall_level[33][CsTeams];

new 
cvar_xp_suicide;
new 
cvar_xp_kill;
new 
cvar_xp_headshot;
new 
cvar_xp_grenade;
new 
cvar_xp_survive;
new 
cvar_xp_win;
new 
cvar_spawn_nade_delay;

new 
Float:g_nade_give_time;

new 
Regex:g_SteamID_pattern;
new 
g_regex_return;

new 
g_first_client;
new 
g_max_clients;

new 
g_msgid_SayText;

#if defined USING_SQL
public plugin_precache()
{
    
g_sql_tuple SQL_MakeStdTuple();
    
    
SQL_ThreadQuery(g_sql_tuple"QueryCreateTable""CREATE TABLE IF NOT EXISTS `hns_xp` ( `name` VARCHAR(32) NOT NULL, `authid` VARCHAR(35) NOT NULL, `data` VARCHAR(256) NOT NULL );" );
}

public 
QueryCreateTable(failstateHandle:queryerror[], errnumdata[], sizeFloat:queuetime)
{
    if( 
failstate == TQUERY_CONNECT_FAILED
    
|| failstate == TQUERY_QUERY_FAILED )
    {
        
set_fail_state(error);
    }
}
#endif

public plugin_init()
{
    
register_plugin("HideNSeek XP Mod"VERSION"Exolent");
    
register_cvar("hnsxp_author""Exolent"FCVAR_SPONLY);
    
register_cvar("hnsxp_version"VERSIONFCVAR_SPONLY);
    
    
register_clcmd("say /xp""CmdMainMenu");
    
register_clcmd("say /exp""CmdMainMenu");
    
register_clcmd("say /myxp""CmdMainMenu");
    
register_clcmd("say /myexp""CmdMainMenu");
    
register_clcmd("say_team /xp""CmdMainMenu");
    
register_clcmd("say_team /exp""CmdMainMenu");
    
register_clcmd("say_team /myxp""CmdMainMenu");
    
register_clcmd("say_team /myexp""CmdMainMenu");
    
    
register_concmd("amx_givexp""CmdGiveXP"ADMIN_RCON"<nick, #userid, authid> <xp>");
    
register_concmd("amx_removexp""CmdRemoveXP"ADMIN_RCON"<nick, #userid, authid> <xp>");
    
    
register_event("HLTV""EventNewRound""a""1=0""2=0");
    
register_event("DeathMsg""EventDeathMsg""a");
    
register_logevent("EventRoundStart"2"1=Round_Start");
    
register_logevent("EventRoundEnd"2"1=Round_End");
    
register_event("TextMsg""EventRoundRestart""a""2&#Game_C""2&#Game_w");
    
    
RegisterHam(Ham_Spawn"player""FwdPlayerSpawn"1);
    
RegisterHam(Ham_Killed"player""FwdPlayerDeath"1);
    
RegisterHam(Ham_TakeDamage"player""FwdPlayerDamage");
    
    
cvar_xp_suicide register_cvar("hnsxp_xp_suicide""5");
    
cvar_xp_kill register_cvar("hnsxp_xp_kill""35");
    
cvar_xp_headshot register_cvar("hnsxp_xp_headshot""15");
    
cvar_xp_grenade register_cvar("hnsxp_xp_grenade""5");
    
cvar_xp_survive register_cvar("hnsxp_xp_survive""10");
    
cvar_xp_win register_cvar("hnsxp_xp_win""15");
    
cvar_spawn_nade_delay register_cvar("hnsxp_spawn_nade_delay""10");
    
    
#if !defined USING_SQL
    
g_vault nvault_open("hnsxp");
    
#endif
    
    
new err[2];
    
g_SteamID_pattern regex_compile("^^STEAM_0:(0|1):\d+$"g_regex_returnerrsizeof(err) - 1);
    
    
g_first_client 1;
    
g_max_clients get_maxplayers();
    
    
g_msgid_SayText get_user_msgid("SayText");
}

#if !defined USING_SQL
public plugin_end()
{
    
nvault_close(g_vault);
}
#endif

public plugin_natives()
{
    
register_library("hns_xp");
    
register_native("hnsxp_get_user_xp""_get_xp");
    
register_native("hnsxp_set_user_xp""_set_xp");
}

public 
_get_xp(pluginparams)
{
    return 
g_xp[get_param(1)];
}

public 
_set_xp(pluginparams)
{
    new 
client get_param(1);
    
g_xp[client] = max(0get_param(2));
    
Save(client);
    return 
g_xp[client];
}

public 
client_authorized(client)
{
    if( !
is_user_bot(client) && !is_user_hltv(client) )
    {
        
/* is this still called in LAN, non-steam, etc? */
        
get_user_authid(clientg_authid[client], sizeof(g_authid[]) - 1);
        
        if( !
IsValidAuthid(g_authid[client]) )
        {
            
g_authid[client][0] = 0;
        }
        else
        {
            
Load(client);
        }
    }
}

public 
client_disconnect(client)
{
    
Save(client);
    
    
g_authid[client][0] = 0;
    
g_first_time[client] = 0;
    
#if defined USING_SQL
    
g_loaded_data[client] = 0;
    
#endif
    
g_used_revive[client] = 0;
}

public 
CmdMainMenu(client)
{
    
ShowMainMenu(client);
}

public 
CmdGiveXP(clientlevelcid)
{
    if( !
cmd_access(clientlevelcid3) ) return PLUGIN_HANDLED;
    
    static 
arg[35];
    
read_argv(1argsizeof(arg) - 1);
    
    new 
target cmd_target(clientargCMDTARGET_OBEY_IMMUNITY|CMDTARGET_NO_BOTS);
    if( !
target ) return PLUGIN_HANDLED;
    
    if( !
IsUserAuthorized(target) )
    {
        
console_print(client"Target has not authorized with the server.");
        return 
PLUGIN_HANDLED;
    }
    
    
read_argv(2argsizeof(arg) - 1);
    new 
xp str_to_num(arg);
    
    if( 
xp <= )
    {
        
console_print(client"XP must be a value greater than 0!");
        if( 
xp )
        {
            
console_print(client"Use hnsxp_remove_xp instead.");
        }
        return 
PLUGIN_HANDLED;
    }
    
    
g_xp[target] += xp;
    
    
Save(target);
    
    static 
name[2][32];
    
get_user_name(clientname[0], sizeof(name[]) - 1);
    
get_user_name(targetname[1], sizeof(name[]) - 1);
    
    
client_print_color(0Blue"^4%s^3 gave %i XP^3 to^4 %s."name[0], xpname[1]);
    
    static 
steamid[2][35];
    
get_user_authid(clientsteamid[0], sizeof(steamid[]) - 1);
    
get_user_authid(targetsteamid[1], sizeof(steamid[]) - 1);
    
    
log_amx("%s (%s) gave %i XP to %s (%s)"name[0], steamid[0], xpname[1], steamid[1]);
    
    return 
PLUGIN_HANDLED;
}

public 
CmdRemoveXP(clientlevelcid)
{
    if( !
cmd_access(clientlevelcid3) ) return PLUGIN_HANDLED;
    
    static 
arg[35];
    
read_argv(1argsizeof(arg) - 1);
    
    new 
target cmd_target(clientargCMDTARGET_OBEY_IMMUNITY|CMDTARGET_NO_BOTS);
    if( !
target ) return PLUGIN_HANDLED;
    
    if( !
IsUserAuthorized(target) )
    {
        
console_print(client"Target has not authorized with the server.");
        return 
PLUGIN_HANDLED;
    }
    
    
read_argv(2argsizeof(arg) - 1);
    new 
xp str_to_num(arg);
    
    if( 
xp <= )
    {
        
console_print(client"XP must be a value greater than 0!");
        if( 
xp )
        {
            
console_print(client"Use hnsxp_give_xp instead.");
        }
        return 
PLUGIN_HANDLED;
    }
    
    
g_xp[target] -= xp;
    
    
Save(target);
    
    static 
name[2][32];
    
get_user_name(clientname[0], sizeof(name[]) - 1);
    
get_user_name(targetname[1], sizeof(name[]) - 1);
    
    
client_print_color(0Blue"^4%s^3 removed %i XP^3 from^4 %s."name[0], xpname[1]);
    
    static 
steamid[2][35];
    
get_user_authid(clientsteamid[0], sizeof(steamid[]) - 1);
    
get_user_authid(targetsteamid[1], sizeof(steamid[]) - 1);
    
    
log_amx("%s (%s) removed %i XP from %s (%s)"name[0], steamid[0], xpname[1], steamid[1]);
    
    return 
PLUGIN_HANDLED;
}

public 
EventNewRound()
{
    
arrayset(g_used_revive0sizeof(g_used_revive));
    
    
g_nade_give_time 9999999.9;
}

public 
EventDeathMsg()
{
    new 
killer read_data(1);
    new 
victim read_data(2);
    
    if( (
g_first_client <= killer <= g_max_clients) && victim != killer )
    {
        if( 
IsUserAuthorized(killer) )
        {
            
// regular kill
            
new xp get_pcvar_num(cvar_xp_kill);
            
            if( 
read_data(3) )
            {
                
// headshot kill
                
xp += get_pcvar_num(cvar_xp_headshot);
            }
            else
            {
                static 
weapon[20];
                
read_data(4weaponsizeof(weapon) - 1);
                
                if( 
contain(weapon"grenade") >= )
                {
                    
// grenade kill (or frostnade)
                    
xp += get_pcvar_num(cvar_xp_grenade);
                }
            }
            
            
g_xp[killer] += xp;
            
            
client_print_color(killerBlue"You gained^4 %i XP!"xp);
            
            
Save(killer);
        }
    }
    else if( 
IsUserAuthorized(victim) )
    {
        
// victim died of map causes or killed self
        
new xp get_pcvar_num(cvar_xp_suicide);
        
        
g_xp[victim] -= xp;
        
        
client_print_color(victimBlue"You lost^4 %i XP!"xp);
        
        
Save(victim);
    }
}

public 
EventRoundStart()
{
    
g_nade_give_time get_pcvar_float(cvar_spawn_nade_delay);
    
    
set_task(g_nade_give_time"TaskGiveNades"1234);
    
    
g_nade_give_time += get_gametime();
}

public 
EventRoundEnd()
{
    
EventRoundRestart();
    
    new 
hiderseekerhider_alive;
    
    for( new 
g_first_client<= g_max_clientsi++ )
    {
        if( 
is_user_connected(i) )
        {
            switch( 
cs_get_user_team(i) )
            {
                case 
CS_TEAM_CT:
                {
                    if( !
seeker )
                    {
                        
seeker i;
                    }
                }
                case 
CS_TEAM_T:
                {
                    if( !
hider )
                    {
                        
hider i;
                        
                        if( !
hider_alive && is_user_alive(i) )
                        {
                            
hider_alive i;
                        }
                    }
                }
            }
            
            if( 
seeker && hider && hider_alive )
            {
                break;
            }
        }
    }
    
    if( !
hider || !seeker )
    {
        return;
    }
    
    new 
CsTeams:winner CS_TEAM_CT;
    
    if( 
hider_alive )
    {
        
winner CS_TEAM_T;
        
        new 
survive get_pcvar_num(cvar_xp_survive);
        for( new 
client g_first_clientclient <= g_max_clientsclient++ )
        {
            if( 
IsUserAuthorized(client) && is_user_alive(client) && cs_get_user_team(client) == CS_TEAM_T )
            {
                
g_xp[client] += survive;
                
Save(client);
                
                
client_print_color(clientBlue"You gained^4 %i XP^3 for surviving!"survive);
            }
        }
    }
    
    new 
win get_pcvar_num(cvar_xp_win);
    for( new 
client g_first_clientclient <= g_max_clientsclient++ )
    {
        if( 
IsUserAuthorized(client) && is_user_alive(client) && cs_get_user_team(client) == winner )
        {
            
g_xp[client] += win;
            
Save(client);
            
            
client_print_color(clientBlue"You gained^4 %i XP^3 for winning the round!"win);
        }
    }
}

public 
EventRoundRestart()
{
    
remove_task(1234);
    
    
g_nade_give_time 9999999.9;
}

public 
FwdPlayerSpawn(client)
{
    if( 
is_user_alive(client) )
    {
        new 
CsTeams:team cs_get_user_team(client);
        if( 
team == CS_TEAM_T || team == CS_TEAM_CT )
        {
            if( 
g_first_time[client] )
            {
                
client_print_color(clientBlue"It is your first time playing this^3 HideNSeek XP mod, so you are rewarded with^4 %i XP!"ENTRY_XP);
                
client_print_color(clientBlue"You earn XP based upon your gameplay, and you can buy more levels in the menu.");
                
client_print_color(clientBlue"Type^3 /xp^1 to view what you can get!");
                
                
g_first_time[client] = 0;
            }
            else
            {
                if( 
g_health_enabled[team] )
                {
                    new 
health g_health_maxamount[team] * g_health_level[client][team] / g_health_maxlevels[team];
                    if( 
health )
                    {
                        
set_user_health(clientget_user_health(client) + health);
                    }
                }
                
                if( 
g_armor_enabled[team] )
                {
                    new 
armorvalue g_armor_maxamount[team] * g_armor_level[client][team] / g_armor_maxlevels[team];
                    if( 
armorvalue == )
                    {
                        
cs_set_user_armor(clientarmorvalueCS_ARMOR_NONE);
                    }
                    else if( 
armorvalue 100 )
                    {
                        
cs_set_user_armor(clientarmorvalueCS_ARMOR_KEVLAR);
                    }
                    else
                    {
                        
cs_set_user_armor(clientarmorvalueCS_ARMOR_VESTHELM);
                    }
                }
            }
            
            if( 
get_gametime() >= g_nade_give_time )
            {
                
GiveNades(client);
            }
        }
    }
}

public 
FwdPlayerDeath(clientkillershouldgib)
{
    if( !
g_used_revive[client] )
    {
        new 
CsTeams:team cs_get_user_team(client);
        if( 
team == CS_TEAM_T || team == CS_TEAM_CT )
        {
            if( 
g_respawn_enabled[team] )
            {
                new 
percent g_respawn_max_chance[team] * g_respawn_level[client][team] / g_respawn_maxlevels[team];
                if( 
random_num(1100) <= percent )
                {
                    if( 
HasTeammateAlive(clientteam) )
                    {
                        
set_task(0.5"TaskRespawn"client);
                        
                        
client_print_color(clientBlue"You have been respawned!^4 (%i%% chance)"percent);
                        
                        
g_used_revive[client] = 1;
                    }
                }
            }
        }
    }
}

public 
FwdPlayerDamage(clientinflictorattackerFloat:damagedamagebits)
{
    if( 
is_user_alive(client) && (damagebits DMG_FALL) )
    {
        new 
CsTeams:team cs_get_user_team(client);
        if( 
team == CS_TEAM_T || team == CS_TEAM_CT )
        {
            if( 
g_nofall_enabled[team] )
            {
                new 
percent g_nofall_max_chance[team] * g_nofall_level[client][team] / g_nofall_maxlevels[team];
                
SetHamParamFloat(4damage * (1.0 - (float(percent) / 100.0)));
            }
        }
    }
}

public 
TaskRespawn(client)
{
    
ExecuteHamB(Ham_CS_RoundRespawnclient);
}

public 
TaskGiveNades()
{
    for( new 
client g_first_clientclient <= g_max_clientsclient++ )
    {
        if( 
is_user_alive(client) )
        {
            
set_task(0.5"TaskGiveNades"1234);
        }
    }
}

HasTeammateAlive(clientCsTeams:team)
{
    for( new 
g_first_client<= g_max_clientsi++ )
    {
        if( 
== client ) continue;
        
        if( 
is_user_alive(i) && cs_get_user_team(i) == team )
        {
            return 
1;
        }
    }
    
    return 
0;
}

GiveNades(client)
{
    new 
CsTeams:team cs_get_user_team(client);
    
    if( 
team == CS_TEAM_T )
    {
        static 
percent;
        for( new 
0Grenadesi++ )
        {
            if( 
g_nade_enabled[i] )
            {
                
percent g_nade_max_chance[i] * g_nade_level[client][i] / g_nade_maxlevels[i];
                if( 
percent && (percent == 100 || random_num(1100) <= percent) )
                {
                    
give_item(clientg_nade_classnames[i]);
                    
                    if( 
percent 100 )
                    {
                        
client_print_color(clientBlue"You received your^3 %s!^4 (%i%% chance)"g_nade_names[i], percent);
                    }
                }
            }
        }
    }
}

ShowMainMenu(client)
{
    static 
title[128];
    
formatex(titlesizeof(title) - 1"\r[JG]^n\wHNS-XP Menu^n^nYour XP: \w%i"g_xp[client]);
    new 
menu menu_create(title"MenuMain");
    
    
menu_additem(menu"\yHelp""*");
    if( 
g_any_nade_enabled )
    {
        
menu_additem(menu"Grenades Menu""1");
    }
    if( 
g_any_health_enabled )
    {
        
menu_additem(menu"Health Menu""2");
    }
    if( 
g_any_armor_enabled )
    {
        
menu_additem(menu"Armor Menu""3");
    }
    if( 
g_any_respawn_enabled )
    {
        
menu_additem(menu"Respawn Menu""4");
    }
    if( 
g_any_nofall_enabled )
    {
        
menu_additem(menu"Fall Damage Menu^n""5");
    }
    if( 
ANY_ABILITY_ENABLED )
    {
        
menu_additem(menu"Player Info""6");
    }
    
    
menu_display(clientmenu);
}

public 
MenuMain(clientmenuitem)
{
    if( 
item == MENU_EXIT )
    {
        
menu_destroy(menu);
        return;
    }
    
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
menu_destroy(menu);
    
    switch( 
info[0] )
    {
        case 
'*':
        {
            static 
motd[2500];
            new 
len formatex(motdsizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
            
len += format(motd[len], sizeof(motd) - len 1,    "<p align=^"center^">");
            
len += format(motd[len], sizeof(motd) - len 1,    "HideNSeek XP Mod is an experienced based addon for HideNSeek.<br>");
            
len += format(motd[len], sizeof(motd) - len 1,    "Players earn experience points by how well they play the game.<br>");
            
len += format(motd[len], sizeof(motd) - len 1,    "<br>");
            
len += format(motd[len], sizeof(motd) - len 1,    "<table border=0>");
            
len += format(motd[len], sizeof(motd) - len 1,    "<tr><th>Action</th><th>XP</th></tr>");
            
len += format(motd[len], sizeof(motd) - len 1,    "<tr><td>Kill</td><td>+%i</td></tr>"get_pcvar_num(cvar_xp_kill));
            
len += format(motd[len], sizeof(motd) - len 1,    "<tr><td>Grenade</td><td>+%i</td></tr>"get_pcvar_num(cvar_xp_grenade));
            
len += format(motd[len], sizeof(motd) - len 1,    "<tr><td>Headshot</td><td>+%i</td></tr>"get_pcvar_num(cvar_xp_headshot));
            
len += format(motd[len], sizeof(motd) - len 1,    "<tr><td>Suicide</td><td>-%i</td></tr>"get_pcvar_num(cvar_xp_suicide));
            
len += format(motd[len], sizeof(motd) - len 1,    "<tr><td>Survive as a T</td><td>+%i</td></tr>"get_pcvar_num(cvar_xp_survive));
            
len += format(motd[len], sizeof(motd) - len 1,    "<tr><td>Win Round</td><td>+%i</td></tr>"get_pcvar_num(cvar_xp_win));
            
len += format(motd[len], sizeof(motd) - len 1,    "</table>");
            
len += format(motd[len], sizeof(motd) - len 1,    "With these XP points, you can buy upgrades.<br>");
            
len += format(motd[len], sizeof(motd) - len 1,    "For a list of these upgrades, type /xp again and view the other menus inside.");
            
len += format(motd[len], sizeof(motd) - len 1,    "</p>");
            
len += format(motd[len], sizeof(motd) - len 1,    "</body>");
            
            
show_motd(clientmotd"HideNSeek XP Mod Info");
        }
        case 
'1':
        {
            
ShowGrenadesMenu(client);
        }
        case 
'2':
        {
            
ShowHealthMenu(client);
        }
        case 
'3':
        {
            
ShowArmorMenu(client);
        }
        case 
'4':
        {
            
ShowRespawnMenu(client);
        }
        case 
'5':
        {
            
ShowNoFallMenu(client);
        }
        case 
'6':
        {
            
ShowPlayerMenu(client);
        }
    }
}

ShowGrenadesMenu(client)
{
    static 
title[128];
    
formatex(titlesizeof(title) - 1"\r[JG]^n\wGrenade Menu^n^nNote: \rTerrorists Only\y^n^nYour XP: \w%i"g_xp[client]);
    new 
menu menu_create(title"MenuGrenades");
    new 
callback menu_makecallback("CallbackGrenades");
    
    
menu_additem(menu"\yHelp""*"_callback);
    
    static 
levelxppercentitem[128], info[4];
    for( new 
0Grenadesi++ )
    {
        if( 
g_nade_enabled[i] )
        {
            
level g_nade_level[client][i] + 1;
            
percent g_nade_max_chance[i] * level g_nade_maxlevels[i];
            
            if( 
g_nade_level[client][i] < g_nade_maxlevels[i] )
            {
                
xp g_nade_first_xp[i] * (<< (level 1));
                
formatex(itemsizeof(item) - 1"%s: \yLevel %i (%i%%) \r[\w%i XP\r]"g_nade_names[i], levelpercentxp);
            }
            else
            {
                
formatex(itemsizeof(item) - 1"%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]"g_nade_names[i], levelpercent);
            }
            
            
num_to_str(iinfosizeof(info) - 1);
            
            
menu_additem(menuiteminfo_callback);
        }
    }
    
    
menu_display(clientmenu);
}

public 
MenuGrenades(clientmenuitem)
{
    if( 
item == MENU_EXIT )
    {
        
menu_destroy(menu);
        
ShowMainMenu(client);
        return;
    }
    
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
menu_destroy(menu);
    
    if( 
info[0] == '*' )
    {
        static 
motd[2500];
        new 
len formatex(motdsizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "<p align=^"center^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "The Grenades ability for the XP Mod is for Terrorists only.<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "The Grenades ability contains the HE Grenade, 2 Flashbangs, and Frost Nade.<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "These are the grenades you are given when you receive the your items after the hide timer ends.<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th></th>");
        for( new 
0Grenadesi++ )
        {
            if( 
g_nade_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<th>%s</th>"g_nade_names[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Chance Intervals</th>");
        for( new 
0Grenadesi++ )
        {
            if( 
g_nade_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i%%</td>", (g_nade_max_chance[i] / g_nade_maxlevels[i]));
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Level</th>");
        for( new 
0Grenadesi++ )
        {
            if( 
g_nade_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i</td>"g_nade_maxlevels[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Chance</th>");
        for( new 
0Grenadesi++ )
        {
            if( 
g_nade_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i%%</td>"g_nade_max_chance[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</p>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</body>");
        
        
show_motd(clientmotd"XP Grenades Info");
    }
    else
    {
        new 
upgrade str_to_num(info);
        
        new 
level g_nade_level[client][upgrade] + 1;
        new 
xp g_nade_first_xp[upgrade] * (<< (level 1));
        new 
percent g_nade_max_chance[upgrade] * level g_nade_maxlevels[upgrade];
        
        
g_xp[client] -= xp;
        
g_nade_level[client][upgrade] = level;
        
        
Save(client);
        
        
client_print_color(clientBlue"You bought^4 %s Level %i (%i%%)^3 for^4 %i XP!"g_nade_names[upgrade], levelpercentxp);
    }
    
    
ShowGrenadesMenu(client);
}

public 
CallbackGrenades(clientmenuitem)
{
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
    if( 
info[0] == '*' ) return ITEM_ENABLED;
    
    new 
upgrade str_to_num(info);
    if( 
g_nade_level[client][upgrade] == g_nade_maxlevels[upgrade] )
    {
        return 
ITEM_DISABLED;
    }
    
    new 
xp g_nade_first_xp[upgrade] * (<< g_nade_level[client][upgrade]);
    if( 
g_xp[client] < xp )
    {
        return 
ITEM_DISABLED;
    }
    
    return 
ITEM_ENABLED;
}

ShowHealthMenu(client)
{
    static 
title[128];
    
formatex(titlesizeof(title) - 1"\r[JG]^n\wHealth Menu^n^nYour XP: \w%i"g_xp[client]);
    new 
menu menu_create(title"MenuHealth");
    new 
callback menu_makecallback("CallbackHealth");
    
    
menu_additem(menu"\yHelp""*"_callback);
    
    static 
levelxpamountitem[128], info[4];
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        if( 
g_health_enabled[i] )
        {
            
level g_health_level[client][i] + 1;
            
amount g_health_maxamount[i] * level g_health_maxlevels[i];
            
            if( 
g_health_level[client][i] < g_health_maxlevels[i] )
            {
                
xp g_health_first_xp[i] * (<< (level 1));
                
formatex(itemsizeof(item) - 1"%s: \yLevel %i (%i HP) \r[\w%i XP\r]"g_health_names[i], levelamountxp);
            }
            else
            {
                
formatex(itemsizeof(item) - 1"\w%s: \yLevel %i (%i HP) \r[\wMaxed Out!\r]"g_health_names[i], levelamount);
            }
            
            
num_to_str(_:iinfosizeof(info) - 1);
            
            
menu_additem(menuiteminfo_callback);
        }
    }
    
    
menu_display(clientmenu);
}

public 
MenuHealth(clientmenuitem)
{
    if( 
item == MENU_EXIT )
    {
        
menu_destroy(menu);
        
ShowMainMenu(client);
        return;
    }
    
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
menu_destroy(menu);
    
    if( 
info[0] == '*' )
    {
        static 
motd[2500];
        new 
len formatex(motdsizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "<p align=^"center^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "The Health ability is the amount of HP that is added to your spawn health.<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th></th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_health_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<th>%s</th>",g_team_names[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Health Intervals</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_health_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i</td>", (g_health_maxamount[i] / g_health_maxlevels[i]));
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Level</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_health_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i</td>"g_health_maxlevels[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Health</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_health_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i</td>"g_health_maxamount[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</p>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</body>");
        
        
show_motd(clientmotd"XP Health Info");
    }
    else
    {
        new 
CsTeams:upgrade CsTeams:str_to_num(info);
        
        new 
level g_health_level[client][upgrade] + 1;
        new 
xp g_health_first_xp[upgrade] * (<< (level 1));
        new 
amount g_health_maxamount[upgrade] * level g_health_maxlevels[upgrade];
        
        
g_xp[client] -= xp;
        
g_health_level[client][upgrade] = level;
        
        
Save(client);
        
        
client_print_color(clientBlue"You bought^4 %s Level %i (%i HP)^3 for^4 %i XP!"g_health_names[upgrade], levelamountxp);
    }
    
    
ShowHealthMenu(client);
}

public 
CallbackHealth(clientmenuitem)
{
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
    if( 
info[0] == '*' ) return ITEM_ENABLED;
    
    new 
CsTeams:upgrade CsTeams:str_to_num(info);
    if( 
g_health_level[client][upgrade] == g_health_maxlevels[upgrade] )
    {
        return 
ITEM_DISABLED;
    }
    
    new 
xp g_health_first_xp[upgrade] * (<< g_health_level[client][upgrade]);
    if( 
g_xp[client] < xp )
    {
        return 
ITEM_DISABLED;
    }
    
    return 
ITEM_ENABLED;
}

ShowArmorMenu(client)
{
    static 
title[128];
    
formatex(titlesizeof(title) - 1"\r[JG]^n\wArmor Menu^n^nYour XP: \w%i"g_xp[client]);
    new 
menu menu_create(title"MenuArmor");
    new 
callback menu_makecallback("CallbackArmor");
    
    
menu_additem(menu"\yHelp""*"_callback);
    
    static 
levelxpamountitem[128], info[4];
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        if( 
g_armor_enabled[i] )
        {
            
level g_armor_level[client][i] + 1;
            
amount g_armor_maxamount[i] * level g_armor_maxlevels[i];
            
            if( 
g_armor_level[client][i] < g_armor_maxlevels[i] )
            {
                
xp g_armor_first_xp[i] * (<< (level 1));
                
formatex(itemsizeof(item) - 1"%s: \yLevel %i (%i AP) \r[\w%i XP\r]"g_armor_names[i], levelamountxp);
            }
            else
            {
                
formatex(itemsizeof(item) - 1"\w%s: \yLevel %i (%i AP) \r[\wMaxed Out!\r]"g_armor_names[i], levelamount);
            }
            
            
num_to_str(_:iinfosizeof(info) - 1);
            
            
menu_additem(menuiteminfo_callback);
        }
    }
    
    
menu_display(clientmenu);
}

public 
MenuArmor(clientmenuitem)
{
    if( 
item == MENU_EXIT )
    {
        
menu_destroy(menu);
        
ShowMainMenu(client);
        return;
    }
    
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
menu_destroy(menu);
    
    if( 
info[0] == '*' )
    {
        static 
motd[2500];
        new 
len formatex(motdsizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "<p align=^"center^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "The Armor ability is the amount of AP that given to you at spawn.<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th></th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_armor_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<th>%s</th>",g_team_names[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Armor Intervals</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_armor_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i</td>", (g_armor_maxamount[i] / g_armor_maxlevels[i]));
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Level</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_armor_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i</td>"g_armor_maxlevels[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Armor</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_armor_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i</td>"g_armor_maxamount[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</p>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</body>");
        
        
show_motd(clientmotd"XP Armor Info");
    }
    else
    {
        new 
CsTeams:upgrade CsTeams:str_to_num(info);
        
        new 
level g_armor_level[client][upgrade] + 1;
        new 
xp g_armor_first_xp[upgrade] * (<< (level 1));
        new 
amount g_armor_maxamount[upgrade] * level g_armor_maxlevels[upgrade];
        
        
g_xp[client] -= xp;
        
g_armor_level[client][upgrade] = level;
        
        
Save(client);
        
        
client_print_color(clientBlue"You bought^4 %s Level %i (%i AP)^3 for^4 %i XP!"g_armor_names[upgrade], levelamountxp);
    }
    
    
ShowArmorMenu(client);
}

public 
CallbackArmor(clientmenuitem)
{
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
    if( 
info[0] == '*' ) return ITEM_ENABLED;
    
    new 
CsTeams:upgrade CsTeams:str_to_num(info);
    if( 
g_armor_level[client][upgrade] == g_armor_maxlevels[upgrade] )
    {
        return 
ITEM_DISABLED;
    }
    
    new 
xp g_armor_first_xp[upgrade] * (<< g_armor_level[client][upgrade]);
    if( 
g_xp[client] < xp )
    {
        return 
ITEM_DISABLED;
    }
    
    return 
ITEM_ENABLED;
}

ShowRespawnMenu(client)
{
    static 
title[128];
    
formatex(titlesizeof(title) - 1"\r[JG]^n\wRespawn Menu^n^nYour XP: \w%i"g_xp[client]);
    new 
menu menu_create(title"MenuRespawn");
    new 
callback menu_makecallback("CallbackRespawn");
    
    
menu_additem(menu"\yHelp""*"_callback);
    
    static 
levelxppercentitem[128], info[4];
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        if( 
g_respawn_enabled[i] )
        {
            
level g_respawn_level[client][i] + 1;
            
percent g_respawn_max_chance[i] * level g_respawn_maxlevels[i];
            
            if( 
g_respawn_level[client][i] < g_respawn_maxlevels[i] )
            {
                
xp g_respawn_first_xp[i] * (<< (level 1));
                
formatex(itemsizeof(item) - 1"%s: \yLevel %i (%i%%) \r[\w%i XP\r]"g_respawn_names[i], levelpercentxp);
            }
            else
            {
                
formatex(itemsizeof(item) - 1"%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]"g_respawn_names[i], levelpercent);
            }
            
            
num_to_str(_:iinfosizeof(info) - 1);
            
            
menu_additem(menuiteminfo_callback);
        }
    }
    
    
menu_display(clientmenu);
}

public 
MenuRespawn(clientmenuitem)
{
    if( 
item == MENU_EXIT )
    {
        
menu_destroy(menu);
        
ShowMainMenu(client);
        return;
    }
    
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
menu_destroy(menu);
    
    if( 
info[0] == '*' )
    {
        static 
motd[2500];
        new 
len formatex(motdsizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "<p align=^"center^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "The Respawn ability is chance to be respawned when you die.<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th></th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_respawn_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<th>%s</th>",g_team_names[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Chance Intervals</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_respawn_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i%%</td>", (g_respawn_max_chance[i] / g_respawn_maxlevels[i]));
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Level</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_respawn_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i</td>"g_respawn_maxlevels[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Chance</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_respawn_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i%%</td>"g_respawn_max_chance[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</p>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</body>");
        
        
show_motd(clientmotd"XP Respawn Info");
    }
    else
    {
        new 
CsTeams:upgrade CsTeams:str_to_num(info);
        
        new 
level g_respawn_level[client][upgrade] + 1;
        new 
xp g_respawn_first_xp[upgrade] * (<< (level 1));
        new 
percent g_respawn_max_chance[upgrade] * level g_respawn_maxlevels[upgrade];
        
        
g_xp[client] -= xp;
        
g_respawn_level[client][upgrade] = level;
        
        
Save(client);
        
        
client_print_color(clientBlue"You bought^4 %s Level %i (%i%%)^3 for^4 %i XP!"g_respawn_names[upgrade], levelpercentxp);
    }
    
    
ShowRespawnMenu(client);
}

public 
CallbackRespawn(clientmenuitem)
{
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
    if( 
info[0] == '*' ) return ITEM_ENABLED;
    
    new 
CsTeams:upgrade CsTeams:str_to_num(info);
    if( 
g_respawn_level[client][upgrade] == g_respawn_maxlevels[upgrade] )
    {
        return 
ITEM_DISABLED;
    }
    
    new 
xp g_respawn_first_xp[upgrade] * (<< g_respawn_level[client][upgrade]);
    if( 
g_xp[client] < xp || g_respawn_level[client][upgrade] == g_respawn_maxlevels[upgrade] )
    {
        return 
ITEM_DISABLED;
    }
    
    return 
ITEM_ENABLED;
}

ShowNoFallMenu(client)
{
    static 
title[128];
    
formatex(titlesizeof(title) - 1"\r[JG]^n\wFall Damage Menu^n^nYour XP: \w%i"g_xp[client]);
    new 
menu menu_create(title"MenuNoFall");
    new 
callback menu_makecallback("CallbackNoFall");
    
    
menu_additem(menu"\yHelp""*"_callback);
    
    static 
levelxppercentitem[128], info[4];
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        if( 
g_nofall_enabled[i] )
        {
            
level g_nofall_level[client][i] + 1;
            
percent g_nofall_max_chance[i] * level g_nofall_maxlevels[i];
            
            if( 
g_nofall_level[client][i] < g_nofall_maxlevels[i] )
            {
                
xp g_nofall_first_xp[i] * (<< (level 1));
                
formatex(itemsizeof(item) - 1"%s: \yLevel %i (%i%%) \r[\w%i XP\r]"g_nofall_names[i], levelpercentxp);
            }
            else
            {
                
formatex(itemsizeof(item) - 1"%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]"g_nofall_names[i], levelpercent);
            }
            
            
num_to_str(_:iinfosizeof(info) - 1);
            
            
menu_additem(menuiteminfo_callback);
        }
    }
    
    
menu_display(clientmenu);
}

public 
MenuNoFall(clientmenuitem)
{
    if( 
item == MENU_EXIT )
    {
        
menu_destroy(menu);
        
ShowMainMenu(client);
        return;
    }
    
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
menu_destroy(menu);
    
    if( 
info[0] == '*' )
    {
        static 
motd[2500];
        new 
len formatex(motdsizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "<p align=^"center^">");
        
len += format(motd[len], sizeof(motd) - len 1,    "The Fall Damage ability reduces the amount of damage inflicted from falling.<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<br>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th></th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_nofall_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<th>%s</th>",g_team_names[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Reduction Intervals</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_nofall_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i%%</td>", (g_nofall_max_chance[i] / g_nofall_maxlevels[i]));
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Level</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_nofall_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i</td>"g_nofall_maxlevels[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "<th>Max Chance</th>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_nofall_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1,    "<td>%i%%</td>"g_nofall_max_chance[i]);
            }
        }
        
len += format(motd[len], sizeof(motd) - len 1,    "</tr>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</table>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</p>");
        
len += format(motd[len], sizeof(motd) - len 1,    "</body>");
        
        
show_motd(clientmotd"XP Fall Damage Info");
    }
    else
    {
        new 
CsTeams:upgrade CsTeams:str_to_num(info);
        
        new 
level g_nofall_level[client][upgrade] + 1;
        new 
xp g_nofall_first_xp[upgrade] * (<< (level 1));
        new 
percent g_nofall_max_chance[upgrade] * level g_nofall_maxlevels[upgrade];
        
        
g_xp[client] -= xp;
        
g_nofall_level[client][upgrade] = level;
        
        
Save(client);
        
        
client_print_color(clientBlue"You bought^4 %s Level %i (%i%%)^3 for^4 %i XP!"g_nofall_names[upgrade], levelpercentxp);
    }
    
    
ShowNoFallMenu(client);
}

public 
CallbackNoFall(clientmenuitem)
{
    static 
_accessinfo[4], callback;
    
menu_item_getinfo(menuitem_accessinfosizeof(info) - 1__callback);
    
    if( 
info[0] == '*' ) return ITEM_ENABLED;
    
    new 
CsTeams:upgrade CsTeams:str_to_num(info);
    if( 
g_nofall_level[client][upgrade] == g_nofall_maxlevels[upgrade] )
    {
        return 
ITEM_DISABLED;
    }
    
    new 
xp g_nofall_first_xp[upgrade] * (<< g_nofall_level[client][upgrade]);
    if( 
g_xp[client] < xp || g_nofall_level[client][upgrade] == g_nofall_maxlevels[upgrade] )
    {
        return 
ITEM_DISABLED;
    }
    
    return 
ITEM_ENABLED;
}

ShowPlayerMenu(client)
{
    new 
menu menu_create("Player Info Menu""MenuPlayer");
    
    new 
name[32], authid[35];
    for( new 
1<= g_max_clientsi++ )
    {
        if( !
is_user_connected(i) ) continue;
        
        
get_user_name(inamesizeof(name) - 1);
        
get_user_authid(iauthidsizeof(authid) - 1);
        
        
menu_additem(menunameauthid);
    }
    
    
menu_display(clientmenu);
}

public 
MenuPlayer(clientmenuitem)
{
    if( 
item == MENU_EXIT )
    {
        
menu_destroy(menu);
        
ShowMainMenu(client);
        return;
    }
    
    static 
_accessauthid[35], callback;
    
menu_item_getinfo(menuitem_accessauthidsizeof(authid) - 1__callback);
    
menu_destroy(menu);
    
    new 
player find_player("c"authid);
    if( !
is_user_connected(player) )
    {
        
ShowMainMenu(client);
        return;
    }
    
    new 
name[32];
    
get_user_name(playernamesizeof(name) - 1);
    
    static 
motd[2500];
    new 
len copy(motdsizeof(motd) - 1"<html>");
    
len += format(motd[len], sizeof(motd) - len 1"<b><font size=^"4^">Name:</font></b> %s<br><br>"name);
    
len += format(motd[len], sizeof(motd) - len 1"<b><font size=^"4^">XP:</font></b> %i<br><br>"g_xp[player]);
    if( 
g_any_nade_enabled )
    {
        
len += format(motd[len], sizeof(motd) - len 1"<b><font size=^"4^">Grenades Levels:</font></b><br>");
        for( new 
0Grenadesi++ )
        {
            if( 
g_nade_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1"<b>%s:</b> %i/%i<br>"g_nade_names[i], g_nade_level[player][i], g_nade_maxlevels[i]);
            }
        }
    }
    if( 
g_any_health_enabled )
    {
        
len += format(motd[len], sizeof(motd) - len 1"<br><b><font size=^"4^">Health Levels:</font></b><br>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_health_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1"<b>%s:</b> %i/%i (%i/%i HP)<br>",\
                    
g_health_names[i], g_health_level[player][i], g_health_maxlevels[i],\
                    (
g_health_maxamount[i] * g_health_level[player][i] / g_health_maxlevels[i]), g_health_maxamount[i]);
            }
        }
    }
    if( 
g_any_armor_enabled )
    {
        
len += format(motd[len], sizeof(motd) - len 1"<br><b><font size=^"4^">Armor Levels:</font></b><br>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_armor_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1"<b>%s:</b> %i/%i (%i/%i AP)<br>",\
                    
g_armor_names[i], g_armor_level[player][i], g_armor_maxlevels[i],\
                    (
g_armor_maxamount[i] * g_armor_level[player][i] / g_armor_maxlevels[i]), g_armor_maxamount[i]);
            }
        }
    }
    if( 
g_any_respawn_enabled )
    {
        
len += format(motd[len], sizeof(motd) - len 1"<br><b><font size=^"4^">Respawn Levels:</font></b><br>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_respawn_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1"<b>%s:</b> %i/%i (%i/%i %%)<br>",\
                    
g_respawn_names[i], g_respawn_level[player][i], g_respawn_maxlevels[i],\
                    (
g_respawn_max_chance[i] * g_respawn_level[player][i] / g_respawn_maxlevels[i]), g_respawn_max_chance[i]);
            }
        }
    }
    if( 
g_any_nofall_enabled )
    {
        
len += format(motd[len], sizeof(motd) - len 1"<br><b><font size=^"4^">Fall Damage Levels:</font></b><br>");
        for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
        {
            if( 
g_nofall_enabled[i] )
            {
                
len += format(motd[len], sizeof(motd) - len 1"<b>%s:</b> %i/%i (%i/%i %%)<br>",\
                    
g_nofall_names[i], g_nofall_level[player][i], g_nofall_maxlevels[i],\
                    (
g_nofall_max_chance[i] * g_nofall_level[player][i] / g_nofall_maxlevels[i]), g_nofall_max_chance[i]);
            }
        }
    }
    
len += format(motd[len], sizeof(motd) - len 1"</html>");
    
    
show_motd(clientmotd"HNS XP Mod Info");
    
    
ShowPlayerMenu(client);
}

IsValidAuthid(authid[])
{
    return (
regex_match_c(authidg_SteamID_patterng_regex_return) > 0);
}

IsUserAuthorized(client)
{
    return 
g_authid[client][0] != 0;
}

Print(
client, const msg_fmt[], any:...)
{
    static 
message[192];
    new 
len formatex(messagesizeof(message) - 1"%s^x03 "MESSAGE_TAG);
    
vformat(message[len], sizeof(message) - len 1msg_fmt3);
    
    if( 
client )
    {
        
message_begin(MSG_ONE_UNRELIABLEg_msgid_SayText_client);
        
write_byte(client);
        
write_string(message);
        
message_end();
    }
    else
    {
        for( new 
g_first_client<= g_max_clientsi++ )
        {
            if( 
is_user_connected(i) )
            {
                
message_begin(MSG_ONE_UNRELIABLEg_msgid_SayText_i);
                
write_byte(i);
                
write_string(message);
                
message_end();
            }
        }
    }
}

Load(client)
{
    
#if defined USING_SQL
    
static query[128];
    
formatex(querysizeof(query) - 1"SELECT `data` FROM `hns_xp` WHERE `authid` = '%s';"g_authid[client]);
    
    static 
data[2];
    
data[0] = client;
    
    
SQL_ThreadQuery(g_sql_tuple"QueryLoadData"querydatasizeof(data));
    
#else
    
static data[256], timestamp;
    if( 
nvault_lookup(g_vaultg_authid[client], datasizeof(data) - 1timestamp) )
    {
        
ParseLoadData(clientdata);
        return;
    }
    else
    {
        
NewUser(client);
    }
    
#endif
}

#if defined USING_SQL
public QueryLoadData(failstateHandle:queryerror[], errnumdata[], sizeFloat:queuetime)
{
    if( 
failstate == TQUERY_CONNECT_FAILED
    
|| failstate == TQUERY_QUERY_FAILED )
    {
        
set_fail_state(error);
    }
    else
    {
        if( 
SQL_NumResults(query) )
        {
            static 
sqldata[256];
            
SQL_ReadResult(query0sqldatasizeof(sqldata) - 1);
            
ParseLoadData(data[0], sqldata);
        }
        else
        {
            
NewUser(data[0]);
        }
    }
}
#endif

ParseLoadData(clientdata[256])
{
    static 
num[6];
    
strbreak(datanumsizeof(num) - 1datasizeof(data) - 1);
    
    
g_xp[client] = str_to_num(num);
    
    for( new 
0Grenadesi++ )
    {
        
strbreak(datanumsizeof(num) - 1datasizeof(data) - 1);
        
g_nade_level[client][i] = clamp(str_to_num(num), 0g_nade_maxlevels[i]);
    }
    
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        
strbreak(datanumsizeof(num) - 1datasizeof(data) - 1);
        
g_armor_level[client][i] = clamp(str_to_num(num), 0g_armor_maxlevels[i]);
    }
    
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        
strbreak(datanumsizeof(num) - 1datasizeof(data) - 1);
        
g_respawn_level[client][i] = clamp(str_to_num(num), 0g_respawn_maxlevels[i]);
    }
    
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        
strbreak(datanumsizeof(num) - 1datasizeof(data) - 1);
        
g_health_level[client][i] = clamp(str_to_num(num), 0g_health_maxlevels[i]);
    }
    
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        
strbreak(datanumsizeof(num) - 1datasizeof(data) - 1);
        
g_nofall_level[client][i] = clamp(str_to_num(num), 0g_nofall_maxlevels[i]);
    }
    
    
#if defined USING_SQL
    
g_loaded_data[client] = 1;
    
#endif
}

NewUser(client)
{
    
g_first_time[client] = 1;
    
    
g_xp[client] = ENTRY_XP;
    
arrayset(g_nade_level[client], 0sizeof(g_nade_level[]));
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        
g_armor_level[client][i] = 0;
        
g_respawn_level[client][i] = 0;
        
g_health_level[client][i] = 0;
        
g_nofall_level[client][i] = 0;
    }
}

Save(client)
{
    if( !
IsUserAuthorized(client) ) return;
    
    static 
data[256];
    new 
len formatex(datasizeof(data) - 1"%i"g_xp[client]);
    
    for( new 
0Grenadesi++ )
    {
        
len += formatex(data[len], sizeof(data) - len 1" %i"g_nade_level[client][i]);
    }
    
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        
len += formatex(data[len], sizeof(data) - len 1" %i"g_armor_level[client][i]);
    }
    
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        
len += formatex(data[len], sizeof(data) - len 1" %i"g_respawn_level[client][i]);
    }
    
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        
len += formatex(data[len], sizeof(data) - len 1" %i"g_health_level[client][i]);
    }
    
    for( new 
CsTeams:CS_TEAM_T<= CS_TEAM_CTi++ )
    {
        
len += formatex(data[len], sizeof(data) - len 1" %i"g_nofall_level[client][i]);
    }
    
    
#if defined USING_SQL
    
static name[32];
    
get_user_name(clientnamesizeof(name) - 1);
    
    static 
query[512];
    if( 
g_loaded_data[client] )
    {
        
formatex(querysizeof(query) - 1"UPDATE `hns_xp` SET `name` = '%s', `data` = '%s' WHERE `authid` = '%s';"namedatag_authid[client]);
    }
    else
    {
        
formatex(querysizeof(query) - 1"INSERT INTO `hns_xp` ( `name`, `authid`, `data` ) VALUES ( '%s', '%s', '%s' );"nameg_authid[client], data);
    }
    
    
SQL_ThreadQuery(g_sql_tuple"QuerySaveData"query);
    
#else
    
nvault_set(g_vaultg_authid[client], data);
    
#endif
}

#if defined USING_SQL
public QuerySaveData(failstateHandle:queryerror[], errnumdata[], sizeFloat:queuetime)
{
    if( 
failstate == TQUERY_CONNECT_FAILED
    
|| failstate == TQUERY_QUERY_FAILED )
    {
        
set_fail_state(error);
    }
}
#endif
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang11274\\ f0\\ fs16 \n\\ par }
*/ 
__________________
Currently accepting payment US DOLLARS ONLY for custom plugins, contact me through PM.
GXLZPGX is offline
Exolent[jNr]
Veteran Member
Join Date: Feb 2007
Location: Tennessee
Old 05-03-2010 , 22:09   Re: HNS XP Mod
Reply With Quote #2

You should post in the plugin's topic.
__________________
No private work or selling mods.
Quote:
Originally Posted by xPaw View Post
I love you exolent!
Exolent[jNr] is offline
blacktample
Junior Member
Join Date: May 2010
Old 12-02-2010 , 12:15   Re: HNS XP Mod
Reply With Quote #3

does it save xp on <IP/NICK> or no change on steam id save?
blacktample is offline
Exolent[jNr]
Veteran Member
Join Date: Feb 2007
Location: Tennessee
Old 12-02-2010 , 15:32   Re: HNS XP Mod
Reply With Quote #4

Quote:
Originally Posted by blacktample View Post
does it save xp on <IP/NICK> or no change on steam id save?
SteamID only.
__________________
No private work or selling mods.
Quote:
Originally Posted by xPaw View Post
I love you exolent!
Exolent[jNr] is offline
Reply


Thread Tools
Display Modes

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off

Forum Jump


All times are GMT -4. The time now is 03:36.


Powered by vBulletin®
Copyright ©2000 - 2024, vBulletin Solutions, Inc.
Theme made by Freecode