hlmod.hu

#include <amxmodx>
#include <engine>
#include <fakemeta>
#include <hamsandwich>
#include <zombieplague>
 
#define PLUGIN "ZP Addon QuadDamage"
#define VERSION "1.0.1"
#define AUTHOR "yokomo"
 
enum (+= 100)
{
	TASK_QUAD_SPAWN = 2011,
	TASK_QUAD_TIME
}
 
#define ID_QUAD_TIME (taskid - TASK_QUAD_TIME)
 
const GLOW_R = 0
const GLOW_G = 100
const GLOW_B = 200
const MAX_SPAWNS = 128
 
new const SOUND_QUAD[] = "zombie_plague/quaddmgvox.wav"
new const SOUND_QUAD_SPAWN[] = "items/suitchargeok1.wav"
new const MODEL_QUAD[] = "models/bskull_template1.mdl"
new const CLASSNAME_QUAD[] = "quad_ent"
 
new cvar_spawntime, cvar_dmgtime, cvar_dmgmulti
new g_spawnCount, g_spawnCount2, g_maxplayers, g_roundend
new g_hamczbots, cvar_botquota
new Float:g_spawns[MAX_SPAWNS][3], Float:g_spawns2[MAX_SPAWNS][3]
new g_has_quad[33], g_time_quad[33]
 
public plugin_precache()
{
	precache_sound(SOUND_QUAD)
	precache_sound(SOUND_QUAD_SPAWN)
	precache_model(MODEL_QUAD)
}
 
public plugin_init()
{
	register_plugin(PLUGIN, VERSION, AUTHOR)
 
	register_event("HLTV", "EventRoundStart", "a", "1=0", "2=0")
	register_logevent("logevent_round_end", 2, "1=Round_End")
 
	RegisterHam(Ham_Killed, "player", "fw_PlayerKilled")
	RegisterHam(Ham_TakeDamage, "player", "fw_TakeDamage")
 
	register_forward(FM_Touch, "fw_Touch")
 
	CreateQuadSpawnPoints()
 
	cvar_spawntime = register_cvar("zp_quad_spawntime", "30")
	cvar_dmgtime = register_cvar("zp_quad_quadtime", "60")
	cvar_dmgmulti = register_cvar("zp_quad_dmgmulti", "4")
	cvar_botquota = get_cvar_pointer("bot_quota")
 
	g_maxplayers = get_maxplayers()
}
 
public client_putinserver(id)
{
	ResetValuePlayer(id)
 
	if(is_user_bot(id) && !g_hamczbots && cvar_botquota) set_task(0.1, "register_ham_czbots", id)
}
 
public client_disconnect(id)
{
	ResetValuePlayer(id)
}
 
public EventRoundStart()
{
	remove_task(TASK_QUAD_SPAWN)
	RemoveQuadEntity()
 
	for(new id = 1; id <= g_maxplayers; id++)
	{
		if(!is_user_connected(id)) continue
		ResetValuePlayer(id)
	}
}
 
public logevent_round_end()
{
	g_roundend = 1
}
 
public register_ham_czbots(id)
{
	if (g_hamczbots || !is_user_connected(id) || !get_pcvar_num(cvar_botquota)) return
 
	RegisterHamFromEntity(Ham_Killed, id, "fw_PlayerKilled")
	RegisterHamFromEntity(Ham_TakeDamage, id, "fw_TakeDamage")
 
	g_hamczbots = true
}
 
public zp_round_started(mode)
{
	g_roundend = 0
 
	if(mode != MODE_SURVIVOR) set_task(get_pcvar_float(cvar_spawntime), "CreateQuadEntity", TASK_QUAD_SPAWN)
}
 
public zp_user_infected_post(id, infector)
{
	if(!id || !infector) return
 
	ResetValuePlayer(id)
}
 
public fw_PlayerKilled(victim, attacker, shouldgib)
{
	ResetValuePlayer(victim)
}
 
public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damage_type)
{
	if(victim == attacker) return HAM_IGNORED
 
	if(g_roundend) return HAM_SUPERCEDE
 
	if(!pev_valid(victim) || !is_user_connected(attacker)) return HAM_IGNORED
 
	if(g_has_quad[attacker])
	{
		SetHamParamFloat(4, damage*get_pcvar_float(cvar_dmgmulti))
	}
 
	return HAM_IGNORED
}
 
public fw_Touch(ent, id)
{
	if(!pev_valid(ent) || !is_user_alive(id) || zp_get_user_zombie(id) || zp_get_user_survivor(id) || g_roundend) return FMRES_IGNORED
 
	if(g_has_quad[id]) return FMRES_IGNORED
 
	new classname[32]
	pev(ent, pev_classname, classname, 31)
	if(!(equal(classname, CLASSNAME_QUAD))) return FMRES_IGNORED
 
	engfunc(EngFunc_RemoveEntity, ent)
 
	g_has_quad[id] = 1
	emit_sound(id, CHAN_VOICE, SOUND_QUAD, 1.0, ATTN_NORM, 0, PITCH_NORM)
	set_rendering(id, kRenderFxGlowShell, GLOW_R, GLOW_G, GLOW_B, kRenderNormal, 5)
 
	g_time_quad[id] = get_pcvar_num(cvar_dmgtime)
	remove_task(TASK_QUAD_TIME)
	set_task(1.0, "CountDownStart", id+TASK_QUAD_TIME, _, _, "b")
 
	remove_task(TASK_QUAD_SPAWN)
	set_task(get_pcvar_float(cvar_spawntime), "CreateQuadEntity", TASK_QUAD_SPAWN)
 
	return FMRES_IGNORED
}
 
public CountDownStart(taskid)
{	
	if(!g_time_quad[ID_QUAD_TIME])
	{
		g_has_quad[ID_QUAD_TIME] = 0
 
		remove_task(taskid)
		set_rendering(ID_QUAD_TIME)
	}
	else if(g_time_quad[ID_QUAD_TIME]<=get_pcvar_num(cvar_dmgtime))
	{
		set_hudmessage(GLOW_R, GLOW_G, GLOW_B, 0.56, 0.76, 0, 1.0, 1.0)
		show_hudmessage(ID_QUAD_TIME, "Extra Sebzes: %d", g_time_quad[ID_QUAD_TIME])
		g_time_quad[ID_QUAD_TIME] -= 1
	}
}
 
public CreateQuadEntity()
{
	if(g_roundend) return
 
	new ent = engfunc(EngFunc_CreateNamedEntity, engfunc(EngFunc_AllocString, "info_target"))
	set_pev(ent, pev_classname, CLASSNAME_QUAD)
	MakeRandomOrigin(ent)
	engfunc(EngFunc_SetModel, ent, MODEL_QUAD)
	engfunc(EngFunc_SetSize, ent, Float:{-4.0,-4.0,-4.0}, Float:{4.0,4.0,4.0})
	set_pev(ent, pev_solid, SOLID_TRIGGER)
	set_pev(ent, pev_movetype, MOVETYPE_BOUNCE)
	set_rendering(ent, kRenderFxGlowShell, GLOW_R, GLOW_G, GLOW_B, kRenderNormal, 5)
	emit_sound(ent, CHAN_VOICE, SOUND_QUAD_SPAWN, 1.0, ATTN_NORM, 0, PITCH_NORM)
}
 
CreateQuadSpawnPoints()
{
	collect_spawns_ent("info_player_start")
	collect_spawns_ent("info_player_deathmatch")
 
	collect_spawns_ent2("info_player_start")
	collect_spawns_ent2("info_player_deathmatch")
}
 
collect_spawns_ent(const classname[])
{
	new ent = -1
	while ((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", classname)) != 0)
	{
		new Float:originF[3]
		pev(ent, pev_origin, originF)
		g_spawns[g_spawnCount][0] = originF[0]
		g_spawns[g_spawnCount][1] = originF[1]
		g_spawns[g_spawnCount][2] = originF[2]
 
		g_spawnCount++
		if (g_spawnCount >= sizeof g_spawns) break
	}
}
 
collect_spawns_ent2(const classname[])
{
	new ent = -1
	while ((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", classname)) != 0)
	{
		new Float:originF[3]
		pev(ent, pev_origin, originF)
		g_spawns2[g_spawnCount2][0] = originF[0]
		g_spawns2[g_spawnCount2][1] = originF[1]
		g_spawns2[g_spawnCount2][2] = originF[2]
 
		g_spawnCount2++
		if (g_spawnCount2 >= sizeof g_spawns2) break
	}
}
 
MakeRandomOrigin(id, regularspawns = 0)
{
	static hull, sp_index, i
 
	hull = (pev(id, pev_flags) & FL_DUCKING) ? HULL_HEAD : HULL_HUMAN
 
	if (!regularspawns)
	{
		if (!g_spawnCount)
			return
 
		sp_index = random_num(0, g_spawnCount - 1)
 
		for (i = sp_index + 1; /*no condition*/; i++)
		{
			if (i >= g_spawnCount) i = 0
 
			if (is_hull_vacant(g_spawns[i], hull))
			{
				engfunc(EngFunc_SetOrigin, id, g_spawns[i])
				break
			}
 
			if (i == sp_index) break
		}
	}
	else
	{
		if (!g_spawnCount2)
			return
 
		sp_index = random_num(0, g_spawnCount2 - 1)
 
		for (i = sp_index + 1; /*no condition*/; i++)
		{
			if (i >= g_spawnCount2) i = 0
 
			if (is_hull_vacant(g_spawns2[i], hull))
			{
				engfunc(EngFunc_SetOrigin, id, g_spawns2[i])
				break
			}
 
			if (i == sp_index) break
		}
	}
}
 
is_hull_vacant(Float:origin[3], hull)
{
	engfunc(EngFunc_TraceHull, origin, origin, 0, hull, 0, 0)
 
	if (!get_tr2(0, TR_StartSolid) && !get_tr2(0, TR_AllSolid) && get_tr2(0, TR_InOpen))
		return true;
 
	return false;
}
 
RemoveQuadEntity()
{
	static ent
	ent = engfunc(EngFunc_FindEntityByString, -1, "classname", CLASSNAME_QUAD)
	while(ent > 0)
	{
		engfunc(EngFunc_RemoveEntity, ent)
		ent = engfunc(EngFunc_FindEntityByString, -1, "classname", CLASSNAME_QUAD)
	}
}
 
ResetValuePlayer(id)
{
	remove_task(id+TASK_QUAD_TIME)
 
	g_has_quad[id] = 0
	g_time_quad[id] = 0
}
/* AMXX-Studio Notes - DO NOT MODIFY BELOW HERE
*{\\ rtf1\\ ansi\\ deff0{\\ fonttbl{\\ f0\\ fnil Tahoma;}}\n\\ viewkind4\\ uc1\\ pard\\ lang1033\\ f0\\ fs16 \n\\ par }
*/