	ГЛАВНАЯ	УСЛУГИ	ПЛАГИНЫ	КАРТЫ	REBUY	SCANMON	CASSA	SALE	ФОРУМ	МОНИТОР	HELP	КОНТАКТ

Плагин для cs 1.6 "ЗАХВАТ РОБОТА"

Теги: Скачать плагины cs

В начале игры, при загрузке новой карты, на ней появляются спящие роботы в определенных местах,
заранее расставленных точках. Все роботы изначально не активны, находятся в спящем режиме.
Чтобы завладеть одним из таких роботов и стать хозяином, необходимо прикоснуться к нему и никуда не уходить,
пока не закончится таймер.

Компилятор: 1.8.2 +ZIP 2171

Команды:

amx_spawn_robot Установить Робота

Cvars:

r_health_1 "1000" hp робота 1 уровень

r_health_2 "2000" hp робота 2 уровень

r_health_3 "5000" hp робота 3 уровень

r_cost_up "1500" стоимость улучшения робота

r_time_capture "10" время захвата робота

r_reward "500" награда за убийство

.sma / .sp

#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <fun>
#include <cstrike>
#include <fakemeta>
#include <fakemeta_util>
#include <hamsandwich>
#include <xs>
#include <dhudmessage>

#define MODEL_OFFLINE "models/rg_capture_sleep.mdl"
#define MODEL_CT "models/rg_capture_ct.mdl"
#define MODEL_T "models/rg_capture_t.mdl"
#define Mine_Sprite_Laser "sprites/test/laser.spr"
#define Mine_Sprite_Laser2 "sprites/zbeam2.spr"
new const GrenadeModel[]="models/shell.mdl"

#define SPRITE_FLARE "sprites/flare1.spr"

#define ACTIVE pev_iuser1
#define TYPE_SHOOT pev_iuser2
#define STATE pev_iuser3
#define ROCKETS_COUNT pev_iuser4

public plugin_init()
{
	register_clcmd("amx_spawn_robot", "clcmd_open_menu")
	
	register_menu("RoboMenu", keys, "robo_menu")
	register_menu("TurretMenu", keys, "turret_menu")
	
	register_touch("RobotTurret", "player", "touch_player")
	
	register_touch("robo_rocket", "*", "touch_rocket")
	
	register_think("RobotTurret", "think_turret")
	
	RegisterHam(Ham_TakeDamage, "func_breakable", "ham_takedamage", 0)
	
	
	g_iCvar[0]=register_cvar("r_health_1", "1000")
	g_iCvar[1]=register_cvar("r_health_2", "2000")
	g_iCvar[2]=register_cvar("r_health_3", "5000")
	g_iCvar[3]=register_cvar("r_time_capture", "10")
	g_iCvar[4]=register_cvar("r_reward", "500")
	g_iCvar[5]=register_cvar("r_cost_up", "1500")
}

public plugin_cfg()
{
	g_Entity_robo = engfunc(EngFunc_AllocString, "func_breakable")
	
	load_flags()
	
	new file[128]; get_localinfo("amxx_configsdir",file,63)
	format(file, 127, "%s/dm/robot_turret.cfg", file)
	if(file_exists(file)) server_cmd("exec %s", file), server_exec()
}

public load_flags()
{
	new szMapName[32]
	get_mapname(szMapName, 31)
	strtolower(szMapName)
	
	formatex(g_szConfigFile, 127, "addons/amxmodx/configs/robots_m")
	
	if( !dir_exists(g_szConfigFile)) 
	{
		mkdir(g_szConfigFile)
		format(g_szConfigFile, 127, "%s/%s.txt", g_szConfigFile, szMapName )
		return
	}
	
	format(g_szConfigFile, 127, "%s/%s.txt", g_szConfigFile, szMapName)
	if(!file_exists(g_szConfigFile)) 
	{
		fopen(g_szConfigFile, "at")
		return
	}
	
	new iFile = fopen( g_szConfigFile, "rt" )
	if(!iFile) return
	
	new x[16], y[16], z[16], szData[charsmax(x) + charsmax(y) + charsmax(z)]
	
	new Float:vOrigin[3]
	
	while(!feof(iFile)) 
	{
		fgets(iFile, szData, charsmax(szData))
		trim(szData)
		
		if(!szData[0]) continue;
		
		parse(szData, x, 15, y, 15, z, 15)
		
		vOrigin[0] = str_to_float(x)
		vOrigin[1] = str_to_float(y)
		vOrigin[2] = str_to_float(z)
		
		set_robot(vOrigin)
	}
	
	fclose( iFile )
}

public plugin_precache()
{
	precache_model(MODEL_OFFLINE)
	precache_model(MODEL_CT)
	precache_model(MODEL_T)
	
	precache_model(SPRITE_FLARE)
	
	precache_model(GrenadeModel)
	
	precache_sound("test/turrspot.wav")
	
	precache_sound("hassault/hw_gun4.wav")
	precache_sound("hassault/hw_spinup.wav")
	precache_sound("hassault/hw_spindown.wav")

precache_sound("weapons/rocketfire1.wav")
	precache_sound("test/ethereal_shoot1.wav")
	
	precache_sound("test/rg_build_1.wav")
	
	g_iBeam=precache_model(Mine_Sprite_Laser)
	g_iBeam2=precache_model(Mine_Sprite_Laser2)
	
	explode_spr=precache_model("sprites/fexplo.spr")
}

public clcmd_open_update(id)
{
	new menu[512], iLen
	new ent=g_ent[id]
	
	if(pev(ent, TYPE_SHOOT)>=2)return
	
	iLen = formatex(menu[iLen], charsmax(menu) - iLen, "\yУлучшение робота^n^n")
            
	if(pev(ent, TYPE_SHOOT)>=0)
		iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n\r[\y1\r]\d Уровень 1 (Пулемет)")
	else iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n\r[\y1\r]\w Уровень 1 \r(\yПулемет\r)")
	
	if(pev(ent, TYPE_SHOOT)>=1)
		iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n\r[\y2\r]\d Уровень 2 (Ракетница)")
	else iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n\r[\y2\r]\w Уровень 2 \r(\yРакетница\r) \w5000$")
	
	if(pev(ent, TYPE_SHOOT)>=2)
		iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n\r[\y3\r]\d Уровень 3 (Лазер)")
	else iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n\r[\y3\r]\w Уровень 3 \r(\yЛазер\r) \w5000$")
	
	//iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n^n\r[\y4\r]\w Движение робота \r(\y4000$\r)")
	
	iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n^n\r[\y0\r]\w Выход")
	
	show_menu(id, keys, menu, -1, "TurretMenu")
}

public turret_menu(id, key)
{
	if (key>2)return
	new ent=g_ent[id]
		
	if(pev(ent, TYPE_SHOOT)>=key)return
	
	if(cs_get_user_money(id)<get_pcvar_num(g_iCvar[5]))return
	
	cs_set_user_money(id, cs_get_user_money(id)-get_pcvar_num(g_iCvar[5]))
	
	set_pev(ent, TYPE_SHOOT, key)
	
	set_pev(ent, pev_health, get_pcvar_float(g_iCvar[key]))
	
	set_anim(ent, 1)
	set_pev(ent, pev_controller_0, 127)
	set_pev(ent, pev_controller_1, 127)
	
	set_pev(ent, pev_euser1, 0)
	
	set_pev(ent, pev_nextthink, get_gametime()+2.5)
	
	emit_sound(ent, CHAN_WEAPON, "test/rg_build_1.wav", 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public clcmd_open_menu(id)
{
	new menu[512], iLen
	
	iLen = formatex(menu[iLen], charsmax(menu) - iLen, "\yУстановка роботов^n^n")
            
	iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n\r[\y1\r]\w Поставить робота")
	
	iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n\r[\y2\r]\w Удалить всех роботов")
	
	iLen += formatex(menu[iLen], charsmax(menu) - iLen, "^n^n\r[\y0\r]\w Выход")
	
	show_menu(id, keys, menu, -1, "RoboMenu")
}

public robo_menu(id, key)
{
	if(key>2) return

switch(key)
	{
		case 0:
		{
			new Float:playerOrigin[3]
			entity_get_vector(id, EV_VEC_origin, playerOrigin)
			
			new Float:vNewOrigin[3]
			new Float:vTraceDirection[3]
			new Float:vTraceEnd[3]
			new Float:vTraceResult[3]
			velocity_by_aim(id, 64, vTraceDirection)
			vTraceEnd[0] = vTraceDirection[0] + playerOrigin[0]
			vTraceEnd[1] = vTraceDirection[1] + playerOrigin[1]
			vTraceEnd[2] = vTraceDirection[2] + playerOrigin[2]
			trace_line(id, playerOrigin, vTraceEnd, vTraceResult)
			vNewOrigin[0] = vTraceResult[0]
			vNewOrigin[1] = vTraceResult[1]
			vNewOrigin[2] = playerOrigin[2]
			
			if (point_contents(vNewOrigin) != CONTENTS_EMPTY || TraceCheckCollides(vNewOrigin, 24.0)) return
			
			new oloent=set_robot(vNewOrigin)
			Save_Flags(oloent)
		}
		
		case 3:
		{
			delete_file(g_szConfigFile)
			fopen(g_szConfigFile, "at")
		}

}
}

Save_Flags(ent)
{
	new iFile = fopen(g_szConfigFile, "at")
	
	if(!iFile) return
	
	new Float:vOrigin[3]
	pev(ent, pev_origin, vOrigin)

fprintf(iFile, "%f %f %f^n", vOrigin[0], vOrigin[1], vOrigin[2])
	fclose(iFile)
}

public set_robot(const Float:vNewOrigin[3])
{
	new i_Ent = engfunc(EngFunc_CreateNamedEntity, g_Entity_robo)
	
	if(!i_Ent) return 0

engfunc(EngFunc_SetModel, i_Ent, MODEL_OFFLINE)
	
	entity_set_origin(i_Ent, vNewOrigin)
	
	set_pev(i_Ent, pev_solid, SOLID_BBOX)
	set_pev(i_Ent, pev_movetype, MOVETYPE_TOSS)
	
	engfunc(EngFunc_SetSize, i_Ent, Float:{ -24.0, -24.0, -0.0 }, Float:{ 24.0, 24.0, 24.0 })
	
	set_pev(i_Ent, pev_classname, "RobotTurret")
	
	set_pdata_int(i_Ent, 36, 6, 4)
	
	set_pev(i_Ent, ACTIVE, 0)
	set_pev(i_Ent, TYPE_SHOOT, 0)
	
	set_pev(i_Ent, pev_takedamage, DAMAGE_NO)	
	
	set_pev(i_Ent, pev_controller_0, 127)
	set_pev(i_Ent, pev_controller_1, 127)
	
	set_pev(i_Ent, pev_health, get_pcvar_float(g_iCvar[0]))
	set_pev(i_Ent, pev_deadflag, DEAD_NO)
	
	set_anim(i_Ent, 0)
	
	return i_Ent
}

public touch_player(ent, id)
{
	if(pev(ent, ACTIVE)){
		g_ent[id]=ent
		
		if(fm_cs_get_user_team(id)!=pev(ent, pev_body)) return
		
		clcmd_open_update(id)
		return
	}
	
	if(pev(ent, ROCKETS_COUNT)) return
	
	set_pev(ent, ROCKETS_COUNT, get_pcvar_num(g_iCvar[3]))
	
	set_dhudmessage(0,255,0, -1.0, 0.7, 0, 0.0, 1.1, 0.0, 0.0)
	show_dhudmessage(id, "Начинаем захват!^nОсталось %d сек", pev(ent, ROCKETS_COUNT))
	
	new info[2]
	info[0] = ent
	info[1] = id
	
	set_task(1.0, "flag_refresh", ent+88554, info, 2, "b")
}

public flag_refresh(const info[])
{
	new ent=info[0]
	new id=info[1]
	
	if(!is_user_connected(id))
	{
		set_pev(ent, ROCKETS_COUNT, 0)
		remove_task(ent+88554)	
		return
	}
	
	new Float:flOrigin[3], Float:flOrigin2[3]
	pev(id, pev_origin, flOrigin)
	pev(ent, pev_origin, flOrigin2)
		
	new Float:flDistance = get_distance_f(flOrigin, flOrigin2) 
	
	if(flDistance>150.0||!is_user_alive(id)){
		set_pev(ent, ROCKETS_COUNT, 0)
		remove_task(ent+88554)	
		return
	}
	
	set_pev(ent, ROCKETS_COUNT, pev(ent, ROCKETS_COUNT)-1)
	
	set_dhudmessage(255,255,255, -1.0, 0.7, 0, 0.0, 1.1, 0.0, 0.0)
	show_dhudmessage(id, "Захват робота^nОсталось %d сек", pev(ent, ROCKETS_COUNT))
	
	if(!pev(ent, ROCKETS_COUNT))
	{
		remove_task(ent+88554)	
		
		
		if(fm_cs_get_user_team(id)==1) engfunc(EngFunc_SetModel, ent, MODEL_T)	
		else engfunc(EngFunc_SetModel, ent, MODEL_CT)	
		engfunc(EngFunc_SetSize, ent, Float:{ -24.0, -24.0, -0.0 }, Float:{ 24.0, 24.0, 24.0 })
	
		set_anim(ent, 2)
		set_pev(ent, ACTIVE, 1)
		set_pev(ent, pev_controller_0, 127)
		set_pev(ent, pev_controller_1, 127)
		set_pev(ent, pev_nextthink, get_gametime()+2.5)
		set_pev(ent, pev_takedamage, DAMAGE_YES)	
		
		set_pev(ent, pev_euser2, id)
		
		emit_sound(ent, CHAN_WEAPON, "test/rg_build_1.wav", 1.0, ATTN_NORM, 0, PITCH_NORM)
		
		set_pev(ent, pev_body, fm_cs_get_user_team(id))
	}
}

public client_putinserver(id)
{
	set_task(1.0, "Task_Informer", id+666)
}

public Task_Informer(taskid)
{
	new id=taskid-666
	
	set_task(1.0, "Task_Informer", taskid)
	
	if(!is_user_alive(id))return
	
	new target, body
	get_user_aiming(id, target, body, 9999)
	
	static ClassName[32]
	pev(target, pev_classname, ClassName, charsmax(ClassName))
	if (equal(ClassName, "RobotTurret")) 
	{
		if(pev(target, ACTIVE)==0){
			if(pev(target, pev_deadflag)==DEAD_DYING){
				set_dhudmessage(200,20, 20, -1.0, 0.60, 0, 0.0, 1.0, 0.01, 0.01)
				show_dhudmessage(id, "Робот уничтожен")
			}
			
			else if(pev(target, ROCKETS_COUNT)){
				set_dhudmessage(200, 200, 20, -1.0, 0.60, 0, 0.0, 1.0, 0.01, 0.01)
				show_dhudmessage(id, "Активирование...")
			}
			else{
				set_dhudmessage(0, 255, 0, -1.0, 0.60, 0, 0.0, 1.0, 0.01, 0.01)
				show_dhudmessage(id, "Ждет активации...")
			}
			return
		}
		
		if(fm_cs_get_user_team(id)!=pev(target, pev_body)) return

new Float:Health
		pev(target, pev_health, Health)
		new Name[32]
		get_user_name(pev(target, pev_euser2),Name,31)
		
		set_dhudmessage(200, 50, 52, -1.0, 0.60, 0, 0.0, 1.0, 0.01, 0.01)
		show_dhudmessage(id, "Захватил: %s^nУбийств: %d^nЖизни: %d^nУровень: %d", Name, pev(target, pev_iuser3), floatround(Health), pev(target, TYPE_SHOOT)+1)
	}
}

stock fm_cs_get_user_team(id)
{
	if (pev_valid(id) != 2) return 0
	
	return get_pdata_int(id, 114, 5)
}

public ham_takedamage(victim, weapon, attacker, Float:damage, damagetype) 
{
	if(!pev_valid(victim)) return HAM_IGNORED
	
	static ClassName[32]
	pev(victim, pev_classname, ClassName, charsmax(ClassName))

if (equal(ClassName, "RobotTurret")) 
	{
		if(!is_user_connected(attacker)||(fm_cs_get_user_team(attacker)==pev(victim, pev_body)))
			return HAM_SUPERCEDE
		
		new Float:g_Health
		pev(victim, pev_health, g_Health)
		
		if (g_Health <= damage) 
		{
			set_anim(victim, 4)
			
			set_pev(victim, pev_deadflag, DEAD_DYING)
			
			set_pev(victim, pev_takedamage, DAMAGE_NO)	
			
			set_pev(victim, ACTIVE, 0)
			
			set_pev(victim, TYPE_SHOOT, 0)
			
			set_pev(victim, pev_health, 100.0)
			
			set_pev(victim, pev_nextthink, get_gametime()+6.5)
			
			
			
			cs_set_user_money(attacker, cs_get_user_money(attacker)+get_pcvar_num(g_iCvar[4]))

return HAM_SUPERCEDE
		}
	}
	return HAM_IGNORED
}

public think_turret(ent)
{
		if(pev(ent, pev_deadflag)==DEAD_DYING)
		{
			engfunc(EngFunc_SetModel, ent, MODEL_OFFLINE)	
			engfunc(EngFunc_SetSize, ent, Float:{ -24.0, -24.0, -0.0 }, Float:{ 24.0, 24.0, 24.0 })
		
			set_anim(ent, 1)
			set_pev(ent, ACTIVE, 0)
			set_pev(ent, pev_controller_0, 127)
			set_pev(ent, pev_controller_1, 127)
			set_pev(ent, pev_nextthink, get_gametime()+2.5)
			
			set_pev(ent, pev_deadflag, DEAD_NO)
			
			//fm_remove_entity(ent)
		
			return
		}
		
		if(!pev(ent, ACTIVE))return
		
		new closestTarget = 0, Float:closestDistance, Float:distance, Float:closestOrigin[3], Float:playerOrigin[3]
		new Float:sentryOrigin[3], Float:hitOrigin[3], hitent
		entity_get_vector(ent, EV_VEC_origin, sentryOrigin)
		
		new Float:HealthT
		pev(ent, pev_health, HealthT)
		HealthT-=0.1
		set_pev(ent, pev_health, HealthT)

if(pev(ent, STATE))
		{
			if(pev(ent, pev_euser1))
			{
				new target=pev(ent, pev_euser1)
				new attacker=pev(ent, pev_euser2)
				
				new Float:targetOrigin[3]
				entity_get_vector(target, EV_VEC_origin, targetOrigin)
				
				new Float:x = targetOrigin[0] - sentryOrigin[0]
				new Float:z = targetOrigin[1] - sentryOrigin[1]
				new Float:radians = floatatan(z/x, radian)
				new Float:degs = radians * (180.0 / 3.141592654)
				if (targetOrigin[0] < sentryOrigin[0]) degs-=180.0
				
				new Float:RADIUS = 180.0
				new Float:degreeByte = RADIUS/256.0
				
				new Float:tilt = 127.0+(degreeByte*degs)
				
				set_pev(ent, pev_controller_1, floatround(tilt)) 
				
				new Float:h = targetOrigin[2] - sentryOrigin[2]
				new Float:b = vector_distance(sentryOrigin, targetOrigin)
				radians = floatatan(h/b, radian)
				degs = radians * (180.0 / 3.141592654)
	
				RADIUS = 360.0
				degreeByte = RADIUS/256.0
				tilt = 127.0-degreeByte * degs
		
				set_pev(ent, pev_controller_0, floatround(tilt)) 
				
				if (entity_get_int(target, EV_INT_flags) & FL_DUCKING) targetOrigin[2] += 18.0

if(is_user_alive(target)) {
					new hitent = trace_line(ent, sentryOrigin, targetOrigin, hitOrigin)
					if(hitent==target){
				
					
					switch(pev(ent, TYPE_SHOOT))
					{
						case 0:
						{
							new Float:TimeF
							pev(ent, pev_fuser1, TimeF)
							if(TimeF>get_gametime()){
							}
							else{
								set_anim(ent, 9)
								
								emit_sound(ent, CHAN_WEAPON, "hassault/hw_gun4.wav", 1.0, ATTN_NORM, 0, PITCH_NORM)
								
								tracer(sentryOrigin, targetOrigin)
								
								
								set_pev(ent, pev_fuser1, get_gametime()+0.2)
								
								new Float:Health
								pev(target, pev_health, Health)
								if(Health>1.0) {
									ExecuteHamB(Ham_TakeDamage, target, ent, attacker, 1.0, DMG_BLAST)
								}else {
									ExecuteHamB(Ham_TakeDamage, target, ent, attacker, 100.0, DMG_BULLET)
									set_pev(ent, pev_iuser3, pev(ent, pev_iuser3)+1)
								}
			
							}
							set_pev(ent, pev_nextthink, get_gametime()+0.1)	
						}
						
						case 1:
						{
							if(pev(ent, ROCKETS_COUNT)>=7){
								set_pev(ent, ROCKETS_COUNT, 0)
								set_pev(ent, pev_nextthink, get_gametime()+0.1)
								set_pev(ent, pev_fuser1, get_gametime()+1.5)
							}else{
								new Float:TimeF
								pev(ent, pev_fuser1, TimeF)
								if(TimeF>get_gametime()){
									set_pev(ent, pev_nextthink, get_gametime()+0.1)
								}
								else{
									if(pev(ent, ROCKETS_COUNT)==0) {
										
										emit_sound(ent, CHAN_WEAPON, "weapons/rocketfire1.wav", 1.0, ATTN_NORM, 0, PITCH_NORM)
										set_anim(ent, 12)
									}
									
									GrenadeAttack(ent, targetOrigin, pev(ent, ROCKETS_COUNT))
									set_pev(ent, ROCKETS_COUNT, pev(ent, ROCKETS_COUNT)+1)
									set_pev(ent, pev_nextthink, get_gametime()+random_float(0.01,0.04))
								}
							}
						}
						
						case 2:
						{
							set_anim(ent, 6)
							
							message_begin(MSG_BROADCAST,SVC_TEMPENTITY)
							write_byte(TE_BEAMENTPOINT)
							write_short(target)
							engfunc(EngFunc_WriteCoord,sentryOrigin[0])
							engfunc(EngFunc_WriteCoord,sentryOrigin[1])
							engfunc(EngFunc_WriteCoord,sentryOrigin[2]+50.0)
							write_short(g_iBeam)
							write_byte(0);
							write_byte(0);
							write_byte(1)
							write_byte(20)
							write_byte(0) 
							write_byte(255)
							write_byte(255)
							write_byte(255)
							write_byte(255)
							write_byte(0)
							message_end()
							
							new Float:Health
							pev(target, pev_health, Health)
							if(Health>1.0) {
									ExecuteHamB(Ham_TakeDamage, target, ent, attacker, 1.0, DMG_BLAST)
							}else {
									ExecuteHamB(Ham_TakeDamage, target, ent, attacker, 100.0, DMG_BULLET)
									set_pev(ent, pev_iuser3, pev(ent, pev_iuser3)+1)
							}
							
							emit_sound(ent, CHAN_WEAPON, "test/ethereal_shoot1.wav", 1.0, ATTN_NORM, 0, PITCH_NORM)

set_pev(ent, pev_nextthink, get_gametime()+0.1)
						}
					}
					return
				}
				}
			}
			
		}

for (new i = 1; i <= 32; i++) 
		{
			if (!is_user_connected(i) || !is_user_alive(i) || pev(i, pev_takedamage)== DAMAGE_NO || pev(ent, pev_body)== fm_cs_get_user_team(i)) continue
		
			entity_get_vector(i, EV_VEC_origin, playerOrigin)
		
			if (entity_get_int(i, EV_INT_flags) & FL_DUCKING) playerOrigin[2] += 18.0
	
			hitent = trace_line(ent, sentryOrigin, playerOrigin, hitOrigin)
		
			if (hitent == i) 
			{
				distance = vector_distance(sentryOrigin, playerOrigin)
				closestOrigin = playerOrigin
		
				if (distance < closestDistance || closestTarget == 0) 
				{
					closestTarget = i
					closestDistance = distance
				}
			}
		}
		
		if (closestTarget) {
			set_pev(ent, STATE, 1)
			
			new Float:x = closestOrigin[0] - sentryOrigin[0]
			new Float:z = closestOrigin[1] - sentryOrigin[1]
			new Float:radians = floatatan(z/x, radian)
			new Float:degs = radians * (180.0 / 3.141592654)
			if (closestOrigin[0] < sentryOrigin[0]) degs-=180.0
			
			new Float:RADIUS = 180.0
			new Float:degreeByte = RADIUS/256.0; // tweak radius later
			
			new Float:tilt = 127.0+(degreeByte*degs)// 127 is center of 256... well, almost
			
			set_pev(ent, pev_controller_1, floatround(tilt))

new Float:h = closestOrigin[2] - sentryOrigin[2]
			new Float:b = vector_distance(sentryOrigin, closestOrigin)
			radians = floatatan(h/b, radian)
			degs = radians * (180.0 / 3.141592654)
			
			RADIUS = 360.0
			degreeByte = RADIUS/256.0; // tweak radius later
			tilt = 127.0-degreeByte * degs // 127 is center of 256... well, almost
	
			set_pev(ent, pev_controller_0, floatround(tilt)) 
			
			set_pev(ent, pev_euser1, closestTarget)
			
			emit_sound(ent, CHAN_AUTO, "test/turrspot.wav", 1.0, ATTN_NORM, 0, PITCH_NORM)
			set_pev(ent, pev_nextthink, get_gametime()+0.7)
				
			switch(pev(ent, TYPE_SHOOT)){
				case 0: {
					set_anim(ent, 8)
					emit_sound(ent, CHAN_WEAPON, "hassault/hw_spinup.wav", 1.0, ATTN_NORM, 0, PITCH_NORM)
				}
				case 1: set_anim(ent, 11)
				case 2: set_anim(ent, 5)
			}
		}
		else if(pev(ent, STATE)){
			set_pev(ent, pev_nextthink, get_gametime()+0.7)
			set_pev(ent, STATE, 0)
			
			switch(pev(ent, TYPE_SHOOT)){
				case 0: {
					set_anim(ent, 10)
					emit_sound(ent, CHAN_WEAPON, "hassault/hw_spindown.wav", 1.0, ATTN_NORM, 0, PITCH_NORM)
				}
				case 1: set_anim(ent, 13)
				case 2: set_anim(ent, 7)
			}
		}
		else {
			if(pev(ent, pev_sequence)!=2)set_anim(ent, 2)
			set_pev(ent, pev_nextthink, get_gametime()+0.25)
		}
}
new Float:coords[] ={-33.0, -22.0, -11.0, 0.0, 11.0, 22.0, 33.0}
new Color1[]={0,255,10,255,10,255,0}
new Color2[]={210,100,50,255,50,100,210}
new Color3[]={10,0,200,255,200,0,10}
public GrenadeAttack(id, Float:AimOrigin[3], numnum)
{	
	AimOrigin[0]+=coords[numnum]
	AimOrigin[1]+=coords[numnum]
	
	new ent=fm_create_entity("info_target")
	
	if(!ent) return

set_pev(ent, pev_classname, "robo_rocket")	
	
	set_pev(ent, pev_owner, pev(id, pev_euser2))
	set_pev(ent, pev_euser2, id)
	
	new Float:Origin[3], Float:Velocity[3]
	pev(id, pev_origin, Origin)
	Origin[2]+=70.0
	set_pev(ent, pev_origin, Origin)
	
	fm_entity_set_model(ent,GrenadeModel)

set_pev(ent, pev_solid, SOLID_BBOX)
	set_pev(ent, pev_movetype, MOVETYPE_TOSS)

fm_entity_set_size(ent,Float:{0.0, 0.0, 0.0},Float:{0.0, 0.0, 0.0})

set_pev(ent, pev_gravity, 0.8)

xs_vec_sub(AimOrigin, Origin, AimOrigin)
	xs_vec_normalize(AimOrigin, Velocity)
	xs_vec_mul_scalar(Velocity, 2000.0, Velocity)
	Velocity[2]+=random_float(1.0, 5.0)
	
	vector_to_angle(AimOrigin, AimOrigin)

message_begin(MSG_BROADCAST, SVC_TEMPENTITY)
	write_byte(TE_BEAMFOLLOW)
	write_short(ent)
	write_short(g_iBeam2)
	write_byte(20)
	write_byte(2)
	write_byte(Color1[numnum])
	write_byte(Color2[numnum])
	write_byte(Color3[numnum])
	write_byte(255)
	message_end()	
	
	set_pev(ent, pev_euser1, CreateFlare(ent, float(Color1[numnum]), float(Color2[numnum]), float(Color3[numnum])))
	 	
	set_pev(ent, pev_angles, AimOrigin)
	set_pev(ent, pev_velocity, Velocity)
}

CreateFlare(iAttachTo, Float:color1, Float:color2, Float:color3)
{
    new iEnt = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "env_sprite"));
    engfunc(EngFunc_SetModel, iEnt, SPRITE_FLARE);
    
    set_pev(iEnt, pev_scale, 0.3);
    set_pev(iEnt, pev_spawnflags, SF_SPRITE_STARTON);
    
    set_pev(iEnt, pev_solid, SOLID_NOT);
    set_pev(iEnt, pev_movetype, MOVETYPE_FOLLOW);
    set_pev(iEnt, pev_aiment, iAttachTo);
    
    new Float:color[3]
    color[0]=color1
    color[1]=color2
    color[2]=color3
    
    set_pev(iEnt, pev_rendercolor, color);
    set_pev(iEnt, pev_renderamt, 255.0);
    set_pev(iEnt, pev_rendermode, kRenderTransAdd);
    set_pev(iEnt, pev_renderfx, kRenderFxNone);
    
    set_kvd(0, KV_KeyName, "framerate");
    set_kvd(0, KV_Value, "18.0");
    dllfunc(DLLFunc_KeyValue, iEnt, 0);
    dllfunc(DLLFunc_Spawn, iEnt);
    
    return iEnt
}

public touch_rocket(ent, id)
{
	new Float:Origin[3]
	pev(ent, pev_origin, Origin)
	
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY)
	write_byte(TE_EXPLOSION)
	engfunc(EngFunc_WriteCoord, Origin[0])
	engfunc(EngFunc_WriteCoord, Origin[1])
	engfunc(EngFunc_WriteCoord, Origin[2])
	write_short(explode_spr)
	write_byte(random_num(5, 10))
	write_byte(random_num(28, 40))
	write_byte(0)
	message_end()	
	
	new victim=FM_NULLENT

while((victim=fm_find_ent_in_sphere(victim, Origin, 200.0))!=0)
	{	
		if(pev(victim, pev_takedamage)!=DAMAGE_NO&&pev(victim, pev_solid)!=SOLID_NOT)
		{
			if(1<=victim<=32)
			{
				if(is_user_alive(victim))
				{
					if(pev(pev(ent, pev_euser2), pev_body)!=fm_cs_get_user_team(victim)){
						
						new Float:Health
						pev(victim, pev_health, Health)
						if(Health>1.0) {
								ExecuteHamB(Ham_TakeDamage, victim, ent, pev(ent, pev_owner), 1.0, DMG_BLAST)
						}else {
								ExecuteHamB(Ham_TakeDamage, victim, ent, pev(ent, pev_owner), 100.0, DMG_BULLET)
								set_pev(pev(ent, pev_euser2), pev_iuser3, pev(pev(ent, pev_euser2), pev_iuser3)+1)
						}	
					}
						
				}
			}
		}
	}
	
	fm_remove_entity(pev(ent, pev_euser1))
	fm_remove_entity(ent)
}

tracer(Float:start[3], Float:end[3]) 
{
	new start_[3], end_[3]
	FVecIVec(start, start_)
	FVecIVec(end, end_)
	message_begin(MSG_BROADCAST, SVC_TEMPENTITY) //  MSG_PAS MSG_BROADCAST
	write_byte(TE_TRACER)
	write_coord(start_[0])
	write_coord(start_[1])
	write_coord(start_[2])
	write_coord(end_[0])
	write_coord(end_[1])
	write_coord(end_[2])
	message_end()
}

stock set_anim(ent, sequence) 
{
	set_pev(ent, pev_sequence, sequence)
	set_pev(ent, pev_animtime, halflife_time())
	set_pev(ent, pev_framerate, 1.0)
}

bool:TraceCheckCollides(Float:origin[3], const Float:BOUNDS)
{
	new Float:traceEnds[8][3], Float:traceHit[3], hitEnt
	
	traceEnds[0][0] = origin[0] - BOUNDS
	traceEnds[0][1] = origin[1] - BOUNDS
	traceEnds[0][2] = origin[2] - BOUNDS
	
	traceEnds[3][0] = origin[0] + BOUNDS
	traceEnds[3][1] = origin[1] + BOUNDS
	traceEnds[3][2] = origin[2] + BOUNDS
	
	traceEnds[2][0] = origin[0] - BOUNDS
	traceEnds[2][1] = origin[1] + BOUNDS
	traceEnds[2][2] = origin[2] + BOUNDS
	
	traceEnds[4][0] = origin[0] + BOUNDS
	traceEnds[4][1] = origin[1] - BOUNDS
	traceEnds[4][2] = origin[2] - BOUNDS
	
	traceEnds[1][0] = origin[0] - BOUNDS
	traceEnds[1][1] = origin[1] - BOUNDS
	traceEnds[1][2] = origin[2] + BOUNDS
	
	traceEnds[5][0] = origin[0] + BOUNDS
	traceEnds[5][1] = origin[1] + BOUNDS
	traceEnds[5][2] = origin[2] - BOUNDS
	
	traceEnds[6][0] = origin[0] + BOUNDS
	traceEnds[6][1] = origin[1] - BOUNDS
	traceEnds[6][2] = origin[2] + BOUNDS
	
	traceEnds[7][0] = origin[0] - BOUNDS
	traceEnds[7][1] = origin[1] + BOUNDS
	traceEnds[7][2] = origin[2] - BOUNDS
	
	for (new i = 0; i < 8; i++) 
	{
		if (point_contents(traceEnds[i]) != CONTENTS_EMPTY) return true
		hitEnt = trace_line(0, origin, traceEnds[i], traceHit)
		if (hitEnt != 0) return true
		for (new j = 0; j < 3; j++) if (traceEnds[i][j] != traceHit[j]) return true
	}
	return false
}

Загрузил ADEPT

2018-10-30 21:19:19

239

Скачать

91.211.118.38:27015

91.211.118.156:27073

УКРАЇНА - Б А Н Д Е Р Ш Т А Т - [2000 FPS] 18+

91.211.118.156:27071

УКРАЇНСЬКІ - ДІВЧАТА - [ RYZEN 9 - 5.7 GHZ ]

91.211.118.49:27030

91.211.118.150:27019

К І Б О Р Г И - У К Р А Ї Н И [RYZEN 9 - 4.7 GHZ]

91.211.118.49:27037

він стріляє но не вбиває навіть хп не знімає

dizykr

2024-01-07 14:30:29

Данная иконка означает, что плагин был проверен администрацией хостинга на тестовом сервере, и проблем с ним не было выявлено. Рекомендуем ставить исключительно проверенные плагины.

Плагин загружен на сервер, но проверка еще не была проведена.

Игровые сервера	Дополнительные услуги		Инфо	Сообщество

Counter-Strike 1.6 Counter-Strike: Source Counter-Strike: GO Counter-Strike 2 Garry's Mod Remote	VDS/VPS Dedicated Remote Вебхостинг CASSA	Scanmon Fast DL Backup Каталог проэктов Проверка IP ^new	Help Тарифы Партнерка Новости Оферта	Форум Мониторинг Плагины vk.com steam Telegram