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