API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Aug 26th, 2019
188
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 67.67 KB | None | 0 0
raw download clone embed print report
  1. #include <amxmodx>
  2. #include <fun>
  3. #include <cstrike>
  4. #include <fakemeta>
  5. #include <hamsandwich>
  6. #include <xs>
  7.  
  8. #define PLUGIN "Crysis Nanosuit Advanced"
  9. #define AUTHOR "OT"
  10. #define VERSION "12.3"
  11.  
  12. // Viewmodel change on cloak [uncomment to use and recompile]
  13. // Do not uncomment these!!! If the weapon model is removed then you will not be allowed to shoot.
  14. // It is a big hl engine problem!!!
  15. //#define REMOVE_VIEWMODEL_ON_CLOAK
  16. //#define USE_WEAPON_STATUSICONS
  17.  
  18. // Settings defines [here it is a good place to modify some of the settings]
  19. // Maxplayers [the max players, change this if you don't have 32 players(Low memory usage)]
  20. #define MAXPLAYERS 32
  21.  
  22. // Refire Rate Manipulation
  23. #define REFIRE_PISTOLS 0.85
  24. #define REFIRE_KNIFE 0.75
  25. #define REFIRE_M3 0.70
  26. #define REFIRE_SNIPERS 0.60
  27.  
  28. // Reload Manipulation Defines
  29. #define RELOAD_RATIO 0.78
  30. #define SH_CARTRAGE_RATIO 2
  31. #define SH_AMMO_MSG_AMMOID 5
  32.  
  33. // Painshock constant
  34. #define PAIN_SHOCK_ATTENUATION 0.5
  35.  
  36. // Strength grenade throw burst
  37. #define GRENADE_STR_THROW_ADD 400
  38.  
  39. // Lowres defines -> refresh rate for screen info in lowresources mode
  40. #define NANO_LOW_RES 5 // time 0.1 seconds
  41.  
  42. // Delay of energy recharge after ability usage (time in 0.1 seconds)
  43. #define DELAY_STR_JUMP 5
  44. #define DELAY_STR_STAB 5
  45. #define DELAY_STR_SHOT 2
  46. #define DELAY_STR_G_THROW 3
  47. #define DELAY_ARM_DAMAGE 5
  48. #define DELAY_SPD_RUN 4
  49. #define DELAY_SPD_FAST_ATTACK 2
  50. #define DELAY_SPD_FAST_RELOAD 4
  51. #define DELAY_SPD_SH_RELOAD 2
  52. #define DELAY_CLK_DELAY 3
  53. #define DELAY_CLK_FORCED 5
  54.  
  55. // Energy regeneration multiply if user crouches
  56. #define ENERGY_CROUCH 1.2
  57.  
  58. // Critical border additive so that the plugin will not do the CRITICAL CRITCAL CRITICAL sound [Do not set this to 0.0 or dare!]
  59. #define CRITICAL_EXTRA_ADD 10.0
  60.  
  61. // Plugin useful defines [DO NOT MODIFY!]
  62. // Offsets defines
  63. #define OFFSET_WEAPON_OWNER 41
  64. #define OFFSET_WEAPON_ID 43
  65. #define OFFSET_WEAPON_NEXT_PRIMARY_ATTACK 46
  66. #define OFFSET_WEAPON_NEXT_SEC_ATTACK 47
  67. #define OFFSET_WEAPON_IDLE_TIME 48
  68. #define OFFSET_WEAPON_PRIMARY_AMMO_TYPE 49
  69. #define OFFSET_WEAPON_CLIP 51
  70. #define OFFSET_WEAPON_IN_RELOAD 54
  71.  
  72. #define OFFSET_PLAYER_NEXT_ATTACK 83
  73. #define OFFSET_PLAYER_PAIN_SHOCK 108
  74. #define OFFSET_PLAYER_ITEM_ACTIVE 373
  75. #define OFFSET_PLAYER_AMMO_SLOT0 376
  76.  
  77. // Linux offset difference
  78. #define EXTRA_OFFSET_PLAYER_LINUX 5
  79. #define EXTRA_OFFSET_WEAPON_LINUX 4
  80.  
  81. // Fall extras
  82. #define FALL_TRUE_VELOCITY 510.0
  83. #define FALL_FALSE_VELOCITY 350.0
  84. #define DMG_FALL_MULTIPLY 1.40
  85.  
  86. // Speed defines
  87. #define SPEED_WATER_MUL_CONSTANT 0.7266666
  88. #define SPEED_CROUCH_MUL_CONSTANT 0.3333333
  89.  
  90. // Damage offsets this is the knife/bullet damage
  91. #define DMG_CS_KNIFE_BULLETS (1 << 12 | 1 << 0)
  92.  
  93. // Flags for speed mode cvar ground
  94. #define NANO_FLAG_INWATER (1<<1)
  95. #define NANO_FLAG_CROUCHED (1<<0)
  96.  
  97. // Recoil Manipulation Defines
  98. new const UNREGISTERED_WEAPONS_BITSUM = ((1<<2) | (1<<CSW_HEGRENADE) | (1<<CSW_FLASHBANG) | (1<<CSW_SMOKEGRENADE) | (1<<CSW_C4))
  99. new const WEAPONS_WITH_SHIELD_BITSUM = ((1<<CSW_GLOCK18) | (1<<CSW_HEGRENADE) | (1<<CSW_FLASHBANG) | (1<<CSW_SMOKEGRENADE) | (1<<CSW_P228) | (1<<CSW_DEAGLE) | (1<<CSW_FIVESEVEN) | (1<<CSW_KNIFE) | (1<<CSW_USP))
  100.  
  101. // Reload Manipulation Defines
  102. new const NO_RELOAD_WEAPONS_BITSUM = ((1<<CSW_M3) | (1<<CSW_XM1014) | (1<<CSW_KNIFE))
  103.  
  104. // Task defines
  105. #define TASK_ENERGY 0
  106. #define TASK_AH_REC 33
  107. #define TASK_AI 66
  108.  
  109. // Macro Function defines [DO NOT MODIFY!]
  110. #define is_user_player(%1) (1 <= %1 <= glb_maxplayers)
  111. #define Ham_Player_ResetMaxSpeed Ham_Item_PreFrame
  112.  
  113. new const ON_LAND_CONST = ( FL_ONGROUND | FL_ONTRAIN | FL_PARTIALGROUND | FL_INWATER | FL_SWIM )
  114. new const ON_WATER_CONST = ( FL_INWATER | FL_SWIM )
  115. new const ON_GROUND_CONST = ( FL_ONGROUND | FL_ONTRAIN | FL_PARTIALGROUND )
  116.  
  117. // Nanosuit status and modes information
  118. enum NanoModes
  119. {
  120. NANO_STREN = 0,
  121. NANO_ARMOR = 1,
  122. NANO_SPEED = 2,
  123. NANO_CLOAK = 3
  124. }
  125.  
  126. new const NanoScreenColor[NanoModes][3] =
  127. {
  128. {255, 0, 0 },
  129. {25, 25, 255},
  130. {255, 255, 0 },
  131. {255, 255, 255}
  132. }
  133.  
  134. new const NanoStatusIcon[NanoModes][] =
  135. {
  136. "dmg_rad",
  137. "item_longjump",
  138. "dmg_shock",
  139. "dmg_bio"
  140. }
  141.  
  142. new const NanoGlowColor[NanoModes][3] =
  143. {
  144. {150, 0, 0 },
  145. {0, 0, 0 },
  146. {150, 150, 0 },
  147. {0, 0, 0 }
  148. }
  149.  
  150. new const NanoGlowAmmount[NanoModes] =
  151. {
  152. 1,
  153. 255,
  154. 1,
  155. 15
  156. }
  157.  
  158. new const NanoGlowFX[NanoModes] =
  159. {
  160. kRenderFxGlowShell,
  161. kRenderFxNone,
  162. kRenderFxGlowShell,
  163. kRenderFxSolidFast
  164. }
  165.  
  166. new const NanoGlowMode[NanoModes] =
  167. {
  168. kRenderNormal,
  169. kRenderNormal,
  170. kRenderNormal,
  171. kRenderTransTexture
  172. }
  173.  
  174. #define set_nano_glow(%1) set_user_rendering(%1, NanoGlowFX[cl_nn_mode[%1]], NanoGlowColor[cl_nn_mode[%1]][0], NanoGlowColor[cl_nn_mode[%1]][1], NanoGlowColor[cl_nn_mode[%1]][2], NanoGlowMode[cl_nn_mode[%1]], NanoGlowAmmount[cl_nn_mode[%1]])
  175. #define reset_rendering(%1) set_user_rendering(%1)
  176.  
  177. enum NanoStatus
  178. {
  179. NANO_NO,
  180. NANO_YES
  181. }
  182.  
  183. enum NanoSpdMode
  184. {
  185. SPEED_MAXIMUM,
  186. SPEED_CRITICAL,
  187. SPEED_NORMAL
  188. }
  189.  
  190. enum NanoSpeed
  191. {
  192. SPD_STILL = 0,
  193. SPD_VSLOW,
  194. SPD_SLOW,
  195. SPD_NORMAL,
  196. SPD_FAST
  197. }
  198.  
  199. enum NanoSpeedScreen
  200. {
  201. SPD_SCR_STILL = 0,
  202. SPD_SCR_VSLOW,
  203. SPD_SCR_SLOW,
  204. SPD_SCR_NORMAL,
  205. SPD_SCR_FAST
  206. }
  207.  
  208. enum IconStatus
  209. {
  210. ICON_REMOVE = 0,
  211. ICON_SHOW,
  212. ICON_PULSE
  213. }
  214.  
  215. enum ShadowIdX
  216. {
  217. SHADOW_REMOVE = 0,
  218. }
  219.  
  220. enum KnifeState
  221. {
  222. KNIFE_NOT = 0,
  223. KNIFE_FIRST_ATTACK,
  224. KNIFE_SECOND_ATTACK
  225. }
  226.  
  227. // HTML properties
  228. new const html_header[] = "<html><head><style type=^"text/css^">body{background:#000000;margin-left:8px;margin-top:0px;}a{text-decoration: underline;}a:link {color#FFFFFF;}a:visited{color: #FFFFFF;}a:active { color: #FFFFFF; }a:hover { color: #FFFFFF; text-decoration: underline; }</style></head><body scroll=^"yes^" style=^"text-align: left; margin: 0 auto; color:#ffb000;^"><div style=^"width: 600px; text-align: left;^"><font style=^"font-size: 20px; color:#ffb000; ^">"
  229.  
  230. // Reload needed constants
  231. stock const Float:wpn_reload_delay[CSW_P90+1] =
  232. {
  233. 0.00, 2.70, 0.00, 2.00, 0.00, 0.55, 0.00, 3.15, 3.30, 0.00, 4.50, 2.70, 3.50, 3.35, 2.45, 3.30, 2.70, 2.20, 2.50, 2.63, 4.70, 0.55, 3.05, 2.12, 3.50, 0.00, 2.20, 3.00, 2.45, 0.00, 3.40
  234. }
  235.  
  236. stock const wpn_reload_anim[CSW_P90+1] =
  237. {
  238. -1, 5, -1, 3, -1, 6, -1, 1, 1, -1, 14, 4, 2, 3, 1, 1, 13, 7, 4, 1, 3, 6, 11, 1, 3, -1, 4, 1, 1, -1, 1
  239. }
  240.  
  241. stock const wpn_max_clip[CSW_P90+1] =
  242. {
  243. -1, 13, -1, 10, 1, 7, 1, 30, 30, 1, 30, 20, 25, 30, 35, 25, 12, 20, 10, 30, 100, 8 , 30, 30, 20, 2, 7, 30, 30, -1, 50
  244. }
  245.  
  246. stock const Float:wpn_act_speed[CSW_P90+1] =
  247. {
  248. 0.0, 250.0, 0.0, 260.0, 250.0, 240.0, 250.0, 250.0, 240.0, 250.0, 250.0, 250.0, 250.0, 210.0, 240.0, 240.0, 250.0, 250.0, 210.0, 250.0, 220.0, 230.0, 230.0, 250.0, 210.0, 250.0, 250.0, 235.0, 221.0, 250.0, 245.0
  249. }
  250.  
  251. // HIT constant damage multi
  252. new const Float:vec_hit_multi[] =
  253. {
  254. 1.0,
  255. 4.0,
  256. 1.0,
  257. 1.25,
  258. 1.0,
  259. 1.0,
  260. 0.75,
  261. 0.75,
  262. 0.0
  263. }
  264.  
  265. new wpn_v_model[CSW_P90 + 1][30]
  266. new wpn_v_shield_model[CSW_P90 + 1][50]
  267. new wpn_ms_icon[CSW_P90 + 1][14]
  268. new bool:once[33];
  269. new bool:Cumparat[33];
  270.  
  271. // Sounds
  272. new const sound_strengh[] = "nanosuit/nanosuit_strength.wav"
  273. new const sound_armor[] = "nanosuit/nanosuit_armor.wav"
  274. new const sound_speed[] = "nanosuit/nanosuit_speed.wav"
  275. new const sound_cloak[] = "nanosuit/nanosuit_cloak.wav"
  276. new const sound_energy[] = "nanosuit/nanosuit_energy.wav"
  277. new const sound_menu[] = "nanosuit/nanosuit_menu.wav"
  278. new const sound_strength_throw[] = "nanosuit/nanosuit_strength_hit.wav"
  279. new const sound_strength_jump[] = "nanosuit/nanosuit_strength_jump.wav"
  280. new const sound_switch_strength[] = "nanosuit/nanosuit_strength_switch.wav"
  281. new const sound_switch_armor[] = "nanosuit/nanosuit_armor_switch.wav"
  282. new const sound_switch_speed[] = "nanosuit/nanosuit_speed_switch.wav"
  283. new const sound_switch_cloak[] = "nanosuit/nanosuit_cloak_switch.wav"
  284. new const sound_speed_run[] = "nanosuit/nanosuit_speed_run.wav"
  285.  
  286. new const sound_ric_metal1[] = "weapons/ric_metal-1.wav"
  287. new const sound_ric_metal2[] = "weapons/ric_metal-2.wav"
  288.  
  289. // Models
  290. new const model_nanosuit_ct[] = "Crysis_US_frk_14"
  291. new const model_nanosuit_ctt[] = "Crysis_US_frk_14T"
  292. new const model_nanosuit_t[] = "crysis_asian2_frk_14"
  293. new const model_nanosuit_tt[] = "crysis_asian2_frk_14T"
  294.  
  295. // We use this to check if the client said in console model leet for example, we see wether the model is T or not or else we do not set it
  296. new vec_model_ct[][] =
  297. {
  298. "gign",
  299. "gsg9",
  300. "sas",
  301. "urban",
  302. "vip"
  303. }
  304. new vec_model_t[][] =
  305. {
  306. "arctic",
  307. "terror",
  308. "leet",
  309. "guerilla"
  310. }
  311.  
  312. // Pcvars
  313. new pcv_nn_price
  314. new pcv_nn_ff
  315. new pcv_nn_death
  316. new pcv_nn_bot
  317. new pcv_nn_bot_buy
  318. new pcv_nn_team
  319. new pcv_nn_energy
  320. new pcv_nn_critical
  321. new pcv_nn_health
  322. new pcv_nn_armor
  323. new pcv_nn_buyzone
  324. new pcv_nn_regenerate
  325. new pcv_nn_night
  326. new pcv_nn_hp_charge
  327. new pcv_nn_ap_charge
  328. new pcv_nn_ar_speed
  329. new pcv_nn_ar_damage
  330. new pcv_nn_st_impulse
  331. new pcv_nn_st_stab
  332. new pcv_nn_st_jump
  333. new pcv_nn_st_throw
  334. new pcv_nn_st_rec_att
  335. new pcv_nn_st_g_throw
  336. new pcv_nn_st_rec_en
  337. new pcv_nn_st_can_th
  338. new pcv_nn_sp_maxim
  339. new pcv_nn_sp_ground
  340. new pcv_nn_sp_critic
  341. new pcv_nn_sp_energy
  342. new pcv_nn_sp_reload
  343. new pcv_nn_sp_fattack
  344. new pcv_nn_sp_fatshre
  345. new pcv_nn_cl_energy
  346. new pcv_nn_cl_fire
  347. new pcv_nn_cl_knife
  348. new pcv_nn_cl_grenade
  349. new pcv_nn_cl_c4
  350. new pcv_zm_regive
  351.  
  352. // Plugin info holders
  353. new glb_maxplayers
  354. new ShadowIdX:SHADOW_CREATE
  355. new bool:glb_use_new_models = true
  356.  
  357. // Client general info
  358. new cl_player_model[MAXPLAYERS + 1][32] // player's model name
  359. new bool:cl_update_model[MAXPLAYERS + 1] = {false, ...}
  360. new cl_nn_weapon[MAXPLAYERS + 1]
  361. new bool:cl_is_bot[MAXPLAYERS + 1] = {false, ...}
  362. new bool:cl_nn_lowres[MAXPLAYERS + 1] = {false, ...}
  363. new NanoStatus:cl_nn_has[MAXPLAYERS + 1] = {NANO_NO, ...}
  364. new NanoStatus:cl_nn_had[MAXPLAYERS + 1] = {NANO_NO, ...}
  365. new bool:cl_added_velocity[MAXPLAYERS + 1] = {false, ...}
  366. new bool:cl_removed_shadow[MAXPLAYERS + 1] = {false, ...}
  367. new bool:cl_nn_zombie[MAXPLAYERS + 1] = {false, ...}
  368.  
  369. // Nanosuit special info
  370. new NanoSpdMode:cl_nn_sp_status[MAXPLAYERS + 1]
  371. new NanoSpeed:cl_nn_speed[MAXPLAYERS + 1]
  372. new NanoSpeedScreen:cl_nn_scr_speed[MAXPLAYERS + 1]
  373. new NanoModes:cl_nn_mode[MAXPLAYERS + 1] = {NANO_ARMOR, ...}
  374. new Float:cl_nn_energy[MAXPLAYERS + 1]
  375. new bool:cl_nn_critical[MAXPLAYERS + 1]
  376. new cl_nn_counter[MAXPLAYERS + 1] = {NANO_LOW_RES, ...}
  377. new cl_nn_block_recharge[MAXPLAYERS + 1]
  378. new KnifeState:cl_nn_st_knife[MAXPLAYERS + 1] = {KNIFE_NOT, ...}
  379. new bool:cl_nn_st_jump[MAXPLAYERS + 1] = {false, ...}
  380. new cl_is_thrown[MAXPLAYERS + 1] = {0, ...}
  381. new Float:cl_nn_punch[MAXPLAYERS + 1][3]
  382. new bool:cl_nn_actual_shot[MAXPLAYERS + 1] = {false, ...}
  383. new cl_nn_shotgun_ammo[MAXPLAYERS + 1]
  384.  
  385. // Needs -> hud + menu + monitor + messages
  386. new nd_menu[MAXPLAYERS + 1]
  387. new nd_hud_sync
  388. new nd_ent_monitor
  389. new nd_msg_saytext
  390. new nd_msg_damage
  391. new nd_msg_iconstatus
  392. new nd_msg_shadowidx
  393. new nd_msg_ammox
  394.  
  395. public plugin_precache()
  396. {
  397. precache_sound(sound_armor)
  398. precache_sound(sound_strengh)
  399. precache_sound(sound_speed)
  400. precache_sound(sound_cloak)
  401. precache_sound(sound_energy)
  402. precache_sound(sound_menu)
  403. precache_sound(sound_strength_jump)
  404. precache_sound(sound_strength_throw)
  405. precache_sound(sound_switch_armor)
  406. precache_sound(sound_switch_cloak)
  407. precache_sound(sound_switch_speed)
  408. precache_sound(sound_switch_strength)
  409. precache_sound(sound_speed_run)
  410.  
  411. precache_sound(sound_ric_metal1)
  412. precache_sound(sound_ric_metal2)
  413.  
  414. SHADOW_CREATE = ShadowIdX:precache_model("sprites/shadow_circle.spr")
  415.  
  416. new modelpath[100]
  417. // We precache the models, if we have problems we don't turn on the model replace system
  418. formatex(modelpath, charsmax(modelpath), "models/player/%s/%s.mdl", model_nanosuit_ct, model_nanosuit_ct)
  419. if (!file_exists(modelpath))
  420. {
  421. glb_use_new_models = false
  422. }
  423. else
  424. {
  425. precache_model(modelpath)
  426. }
  427.  
  428. formatex(modelpath, charsmax(modelpath), "models/player/%s/%s.mdl", model_nanosuit_ct, model_nanosuit_ctt)
  429.  
  430. if (!file_exists(modelpath) || !glb_use_new_models)
  431. {
  432. glb_use_new_models = false
  433. }
  434. else
  435. {
  436. precache_model(modelpath)
  437. }
  438.  
  439. formatex(modelpath, charsmax(modelpath), "models/player/%s/%s.mdl", model_nanosuit_t, model_nanosuit_t)
  440.  
  441. if (!file_exists(modelpath) || !glb_use_new_models)
  442. {
  443. glb_use_new_models = false
  444. }
  445. else
  446. {
  447. precache_model(modelpath)
  448. }
  449.  
  450.  
  451. formatex(modelpath, charsmax(modelpath), "models/player/%s/%s.mdl", model_nanosuit_t, model_nanosuit_tt)
  452.  
  453. if (!file_exists(modelpath) || !glb_use_new_models)
  454. {
  455. glb_use_new_models = false
  456. }
  457. else
  458. {
  459. precache_model(modelpath)
  460. }
  461. }
  462.  
  463. public plugin_init()
  464. {
  465. // Register the plugin
  466. register_plugin(PLUGIN, VERSION, AUTHOR)
  467. register_cvar("nanosuit_version", VERSION, FCVAR_SERVER)
  468.  
  469. register_clcmd("say /nanosuit", "nanosuit_menu_show")
  470. register_clcmd("say_team /nanosuit", "nanosuit_menu_show")
  471. register_clcmd("nanosuit", "nanosuit_menu_show")
  472. register_clcmd("say /nanolowres", "nanosuit_low_res_toggle")
  473. register_clcmd("say_team /nanolowres", "nanosuit_low_res_toggle")
  474. register_clcmd("nanolowres", "nanosuit_low_res_toggle")
  475. register_clcmd("nanobuy","nanosuit_buy")
  476. register_clcmd("say /nanobuy","nanosuit_buy")
  477. register_clcmd("say_team /nanobuy","nanosuit_buy")
  478. register_clcmd("nanohelp","nanosuit_help")
  479. register_clcmd("say /nanohelp","nanosuit_help")
  480. register_clcmd("say_team /nanohelp","nanosuit_help")
  481.  
  482. // The pcvars
  483. pcv_nn_price = register_cvar("nanosuit_price","0")
  484. pcv_nn_death = register_cvar("nanosuit_death_remove","1")
  485. pcv_nn_buyzone = register_cvar("nanosuit_buyzone","1")
  486. pcv_nn_ff = get_cvar_pointer("mp_friendlyfire")
  487. pcv_nn_bot = register_cvar("nanosuit_bot_allow","0")
  488. pcv_nn_bot_buy = register_cvar("nanosuit_bot_buy_mode","0") // 0 on round start 1 on spawn
  489. pcv_nn_night = register_cvar("nanosuit_nightvision","1")
  490. pcv_nn_team = register_cvar("nanosuit_team_allow","2") // 1 T 2 CT 3 both
  491. pcv_zm_regive = register_cvar("nanosuit_disinfect_regive", "1")
  492.  
  493. pcv_nn_energy = register_cvar("nanosuit_energy","100")
  494. pcv_nn_critical = register_cvar("nanosuit_critical","10")
  495.  
  496. pcv_nn_health = register_cvar("nanosuit_health","100")
  497. pcv_nn_armor = register_cvar("nanosuit_armor","200")
  498.  
  499. pcv_nn_regenerate = register_cvar("nanosuit_regenerate","0.75")
  500. pcv_nn_hp_charge = register_cvar("nanosuit_hpcharge","5")
  501. pcv_nn_ap_charge = register_cvar("nanosuit_apcharge","7")
  502.  
  503. pcv_nn_ar_speed = register_cvar("nanosuit_armor_speed","1.0")
  504. pcv_nn_ar_damage = register_cvar("nanosuit_armor_damage","0.85")
  505.  
  506. pcv_nn_st_impulse = register_cvar("nanosuit_strength_impulse","460")
  507. pcv_nn_st_stab = register_cvar("nanosuit_strength_stab","10")
  508. pcv_nn_st_jump = register_cvar("nanosuit_strength_jump","15")
  509. pcv_nn_st_throw = register_cvar("nanosuit_strength_throw","600")
  510. pcv_nn_st_rec_att = register_cvar("nanosuit_strength_recoil_attenuation","1.75")
  511. pcv_nn_st_rec_en = register_cvar("nanosuit_strength_recoil_energy","1.5")
  512. pcv_nn_st_g_throw = register_cvar("nanosuit_strength_grenade_throw","3.0")
  513. pcv_nn_st_can_th = register_cvar("nanosuit_strength_throw_override","1")
  514.  
  515. pcv_nn_sp_maxim = register_cvar("nanosuit_speed_maximum","2.4")
  516. pcv_nn_sp_critic = register_cvar("nanosuit_speed_critical","1.40")
  517. pcv_nn_sp_energy = register_cvar("nanosuit_speed_energy","3.6")
  518. pcv_nn_sp_fattack = register_cvar("nanosuit_speed_fast_attack", "2.0")
  519. pcv_nn_sp_fatshre = register_cvar("nanosuit_speed_fast_sh_reload", "2.5")
  520. pcv_nn_sp_reload = register_cvar("nanosuit_speed_fast_reload", "5.0")
  521. pcv_nn_sp_ground = register_cvar("nanosuit_ground_affect", "2") // 0 normal ground, 1 also crouch, 2 water, 3 water + crouch
  522.  
  523. pcv_nn_cl_energy = register_cvar("nanosuit_cloak_energy","0.65")
  524. pcv_nn_cl_fire = register_cvar("nanosuit_cloak_punish_weapon_fire","1")
  525. pcv_nn_cl_knife = register_cvar("nanosuit_cloak_punish_knife_usage","1")
  526. pcv_nn_cl_grenade = register_cvar("nanosuit_cloak_punish_grenade_throw","1")
  527. pcv_nn_cl_c4 = register_cvar("nanosuit_cloak_punish_c4","1")
  528.  
  529. // Fakemeta forwards
  530. register_forward(FM_PlayerPreThink, "fw_prethink")
  531. register_forward(FM_PlayerPostThink, "fw_postthink")
  532. register_forward(FM_SetModel, "fw_setmodel",1)
  533.  
  534. if (!glb_use_new_models)
  535. {
  536. server_print("[NANO] No models found, not registering the model block forwards!")
  537. }
  538. else
  539. {
  540. server_print("[NANO] Models found, activating model block forwards!")
  541. register_forward(FM_SetClientKeyValue, "fw_setclientkey")
  542. register_event("TeamInfo","event_teaminfo","a")
  543. register_forward(FM_ClientUserInfoChanged, "fw_clientuserinfochanged")
  544. }
  545.  
  546. // Ham forwards (yummy)
  547. RegisterHam(Ham_CS_RoundRespawn,"player","fw_spawn",1)
  548. RegisterHam(Ham_Spawn,"player","fw_spawn",1)
  549. RegisterHam(Ham_Killed,"player","fw_killed")
  550. RegisterHam(Ham_Player_ResetMaxSpeed,"player","fw_resetmaxspeed",1)
  551.  
  552. new weapon_name[24]
  553.  
  554. // Register all weapons for special functions
  555. for (new i=CSW_P228;i<=CSW_P90;i++)
  556. {
  557. if (!(UNREGISTERED_WEAPONS_BITSUM & 1<<i) && get_weaponname(i, weapon_name, charsmax(weapon_name)))
  558. {
  559. RegisterHam(Ham_Weapon_PrimaryAttack, weapon_name, "fw_primary_attack")
  560. RegisterHam(Ham_Weapon_PrimaryAttack, weapon_name, "fw_primary_attack_post",1)
  561. RegisterHam(Ham_Weapon_SecondaryAttack, weapon_name, "fw_secondary_attack")
  562. RegisterHam(Ham_Weapon_SecondaryAttack, weapon_name, "fw_secondary_attack_post",1)
  563.  
  564. if (!(NO_RELOAD_WEAPONS_BITSUM & (1<<i)))
  565. {
  566. RegisterHam(Ham_Weapon_Reload, weapon_name, "fw_reload_post", 1)
  567. }
  568. else
  569. {
  570. if (i != CSW_KNIFE)
  571. {
  572. RegisterHam(Ham_Item_Deploy, weapon_name, "fw_shotgun_deploy", 1)
  573. RegisterHam(Ham_Weapon_Reload, weapon_name, "fw_special_reload_post", 1)
  574. }
  575. }
  576.  
  577.  
  578. format(wpn_ms_icon[i],13,"d_%s",weapon_name[7])
  579. replace(weapon_name,charsmax(weapon_name),"navy","")
  580. format(wpn_v_model[i],29,"models/v_%s.mdl",weapon_name[7])
  581.  
  582. }
  583.  
  584. if (WEAPONS_WITH_SHIELD_BITSUM & 1<<i)
  585. {
  586. format(wpn_v_shield_model[i],49,"models/shield/v_shield_%s.mdl",weapon_name[7])
  587. }
  588. }
  589.  
  590. // Let's add the c4
  591. format(wpn_v_model[CSW_C4],29,"models/v_c4.mdl")
  592.  
  593. format(wpn_v_model[CSW_SMOKEGRENADE],29,"models/v_smokegrenade.mdl")
  594. format(wpn_v_model[CSW_FLASHBANG],29,"models/v_flashbang.mdl")
  595. format(wpn_v_model[CSW_HEGRENADE],29,"models/v_hegrenade.mdl")
  596.  
  597. format(wpn_v_shield_model[CSW_SMOKEGRENADE],49,"models/shield/v_shield_smokegrenade.mdl")
  598. format(wpn_v_shield_model[CSW_FLASHBANG],49,"models/shield/v_shield_flashbang.mdl")
  599. format(wpn_v_shield_model[CSW_HEGRENADE],49,"models/shield/v_shield_hegrenade.mdl")
  600.  
  601. get_weaponname(CSW_C4, weapon_name, charsmax(weapon_name))
  602.  
  603. RegisterHam(Ham_Weapon_PrimaryAttack, weapon_name, "fw_bomb_planting")
  604. RegisterHam(Ham_Use, "grenade", "fw_bomb_defusing")
  605.  
  606.  
  607. // In the previous function we didn't register the grenades
  608. wpn_ms_icon[CSW_HEGRENADE] = "d_grenade"
  609. wpn_ms_icon[CSW_FLASHBANG] = "d_grenade"
  610. wpn_ms_icon[CSW_SMOKEGRENADE] = "d_grenade"
  611.  
  612. // Global Stuff
  613. glb_maxplayers = global_get(glb_maxClients)
  614.  
  615. // Events
  616. register_event("CurWeapon", "event_active_weapon", "be","1=1")
  617. register_event("DeathMsg", "event_death", "ae")
  618. //register_event("HLTV", "event_new", "a")
  619.  
  620. register_logevent("event_startround", 2, "1=Round_Start")
  621.  
  622.  
  623. // Register dictionary (for multilanguage)
  624. register_dictionary("nanosuit.txt")
  625.  
  626. // Tolls
  627. nd_hud_sync = CreateHudSyncObj()
  628.  
  629. // Message variables
  630. nd_msg_saytext = get_user_msgid("SayText")
  631. nd_msg_damage = get_user_msgid("Damage")
  632. nd_msg_iconstatus = get_user_msgid("StatusIcon")
  633. nd_msg_shadowidx = get_user_msgid("ShadowIdx")
  634. nd_msg_ammox = get_user_msgid("AmmoX")
  635.  
  636. // Hud status display
  637. nd_ent_monitor = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
  638.  
  639. if (nd_ent_monitor)
  640. {
  641. set_pev(nd_ent_monitor, pev_classname, "screen_status")
  642. set_pev(nd_ent_monitor, pev_nextthink, get_gametime() + 0.1)
  643.  
  644. register_forward(FM_Think, "fw_screenthink")
  645. }
  646.  
  647. set_task(1.0,"plugin_init_delay",674832)
  648. set_task(60.0,"nanosuit_msg", 674837, _, _, "b", 0)
  649. }
  650.  
  651. public plugin_init_delay(nr)
  652. {
  653. // Register the takedamage after 1 second to let the other plugins mess with the variables
  654. RegisterHam(Ham_TakeDamage, "player", "fw_takedamage")
  655. RegisterHam(Ham_TakeDamage, "player", "fw_takedamage_post", 1)
  656. RegisterHam(Ham_TraceAttack, "player", "fw_traceattack")
  657.  
  658. // Speed fix
  659. server_cmd("sv_maxspeed 99999.0")
  660. }
  661.  
  662. public client_putinserver(id)
  663. {
  664. if (is_user_bot(id))
  665. cl_is_bot[id] = true
  666.  
  667. if (get_pcvar_num(pcv_nn_price) <= 0)
  668. {
  669. if (cl_is_bot[id] && get_pcvar_num(pcv_nn_bot))
  670. cl_nn_has[id] = NANO_YES
  671. if (!cl_is_bot[id])
  672. cl_nn_has[id] = NANO_YES
  673. }
  674. else
  675. cl_nn_has[id] = NANO_NO
  676. }
  677.  
  678. public client_connect(id)
  679. {
  680. client_cmd(id,"cl_sidespeed 99999")
  681. client_cmd(id,"cl_forwardspeed 99999")
  682. client_cmd(id,"cl_backspeed 99999")
  683. cl_nn_actual_shot[id] = false
  684. cl_removed_shadow[id] = false
  685. }
  686.  
  687. public fw_resetmaxspeed(id)
  688. {
  689. if (cl_is_thrown[id] != 0)
  690. set_user_maxspeed(id, 1.0)
  691.  
  692. if (cl_nn_has[id] == NANO_YES)
  693. {
  694. switch (cl_nn_mode[id])
  695. {
  696. case NANO_ARMOR:
  697. {
  698. set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_ar_speed))
  699. }
  700. case NANO_SPEED:
  701. {
  702. if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical))
  703. cl_nn_sp_status[id] = SPEED_MAXIMUM
  704. if (get_pcvar_float(pcv_nn_critical) >= cl_nn_energy[id] > 0)
  705. cl_nn_sp_status[id] = SPEED_CRITICAL
  706. if (0 >= cl_nn_energy[id])
  707. cl_nn_sp_status[id] = SPEED_NORMAL
  708.  
  709. switch (cl_nn_sp_status[id])
  710. {
  711. case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim))
  712. case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic))
  713. }
  714. }
  715. }
  716. }
  717.  
  718. return PLUGIN_CONTINUE
  719. }
  720.  
  721. public nanosuit_msg(nr)
  722. {
  723. static players[32],count,id
  724. get_players(players,count)
  725.  
  726. for (new i=0;i<count;i++)
  727. {
  728. id = players[i]
  729. static msg[300]
  730. format(msg,299,"^x04[NANO]^x03 %L",id,"NANO_HELP")
  731. colored_msg(id,msg)
  732. }
  733.  
  734. return PLUGIN_CONTINUE
  735. }
  736.  
  737. public client_disconnect(id)
  738. {
  739. cl_nn_has[id] = NANO_NO
  740. cl_nn_mode[id] = NANO_ARMOR
  741. cl_is_bot[id] = false
  742. cl_added_velocity[id] = false
  743. nanosuit_reset(id)
  744. }
  745.  
  746. public nanosuit_low_res_toggle(id)
  747. {
  748. cl_nn_lowres[id] = !cl_nn_lowres[id]
  749.  
  750. if (cl_nn_lowres[id])
  751. {
  752. msg_statusicon(id,ICON_REMOVE,NanoStatusIcon[cl_nn_mode[id]],NanoScreenColor[cl_nn_mode[id]])
  753. #if defined USE_WEAPON_STATUSICONS
  754. msg_statusicon(id,ICON_REMOVE,wpn_ms_icon[cl_nn_weapon[id]],{0,255,0})
  755. #endif
  756. client_print(id, print_chat, "%L", id, "NANO_LOWRES_ON")
  757. }
  758. else
  759. {
  760. if (cl_nn_has[id] == NANO_YES)
  761. {
  762. msg_statusicon(id,ICON_SHOW,NanoStatusIcon[cl_nn_mode[id]],NanoScreenColor[cl_nn_mode[id]])
  763. #if defined USE_WEAPON_STATUSICONS
  764. if (cl_nn_mode[id] == NANO_CLOAK)
  765. msg_statusicon(id,ICON_SHOW,wpn_ms_icon[cl_nn_weapon[id]],{0,255,0})
  766. #endif
  767. }
  768. client_print(id, print_chat, "%L", id, "NANO_LOWRES_OFF")
  769. }
  770.  
  771. return
  772. }
  773.  
  774. // Menu System
  775. public nanosuit_menu_create(id)
  776. {
  777. static text[200]
  778.  
  779. format(text,199,"%L",id,"NANO_MENU")
  780. nd_menu[id] = menu_create(text, "nanosuit_menu_choose")
  781.  
  782. format(text,199,"%L",id,"NANO_ST_MODE")
  783. menu_additem(nd_menu[id], text)
  784. format(text,199,"%L",id,"NANO_A_MODE")
  785. menu_additem(nd_menu[id], text)
  786. format(text,199,"%L",id,"NANO_S_MODE")
  787. menu_additem(nd_menu[id], text)
  788. format(text,199,"%L",id,"NANO_C_MODE")
  789. menu_additem(nd_menu[id], text)
  790.  
  791. menu_setprop(nd_menu[id], MPROP_EXIT, MEXIT_NEVER)
  792. }
  793.  
  794. public nanosuit_menu_show(id)
  795. {
  796. if (!is_user_alive(id))
  797. return
  798. if(cs_get_user_team(id) == CS_TEAM_T)
  799. return
  800.  
  801. if (cl_nn_has[id] == NANO_YES)
  802. {
  803. client_cmd(id,"spk %s",sound_menu)
  804. nanosuit_menu_create(id)
  805. menu_display(id, nd_menu[id])
  806. nanosuit_reset(id,false)
  807. return
  808. }
  809. else
  810. client_print(id, print_center,"%L",id,"NANO_NO")
  811.  
  812. return
  813. }
  814.  
  815. public nanosuit_menu_choose(id, menu, item)
  816. {
  817.  
  818. if (item != -3 && cl_nn_mode[id] != NanoModes:item)
  819. {
  820. if (cl_nn_mode[id] == NANO_SPEED)
  821. {
  822. if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical))
  823. cl_nn_sp_status[id] = SPEED_MAXIMUM
  824. if (get_pcvar_float(pcv_nn_critical) >= cl_nn_energy[id] > 0)
  825. cl_nn_sp_status[id] = SPEED_CRITICAL
  826. if (0 >= cl_nn_energy[id])
  827. cl_nn_sp_status[id] = SPEED_NORMAL
  828.  
  829. switch (cl_nn_sp_status[id])
  830. {
  831. case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_maxim))
  832. case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_critic))
  833. }
  834. }
  835.  
  836. if (NanoModes:item == NANO_SPEED)
  837. {
  838. if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical))
  839. cl_nn_sp_status[id] = SPEED_MAXIMUM
  840. if (get_pcvar_float(pcv_nn_critical) >= cl_nn_energy[id] > 0)
  841. cl_nn_sp_status[id] = SPEED_CRITICAL
  842. if (0 >= cl_nn_energy[id])
  843. cl_nn_sp_status[id] = SPEED_NORMAL
  844.  
  845. switch (cl_nn_sp_status[id])
  846. {
  847. case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim))
  848. case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic))
  849. }
  850. }
  851.  
  852. set_nano_mode(id,NanoModes:item)
  853. }
  854.  
  855. if (menu != 0)
  856. menu_destroy(nd_menu[id])
  857. return PLUGIN_HANDLED
  858. }
  859.  
  860.  
  861. // Buy command
  862. public nanosuit_buy(id)
  863. {
  864. if(cs_get_user_team(id) == CS_TEAM_T)
  865. {
  866. client_print(id, print_center, "Only for CT")
  867. return
  868. }
  869.  
  870. if(Cumparat[id])
  871. {
  872. client_print(id, print_center, "Ai cumparat deja odata!");
  873. return;
  874. }
  875.  
  876. if (cl_nn_has[id] == NANO_YES)
  877. {
  878. nanosuit_reset(id)
  879. cl_nn_has[id] = NANO_NO
  880. }
  881.  
  882. if (get_pcvar_num(pcv_nn_price) <= 0)
  883. {
  884. cl_nn_has[id] = NANO_YES
  885. nanosuit_reset(id, true)
  886.  
  887. return
  888. }
  889. else
  890. {
  891. if (get_pcvar_num(pcv_nn_team) != _:cs_get_user_team(id) && get_pcvar_num(pcv_nn_team) != 3)
  892. {
  893. client_print(id,print_center,"You team is not allowed to buy!")
  894. return
  895. }
  896.  
  897. if (get_pcvar_num(pcv_nn_buyzone) && !cs_get_user_buyzone(id))
  898. {
  899. client_print(id,print_center,"%L",id,"NANO_BUYZONE")
  900. return
  901. }
  902.  
  903. static money
  904. money = cs_get_user_money(id)
  905. static price
  906. price = get_pcvar_num(pcv_nn_price)
  907.  
  908. if(once[id])
  909. {
  910. cl_nn_has[id] = NANO_YES
  911. nanosuit_menu_show(id)
  912. nanosuit_reset(id, true)
  913.  
  914. client_print(id,print_center,"%L",id,"NANO_BUY")
  915.  
  916. Cumparat[id] = true;
  917. return
  918. }
  919.  
  920. else if (!once[id] && money >= price)
  921. {
  922. cs_set_user_money(id, money - price)
  923.  
  924. cl_nn_has[id] = NANO_YES
  925. nanosuit_menu_show(id)
  926. nanosuit_reset(id, true)
  927.  
  928. once[id] = true;
  929. Cumparat[id] = true;
  930.  
  931. client_print(id,print_center,"%L",id,"NANO_BUY")
  932. return
  933. }
  934. else
  935. {
  936. client_print(id,print_center,"#Cstrike_TitlesTXT_Not_Enough_Money")
  937. return
  938. }
  939. }
  940.  
  941. return
  942. }
  943.  
  944. // Help command
  945. public nanosuit_help(id)
  946. {
  947. static help[3000]
  948.  
  949. format(help,2999,"%s%s^n",help,html_header)
  950.  
  951. format(help,2999,"%s%L^n",help,id,"NANO_HTML_BASIC")
  952. format(help,2999,"%s%L^n",help,id,"NANO_HTML_MODES")
  953.  
  954. if (get_pcvar_num(pcv_nn_cl_fire))
  955. format(help,2999,"%s%L^n",help,id,"NANO_HTML_CL_FIRE")
  956.  
  957. if (get_pcvar_num(pcv_nn_cl_knife))
  958. format(help,2999,"%s%L^n",help,id,"NANO_HTML_CL_KNIFE")
  959.  
  960. if (get_pcvar_num(pcv_nn_cl_grenade))
  961. format(help,2999,"%s%L^n",help,id,"NANO_HTML_CL_NADE")
  962.  
  963. format(help,2999,"%s%L^n",help,id,"NANO_HTML_ADVICE")
  964.  
  965. delete_file("nanosuit.htm")
  966. write_file("nanosuit.htm",help)
  967. show_motd(id, "nanosuit.htm", "-= Crysis Nanosuit =-")
  968. return
  969. }
  970.  
  971. /* ===================================================
  972. [Events]
  973. ==================================================== */
  974.  
  975. public event_teaminfo()
  976. {
  977. new id
  978. id = read_data(1)
  979.  
  980. if (!is_user_connected(id))
  981. return
  982.  
  983. if (glb_use_new_models)
  984. {
  985. switch (cs_get_user_team(id))
  986. {
  987. case CS_TEAM_CT: fm_set_user_model(id,model_nanosuit_ct)
  988. case CS_TEAM_T: fm_set_user_model(id,model_nanosuit_t)
  989. }
  990. }
  991. else
  992. fm_reset_user_model(id)
  993.  
  994. cl_update_model[id] = false
  995.  
  996. return
  997. }
  998.  
  999. public event_startround()
  1000. {
  1001. if (get_pcvar_num(pcv_nn_bot_buy) || !get_pcvar_num(pcv_nn_bot))
  1002. return PLUGIN_CONTINUE
  1003.  
  1004. new players[32], count, id
  1005. get_players(players,count,"ad")
  1006.  
  1007. for (new i=0;i<count;i++)
  1008. {
  1009. id = players[i]
  1010. nanosuit_buy(id)
  1011. }
  1012.  
  1013. return PLUGIN_CONTINUE
  1014. }
  1015.  
  1016. public event_active_weapon(id)
  1017. {
  1018. new weapon
  1019. weapon = read_data(2)
  1020.  
  1021. if (weapon != CSW_KNIFE)
  1022. cl_nn_st_knife[id] = KNIFE_NOT
  1023.  
  1024.  
  1025. if (weapon != CSW_KNIFE && weapon != CSW_HEGRENADE && weapon != CSW_FLASHBANG && weapon != CSW_SMOKEGRENADE && cl_nn_zombie[id])
  1026. {
  1027. cl_nn_zombie[id] = false
  1028.  
  1029. if (cl_nn_had[id] == NANO_YES && get_pcvar_num(pcv_zm_regive))
  1030. {
  1031. cl_nn_has[id] = NANO_YES
  1032. nanosuit_reset(id)
  1033. }
  1034. }
  1035.  
  1036.  
  1037. if (cl_nn_has[id] == NANO_YES && cl_nn_weapon[id] != weapon)
  1038. {
  1039. #if defined REMOVE_VIEWMODEL_ON_CLOAK
  1040. if (!cl_is_bot[id] && cl_nn_mode[id] == NANO_CLOAK)
  1041. set_pev(id,pev_viewmodel2,"")
  1042. #endif
  1043. #if defined USE_WEAPON_STATUSICONS
  1044. if (cl_nn_mode[id] == NANO_CLOAK && !cl_is_bot[id] && !equal(wpn_ms_icon[cl_nn_weapon[id]],wpn_ms_icon[weapon]))
  1045. {
  1046. msg_statusicon(id,ICON_REMOVE,wpn_ms_icon[cl_nn_weapon[id]],{0,0,0})
  1047. msg_statusicon(id,ICON_SHOW,wpn_ms_icon[weapon],{0,255,0})
  1048. }
  1049. #endif
  1050.  
  1051. if (cl_is_bot[id])
  1052. {
  1053. if (weapon == CSW_KNIFE)
  1054. {
  1055. new hit = -1
  1056. new Float:origin[3]
  1057. pev(id,pev_origin,origin)
  1058.  
  1059. while ((hit = engfunc(EngFunc_FindEntityInSphere, hit, origin, 350.0)))
  1060. {
  1061. if (!is_user_alive(hit))
  1062. continue
  1063.  
  1064. if ((get_pcvar_num(pcv_nn_ff)) || (!get_pcvar_num(pcv_nn_ff) && cs_get_user_team(id) != cs_get_user_team(hit)))
  1065. {
  1066. nanosuit_menu_choose(id,0,_:NANO_STREN)
  1067. break
  1068. }
  1069. }
  1070. }
  1071. }
  1072. }
  1073.  
  1074. cl_nn_weapon[id] = weapon
  1075. }
  1076.  
  1077. public event_death()
  1078. {
  1079. static victim
  1080. victim = read_data(2)
  1081.  
  1082. if (victim == 0)
  1083. return
  1084.  
  1085. once[victim] = false;
  1086.  
  1087. reset_rendering(victim)
  1088.  
  1089. if (get_pcvar_num(pcv_nn_price) > 0 && get_pcvar_num(pcv_nn_death))
  1090. {
  1091. cl_nn_has[victim] = NANO_NO
  1092. nanosuit_reset(victim)
  1093. }
  1094.  
  1095. return
  1096. }
  1097.  
  1098. /* ===================================================
  1099. [Fakemeta forwards (fake!)]
  1100. ==================================================== */
  1101. public fw_prethink(id)
  1102. {
  1103. if (!is_user_alive(id))
  1104. return FMRES_IGNORED
  1105.  
  1106. new Float:origin[3], Float:through[3], Float:vel[3], Float:endpos[3], bool:onground, flags
  1107.  
  1108. flags = pev(id, pev_flags)
  1109.  
  1110. onground = (flags & ON_LAND_CONST) ? true : false
  1111.  
  1112. pev(id,pev_origin,origin)
  1113. pev(id,pev_velocity,vel)
  1114.  
  1115. if (cl_is_thrown[id] && !onground && vel[2] <= -FALL_FALSE_VELOCITY && !cl_added_velocity[id])
  1116. {
  1117. static trace
  1118. trace = create_tr2()
  1119.  
  1120. xs_vec_add(origin,Float:{0.0,0.0,-50.0},through)
  1121.  
  1122. engfunc(EngFunc_TraceLine,origin,through,IGNORE_MONSTERS, id, trace)
  1123. get_tr2(trace,TR_vecEndPos,endpos)
  1124. xs_vec_sub(endpos,origin,endpos)
  1125. xs_vec_sub(through,origin,through)
  1126.  
  1127. if (vector_length(through) != vector_length(endpos))
  1128. {
  1129. vel[2] += FALL_FALSE_VELOCITY - FALL_TRUE_VELOCITY
  1130. cl_added_velocity[id] = true
  1131. set_pev(id,pev_velocity,vel)
  1132. }
  1133.  
  1134. free_tr2(trace)
  1135. }
  1136.  
  1137. if (cl_is_thrown[id] && onground)
  1138. {
  1139. cl_added_velocity[id] = false
  1140. cl_is_thrown[id] = 0
  1141.  
  1142. ExecuteHamB(Ham_Player_ResetMaxSpeed, id)
  1143. }
  1144.  
  1145. if (cl_is_bot[id] && cl_nn_has[id] == NANO_YES && !get_pcvar_num(pcv_nn_bot))
  1146. {
  1147. cl_nn_has[id] = NANO_NO
  1148. nanosuit_reset(id)
  1149. }
  1150.  
  1151. static Float:health
  1152. pev(id,pev_health,health)
  1153.  
  1154. if (cl_is_bot[id] && cl_nn_has[id] == NANO_YES && health < 60.0)
  1155. nanosuit_menu_choose(id,0,_:NANO_ARMOR)
  1156.  
  1157. if (cl_nn_has[id] == NANO_YES)
  1158. nanosuit_functions(id)
  1159.  
  1160. // Run
  1161. new Float:speed
  1162. speed = vector_length(vel)
  1163. new Float:mspeed
  1164. mspeed = get_user_maxspeed(id)
  1165.  
  1166. if (get_pcvar_num(pcv_nn_sp_ground) & NANO_FLAG_INWATER && flags & ON_WATER_CONST)
  1167. mspeed *= SPEED_WATER_MUL_CONSTANT
  1168.  
  1169. if (get_pcvar_num(pcv_nn_sp_ground) & NANO_FLAG_CROUCHED && flags & FL_DUCKING)
  1170. mspeed *= SPEED_CROUCH_MUL_CONSTANT
  1171.  
  1172. // Remember the speed
  1173. if (speed == 0.0) cl_nn_speed[id] = SPD_STILL
  1174. if (speed > 0.0) cl_nn_speed[id] = SPD_VSLOW
  1175. if (speed > 0.4 * mspeed) cl_nn_speed[id] = SPD_SLOW
  1176. if (speed > 0.6 * mspeed) cl_nn_speed[id] = SPD_NORMAL
  1177. if (speed > 0.9 * mspeed) cl_nn_speed[id] = SPD_FAST
  1178.  
  1179. if (speed < 0.6 * mspeed && cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED)
  1180. set_pev(id,pev_flTimeStepSound,100)
  1181.  
  1182. // Screen display
  1183. if (speed == 0.0) cl_nn_scr_speed[id] = SPD_SCR_STILL
  1184. if (speed > 0.0) cl_nn_scr_speed[id] = SPD_SCR_VSLOW
  1185. if (speed > 100.0) cl_nn_scr_speed[id] = SPD_SCR_SLOW
  1186. if (speed > 200.0) cl_nn_scr_speed[id] = SPD_SCR_NORMAL
  1187. if (speed > 265.0) cl_nn_scr_speed[id] = SPD_SCR_FAST
  1188.  
  1189. return FMRES_IGNORED
  1190. }
  1191.  
  1192. public fw_postthink(id)
  1193. {
  1194. if (is_user_alive(id) && cl_nn_st_jump[id])
  1195. {
  1196. client_cmd(id,"spk %s",sound_strength_jump)
  1197. static Float:vecforce[3]
  1198. pev(id,pev_velocity,vecforce)
  1199. vecforce[2] = get_pcvar_float(pcv_nn_st_impulse)
  1200. set_pev(id,pev_velocity,vecforce)
  1201. set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_st_jump), DELAY_STR_JUMP)
  1202. cl_nn_st_jump[id] = false
  1203. }
  1204.  
  1205. return FMRES_IGNORED
  1206. }
  1207.  
  1208. public fw_setmodel(ent, const model[])
  1209. {
  1210. if (!pev_valid(ent))
  1211. return FMRES_IGNORED
  1212.  
  1213. new Float:gravity
  1214. pev(ent,pev_gravity,gravity)
  1215.  
  1216. if (gravity == 0.0)
  1217. return FMRES_IGNORED
  1218.  
  1219. new owner
  1220. owner = pev(ent,pev_owner)
  1221.  
  1222. if (!(cl_nn_has[owner] == NANO_YES))
  1223. return FMRES_IGNORED
  1224.  
  1225. new classname[8]
  1226.  
  1227. pev(ent,pev_classname,classname,7)
  1228.  
  1229. if (equal("grenade",classname,7) && cl_nn_mode[owner] == NANO_CLOAK && get_pcvar_num(pcv_nn_cl_grenade))
  1230. {
  1231. set_nano_energy(owner,0.0,DELAY_CLK_FORCED)
  1232. return FMRES_IGNORED
  1233. }
  1234. if (equal("grenade",classname,7) && cl_nn_mode[owner] == NANO_STREN && containi(model,"c4") == -1 && cl_nn_energy[owner] >= get_pcvar_float(pcv_nn_st_g_throw))
  1235. {
  1236. new Float:v[3], Float:v2[3]
  1237. pev(ent,pev_velocity,v)
  1238. velocity_by_aim(owner, GRENADE_STR_THROW_ADD, v2)
  1239. xs_vec_add(v, v2, v)
  1240. set_pev(ent,pev_velocity,v)
  1241. set_nano_energy(owner,cl_nn_energy[owner] - get_pcvar_float(pcv_nn_st_g_throw),DELAY_STR_G_THROW)
  1242. return FMRES_IGNORED
  1243. }
  1244.  
  1245. return FMRES_IGNORED
  1246. }
  1247.  
  1248. public fw_setclientkey(id,const infobuffer[],const key[])
  1249. {
  1250. // Block CS model changes
  1251. if (cl_nn_has[id] == NANO_YES && equal(key, "model"))
  1252. return FMRES_SUPERCEDE
  1253.  
  1254. return FMRES_IGNORED
  1255. }
  1256.  
  1257. public fw_clientuserinfochanged(id)
  1258. {
  1259. if (!is_user_connected(id))
  1260. return FMRES_IGNORED
  1261.  
  1262. // Get current model
  1263. new currentmodel[32]
  1264. fm_get_user_model(id, currentmodel, charsmax(currentmodel))
  1265.  
  1266. // Check whether it matches the custom model - if not, set it again
  1267. if (!equal(currentmodel, cl_player_model[id]))
  1268. {
  1269. if (cl_nn_has[id] == NANO_YES)
  1270. {
  1271. switch (cs_get_user_team(id))
  1272. {
  1273. case CS_TEAM_CT:
  1274. {
  1275. for (new i=0;i<5;i++)
  1276. {
  1277. if (equali(currentmodel,vec_model_ct[i]))
  1278. {
  1279. cl_update_model[id] = true
  1280. copy(cl_player_model[id], 31, currentmodel)
  1281. return FMRES_SUPERCEDE
  1282. }
  1283. }
  1284. }
  1285. case CS_TEAM_T:
  1286. {
  1287. for (new i=0;i<4;i++)
  1288. {
  1289. if (equali(currentmodel,vec_model_t[i]))
  1290. {
  1291. cl_update_model[id] = true
  1292. copy(cl_player_model[id], 31, currentmodel)
  1293. return FMRES_SUPERCEDE
  1294. }
  1295. }
  1296. }
  1297. }
  1298. }
  1299. else
  1300. {
  1301. switch (cs_get_user_team(id))
  1302. {
  1303. case CS_TEAM_CT:
  1304. {
  1305. for (new i=0;i<5;i++)
  1306. {
  1307. if (equali(currentmodel,vec_model_ct[i]))
  1308. {
  1309. fm_set_user_model(id,currentmodel)
  1310. return FMRES_SUPERCEDE
  1311. }
  1312. }
  1313.  
  1314. fm_reset_user_model(id)
  1315. }
  1316. case CS_TEAM_T:
  1317. {
  1318. for (new i=0;i<4;i++)
  1319. {
  1320. if (equali(currentmodel,vec_model_t[i]))
  1321. {
  1322. fm_set_user_model(id,currentmodel)
  1323. return FMRES_SUPERCEDE
  1324. }
  1325. }
  1326.  
  1327. fm_reset_user_model(id)
  1328. }
  1329. default: fm_reset_user_model(id)
  1330. }
  1331. }
  1332. }
  1333.  
  1334. return FMRES_SUPERCEDE
  1335. }
  1336.  
  1337. /* ===================================================
  1338. [Ham forwards chapter (yummy)]
  1339. ==================================================== */
  1340. public fw_primary_attack(ent)
  1341. {
  1342. new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
  1343.  
  1344. if (cl_nn_weapon[id] == CSW_KNIFE && cl_nn_mode[id] == NANO_STREN && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_st_stab) && cl_nn_has[id] == NANO_YES)
  1345. {
  1346. set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_st_stab), DELAY_STR_STAB)
  1347. cl_nn_st_knife[id] = KNIFE_FIRST_ATTACK
  1348. client_cmd(id,"spk %s",sound_strength_throw)
  1349. }
  1350.  
  1351. pev(id,pev_punchangle,cl_nn_punch[id])
  1352.  
  1353. if (cl_nn_mode[id] == NANO_CLOAK)
  1354. {
  1355. if (cl_nn_weapon[id] == CSW_KNIFE && get_pcvar_num(pcv_nn_cl_knife))
  1356. {
  1357. set_nano_energy(id, 0.0, DELAY_CLK_FORCED)
  1358. }
  1359.  
  1360. if (cl_nn_weapon[id] != CSW_KNIFE && get_pcvar_num(pcv_nn_cl_fire))
  1361. {
  1362. set_nano_energy(id, 0.0, DELAY_CLK_FORCED)
  1363. }
  1364. }
  1365.  
  1366. new ammo,clip
  1367. get_user_ammo(id, cl_nn_weapon[id], ammo, clip)
  1368.  
  1369. if (cs_get_weapon_id(ent) == CSW_M3 || cs_get_weapon_id(ent) == CSW_XM1014)
  1370. cl_nn_shotgun_ammo[id] = ammo
  1371. else
  1372. cl_nn_shotgun_ammo[id] = -1
  1373.  
  1374. if (ammo != 0)
  1375. cl_nn_actual_shot[id] = true
  1376.  
  1377. return HAM_IGNORED
  1378. }
  1379.  
  1380. public fw_primary_attack_post(ent)
  1381. {
  1382. new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
  1383.  
  1384. if (cl_nn_actual_shot[id] && cl_nn_has[id] == NANO_YES && cl_nn_weapon[id] != CSW_KNIFE && cl_nn_mode[id] == NANO_STREN && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_critical))
  1385. {
  1386. new Float:push[3]
  1387. pev(id,pev_punchangle,push)
  1388. xs_vec_sub(push,cl_nn_punch[id],push)
  1389. xs_vec_div_scalar(push,get_pcvar_float(pcv_nn_st_rec_att),push)
  1390. xs_vec_add(push,cl_nn_punch[id],push)
  1391. set_pev(id,pev_punchangle,push)
  1392. set_nano_energy(id,cl_nn_energy[id] - get_pcvar_float(pcv_nn_st_rec_en), DELAY_STR_SHOT)
  1393. }
  1394.  
  1395. if (cl_nn_actual_shot[id] && cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_critical))
  1396. {
  1397. new Float:multi
  1398. multi = 1.0
  1399. switch (cl_nn_weapon[id])
  1400. {
  1401. case CSW_DEAGLE,CSW_ELITE,CSW_FIVESEVEN,CSW_P228,CSW_USP,CSW_GLOCK18:
  1402. {
  1403. multi = REFIRE_PISTOLS
  1404. }
  1405. case CSW_M3:
  1406. {
  1407. multi = REFIRE_M3
  1408. }
  1409. case CSW_KNIFE:
  1410. {
  1411. multi = REFIRE_KNIFE
  1412. static Float:M_Delay
  1413. M_Delay = get_pdata_float(ent, OFFSET_WEAPON_NEXT_SEC_ATTACK, EXTRA_OFFSET_WEAPON_LINUX) * multi
  1414. set_pdata_float(ent, OFFSET_WEAPON_NEXT_SEC_ATTACK, M_Delay, EXTRA_OFFSET_WEAPON_LINUX)
  1415. }
  1416. case CSW_SCOUT,CSW_AWP:
  1417. {
  1418. multi = REFIRE_SNIPERS
  1419. }
  1420. }
  1421.  
  1422. if (multi != 1.0)
  1423. set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_sp_fattack),DELAY_SPD_FAST_ATTACK)
  1424.  
  1425. new Float:Delay
  1426.  
  1427. Delay = get_pdata_float( ent, OFFSET_WEAPON_NEXT_PRIMARY_ATTACK, EXTRA_OFFSET_WEAPON_LINUX) * multi
  1428. set_pdata_float( ent, OFFSET_WEAPON_NEXT_PRIMARY_ATTACK, Delay, EXTRA_OFFSET_WEAPON_LINUX)
  1429. }
  1430.  
  1431. cl_nn_actual_shot[id] = false
  1432. return HAM_IGNORED
  1433. }
  1434.  
  1435. public fw_secondary_attack(ent)
  1436. {
  1437. new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
  1438.  
  1439. if (cl_nn_weapon[id] == CSW_KNIFE && cl_nn_mode[id] == NANO_STREN && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_st_stab) && cl_nn_has[id] == NANO_YES)
  1440. {
  1441. set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_st_stab), DELAY_STR_STAB)
  1442. cl_nn_st_knife[id] = KNIFE_SECOND_ATTACK
  1443. client_cmd(id,"spk %s",sound_strength_throw)
  1444. }
  1445.  
  1446. if (cl_nn_mode[id] == NANO_CLOAK)
  1447. {
  1448. if (cl_nn_weapon[id] == CSW_KNIFE && get_pcvar_num(pcv_nn_cl_knife))
  1449. {
  1450. set_nano_energy(id,0.0,DELAY_CLK_FORCED)
  1451. return HAM_IGNORED
  1452. }
  1453. }
  1454.  
  1455. return HAM_IGNORED
  1456. }
  1457.  
  1458. public fw_secondary_attack_post(ent)
  1459. {
  1460. new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
  1461.  
  1462. if (cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_critical))
  1463. {
  1464. new Float:multi = 1.0
  1465. switch (cl_nn_weapon[id])
  1466. {
  1467. case CSW_KNIFE:
  1468. {
  1469. multi = REFIRE_KNIFE
  1470. new Float:mdelay
  1471. mdelay = get_pdata_float( ent, OFFSET_WEAPON_NEXT_SEC_ATTACK, EXTRA_OFFSET_WEAPON_LINUX) * multi
  1472. set_pdata_float( ent, OFFSET_WEAPON_NEXT_SEC_ATTACK, mdelay, EXTRA_OFFSET_WEAPON_LINUX)
  1473. }
  1474. }
  1475. if (multi != 1.0)
  1476. set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_sp_fattack),DELAY_SPD_FAST_ATTACK)
  1477.  
  1478. new Float:delay
  1479. delay = get_pdata_float( ent, OFFSET_WEAPON_NEXT_PRIMARY_ATTACK, EXTRA_OFFSET_WEAPON_LINUX) * multi
  1480. set_pdata_float( ent, OFFSET_WEAPON_NEXT_PRIMARY_ATTACK, delay, EXTRA_OFFSET_WEAPON_LINUX)
  1481. }
  1482. return HAM_IGNORED
  1483. }
  1484.  
  1485. public fw_shotgun_deploy(ent)
  1486. {
  1487. new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
  1488. cl_nn_shotgun_ammo[id] = cs_get_weapon_ammo(ent)
  1489. }
  1490.  
  1491. public fw_special_reload_post(ent)
  1492. {
  1493. new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
  1494.  
  1495. new wpn_id = cs_get_weapon_id(ent)
  1496. new maxammo = wpn_max_clip[wpn_id]
  1497. new curammo = cs_get_weapon_ammo(ent)
  1498.  
  1499. if (cl_nn_shotgun_ammo[id] == -1)
  1500. {
  1501. cl_nn_shotgun_ammo[id] = curammo
  1502. return HAM_IGNORED
  1503. }
  1504. else
  1505. {
  1506. if (!(cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_critical)))
  1507. {
  1508. cl_nn_shotgun_ammo[id] = curammo
  1509. return HAM_IGNORED
  1510. }
  1511.  
  1512. if (curammo < cl_nn_shotgun_ammo[id])
  1513. cl_nn_shotgun_ammo[id] = curammo
  1514.  
  1515. if (curammo - cl_nn_shotgun_ammo[id] == SH_CARTRAGE_RATIO && cs_get_user_bpammo(id, wpn_id) && curammo + 1 <= maxammo)
  1516. {
  1517. cs_set_weapon_ammo(ent, curammo + 1)
  1518. cs_set_user_bpammo(id, wpn_id, cs_get_user_bpammo(id, wpn_id) - 1)
  1519. cl_nn_shotgun_ammo[id] = curammo + 1
  1520.  
  1521. set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_sp_fatshre), DELAY_SPD_SH_RELOAD)
  1522.  
  1523. // Update hud weapon info, emessage to be blocked if needed
  1524. emessage_begin(MSG_ONE, nd_msg_ammox, {0,0,0}, id)
  1525. ewrite_byte(SH_AMMO_MSG_AMMOID)
  1526. ewrite_byte(curammo + 1)
  1527. emessage_end()
  1528.  
  1529. }
  1530. }
  1531.  
  1532. return HAM_IGNORED
  1533.  
  1534. }
  1535.  
  1536. public fw_reload_post(ent)
  1537. {
  1538. if(get_pdata_int(ent, OFFSET_WEAPON_IN_RELOAD, EXTRA_OFFSET_WEAPON_LINUX))
  1539. {
  1540. new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
  1541.  
  1542. cl_nn_shotgun_ammo[id] = -1
  1543.  
  1544. if (cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_critical))
  1545. {
  1546. new Float:delay = wpn_reload_delay[get_pdata_int(ent, OFFSET_WEAPON_ID, EXTRA_OFFSET_WEAPON_LINUX)] * RELOAD_RATIO
  1547.  
  1548. set_pdata_float(id, OFFSET_PLAYER_NEXT_ATTACK, delay, EXTRA_OFFSET_PLAYER_LINUX)
  1549. set_pdata_float(ent, OFFSET_WEAPON_IDLE_TIME, delay + 0.5, EXTRA_OFFSET_WEAPON_LINUX)
  1550.  
  1551. set_nano_energy(id,cl_nn_energy[id] - get_pcvar_float(pcv_nn_sp_reload),DELAY_SPD_FAST_RELOAD)
  1552. }
  1553. }
  1554.  
  1555. return HAM_IGNORED
  1556. }
  1557.  
  1558. public fw_spawn(id)
  1559. {
  1560. if (is_user_alive(id) && cs_get_user_team(id) == CS_TEAM_CT)
  1561. {
  1562. msg_shadowidx(id,SHADOW_CREATE)
  1563. nanosuit_reset(id,true)
  1564. cl_nn_zombie[id] = false
  1565.  
  1566. once[id] = false;
  1567. Cumparat[id] = false;
  1568.  
  1569. if (cl_nn_has[id] == NANO_NO && !cl_is_bot[id] && (get_pcvar_num(pcv_nn_team) == _:cs_get_user_team(id) || get_pcvar_num(pcv_nn_team) != 3) && get_pcvar_num(pcv_nn_price) <= 0)
  1570. {
  1571. cl_nn_has[id] = NANO_YES
  1572. nanosuit_reset(id,true)
  1573. }
  1574.  
  1575. if (cl_is_bot[id] && get_pcvar_num(pcv_nn_price) > 0 && get_pcvar_num(pcv_nn_bot) && get_pcvar_num(pcv_nn_bot_buy) && cs_get_user_team(id) == CS_TEAM_T)
  1576. nanosuit_buy(id)
  1577. }
  1578.  
  1579. if(is_user_alive(id) && cs_get_user_team(id) == CS_TEAM_T)
  1580. {
  1581. nanosuit_reset(id)
  1582. cl_nn_has[id] = NANO_NO
  1583. reset_rendering(id)
  1584. }
  1585.  
  1586.  
  1587. return HAM_IGNORED
  1588. }
  1589.  
  1590. public fw_killed(id,attacker,gib)
  1591. {
  1592. if (cl_nn_has[id] == NANO_YES)
  1593. {
  1594. msg_statusicon(id,ICON_REMOVE,NanoStatusIcon[cl_nn_mode[id]],NanoScreenColor[cl_nn_mode[id]])
  1595. #if defined USE_WEAPON_STATUSICONS
  1596. msg_statusicon(id,ICON_REMOVE,wpn_ms_icon[cl_nn_weapon[id]],{0,255,0})
  1597. #endif
  1598. }
  1599.  
  1600. return HAM_IGNORED
  1601. }
  1602.  
  1603. public fw_traceattack(victim, attacker, Float:damage, Float:direction[3], tr, damagebits)
  1604. {
  1605. new hitzone
  1606. hitzone = get_tr2(tr,TR_iHitgroup)
  1607. damage *= vec_hit_multi[hitzone]
  1608. new Float:origin[3]
  1609. pev(attacker,pev_origin,origin)
  1610. new use_strength
  1611. use_strength = 0
  1612.  
  1613. if (is_user_player(attacker))
  1614. {
  1615. // Strength Mode
  1616. if (get_pcvar_num(pcv_nn_ff))
  1617. {
  1618. if (cs_get_user_team(victim) == cs_get_user_team(attacker))
  1619. {
  1620. damage /= 2.0
  1621. use_strength = 2
  1622. }
  1623. else
  1624. {
  1625. use_strength = 1
  1626. }
  1627. }
  1628. else
  1629. {
  1630. if (cs_get_user_team(victim) == cs_get_user_team(attacker))
  1631. {
  1632. if (get_pcvar_num(pcv_nn_st_can_th))
  1633. use_strength = 1
  1634. }
  1635. else
  1636. {
  1637. use_strength = 1
  1638. }
  1639. }
  1640.  
  1641. if (use_strength && cl_nn_has[attacker] == NANO_YES && cl_nn_mode[attacker] == NANO_STREN && CSW_KNIFE == cl_nn_weapon[attacker])
  1642. {
  1643. damage *= 4.0
  1644.  
  1645. if (cl_nn_st_knife[attacker] == KNIFE_FIRST_ATTACK)
  1646. {
  1647. new Float:origin[3], Float:origin2[3], Float:throw[3], Float:aimvel[3]
  1648.  
  1649. // Get the origin of attacker and victim
  1650. pev(victim,pev_origin,origin)
  1651. pev(attacker,pev_origin,origin2)
  1652. velocity_by_aim(attacker,2,aimvel)
  1653.  
  1654. // We need to make a vector between them and we multiply it's value so we can make it powerfull
  1655. xs_vec_sub(origin,origin2,throw)
  1656. xs_vec_div_scalar(throw,xs_vec_len(throw),throw)
  1657. xs_vec_add(throw,aimvel,throw)
  1658. xs_vec_div_scalar(throw,xs_vec_len(throw),throw)
  1659. throw[2] += 0.6
  1660. xs_vec_mul_scalar(throw,get_pcvar_float(pcv_nn_st_throw),throw)
  1661.  
  1662. // We add it to the velocity so we can make it a throw
  1663. set_pev(victim,pev_velocity,throw)
  1664.  
  1665. // We block the speed of the player so he can't influence the direction of the throw (too much :P)
  1666. set_user_maxspeed(victim, 1.0)
  1667. cl_is_thrown[victim] = attacker
  1668. set_pev(victim,pev_flags,pev(victim,pev_flags) & ~FL_ONGROUND)
  1669. }
  1670.  
  1671. cl_nn_st_knife[attacker] = KNIFE_NOT
  1672. }
  1673. }
  1674.  
  1675. // Armor Mode
  1676. if ((!is_user_player(attacker)) || (get_pcvar_num(pcv_nn_ff) || ((!get_pcvar_num(pcv_nn_ff) && cs_get_user_team(victim) != cs_get_user_team(attacker)))))
  1677. {
  1678. if ((get_tr2(tr,TR_iHitgroup) != 8) && cl_nn_has[victim] == NANO_YES && cl_nn_mode[victim] == NANO_ARMOR)
  1679. {
  1680. damage *= get_pcvar_float(pcv_nn_ar_damage)
  1681.  
  1682. if (damage < cl_nn_energy[victim])
  1683. {
  1684. set_nano_energy(victim, cl_nn_energy[victim] - damage, DELAY_ARM_DAMAGE)
  1685. set_tr2(tr,TR_iHitgroup,8)
  1686. static Float:vec_end_pos[3]
  1687. get_tr2(tr,TR_vecEndPos,vec_end_pos)
  1688.  
  1689. if (hitzone != HIT_GENERIC)
  1690. draw_spark(vec_end_pos)
  1691.  
  1692.  
  1693. if (random(2) > 0)
  1694. {
  1695. engfunc(EngFunc_EmitSound,victim,CHAN_AUTO,sound_ric_metal1, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
  1696. }
  1697. else
  1698. {
  1699. engfunc(EngFunc_EmitSound,victim,CHAN_AUTO,sound_ric_metal2, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
  1700. }
  1701.  
  1702. set_pev(victim,pev_dmg_inflictor,attacker)
  1703. emsg_damage(victim,0,floatround(damage),damagebits,origin)
  1704. damage = 0.0
  1705. }
  1706. else
  1707. {
  1708. damage -= cl_nn_energy[victim]
  1709. set_nano_energy(victim, 0.0, DELAY_ARM_DAMAGE)
  1710. }
  1711. }
  1712. }
  1713.  
  1714. if (use_strength == 2)
  1715. damage *= 2.0
  1716.  
  1717. if (hitzone != 8 && damage != 0.0)
  1718. damage /= vec_hit_multi[hitzone]
  1719.  
  1720. SetHamParamTraceResult(5,tr)
  1721. SetHamParamFloat(3,damage)
  1722. return HAM_HANDLED
  1723. }
  1724.  
  1725.  
  1726. public fw_takedamage(victim, inflictor, attacker, Float:damage, damagebits)
  1727. {
  1728. new Float:origin[3]
  1729. pev(inflictor,pev_origin,origin)
  1730.  
  1731. if (damagebits == DMG_FALL && cl_is_thrown[victim])
  1732. {
  1733. damage *= DMG_FALL_MULTIPLY
  1734. attacker = cl_is_thrown[victim]
  1735. SetHamParamEntity(3, attacker)
  1736. }
  1737.  
  1738. // Armor Mode
  1739. if (((!(inflictor == attacker) || (attacker == victim)) || !is_user_player(attacker)) && cl_nn_has[victim] == NANO_YES && cl_nn_mode[victim] == NANO_ARMOR && ((get_pcvar_num(pcv_nn_ff)) || ((!get_pcvar_num(pcv_nn_ff) && (!is_user_player(attacker) || cs_get_user_team(victim) != cs_get_user_team(attacker) || attacker == victim)))))
  1740. {
  1741. damage *= get_pcvar_float(pcv_nn_ar_damage)
  1742.  
  1743. if (damage < cl_nn_energy[victim])
  1744. {
  1745. set_nano_energy(victim, cl_nn_energy[victim] - damage, DELAY_ARM_DAMAGE)
  1746. set_pev(victim,pev_dmg_inflictor,inflictor)
  1747. emsg_damage(victim,0,floatround(damage),damagebits,origin)
  1748. damage = 0.0
  1749. }
  1750. else
  1751. {
  1752. damage -= cl_nn_energy[victim]
  1753. set_nano_energy(victim, 0.0, DELAY_ARM_DAMAGE)
  1754. }
  1755. }
  1756.  
  1757. SetHamParamFloat(4,damage)
  1758. return HAM_HANDLED
  1759. }
  1760.  
  1761. public fw_takedamage_post(victim, inflictor, attacker, Float:damage, damagebits)
  1762. {
  1763. if (cl_nn_has[victim] == NANO_YES && cl_nn_mode[victim] == NANO_ARMOR)
  1764. {
  1765. new Float: painshock = get_pdata_float(victim, OFFSET_PLAYER_PAIN_SHOCK, EXTRA_OFFSET_PLAYER_LINUX)
  1766.  
  1767. if (painshock == 1.0)
  1768. return HAM_IGNORED
  1769.  
  1770. painshock = (1.0 - ((1.0 - painshock) * PAIN_SHOCK_ATTENUATION))
  1771.  
  1772. set_pdata_float(victim, OFFSET_PLAYER_PAIN_SHOCK, painshock, EXTRA_OFFSET_PLAYER_LINUX)
  1773. }
  1774.  
  1775. return HAM_IGNORED
  1776. }
  1777.  
  1778. public fw_bomb_planting(ent)
  1779. {
  1780. new planter
  1781. planter = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
  1782.  
  1783. if (cl_nn_has[planter] == NANO_YES && cl_nn_mode[planter] == NANO_CLOAK && get_pcvar_num(pcv_nn_cl_c4))
  1784. {
  1785. set_nano_energy(planter,0.0,DELAY_CLK_FORCED)
  1786. }
  1787.  
  1788. return HAM_IGNORED
  1789. }
  1790.  
  1791. public fw_bomb_defusing(ent, caller, activator, use_type, Float:value)
  1792. {
  1793. if (cl_nn_has[caller] == NANO_YES && cl_nn_mode[caller] == NANO_CLOAK && get_pcvar_num(pcv_nn_cl_c4) && cs_get_user_team(caller) == CS_TEAM_CT)
  1794. {
  1795. set_nano_energy(caller,0.0,DELAY_CLK_FORCED)
  1796. }
  1797.  
  1798. return HAM_IGNORED
  1799. }
  1800.  
  1801. /* ===================================================
  1802. [Screen think of all players]
  1803. ==================================================== */
  1804. public fw_screenthink(ent)
  1805. {
  1806. if (!pev_valid(ent))
  1807. return FMRES_IGNORED
  1808.  
  1809. if (ent != nd_ent_monitor)
  1810. return FMRES_IGNORED
  1811.  
  1812. new players[32], count, id
  1813. new Float:energy
  1814. energy = get_pcvar_float(pcv_nn_energy)
  1815.  
  1816. get_players(players, count, "ac")
  1817.  
  1818. for (new i=0;i<count;i++)
  1819. {
  1820. id = players[i]
  1821.  
  1822. if (cl_nn_has[id] == NANO_YES && ((cl_nn_lowres[id] && cl_nn_counter[id] == 0) || !cl_nn_lowres[id]))
  1823. {
  1824. // Current Mode
  1825. static hud[200]
  1826.  
  1827. formatex(hud, 199, "%L",id,"NANO_MODE")
  1828.  
  1829. switch (cl_nn_mode[id])
  1830. {
  1831. case NANO_STREN: formatex(hud, 199, "%s %L ^n",hud,id,"NANO_ST_MODE")
  1832. case NANO_ARMOR: formatex(hud, 199, "%s %L ^n",hud,id,"NANO_A_MODE")
  1833. case NANO_SPEED: formatex(hud, 199, "%s %L ^n",hud,id,"NANO_S_MODE")
  1834. case NANO_CLOAK: formatex(hud, 199, "%s %L ^n",hud,id,"NANO_C_MODE")
  1835. }
  1836.  
  1837. formatex(hud, 199, "%L",id,"NANO_ENERGY", hud, floatround(cl_nn_energy[id] / energy * 100))
  1838.  
  1839. for (new x = 0; x < floatround(cl_nn_energy[id] / energy * 20); x++)
  1840. formatex(hud, 199, "%s|", hud)
  1841.  
  1842. formatex(hud, 199, "%s^n^n", hud)
  1843.  
  1844. // Health, Armor, Speed
  1845. formatex(hud, 199, "%L",id,"NANO_POINTS", hud, get_user_health(id), get_user_armor(id))
  1846.  
  1847. switch (cl_nn_scr_speed[id])
  1848. {
  1849. case SPD_SCR_STILL: formatex(hud, 199, "%L",id,"NANO_SPD_ST", hud)
  1850. case SPD_SCR_VSLOW: formatex(hud, 199, "%L",id,"NANO_SPD_VS", hud)
  1851. case SPD_SCR_SLOW: formatex(hud, 199, "%L",id,"NANO_SPD_SL", hud)
  1852. case SPD_SCR_NORMAL: formatex(hud, 199, "%L",id,"NANO_SPD_NO", hud)
  1853. case SPD_SCR_FAST: formatex(hud, 199, "%L",id,"NANO_SPD_FA", hud)
  1854. }
  1855.  
  1856. if (!cl_nn_lowres[id])
  1857. {
  1858. set_hudmessage(NanoScreenColor[cl_nn_mode[id]][0], NanoScreenColor[cl_nn_mode[id]][1], NanoScreenColor[cl_nn_mode[id]][2], 0.02, 0.70, 0, 0.0, 0.2, 0.0, 0.0)
  1859. ShowSyncHudMsg(id, nd_hud_sync, "%s", hud)
  1860. }
  1861. else
  1862. {
  1863. set_hudmessage(NanoScreenColor[cl_nn_mode[id]][0], NanoScreenColor[cl_nn_mode[id]][1], NanoScreenColor[cl_nn_mode[id]][2], 0.02, 0.70, 0, 0.0, (0.2 + (0.1 * float(NANO_LOW_RES))), 0.0, 0.0)
  1864. ShowSyncHudMsg(id, nd_hud_sync, "%s", hud)
  1865. }
  1866. }
  1867.  
  1868. if (cl_nn_counter[id] > 0)
  1869. cl_nn_counter[id] -= 1
  1870. else
  1871. cl_nn_counter[id] = NANO_LOW_RES
  1872. }
  1873.  
  1874. set_pev(ent, pev_nextthink, get_gametime() + 0.1)
  1875.  
  1876. return FMRES_IGNORED
  1877. }
  1878.  
  1879. /* ===================================================
  1880. [Energy manipulation task]
  1881. ==================================================== */
  1882. public set_energy(id)
  1883. {
  1884. id -= TASK_ENERGY
  1885.  
  1886. if (!(cl_nn_has[id] == NANO_YES))
  1887. {
  1888. remove_task(id + TASK_ENERGY)
  1889. return PLUGIN_CONTINUE
  1890. }
  1891.  
  1892. if (!is_user_alive(id))
  1893. {
  1894. return PLUGIN_CONTINUE
  1895. }
  1896.  
  1897. new NanoModes:active = cl_nn_mode[id]
  1898. new Float:energy = cl_nn_energy[id]
  1899.  
  1900. // Decrease when player is running in speed mode
  1901. if (active == NANO_SPEED && pev(id,pev_flags) & ON_LAND_CONST)
  1902. {
  1903. new Float:multi
  1904.  
  1905. switch (cl_nn_sp_status[id])
  1906. {
  1907. case SPEED_NORMAL:
  1908. {
  1909. switch (cl_nn_speed[id])
  1910. {
  1911. case SPD_STILL: multi = 0.0
  1912. case SPD_VSLOW: multi = 0.0
  1913. case SPD_SLOW: multi = 0.0
  1914. case SPD_NORMAL: multi = 1.0
  1915. case SPD_FAST: multi = 1.0
  1916. }
  1917.  
  1918. energy -= (0.1) * multi
  1919. }
  1920. case SPEED_CRITICAL:
  1921. {
  1922. switch (cl_nn_speed[id])
  1923. {
  1924. case SPD_STILL: multi = 0.0
  1925. case SPD_VSLOW: multi = 0.0
  1926. case SPD_SLOW: multi = 0.0
  1927. case SPD_NORMAL: multi = 0.0
  1928. case SPD_FAST: multi = 1.0
  1929. }
  1930.  
  1931. energy -= (0.2) * multi
  1932. }
  1933. case SPEED_MAXIMUM:
  1934. {
  1935. switch (cl_nn_speed[id])
  1936. {
  1937. case SPD_STILL: multi = 0.0
  1938. case SPD_VSLOW: multi = 0.0
  1939. case SPD_SLOW: multi = 0.0
  1940. case SPD_NORMAL: multi = 0.0
  1941. case SPD_FAST:
  1942. {
  1943. multi = 1.0
  1944. client_cmd(id, "speak %s", sound_speed_run)
  1945. }
  1946. }
  1947.  
  1948. energy -= get_pcvar_float(pcv_nn_sp_energy) * multi
  1949. }
  1950. }
  1951.  
  1952. if (multi != 0.0)
  1953. cl_nn_block_recharge[id] = DELAY_SPD_RUN + 1
  1954. }
  1955.  
  1956. // Decrease in cloak mode
  1957. if (active == NANO_CLOAK)
  1958. {
  1959. static Float:multi = 1.0
  1960.  
  1961. switch (cl_nn_speed[id])
  1962. {
  1963. case SPD_STILL: multi = 0.1
  1964. case SPD_VSLOW: multi = 0.2
  1965. case SPD_SLOW: multi = 0.5
  1966. case SPD_NORMAL: multi = 1.0
  1967. case SPD_FAST: multi = 1.4
  1968. }
  1969.  
  1970. energy -= get_pcvar_float(pcv_nn_cl_energy) * multi
  1971. }
  1972.  
  1973. if (energy < get_pcvar_num(pcv_nn_critical) && !cl_nn_critical[id])
  1974. {
  1975. cl_nn_critical[id] = true
  1976.  
  1977. if (!cl_is_bot[id])
  1978. {
  1979. client_cmd(id, "spk %s", sound_energy)
  1980. client_print(id, print_center, "%L", id, "NANO_CRITIC")
  1981. }
  1982. }
  1983.  
  1984. if (energy <= 0.0)
  1985. {
  1986. if (active == NANO_CLOAK)
  1987. {
  1988. cl_nn_block_recharge[id] = DELAY_CLK_DELAY
  1989. set_nano_mode(id,NANO_ARMOR)
  1990. #if defined REMOVE_VIEWMODEL_ON_CLOAK
  1991. if (!cl_is_bot[id])
  1992. {
  1993. if (cs_get_user_shield(id) && (WEAPONS_WITH_SHIELD_BITSUM & 1<<cl_nn_weapon[id]))
  1994. {
  1995. set_pev(id,pev_viewmodel2,wpn_v_shield_model[cl_nn_weapon[id]])
  1996. }
  1997. else
  1998. set_pev(id,pev_viewmodel2,wpn_v_model[cl_nn_weapon[id]])
  1999. }
  2000. #endif
  2001. }
  2002.  
  2003. energy = 0.0
  2004. }
  2005.  
  2006. // Increase but not when in cloak mode
  2007. if (energy < get_pcvar_float(pcv_nn_energy) && cl_nn_mode[id] != NANO_CLOAK && cl_nn_block_recharge[id] == 0)
  2008. {
  2009. static Float:energy2
  2010. energy2 = get_pcvar_float(pcv_nn_regenerate)
  2011.  
  2012. if (pev(id,pev_button) & IN_DUCK && cl_nn_speed[id] == SPD_STILL)
  2013. energy2 *= ENERGY_CROUCH
  2014.  
  2015. energy2 += energy
  2016.  
  2017. // Useful to block the moment when a player energy is bigger than the maximum energy
  2018. energy = floatmin(get_pcvar_float(pcv_nn_energy), energy2)
  2019.  
  2020. if (energy > get_pcvar_float(pcv_nn_critical) + CRITICAL_EXTRA_ADD)
  2021. cl_nn_critical[id] = false
  2022. }
  2023.  
  2024. if (cl_nn_block_recharge[id] > 0)
  2025. cl_nn_block_recharge[id] -= 1
  2026.  
  2027. cl_nn_energy[id] = energy
  2028.  
  2029. return PLUGIN_CONTINUE
  2030. }
  2031.  
  2032. /* ===================================================
  2033. [Armor and HitPoints nano recharge]
  2034. ==================================================== */
  2035. public nanosuit_ah_charge(id)
  2036. {
  2037. id -= TASK_AH_REC
  2038.  
  2039. if (!(cl_nn_has[id] == NANO_YES))
  2040. {
  2041. remove_task(id + TASK_AH_REC)
  2042. return PLUGIN_CONTINUE
  2043. }
  2044.  
  2045. if (!is_user_alive(id))
  2046. {
  2047. return PLUGIN_CONTINUE
  2048. }
  2049.  
  2050. static CsArmorType:type
  2051.  
  2052. if (cs_get_user_armor(id,type) < get_pcvar_num(pcv_nn_armor) || type != CS_ARMOR_VESTHELM && cl_nn_block_recharge[id] == 0)
  2053. cs_set_user_armor(id, min(get_pcvar_num(pcv_nn_armor), get_user_armor(id) + get_pcvar_num(pcv_nn_ap_charge)), CS_ARMOR_KEVLAR)
  2054.  
  2055. static Float:health
  2056. pev(id,pev_health,health)
  2057.  
  2058. if (floatround(health,floatround_floor) < get_pcvar_num(pcv_nn_health) && cl_nn_block_recharge[id] == 0)
  2059. set_user_health(id, min(get_pcvar_num(pcv_nn_health), get_user_health(id) + get_pcvar_num(pcv_nn_hp_charge)))
  2060.  
  2061. return PLUGIN_CONTINUE
  2062. }
  2063.  
  2064. /* ===================================================
  2065. [Nanosuit prethink functions]
  2066. ==================================================== */
  2067. public nanosuit_functions(id)
  2068. {
  2069. if (cl_nn_mode[id] == NANO_SPEED)
  2070. {
  2071. if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical))
  2072. {
  2073. if (cl_nn_sp_status[id] == SPEED_NORMAL)
  2074. {
  2075. set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim))
  2076. }
  2077. if (cl_nn_sp_status[id] == SPEED_CRITICAL)
  2078. {
  2079. set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim) / get_pcvar_float(pcv_nn_sp_critic))
  2080. }
  2081.  
  2082. cl_nn_sp_status[id] = SPEED_MAXIMUM
  2083. }
  2084. if (get_pcvar_float(pcv_nn_critical) >= cl_nn_energy[id] > 0)
  2085. {
  2086. if (cl_nn_sp_status[id] == SPEED_NORMAL)
  2087. {
  2088. set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic))
  2089. }
  2090. if (cl_nn_sp_status[id] == SPEED_MAXIMUM)
  2091. {
  2092. set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic) / get_pcvar_float(pcv_nn_sp_maxim))
  2093. }
  2094.  
  2095. cl_nn_sp_status[id] = SPEED_CRITICAL
  2096. }
  2097. if (0 >= cl_nn_energy[id])
  2098. {
  2099. if (cl_nn_sp_status[id] == SPEED_MAXIMUM)
  2100. {
  2101. set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_maxim))
  2102. }
  2103. if (cl_nn_sp_status[id] == SPEED_CRITICAL)
  2104. {
  2105. set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_critic))
  2106. }
  2107.  
  2108. cl_nn_sp_status[id] = SPEED_NORMAL
  2109. }
  2110.  
  2111. return
  2112. }
  2113.  
  2114. if (cl_nn_mode[id] == NANO_STREN)
  2115. set_pev(id, pev_fuser2, 0.0)
  2116.  
  2117. if (!is_glowing_in_nano(id))
  2118. {
  2119. set_nano_glow(id)
  2120. }
  2121.  
  2122.  
  2123. if (cl_nn_mode[id] == NANO_STREN && pev(id, pev_button) & IN_JUMP &&!(pev(id, pev_oldbuttons) & IN_JUMP) && pev(id, pev_flags) & ON_GROUND_CONST && cl_nn_energy[id] >= get_pcvar_num(pcv_nn_st_jump))
  2124. cl_nn_st_jump[id] = true
  2125. else
  2126. cl_nn_st_jump[id] = false
  2127.  
  2128. return
  2129. }
  2130.  
  2131. /* ===================================================
  2132. [Bot think task, allows bots to use the nano functions]
  2133. ==================================================== */
  2134. public nanosuit_bot_think(id)
  2135. {
  2136. id -= TASK_AI
  2137.  
  2138. if (!is_user_alive(id))
  2139. return PLUGIN_CONTINUE
  2140.  
  2141. if (!cl_is_bot[id])
  2142. {
  2143. remove_task(id + TASK_AI)
  2144. return PLUGIN_CONTINUE
  2145. }
  2146.  
  2147. new Float:health
  2148. pev(id,pev_health,health)
  2149.  
  2150. if (health < 60.0)
  2151. {
  2152. nanosuit_menu_choose(id,0,_:NANO_ARMOR)
  2153. return PLUGIN_CONTINUE
  2154. }
  2155.  
  2156. new hit = -1
  2157. new Float:origin[3]
  2158. pev(id,pev_origin,origin)
  2159. new Float:velocity[3]
  2160. pev(id,pev_velocity,velocity)
  2161. vector_length(velocity)
  2162.  
  2163. if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical) && floatround(vector_length(velocity)) <= 20)
  2164. {
  2165. nanosuit_menu_choose(id,0,_:NANO_CLOAK)
  2166. return PLUGIN_CONTINUE
  2167. }
  2168.  
  2169. if (cl_nn_weapon[id] == CSW_KNIFE)
  2170. {
  2171. while ((hit = engfunc(EngFunc_FindEntityInSphere, hit, origin, 350.0)))
  2172. {
  2173. if (!is_user_alive(hit))
  2174. continue
  2175.  
  2176. if ((get_pcvar_num(pcv_nn_ff)) || (!get_pcvar_num(pcv_nn_ff) && cs_get_user_team(id) != cs_get_user_team(hit)))
  2177. {
  2178. nanosuit_menu_choose(id,0,_:NANO_STREN)
  2179. break
  2180. }
  2181. }
  2182. }
  2183. else
  2184. {
  2185. if (random_num(0,100) <= 40)
  2186. nanosuit_menu_choose(id,0,_:NANO_SPEED)
  2187. else
  2188. nanosuit_menu_choose(id,0,_:NANO_ARMOR)
  2189. }
  2190.  
  2191. return PLUGIN_CONTINUE
  2192. }
  2193.  
  2194. /* ===================================================
  2195. [Zombie Functons and Forwards]
  2196. ==================================================== */
  2197. public event_infect(victim, attacker)
  2198. {
  2199. cl_nn_zombie[victim] = true
  2200. cl_nn_had[victim] = cl_nn_has[victim]
  2201. cl_nn_has[victim] = NANO_NO
  2202. nanosuit_reset(victim)
  2203.  
  2204. return PLUGIN_CONTINUE
  2205. }
  2206.  
  2207. public zp_user_infected_post(victim, attacker)
  2208. {
  2209. cl_nn_had[victim] = cl_nn_has[victim]
  2210. cl_nn_has[victim] = NANO_NO
  2211. nanosuit_reset(victim)
  2212.  
  2213. return PLUGIN_CONTINUE
  2214. }
  2215.  
  2216.  
  2217. public zp_user_humanized_post(id, survivor)
  2218. {
  2219. if (!get_pcvar_num(pcv_zm_regive))
  2220. return PLUGIN_CONTINUE
  2221.  
  2222. if (cl_nn_had[id] == NANO_YES)
  2223. {
  2224. cl_nn_has[id] = NANO_YES
  2225. nanosuit_reset(id)
  2226. }
  2227.  
  2228. return PLUGIN_CONTINUE
  2229. }
  2230.  
  2231. /* ===================================================
  2232. [Functions that come in handy]
  2233. ==================================================== */
  2234. set_nano_mode(id, NanoModes:mode, bool:announce = true)
  2235. {
  2236. if (cl_nn_mode[id] == mode)
  2237. return
  2238.  
  2239. if (cl_nn_mode[id] == NANO_CLOAK)
  2240. {
  2241. #if defined REMOVE_VIEWMODEL_ON_CLOAK
  2242. if (!cl_is_bot[id])
  2243. {
  2244. if (cs_get_user_shield(id) && (WEAPONS_WITH_SHIELD_BITSUM & 1<<cl_nn_weapon[id]))
  2245. {
  2246. set_pev(id,pev_viewmodel2,wpn_v_shield_model[cl_nn_weapon[id]])
  2247. }
  2248. else
  2249. set_pev(id,pev_viewmodel2,wpn_v_model[cl_nn_weapon[id]])
  2250. }
  2251. #endif
  2252. #if defined USE_WEAPON_STATUSICONS
  2253. msg_statusicon(id,ICON_REMOVE,wpn_ms_icon[cl_nn_weapon[id]],{0,0,0})
  2254. #endif
  2255.  
  2256. msg_shadowidx(id,SHADOW_CREATE)
  2257. }
  2258. if (mode == NANO_CLOAK)
  2259. {
  2260. msg_shadowidx(id,SHADOW_REMOVE)
  2261. }
  2262.  
  2263. msg_statusicon(id,ICON_REMOVE,NanoStatusIcon[cl_nn_mode[id]],{0,0,0})
  2264. msg_statusicon(id,ICON_SHOW,NanoStatusIcon[mode],NanoScreenColor[mode])
  2265.  
  2266. cl_nn_mode[id] = mode
  2267.  
  2268. set_nano_glow(id)
  2269.  
  2270. if (!cl_is_bot[id] && announce)
  2271. {
  2272. switch (mode)
  2273. {
  2274. case NANO_ARMOR:
  2275. {
  2276. client_cmd(id, "spk %s", sound_switch_armor)
  2277. client_cmd(id, "spk %s", sound_armor)
  2278. client_print(id, print_center, "%L", id, "NANO_ARM")
  2279. }
  2280. case NANO_STREN:
  2281. {
  2282. client_cmd(id, "spk %s", sound_switch_strength)
  2283. client_cmd(id, "spk %s", sound_strengh)
  2284. client_print(id, print_center, "%L", id, "NANO_STR")
  2285. }
  2286. case NANO_SPEED:
  2287. {
  2288. client_cmd(id, "spk %s", sound_switch_speed)
  2289. client_cmd(id, "spk %s", sound_speed)
  2290. client_print(id, print_center, "%L", id, "NANO_SPD")
  2291. }
  2292. case NANO_CLOAK:
  2293. {
  2294. #if defined REMOVE_VIEWMODEL_ON_CLOAK
  2295. set_pev(id,pev_viewmodel2,"")
  2296. #endif
  2297. #if defined USE_WEAPON_STATUSICONS
  2298. msg_statusicon(id,ICON_SHOW,wpn_ms_icon[cl_nn_weapon[id]],{0,255,0})
  2299. #endif
  2300. client_cmd(id, "spk %s", sound_switch_cloak)
  2301. client_cmd(id, "spk %s", sound_cloak)
  2302. client_print(id, print_center, "%L", id, "NANO_CLO")
  2303. }
  2304. }
  2305. }
  2306. }
  2307.  
  2308. set_nano_energy(id, Float:ammount, delay = 0)
  2309. {
  2310. cl_nn_energy[id] = ammount
  2311. if (delay > cl_nn_block_recharge[id])
  2312. cl_nn_block_recharge[id] = delay
  2313. if (ammount == 0.0 && cl_nn_mode[id] == NANO_CLOAK)
  2314. {
  2315. set_nano_mode(id,NANO_ARMOR)
  2316. }
  2317.  
  2318. return 1
  2319. }
  2320.  
  2321. nanosuit_reset(id, bool:affect_user_properties = false)
  2322. {
  2323. if (cl_nn_has[id] == NANO_YES)
  2324. {
  2325. if (glb_use_new_models)
  2326. {
  2327. switch (cs_get_user_team(id))
  2328. {
  2329. case CS_TEAM_CT: fm_set_user_model(id,model_nanosuit_ct)
  2330. case CS_TEAM_T: fm_set_user_model(id,model_nanosuit_t)
  2331. }
  2332. }
  2333.  
  2334. set_nano_glow(id)
  2335.  
  2336. if (affect_user_properties)
  2337. {
  2338. cl_nn_energy[id] = get_pcvar_float(pcv_nn_energy)
  2339. set_user_health(id, get_pcvar_num(pcv_nn_health))
  2340. cs_set_user_armor(id,get_pcvar_num(pcv_nn_armor),CS_ARMOR_VESTHELM)
  2341. if (get_pcvar_num(pcv_nn_night))
  2342. cs_set_user_nvg(id,1)
  2343.  
  2344. if (cl_nn_mode[id] == NANO_SPEED)
  2345. {
  2346. switch (cl_nn_sp_status[id])
  2347. {
  2348. case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim))
  2349. case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic))
  2350. }
  2351. }
  2352. }
  2353.  
  2354. if (task_exists(id + TASK_ENERGY))
  2355. remove_task(id + TASK_ENERGY)
  2356.  
  2357. if (task_exists(id + TASK_AH_REC))
  2358. remove_task(id + TASK_AH_REC)
  2359.  
  2360. if (task_exists(id + TASK_AI))
  2361. remove_task(id + TASK_AI)
  2362.  
  2363. msg_statusicon(id,ICON_SHOW,NanoStatusIcon[cl_nn_mode[id]],NanoScreenColor[cl_nn_mode[id]])
  2364.  
  2365. set_task(0.1,"set_energy",id + TASK_ENERGY, _, _,"b", 0)
  2366. set_task(1.0,"nanosuit_ah_charge",id + TASK_AH_REC, _, _,"b", 0)
  2367.  
  2368. if (cl_is_bot[id])
  2369. {
  2370. set_task(2.0,"nanosuit_bot_think",id + TASK_AI, _, _,"b", 0)
  2371. }
  2372. }
  2373. else
  2374. {
  2375. if (cl_update_model[id])
  2376. {
  2377. fm_set_user_model(id,cl_player_model[id])
  2378. cl_update_model[id] = false
  2379. }
  2380. else
  2381. {
  2382. fm_reset_user_model(id)
  2383. }
  2384.  
  2385. if (cl_nn_mode[id] == NANO_SPEED)
  2386. {
  2387. switch (cl_nn_sp_status[id])
  2388. {
  2389. case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_maxim))
  2390. case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_critic))
  2391. }
  2392. }
  2393.  
  2394. if (task_exists(id + TASK_ENERGY))
  2395. remove_task(id + TASK_ENERGY)
  2396.  
  2397. if (task_exists(id + TASK_AH_REC))
  2398. remove_task(id + TASK_AH_REC)
  2399.  
  2400. if (task_exists(id + TASK_AI))
  2401. remove_task(id + TASK_AI)
  2402. }
  2403. }
  2404.  
  2405. /* ===================================================
  2406. [Message stocks]
  2407. ==================================================== */
  2408. stock draw_spark(const Float:origin[3])
  2409. {
  2410. static o[3]
  2411. o[0] = floatround(origin[0])
  2412. o[1] = floatround(origin[1])
  2413. o[2] = floatround(origin[2])
  2414. emessage_begin(MSG_PVS, SVC_TEMPENTITY, o, 0)
  2415. ewrite_byte(TE_SPARKS)
  2416. ewrite_coord(o[0])
  2417. ewrite_coord(o[1])
  2418. ewrite_coord(o[2])
  2419. emessage_end()
  2420. }
  2421.  
  2422. stock emsg_damage(player,dmg_save,dmg_take,dmg_type,Float:origin[3])
  2423. {
  2424. set_pev(player,pev_dmg_save,float(dmg_save))
  2425. set_pev(player,pev_dmg_take,float(dmg_take))
  2426. emessage_begin(MSG_ONE, nd_msg_damage, {0,0,0}, player)
  2427. ewrite_byte(dmg_save)
  2428. ewrite_byte(dmg_take)
  2429. ewrite_long(dmg_type)
  2430. ewrite_coord(floatround(origin[0]))
  2431. ewrite_coord(floatround(origin[1]))
  2432. ewrite_coord(floatround(origin[2]))
  2433. emessage_end()
  2434. }
  2435.  
  2436. stock colored_msg(id,msg[])
  2437. {
  2438. message_begin(MSG_ONE, nd_msg_saytext, {0,0,0}, id)
  2439. write_byte(id)
  2440. write_string(msg)
  2441. message_end()
  2442. }
  2443.  
  2444. stock msg_statusicon(id,IconStatus:mode,icon[],color[3])
  2445. {
  2446. if (cl_is_bot[id] || (cl_nn_lowres[id] && mode != ICON_REMOVE))
  2447. return
  2448.  
  2449. new msg_type
  2450. if (mode == ICON_REMOVE)
  2451. msg_type = MSG_ONE
  2452. else
  2453. msg_type = MSG_ONE_UNRELIABLE
  2454.  
  2455. message_begin(msg_type, nd_msg_iconstatus, {0,0,0}, id)
  2456. write_byte(_:mode)
  2457. write_string(icon)
  2458. write_byte(color[0])
  2459. write_byte(color[1])
  2460. write_byte(color[2])
  2461. message_end()
  2462.  
  2463. return
  2464. }
  2465.  
  2466. stock msg_shadowidx(id, ShadowIdX:long)
  2467. {
  2468. if ((cl_removed_shadow[id] && long == SHADOW_REMOVE) || (!cl_removed_shadow[id] && long == SHADOW_CREATE))
  2469. {
  2470. return
  2471. }
  2472.  
  2473. if (long == SHADOW_REMOVE)
  2474. cl_removed_shadow[id] = true
  2475. else
  2476. cl_removed_shadow[id] = false
  2477.  
  2478. message_begin(MSG_ONE, nd_msg_shadowidx, {0,0,0}, id)
  2479. write_long(_:long)
  2480. message_end()
  2481. }
  2482.  
  2483. bool:is_glowing_in_nano(id)
  2484. {
  2485. if (pev(id, pev_renderfx) != NanoGlowFX[cl_nn_mode[id]])
  2486. return false
  2487.  
  2488. if (pev(id, pev_rendermode) != NanoGlowMode[cl_nn_mode[id]])
  2489. return false
  2490.  
  2491. static Float:ammount
  2492. pev(id, pev_renderamt, ammount)
  2493.  
  2494. if (floatround(ammount) != NanoGlowAmmount[cl_nn_mode[id]])
  2495. return false
  2496.  
  2497. return true
  2498. }
  2499.  
  2500. /* ===================================================
  2501. [Set model stocks]
  2502. ==================================================== */
  2503. stock fm_get_user_model(player, model[], len)
  2504. {
  2505. // Retrieve current model
  2506. engfunc(EngFunc_InfoKeyValue, engfunc(EngFunc_GetInfoKeyBuffer, player), "model", model, len)
  2507. }
  2508.  
  2509. stock fm_reset_user_model(player)
  2510. {
  2511. dllfunc(DLLFunc_ClientUserInfoChanged, player, engfunc(EngFunc_GetInfoKeyBuffer, player))
  2512. }
  2513.  
  2514. public fm_set_user_model(player,const model[])
  2515. {
  2516. // Set new model
  2517. engfunc(EngFunc_SetClientKeyValue, player, engfunc( EngFunc_GetInfoKeyBuffer, player ), "model", model)
  2518. }
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!