#include <amxmodx>
#include <amxmisc>
#include <engine>
#include <fakemeta>
#include <hamsandwich>
#include <zombieplague>

#define PLUGIN "NPC"
#define VERSION "1.0"
#define AUTHOR "Dias"

#define NPC_CLASSNAME "witch"
#define NPC_HEALTH 1000.0

#define TASK_CRY 11111
#define TASK_STARTATTACK 11112
#define TASK_ATTACKING 11113
#define TASK_AURA 11114

#define MAX_WITCH 3

const MAX_NPC = 512
new npc_modelindex, g_hamnpc, Float:g_myorigin[3], g_ena
new const npc_model[] = "models/player/zombie_witch/zombie_witch.mdl"
new npc_victim[MAX_NPC]
new g_think[MAX_NPC], g_madness[MAX_NPC]
new cache_blood, cache_bloodspray

// spawns & way points
new const SPAWNS_FILE[] = "%s/npc_witch/%s.cfg"
const MAX_SPAWNS = 128
new Float:g_spawns[MAX_SPAWNS][3], g_total_spawns

enum
{
	THINK_DEATH = 1,
	THINK_REMOVE
}

new const witch_cry[][] = {
	"npc_witch/female_cry_1.wav",
	"npc_witch/female_cry_2.wav",
	"npc_witch/female_cry_3.wav"
}

new const witch_madness[][] = {
	"npc_witch/female_ls_d_madscream01.wav",
	"npc_witch/female_ls_d_madscream02.wav",
	"npc_witch/female_ls_d_madscream03.wav"
}

new const witch_startattack[][] = {
	"npc_witch/female_distantscream1.wav",
	"npc_witch/female_distantscream2.wav"
}

new const witch_death[][] = {
	"npc_witch/female_death_1.wav",	
	"npc_witch/headshot_death_1.wav",
	"npc_witch/headshot_death_2.wav",
	"npc_witch/headshot_death_3.wav"
}

new const witch_pain[][] = {
	"npc_witch/witch_pain_1.wav",
	"npc_witch/witch_pain_2.wav",
	"npc_witch/witch_pain_3.wav"
}

new const killed_by_witch[] = "npc_witch/killed_by_witch.wav"

public plugin_init()
{
	register_plugin(PLUGIN, VERSION, AUTHOR)
	
	register_clcmd("dias_make_witch", "event_newround")
	register_clcmd("dias_get_origin", "get_origin")
}

public plugin_precache()
{
	npc_modelindex = engfunc(EngFunc_PrecacheModel, npc_model)

	cache_blood = engfunc(EngFunc_PrecacheModel, "sprites/blood.spr")
	cache_bloodspray = engfunc(EngFunc_PrecacheModel, "sprites/bloodspray.spr")

	new i
	for(i = 0; i < sizeof(witch_cry); i++)
		engfunc(EngFunc_PrecacheSound, witch_cry[i])	
	for(i = 0; i < sizeof(witch_madness); i++)
		engfunc(EngFunc_PrecacheSound, witch_madness[i])
	for(i = 0; i < sizeof(witch_startattack); i++)
		engfunc(EngFunc_PrecacheSound, witch_startattack[i])
	for(i = 0; i < sizeof(witch_death); i++)
		engfunc(EngFunc_PrecacheSound, witch_death[i])
	for(i = 0; i < sizeof(witch_pain); i++)
		engfunc(EngFunc_PrecacheSound, witch_pain[i])
	engfunc(EngFunc_PrecacheSound, killed_by_witch)
	
	load_spawn_points()
}

public event_newround(id)
{
	create_npc()
		
	client_print(id, print_chat, "CREATED")
}

stock collect_spawn(Float:origin[3])
{
	for (new i=1; i<=g_total_spawns*3; i++)
	{
		origin = g_spawns[random(g_total_spawns)]
		if (check_spawn(origin)) return 1;
	}

	return 0;
}

stock check_spawn(Float:origin[3])
{
	new Float:originE[3], Float:origin1[3], Float:origin2[3]
	new ent = -1
	while ((ent = engfunc(EngFunc_FindEntityByString, ent, "classname", NPC_CLASSNAME)) != 0)
	{
		pev(ent, pev_origin, originE)
		
		// xoy
		origin1 = origin
		origin2 = originE
		origin1[2] = origin2[2] = 0.0
		if (vector_distance(origin1, origin2) <= 2 * 16.0)
		{
			// oz
			origin1 = origin
			origin2 = originE
			origin1[0] = origin2[0] = origin1[1] = origin2[1] = 0.0
			if (vector_distance(origin1, origin2) <= 36.0) return 0;
		}
	}
	return 1;
}

// load spawn points
load_spawn_points()
{
	// Check for spawns points of the current map
	new cfgdir[32], mapname[32], filepath[100], linedata[64]
	get_configsdir(cfgdir, charsmax(cfgdir))
	get_mapname(mapname, charsmax(mapname))
	formatex(filepath, charsmax(filepath), SPAWNS_FILE, cfgdir, mapname)
	
	// Load spawns points
	if (file_exists(filepath))
	{
		new file = fopen(filepath,"rt"), row[4][6]
		
		while (file && !feof(file))
		{
			fgets(file, linedata, charsmax(linedata))
			
			// invalid spawn
			if(!linedata[0] || str_count(linedata,' ') < 2) continue;
			
			// get spawn point data
			parse(linedata,row[0],5,row[1],5,row[2],5,row[3],5)
			
			// origin
			if (g_total_spawns<MAX_SPAWNS)
			{
				g_spawns[g_total_spawns][0] = floatstr(row[1])
				g_spawns[g_total_spawns][1] = floatstr(row[2])
				g_spawns[g_total_spawns][2] = floatstr(row[3])
				g_total_spawns++
			}
		}
		if (file) fclose(file)
	}
}

stock str_count(const str[], searchchar)
{
	new count, i, len = strlen(str)
	
	for (i = 0; i <= len; i++)
	{
		if(str[i] == searchchar)
			count++
	}
	
	return count;
}

public get_origin(id)
{
	g_ena = 1
	pev(id, pev_origin, g_myorigin)
}

public create_npc()
{
	new ent = create_entity("info_target")
	
	dllfunc(DLLFunc_Spawn, ent)
	entity_set_string(ent, EV_SZ_classname, NPC_CLASSNAME)
	
	static Float:Origin[3]
	collect_spawn(Origin)
	
	if(g_ena)
	{
		entity_set_origin(ent, g_myorigin)
	} else {
		entity_set_origin(ent, Origin)
	}
	set_pev(ent, pev_health, NPC_HEALTH)
	
	entity_set_model(ent, npc_model)
	entity_set_int(ent, EV_INT_modelindex, npc_modelindex)	
	entity_set_int(ent, EV_INT_solid, SOLID_SLIDEBOX)
	entity_set_int(ent, EV_INT_movetype, MOVETYPE_FLY)
	
	entity_set_float(ent, EV_FL_animtime, get_gametime())
	entity_set_float(ent, EV_FL_framerate,1.0)
	entity_set_float(ent, EV_FL_gravity, 1.0)
	entity_set_float(ent, EV_FL_takedamage, 1.0)
	entity_set_float(ent, EV_FL_nextthink, halflife_time() + 0.1)

	new Float:maxs[3] = {16.0,16.0,36.0}
	new Float:mins[3] = {-16.0,-16.0,-36.0}
	entity_set_size(ent, mins, maxs)
	
	entity_set_byte(ent, EV_BYTE_controller1, 125)
	entity_set_byte(ent, EV_BYTE_controller2, 125)
	entity_set_byte(ent, EV_BYTE_controller3, 125)
	entity_set_byte(ent, EV_BYTE_controller4, 125)	
	
	set_task(0.1, "make_aura", ent+TASK_AURA, _, _, "b")
	
	g_madness[ent] = 0
	g_think[ent] = 0
	npc_victim[ent] = 0
	
	drop_to_floor(ent)
	
	set_task(5.0, "witch_do_cry", ent+TASK_CRY, _, _, "b")
	
	if (!g_hamnpc)
	{
		RegisterHamFromEntity(Ham_TakeDamage, ent, "fw_TakeDamage")
		RegisterHamFromEntity(Ham_Think, ent, "fw_think")
		RegisterHamFromEntity(Ham_Touch, ent, "fw_touch")

		g_hamnpc = 1
	}	
}

public witch_do_cry(ent)
{
	ent -= TASK_CRY
	
	if(g_think[ent] == THINK_DEATH || g_think[ent] == THINK_REMOVE || g_madness[ent] != 0)
	{
		remove_task(ent+TASK_CRY)
		return
	}
	
	emit_sound(ent, CHAN_AUTO, witch_cry[random_num(0, charsmax(witch_cry))], 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public make_aura(ent)
{
	ent -= TASK_AURA
	
	if(g_think[ent] == THINK_DEATH || g_think[ent] == THINK_REMOVE)
	{
		remove_task(ent+TASK_AURA)
		return
	}
	
	static Float:origin[3]
	pev(ent, pev_origin, origin)
	
	message_begin(MSG_BROADCAST,SVC_TEMPENTITY);
	write_byte(27)
	write_coord(floatround(origin[0]))
	write_coord(floatround(origin[1]))
	write_coord(floatround(origin[2]))
	write_byte(10)
	write_byte(255)
	write_byte(0)
	write_byte(0)
	write_byte(100)
	write_byte(60)
	message_end()
}

public fw_TakeDamage(victim, inflictor, attacker, Float:damage, damage_type)
{	
	if (victim == attacker)
		return HAM_IGNORED
	
	if (!pev_valid(victim) || !pev_valid(attacker))
		return HAM_IGNORED
	
	if (is_user_connected(victim) && is_user_connected(attacker))
		return HAM_SUPERCEDE
	
	if(zp_get_user_zombie(attacker))
		return FMRES_IGNORED
	
	new classname[32]
	pev(victim, pev_classname, classname, charsmax(classname))
	
	if (equal(classname, NPC_CLASSNAME))
	{
		if (g_think[victim] == THINK_DEATH || g_think[victim] == THINK_REMOVE) return HAM_SUPERCEDE
		
		// get aim
		new aimOrigin[3], target, body
		get_user_origin(attacker, aimOrigin, 3)
		get_user_aiming(attacker, target, body)
		
		// fix hit body damage
		if (!(damage_type & DMG_BULLET)) damage = float(get_damage_body(body, damage))
		
		// set new damage
		SetHamParamFloat(4, damage)
		
		// create block sprites
		if (damage_type & DMG_BULLET) 
			create_blood(aimOrigin)
		
		emit_sound(victim, CHAN_AUTO, witch_pain[random_num(0, charsmax(witch_pain))], 1.0, ATTN_NORM, 0, PITCH_NORM)
		
		// NPC die
		if (0.0 < pev(victim, pev_health) <= damage)
		{
			set_pev(victim, pev_health, 0.0)
			
			static Float:reset[3]
			entity_set_size(victim, reset, reset)
			entity_set_vector(victim, EV_VEC_velocity, reset)
			set_anim(victim, 128)
			
			emit_sound(victim, CHAN_AUTO, witch_death[random_num(0, charsmax(witch_death))], 1.0, ATTN_NORM, 0, PITCH_NORM)
			
			g_think[victim] = THINK_DEATH
			
			return HAM_SUPERCEDE
		}
		else
		{
			set_anim(victim, 127)
			
			if(!g_madness[victim])
			{
				npc_victim[victim] = attacker
				
				static name[32]
				get_user_name(attacker, name, sizeof(name))
				
				client_print(0, print_chat, "%s has started the Witch !!!", name)	
				
				g_madness[victim] = 2
				
				emit_sound(victim, CHAN_AUTO, witch_startattack[random_num(0, charsmax(witch_startattack))], 1.0, ATTN_NORM, 0, PITCH_NORM)
				
				set_task(3.0, "start_attack", victim+TASK_STARTATTACK)
				set_task(1.5, "witch_do_madness", victim+TASK_ATTACKING, _, _, "b")
			}
		}
		
	}
	
	return HAM_IGNORED
}

public start_attack(ent)
{
	ent -= TASK_STARTATTACK
	
	g_madness[ent] = 1
}

public witch_do_madness(ent)
{
	ent -= TASK_ATTACKING
	
	if(g_think[ent] == THINK_DEATH || g_think[ent] == THINK_REMOVE || g_madness[ent] != 1)
	{
		remove_task(ent+TASK_ATTACKING)
		return
	}
	
	emit_sound(ent, CHAN_AUTO, witch_madness[random_num(0, charsmax(witch_madness))], 1.0, ATTN_NORM, 0, PITCH_NORM)
}

public fw_think(ent)
{
	if(g_think[ent] == THINK_DEATH || g_think[ent] == THINK_REMOVE)
		return HAM_IGNORED
	
	if(g_madness[ent] == 2)
	{
		set_anim(ent, 1)
		} else if(g_madness[ent] == 1) {	
		static victim
		victim = npc_victim[ent]
		
		static Float:Origin[3], Float:VicOrigin[3], Float:distance
		
		pev(ent, pev_origin, Origin)
		pev(victim, pev_origin, VicOrigin)
		
		distance = get_distance_f(Origin, VicOrigin)		
		
		if(is_user_alive(victim))
		{
			if(distance <= 60.0)
			{
				new Float:Ent_Origin[3], Float:Vic_Origin[3]
				
				pev(ent, pev_origin, Ent_Origin)
				pev(victim, pev_origin, Vic_Origin)			
				
				witch_attack(ent, victim)
				} else {
				set_anim(ent, 4)
				
				new Float:Ent_Origin[3], Float:Vic_Origin[3]
				
				pev(ent, pev_origin, Ent_Origin)
				pev(victim, pev_origin, Vic_Origin)
				
				npc_turntotarget(ent, Ent_Origin, victim, Vic_Origin)
				
				
				hook_ent(ent, victim)
				
				entity_set_float(ent, EV_FL_nextthink, get_gametime() + 0.5)
			}
		} else {
			g_madness[ent] = 0
			set_task(5.0, "witch_do_cry", ent+TASK_CRY, _, _, "b")
				
			remove_task(ent+TASK_ATTACKING)
		}
		} else if(!g_madness[ent]) {
		set_anim(ent, 0)
	}
	
	entity_set_float(ent, EV_FL_nextthink, halflife_time() + 0.1)
	
	return HAM_HANDLED
}

public fw_touch(witch, id)
{
	if(g_think[witch] == THINK_DEATH || g_think[witch] == THINK_REMOVE)
		return HAM_IGNORED
	
	if(!is_user_alive(id))
		return HAM_IGNORED
	
	if(g_madness[witch] != 1)
		return HAM_IGNORED
	
	set_anim(witch, 85)
	user_kill(id)
	emit_sound(id, CHAN_AUTO, killed_by_witch, 1.0, ATTN_NORM, 0, PITCH_NORM)
	
	static name[32]
	get_user_name(id, name, sizeof(name))
	
	client_print(0, print_chat, "%s has been killed by Witch !!!", name)		
	
	return HAM_HANDLED
}

public witch_attack(ent, victim)
{
	set_anim(ent, 85)
	
	emit_sound(victim, CHAN_AUTO, killed_by_witch, 1.0, ATTN_NORM, 0, PITCH_NORM)
	user_kill(victim)
	
	static name[32]
	get_user_name(victim, name, sizeof(name))
	
	client_print(0, print_chat, "%s has been killed by Witch !!!", name)		
}

stock set_anim(ent, anim)
{
	if (pev(ent, pev_sequence) != anim)
	{
		entity_set_float(ent, EV_FL_animtime, get_gametime())
		entity_set_int(ent, EV_INT_sequence, anim)
	}
}

stock create_blood(const origin[3])
{
	// Show some blood :)
	message_begin(MSG_BROADCAST, SVC_TEMPENTITY) 
	write_byte(TE_BLOODSPRITE)
	write_coord(origin[0])
	write_coord(origin[1])
	write_coord(origin[2])
	write_short(cache_bloodspray)
	write_short(cache_blood)
	write_byte(75)
	write_byte(5)
	message_end()
}

stock get_damage_body(body, Float:damage)
{
	switch (body)
	{
		case HIT_HEAD: damage *= 4.0
			case HIT_STOMACH: damage *= 1.25
			case HIT_LEFTLEG: damage *= 0.75
			case HIT_RIGHTLEG: damage *= 0.75
			default: damage *= 1.0
	}
	
	return floatround(damage);
}

stock npc_turntotarget(ent, Float:Ent_Origin[3], target, Float:Vic_Origin[3]) 
{
	if(target) 
	{
		new Float:newAngle[3]
		entity_get_vector(ent, EV_VEC_angles, newAngle)
		new Float:x = Vic_Origin[0] - Ent_Origin[0]
		new Float:z = Vic_Origin[1] - Ent_Origin[1]
		
		new Float:radians = floatatan(z/x, radian)
		newAngle[1] = radians * (180 / 3.14)
		if (Vic_Origin[0] < Ent_Origin[0])
			newAngle[1] -= 180.0
		
		entity_set_vector(ent, EV_VEC_angles, newAngle)
	}
}

stock hook_ent(ent, victim)
{
	static Float:fl_Velocity[3]
	static Float:VicOrigin[3], Float:EntOrigin[3]
	static Float:Speed
	
	pev(ent, pev_origin, EntOrigin)
	pev(victim, pev_origin, VicOrigin)
	Speed = 400.0
	
	static Float:distance_f
	distance_f = get_distance_f(EntOrigin, VicOrigin)
	
	if (distance_f > 60.0)
	{
		new Float:fl_Time = distance_f / Speed
		
		fl_Velocity[0] = (VicOrigin[0] - EntOrigin[0]) / fl_Time
		fl_Velocity[1] = (VicOrigin[1] - EntOrigin[1]) / fl_Time
		fl_Velocity[2] = (VicOrigin[2] - EntOrigin[2]) / fl_Time
	} else {
		fl_Velocity[0] = 0.0
		fl_Velocity[1] = 0.0
		fl_Velocity[2] = 0.0
	}

	entity_set_vector(ent, EV_VEC_velocity, fl_Velocity)
}