how to add glow in nanosuit

« Prev
1
Next »

nikolay New Member InfernoBoy Posts: 35	how to add glow in nanosuit Jan 30, 2015 22:01:40 GMT Quote Select Post Deselect Post Link to Post Member Give Gift Back to Top Post by nikolay on Jan 30, 2015 22:01:40 GMT how to add glow in my nanosuit... When player select Strenght mode the player have red glow When player select Armor mode, player have Blue glow When player select Speed mode, player have yellow glow yes, i want this

zmd94 Zp Staff Posts: 8,249	how to add glow in nanosuit Jan 31, 2015 14:02:42 GMT Quote Select Post Deselect Post Link to Post Member Give Gift Back to Top Post by zmd94 on Jan 31, 2015 14:02:42 GMT Where is the .sma file?
	Personal message only for paid request. If you love this forum, kindly to donate by clicking the donate button at the footer of this forum.

nikolay New Member InfernoBoy Posts: 35	how to add glow in nanosuit Jan 31, 2015 16:58:38 GMT Quote Select Post Deselect Post Link to Post Member Give Gift Back to Top Post by nikolay on Jan 31, 2015 16:58:38 GMT here ----------> www.mediafire.com/download/afi7a875nebo680/zp_nanosuit_new.sma

zmd94
Zp Staff

Posts: 8,249

how to add glow in nanosuit Feb 2, 2015 11:09:25 GMT

Quote

Post by zmd94 on Feb 2, 2015 11:09:25 GMT

Just try below:

#include <amxmodx>
#include <fun>
#include <cstrike>
#include <fakemeta>
#include <hamsandwich>
#include <xs>
#include <zombie_plague_advance>

#define PLUGIN	"[Todoresteeeee] : [Crysis Nanosuit]"
#define AUTHOR	"Todoresteeeeee"
#define VERSION	"0.1.0"

//#define REMOVE_VIEWMODEL_ON_CLOAK
//#define USE_WEAPON_STATUSICONS

// Settings defines [here it is a good place to modify some of the settings]
// Maxplayers [the max players, change this if you don't have 32 players(Low memory usage)]
#define MAXPLAYERS 				 			32

// Refire Rate Manipulation
#define REFIRE_PISTOLS			 			0.85
#define REFIRE_KNIFE 			 			0.75
#define REFIRE_M3				 			0.70
#define REFIRE_SNIPERS 			 			0.60

// Reload Manipulation Defines
#define RELOAD_RATIO 			 			0.78
#define SH_CARTRAGE_RATIO		 			2
#define SH_AMMO_MSG_AMMOID					5

// Painshock constant
#define PAIN_SHOCK_ATTENUATION	 			0.5

// Strength grenade throw burst
#define GRENADE_STR_THROW_ADD	 			400

// Lowres defines  -> refresh rate for screen info in lowresources mode
#define NANO_LOW_RES  			 			5  // time 0.1 seconds

// Delay of energy recharge after ability usage (time in 0.1 seconds)
#define DELAY_STR_JUMP 			 			5
#define DELAY_STR_STAB 			 			5
#define DELAY_STR_SHOT 			 			2
#define DELAY_STR_G_THROW 		 			3
#define DELAY_ARM_DAMAGE	 	 			5
#define DELAY_SPD_RUN 			 			4
#define DELAY_SPD_FAST_ATTACK	 			2
#define DELAY_SPD_FAST_RELOAD	 			4
#define DELAY_SPD_SH_RELOAD		 			2
#define DELAY_CLK_DELAY			 			3
#define DELAY_CLK_FORCED		 			5

// Energy regeneration multiply if user crouches
#define ENERGY_CROUCH 			 			1.2

// Critical border additive so that the plugin will not do the CRITICAL CRITCAL CRITICAL sound [Do not set this to 0.0 or dare!]
#define CRITICAL_EXTRA_ADD		 			10.0

// Plugin useful defines [DO NOT MODIFY!]
// Offsets defines
#define OFFSET_WEAPON_OWNER					41
#define OFFSET_WEAPON_ID					43
#define OFFSET_WEAPON_NEXT_PRIMARY_ATTACK   46
#define OFFSET_WEAPON_NEXT_SEC_ATTACK		47
#define OFFSET_WEAPON_IDLE_TIME				48
#define OFFSET_WEAPON_PRIMARY_AMMO_TYPE		49
#define OFFSET_WEAPON_CLIP					51
#define OFFSET_WEAPON_IN_RELOAD				54

#define OFFSET_PLAYER_NEXT_ATTACK			83
#define OFFSET_PLAYER_PAIN_SHOCK			108
#define OFFSET_PLAYER_ITEM_ACTIVE			373
#define OFFSET_PLAYER_AMMO_SLOT0			376

// Linux offset difference
#define EXTRA_OFFSET_PLAYER_LINUX  			5
#define EXTRA_OFFSET_WEAPON_LINUX			4

// Fall extras
#define FALL_TRUE_VELOCITY 					510.0
#define FALL_FALSE_VELOCITY					350.0
#define DMG_FALL_MULTIPLY					1.40

// Speed defines
#define SPEED_WATER_MUL_CONSTANT			0.7266666
#define SPEED_CROUCH_MUL_CONSTANT			0.3333333

// Damage offsets this is the knife/bullet damage
#define DMG_CS_KNIFE_BULLETS		   		(1 << 12 | 1 << 0)

// Flags for speed mode cvar ground
#define NANO_FLAG_INWATER					(1<<1)
#define NANO_FLAG_CROUCHED					(1<<0)

// Recoil Manipulation Defines
new const UNREGISTERED_WEAPONS_BITSUM  = 	((1<<2) | (1<<CSW_HEGRENADE) | (1<<CSW_FLASHBANG) | (1<<CSW_SMOKEGRENADE) | (1<<CSW_C4))
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))

// Reload Manipulation Defines
new const NO_RELOAD_WEAPONS_BITSUM	   =	((1<<CSW_M3) | (1<<CSW_XM1014) | (1<<CSW_KNIFE))

// Task defines
#define TASK_ENERGY 	0
#define TASK_AH_REC 	33
#define TASK_AI			66

// Macro Function defines [DO NOT MODIFY!]
#define is_user_player(%1) 					(1 <= %1 <= glb_maxplayers)
#define Ham_Player_ResetMaxSpeed			Ham_Item_PreFrame

new const ON_LAND_CONST		=	( FL_ONGROUND | FL_ONTRAIN | FL_PARTIALGROUND | FL_INWATER | FL_SWIM )
new const ON_WATER_CONST	=	( FL_INWATER | FL_SWIM )

// Nanosuit status and modes information
enum NanoModes
{
	NANO_STREN = 0,
	NANO_ARMOR = 1,
	NANO_SPEED = 2,
	NANO_CLOAK = 3
}

new const NanoScreenColor[NanoModes][3] =
{
	{174, 0,   4  },
	{18,  54,  177},
	{180, 175, 16  },
	{100, 100, 100}
}

new const NanoStatusIcon[NanoModes][] = 
{
	"",
	"",
	"",
	""
}

new const NanoGlowColor[NanoModes][3] =
{
	{0, 0,   0 },
	{0,   0,   0 },
	{0, 0, 0 },
	{0,   0,   0 } 
}

new const NanoGlowAmmount[NanoModes] = 
{
	0,
	0,
	0,
	0
}

new const NanoGlowFX[NanoModes] =
{
	kRenderFxGlowShell,
	kRenderFxNone,
	kRenderFxGlowShell,
	kRenderFxSolidFast
}

new const NanoGlowMode[NanoModes] =
{
	kRenderNormal,
	kRenderNormal,
	kRenderNormal,
	kRenderTransTexture
}

#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]])
#define reset_rendering(%1) set_user_rendering(%1)

enum NanoStatus
{
	NANO_NO,
	NANO_YES
}

enum NanoSpdMode
{
	SPEED_MAXIMUM,
	SPEED_CRITICAL,
	SPEED_NORMAL
}

enum NanoSpeed
{
	SPD_STILL = 0,
	SPD_VSLOW,
	SPD_SLOW,
	SPD_NORMAL,
	SPD_FAST
}

enum NanoSpeedScreen
{
	SPD_SCR_STILL = 0,
	SPD_SCR_VSLOW,
	SPD_SCR_SLOW,
	SPD_SCR_NORMAL,
	SPD_SCR_FAST
}

enum IconStatus
{
	ICON_REMOVE = 0,
	ICON_SHOW,
	ICON_PULSE
}

enum ShadowIdX
{
	SHADOW_REMOVE = 0,
}

enum KnifeState
{
	KNIFE_NOT = 0,
	KNIFE_FIRST_ATTACK,
	KNIFE_SECOND_ATTACK
}

// HTML properties
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; ^">"

// Reload needed constants
stock const Float:wpn_reload_delay[CSW_P90+1] =
{
	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
}

stock const wpn_reload_anim[CSW_P90+1] = 
{
	-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
}

stock const wpn_max_clip[CSW_P90+1] = 
{
	-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
}

stock const Float:wpn_act_speed[CSW_P90+1] = 
{
	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 
}

// HIT constant damage multi
new const Float:vec_hit_multi[] =
{
	1.0,
	4.0,
	1.0,
	1.25,
	1.0,
	1.0,
	0.75,
	0.75,
	0.0
}

new wpn_v_model[CSW_P90 + 1][30]
new wpn_v_shield_model[CSW_P90 + 1][50]
new wpn_ms_icon[CSW_P90 + 1][14]

// Sounds
new const sound_strengh[] =				"zp_nanosuit/nanosuit_strength.wav"
new const sound_online[] =				"zp_nanosuit/nanosuit_allonline.wav"
new const sound_armor[] = 				"zp_nanosuit/nanosuit_armor.wav"
new const sound_speed[] = 				"zp_nanosuit/nanosuit_speed.wav"
new const sound_cloak[] = 				"zp_nanosuit/nanosuit_cloak.wav"
new const sound_energy[] = 				"zp_nanosuit/nanosuit_energy.wav"
new const sound_menu[] = 				"zp_nanosuit/nanosuit_menu.wav"
new const sound_strength_throw[] = 			"zp_nanosuit/nanosuit_strength_hit.wav"
new const sound_strength_jump[] = 			"zp_nanosuit/nanosuit_strength_jump.wav"
new const sound_switch_strength[] = 			"zp_nanosuit/nanosuit_strength_switch.wav"
new const sound_switch_armor[] = 			"zp_nanosuit/nanosuit_armor_switch.wav"
new const sound_switch_speed[] = 			"zp_nanosuit/nanosuit_speed_switch.wav"
new const sound_switch_cloak[] = 			"zp_nanosuit/nanosuit_cloak_switch.wav"
new const sound_speed_run[] = 				"zp_nanosuit/nanosuit_speed_run.wav"

new const sound_ric_metal1[] = 			"weapons/ric_metal-1.wav"
new const sound_ric_metal2[] = 			"weapons/ric_metal-2.wav"

// 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
new vec_model_ct[][] = 
{
	"gign",
	"gsg9",
	"sas",
	"urban",
	"vip"
}
new vec_model_t[][] = 
{
	"arctic",
	"terror",
	"leet",
	"guerilla"
}

// Pcvars
new pcv_nn_price
new pcv_nn_ff
new pcv_nn_death
new pcv_nn_bot
new pcv_nn_bot_buy
new pcv_nn_team
new pcv_nn_energy
new pcv_nn_critical
new pcv_nn_health
new pcv_nn_buyzone
new pcv_nn_regenerate
new pcv_nn_night
new pcv_nn_hp_charge
new pcv_nn_ar_speed
new pcv_nn_ar_damage
new pcv_nn_st_stab
new pcv_nn_st_throw
new pcv_nn_st_rec_att
new pcv_nn_st_g_throw
new pcv_nn_st_rec_en
new pcv_nn_st_can_th
new pcv_nn_sp_maxim
new pcv_nn_sp_ground
new pcv_nn_sp_critic
new pcv_nn_sp_energy
new pcv_nn_sp_reload
new pcv_nn_sp_fattack
new pcv_nn_sp_fatshre
new pcv_nn_cl_energy
new pcv_nn_cl_fire
new pcv_nn_cl_knife
new pcv_nn_cl_grenade
new pcv_nn_cl_c4
new pcv_zm_regive

new g_msgScreenFade

// Plugin info holders
new glb_maxplayers
new ShadowIdX:SHADOW_CREATE
new bool:glb_use_new_models = true

// Client general info
new cl_player_model[MAXPLAYERS + 1][32] // player's model name
new bool:cl_update_model[MAXPLAYERS + 1] = {false, ...}
new cl_nn_weapon[MAXPLAYERS + 1]
new bool:cl_is_bot[MAXPLAYERS + 1] = {false, ...}
new bool:cl_nn_lowres[MAXPLAYERS + 1] = {false, ...}
new NanoStatus:cl_nn_has[MAXPLAYERS + 1] = {NANO_NO, ...}
new NanoStatus:cl_nn_had[MAXPLAYERS + 1] = {NANO_NO, ...}
new bool:cl_added_velocity[MAXPLAYERS + 1] = {false, ...}
new bool:cl_removed_shadow[MAXPLAYERS + 1] = {false, ...}
new bool:cl_nn_zombie[MAXPLAYERS + 1] = {false, ...}

// Nanosuit special info
new NanoSpdMode:cl_nn_sp_status[MAXPLAYERS + 1]
new NanoSpeed:cl_nn_speed[MAXPLAYERS + 1]
new NanoSpeedScreen:cl_nn_scr_speed[MAXPLAYERS + 1]
new NanoModes:cl_nn_mode[MAXPLAYERS + 1] = {NANO_ARMOR, ...}
new Float:cl_nn_energy[MAXPLAYERS + 1]
new bool:cl_nn_critical[MAXPLAYERS + 1]
new bool:cl_nn_online[MAXPLAYERS + 1]
new cl_nn_counter[MAXPLAYERS + 1] = {NANO_LOW_RES, ...}
new cl_nn_block_recharge[MAXPLAYERS + 1]
new KnifeState:cl_nn_st_knife[MAXPLAYERS + 1] = {KNIFE_NOT, ...}
new cl_is_thrown[MAXPLAYERS + 1] = {0, ...}
new Float:cl_nn_punch[MAXPLAYERS + 1][3]
new bool:cl_nn_actual_shot[MAXPLAYERS + 1] = {false, ...}
new cl_nn_shotgun_ammo[MAXPLAYERS + 1]

// Needs -> hud + menu + monitor + messages
new nd_menu[MAXPLAYERS + 1]
new nd_hud_sync
new nd_ent_monitor
new nd_msg_saytext
new nd_msg_damage
new nd_msg_iconstatus
new nd_msg_shadowidx
new nd_msg_ammox

public plugin_precache()
{
	precache_sound(sound_armor)
	precache_sound(sound_strengh)
	precache_sound(sound_online)
	precache_sound(sound_speed)
	precache_sound(sound_cloak)
	precache_sound(sound_energy)
	precache_sound(sound_menu)
	precache_sound(sound_strength_throw)
	precache_sound(sound_switch_armor)
	precache_sound(sound_switch_cloak)
	precache_sound(sound_switch_speed)
	precache_sound(sound_switch_strength)
	precache_sound(sound_speed_run)
	
	precache_sound(sound_ric_metal1)
	precache_sound(sound_ric_metal2)
	
	SHADOW_CREATE = ShadowIdX:precache_model("sprites/shadow_circle.spr")
	
}

public plugin_init()
{
	// Register the plugin
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	register_clcmd("say /nanosuit", "nanosuit_menu_show")
	register_clcmd("say_team /nanosuit", "nanosuit_menu_show")
	register_clcmd("nanosuit", "nanosuit_menu_show")
	register_clcmd("say /23s22", "nanosuit_low_res_toggle")
	register_clcmd("/n23123wres", "nanosuit_low_res_toggle")
	register_clcmd("na23wres", "nanosuit_low_res_toggle")
	register_clcmd("n1231y","nanosuit_buy")
	register_clcmd("say /na123uy","nanosuit_buy")
	register_clcmd("say_team /na23uy","nanosuit_buy")
	register_clcmd("33221w2","nanosuit_help")
	register_clcmd("nan324p","nanosuit_help")
	register_clcmd("/234lp","nanosuit_help")
	register_clcmd("say /bindmenu","openmenu")
	register_clcmd("say_team /bindmenu", "openmenu")
	register_clcmd("say bindmenu","openmenu")
	register_clcmd("say_team bindmenu","openmenu")
	register_concmd("get_strength", "give_strength")
	register_concmd("get_armor", "give_armor")
	register_concmd("get_speed", "give_speed")
	register_concmd("get_cloak", "give_cloak")
	
	// The pcvars
	pcv_nn_price      = register_cvar("zp_nanosuit_price","0")
	pcv_nn_death      = register_cvar("zp_nanosuit_death_remove","0")
	pcv_nn_buyzone    = register_cvar("zp_nanosuit_buyzone","0")
	pcv_nn_ff         = get_cvar_pointer("mp_friendlyfire")
	pcv_nn_bot        = register_cvar("zp_nanosuit_bot_allow","0")
	pcv_nn_bot_buy    = register_cvar("zp_nanosuit_bot_buy_mode","0")  // 0 on round start 1 on spawn
	pcv_nn_night	  = register_cvar("zp_nanosuit_nightvision","1")
	pcv_nn_team		  = register_cvar("zp_nanosuit_team_allow","2") // 1 T 2 CT 3 both
	pcv_zm_regive	  = register_cvar("zp_nanosuit_disinfect_regive", "1")
	
	pcv_nn_energy     = register_cvar("zp_nanosuit_energy","100")
	pcv_nn_critical   = register_cvar("zp_nanosuit_critical","3")
	
	pcv_nn_health     = register_cvar("zp_nanosuit_health","100")
	
	pcv_nn_regenerate = register_cvar("zp_nanosuit_regenerate","1.0")
	pcv_nn_hp_charge  = register_cvar("zp_nanosuit_hpcharge","1")
	
	pcv_nn_ar_speed   = register_cvar("zp_nanosuit_armor_speed","1.0")
	pcv_nn_ar_damage  = register_cvar("zp_nanosuit_armor_damage","3.0")
	
	pcv_nn_st_stab    = register_cvar("zp_nanosuit_strength_stab","10")
	pcv_nn_st_throw   = register_cvar("zp_nanosuit_strength_throw","600")
	pcv_nn_st_rec_att = register_cvar("zp_nanosuit_strength_recoil_attenuation","200.0")
	pcv_nn_st_rec_en  = register_cvar("zp_nanosuit_strength_recoil_energy","2.1")
	pcv_nn_st_g_throw = register_cvar("zp_nanosuit_strength_grenade_throw","3.0")
	pcv_nn_st_can_th  = register_cvar("zp_nanosuit_strength_throw_override","1")
	
	pcv_nn_sp_maxim   = register_cvar("zp_nanosuit_speed_maximum","2.3")
	pcv_nn_sp_critic  = register_cvar("zp_nanosuit_speed_critical","1.40")
	pcv_nn_sp_energy  = register_cvar("zp_nanosuit_speed_energy","3.5")
	pcv_nn_sp_fattack = register_cvar("zp_nanosuit_speed_fast_attack", "4.0")
	pcv_nn_sp_fatshre = register_cvar("zp_nanosuit_speed_fast_sh_reload", "2.5")
	pcv_nn_sp_reload  = register_cvar("zp_nanosuit_speed_fast_reload", "5.0")
	pcv_nn_sp_ground  = register_cvar("zp_nanosuit_ground_affect", "1") // 0 normal ground, 1 also crouch, 2 water, 3 water + crouch
	
	pcv_nn_cl_energy  = register_cvar("zp_nanosuit_cloak_energy","0.99")
	pcv_nn_cl_fire    = register_cvar("zp_nanosuit_cloak_punish_weapon_fire","1")
	pcv_nn_cl_knife   = register_cvar("zp_nanosuit_cloak_punish_knife_usage","1")
	pcv_nn_cl_grenade = register_cvar("zp_nanosuit_cloak_punish_grenade_throw","1")
	pcv_nn_cl_c4      = register_cvar("zp_nanosuit_cloak_punish_c4","1")

	g_msgScreenFade = get_user_msgid("ScreenFade")
	
	// Fakemeta forwards
	register_forward(FM_PlayerPreThink, "fw_prethink")
	register_forward(FM_SetModel, "fw_setmodel",1)
	
	if (!glb_use_new_models)
	{
		server_print("[NANO] No models found, not registering the model block forwards!")
	}
	else
	{
		server_print("[NANO] Models found, activating model block forwards!")
		register_forward(FM_SetClientKeyValue, "fw_setclientkey")
		register_event("TeamInfo","event_teaminfo","a")
		register_forward(FM_ClientUserInfoChanged, "fw_clientuserinfochanged")
	}
	
	// Ham forwards (yummy)
	RegisterHam(Ham_CS_RoundRespawn,"player","fw_spawn",1)
	RegisterHam(Ham_Spawn,"player","fw_spawn",1)
	RegisterHam(Ham_Killed,"player","fw_killed")
	RegisterHam(Ham_Player_ResetMaxSpeed,"player","fw_resetmaxspeed",1)
	
	new weapon_name[24]
	
	// Register all weapons for special functions
	for (new i=CSW_P228;i<=CSW_P90;i++)
	{
		if (!(UNREGISTERED_WEAPONS_BITSUM & 1<<i) && get_weaponname(i, weapon_name, charsmax(weapon_name)))
		{
			RegisterHam(Ham_Weapon_PrimaryAttack, weapon_name, "fw_primary_attack")
			RegisterHam(Ham_Weapon_PrimaryAttack, weapon_name, "fw_primary_attack_post",1)
			RegisterHam(Ham_Weapon_SecondaryAttack, weapon_name, "fw_secondary_attack")
			RegisterHam(Ham_Weapon_SecondaryAttack, weapon_name, "fw_secondary_attack_post",1)
			
			if (!(NO_RELOAD_WEAPONS_BITSUM & (1<<i)))
			{
				RegisterHam(Ham_Weapon_Reload, weapon_name, "fw_reload_post", 1)
			}
			else
			{
				if (i != CSW_KNIFE)
				{
					RegisterHam(Ham_Item_Deploy, weapon_name, "fw_shotgun_deploy", 1)
					RegisterHam(Ham_Weapon_Reload, weapon_name, "fw_special_reload_post", 1)
				}
			}
			
			
			format(wpn_ms_icon[i],13,"d_%s",weapon_name[7])
			replace(weapon_name,charsmax(weapon_name),"navy","")
			format(wpn_v_model[i],29,"models/v_%s.mdl",weapon_name[7])
			
		}
		
		if (WEAPONS_WITH_SHIELD_BITSUM & 1<<i)
		{
			format(wpn_v_shield_model[i],49,"models/shield/v_shield_%s.mdl",weapon_name[7])
		}
	}
	
	// Let's add the c4
	format(wpn_v_model[CSW_C4],29,"models/v_c4.mdl")
	
	format(wpn_v_model[CSW_SMOKEGRENADE],29,"models/v_smokegrenade.mdl")
	format(wpn_v_model[CSW_FLASHBANG],29,"models/v_flashbang.mdl")
	format(wpn_v_model[CSW_HEGRENADE],29,"models/v_hegrenade.mdl")
	
	format(wpn_v_shield_model[CSW_SMOKEGRENADE],49,"models/shield/v_shield_smokegrenade.mdl")
	format(wpn_v_shield_model[CSW_FLASHBANG],49,"models/shield/v_shield_flashbang.mdl")
	format(wpn_v_shield_model[CSW_HEGRENADE],49,"models/shield/v_shield_hegrenade.mdl")
	
	get_weaponname(CSW_C4, weapon_name, charsmax(weapon_name))
	
	RegisterHam(Ham_Weapon_PrimaryAttack, weapon_name, "fw_bomb_planting")
	RegisterHam(Ham_Use, "grenade", "fw_bomb_defusing")
	
	
	// In the previous function we didn't register the grenades
	wpn_ms_icon[CSW_HEGRENADE] = 	"d_grenade"
	wpn_ms_icon[CSW_FLASHBANG] = 	"d_grenade"
	wpn_ms_icon[CSW_SMOKEGRENADE] = "d_grenade"
	
	// Global Stuff
	glb_maxplayers = global_get(glb_maxClients)
	
	// Events
	register_event("CurWeapon", "event_active_weapon", "be","1=1")
	register_event("DeathMsg", "event_death", "ae")
	
	register_logevent("event_startround", 2, "1=Round_Start")
	
	
	// Register dictionary (for multilanguage)
	register_dictionary("nanosuit.txt")
	
	// Tolls
	nd_hud_sync = CreateHudSyncObj()
	
	// Message variables
	nd_msg_saytext 		= get_user_msgid("SayText")
	nd_msg_damage 		= get_user_msgid("Damage")
	nd_msg_iconstatus 	= get_user_msgid("StatusIcon")
	nd_msg_shadowidx  	= get_user_msgid("ShadowIdx")
	nd_msg_ammox		= get_user_msgid("AmmoX")
	
	// Hud status display
	nd_ent_monitor = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
	
	if (nd_ent_monitor)
	{
		set_pev(nd_ent_monitor, pev_classname, "screen_status")
		set_pev(nd_ent_monitor, pev_nextthink, get_gametime() + 0.1)
		
		register_forward(FM_Think, "fw_screenthink")
	}
	
	set_task(1.0,"plugin_init_delay",674832)
	set_task(60.0,"nanosuit_msg", 674837, _, _, "b", 0)
}

public openmenu(id)
{
	new menu = menu_create("Nanosuit Binds", "nanobinds")
	menu_additem(menu, "Bind all needed butons.","1", 0)
	menu_additem(menu, "Bind only Z, X, C and V button.","2", 0)
	menu_additem(menu, "Bind only /nanosuit command.","3", 0)
	menu_additem(menu, "Restore to radio binds.","4", 0)
	menu_additem(menu, "No thanks.","5", 0)
	menu_setprop(menu, MPROP_EXIT, MEXIT_NEVER)
	menu_display(id, menu, 0)
}

public nanobinds( id, menu, item )
{
	new iData[ 6 ], szName[ 64 ]
	new access, callback
	menu_item_getinfo( menu, item, access, iData, charsmax( iData ), szName, charsmax( szName ), callback )
	new key = str_to_num( iData )
	switch( key )
	{
		case 1:
		{
			client_cmd(id, "bind k ^"say /nanosuit^"")
			client_cmd(id, "bind z ^"get_strength^"")
			client_cmd(id, "bind x ^"get_armor^"")
			client_cmd(id, "bind v ^"get_speed^"")
			client_cmd(id, "bind c ^"get_cloak^"")
			client_print(id,print_center,"...::: Successfully binded! :::...")
		}
		case 2:
		{
			client_cmd(id, "bind z ^"get_strength^"")
			client_cmd(id, "bind x ^"get_armor^"")
			client_cmd(id, "bind v ^"get_speed^"")
			client_cmd(id, "bind c ^"get_cloak^"")
			client_print(id,print_center,"...::: Successfully binded! :::...")
		}
		case 3:
		{
			client_cmd(id, "bind k ^"say /nanosuit^"")
			client_print(id,print_center,"...::: Successfully binded! :::...")
		}
		case 4:
		{
			client_cmd(id, "bind z ^"radio1^"")
			client_cmd(id, "bind x ^"radio2^"")
			client_cmd(id, "bind c ^"radio3^"")
			client_cmd(id, "unbind v")
			client_print(id,print_center,"...::: Successfully restored! :::...")
		}
		case 5:
		{
			menu_destroy(menu)
			return PLUGIN_HANDLED_MAIN
		}
	}
	menu_destroy(menu)
	return PLUGIN_HANDLED_MAIN
}

public plugin_init_delay(nr)
{
	// Register the takedamage after 1 second to let the other plugins mess with the variables
	RegisterHam(Ham_TakeDamage, "player", "fw_takedamage")
	RegisterHam(Ham_TakeDamage, "player", "fw_takedamage_post", 1)
	RegisterHam(Ham_TraceAttack, "player", "fw_traceattack")
	
	// Speed fix
	server_cmd("sv_maxspeed 99999.0")
}

public client_putinserver(id)
{
	if (is_user_bot(id))
		cl_is_bot[id] = true
	
	if (get_pcvar_num(pcv_nn_price) <= 0)
	{
		if (cl_is_bot[id] && get_pcvar_num(pcv_nn_bot))
			cl_nn_has[id] = NANO_YES
		if (!cl_is_bot[id])
			cl_nn_has[id] = NANO_YES
	}
	else
		cl_nn_has[id] = NANO_NO
}

public client_connect(id)
{
	client_cmd(id,"cl_sidespeed 400")
	client_cmd(id,"cl_forwardspeed 400")
	client_cmd(id,"cl_backspeed 400")
	cl_nn_actual_shot[id] = false
	cl_removed_shadow[id] = false
}

public fw_resetmaxspeed(id)
{
	if (cl_is_thrown[id] != 0)
		set_user_maxspeed(id, 1.0)
	
	if (cl_nn_has[id] == NANO_YES)
	{
		switch (cl_nn_mode[id])
		{
			case NANO_ARMOR:
			{
				set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_ar_speed))
			}
			case NANO_SPEED:
			{
				if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical))
					cl_nn_sp_status[id] = SPEED_MAXIMUM
				if (get_pcvar_float(pcv_nn_critical) >= cl_nn_energy[id] > 0)
					cl_nn_sp_status[id] = SPEED_CRITICAL
				if (0 >= cl_nn_energy[id])
					cl_nn_sp_status[id] = SPEED_NORMAL
				
				switch (cl_nn_sp_status[id])
				{
					case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim))
					case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic))
				}
			}
		}
	}
	
	return PLUGIN_CONTINUE
}

public nanosuit_msg(nr)
{
	static players[32],count,id
	get_players(players,count)
	
	for (new i=0;i<count;i++)
	{
		id = players[i]
		static msg[300]
		colored_msg(id,msg)
	}
	
	return PLUGIN_CONTINUE
}

public client_disconnect(id)
{
	cl_nn_has[id] = NANO_NO
	cl_nn_mode[id] = NANO_ARMOR
	cl_is_bot[id] = false
	cl_added_velocity[id] = false
	nanosuit_reset(id)
}

public nanosuit_low_res_toggle(id)
{
	cl_nn_lowres[id] = !cl_nn_lowres[id]
	
	if (cl_nn_lowres[id])
	{
		msg_statusicon(id,ICON_REMOVE,NanoStatusIcon[cl_nn_mode[id]],NanoScreenColor[cl_nn_mode[id]])
		#if defined USE_WEAPON_STATUSICONS
		msg_statusicon(id,ICON_REMOVE,wpn_ms_icon[cl_nn_weapon[id]],{0,255,0})
		#endif
		client_print(id, print_chat, "%L", id, "NANO_LOWRES_ON")
	}
	else
	{
		if (cl_nn_has[id] == NANO_YES)
		{
			msg_statusicon(id,ICON_SHOW,NanoStatusIcon[cl_nn_mode[id]],NanoScreenColor[cl_nn_mode[id]])
			#if defined USE_WEAPON_STATUSICONS
			if (cl_nn_mode[id] == NANO_CLOAK)
				msg_statusicon(id,ICON_SHOW,wpn_ms_icon[cl_nn_weapon[id]],{0,255,0})
			#endif
		}
		client_print(id, print_chat, "%L", id, "NANO_LOWRES_OFF")
	}
	
	return
}

// Menu System
public nanosuit_menu_create(id)
{
	static text[200]
	
	format(text,199,"%L",id,"NANO_MENU")
	nd_menu[id] = menu_create(text, "nanosuit_menu_choose")
	
	format(text,199,"%L",id,"NANO_ST_MODE")
	menu_additem(nd_menu[id], text)
	format(text,199,"%L",id,"NANO_A_MODE")
	menu_additem(nd_menu[id], text)
	format(text,199,"%L",id,"NANO_S_MODE")
	menu_additem(nd_menu[id], text)
	format(text,199,"%L",id,"NANO_C_MODE")
	menu_additem(nd_menu[id], text)
	
	menu_setprop(nd_menu[id], MPROP_EXIT, MEXIT_NEVER)
}

public nanosuit_menu_show(id)
{
	if (!is_user_alive(id))
		return
	
	if (cl_nn_has[id] == NANO_YES)
	{
		client_cmd(id,"spk %s",sound_menu)
		nanosuit_menu_create(id)
		menu_display(id, nd_menu[id])
		nanosuit_reset(id,false)
		return
	}
}

public nanosuit_menu_choose(id, menu, item)
{
	
	if (item != -3 && cl_nn_mode[id] != NanoModes:item)
	{
		if (cl_nn_mode[id] == NANO_SPEED)
		{
			if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical))
				cl_nn_sp_status[id] = SPEED_MAXIMUM
			if (get_pcvar_float(pcv_nn_critical) >= cl_nn_energy[id] > 0)
				cl_nn_sp_status[id] = SPEED_CRITICAL
			if (0 >= cl_nn_energy[id])
				cl_nn_sp_status[id] = SPEED_NORMAL
			
			switch (cl_nn_sp_status[id])
			{
				case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_maxim))
				case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_critic))
			}
		}
		
		if (NanoModes:item == NANO_SPEED)
		{
			if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical))
				cl_nn_sp_status[id] = SPEED_MAXIMUM
			if (get_pcvar_float(pcv_nn_critical) >= cl_nn_energy[id] > 0)
				cl_nn_sp_status[id] = SPEED_CRITICAL
			if (0 >= cl_nn_energy[id])
				cl_nn_sp_status[id] = SPEED_NORMAL
			
			switch (cl_nn_sp_status[id])
			{
				case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim))
				case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic))
			}
		}
		
		set_nano_mode(id,NanoModes:item)
	}
	
	if (menu != 0)
		menu_destroy(nd_menu[id])
	return PLUGIN_HANDLED
}


// Buy command
public nanosuit_buy(id)
{
	if (cl_nn_has[id] == NANO_YES)
	{
		client_print(id,print_center,"#Cstrike_Already_Own_Weapon")
		return
	}
	
	if (get_pcvar_num(pcv_nn_price) <= 0)
	{
		cl_nn_has[id] = NANO_YES
		nanosuit_reset(id, true)
		
		return
	}
	else
	{
		if (get_pcvar_num(pcv_nn_team) != _:cs_get_user_team(id) && get_pcvar_num(pcv_nn_team) != 3)
		{
			client_print(id,print_center,"You team is not allowed to buy!")
			return
		}
		
		if (get_pcvar_num(pcv_nn_buyzone) && !cs_get_user_buyzone(id))
		{
			client_print(id,print_center,"%L",id,"NANO_BUYZONE")
			return
		}
		
		static money
		money = cs_get_user_money(id)
		static price
		price = get_pcvar_num(pcv_nn_price)
		
		if (money >= price)
		{
			cs_set_user_money(id, money - price)
			
			cl_nn_has[id] = NANO_YES
			nanosuit_reset(id, true)
			
			client_print(id,print_center,"%L",id,"NANO_BUY")
			return
		}
		else
		{
			client_print(id,print_center,"#Cstrike_TitlesTXT_Not_Enough_Money")
			return
		}
	}
	
	return
}

// Help command
public nanosuit_help(id)
{
	static help[3000]
	
	format(help,2999,"%s%s^n",help,html_header)
	
	format(help,2999,"%s%L^n",help,id,"NANO_HTML_BASIC")
	format(help,2999,"%s%L^n",help,id,"NANO_HTML_MODES")
	
	if (get_pcvar_num(pcv_nn_cl_fire))
		format(help,2999,"%s%L^n",help,id,"NANO_HTML_CL_FIRE")
	
	if (get_pcvar_num(pcv_nn_cl_knife))
		format(help,2999,"%s%L^n",help,id,"NANO_HTML_CL_KNIFE")
	
	if (get_pcvar_num(pcv_nn_cl_grenade))
		format(help,2999,"%s%L^n",help,id,"NANO_HTML_CL_NADE")
	
	format(help,2999,"%s%L^n",help,id,"NANO_HTML_ADVICE")
	
	delete_file("nanosuit.htm")
	write_file("nanosuit.htm",help)
	show_motd(id, "nanosuit.htm", "-= Crysis Nanosuit =-")
	return
}

/* ===================================================
[Events]
==================================================== */

public event_teaminfo()
{
	new id
	id = read_data(1)
	
	if (!is_user_connected(id))
	return
	
	fm_reset_user_model(id)
	
	cl_update_model[id] = false
	
	return
}

public event_startround()
{
	if (get_pcvar_num(pcv_nn_bot_buy) || !get_pcvar_num(pcv_nn_bot))
		return PLUGIN_CONTINUE
	
	new players[32], count, id
	get_players(players,count,"ad")
	
	for (new i=0;i<count;i++)
	{
		id = players[i]
		nanosuit_buy(id)
	}
	
	return PLUGIN_CONTINUE
}

public event_active_weapon(id)
{
	new weapon
	weapon = read_data(2)
	
	if (weapon != CSW_KNIFE)
		cl_nn_st_knife[id] = KNIFE_NOT
	
	
	if (weapon != CSW_KNIFE && weapon != CSW_HEGRENADE && weapon != CSW_FLASHBANG && weapon != CSW_SMOKEGRENADE && cl_nn_zombie[id])
	{
		cl_nn_zombie[id] = false
		
		if (cl_nn_had[id] == NANO_YES && get_pcvar_num(pcv_zm_regive))
		{
			cl_nn_has[id] = NANO_YES
			nanosuit_reset(id)
		}
	}
	
	
	if (cl_nn_has[id] == NANO_YES && cl_nn_weapon[id] != weapon)
	{
		#if defined	REMOVE_VIEWMODEL_ON_CLOAK
		if (!cl_is_bot[id] && cl_nn_mode[id] == NANO_CLOAK)
			set_pev(id,pev_viewmodel2,"")
		#endif
		#if defined USE_WEAPON_STATUSICONS
		if (cl_nn_mode[id] == NANO_CLOAK && !cl_is_bot[id] && !equal(wpn_ms_icon[cl_nn_weapon[id]],wpn_ms_icon[weapon]))
		{
			msg_statusicon(id,ICON_REMOVE,wpn_ms_icon[cl_nn_weapon[id]],{0,0,0})
			msg_statusicon(id,ICON_SHOW,wpn_ms_icon[weapon],{0,255,0})
		}
		#endif
		
		if (cl_is_bot[id])
		{
			if (weapon == CSW_KNIFE)
			{
				new hit = -1
				new Float:origin[3]
				pev(id,pev_origin,origin)
				
				while ((hit = engfunc(EngFunc_FindEntityInSphere, hit, origin, 350.0)))
				{
					if (!is_user_alive(hit))
						continue
					
					if ((get_pcvar_num(pcv_nn_ff)) || (!get_pcvar_num(pcv_nn_ff) && cs_get_user_team(id) != cs_get_user_team(hit)))
					{
						nanosuit_menu_choose(id,0,_:NANO_STREN)
						break
					}
				}
			}
		}
	}
	
	cl_nn_weapon[id] = weapon
}

public event_death()
{
	static victim
	victim = read_data(2)
	
	if (victim == 0)
		return 
	
	reset_rendering(victim)
	
	if (get_pcvar_num(pcv_nn_price) > 0 && get_pcvar_num(pcv_nn_death))
	{
		cl_nn_has[victim] = NANO_NO
		nanosuit_reset(victim)
	}
	
	return
}

/* ===================================================
[Fakemeta forwards (fake!)]
==================================================== */
public fw_prethink(id)
{
	if (!is_user_alive(id))
		return FMRES_IGNORED
	
	new Float:origin[3], Float:through[3], Float:vel[3], Float:endpos[3], bool:onground, flags
	
	flags = pev(id, pev_flags)
	
	onground = (flags & ON_LAND_CONST)  ? true : false
	
	pev(id,pev_origin,origin)
	pev(id,pev_velocity,vel)
	
	if (cl_is_thrown[id] && !onground && vel[2] <= -FALL_FALSE_VELOCITY && !cl_added_velocity[id])
	{
		static trace
		trace = create_tr2()
		
		xs_vec_add(origin,Float:{0.0,0.0,-50.0},through)
		
		engfunc(EngFunc_TraceLine,origin,through,IGNORE_MONSTERS, id, trace)
		get_tr2(trace,TR_vecEndPos,endpos)
		xs_vec_sub(endpos,origin,endpos)
		xs_vec_sub(through,origin,through)
		
		if (vector_length(through) != vector_length(endpos))
		{
			vel[2] += FALL_FALSE_VELOCITY - FALL_TRUE_VELOCITY
			cl_added_velocity[id] = true
			set_pev(id,pev_velocity,vel)
		}
		
		free_tr2(trace)
	}
	
	if (cl_is_thrown[id] && onground)
	{
		cl_added_velocity[id] = false
		cl_is_thrown[id] = 0
		
		ExecuteHamB(Ham_Player_ResetMaxSpeed, id)
	}
	
	if (cl_is_bot[id] && cl_nn_has[id] == NANO_YES && !get_pcvar_num(pcv_nn_bot))
	{
		cl_nn_has[id] = NANO_NO
		nanosuit_reset(id)
	}
	
	static Float:health
	pev(id,pev_health,health)
	
	if (cl_is_bot[id] && cl_nn_has[id] == NANO_YES && health < 60.0)
		nanosuit_menu_choose(id,0,_:NANO_ARMOR)
	
	if (cl_nn_has[id] == NANO_YES)
		nanosuit_functions(id)

	// Maximum Speed
	if (cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED)
	{
				if (cl_nn_energy[id] < 100)
					set_pev(id, pev_maxspeed, 420.0)

				if (cl_nn_energy[id] < 10)
				{
					set_pev(id, pev_maxspeed, 240.0)

					message_begin(MSG_ONE, g_msgScreenFade, _, id)
					write_short((1<<12)*2) // duration
					write_short(0) // hold time
					write_short(0x0000) // fade type
					write_byte(250) // r
					write_byte(250) // g
					write_byte(0) // b
					write_byte(50) // nvg Alpha
					message_end()
				}
	}
	
	// Run
	new Float:speed
	speed  = vector_length(vel)
	new Float:mspeed
	mspeed = get_user_maxspeed(id)
	
	if (get_pcvar_num(pcv_nn_sp_ground) & NANO_FLAG_INWATER && flags & ON_WATER_CONST)
		mspeed *= SPEED_WATER_MUL_CONSTANT
	
	if (get_pcvar_num(pcv_nn_sp_ground) & NANO_FLAG_CROUCHED && flags & FL_DUCKING)
		mspeed *= SPEED_CROUCH_MUL_CONSTANT
	
	// Remember the speed
	if (speed ==         0.0)		cl_nn_speed[id] = SPD_STILL
	if (speed >			 0.0)		cl_nn_speed[id] = SPD_VSLOW
	if (speed > 0.4 * mspeed)		cl_nn_speed[id] = SPD_SLOW
	if (speed > 0.6 * mspeed)		cl_nn_speed[id] = SPD_NORMAL
	if (speed > 0.9 * mspeed)		cl_nn_speed[id] = SPD_FAST
	
	if (speed < 0.6 * mspeed && cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED)	
		set_pev(id,pev_flTimeStepSound,100)
	
	// Screen display
	if (speed ==  0.0)				cl_nn_scr_speed[id] = SPD_SCR_STILL
	if (speed >	  0.0)				cl_nn_scr_speed[id] = SPD_SCR_VSLOW
	if (speed > 100.0)				cl_nn_scr_speed[id] = SPD_SCR_SLOW
	if (speed > 200.0)				cl_nn_scr_speed[id] = SPD_SCR_NORMAL
	if (speed > 265.0)				cl_nn_scr_speed[id] = SPD_SCR_FAST
	
	return FMRES_IGNORED
}

public fw_setmodel(ent, const model[])
{
	if (!pev_valid(ent))
		return FMRES_IGNORED
	
	new Float:gravity
	pev(ent,pev_gravity,gravity)
	
	if (gravity == 0.0)
		return FMRES_IGNORED
	
	new owner
	owner = pev(ent,pev_owner)
	
	if (!(cl_nn_has[owner] == NANO_YES))
		return FMRES_IGNORED
	
	new classname[8]
	
	pev(ent,pev_classname,classname,7)
	
	if (equal("grenade",classname,7) && cl_nn_mode[owner] == NANO_CLOAK && get_pcvar_num(pcv_nn_cl_grenade))
	{
		set_nano_energy(owner,0.0,DELAY_CLK_FORCED)
		return FMRES_IGNORED
	}
	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))
	{
		new Float:v[3], Float:v2[3]
		pev(ent,pev_velocity,v)
		velocity_by_aim(owner, GRENADE_STR_THROW_ADD, v2)
		xs_vec_add(v, v2, v)
		set_pev(ent,pev_velocity,v)
		set_nano_energy(owner,cl_nn_energy[owner] - get_pcvar_float(pcv_nn_st_g_throw),DELAY_STR_G_THROW)
		return FMRES_IGNORED
	}
	
	return FMRES_IGNORED
}

public fw_setclientkey(id,const infobuffer[],const key[])
{   
	// Block CS model changes
	if (cl_nn_has[id] == NANO_YES && equal(key, "model"))
		return FMRES_SUPERCEDE
	
	return FMRES_IGNORED
}

public fw_clientuserinfochanged(id)
{
	if (!is_user_connected(id))
		return FMRES_IGNORED
	
	// Get current model
	new currentmodel[32]
	fm_get_user_model(id, currentmodel, charsmax(currentmodel))
	
	// Check whether it matches the custom model - if not, set it again
	if (!equal(currentmodel, cl_player_model[id]))
	{
		if (cl_nn_has[id] == NANO_YES)
		{
			switch (cs_get_user_team(id))
			{
				case CS_TEAM_CT:
				{
					for (new i=0;i<5;i++)
					{
						if (equali(currentmodel,vec_model_ct[i]))
						{
							cl_update_model[id] = true
							copy(cl_player_model[id], 31, currentmodel)
							return FMRES_SUPERCEDE
						}
					}
				}
				case CS_TEAM_T:
				{
					for (new i=0;i<4;i++)
					{
						if (equali(currentmodel,vec_model_t[i]))
						{
							cl_update_model[id] = true
							copy(cl_player_model[id], 31, currentmodel)
							return FMRES_SUPERCEDE
						}
					}
				}
			}
		}
		else
		{
			switch (cs_get_user_team(id))
			{
				case CS_TEAM_CT:
				{
					for (new i=0;i<5;i++)
					{
						if (equali(currentmodel,vec_model_ct[i]))
						{
							fm_set_user_model(id,currentmodel)
							return FMRES_SUPERCEDE
						}
					}
					
					fm_reset_user_model(id)
				}
				case CS_TEAM_T:
				{
					for (new i=0;i<4;i++)
					{
						if (equali(currentmodel,vec_model_t[i]))
						{
							fm_set_user_model(id,currentmodel)
							return FMRES_SUPERCEDE
						}
					}
					
					fm_reset_user_model(id)
				}
				default: fm_reset_user_model(id)
			}
		}
	}
	
	return FMRES_SUPERCEDE
}

/* ===================================================
[Ham forwards chapter (yummy)]
==================================================== */
public fw_primary_attack(ent)
{
	new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
	
	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)
	{
		set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_st_stab), DELAY_STR_STAB)
		cl_nn_st_knife[id] = KNIFE_FIRST_ATTACK
		client_cmd(id,"spk %s",sound_strength_throw)
	}
	
	pev(id,pev_punchangle,cl_nn_punch[id])
	
	if (cl_nn_mode[id] == NANO_CLOAK)
	{
		if (cl_nn_weapon[id] == CSW_KNIFE &&  get_pcvar_num(pcv_nn_cl_knife))
		{
			set_nano_mode(id,NANO_ARMOR)
		}
		
		if (cl_nn_weapon[id] != CSW_KNIFE && get_pcvar_num(pcv_nn_cl_fire))
		{
			set_nano_mode(id,NANO_ARMOR)
		}
	}
	
	new ammo,clip
	get_user_ammo(id, cl_nn_weapon[id], ammo, clip)
	
	if (cs_get_weapon_id(ent) == CSW_M3 || cs_get_weapon_id(ent) == CSW_XM1014)
		cl_nn_shotgun_ammo[id] = ammo
	else
		cl_nn_shotgun_ammo[id] = -1
	
	if (ammo != 0)
		cl_nn_actual_shot[id] = true
	
	return HAM_IGNORED
}

public fw_primary_attack_post(ent)
{
	new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
	
	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))
	{
		new Float:push[3]
		pev(id,pev_punchangle,push)
		xs_vec_sub(push,cl_nn_punch[id],push)
		xs_vec_div_scalar(push,get_pcvar_float(pcv_nn_st_rec_att),push)
		xs_vec_add(push,cl_nn_punch[id],push)
		set_pev(id,pev_punchangle,push)
		set_nano_energy(id,cl_nn_energy[id] - get_pcvar_float(pcv_nn_st_rec_en), DELAY_STR_SHOT)
	}
	
	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))
	{
		new Float:multi
		multi = 1.0
		switch (cl_nn_weapon[id])
		{
			case CSW_DEAGLE,CSW_ELITE,CSW_FIVESEVEN,CSW_P228,CSW_USP,CSW_GLOCK18:
			{
				multi = REFIRE_PISTOLS
			}
			case CSW_M3:
			{
				multi = REFIRE_M3
			}
			case CSW_KNIFE:
			{
				multi = REFIRE_KNIFE
				static Float:M_Delay
				M_Delay = get_pdata_float(ent, OFFSET_WEAPON_NEXT_SEC_ATTACK, EXTRA_OFFSET_WEAPON_LINUX) * multi
				set_pdata_float(ent, OFFSET_WEAPON_NEXT_SEC_ATTACK, M_Delay,  EXTRA_OFFSET_WEAPON_LINUX)
			}
			case CSW_SCOUT,CSW_AWP:
			{
				multi = REFIRE_SNIPERS
			}
		}
		
		if (multi != 1.0)
			set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_sp_fattack),DELAY_SPD_FAST_ATTACK)
		
		new	Float:Delay
		
		Delay = get_pdata_float( ent, OFFSET_WEAPON_NEXT_PRIMARY_ATTACK,  EXTRA_OFFSET_WEAPON_LINUX) * multi
		set_pdata_float( ent, OFFSET_WEAPON_NEXT_PRIMARY_ATTACK, Delay,  EXTRA_OFFSET_WEAPON_LINUX)
	}
	
	cl_nn_actual_shot[id] = false
	return HAM_IGNORED
}

public fw_secondary_attack(ent)
{
	new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
	
	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)
	{
		set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_st_stab), DELAY_STR_STAB)
		cl_nn_st_knife[id] = KNIFE_SECOND_ATTACK
		client_cmd(id,"spk %s",sound_strength_throw)
	}
	
	if (cl_nn_mode[id] == NANO_CLOAK)
	{
		if (cl_nn_weapon[id] == CSW_KNIFE &&  get_pcvar_num(pcv_nn_cl_knife))
		{
			set_nano_mode(id,NANO_ARMOR)
			return HAM_IGNORED
		}
	}
	
	return HAM_IGNORED
}

public fw_secondary_attack_post(ent)
{
	new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
	
	if (cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_critical))
	{
		new Float:multi = 1.0
		switch (cl_nn_weapon[id])
		{
			case CSW_KNIFE:
			{
				multi = REFIRE_KNIFE
				new	Float:mdelay
				mdelay = get_pdata_float( ent, OFFSET_WEAPON_NEXT_SEC_ATTACK, EXTRA_OFFSET_WEAPON_LINUX) * multi
				set_pdata_float( ent, OFFSET_WEAPON_NEXT_SEC_ATTACK, mdelay, EXTRA_OFFSET_WEAPON_LINUX)
			}
		}
		if (multi != 1.0)
			set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_sp_fattack),DELAY_SPD_FAST_ATTACK)
		
		new	Float:delay
		delay = get_pdata_float( ent, OFFSET_WEAPON_NEXT_PRIMARY_ATTACK, EXTRA_OFFSET_WEAPON_LINUX) * multi
		set_pdata_float( ent, OFFSET_WEAPON_NEXT_PRIMARY_ATTACK, delay, EXTRA_OFFSET_WEAPON_LINUX)
	}
	return HAM_IGNORED
}

public fw_shotgun_deploy(ent)
{
	new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
	cl_nn_shotgun_ammo[id] = cs_get_weapon_ammo(ent)
}

public fw_special_reload_post(ent)
{
	new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
	
	new wpn_id	= cs_get_weapon_id(ent)
	new maxammo = wpn_max_clip[wpn_id]
	new curammo = cs_get_weapon_ammo(ent)
	
	if (cl_nn_shotgun_ammo[id] == -1)
	{
		cl_nn_shotgun_ammo[id] = curammo
		return HAM_IGNORED
	}
	else
	{
		if (!(cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_critical)))
		{
			cl_nn_shotgun_ammo[id] = curammo
			return HAM_IGNORED
		}
		
		if (curammo < cl_nn_shotgun_ammo[id])
			cl_nn_shotgun_ammo[id] = curammo
		
		if (curammo - cl_nn_shotgun_ammo[id] == SH_CARTRAGE_RATIO && cs_get_user_bpammo(id, wpn_id) && curammo + 1 <= maxammo)
		{
			cs_set_weapon_ammo(ent, curammo + 1)
			cs_set_user_bpammo(id, wpn_id, cs_get_user_bpammo(id, wpn_id) - 1)
			cl_nn_shotgun_ammo[id] = curammo + 1
			
			set_nano_energy(id, cl_nn_energy[id] - get_pcvar_float(pcv_nn_sp_fatshre), DELAY_SPD_SH_RELOAD)
			
			// Update hud weapon info, emessage to be blocked if needed
			emessage_begin(MSG_ONE, nd_msg_ammox, {0,0,0}, id)
			ewrite_byte(SH_AMMO_MSG_AMMOID)
			ewrite_byte(curammo + 1)
			emessage_end()
			
		}
	}
	
	return HAM_IGNORED
	
}

public fw_reload_post(ent)
{
	if(get_pdata_int(ent, OFFSET_WEAPON_IN_RELOAD, EXTRA_OFFSET_WEAPON_LINUX))
	{
		new id = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
		
		cl_nn_shotgun_ammo[id] = -1
		
		if (cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_SPEED && cl_nn_energy[id] >= get_pcvar_float(pcv_nn_critical))
		{
			new Float:delay = wpn_reload_delay[get_pdata_int(ent, OFFSET_WEAPON_ID, EXTRA_OFFSET_WEAPON_LINUX)] * RELOAD_RATIO
			
			set_pdata_float(id, OFFSET_PLAYER_NEXT_ATTACK, delay, EXTRA_OFFSET_PLAYER_LINUX)
			set_pdata_float(ent, OFFSET_WEAPON_IDLE_TIME, delay + 0.5, EXTRA_OFFSET_WEAPON_LINUX)
			
			set_nano_energy(id,cl_nn_energy[id] - get_pcvar_float(pcv_nn_sp_reload),DELAY_SPD_FAST_RELOAD)
		}
	}
	
	return HAM_IGNORED
}

public fw_spawn(id)
{
	if (is_user_alive(id))
	{
		msg_shadowidx(id,SHADOW_CREATE)
		nanosuit_reset(id,true)
		cl_nn_zombie[id] = false
		
		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)
		{
			if (!zp_get_user_zombie(id))
			{
				cl_nn_has[id] = NANO_YES
				nanosuit_reset(id,true)
			}
		}
		
		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))
			nanosuit_buy(id)
	}
	
	return HAM_IGNORED
}

public fw_killed(id,attacker,gib)
{
	if (cl_nn_has[id] == NANO_YES)
	{
		msg_statusicon(id,ICON_REMOVE,NanoStatusIcon[cl_nn_mode[id]],NanoScreenColor[cl_nn_mode[id]])
		#if defined USE_WEAPON_STATUSICONS
		msg_statusicon(id,ICON_REMOVE,wpn_ms_icon[cl_nn_weapon[id]],{0,255,0})
		#endif
	}
	
	return HAM_IGNORED
}

public fw_traceattack(victim, attacker, Float:damage, Float:direction[3], tr, damagebits)
{
	new hitzone
	hitzone = get_tr2(tr,TR_iHitgroup)
	damage *= vec_hit_multi[hitzone]
	new Float:origin[3]
	pev(attacker,pev_origin,origin)
	new use_strength
	use_strength = 0
	
	if (is_user_player(attacker))
	{
		// Strength Mode
		if (get_pcvar_num(pcv_nn_ff))
		{
			if (cs_get_user_team(victim) == cs_get_user_team(attacker))
			{
				damage /= 0.4
				use_strength = 2
			}
			else
			{
				use_strength = 1
			}
		}
		else
		{
			if (cs_get_user_team(victim) == cs_get_user_team(attacker))
			{
				if (get_pcvar_num(pcv_nn_st_can_th))
					use_strength = 1
			}
			else
			{
				use_strength = 1
			}
		}
		
		if (use_strength && cl_nn_has[attacker] == NANO_YES && cl_nn_mode[attacker] == NANO_STREN && CSW_KNIFE == cl_nn_weapon[attacker])
		{
			damage *= 0.5
			
			if (cl_nn_st_knife[attacker] == KNIFE_FIRST_ATTACK)
			{
				new Float:origin[3], Float:origin2[3], Float:throw[3], Float:aimvel[3]
				
				// Get the origin of attacker and victim
				pev(victim,pev_origin,origin)
				pev(attacker,pev_origin,origin2)
				velocity_by_aim(attacker,2,aimvel)
				
				// We need to make a vector between them and we multiply it's value so we can make it powerfull
				xs_vec_sub(origin,origin2,throw)
				xs_vec_div_scalar(throw,xs_vec_len(throw),throw)
				xs_vec_add(throw,aimvel,throw)
				xs_vec_div_scalar(throw,xs_vec_len(throw),throw)
				throw[2] += 0.6
				xs_vec_mul_scalar(throw,get_pcvar_float(pcv_nn_st_throw),throw)
				
				// We add it to the velocity so we can make it a throw
				set_pev(victim,pev_velocity,throw)
				
				// We block the speed of the player so he can't influence the direction of the throw (too much :P)
				set_user_maxspeed(victim, 1.0)
				cl_is_thrown[victim] = attacker
				set_pev(victim,pev_flags,pev(victim,pev_flags) & ~FL_ONGROUND)
			}
			
			cl_nn_st_knife[attacker] = KNIFE_NOT
		}
	}
	
	// Armor Mode
	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)))))
	{
		if ((get_tr2(tr,TR_iHitgroup) != 8) && cl_nn_has[victim] == NANO_YES && cl_nn_mode[victim] == NANO_ARMOR)
		{
			damage *= get_pcvar_float(pcv_nn_ar_damage)
			
			if (damage < cl_nn_energy[victim])
			{
				set_nano_energy(victim, cl_nn_energy[victim] - damage, DELAY_ARM_DAMAGE)
				set_tr2(tr,TR_iHitgroup,8)
				static Float:vec_end_pos[3]
				get_tr2(tr,TR_vecEndPos,vec_end_pos)
				
				if (hitzone != HIT_GENERIC)
					draw_spark(vec_end_pos)
				
				
				if (random(2) > 0)
				{
					engfunc(EngFunc_EmitSound,victim,CHAN_AUTO,sound_ric_metal1, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)	
				}
				else
				{
					engfunc(EngFunc_EmitSound,victim,CHAN_AUTO,sound_ric_metal2, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)	
				}
				
				set_pev(victim,pev_dmg_inflictor,attacker)
				emsg_damage(victim,0,floatround(damage),damagebits,origin)
				damage = 0.0
			}
			else
			{
				damage -= cl_nn_energy[victim]
				set_nano_energy(victim, 0.0, DELAY_ARM_DAMAGE)
			}
		}
	}
	
	if (use_strength == 2)
		damage *= 2.0
	
	if (hitzone != 8 && damage != 0.0)
		damage /= vec_hit_multi[hitzone]
	
	SetHamParamTraceResult(5,tr)
	SetHamParamFloat(3,damage)
	return HAM_HANDLED
}


public fw_takedamage(victim, inflictor, attacker, Float:damage, damagebits)
{
	new Float:origin[3]
	pev(inflictor,pev_origin,origin)
	
	if (damagebits == DMG_FALL && cl_is_thrown[victim])
	{
		damage *= DMG_FALL_MULTIPLY
		attacker = cl_is_thrown[victim]
		SetHamParamEntity(3, attacker)
	}

	// Armor Mode
	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)))))
	{
		damage *= get_pcvar_float(pcv_nn_ar_damage)
		
		if (damage < cl_nn_energy[victim])
		{
			set_nano_energy(victim, cl_nn_energy[victim] - damage, DELAY_ARM_DAMAGE)
			set_pev(victim,pev_dmg_inflictor,inflictor)
			emsg_damage(victim,0,floatround(damage),damagebits,origin)
			damage = 0.0
		}
		else
		{
			damage -= cl_nn_energy[victim]
			set_nano_energy(victim, 0.0, DELAY_ARM_DAMAGE)
		}
	}

	if (cl_nn_has[attacker] == NANO_YES && cl_nn_mode[attacker] == NANO_STREN)
	{
				if (cl_nn_energy[attacker] < 100)
						damage *= 2.0


				if (cl_nn_energy[attacker] < 12)
						damage *= 1.0
	}
	
	SetHamParamFloat(4,damage)
	return HAM_HANDLED
}

public fw_takedamage_post(victim, inflictor, attacker, Float:damage, damagebits)
{
	if (cl_nn_has[victim] == NANO_YES && cl_nn_mode[victim] == NANO_ARMOR)
	{
		new Float: painshock = get_pdata_float(victim, OFFSET_PLAYER_PAIN_SHOCK, EXTRA_OFFSET_PLAYER_LINUX)
		
		if (painshock == 1.0)
			return HAM_IGNORED
		
		painshock = (1.0 - ((1.0 - painshock) * PAIN_SHOCK_ATTENUATION))
		
		set_pdata_float(victim, OFFSET_PLAYER_PAIN_SHOCK, painshock, EXTRA_OFFSET_PLAYER_LINUX)
	}

	return HAM_IGNORED
}

public fw_bomb_planting(ent)
{
	new planter
	planter = get_pdata_cbase(ent, OFFSET_WEAPON_OWNER, EXTRA_OFFSET_WEAPON_LINUX)
	
	if (cl_nn_has[planter] == NANO_YES && cl_nn_mode[planter] == NANO_CLOAK && get_pcvar_num(pcv_nn_cl_c4))
	{
		set_nano_energy(planter,0.0,DELAY_CLK_FORCED)
	}
	
	return HAM_IGNORED
}

public fw_bomb_defusing(ent, caller, activator, use_type, Float:value)
{
	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)
	{
		set_nano_energy(caller,0.0,DELAY_CLK_FORCED)
	}
	
	return HAM_IGNORED
}

/* ===================================================
[Screen think of all players]
==================================================== */
public fw_screenthink(ent)
{
	if (!pev_valid(ent))
		return FMRES_IGNORED
	
	if (ent != nd_ent_monitor)
		return FMRES_IGNORED
	
	new players[32], count, id
	new Float:energy
	energy = get_pcvar_float(pcv_nn_energy)
	
	get_players(players, count, "ac")
	
	for (new i=0;i<count;i++)
	{
		id = players[i]
		
		if (cl_nn_has[id] == NANO_YES && ((cl_nn_lowres[id] && cl_nn_counter[id] == 0) || !cl_nn_lowres[id]))
		{
			// Current Mode
			static hud[200]
			
			formatex(hud, 199, "%L",id,"NANO_MODE")
			
			switch (cl_nn_mode[id])
			{
				case NANO_STREN: formatex(hud, 199, "%s %L /",hud,id,"NANO_ST_MODE")
				case NANO_ARMOR: formatex(hud, 199, "%s %L /",hud,id,"NANO_A_MODE")
				case NANO_SPEED: formatex(hud, 199, "%s %L /",hud,id,"NANO_S_MODE")
				case NANO_CLOAK: formatex(hud, 199, "%s %L /",hud,id,"NANO_C_MODE")
			}
			
			formatex(hud, 199, "%L",id,"NANO_ENERGY", hud, floatround(cl_nn_energy[id] / energy * 100))
			
			for (new x = 0; x < floatround(cl_nn_energy[id] / energy * 20); x++)
				formatex(hud, 199, "%s", hud)
			
			formatex(hud, 199, "%s^n", hud)
			
			// Health, Armor, Speed
			formatex(hud, 199, "%L",id,"NANO_POINTS", hud, get_user_health(id), get_user_armor(id))
			
			switch (cl_nn_scr_speed[id])
			{
				case SPD_SCR_STILL:  formatex(hud, 199, "%L",id,"NANO_SPD_ST", hud)
				case SPD_SCR_VSLOW:  formatex(hud, 199, "%L",id,"NANO_SPD_VS", hud)
				case SPD_SCR_SLOW:   formatex(hud, 199, "%L",id,"NANO_SPD_SL", hud)
				case SPD_SCR_NORMAL: formatex(hud, 199, "%L",id,"NANO_SPD_NO", hud)
				case SPD_SCR_FAST:   formatex(hud, 199, "%L",id,"NANO_SPD_FA", hud)
			}
			
			if (!cl_nn_lowres[id])
			{
				set_hudmessage(NanoScreenColor[cl_nn_mode[id]][0], NanoScreenColor[cl_nn_mode[id]][1], NanoScreenColor[cl_nn_mode[id]][2], -1.0, 0.80, 0, 0.0, 0.2, 0.0, 0.0)
				ShowSyncHudMsg(id, nd_hud_sync, "%s", hud)
			}
			else
			{
				set_hudmessage(NanoScreenColor[cl_nn_mode[id]][0], NanoScreenColor[cl_nn_mode[id]][1], NanoScreenColor[cl_nn_mode[id]][2], -1.0, 0.80, 0, 0.0, (0.2 + (0.1 * float(NANO_LOW_RES))), 0.0, 0.0)
				ShowSyncHudMsg(id, nd_hud_sync, "%s", hud)
			}
		}
		
		if (cl_nn_counter[id] > 0)
			cl_nn_counter[id] -= 1
		else
			cl_nn_counter[id] = NANO_LOW_RES
	}
	
	set_pev(ent, pev_nextthink, get_gametime() + 0.1)
	
	return FMRES_IGNORED
}

/* ===================================================
[Energy manipulation task]
==================================================== */
public set_energy(id)
{
	id -= TASK_ENERGY
	
	if (!(cl_nn_has[id] == NANO_YES))
	{
		remove_task(id + TASK_ENERGY)
		return PLUGIN_CONTINUE
	}
	
	if (!is_user_alive(id))
	{
		return PLUGIN_CONTINUE
	}
	
	new NanoModes:active = cl_nn_mode[id]
	new Float:energy = cl_nn_energy[id]
	
	// Decrease when player is running in speed mode
	if (active == NANO_SPEED && pev(id,pev_flags) & ON_LAND_CONST)
	{
		new Float:multi
		
		switch (cl_nn_sp_status[id])
		{
			case SPEED_NORMAL:
			{
				switch (cl_nn_speed[id])
				{
					case SPD_STILL: multi = 0.0
					case SPD_VSLOW: multi = 0.0
					case SPD_SLOW: multi = 0.0
					case SPD_NORMAL: multi = 1.0
					case SPD_FAST: multi = 1.0
				}
				
				energy -= (0.1) * multi
			}
			case SPEED_CRITICAL:
			{
				switch (cl_nn_speed[id])
				{
					case SPD_STILL: multi = 0.0
					case SPD_VSLOW: multi = 0.0
					case SPD_SLOW: multi = 0.0
					case SPD_NORMAL: multi = 0.0
					case SPD_FAST: multi = 1.0
				}
				
				energy -= (0.2) * multi
			}
			case SPEED_MAXIMUM:
			{
				switch (cl_nn_speed[id])
				{
					case SPD_STILL: multi = 0.0
					case SPD_VSLOW: multi = 0.0
					case SPD_SLOW: multi = 0.0
					case SPD_NORMAL: multi = 0.0
					case SPD_FAST:
					{
						multi = 1.0
						client_cmd(id, "speak %s", sound_speed_run)
					}
				}
				
				energy -= get_pcvar_float(pcv_nn_sp_energy) * multi
			}
		}
		
		if (multi != 0.0)
			cl_nn_block_recharge[id] = DELAY_SPD_RUN + 1
	}
	
	// Decrease in cloak mode
	if (active == NANO_CLOAK)
	{		
		static Float:multi = 1.0
		
		switch (cl_nn_speed[id])
		{
			case SPD_STILL: multi = 0.1
			case SPD_VSLOW: multi = 0.2
			case SPD_SLOW: multi = 0.5
			case SPD_NORMAL: multi = 1.0
			case SPD_FAST: multi = 1.4
		}
		
		energy -= get_pcvar_float(pcv_nn_cl_energy) * multi
	}
	
	if (energy < get_pcvar_num(pcv_nn_critical) && !cl_nn_critical[id])
	{
		cl_nn_critical[id] = true
		cl_nn_online[id] = true
		
		if (!cl_is_bot[id])
		{
			client_cmd(id, "spk %s", sound_energy)
			client_print(id, print_center, "%L", id, "NANO_CRITIC")
		}
	}

	if (energy >= 100 && cl_nn_online[id])
	{	
		if (!cl_is_bot[id])
		{
			client_cmd(id, "spk %s", sound_online)
			client_print(id, print_center, "-= All systems Online =-")
			cl_nn_online[id] = false
		}
	}
	
	if (energy <= 0.0)
	{
		if (active == NANO_CLOAK)
		{
			cl_nn_block_recharge[id] = DELAY_CLK_DELAY
			set_nano_mode(id,NANO_ARMOR)
			#if defined REMOVE_VIEWMODEL_ON_CLOAK
			if (!cl_is_bot[id])
			{
				if (cs_get_user_shield(id) && (WEAPONS_WITH_SHIELD_BITSUM & 1<<cl_nn_weapon[id]))
				{
					set_pev(id,pev_viewmodel2,wpn_v_shield_model[cl_nn_weapon[id]])
				}
				else
					set_pev(id,pev_viewmodel2,wpn_v_model[cl_nn_weapon[id]])
			}
			#endif
		}
		
		energy = 0.0
	}
	
	// Increase but not when in cloak mode
	if (energy < get_pcvar_float(pcv_nn_energy) && cl_nn_mode[id] != NANO_CLOAK && cl_nn_block_recharge[id] == 0)
	{
		static Float:energy2
		energy2 = get_pcvar_float(pcv_nn_regenerate)
		
		if (pev(id,pev_button) & IN_DUCK && cl_nn_speed[id] == SPD_FAST)
			energy2 *= ENERGY_CROUCH
		
		energy2 += energy
		
		// Useful to block the moment when a player energy is bigger than the maximum energy
		energy = floatmin(get_pcvar_float(pcv_nn_energy), energy2)
		
		if (energy > get_pcvar_float(pcv_nn_critical) + CRITICAL_EXTRA_ADD)
			cl_nn_critical[id] = false
	}
	// White
	if (cl_nn_has[id] == NANO_YES && cl_nn_mode[id] == NANO_CLOAK)
	{
		message_begin(MSG_ONE, g_msgScreenFade, _, id)
		write_short((1<<12)*2) // duration
		write_short(0) // hold time
		write_short(0x0000) // fade type
		write_byte(200) // r
		write_byte(200) // g
		write_byte(200) // b
		write_byte(70) // nvg Alpha
		message_end()
	}

	
	if (cl_nn_block_recharge[id] > 0)
		cl_nn_block_recharge[id] -= 1
	
	cl_nn_energy[id] = energy
	
	return PLUGIN_CONTINUE
}

/* ===================================================
[Armor and HitPoints nano recharge]
==================================================== */
public nanosuit_ah_charge(id)
{
	id -= TASK_AH_REC
	
	if (!(cl_nn_has[id] == NANO_YES))
	{
		remove_task(id + TASK_AH_REC)
		return PLUGIN_CONTINUE
	}
	
	if (!is_user_alive(id))
	{
		return PLUGIN_CONTINUE
	}
	
	static Float:health
	pev(id,pev_health,health)
	
	if (floatround(health,floatround_floor) < get_pcvar_num(pcv_nn_health) && cl_nn_block_recharge[id] == 0)
		set_user_health(id, min(get_pcvar_num(pcv_nn_health), get_user_health(id) + get_pcvar_num(pcv_nn_hp_charge)))
	
	return PLUGIN_CONTINUE
}

/* ===================================================
[Nanosuit prethink functions]
==================================================== */
public nanosuit_functions(id)
{
	if (cl_nn_mode[id] == NANO_SPEED)
	{
		if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical))
		{
			if (cl_nn_sp_status[id] == SPEED_NORMAL)
			{
				set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim))
			}
			if (cl_nn_sp_status[id] == SPEED_CRITICAL)
			{
				set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim) / get_pcvar_float(pcv_nn_sp_critic))
			}
			
			cl_nn_sp_status[id] = SPEED_MAXIMUM
		}
		if (get_pcvar_float(pcv_nn_critical) >= cl_nn_energy[id] > 0)
		{
			if (cl_nn_sp_status[id] == SPEED_NORMAL)
			{
				set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic))
			}
			if (cl_nn_sp_status[id] == SPEED_MAXIMUM)
			{
				set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic) / get_pcvar_float(pcv_nn_sp_maxim))
			}
			
			cl_nn_sp_status[id] = SPEED_CRITICAL
		}
		if (0 >= cl_nn_energy[id])
		{
			if (cl_nn_sp_status[id] == SPEED_MAXIMUM)
			{
				set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_maxim))
			}
			if (cl_nn_sp_status[id] == SPEED_CRITICAL)
			{
				set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_critic))
			}
			
			cl_nn_sp_status[id] = SPEED_NORMAL
		}
		
		return
	}
	
	if (cl_nn_mode[id] == NANO_STREN)
		set_pev(id, pev_fuser2, 1.2)
	
	if (!is_glowing_in_nano(id))
	{
		set_nano_glow(id)
	}
	
	return
}

/* ===================================================
[Bot think task, allows bots to use the nano functions]
==================================================== */
public nanosuit_bot_think(id)
{
	id -= TASK_AI
	
	if (!is_user_alive(id))
		return PLUGIN_CONTINUE
	
	if (!cl_is_bot[id])
	{
		remove_task(id + TASK_AI)
		return PLUGIN_CONTINUE
	}
	
	new Float:health
	pev(id,pev_health,health)
	
	if (health < 60.0)
	{
		nanosuit_menu_choose(id,0,_:NANO_ARMOR)
		return PLUGIN_CONTINUE
	}
	
	new hit = -1
	new Float:origin[3]
	pev(id,pev_origin,origin)
	new Float:velocity[3]
	pev(id,pev_velocity,velocity)
	vector_length(velocity)
	
	if (cl_nn_energy[id] > get_pcvar_float(pcv_nn_critical) && floatround(vector_length(velocity)) <= 20)
	{
		nanosuit_menu_choose(id,0,_:NANO_CLOAK)
		return PLUGIN_CONTINUE
	}
	
	if (cl_nn_weapon[id] == CSW_KNIFE)
	{	
		while ((hit = engfunc(EngFunc_FindEntityInSphere, hit, origin, 350.0)))
		{
			if (!is_user_alive(hit))
				continue
			
			if ((get_pcvar_num(pcv_nn_ff)) || (!get_pcvar_num(pcv_nn_ff) && cs_get_user_team(id) != cs_get_user_team(hit)))
			{
				nanosuit_menu_choose(id,0,_:NANO_STREN)
				break
			}
		}
	}
	else
	{
		if (random_num(0,100) <= 40)
			nanosuit_menu_choose(id,0,_:NANO_SPEED)
		else
			nanosuit_menu_choose(id,0,_:NANO_ARMOR)
	}
	
	return PLUGIN_CONTINUE
}

/* ===================================================
[Zombie Functons and Forwards]
==================================================== */
public event_infect(victim, attacker)
{
	cl_nn_zombie[victim] = true
	cl_nn_had[victim] = cl_nn_has[victim]
	cl_nn_has[victim] = NANO_NO
	nanosuit_reset(victim)
	
	return PLUGIN_CONTINUE
}

public zp_user_infected_post(victim, attacker)
{
	cl_nn_had[victim] = cl_nn_has[victim]
	cl_nn_has[victim] = NANO_NO
	nanosuit_reset(victim)
	show_menu(victim, 0, "^n", 1);
	
	return PLUGIN_CONTINUE
}


public zp_user_humanized_post(id, survivor)
{
	if (!get_pcvar_num(pcv_zm_regive))
		return PLUGIN_CONTINUE
	
	if (cl_nn_had[id] == NANO_YES)
	{
		cl_nn_has[id] = NANO_YES
		nanosuit_reset(id)
	}

	if (zp_get_user_survivor(id) || zp_get_user_sniper(id))
	{
		cl_nn_had[id] = NANO_NO
		cl_nn_has[id] = NANO_NO
		nanosuit_reset(id)
		show_menu(id, 0, "^n", 1)
	}
	
	return PLUGIN_CONTINUE
}
public zp_user_humanized_pre(id, survivor)
{
	cl_nn_had[id] = NANO_YES
	cl_nn_has[id] = NANO_YES
	nanosuit_reset(id,true)
	
	return PLUGIN_CONTINUE
}

/* ===================================================
[Functions that come in handy]
==================================================== */
set_nano_mode(id, NanoModes:mode, bool:announce = true)
{
	if (cl_nn_mode[id] == mode)
		return
	
	if (cl_nn_mode[id] == NANO_CLOAK)
	{
		#if defined REMOVE_VIEWMODEL_ON_CLOAK
		if (!cl_is_bot[id])
		{
			if (cs_get_user_shield(id) && (WEAPONS_WITH_SHIELD_BITSUM & 1<<cl_nn_weapon[id]))
			{
				set_pev(id,pev_viewmodel2,wpn_v_shield_model[cl_nn_weapon[id]])
			}
			else
				set_pev(id,pev_viewmodel2,wpn_v_model[cl_nn_weapon[id]])
		}
		#endif
		#if defined USE_WEAPON_STATUSICONS
		msg_statusicon(id,ICON_REMOVE,wpn_ms_icon[cl_nn_weapon[id]],{0,0,0})
		#endif
		
		msg_shadowidx(id,SHADOW_CREATE)
	}
	if (mode == NANO_CLOAK)
	{
		msg_shadowidx(id,SHADOW_REMOVE)
	}
	
	msg_statusicon(id,ICON_REMOVE,NanoStatusIcon[cl_nn_mode[id]],{0,0,0})
	msg_statusicon(id,ICON_SHOW,NanoStatusIcon[mode],NanoScreenColor[mode])
	
	cl_nn_mode[id] = mode
	
	set_nano_glow(id)
	
	if (!cl_is_bot[id] && announce)
	{
		switch (mode)
		{
			case NANO_ARMOR:
			{
				client_cmd(id, "spk %s", sound_switch_armor)
				client_cmd(id, "spk %s", sound_armor)
				client_print(id, print_center, "%L", id, "NANO_ARM")
				client_cmd(id,"cl_sidespeed 400")
				client_cmd(id,"cl_forwardspeed 400")
				client_cmd(id,"cl_backspeed 400")
				
				// Blue glow. ;)
				set_user_rendering(id, kRenderFxGlowShell, 0, 0, 255, kRenderNormal, 25)
				
				message_begin(MSG_ONE, g_msgScreenFade, _, id)
				write_short( 1<<10 )
				write_short( 1<<10 )
				write_short( 1<<12 )
				write_byte(18) // r
				write_byte(54) // g
				write_byte(177) // b
				write_byte(50) // Alpha
				message_end()
			}
			case NANO_STREN:
			{
				client_cmd(id, "spk %s", sound_switch_strength)
				client_cmd(id, "spk %s", sound_strengh)
				client_print(id, print_center, "%L", id, "NANO_STR")
				client_cmd(id,"cl_sidespeed 400")
				client_cmd(id,"cl_forwardspeed 400")
				client_cmd(id,"cl_backspeed 400")
				
				// Blue glow. ;)
				set_user_rendering(id, kRenderFxGlowShell, 255, 0, 0, kRenderNormal, 25)
				
				message_begin(MSG_ONE_UNRELIABLE, g_msgScreenFade, _, id)
				write_short( 1<<10 )
				write_short( 1<<10 )
				write_short( 1<<12 )
				write_byte(196) // r
				write_byte(0) // g
				write_byte(5) // b
				write_byte(50) // Alpha
				message_end()
			}
			case NANO_SPEED:
			{
				client_cmd(id, "spk %s", sound_switch_speed)
				client_cmd(id, "spk %s", sound_speed)
				client_print(id, print_center, "%L", id, "NANO_SPD")
				client_cmd(id,"cl_sidespeed 900")
				client_cmd(id,"cl_forwardspeed 900")
				client_cmd(id,"cl_backspeed 900")
				
				// Yellow glow. ;)
				set_user_rendering(id, kRenderFxGlowShell, 255, 255, 0, kRenderNormal, 25)
				
				message_begin(MSG_ONE_UNRELIABLE, g_msgScreenFade, _, id)
				write_short( 1<<10 )
				write_short( 1<<10 )
				write_short( 1<<12 )
				write_byte(253) // r
				write_byte(247) // g
				write_byte(0) // b
				write_byte(50) // Alpha
				message_end()
			}
			case NANO_CLOAK:
			{
				#if defined REMOVE_VIEWMODEL_ON_CLOAK
				set_pev(id,pev_viewmodel2,"")
				#endif
				#if defined USE_WEAPON_STATUSICONS
				msg_statusicon(id,ICON_SHOW,wpn_ms_icon[cl_nn_weapon[id]],{0,255,0})
				#endif
				client_cmd(id, "spk %s", sound_switch_cloak)
				client_cmd(id, "spk %s", sound_cloak)
				client_print(id, print_center, "%L", id, "NANO_CLO")
				client_cmd(id,"cl_sidespeed 400")
				client_cmd(id,"cl_forwardspeed 400")
				client_cmd(id,"cl_backspeed 400")
			}
		}
	}
}

set_nano_energy(id, Float:ammount, delay = 0)
{
	cl_nn_energy[id] = ammount
	if (delay > cl_nn_block_recharge[id])
		cl_nn_block_recharge[id] = delay
	if (ammount == 0.0 && cl_nn_mode[id] == NANO_CLOAK)
	{
		set_nano_mode(id,NANO_ARMOR)
	}
	
	return 1
}

nanosuit_reset(id, bool:affect_user_properties = false)
{
	if (cl_nn_has[id] == NANO_YES)
	{
		set_nano_glow(id)
		
		if (affect_user_properties)
		{
			if (!zp_get_user_zombie(id))
			{
			cl_nn_energy[id] = get_pcvar_float(pcv_nn_energy)
			//set_user_health(id, get_pcvar_num(pcv_nn_health))
			if (get_pcvar_num(pcv_nn_night))
				cs_set_user_nvg(id,1)
			}
			
			if (cl_nn_mode[id] == NANO_SPEED)
			{
				switch (cl_nn_sp_status[id])
				{
					case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_maxim))
					case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) * get_pcvar_float(pcv_nn_sp_critic))
				}
			}
		}
		
		if (task_exists(id + TASK_ENERGY))
			remove_task(id + TASK_ENERGY)
		
		if (task_exists(id + TASK_AH_REC))
			remove_task(id + TASK_AH_REC)
		
		if (task_exists(id + TASK_AI))
			remove_task(id + TASK_AI)
		
		msg_statusicon(id,ICON_SHOW,NanoStatusIcon[cl_nn_mode[id]],NanoScreenColor[cl_nn_mode[id]])
		
		set_task(0.1,"set_energy",id + TASK_ENERGY, _, _,"b", 0)
		set_task(1.0,"nanosuit_ah_charge",id + TASK_AH_REC, _, _,"b", 0)
		
		if (cl_is_bot[id])
		{
			set_task(2.0,"nanosuit_bot_think",id + TASK_AI, _, _,"b", 0)
		}
	}
	else
	{
		if (cl_update_model[id])
		{
			fm_set_user_model(id,cl_player_model[id])
			cl_update_model[id] = false
		}
		else
		{
			fm_reset_user_model(id)
		}
		
		if (cl_nn_mode[id] == NANO_SPEED)
		{
			switch (cl_nn_sp_status[id])
			{
				case SPEED_MAXIMUM: set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_maxim))
				case SPEED_CRITICAL: set_user_maxspeed(id,get_user_maxspeed(id) / get_pcvar_float(pcv_nn_sp_critic))
			}
		}
		
		if (task_exists(id + TASK_ENERGY))
			remove_task(id + TASK_ENERGY)
		
		if (task_exists(id + TASK_AH_REC))
			remove_task(id + TASK_AH_REC)
		
		if (task_exists(id + TASK_AI))
			remove_task(id + TASK_AI)
	}
}

/* ===================================================
[Message stocks]
==================================================== */
stock draw_spark(const Float:origin[3])
{
	static o[3]
	o[0] = floatround(origin[0])
	o[1] = floatround(origin[1])
	o[2] = floatround(origin[2])
	emessage_begin(MSG_PVS, SVC_TEMPENTITY, o, 0)
	ewrite_byte(TE_SPARKS)
	ewrite_coord(o[0])
	ewrite_coord(o[1])
	ewrite_coord(o[2])
	emessage_end()	
}

stock emsg_damage(player,dmg_save,dmg_take,dmg_type,Float:origin[3])
{
	set_pev(player,pev_dmg_save,float(dmg_save))
	set_pev(player,pev_dmg_take,float(dmg_take))
	emessage_begin(MSG_ONE, nd_msg_damage, {0,0,0}, player)
	ewrite_byte(dmg_save)
	ewrite_byte(dmg_take)
	ewrite_long(dmg_type)
	ewrite_coord(floatround(origin[0]))
	ewrite_coord(floatround(origin[1]))
	ewrite_coord(floatround(origin[2]))
	emessage_end()
}

stock colored_msg(id,msg[])
{
	message_begin(MSG_ONE, nd_msg_saytext, {0,0,0}, id)
	write_byte(id)
	write_string(msg)
	message_end()
}

stock msg_statusicon(id,IconStatus:mode,icon[],color[3])
{
	if (cl_is_bot[id] || (cl_nn_lowres[id] && mode != ICON_REMOVE))
		return
	
	new msg_type
	if (mode == ICON_REMOVE)
		msg_type = MSG_ONE
	else
	msg_type = MSG_ONE_UNRELIABLE
	
	message_begin(msg_type, nd_msg_iconstatus, {0,0,0}, id)
	write_byte(_:mode)
	write_string(icon)
	write_byte(color[0])
	write_byte(color[1])
	write_byte(color[2])
	message_end()
	
	return
}

stock msg_shadowidx(id, ShadowIdX:long)
{
	if ((cl_removed_shadow[id] && long == SHADOW_REMOVE) || (!cl_removed_shadow[id] && long == SHADOW_CREATE))
	{
		return
	}
	
	if (long == SHADOW_REMOVE)
		cl_removed_shadow[id] = true
	else
		cl_removed_shadow[id] = false
	
	message_begin(MSG_ONE, nd_msg_shadowidx, {0,0,0}, id)
	write_long(_:long)
	message_end()
}

bool:is_glowing_in_nano(id)
{
	if (pev(id, pev_renderfx) != NanoGlowFX[cl_nn_mode[id]])
		return false
	
	if (pev(id, pev_rendermode) != NanoGlowMode[cl_nn_mode[id]])
		return false
	
	static Float:ammount
	pev(id, pev_renderamt, ammount)
	
	if (floatround(ammount) != NanoGlowAmmount[cl_nn_mode[id]])
		return false
	
	return true
}

public give_strength(id)
{
	if(is_user_alive(id) && !zp_get_user_zombie(id) && !zp_get_user_survivor(id) && !zp_get_user_sniper(id))
	{
		set_nano_mode(id,NANO_STREN)
		ExecuteHamB(Ham_Player_ResetMaxSpeed,id)
	}
	else
		client_print(id, print_center,"%L",id,"NANO_NO")
	
	return PLUGIN_HANDLED
}

public give_armor(id)
{
	if(is_user_alive(id) && !zp_get_user_zombie(id) && !zp_get_user_survivor(id) && !zp_get_user_sniper(id))
	{
		set_nano_mode(id,NANO_ARMOR)
		ExecuteHamB(Ham_Player_ResetMaxSpeed,id)
	}
	else
		client_print(id, print_center,"%L",id,"NANO_NO")
	
	return PLUGIN_HANDLED
}

public give_speed(id)
{
	if(is_user_alive(id) && !zp_get_user_zombie(id) && !zp_get_user_survivor(id) && !zp_get_user_sniper(id))
	{
		set_nano_mode(id,NANO_SPEED)
		ExecuteHamB(Ham_Player_ResetMaxSpeed,id)
	}
	else
		client_print(id, print_center,"%L",id,"NANO_NO")
	
	return PLUGIN_HANDLED
}

public give_cloak(id)
{
	if(is_user_alive(id) && !zp_get_user_zombie(id) && !zp_get_user_survivor(id) && !zp_get_user_sniper(id))
	{
		set_nano_mode(id,NANO_CLOAK)
		ExecuteHamB(Ham_Player_ResetMaxSpeed,id)
	}
	else
		client_print(id, print_center,"%L",id,"NANO_NO")
	
	return PLUGIN_HANDLED
}

/* ===================================================
[Set model stocks]
==================================================== */
stock fm_get_user_model(player, model[], len)
{
	// Retrieve current model
	engfunc(EngFunc_InfoKeyValue, engfunc(EngFunc_GetInfoKeyBuffer, player), "model", model, len)
}

stock fm_reset_user_model(player)
{
	dllfunc(DLLFunc_ClientUserInfoChanged, player, engfunc(EngFunc_GetInfoKeyBuffer, player))
}

public fm_set_user_model(player,const model[])
{
	// Set new model
	engfunc(EngFunc_SetClientKeyValue, player, engfunc( EngFunc_GetInfoKeyBuffer, player ), "model", model)
}

Personal message only for paid request. If you love this forum, kindly to donate by clicking the donate button at the footer of this forum.

nikolay
New Member

InfernoBoy

Posts: 35

how to add glow in nanosuit Feb 2, 2015 12:34:22 GMT

Quote

Post by nikolay on Feb 2, 2015 12:34:22 GMT

WOW thank you zmd94.
When player select Speed mode have Yellow glow thank you for this
but when player select armor or strenght mode no have glow
i want when player select armor mode player have blue glow
i want when player select strenght mode player have red glow

zmd94
Zp Staff

Posts: 8,249

how to add glow in nanosuit Feb 2, 2015 15:31:49 GMT

Quote

Post by zmd94 on Feb 2, 2015 15:31:49 GMT

I already added that code for all mode:

/* ===================================================
[Functions that come in handy]
==================================================== */
set_nano_mode(id, NanoModes:mode, bool:announce = true)
{
	if (cl_nn_mode[id] == mode)
		return
	
	if (cl_nn_mode[id] == NANO_CLOAK)
	{
		#if defined REMOVE_VIEWMODEL_ON_CLOAK
		if (!cl_is_bot[id])
		{
			if (cs_get_user_shield(id) && (WEAPONS_WITH_SHIELD_BITSUM & 1<<cl_nn_weapon[id]))
			{
				set_pev(id,pev_viewmodel2,wpn_v_shield_model[cl_nn_weapon[id]])
			}
			else
				set_pev(id,pev_viewmodel2,wpn_v_model[cl_nn_weapon[id]])
		}
		#endif
		#if defined USE_WEAPON_STATUSICONS
		msg_statusicon(id,ICON_REMOVE,wpn_ms_icon[cl_nn_weapon[id]],{0,0,0})
		#endif
		
		msg_shadowidx(id,SHADOW_CREATE)
	}
	if (mode == NANO_CLOAK)
	{
		msg_shadowidx(id,SHADOW_REMOVE)
	}
	
	msg_statusicon(id,ICON_REMOVE,NanoStatusIcon[cl_nn_mode[id]],{0,0,0})
	msg_statusicon(id,ICON_SHOW,NanoStatusIcon[mode],NanoScreenColor[mode])
	
	cl_nn_mode[id] = mode
	
	set_nano_glow(id)
	
	if (!cl_is_bot[id] && announce)
	{
		switch (mode)
		{
			case NANO_ARMOR:
			{
				client_cmd(id, "spk %s", sound_switch_armor)
				client_cmd(id, "spk %s", sound_armor)
				client_print(id, print_center, "%L", id, "NANO_ARM")
				client_cmd(id,"cl_sidespeed 400")
				client_cmd(id,"cl_forwardspeed 400")
				client_cmd(id,"cl_backspeed 400")
				
				// Blue glow. ;)
				set_user_rendering(id, kRenderFxGlowShell, 0, 0, 255, kRenderNormal, 25)
				
				message_begin(MSG_ONE, g_msgScreenFade, _, id)
				write_short( 1<<10 )
				write_short( 1<<10 )
				write_short( 1<<12 )
				write_byte(18) // r
				write_byte(54) // g
				write_byte(177) // b
				write_byte(50) // Alpha
				message_end()
			}
			case NANO_STREN:
			{
				client_cmd(id, "spk %s", sound_switch_strength)
				client_cmd(id, "spk %s", sound_strengh)
				client_print(id, print_center, "%L", id, "NANO_STR")
				client_cmd(id,"cl_sidespeed 400")
				client_cmd(id,"cl_forwardspeed 400")
				client_cmd(id,"cl_backspeed 400")
				
				// Blue glow. ;)
				set_user_rendering(id, kRenderFxGlowShell, 255, 0, 0, kRenderNormal, 25)
				
				message_begin(MSG_ONE_UNRELIABLE, g_msgScreenFade, _, id)
				write_short( 1<<10 )
				write_short( 1<<10 )
				write_short( 1<<12 )
				write_byte(196) // r
				write_byte(0) // g
				write_byte(5) // b
				write_byte(50) // Alpha
				message_end()
			}
			case NANO_SPEED:
			{
				client_cmd(id, "spk %s", sound_switch_speed)
				client_cmd(id, "spk %s", sound_speed)
				client_print(id, print_center, "%L", id, "NANO_SPD")
				client_cmd(id,"cl_sidespeed 900")
				client_cmd(id,"cl_forwardspeed 900")
				client_cmd(id,"cl_backspeed 900")
				
				// Yellow glow. ;)
				set_user_rendering(id, kRenderFxGlowShell, 255, 255, 0, kRenderNormal, 25)
				
				message_begin(MSG_ONE_UNRELIABLE, g_msgScreenFade, _, id)
				write_short( 1<<10 )
				write_short( 1<<10 )
				write_short( 1<<12 )
				write_byte(253) // r
				write_byte(247) // g
				write_byte(0) // b
				write_byte(50) // Alpha
				message_end()
			}
			case NANO_CLOAK:
			{
				#if defined REMOVE_VIEWMODEL_ON_CLOAK
				set_pev(id,pev_viewmodel2,"")
				#endif
				#if defined USE_WEAPON_STATUSICONS
				msg_statusicon(id,ICON_SHOW,wpn_ms_icon[cl_nn_weapon[id]],{0,255,0})
				#endif
				client_cmd(id, "spk %s", sound_switch_cloak)
				client_cmd(id, "spk %s", sound_cloak)
				client_print(id, print_center, "%L", id, "NANO_CLO")
				client_cmd(id,"cl_sidespeed 400")
				client_cmd(id,"cl_forwardspeed 400")
				client_cmd(id,"cl_backspeed 400")
			}
		}
	}
}

Last Edit: Feb 2, 2015 15:32:19 GMT by zmd94

Personal message only for paid request. If you love this forum, kindly to donate by clicking the donate button at the footer of this forum.

how to add glow in nanosuit

Post by nikolay on Jan 30, 2015 22:01:40 GMT

Post by zmd94 on Jan 31, 2015 14:02:42 GMT

Post by nikolay on Jan 31, 2015 16:58:38 GMT

Post by zmd94 on Feb 2, 2015 11:09:25 GMT

Post by nikolay on Feb 2, 2015 12:34:22 GMT

Post by zmd94 on Feb 2, 2015 15:31:49 GMT