API tools faq
paste
Advertisement
OciXCrom

Untitled

OciXCrom
Feb 3rd, 2017
228
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Pawn 63.56 KB | None | 0 0
raw download clone embed print report
  1. // =================================================
  2. // BEGIN EDITING HERE
  3. // =================================================
  4.  
  5. // Should the plugin save player data in SQL database?
  6. // To save player data in a vault, change "#define USING_SQL" to "//#define USING_SQL"
  7. // To save player data in SQL, change "//#define USING_SQL" to "#define USING_SQL"
  8.  
  9. //#define USING_SQL
  10.  
  11. // The prefix in all of the plugin's messages
  12.  
  13. new const MESSAGE_TAG[] =        "[HNS XP]";
  14.  
  15. // If the player hasn't ever been to your server, they will get this much xp to start with
  16.  
  17. #define ENTRY_XP            100
  18.  
  19. // These determine if these abilities should be enabled or disabled
  20. // 1 = enabled
  21. // 0 = disabled
  22.  
  23. #define ENABLE_GRENADE            1
  24. #define ENABLE_FLASHBANG_1        1
  25. #define ENABLE_FLASHBANG_2        1
  26. #define ENABLE_SMOKEGRENADE        1
  27. #define ENABLE_TERR_HEALTH        1
  28. #define ENABLE_CT_HEALTH        1
  29. #define ENABLE_TERR_ARMOR        1
  30. #define ENABLE_CT_ARMOR            1
  31. #define ENABLE_TERR_RESPAWN        1
  32. #define ENABLE_CT_RESPAWN        1
  33. #define ENABLE_TERR_NOFALL        1
  34. #define ENABLE_CT_NOFALL        1
  35.  
  36. // The maximum level for each ability
  37.  
  38. #define MAXLEVEL_GRENADE        8
  39. #define MAXLEVEL_FLASHBANG_1        4
  40. #define MAXLEVEL_FLASHBANG_2        4
  41. #define MAXLEVEL_SMOKEGRENADE        4
  42. #define MAXLEVEL_TERR_HEALTH        10
  43. #define MAXLEVEL_CT_HEALTH        5
  44. #define MAXLEVEL_TERR_ARMOR        8
  45. #define MAXLEVEL_CT_ARMOR        6
  46. #define MAXLEVEL_TERR_RESPAWN        2
  47. #define MAXLEVEL_CT_RESPAWN        2
  48. #define MAXLEVEL_TERR_NOFALL        8
  49. #define MAXLEVEL_CT_NOFALL        8
  50.  
  51. // The xp amount required to buy the first level
  52.  
  53. #define FIRST_XP_GRENADE        100
  54. #define FIRST_XP_FLASHBANG_1        100
  55. #define FIRST_XP_FLASHBANG_2        100
  56. #define FIRST_XP_SMOKEGRENADE        100
  57. #define FIRST_XP_TERR_HEALTH        100
  58. #define FIRST_XP_CT_HEALTH        100
  59. #define FIRST_XP_TERR_ARMOR        100
  60. #define FIRST_XP_CT_ARMOR        100
  61. #define FIRST_XP_TERR_RESPAWN        1000
  62. #define FIRST_XP_CT_RESPAWN        2000
  63. #define FIRST_XP_TERR_NOFALL        100
  64. #define FIRST_XP_CT_NOFALL        100
  65.  
  66. // The maximum chance possible for this ability (happens when player has maximum level)
  67.  
  68. #define CHANCE_MAX_GRENADE        100
  69. #define CHANCE_MAX_FLASHBANG_1        100
  70. #define CHANCE_MAX_FLASHBANG_2        100
  71. #define CHANCE_MAX_SMOKEGRENADE        100
  72. #define CHANCE_MAX_TERR_RESPAWN        50
  73. #define CHANCE_MAX_CT_RESPAWN        50
  74. #define CHANCE_MAX_TERR_NOFALL        80
  75. #define CHANCE_MAX_CT_NOFALL        80
  76.  
  77. // =================================================
  78. // STOP EDITING HERE
  79. // =================================================
  80.  
  81.  
  82. #include <amxmodx>
  83. #include <amxmisc>
  84. #include <cstrike>
  85. #include <hamsandwich>
  86. #include <fun>
  87. #include <regex>
  88. #include <hlsdk_const>
  89.  
  90. #if defined USING_SQL
  91. #include <sqlx>
  92.  
  93. new Handle:g_sql_tuple;
  94. #else
  95. #include <nvault>
  96.  
  97. new g_vault;
  98. #endif
  99.  
  100.  
  101. new const VERSION[] =    "0.0.1";
  102.  
  103.  
  104. #pragma semicolon 1
  105.  
  106. enum _:Grenades
  107. {
  108.     NADE_HE,
  109.     NADE_FL1,
  110.     NADE_FL2,
  111.     NADE_SM
  112. };
  113.  
  114. new const g_nade_enabled[Grenades] =
  115. {
  116.     ENABLE_GRENADE,
  117.     ENABLE_FLASHBANG_1,
  118.     ENABLE_FLASHBANG_2,
  119.     ENABLE_SMOKEGRENADE
  120. };
  121.  
  122. new const g_any_nade_enabled = ENABLE_GRENADE + ENABLE_FLASHBANG_1 + ENABLE_FLASHBANG_2 + ENABLE_SMOKEGRENADE;
  123.  
  124. new const g_nade_names[Grenades][] =
  125. {
  126.     "HE Grenade",
  127.     "Flashbang #1",
  128.     "Flashbang #2",
  129.     "Frost Nade"
  130. };
  131.  
  132. new const g_nade_classnames[Grenades][] =
  133. {
  134.     "weapon_hegrenade",
  135.     "weapon_flashbang",
  136.     "weapon_flashbang",
  137.     "weapon_smokegrenade"
  138. };
  139.  
  140. new const g_nade_maxlevels[Grenades] =
  141. {
  142.     MAXLEVEL_GRENADE,
  143.     MAXLEVEL_FLASHBANG_1,
  144.     MAXLEVEL_FLASHBANG_2,
  145.     MAXLEVEL_SMOKEGRENADE
  146. };
  147.  
  148. new const g_nade_first_xp[Grenades] =
  149. {
  150.     FIRST_XP_GRENADE,
  151.     FIRST_XP_FLASHBANG_1,
  152.     FIRST_XP_FLASHBANG_2,
  153.     FIRST_XP_SMOKEGRENADE
  154. };
  155.  
  156. new const g_nade_max_chance[Grenades] =
  157. {
  158.     CHANCE_MAX_GRENADE,
  159.     CHANCE_MAX_FLASHBANG_1,
  160.     CHANCE_MAX_FLASHBANG_2,
  161.     CHANCE_MAX_SMOKEGRENADE
  162. };
  163.  
  164. new const g_team_names[CsTeams][] =
  165. {
  166.     "Spectator",
  167.     "Terrorist",
  168.     "Counter-Terrorist",
  169.     "Spectator"
  170. };
  171.  
  172. new const g_health_enabled[CsTeams] =
  173. {
  174.     0,
  175.     ENABLE_TERR_HEALTH,
  176.     ENABLE_CT_HEALTH,
  177.     0
  178. };
  179.  
  180. new const g_any_health_enabled = ENABLE_TERR_HEALTH + ENABLE_CT_HEALTH;
  181.  
  182. new const g_health_names[CsTeams][] =
  183. {
  184.     "",
  185.     "T Extra Health",
  186.     "CT Extra Health",
  187.     ""
  188. };
  189.  
  190. new const g_health_maxamount[CsTeams] =
  191. {
  192.     0,
  193.     100,
  194.     50,
  195.     0
  196. };
  197.  
  198. new const g_health_maxlevels[CsTeams] =
  199. {
  200.     0,
  201.     MAXLEVEL_TERR_HEALTH,
  202.     MAXLEVEL_CT_HEALTH,
  203.     0
  204. };
  205.  
  206. new const g_health_first_xp[CsTeams] =
  207. {
  208.     0,
  209.     FIRST_XP_TERR_HEALTH,
  210.     FIRST_XP_CT_HEALTH,
  211.     0
  212. };
  213.  
  214. new const g_armor_enabled[CsTeams] =
  215. {
  216.     0,
  217.     ENABLE_TERR_ARMOR,
  218.     ENABLE_CT_ARMOR,
  219.     0
  220. };
  221.  
  222. new const g_any_armor_enabled = ENABLE_TERR_ARMOR + ENABLE_CT_ARMOR;
  223.  
  224. new const g_armor_names[CsTeams][] =
  225. {
  226.     "",
  227.     "T Armor",
  228.     "CT Armor",
  229.     ""
  230. };
  231.  
  232. new const g_armor_maxamount[CsTeams] =
  233. {
  234.     0,
  235.     200,
  236.     150,
  237.     0
  238. };
  239.  
  240. new const g_armor_maxlevels[CsTeams] =
  241. {
  242.     0,
  243.     MAXLEVEL_TERR_ARMOR,
  244.     MAXLEVEL_CT_ARMOR,
  245.     0
  246. };
  247.  
  248. new const g_armor_first_xp[CsTeams] =
  249. {
  250.     0,
  251.     FIRST_XP_TERR_ARMOR,
  252.     FIRST_XP_CT_ARMOR,
  253.     0
  254. };
  255.  
  256. new const g_respawn_enabled[CsTeams] =
  257. {
  258.     0,
  259.     ENABLE_TERR_RESPAWN,
  260.     ENABLE_CT_RESPAWN,
  261.     0
  262. };
  263.  
  264. new const g_any_respawn_enabled = ENABLE_TERR_RESPAWN + ENABLE_CT_RESPAWN;
  265.  
  266. new const g_respawn_names[CsTeams][] =
  267. {
  268.     "",
  269.     "T Respawn Chance",
  270.     "CT Respawn Chance",
  271.     ""
  272. };
  273.  
  274. new const g_respawn_maxlevels[CsTeams] =
  275. {
  276.     0,
  277.     MAXLEVEL_TERR_RESPAWN,
  278.     MAXLEVEL_CT_RESPAWN,
  279.     0
  280. };
  281.  
  282. new const g_respawn_first_xp[CsTeams] =
  283. {
  284.     0,
  285.     FIRST_XP_TERR_RESPAWN,
  286.     FIRST_XP_CT_RESPAWN,
  287.     0
  288. };
  289.  
  290. new const g_respawn_max_chance[CsTeams] =
  291. {
  292.     0,
  293.     CHANCE_MAX_TERR_RESPAWN,
  294.     CHANCE_MAX_CT_RESPAWN,
  295.     0
  296. };
  297.  
  298. new const g_nofall_enabled[CsTeams] =
  299. {
  300.     0,
  301.     ENABLE_TERR_NOFALL,
  302.     ENABLE_CT_NOFALL,
  303.     0
  304. };
  305.  
  306. new const g_any_nofall_enabled = ENABLE_TERR_NOFALL + ENABLE_CT_NOFALL;
  307.  
  308. new const g_nofall_names[CsTeams][] =
  309. {
  310.     "",
  311.     "T Fall Damage Reducer",
  312.     "CT Fall Damage Reducer",
  313.     ""
  314. };
  315.  
  316. new const g_nofall_maxlevels[CsTeams] =
  317. {
  318.     0,
  319.     MAXLEVEL_TERR_NOFALL,
  320.     MAXLEVEL_CT_NOFALL,
  321.     0
  322. };
  323.  
  324. new const g_nofall_first_xp[CsTeams] =
  325. {
  326.     0,
  327.     FIRST_XP_TERR_NOFALL,
  328.     FIRST_XP_CT_NOFALL,
  329.     0
  330. };
  331.  
  332. new const g_nofall_max_chance[CsTeams] =
  333. {
  334.     0,
  335.     CHANCE_MAX_TERR_NOFALL,
  336.     CHANCE_MAX_CT_NOFALL,
  337.     0
  338. };
  339.  
  340. #define ANY_ABILITY_ENABLED (g_any_nade_enabled || g_any_health_enabled || g_any_armor_enabled || g_any_respawn_enabled || g_any_nofall_enabled)
  341.  
  342. new g_authid[33][35];
  343.  
  344. new g_xp[33];
  345.  
  346. new g_first_time[33];
  347. #if defined USING_SQL
  348. new g_loaded_data[33];
  349. #endif
  350.  
  351. new g_used_revive[33];
  352.  
  353. new g_nade_level[33][Grenades];
  354. new g_armor_level[33][CsTeams];
  355. new g_respawn_level[33][CsTeams];
  356. new g_health_level[33][CsTeams];
  357. new g_nofall_level[33][CsTeams];
  358.  
  359. new cvar_xp_suicide;
  360. new cvar_xp_kill;
  361. new cvar_xp_headshot;
  362. new cvar_xp_grenade;
  363. new cvar_xp_survive;
  364. new cvar_xp_win;
  365. new cvar_spawn_nade_delay;
  366.  
  367. new Float:g_nade_give_time;
  368.  
  369. new Regex:g_SteamID_pattern;
  370. new g_regex_return;
  371.  
  372. new g_first_client;
  373. new g_max_clients;
  374.  
  375. new g_msgid_SayText;
  376.  
  377. #if defined USING_SQL
  378. public plugin_precache()
  379. {
  380.     g_sql_tuple = SQL_MakeStdTuple();
  381.    
  382.     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 );" );
  383. }
  384.  
  385. public QueryCreateTable(failstate, Handle:query, error[], errnum, data[], size, Float:queuetime)
  386. {
  387.     if( failstate == TQUERY_CONNECT_FAILED
  388.     || failstate == TQUERY_QUERY_FAILED )
  389.     {
  390.         set_fail_state(error);
  391.     }
  392. }
  393. #endif
  394.  
  395. public plugin_init()
  396. {
  397.     register_plugin("HideNSeek XP Mod", VERSION, "Exolent");
  398.     register_cvar("hnsxp_author", "Exolent", FCVAR_SPONLY);
  399.     register_cvar("hnsxp_version", VERSION, FCVAR_SPONLY);
  400.    
  401.     register_clcmd("say /xp", "CmdMainMenu");
  402.     register_clcmd("say /exp", "CmdMainMenu");
  403.    
  404.     register_concmd("hnsxp_give_xp", "CmdGiveXP", ADMIN_RCON, "<nick, #userid, authid> <xp>");
  405.     register_concmd("hnsxp_remove_xp", "CmdRemoveXP", ADMIN_RCON, "<nick, #userid, authid> <xp>");
  406.    
  407.     register_event("HLTV", "EventNewRound", "a", "1=0", "2=0");
  408.     register_event("DeathMsg", "EventDeathMsg", "a");
  409.     register_logevent("EventRoundStart", 2, "1=Round_Start");
  410.     register_logevent("EventRoundEnd", 2, "1=Round_End");
  411.     register_event("TextMsg", "EventRoundRestart", "a", "2&#Game_C", "2&#Game_w");
  412.    
  413.     RegisterHam(Ham_Spawn, "player", "FwdPlayerSpawn", 1);
  414.     RegisterHam(Ham_Killed, "player", "FwdPlayerDeath", 1);
  415.     RegisterHam(Ham_TakeDamage, "player", "FwdPlayerDamage");
  416.    
  417.     cvar_xp_suicide = register_cvar("hnsxp_xp_suicide", "5");
  418.     cvar_xp_kill = register_cvar("hnsxp_xp_kill", "4");
  419.     cvar_xp_headshot = register_cvar("hnsxp_xp_headshot", "3");
  420.     cvar_xp_grenade = register_cvar("hnsxp_xp_grenade", "6");
  421.     cvar_xp_survive = register_cvar("hnsxp_xp_survive", "2");
  422.     cvar_xp_win = register_cvar("hnsxp_xp_win", "3");
  423.     cvar_spawn_nade_delay = register_cvar("hnsxp_spawn_nade_delay", "10");
  424.    
  425.     #if !defined USING_SQL
  426.     g_vault = nvault_open("hnsxp");
  427.     #endif
  428.    
  429.     new err[2];
  430.     g_SteamID_pattern = regex_compile("^^STEAM_0:(0|1):\d+$", g_regex_return, err, sizeof(err) - 1);
  431.    
  432.     g_first_client = 1;
  433.     g_max_clients = get_maxplayers();
  434.    
  435.     g_msgid_SayText = get_user_msgid("SayText");
  436. }
  437.  
  438. #if !defined USING_SQL
  439. public plugin_end()
  440. {
  441.     nvault_close(g_vault);
  442. }
  443. #endif
  444.  
  445. public plugin_natives()
  446. {
  447.     register_library("hns_xp");
  448.     register_native("hnsxp_get_user_xp", "_get_xp");
  449.     register_native("hnsxp_set_user_xp", "_set_xp");
  450. }
  451.  
  452. public _get_xp(plugin, params)
  453. {
  454.     return g_xp[get_param(1)];
  455. }
  456.  
  457. public _set_xp(plugin, params)
  458. {
  459.     new client = get_param(1);
  460.     g_xp[client] = max(0, get_param(2));
  461.     Save(client);
  462.     return g_xp[client];
  463. }
  464.  
  465. public client_authorized(client)
  466. {
  467.     if( !is_user_bot(client) && !is_user_hltv(client) )
  468.     {
  469.         /* is this still called in LAN, non-steam, etc? */
  470.         get_user_authid(client, g_authid[client], sizeof(g_authid[]) - 1);
  471.        
  472.         if( !IsValidAuthid(g_authid[client]) )
  473.         {
  474.             g_authid[client][0] = 0;
  475.         }
  476.         else
  477.         {
  478.             Load(client);
  479.         }
  480.     }
  481. }
  482.  
  483. public client_disconnect(client)
  484. {
  485.     Save(client);
  486.    
  487.     g_authid[client][0] = 0;
  488.     g_first_time[client] = 0;
  489.     #if defined USING_SQL
  490.     g_loaded_data[client] = 0;
  491.     #endif
  492.     g_used_revive[client] = 0;
  493. }
  494.  
  495. public CmdMainMenu(client)
  496. {
  497.     ShowMainMenu(client);
  498. }
  499.  
  500. public CmdGiveXP(client, level, cid)
  501. {
  502.     if( !cmd_access(client, level, cid, 3) ) return PLUGIN_HANDLED;
  503.    
  504.     static arg[35];
  505.     read_argv(1, arg, sizeof(arg) - 1);
  506.    
  507.     new target = cmd_target(client, arg, CMDTARGET_OBEY_IMMUNITY|CMDTARGET_NO_BOTS);
  508.     if( !target ) return PLUGIN_HANDLED;
  509.    
  510.     if( !IsUserAuthorized(target) )
  511.     {
  512.         console_print(client, "Target has not authorized with the server.");
  513.         return PLUGIN_HANDLED;
  514.     }
  515.    
  516.     read_argv(2, arg, sizeof(arg) - 1);
  517.     new xp = str_to_num(arg);
  518.    
  519.     if( xp <= 0 )
  520.     {
  521.         console_print(client, "XP must be a value greater than 0!");
  522.         if( xp < 0 )
  523.         {
  524.             console_print(client, "Use hnsxp_remove_xp instead.");
  525.         }
  526.         return PLUGIN_HANDLED;
  527.     }
  528.    
  529.     g_xp[target] += xp;
  530.    
  531.     Save(target);
  532.    
  533.     static name[2][32];
  534.     get_user_name(client, name[0], sizeof(name[]) - 1);
  535.     get_user_name(target, name[1], sizeof(name[]) - 1);
  536.    
  537.     Print(0, "%s gave %i XP to %s.", name[0], xp, name[1]);
  538.    
  539.     static steamid[2][35];
  540.     get_user_authid(client, steamid[0], sizeof(steamid[]) - 1);
  541.     get_user_authid(target, steamid[1], sizeof(steamid[]) - 1);
  542.    
  543.     log_amx("%s (%s) gave %i XP to %s (%s)", name[0], steamid[0], xp, name[1], steamid[1]);
  544.    
  545.     return PLUGIN_HANDLED;
  546. }
  547.  
  548. public CmdRemoveXP(client, level, cid)
  549. {
  550.     if( !cmd_access(client, level, cid, 3) ) return PLUGIN_HANDLED;
  551.    
  552.     static arg[35];
  553.     read_argv(1, arg, sizeof(arg) - 1);
  554.    
  555.     new target = cmd_target(client, arg, CMDTARGET_OBEY_IMMUNITY|CMDTARGET_NO_BOTS);
  556.     if( !target ) return PLUGIN_HANDLED;
  557.    
  558.     if( !IsUserAuthorized(target) )
  559.     {
  560.         console_print(client, "Target has not authorized with the server.");
  561.         return PLUGIN_HANDLED;
  562.     }
  563.    
  564.     read_argv(2, arg, sizeof(arg) - 1);
  565.     new xp = str_to_num(arg);
  566.    
  567.     if( xp <= 0 )
  568.     {
  569.         console_print(client, "XP must be a value greater than 0!");
  570.         if( xp < 0 )
  571.         {
  572.             console_print(client, "Use hnsxp_give_xp instead.");
  573.         }
  574.         return PLUGIN_HANDLED;
  575.     }
  576.    
  577.     g_xp[target] -= xp;
  578.    
  579.     Save(target);
  580.    
  581.     static name[2][32];
  582.     get_user_name(client, name[0], sizeof(name[]) - 1);
  583.     get_user_name(target, name[1], sizeof(name[]) - 1);
  584.    
  585.     Print(0, "%s removed %i XP from %s.", name[0], xp, name[1]);
  586.    
  587.     static steamid[2][35];
  588.     get_user_authid(client, steamid[0], sizeof(steamid[]) - 1);
  589.     get_user_authid(target, steamid[1], sizeof(steamid[]) - 1);
  590.    
  591.     log_amx("%s (%s) removed %i XP from %s (%s)", name[0], steamid[0], xp, name[1], steamid[1]);
  592.    
  593.     return PLUGIN_HANDLED;
  594. }
  595.  
  596. public EventNewRound()
  597. {
  598.     arrayset(g_used_revive, 0, sizeof(g_used_revive));
  599.    
  600.     g_nade_give_time = 9999999.9;
  601. }
  602.  
  603. public EventDeathMsg()
  604. {
  605.     new killer = read_data(1);
  606.     new victim = read_data(2);
  607.    
  608.     if( (g_first_client <= killer <= g_max_clients) && victim != killer )
  609.     {
  610.         if( IsUserAuthorized(killer) )
  611.         {
  612.             // regular kill
  613.             new xp = get_pcvar_num(cvar_xp_kill);
  614.            
  615.             if( read_data(3) )
  616.             {
  617.                 // headshot kill
  618.                 xp += get_pcvar_num(cvar_xp_headshot);
  619.             }
  620.             else
  621.             {
  622.                 static weapon[20];
  623.                 read_data(4, weapon, sizeof(weapon) - 1);
  624.                
  625.                 if( contain(weapon, "grenade") >= 0 )
  626.                 {
  627.                     // grenade kill (or frostnade)
  628.                     xp += get_pcvar_num(cvar_xp_grenade);
  629.                 }
  630.             }
  631.            
  632.             g_xp[killer] += xp;
  633.            
  634.             Print(killer, "You gained %i XP!", xp);
  635.            
  636.             Save(killer);
  637.         }
  638.     }
  639.     else if( IsUserAuthorized(victim) )
  640.     {
  641.         // victim died of map causes or killed self
  642.         new xp = get_pcvar_num(cvar_xp_suicide);
  643.        
  644.         g_xp[victim] -= xp;
  645.        
  646.         Print(victim, "You lost %i XP!", xp);
  647.        
  648.         Save(victim);
  649.     }
  650. }
  651.  
  652. public EventRoundStart()
  653. {
  654.     g_nade_give_time = get_pcvar_float(cvar_spawn_nade_delay);
  655.    
  656.     set_task(g_nade_give_time, "TaskGiveNades", 1234);
  657.    
  658.     g_nade_give_time += get_gametime();
  659. }
  660.  
  661. public EventRoundEnd()
  662. {
  663.     EventRoundRestart();
  664.    
  665.     new hider, seeker, hider_alive;
  666.    
  667.     for( new i = g_first_client; i <= g_max_clients; i++ )
  668.     {
  669.         if( is_user_connected(i) )
  670.         {
  671.             switch( cs_get_user_team(i) )
  672.             {
  673.                 case CS_TEAM_CT:
  674.                 {
  675.                     if( !seeker )
  676.                     {
  677.                         seeker = i;
  678.                     }
  679.                 }
  680.                 case CS_TEAM_T:
  681.                 {
  682.                     if( !hider )
  683.                     {
  684.                         hider = i;
  685.                        
  686.                         if( !hider_alive && is_user_alive(i) )
  687.                         {
  688.                             hider_alive = i;
  689.                         }
  690.                     }
  691.                 }
  692.             }
  693.            
  694.             if( seeker && hider && hider_alive )
  695.             {
  696.                 break;
  697.             }
  698.         }
  699.     }
  700.    
  701.     if( !hider || !seeker )
  702.     {
  703.         return;
  704.     }
  705.    
  706.     new CsTeams:winner = CS_TEAM_CT;
  707.    
  708.     if( hider_alive )
  709.     {
  710.         winner = CS_TEAM_T;
  711.        
  712.         new survive = get_pcvar_num(cvar_xp_survive);
  713.         for( new client = g_first_client; client <= g_max_clients; client++ )
  714.         {
  715.             if( IsUserAuthorized(client) && is_user_alive(client) && cs_get_user_team(client) == CS_TEAM_T )
  716.             {
  717.                 g_xp[client] += survive;
  718.                 Save(client);
  719.                
  720.                 Print(client, "You gained %i XP for surviving!", survive);
  721.             }
  722.         }
  723.     }
  724.    
  725.     new win = get_pcvar_num(cvar_xp_win);
  726.     for( new client = g_first_client; client <= g_max_clients; client++ )
  727.     {
  728.         if( IsUserAuthorized(client) && is_user_alive(client) && cs_get_user_team(client) == winner )
  729.         {
  730.             g_xp[client] += win;
  731.             Save(client);
  732.            
  733.             Print(client, "You gained %i XP for winning the round!", win);
  734.         }
  735.     }
  736. }
  737.  
  738. public EventRoundRestart()
  739. {
  740.     remove_task(1234);
  741.    
  742.     g_nade_give_time = 9999999.9;
  743. }
  744.  
  745. public FwdPlayerSpawn(client)
  746. {
  747.     if( is_user_alive(client) )
  748.     {
  749.         new CsTeams:team = cs_get_user_team(client);
  750.         if( team == CS_TEAM_T || team == CS_TEAM_CT )
  751.         {
  752.             if( g_first_time[client] )
  753.             {
  754.                 Print(client, "It is your first time playing this HideNSeek XP mod, so you are rewarded with %i XP!", ENTRY_XP);
  755.                 Print(client, "You earn XP based upon your gameplay, and you can buy more levels in the menu.");
  756.                 Print(client, "Type /xp to view what you can get!");
  757.                
  758.                 g_first_time[client] = 0;
  759.             }
  760.             else
  761.             {
  762.                 if( g_health_enabled[team] )
  763.                 {
  764.                     new health = g_health_maxamount[team] * g_health_level[client][team] / g_health_maxlevels[team];
  765.                     if( health > 0 )
  766.                     {
  767.                         set_user_health(client, get_user_health(client) + health);
  768.                     }
  769.                 }
  770.                
  771.                 if( g_armor_enabled[team] )
  772.                 {
  773.                     new armorvalue = g_armor_maxamount[team] * g_armor_level[client][team] / g_armor_maxlevels[team];
  774.                     if( armorvalue == 0 )
  775.                     {
  776.                         cs_set_user_armor(client, armorvalue, CS_ARMOR_NONE);
  777.                     }
  778.                     else if( armorvalue < 100 )
  779.                     {
  780.                         cs_set_user_armor(client, armorvalue, CS_ARMOR_KEVLAR);
  781.                     }
  782.                     else
  783.                     {
  784.                         cs_set_user_armor(client, armorvalue, CS_ARMOR_VESTHELM);
  785.                     }
  786.                 }
  787.             }
  788.            
  789.             if( get_gametime() >= g_nade_give_time )
  790.             {
  791.                 GiveNades(client);
  792.             }
  793.         }
  794.     }
  795. }
  796.  
  797. public FwdPlayerDeath(client, killer, shouldgib)
  798. {
  799.     if( !g_used_revive[client] )
  800.     {
  801.         new CsTeams:team = cs_get_user_team(client);
  802.         if( team == CS_TEAM_T || team == CS_TEAM_CT )
  803.         {
  804.             if( g_respawn_enabled[team] )
  805.             {
  806.                 new percent = g_respawn_max_chance[team] * g_respawn_level[client][team] / g_respawn_maxlevels[team];
  807.                 if( random_num(1, 100) <= percent )
  808.                 {
  809.                     if( HasTeammateAlive(client, team) )
  810.                     {
  811.                         set_task(0.5, "TaskRespawn", client);
  812.                        
  813.                         Print(client, "You have been respawned! (%i%% chance)", percent);
  814.                        
  815.                         g_used_revive[client] = 1;
  816.                     }
  817.                 }
  818.             }
  819.         }
  820.     }
  821. }
  822.  
  823. public FwdPlayerDamage(client, inflictor, attacker, Float:damage, damagebits)
  824. {
  825.     if( is_user_alive(client) && (damagebits & DMG_FALL) )
  826.     {
  827.         new CsTeams:team = cs_get_user_team(client);
  828.         if( team == CS_TEAM_T || team == CS_TEAM_CT )
  829.         {
  830.             if( g_nofall_enabled[team] )
  831.             {
  832.                 new percent = g_nofall_max_chance[team] * g_nofall_level[client][team] / g_nofall_maxlevels[team];
  833.                 SetHamParamFloat(4, damage * (1.0 - (float(percent) / 100.0)));
  834.             }
  835.         }
  836.     }
  837. }
  838.  
  839. public TaskRespawn(client)
  840. {
  841.     ExecuteHamB(Ham_CS_RoundRespawn, client);
  842. }
  843.  
  844. public TaskGiveNades()
  845. {
  846.     for( new client = g_first_client; client <= g_max_clients; client++ )
  847.     {
  848.         if( is_user_alive(client) )
  849.         {
  850.             GiveNades(client);
  851.         }
  852.     }
  853. }
  854.  
  855. HasTeammateAlive(client, CsTeams:team)
  856. {
  857.     for( new i = g_first_client; i <= g_max_clients; i++ )
  858.     {
  859.         if( i == client ) continue;
  860.        
  861.         if( is_user_alive(i) && cs_get_user_team(i) == team )
  862.         {
  863.             return 1;
  864.         }
  865.     }
  866.    
  867.     return 0;
  868. }
  869.  
  870. GiveNades(client)
  871. {
  872.     new CsTeams:team = cs_get_user_team(client);
  873.    
  874.     if( team == CS_TEAM_T )
  875.     {
  876.         static percent;
  877.         for( new i = 0; i < Grenades; i++ )
  878.         {
  879.             if( g_nade_enabled[i] )
  880.             {
  881.                 percent = g_nade_max_chance[i] * g_nade_level[client][i] / g_nade_maxlevels[i];
  882.                 if( percent > 0 && (percent == 100 || random_num(1, 100) <= percent) )
  883.                 {
  884.                     give_item(client, g_nade_classnames[i]);
  885.                    
  886.                     if( percent < 100 )
  887.                     {
  888.                         Print(client, "You received your %s! (%i%% chance)", g_nade_names[i], percent);
  889.                     }
  890.                 }
  891.             }
  892.         }
  893.     }
  894. }
  895.  
  896. ShowMainMenu(client)
  897. {
  898.     static title[128];
  899.     formatex(title, sizeof(title) - 1, "[HNS XP by Exolent]^nMain Menu^n^nYour XP: \w%i", g_xp[client]);
  900.     new menu = menu_create(title, "MenuMain");
  901.    
  902.     //menu_additem(menu, "\yHelp", "*");
  903.     if( g_any_nade_enabled )
  904.     {
  905.         menu_additem(menu, "Grenades Menu", "1");
  906.     }
  907.     if( g_any_health_enabled )
  908.     {
  909.         menu_additem(menu, "Health Menu", "2");
  910.     }
  911.     if( g_any_armor_enabled )
  912.     {
  913.         menu_additem(menu, "Armor Menu", "3");
  914.     }
  915.     if( g_any_respawn_enabled )
  916.     {
  917.         menu_additem(menu, "Respawn Menu", "4");
  918.     }
  919.     if( g_any_nofall_enabled )
  920.     {
  921.         menu_additem(menu, "Fall Damage Menu^n", "5");
  922.     }
  923.     if( ANY_ABILITY_ENABLED )
  924.     {
  925.         menu_additem(menu, "Player Info", "6", ADMIN_SLAY);
  926.     }
  927.    
  928.     menu_display(client, menu);
  929. }
  930.  
  931. public MenuMain(client, menu, item)
  932. {
  933.     if( item == MENU_EXIT )
  934.     {
  935.         menu_destroy(menu);
  936.         return;
  937.     }
  938.    
  939.     static _access, info[4], callback;
  940.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  941.     menu_destroy(menu);
  942.    
  943.     switch( info[0] )
  944.     {
  945.         case '*':
  946.         {
  947.             static motd[2500];
  948.             new len = formatex(motd, sizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
  949.             len += format(motd[len], sizeof(motd) - len - 1,    "<p align=^"center^">");
  950.             len += format(motd[len], sizeof(motd) - len - 1,    "HideNSeek XP Mod is an experienced based addon for HideNSeek.<br>");
  951.             len += format(motd[len], sizeof(motd) - len - 1,    "Players earn experience points by how well they play the game.<br>");
  952.             len += format(motd[len], sizeof(motd) - len - 1,    "<br>");
  953.             len += format(motd[len], sizeof(motd) - len - 1,    "<table border=0>");
  954.             len += format(motd[len], sizeof(motd) - len - 1,    "<tr><th>Action</th><th>XP</th></tr>");
  955.             len += format(motd[len], sizeof(motd) - len - 1,    "<tr><td>Kill</td><td>+%i</td></tr>", get_pcvar_num(cvar_xp_kill));
  956.             len += format(motd[len], sizeof(motd) - len - 1,    "<tr><td>Grenade</td><td>+%i</td></tr>", get_pcvar_num(cvar_xp_grenade));
  957.             len += format(motd[len], sizeof(motd) - len - 1,    "<tr><td>Headshot</td><td>+%i</td></tr>", get_pcvar_num(cvar_xp_headshot));
  958.             len += format(motd[len], sizeof(motd) - len - 1,    "<tr><td>Suicide</td><td>-%i</td></tr>", get_pcvar_num(cvar_xp_suicide));
  959.             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));
  960.             len += format(motd[len], sizeof(motd) - len - 1,    "<tr><td>Win Round</td><td>+%i</td></tr>", get_pcvar_num(cvar_xp_win));
  961.             len += format(motd[len], sizeof(motd) - len - 1,    "</table>");
  962.             len += format(motd[len], sizeof(motd) - len - 1,    "With these XP points, you can buy upgrades.<br>");
  963.             len += format(motd[len], sizeof(motd) - len - 1,    "For a list of these upgrades, type /xp again and view the other menus inside.");
  964.             len += format(motd[len], sizeof(motd) - len - 1,    "</p>");
  965.             len += format(motd[len], sizeof(motd) - len - 1,    "</body>");
  966.            
  967.             show_motd(client, motd, "HideNSeek XP Mod Info");
  968.         }
  969.         case '1':
  970.         {
  971.             ShowGrenadesMenu(client);
  972.         }
  973.         case '2':
  974.         {
  975.             ShowHealthMenu(client);
  976.         }
  977.         case '3':
  978.         {
  979.             ShowArmorMenu(client);
  980.         }
  981.         case '4':
  982.         {
  983.             ShowRespawnMenu(client);
  984.         }
  985.         case '5':
  986.         {
  987.             ShowNoFallMenu(client);
  988.         }
  989.         case '6':
  990.         {
  991.             ShowPlayerMenu(client);
  992.         }
  993.     }
  994. }
  995.  
  996. ShowGrenadesMenu(client)
  997. {
  998.     static title[128];
  999.     formatex(title, sizeof(title) - 1, "[HNS XP by Exolent]^nGrenades Menu^n^nNote: \wGrenade abilities are for \rT's Only!\y^n^nYour XP: \w%i", g_xp[client]);
  1000.     new menu = menu_create(title, "MenuGrenades");
  1001.     new callback = menu_makecallback("CallbackGrenades");
  1002.    
  1003.     //menu_additem(menu, "\yHelp", "*", _, callback);
  1004.    
  1005.     static level, xp, percent, item[128], info[4];
  1006.     for( new i = 0; i < Grenades; i++ )
  1007.     {
  1008.         if( g_nade_enabled[i] )
  1009.         {
  1010.             level = g_nade_level[client][i] + 1;
  1011.             percent = g_nade_max_chance[i] * level / g_nade_maxlevels[i];
  1012.            
  1013.             if( g_nade_level[client][i] < g_nade_maxlevels[i] )
  1014.             {
  1015.                 xp = g_nade_first_xp[i] * (1 << (level - 1));
  1016.                 formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\w%i XP\r]", g_nade_names[i], level, percent, xp);
  1017.             }
  1018.             else
  1019.             {
  1020.                 formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]", g_nade_names[i], level, percent);
  1021.             }
  1022.            
  1023.             num_to_str(i, info, sizeof(info) - 1);
  1024.            
  1025.             menu_additem(menu, item, info, _, callback);
  1026.         }
  1027.     }
  1028.    
  1029.     menu_display(client, menu);
  1030. }
  1031.  
  1032. public MenuGrenades(client, menu, item)
  1033. {
  1034.     if( item == MENU_EXIT )
  1035.     {
  1036.         menu_destroy(menu);
  1037.         ShowMainMenu(client);
  1038.         return;
  1039.     }
  1040.    
  1041.     static _access, info[4], callback;
  1042.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1043.     menu_destroy(menu);
  1044.    
  1045.     if( info[0] == '*' )
  1046.     {
  1047.         static motd[2500];
  1048.         new len = formatex(motd, sizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
  1049.         len += format(motd[len], sizeof(motd) - len - 1,    "<p align=^"center^">");
  1050.         len += format(motd[len], sizeof(motd) - len - 1,    "The Grenades ability for the XP Mod is for Terrorists only.<br>");
  1051.         len += format(motd[len], sizeof(motd) - len - 1,    "The Grenades ability contains the HE Grenade, 2 Flashbangs, and Frost Nade.<br>");
  1052.         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>");
  1053.         len += format(motd[len], sizeof(motd) - len - 1,    "<br>");
  1054.         len += format(motd[len], sizeof(motd) - len - 1,    "<table>");
  1055.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1056.         len += format(motd[len], sizeof(motd) - len - 1,    "<th></th>");
  1057.         for( new i = 0; i < Grenades; i++ )
  1058.         {
  1059.             if( g_nade_enabled[i] )
  1060.             {
  1061.                 len += format(motd[len], sizeof(motd) - len - 1,    "<th>%s</th>", g_nade_names[i]);
  1062.             }
  1063.         }
  1064.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1065.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1066.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Chance Intervals</th>");
  1067.         for( new i = 0; i < Grenades; i++ )
  1068.         {
  1069.             if( g_nade_enabled[i] )
  1070.             {
  1071.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i%%</td>", (g_nade_max_chance[i] / g_nade_maxlevels[i]));
  1072.             }
  1073.         }
  1074.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1075.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1076.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Level</th>");
  1077.         for( new i = 0; i < Grenades; i++ )
  1078.         {
  1079.             if( g_nade_enabled[i] )
  1080.             {
  1081.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i</td>", g_nade_maxlevels[i]);
  1082.             }
  1083.         }
  1084.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1085.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Chance</th>");
  1086.         for( new i = 0; i < Grenades; i++ )
  1087.         {
  1088.             if( g_nade_enabled[i] )
  1089.             {
  1090.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i%%</td>", g_nade_max_chance[i]);
  1091.             }
  1092.         }
  1093.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1094.         len += format(motd[len], sizeof(motd) - len - 1,    "</table>");
  1095.         len += format(motd[len], sizeof(motd) - len - 1,    "</p>");
  1096.         len += format(motd[len], sizeof(motd) - len - 1,    "</body>");
  1097.        
  1098.         show_motd(client, motd, "XP Grenades Info");
  1099.     }
  1100.     else
  1101.     {
  1102.         new upgrade = str_to_num(info);
  1103.        
  1104.         new level = g_nade_level[client][upgrade] + 1;
  1105.         new xp = g_nade_first_xp[upgrade] * (1 << (level - 1));
  1106.         new percent = g_nade_max_chance[upgrade] * level / g_nade_maxlevels[upgrade];
  1107.        
  1108.         g_xp[client] -= xp;
  1109.         g_nade_level[client][upgrade] = level;
  1110.        
  1111.         Save(client);
  1112.        
  1113.         Print(client, "You bought %s Level %i (%i%%) for %i XP!", g_nade_names[upgrade], level, percent, xp);
  1114.     }
  1115.    
  1116.     ShowGrenadesMenu(client);
  1117. }
  1118.  
  1119. public CallbackGrenades(client, menu, item)
  1120. {
  1121.     static _access, info[4], callback;
  1122.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1123.    
  1124.     if( info[0] == '*' ) return ITEM_ENABLED;
  1125.    
  1126.     new upgrade = str_to_num(info);
  1127.     if( g_nade_level[client][upgrade] == g_nade_maxlevels[upgrade] )
  1128.     {
  1129.         return ITEM_DISABLED;
  1130.     }
  1131.    
  1132.     new xp = g_nade_first_xp[upgrade] * (1 << g_nade_level[client][upgrade]);
  1133.     if( g_xp[client] < xp )
  1134.     {
  1135.         return ITEM_DISABLED;
  1136.     }
  1137.    
  1138.     return ITEM_ENABLED;
  1139. }
  1140.  
  1141. ShowHealthMenu(client)
  1142. {
  1143.     static title[128];
  1144.     formatex(title, sizeof(title) - 1, "[HNS XP by Exolent]^nHealth Menu^n^nYour XP: \w%i", g_xp[client]);
  1145.     new menu = menu_create(title, "MenuHealth");
  1146.     new callback = menu_makecallback("CallbackHealth");
  1147.    
  1148.     //menu_additem(menu, "\yHelp", "*", _, callback);
  1149.    
  1150.     static level, xp, amount, item[128], info[4];
  1151.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1152.     {
  1153.         if( g_health_enabled[i] )
  1154.         {
  1155.             level = g_health_level[client][i] + 1;
  1156.             amount = g_health_maxamount[i] * level / g_health_maxlevels[i];
  1157.            
  1158.             if( g_health_level[client][i] < g_health_maxlevels[i] )
  1159.             {
  1160.                 xp = g_health_first_xp[i] * (1 << (level - 1));
  1161.                 formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i HP) \r[\w%i XP\r]", g_health_names[i], level, amount, xp);
  1162.             }
  1163.             else
  1164.             {
  1165.                 formatex(item, sizeof(item) - 1, "\w%s: \yLevel %i (%i HP) \r[\wMaxed Out!\r]", g_health_names[i], level, amount);
  1166.             }
  1167.            
  1168.             num_to_str(_:i, info, sizeof(info) - 1);
  1169.            
  1170.             menu_additem(menu, item, info, _, callback);
  1171.         }
  1172.     }
  1173.    
  1174.     menu_display(client, menu);
  1175. }
  1176.  
  1177. public MenuHealth(client, menu, item)
  1178. {
  1179.     if( item == MENU_EXIT )
  1180.     {
  1181.         menu_destroy(menu);
  1182.         ShowMainMenu(client);
  1183.         return;
  1184.     }
  1185.    
  1186.     static _access, info[4], callback;
  1187.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1188.     menu_destroy(menu);
  1189.    
  1190.     if( info[0] == '*' )
  1191.     {
  1192.         static motd[2500];
  1193.         new len = formatex(motd, sizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
  1194.         len += format(motd[len], sizeof(motd) - len - 1,    "<p align=^"center^">");
  1195.         len += format(motd[len], sizeof(motd) - len - 1,    "The Health ability is the amount of HP that is added to your spawn health.<br>");
  1196.         len += format(motd[len], sizeof(motd) - len - 1,    "<br>");
  1197.         len += format(motd[len], sizeof(motd) - len - 1,    "<table>");
  1198.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1199.         len += format(motd[len], sizeof(motd) - len - 1,    "<th></th>");
  1200.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1201.         {
  1202.             if( g_health_enabled[i] )
  1203.             {
  1204.                 len += format(motd[len], sizeof(motd) - len - 1,    "<th>%s</th>",g_team_names[i]);
  1205.             }
  1206.         }
  1207.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1208.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1209.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Health Intervals</th>");
  1210.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1211.         {
  1212.             if( g_health_enabled[i] )
  1213.             {
  1214.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i</td>", (g_health_maxamount[i] / g_health_maxlevels[i]));
  1215.             }
  1216.         }
  1217.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1218.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1219.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Level</th>");
  1220.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1221.         {
  1222.             if( g_health_enabled[i] )
  1223.             {
  1224.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i</td>", g_health_maxlevels[i]);
  1225.             }
  1226.         }
  1227.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1228.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Health</th>");
  1229.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1230.         {
  1231.             if( g_health_enabled[i] )
  1232.             {
  1233.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i</td>", g_health_maxamount[i]);
  1234.             }
  1235.         }
  1236.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1237.         len += format(motd[len], sizeof(motd) - len - 1,    "</table>");
  1238.         len += format(motd[len], sizeof(motd) - len - 1,    "</p>");
  1239.         len += format(motd[len], sizeof(motd) - len - 1,    "</body>");
  1240.        
  1241.         show_motd(client, motd, "XP Health Info");
  1242.     }
  1243.     else
  1244.     {
  1245.         new CsTeams:upgrade = CsTeams:str_to_num(info);
  1246.        
  1247.         new level = g_health_level[client][upgrade] + 1;
  1248.         new xp = g_health_first_xp[upgrade] * (1 << (level - 1));
  1249.         new amount = g_health_maxamount[upgrade] * level / g_health_maxlevels[upgrade];
  1250.        
  1251.         g_xp[client] -= xp;
  1252.         g_health_level[client][upgrade] = level;
  1253.        
  1254.         Save(client);
  1255.        
  1256.         Print(client, "You bought %s Level %i (%i HP) for %i XP!", g_health_names[upgrade], level, amount, xp);
  1257.     }
  1258.    
  1259.     ShowHealthMenu(client);
  1260. }
  1261.  
  1262. public CallbackHealth(client, menu, item)
  1263. {
  1264.     static _access, info[4], callback;
  1265.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1266.    
  1267.     if( info[0] == '*' ) return ITEM_ENABLED;
  1268.    
  1269.     new CsTeams:upgrade = CsTeams:str_to_num(info);
  1270.     if( g_health_level[client][upgrade] == g_health_maxlevels[upgrade] )
  1271.     {
  1272.         return ITEM_DISABLED;
  1273.     }
  1274.    
  1275.     new xp = g_health_first_xp[upgrade] * (1 << g_health_level[client][upgrade]);
  1276.     if( g_xp[client] < xp )
  1277.     {
  1278.         return ITEM_DISABLED;
  1279.     }
  1280.    
  1281.     return ITEM_ENABLED;
  1282. }
  1283.  
  1284. ShowArmorMenu(client)
  1285. {
  1286.     static title[128];
  1287.     formatex(title, sizeof(title) - 1, "[HNS XP by Exolent]^nArmor Menu^n^nYour XP: \w%i", g_xp[client]);
  1288.     new menu = menu_create(title, "MenuArmor");
  1289.     new callback = menu_makecallback("CallbackArmor");
  1290.    
  1291.     //menu_additem(menu, "\yHelp", "*", _, callback);
  1292.    
  1293.     static level, xp, amount, item[128], info[4];
  1294.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1295.     {
  1296.         if( g_armor_enabled[i] )
  1297.         {
  1298.             level = g_armor_level[client][i] + 1;
  1299.             amount = g_armor_maxamount[i] * level / g_armor_maxlevels[i];
  1300.            
  1301.             if( g_armor_level[client][i] < g_armor_maxlevels[i] )
  1302.             {
  1303.                 xp = g_armor_first_xp[i] * (1 << (level - 1));
  1304.                 formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i AP) \r[\w%i XP\r]", g_armor_names[i], level, amount, xp);
  1305.             }
  1306.             else
  1307.             {
  1308.                 formatex(item, sizeof(item) - 1, "\w%s: \yLevel %i (%i AP) \r[\wMaxed Out!\r]", g_armor_names[i], level, amount);
  1309.             }
  1310.            
  1311.             num_to_str(_:i, info, sizeof(info) - 1);
  1312.            
  1313.             menu_additem(menu, item, info, _, callback);
  1314.         }
  1315.     }
  1316.    
  1317.     menu_display(client, menu);
  1318. }
  1319.  
  1320. public MenuArmor(client, menu, item)
  1321. {
  1322.     if( item == MENU_EXIT )
  1323.     {
  1324.         menu_destroy(menu);
  1325.         ShowMainMenu(client);
  1326.         return;
  1327.     }
  1328.    
  1329.     static _access, info[4], callback;
  1330.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1331.     menu_destroy(menu);
  1332.    
  1333.     if( info[0] == '*' )
  1334.     {
  1335.         static motd[2500];
  1336.         new len = formatex(motd, sizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
  1337.         len += format(motd[len], sizeof(motd) - len - 1,    "<p align=^"center^">");
  1338.         len += format(motd[len], sizeof(motd) - len - 1,    "The Armor ability is the amount of AP that given to you at spawn.<br>");
  1339.         len += format(motd[len], sizeof(motd) - len - 1,    "<br>");
  1340.         len += format(motd[len], sizeof(motd) - len - 1,    "<table>");
  1341.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1342.         len += format(motd[len], sizeof(motd) - len - 1,    "<th></th>");
  1343.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1344.         {
  1345.             if( g_armor_enabled[i] )
  1346.             {
  1347.                 len += format(motd[len], sizeof(motd) - len - 1,    "<th>%s</th>",g_team_names[i]);
  1348.             }
  1349.         }
  1350.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1351.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1352.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Armor Intervals</th>");
  1353.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1354.         {
  1355.             if( g_armor_enabled[i] )
  1356.             {
  1357.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i</td>", (g_armor_maxamount[i] / g_armor_maxlevels[i]));
  1358.             }
  1359.         }
  1360.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1361.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1362.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Level</th>");
  1363.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1364.         {
  1365.             if( g_armor_enabled[i] )
  1366.             {
  1367.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i</td>", g_armor_maxlevels[i]);
  1368.             }
  1369.         }
  1370.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1371.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Armor</th>");
  1372.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1373.         {
  1374.             if( g_armor_enabled[i] )
  1375.             {
  1376.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i</td>", g_armor_maxamount[i]);
  1377.             }
  1378.         }
  1379.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1380.         len += format(motd[len], sizeof(motd) - len - 1,    "</table>");
  1381.         len += format(motd[len], sizeof(motd) - len - 1,    "</p>");
  1382.         len += format(motd[len], sizeof(motd) - len - 1,    "</body>");
  1383.        
  1384.         show_motd(client, motd, "XP Armor Info");
  1385.     }
  1386.     else
  1387.     {
  1388.         new CsTeams:upgrade = CsTeams:str_to_num(info);
  1389.        
  1390.         new level = g_armor_level[client][upgrade] + 1;
  1391.         new xp = g_armor_first_xp[upgrade] * (1 << (level - 1));
  1392.         new amount = g_armor_maxamount[upgrade] * level / g_armor_maxlevels[upgrade];
  1393.        
  1394.         g_xp[client] -= xp;
  1395.         g_armor_level[client][upgrade] = level;
  1396.        
  1397.         Save(client);
  1398.        
  1399.         Print(client, "You bought %s Level %i (%i AP) for %i XP!", g_armor_names[upgrade], level, amount, xp);
  1400.     }
  1401.    
  1402.     ShowArmorMenu(client);
  1403. }
  1404.  
  1405. public CallbackArmor(client, menu, item)
  1406. {
  1407.     static _access, info[4], callback;
  1408.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1409.    
  1410.     if( info[0] == '*' ) return ITEM_ENABLED;
  1411.    
  1412.     new CsTeams:upgrade = CsTeams:str_to_num(info);
  1413.     if( g_armor_level[client][upgrade] == g_armor_maxlevels[upgrade] )
  1414.     {
  1415.         return ITEM_DISABLED;
  1416.     }
  1417.    
  1418.     new xp = g_armor_first_xp[upgrade] * (1 << g_armor_level[client][upgrade]);
  1419.     if( g_xp[client] < xp )
  1420.     {
  1421.         return ITEM_DISABLED;
  1422.     }
  1423.    
  1424.     return ITEM_ENABLED;
  1425. }
  1426.  
  1427. ShowRespawnMenu(client)
  1428. {
  1429.     static title[128];
  1430.     formatex(title, sizeof(title) - 1, "[HNS XP by Exolent]^nRespawn Menu^n^nYour XP: \w%i", g_xp[client]);
  1431.     new menu = menu_create(title, "MenuRespawn");
  1432.     new callback = menu_makecallback("CallbackRespawn");
  1433.    
  1434.     //menu_additem(menu, "\yHelp", "*", _, callback);
  1435.    
  1436.     static level, xp, percent, item[128], info[4];
  1437.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1438.     {
  1439.         if( g_respawn_enabled[i] )
  1440.         {
  1441.             level = g_respawn_level[client][i] + 1;
  1442.             percent = g_respawn_max_chance[i] * level / g_respawn_maxlevels[i];
  1443.            
  1444.             if( g_respawn_level[client][i] < g_respawn_maxlevels[i] )
  1445.             {
  1446.                 xp = g_respawn_first_xp[i] * (1 << (level - 1));
  1447.                 formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\w%i XP\r]", g_respawn_names[i], level, percent, xp);
  1448.             }
  1449.             else
  1450.             {
  1451.                 formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]", g_respawn_names[i], level, percent);
  1452.             }
  1453.            
  1454.             num_to_str(_:i, info, sizeof(info) - 1);
  1455.            
  1456.             menu_additem(menu, item, info, _, callback);
  1457.         }
  1458.     }
  1459.    
  1460.     menu_display(client, menu);
  1461. }
  1462.  
  1463. public MenuRespawn(client, menu, item)
  1464. {
  1465.     if( item == MENU_EXIT )
  1466.     {
  1467.         menu_destroy(menu);
  1468.         ShowMainMenu(client);
  1469.         return;
  1470.     }
  1471.    
  1472.     static _access, info[4], callback;
  1473.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1474.     menu_destroy(menu);
  1475.    
  1476.     if( info[0] == '*' )
  1477.     {
  1478.         static motd[2500];
  1479.         new len = formatex(motd, sizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
  1480.         len += format(motd[len], sizeof(motd) - len - 1,    "<p align=^"center^">");
  1481.         len += format(motd[len], sizeof(motd) - len - 1,    "The Respawn ability is chance to be respawned when you die.<br>");
  1482.         len += format(motd[len], sizeof(motd) - len - 1,    "<br>");
  1483.         len += format(motd[len], sizeof(motd) - len - 1,    "<table>");
  1484.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1485.         len += format(motd[len], sizeof(motd) - len - 1,    "<th></th>");
  1486.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1487.         {
  1488.             if( g_respawn_enabled[i] )
  1489.             {
  1490.                 len += format(motd[len], sizeof(motd) - len - 1,    "<th>%s</th>",g_team_names[i]);
  1491.             }
  1492.         }
  1493.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1494.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1495.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Chance Intervals</th>");
  1496.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1497.         {
  1498.             if( g_respawn_enabled[i] )
  1499.             {
  1500.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i%%</td>", (g_respawn_max_chance[i] / g_respawn_maxlevels[i]));
  1501.             }
  1502.         }
  1503.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1504.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1505.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Level</th>");
  1506.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1507.         {
  1508.             if( g_respawn_enabled[i] )
  1509.             {
  1510.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i</td>", g_respawn_maxlevels[i]);
  1511.             }
  1512.         }
  1513.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1514.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Chance</th>");
  1515.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1516.         {
  1517.             if( g_respawn_enabled[i] )
  1518.             {
  1519.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i%%</td>", g_respawn_max_chance[i]);
  1520.             }
  1521.         }
  1522.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1523.         len += format(motd[len], sizeof(motd) - len - 1,    "</table>");
  1524.         len += format(motd[len], sizeof(motd) - len - 1,    "</p>");
  1525.         len += format(motd[len], sizeof(motd) - len - 1,    "</body>");
  1526.        
  1527.         show_motd(client, motd, "XP Respawn Info");
  1528.     }
  1529.     else
  1530.     {
  1531.         new CsTeams:upgrade = CsTeams:str_to_num(info);
  1532.        
  1533.         new level = g_respawn_level[client][upgrade] + 1;
  1534.         new xp = g_respawn_first_xp[upgrade] * (1 << (level - 1));
  1535.         new percent = g_respawn_max_chance[upgrade] * level / g_respawn_maxlevels[upgrade];
  1536.        
  1537.         g_xp[client] -= xp;
  1538.         g_respawn_level[client][upgrade] = level;
  1539.        
  1540.         Save(client);
  1541.        
  1542.         Print(client, "You bought %s Level %i (%i%%) for %i XP!", g_respawn_names[upgrade], level, percent, xp);
  1543.     }
  1544.    
  1545.     ShowRespawnMenu(client);
  1546. }
  1547.  
  1548. public CallbackRespawn(client, menu, item)
  1549. {
  1550.     static _access, info[4], callback;
  1551.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1552.    
  1553.     if( info[0] == '*' ) return ITEM_ENABLED;
  1554.    
  1555.     new CsTeams:upgrade = CsTeams:str_to_num(info);
  1556.     if( g_respawn_level[client][upgrade] == g_respawn_maxlevels[upgrade] )
  1557.     {
  1558.         return ITEM_DISABLED;
  1559.     }
  1560.    
  1561.     new xp = g_respawn_first_xp[upgrade] * (1 << g_respawn_level[client][upgrade]);
  1562.     if( g_xp[client] < xp || g_respawn_level[client][upgrade] == g_respawn_maxlevels[upgrade] )
  1563.     {
  1564.         return ITEM_DISABLED;
  1565.     }
  1566.    
  1567.     return ITEM_ENABLED;
  1568. }
  1569.  
  1570. ShowNoFallMenu(client)
  1571. {
  1572.     static title[128];
  1573.     formatex(title, sizeof(title) - 1, "[HNS XP by Exolent]^nFall Damage Menu^n^nYour XP: \w%i", g_xp[client]);
  1574.     new menu = menu_create(title, "MenuNoFall");
  1575.     new callback = menu_makecallback("CallbackNoFall");
  1576.    
  1577.     //menu_additem(menu, "\yHelp", "*", _, callback);
  1578.    
  1579.     static level, xp, percent, item[128], info[4];
  1580.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1581.     {
  1582.         if( g_nofall_enabled[i] )
  1583.         {
  1584.             level = g_nofall_level[client][i] + 1;
  1585.             percent = g_nofall_max_chance[i] * level / g_nofall_maxlevels[i];
  1586.            
  1587.             if( g_nofall_level[client][i] < g_nofall_maxlevels[i] )
  1588.             {
  1589.                 xp = g_nofall_first_xp[i] * (1 << (level - 1));
  1590.                 formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\w%i XP\r]", g_nofall_names[i], level, percent, xp);
  1591.             }
  1592.             else
  1593.             {
  1594.                 formatex(item, sizeof(item) - 1, "%s: \yLevel %i (%i%%) \r[\wMaxed Out!\r]", g_nofall_names[i], level, percent);
  1595.             }
  1596.            
  1597.             num_to_str(_:i, info, sizeof(info) - 1);
  1598.            
  1599.             menu_additem(menu, item, info, _, callback);
  1600.         }
  1601.     }
  1602.    
  1603.     menu_display(client, menu);
  1604. }
  1605.  
  1606. public MenuNoFall(client, menu, item)
  1607. {
  1608.     if( item == MENU_EXIT )
  1609.     {
  1610.         menu_destroy(menu);
  1611.         ShowMainMenu(client);
  1612.         return;
  1613.     }
  1614.    
  1615.     static _access, info[4], callback;
  1616.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1617.     menu_destroy(menu);
  1618.    
  1619.     if( info[0] == '*' )
  1620.     {
  1621.         static motd[2500];
  1622.         new len = formatex(motd, sizeof(motd) - 1,    "<body style=^"background-color:#030303; color:#FF8F00^">");
  1623.         len += format(motd[len], sizeof(motd) - len - 1,    "<p align=^"center^">");
  1624.         len += format(motd[len], sizeof(motd) - len - 1,    "The Fall Damage ability reduces the amount of damage inflicted from falling.<br>");
  1625.         len += format(motd[len], sizeof(motd) - len - 1,    "<br>");
  1626.         len += format(motd[len], sizeof(motd) - len - 1,    "<table>");
  1627.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1628.         len += format(motd[len], sizeof(motd) - len - 1,    "<th></th>");
  1629.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1630.         {
  1631.             if( g_nofall_enabled[i] )
  1632.             {
  1633.                 len += format(motd[len], sizeof(motd) - len - 1,    "<th>%s</th>",g_team_names[i]);
  1634.             }
  1635.         }
  1636.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1637.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1638.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Reduction Intervals</th>");
  1639.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1640.         {
  1641.             if( g_nofall_enabled[i] )
  1642.             {
  1643.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i%%</td>", (g_nofall_max_chance[i] / g_nofall_maxlevels[i]));
  1644.             }
  1645.         }
  1646.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1647.         len += format(motd[len], sizeof(motd) - len - 1,    "<tr>");
  1648.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Level</th>");
  1649.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1650.         {
  1651.             if( g_nofall_enabled[i] )
  1652.             {
  1653.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i</td>", g_nofall_maxlevels[i]);
  1654.             }
  1655.         }
  1656.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1657.         len += format(motd[len], sizeof(motd) - len - 1,    "<th>Max Chance</th>");
  1658.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1659.         {
  1660.             if( g_nofall_enabled[i] )
  1661.             {
  1662.                 len += format(motd[len], sizeof(motd) - len - 1,    "<td>%i%%</td>", g_nofall_max_chance[i]);
  1663.             }
  1664.         }
  1665.         len += format(motd[len], sizeof(motd) - len - 1,    "</tr>");
  1666.         len += format(motd[len], sizeof(motd) - len - 1,    "</table>");
  1667.         len += format(motd[len], sizeof(motd) - len - 1,    "</p>");
  1668.         len += format(motd[len], sizeof(motd) - len - 1,    "</body>");
  1669.        
  1670.         show_motd(client, motd, "XP Fall Damage Info");
  1671.     }
  1672.     else
  1673.     {
  1674.         new CsTeams:upgrade = CsTeams:str_to_num(info);
  1675.        
  1676.         new level = g_nofall_level[client][upgrade] + 1;
  1677.         new xp = g_nofall_first_xp[upgrade] * (1 << (level - 1));
  1678.         new percent = g_nofall_max_chance[upgrade] * level / g_nofall_maxlevels[upgrade];
  1679.        
  1680.         g_xp[client] -= xp;
  1681.         g_nofall_level[client][upgrade] = level;
  1682.        
  1683.         Save(client);
  1684.        
  1685.         Print(client, "You bought %s Level %i (%i%%) for %i XP!", g_nofall_names[upgrade], level, percent, xp);
  1686.     }
  1687.    
  1688.     ShowNoFallMenu(client);
  1689. }
  1690.  
  1691. public CallbackNoFall(client, menu, item)
  1692. {
  1693.     static _access, info[4], callback;
  1694.     menu_item_getinfo(menu, item, _access, info, sizeof(info) - 1, _, _, callback);
  1695.    
  1696.     if( info[0] == '*' ) return ITEM_ENABLED;
  1697.    
  1698.     new CsTeams:upgrade = CsTeams:str_to_num(info);
  1699.     if( g_nofall_level[client][upgrade] == g_nofall_maxlevels[upgrade] )
  1700.     {
  1701.         return ITEM_DISABLED;
  1702.     }
  1703.    
  1704.     new xp = g_nofall_first_xp[upgrade] * (1 << g_nofall_level[client][upgrade]);
  1705.     if( g_xp[client] < xp || g_nofall_level[client][upgrade] == g_nofall_maxlevels[upgrade] )
  1706.     {
  1707.         return ITEM_DISABLED;
  1708.     }
  1709.    
  1710.     return ITEM_ENABLED;
  1711. }
  1712.  
  1713. ShowPlayerMenu(client)
  1714. {
  1715.     new menu = menu_create("Player Info Menu", "MenuPlayer");
  1716.    
  1717.     new name[32], authid[35];
  1718.     for( new i = 1; i <= g_max_clients; i++ )
  1719.     {
  1720.         if( !is_user_connected(i) ) continue;
  1721.        
  1722.         get_user_name(i, name, sizeof(name) - 1);
  1723.         get_user_authid(i, authid, sizeof(authid) - 1);
  1724.        
  1725.         menu_additem(menu, name, authid);
  1726.     }
  1727.    
  1728.     menu_display(client, menu);
  1729. }
  1730.  
  1731. public MenuPlayer(client, menu, item)
  1732. {
  1733.     if( item == MENU_EXIT )
  1734.     {
  1735.         menu_destroy(menu);
  1736.         ShowMainMenu(client);
  1737.         return;
  1738.     }
  1739.    
  1740.     static _access, authid[35], callback;
  1741.     menu_item_getinfo(menu, item, _access, authid, sizeof(authid) - 1, _, _, callback);
  1742.     menu_destroy(menu);
  1743.    
  1744.     new player = find_player("c", authid);
  1745.     if( !is_user_connected(player) )
  1746.     {
  1747.         ShowMainMenu(client);
  1748.         return;
  1749.     }
  1750.    
  1751.     new name[32];
  1752.     get_user_name(player, name, sizeof(name) - 1);
  1753.    
  1754.     static motd[2500];
  1755.     new len = copy(motd, sizeof(motd) - 1, "<html>");
  1756.     len += format(motd[len], sizeof(motd) - len - 1, "<b><font size=^"4^">Name:</font></b> %s<br><br>", name);
  1757.     len += format(motd[len], sizeof(motd) - len - 1, "<b><font size=^"4^">XP:</font></b> %i<br><br>", g_xp[player]);
  1758.     if( g_any_nade_enabled )
  1759.     {
  1760.         len += format(motd[len], sizeof(motd) - len - 1, "<b><font size=^"4^">Grenades Levels:</font></b><br>");
  1761.         for( new i = 0; i < Grenades; i++ )
  1762.         {
  1763.             if( g_nade_enabled[i] )
  1764.             {
  1765.                 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]);
  1766.             }
  1767.         }
  1768.     }
  1769.     if( g_any_health_enabled )
  1770.     {
  1771.         len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Health Levels:</font></b><br>");
  1772.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1773.         {
  1774.             if( g_health_enabled[i] )
  1775.             {
  1776.                 len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i HP)<br>",\
  1777.                     g_health_names[i], g_health_level[player][i], g_health_maxlevels[i],\
  1778.                     (g_health_maxamount[i] * g_health_level[player][i] / g_health_maxlevels[i]), g_health_maxamount[i]);
  1779.             }
  1780.         }
  1781.     }
  1782.     if( g_any_armor_enabled )
  1783.     {
  1784.         len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Armor Levels:</font></b><br>");
  1785.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1786.         {
  1787.             if( g_armor_enabled[i] )
  1788.             {
  1789.                 len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i AP)<br>",\
  1790.                     g_armor_names[i], g_armor_level[player][i], g_armor_maxlevels[i],\
  1791.                     (g_armor_maxamount[i] * g_armor_level[player][i] / g_armor_maxlevels[i]), g_armor_maxamount[i]);
  1792.             }
  1793.         }
  1794.     }
  1795.     if( g_any_respawn_enabled )
  1796.     {
  1797.         len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Respawn Levels:</font></b><br>");
  1798.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1799.         {
  1800.             if( g_respawn_enabled[i] )
  1801.             {
  1802.                 len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i %%)<br>",\
  1803.                     g_respawn_names[i], g_respawn_level[player][i], g_respawn_maxlevels[i],\
  1804.                     (g_respawn_max_chance[i] * g_respawn_level[player][i] / g_respawn_maxlevels[i]), g_respawn_max_chance[i]);
  1805.             }
  1806.         }
  1807.     }
  1808.     if( g_any_nofall_enabled )
  1809.     {
  1810.         len += format(motd[len], sizeof(motd) - len - 1, "<br><b><font size=^"4^">Fall Damage Levels:</font></b><br>");
  1811.         for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1812.         {
  1813.             if( g_nofall_enabled[i] )
  1814.             {
  1815.                 len += format(motd[len], sizeof(motd) - len - 1, "<b>%s:</b> %i/%i (%i/%i %%)<br>",\
  1816.                     g_nofall_names[i], g_nofall_level[player][i], g_nofall_maxlevels[i],\
  1817.                     (g_nofall_max_chance[i] * g_nofall_level[player][i] / g_nofall_maxlevels[i]), g_nofall_max_chance[i]);
  1818.             }
  1819.         }
  1820.     }
  1821.     len += format(motd[len], sizeof(motd) - len - 1, "</html>");
  1822.    
  1823.     show_motd(client, motd, "HNS XP Mod Info");
  1824.    
  1825.     ShowPlayerMenu(client);
  1826. }
  1827.  
  1828. IsValidAuthid(authid[])
  1829. {
  1830.     return (regex_match_c(authid, g_SteamID_pattern, g_regex_return) > 0);
  1831. }
  1832.  
  1833. IsUserAuthorized(client)
  1834. {
  1835.     return g_authid[client][0] != 0;
  1836. }
  1837.  
  1838. Print(client, const msg_fmt[], any:...)
  1839. {
  1840.     static message[192];
  1841.     new len = formatex(message, sizeof(message) - 1, "%s^x03 ", MESSAGE_TAG);
  1842.     vformat(message[len], sizeof(message) - len - 1, msg_fmt, 3);
  1843.    
  1844.     if( client )
  1845.     {
  1846.         message_begin(MSG_ONE_UNRELIABLE, g_msgid_SayText, _, client);
  1847.         write_byte(client);
  1848.         write_string(message);
  1849.         message_end();
  1850.     }
  1851.     else
  1852.     {
  1853.         for( new i = g_first_client; i <= g_max_clients; i++ )
  1854.         {
  1855.             if( is_user_connected(i) )
  1856.             {
  1857.                 message_begin(MSG_ONE_UNRELIABLE, g_msgid_SayText, _, i);
  1858.                 write_byte(i);
  1859.                 write_string(message);
  1860.                 message_end();
  1861.             }
  1862.         }
  1863.     }
  1864. }
  1865.  
  1866. Load(client)
  1867. {
  1868.     #if defined USING_SQL
  1869.     static query[128];
  1870.     formatex(query, sizeof(query) - 1, "SELECT `data` FROM `hns_xp` WHERE `authid` = '%s';", g_authid[client]);
  1871.    
  1872.     static data[2];
  1873.     data[0] = client;
  1874.    
  1875.     SQL_ThreadQuery(g_sql_tuple, "QueryLoadData", query, data, sizeof(data));
  1876.     #else
  1877.     static data[256], timestamp;
  1878.     if( nvault_lookup(g_vault, g_authid[client], data, sizeof(data) - 1, timestamp) )
  1879.     {
  1880.         ParseLoadData(client, data);
  1881.         return;
  1882.     }
  1883.     else
  1884.     {
  1885.         NewUser(client);
  1886.     }
  1887.     #endif
  1888. }
  1889.  
  1890. #if defined USING_SQL
  1891. public QueryLoadData(failstate, Handle:query, error[], errnum, data[], size, Float:queuetime)
  1892. {
  1893.     if( failstate == TQUERY_CONNECT_FAILED
  1894.     || failstate == TQUERY_QUERY_FAILED )
  1895.     {
  1896.         set_fail_state(error);
  1897.     }
  1898.     else
  1899.     {
  1900.         if( SQL_NumResults(query) )
  1901.         {
  1902.             static sqldata[256];
  1903.             SQL_ReadResult(query, 0, sqldata, sizeof(sqldata) - 1);
  1904.             ParseLoadData(data[0], sqldata);
  1905.         }
  1906.         else
  1907.         {
  1908.             NewUser(data[0]);
  1909.         }
  1910.     }
  1911. }
  1912. #endif
  1913.  
  1914. ParseLoadData(client, data[256])
  1915. {
  1916.     static num[6];
  1917.     strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
  1918.    
  1919.     g_xp[client] = str_to_num(num);
  1920.    
  1921.     for( new i = 0; i < Grenades; i++ )
  1922.     {
  1923.         strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
  1924.         g_nade_level[client][i] = clamp(str_to_num(num), 0, g_nade_maxlevels[i]);
  1925.     }
  1926.    
  1927.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1928.     {
  1929.         strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
  1930.         g_armor_level[client][i] = clamp(str_to_num(num), 0, g_armor_maxlevels[i]);
  1931.     }
  1932.    
  1933.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1934.     {
  1935.         strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
  1936.         g_respawn_level[client][i] = clamp(str_to_num(num), 0, g_respawn_maxlevels[i]);
  1937.     }
  1938.    
  1939.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1940.     {
  1941.         strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
  1942.         g_health_level[client][i] = clamp(str_to_num(num), 0, g_health_maxlevels[i]);
  1943.     }
  1944.    
  1945.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1946.     {
  1947.         strbreak(data, num, sizeof(num) - 1, data, sizeof(data) - 1);
  1948.         g_nofall_level[client][i] = clamp(str_to_num(num), 0, g_nofall_maxlevels[i]);
  1949.     }
  1950.    
  1951.     #if defined USING_SQL
  1952.     g_loaded_data[client] = 1;
  1953.     #endif
  1954. }
  1955.  
  1956. NewUser(client)
  1957. {
  1958.     g_first_time[client] = 1;
  1959.    
  1960.     g_xp[client] = ENTRY_XP;
  1961.     arrayset(g_nade_level[client], 0, sizeof(g_nade_level[]));
  1962.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1963.     {
  1964.         g_armor_level[client][i] = 0;
  1965.         g_respawn_level[client][i] = 0;
  1966.         g_health_level[client][i] = 0;
  1967.         g_nofall_level[client][i] = 0;
  1968.     }
  1969. }
  1970.  
  1971. Save(client)
  1972. {
  1973.     if( !IsUserAuthorized(client) ) return;
  1974.    
  1975.     static data[256];
  1976.     new len = formatex(data, sizeof(data) - 1, "%i", g_xp[client]);
  1977.    
  1978.     for( new i = 0; i < Grenades; i++ )
  1979.     {
  1980.         len += formatex(data[len], sizeof(data) - len - 1, " %i", g_nade_level[client][i]);
  1981.     }
  1982.    
  1983.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1984.     {
  1985.         len += formatex(data[len], sizeof(data) - len - 1, " %i", g_armor_level[client][i]);
  1986.     }
  1987.    
  1988.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1989.     {
  1990.         len += formatex(data[len], sizeof(data) - len - 1, " %i", g_respawn_level[client][i]);
  1991.     }
  1992.    
  1993.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1994.     {
  1995.         len += formatex(data[len], sizeof(data) - len - 1, " %i", g_health_level[client][i]);
  1996.     }
  1997.    
  1998.     for( new CsTeams:i = CS_TEAM_T; i <= CS_TEAM_CT; i++ )
  1999.     {
  2000.         len += formatex(data[len], sizeof(data) - len - 1, " %i", g_nofall_level[client][i]);
  2001.     }
  2002.    
  2003.     #if defined USING_SQL
  2004.     static name[32];
  2005.     get_user_name(client, name, sizeof(name) - 1);
  2006.    
  2007.     static query[512];
  2008.     if( g_loaded_data[client] )
  2009.     {
  2010.         formatex(query, sizeof(query) - 1, "UPDATE `hns_xp` SET `name` = '%s', `data` = '%s' WHERE `authid` = '%s';", name, data, g_authid[client]);
  2011.     }
  2012.     else
  2013.     {
  2014.         formatex(query, sizeof(query) - 1, "INSERT INTO `hns_xp` ( `name`, `authid`, `data` ) VALUES ( '%s', '%s', '%s' );", name, g_authid[client], data);
  2015.     }
  2016.    
  2017.     SQL_ThreadQuery(g_sql_tuple, "QuerySaveData", query);
  2018.     #else
  2019.     nvault_set(g_vault, g_authid[client], data);
  2020.     #endif
  2021. }
  2022.  
  2023. #if defined USING_SQL
  2024. public QuerySaveData(failstate, Handle:query, error[], errnum, data[], size, Float:queuetime)
  2025. {
  2026.     if( failstate == TQUERY_CONNECT_FAILED
  2027.     || failstate == TQUERY_QUERY_FAILED )
  2028.     {
  2029.         set_fail_state(error);
  2030.     }
  2031. }
  2032. #endif
  2033. /* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
  2034. *{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang11274\\ f0\\ fs16 \n\\ par }
  2035. */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!