#pragma semicolon 1

#define DEBUG

#define PLUGIN_AUTHOR "jenz"
#define PLUGIN_VERSION "1.6"
#define generic_length 256

#include <sourcemod>
#include <sdktools>
#include <sdkhooks>
#include <outputinfo>
#include <socket>

//#pragma newdecls required
int target_human_afk_counter[MAXPLAYERS + 1];
int targethuman[MAXPLAYERS + 1];
int target_enemy[MAXPLAYERS + 1];
int buttons_old[MAXPLAYERS + 1];
int flags_old[MAXPLAYERS + 1];
int ports[4] = {48479, 48482, 48476, 48481};
bool surf_cooldown = false;
int bot_avoid_edge[MAXPLAYERS + 1];
float client_old_coords[MAXPLAYERS + 1][3];
float targethuman_teleported[MAXPLAYERS + 1][3];
bool chat_cooldown = false;

//admins & vips
bool admins[MAXPLAYERS + 1];
bool vips[MAXPLAYERS + 1];
bool rtv;

//socket for bot input
Handle global_socket;

public Plugin myinfo = 
{
	name = "coordinates for the bot",
	author = PLUGIN_AUTHOR,
	description = "hello ",
	version = PLUGIN_VERSION,
	url = ""
};

public void OnPluginStart()
{
	rtv = false;
	for (int i = 1; i <= MaxClients; i++)
        	if (IsValidClient(i))
		{
			targethuman[i] = 0;
			target_enemy[i] = 0;
			reset_target_human_tp_coord(i);
		}
	//talking
	RegConsoleCmd("sm_autism", cmd_talk, "talking to the bot through java application");
	RegConsoleCmd("sm_rtv", cmd_botrtv, "making bots rtv");
	
	//hooks
	HookEvent("round_start", Event_RoundStart, EventHookMode_PostNoCopy);
	HookEntityOutput("trigger_multiple", "OnTrigger", Trigger_Multiple);
	HookEntityOutput("trigger_multiple", "OnStartTouch", Trigger_Multiple);
	HookEntityOutput("trigger_teleport", "OnTrigger", trigger_teleport);
	HookEntityOutput("trigger_teleport", "OnStartTouch", trigger_teleport);
	
	//UDP connection
	connect_socket();
	chat_cooldown = false;
}

public void reset_target_human_tp_coord(int client)
{
	targethuman_teleported[client][0] = 0.0;
	targethuman_teleported[client][1] = 0.0;
	targethuman_teleported[client][2] = 0.0;
}

public void trigger_teleport(const char[] output, int entity_index, int client, float delay)
{
	if (IsValidEdict(entity_index))
		for (int i = 1; i <= MaxClients; i++)
                if (IsValidClient(i))
                {
			if (targethuman[i] == client)
			{
				GetEntPropVector(client, Prop_Send, "m_vecOrigin", targethuman_teleported[i]);
				CreateTimer(6.0, reset_target_tp, client);
			}
			else if (is_bot_player(i) && i == client)
				CreateTimer(0.1, reset_target_tp, client);
		}
}

public void Trigger_Multiple(const char[] output, int entity_index, int client, float delay)
{
	if (IsValidEdict(entity_index) && origin_command_check(entity_index))
	{
		for (int i = 1; i <= MaxClients; i++)
                if (IsValidClient(i))
                {
                        if (targethuman[i] == client)
                        {
                                GetEntPropVector(client, Prop_Send, "m_vecOrigin", targethuman_teleported[i]);
                                CreateTimer(6.0, reset_target_tp, client);
                        }
			else if (is_bot_player(i) && i == client)
                                CreateTimer(0.1, reset_target_tp, client);
                }
	}
}

public bool origin_command_check(int entity_index)
{
	int count_trigger = GetOutputCount(entity_index, "m_OnTrigger");
	int count_starttouch = GetOutputCount(entity_index, "m_OnStartTouch");
	for	(int i = 0; i < count_trigger; i++)
	{
		char buffer[generic_length];
		GetOutputParameter(entity_index, "m_OnTrigger", i, buffer, sizeof(buffer));
		if (StrContains(buffer, "origin", true) != -1)
			return true;			
	}
	for	(int i = 0; i < count_starttouch; i++)
	{
		char buffer[generic_length];
		GetOutputParameter(entity_index, "m_OnStartTouch", i, buffer, sizeof(buffer));
		if (StrContains(buffer, "origin", true) != -1)
			return true;
	}
	return false;
}

public Action reset_target_tp(Handle timer, int client)
{
	reset_target_human_tp_coord(client);
	return Plugin_Continue;
}

public bool distance_check(int client)
{
	float dist_target = get_power_distance(client, targethuman_teleported[client]);
	float min_required_distance = 50000.0;
	if (dist_target > min_required_distance)
		return false;
	return true;
}

public void cmd_talk_help(int port, int client, char[] info)
{
	char msg[generic_length * 5];
	chat_cooldown = true;
	char magic_code[16];
	Format(magic_code, sizeof(magic_code), "72DqZ84");
	Format(msg, sizeof(msg), "clientmessage:%N %s %s", client, magic_code, info);
	send_socket_msg(msg, strlen(msg), port);
	CreateTimer(2.0, bot_chat_cooldown);

}

public bool is_autism_bot1(int client)
{
	char auth[50];
	GetClientAuthId(client, AuthId_Engine, auth, sizeof(auth));
	return StrEqual("[U:1:120378081]", auth, false) || StrEqual("STEAM_0:1:60189040", auth, false);
}

public bool is_autism_bot2(int client)
{
        char auth[50];
        GetClientAuthId(client, AuthId_Engine, auth, sizeof(auth));
        return StrEqual("[U:1:1036189204]", auth, false) || StrEqual("STEAM_0:0:518094602", auth, false);
}

public bool is_autism_bot3(int client)
{
        char auth[50];
        GetClientAuthId(client, AuthId_Engine, auth, sizeof(auth));
        return StrEqual("[U:1:408797742]", auth, false) || StrEqual("STEAM_0:0:204398871", auth, false);
}

public bool is_autism_bot4(int client)
{
        char auth[50];
        GetClientAuthId(client, AuthId_Engine, auth, sizeof(auth));
        return StrEqual("[U:1:1221121532]", auth, false) || StrEqual("STEAM_0:0:610560766", auth, false);
}

public Action cmd_botrtv(int client, int args)
{
	if ((vips[client] || admins[client]) && !rtv)
        {
		bool bot_found = false;
		for (int i = 1; i <= MaxClients; i++)
		{
			if (IsValidClient(i) && !IsFakeClient(i) && is_bot_player(i))
			{
				FakeClientCommand(i, "sm_say rtv");
				bot_found = true;
			}
		}
		if (bot_found)
		{
			rtv = true;
		}
        }
	return Plugin_Handled;
}

public Action cmd_talk(int client, int args)
{	
	char info[generic_length];
	GetCmdArgString(info, sizeof(info));
	if (strlen(info) == 0)
	{
		PrintToChat(client, "Add a message to the command if autism bot is ingame and running on discord");
		return Plugin_Handled;
	}
	if (is_bot_player(client))
	{
		return Plugin_Handled;
	}
	if (chat_cooldown)
	{
		PrintToChat(client, "spamming bot too much, applying cooldown");
		return Plugin_Handled;
	}
	bool bot_found = false;
	for (int i = 1; i <= MaxClients; i++)
		if (IsValidClient(i) && !IsFakeClient(i))
                {
			if (is_autism_bot1(i))
			{
				cmd_talk_help(ports[0], client, info);
				bot_found = true;
			}
			if (is_autism_bot2(i))
			{
				cmd_talk_help(ports[1], client, info);
				bot_found = true;
			}
			if (is_autism_bot3(i))
                        {
				cmd_talk_help(ports[2], client, info);
                                bot_found = true;
                        }
			if (is_autism_bot4(i))
                        {
				cmd_talk_help(ports[3], client, info);
                                bot_found = true;
                        }
	}
	if (!bot_found)
		PrintToChat(client, "bot not connected to server");
	return Plugin_Handled;
}

public Action bot_chat_cooldown(Handle timer, any data)
{
	chat_cooldown = false;
	return Plugin_Continue;
}

public void Event_RoundStart(Handle event, const char[] name, bool dontBroadcast)
{
	for (int i = 1; i <= MaxClients; i++)
                if (IsValidClient(i) && !IsFakeClient(i))
                {
			targethuman[i] = 0;
			target_enemy[i] = 0;
			reset_target_human_tp_coord(i);
		}
}

public void OnMapStart()
{
	rtv = true;
	//0.2 too spammmy, 1.5 too slow
	chat_cooldown = false;
	CreateTimer(0.30, recursive_pressing, INVALID_HANDLE, TIMER_REPEAT|TIMER_FLAG_NO_MAPCHANGE);
	CreateTimer(15.0, bot_check_connect, INVALID_HANDLE, TIMER_REPEAT|TIMER_FLAG_NO_MAPCHANGE);
	CreateTimer(600.0, bot_allow_rtv);
}

public void send_socket_msg(char[] query_msg, int len, int port)
{
	//LogMessage("query_msg: %s port: %i", query_msg, port);
	if (global_socket != INVALID_HANDLE && SocketIsConnected(global_socket))
		SocketSendTo(global_socket, query_msg, len, "127.0.0.1", port); //udp
}

public Action bot_allow_rtv(Handle timer, any data)
{
	rtv = false;
	return Plugin_Continue;
}

public Action bot_check_connect(Handle timer, any data)
{
	int client_count = GetClientCount(false);
	char msg[generic_length];
        //PrintToChatAll("sending UDP message...");
        Format(msg, sizeof(msg), "connect to ze");
	bool found_bot1 = false;
	bool found_bot2 = false;
	bool found_bot3 = false;
	bool found_bot4 = false;
	for (int i = 1; i <= MaxClients; i++)
        	if (IsValidClient(i) && !IsFakeClient(i))
		{
			if (client_count > 50)
			{
				found_bot1 = true;
                                found_bot2 = true;
                                found_bot3 = true;
                                found_bot4 = true;
				if (client_count > 60)
				{
					if (is_bot_player(i))
					{
						KickClient(i, "server full you need to leave");
					}
				}
			}
			else
			{
				if (is_autism_bot1(i))
                                {
					found_bot1 = true;
                                }
				if (is_autism_bot2(i))
                                {
					found_bot2 = true;
                                }
				if (is_autism_bot3(i))
                                {
					found_bot3 = true;
                                }
				if (is_autism_bot4(i))
				{
					found_bot4 = true;
				}
			}
		}
	if (!found_bot1)
	{
		send_socket_msg(msg, strlen(msg), ports[0]);
	}
	if (!found_bot2)
	{
		send_socket_msg(msg, strlen(msg), ports[1]);
	}
	if (!found_bot3)
	{
		send_socket_msg(msg, strlen(msg), ports[2]);
	}
	if (!found_bot4)
	{
		send_socket_msg(msg, strlen(msg), ports[3]);
	}
	return Plugin_Continue;
}

public void OnPlayerRunCmdPost(int client, int buttons, int impulse, const float vel[3], const float angles[3], int weapon, int subtype, 
								int cmdnum, int tickcount, int seed, const int mouse[2])
{
	if (!IsClientInGame(client)) return;
	if (is_bot_player(client))
	{
		int flags = GetEntityFlags(client);
		if (!(flags & FL_ONGROUND) && (flags_old[client] & FL_ONGROUND) && !(buttons_old[client] & IN_JUMP) && !(buttons & IN_JUMP) && (GetEntityMoveType(client) != MOVETYPE_LADDER) && GetEntProp(client, Prop_Data, "m_nWaterLevel") <= 2)
		{
			float Vel[3], feet_origin[3], ground_pos[3], downwards[3];
			//TODO prevent bot from falling off edge if nothing infront
			float velocity_addition_z_axis = 300.0; //300.0
			GetEntPropVector(client, Prop_Data, "m_vecVelocity", Vel);
			Vel[2] += velocity_addition_z_axis;
			
			GetClientAbsOrigin(client, feet_origin);
			downwards[0] = 90.0;
			downwards[1] = 0.0;
			downwards[2] = 0.0;
			TR_TraceRayFilter(feet_origin, downwards, MASK_SOLID, RayType_Infinite, TraceRayDontHitSelf, client);
			if (TR_DidHit())
			{
				TR_GetEndPosition(ground_pos);
				feet_origin[2] -= 10.0; 
				float ground_distance = GetVectorDistance(feet_origin, ground_pos);
				if (ground_distance > 80)
				{
					float angles_eye[3];
					GetClientEyeAngles(client, angles_eye);
					//feet_origin[2] += 10.0;
					TR_TraceRayFilter(feet_origin, angles_eye, MASK_SOLID, RayType_Infinite, TraceRayDontHitSelf, client);
					if (TR_DidHit())
					{
						TR_GetEndPosition(ground_pos);
						ground_distance = GetVectorDistance(feet_origin, ground_pos);
						float forward_distance = GetVectorDistance(feet_origin, ground_pos);
						if (forward_distance > 280)
						{
							float ClientPos[3];
							float Result[3];
							GetClientEyePosition(client, ClientPos);
							MakeVectorFromPoints(ClientPos, ground_pos, Result);
							NegateVector(Result);
							GetVectorAngles(Result, Result);
							TeleportEntity(client, NULL_VECTOR, Result, NULL_VECTOR);
							bot_avoid_edge[client] = 0;
							ApplyBoost(client, 350.0);
						}
					}
				}
			}
			//SetEntPropVector(client, Prop_Data, "m_vecBaseVelocity", Vel);  
			TeleportEntity(client, NULL_VECTOR, NULL_VECTOR, Vel);
		}
		buttons_old[client] = buttons;
		flags_old[client] = flags;
	}
}

//this was for turning around to prevent falling off edges
void ApplyBoost(int client, float amount){
	float direction[3], vel[3];
        GetEntPropVector(client, Prop_Data, "m_vecVelocity", vel);
        NormalizeVector(vel, direction);
        ScaleVector(direction, amount);
        AddVectors(vel, direction, vel);
        TeleportEntity(client, NULL_VECTOR, NULL_VECTOR, vel);
	//SetEntPropVector(client, Prop_Data, "m_vecBaseVelocity", vel);
}

public bool is_bot_player(int client)
{
	return is_autism_bot1(client) || is_autism_bot2(client) || is_autism_bot3(client) || is_autism_bot4(client);
}

public Action recursive_pressing(Handle timer, any data)
{
	bool found_valid_ct = false;
	for (int client = 1; client <= MaxClients; client++)
	{
		if (!IsValidClient(client)) continue;
		if (!is_bot_player(client) && GetClientTeam(client) == 3 && IsPlayerAlive(client))
		{
			found_valid_ct = true;
		}
		if (is_bot_player(client))
		{
			if (GetClientTeam(client) == 1 || GetClientTeam(client) == 0)
			{
			    ChangeClientTeam(client, 2);
			    continue;
			}
			if (bot_avoid_edge[client] >= 3)
				bot_avoid_edge[client] = -1;
			if (bot_avoid_edge[client] > -1)
			{
				bot_avoid_edge[client]++;
				continue;
			}
			if (IsPlayerAlive(client))
			{
			    int targeteam = 0;
			    if (GetClientTeam(client) != 3)
			    {
				//2 = autismo is zm and should follow enemies sometimes
				targeteam = 2;
			    }
			    else
			    {
				//3 = autismo is human and should follow closest moving ct
				targeteam = 3;
			    }
			    if (targethuman_teleported[client][0] != 0.0)
			    {
				float ClientPos[3];
				float Result[3];
				GetClientEyePosition(client, ClientPos);
				MakeVectorFromPoints(ClientPos, targethuman_teleported[client], Result);
				GetVectorAngles(Result, Result);
				TeleportEntity(client, NULL_VECTOR, Result, NULL_VECTOR);
				if (!distance_check(client))
				    reset_target_human_tp_coord(client);
				continue;
			    }
				//no target in water somehow
			    target_enemy[client] = GetClosestClient_option1(false, client);
			    targethuman[client] = GetClosestClient_option1(true, client);
			    float enemy_distance = -1.0;
			    float dist_target = -1.0;
			    float pos[3];
			    if (IsValidClient(targethuman[client]))
			    {
				GetEntPropVector(targethuman[client], Prop_Send, "m_vecOrigin", pos);
				dist_target = get_power_distance(client, pos);
			    }
			    if (IsValidClient(target_enemy[client]))
			    {
				GetEntPropVector(target_enemy[client], Prop_Send, "m_vecOrigin", pos);
				enemy_distance = get_power_distance(client, pos);
			    }
			    if ((750 > enemy_distance > 0 && enemy_distance > dist_target && targeteam == 2) || dist_target < 0 < enemy_distance)
			    {
				/*
				float feet_origin[3], enemy_feet_origin[3];
				GetClientAbsOrigin(client, feet_origin);
				GetClientAbsOrigin(target_enemy[client], enemy_feet_origin);
				if (feet_origin[2] + 100 > enemy_feet_origin[2])
				*/
				face_call(target_enemy[client], client);
			    }
			    else if (IsValidClient(targethuman[client]))
				face_call(targethuman[client], client);
				//might prevent bot from jumping off ladders
			    if (GetEntProp(client, Prop_Data, "m_nWaterLevel") <= 2 && GetEntityMoveType(client) != MOVETYPE_LADDER)
				    trace_hulling_bot(client);
			    char message[generic_length * 7];
			    if (IsValidClient(targethuman[client]))
				Format(message, sizeof(message), "dist_target: %f targethuman: %N enemy_distance: %f targeteam: %i", dist_target, targethuman[client], enemy_distance, targeteam);
			    else
				Format(message, sizeof(message), "dist_target: %f targethuman: none enemy_distance: %f targeteam: %i", dist_target, enemy_distance, targeteam);
			    if (IsValidClient(target_enemy[client]))
				Format(message, sizeof(message), "%s target_enemy: %N", message, target_enemy[client]);
			    else
				Format(message, sizeof(message), "%s target_enemy: none", message);

			    if (is_autism_bot1(client))
			    {
				send_socket_msg(message, strlen(message), ports[0]);
			    }
			    if (is_autism_bot2(client))
			    {
				send_socket_msg(message, strlen(message), ports[1]);
			    }
			    if (is_autism_bot3(client))
                            {
				send_socket_msg(message, strlen(message), ports[2]);
                            }
			    if (is_autism_bot4(client))
			    {
				send_socket_msg(message, strlen(message), ports[3]);
			    }
			}
		}
	}
	if (!found_valid_ct)
	{
		for (int client = 1; client <= MaxClients; client++)
		{
			if (!IsValidClient(client)) continue;
			if (is_bot_player(client) && GetClientTeam(client) == 3)
			{
				ForcePlayerSuicide(client);
			}
		}
	}
	return Plugin_Continue;
}

//https://developer.valvesoftware.com/wiki/Dimensions
public void trace_hulling_bot(int client)
{
	char message[generic_length * 3];
	float step_cap = 18.0;
        float crouch_min = 48.0;
        float stand_min = 63.0;
	float feet_origin[3], mins[3], maxs[3], eye_position[3];
	int BOUNDINGBOX_INFLATION_OFFSET = 3;
	GetClientEyePosition(client, eye_position);
	GetClientAbsOrigin(client, feet_origin);
	GetClientMins(client, mins);
	GetClientMaxs(client, maxs);
	//increasing boxes sizes
	for (int ij = 0; ij < sizeof(mins) - 1; ij++)
	{
		mins[ij] -= BOUNDINGBOX_INFLATION_OFFSET;
		maxs[ij] += BOUNDINGBOX_INFLATION_OFFSET;
	}
	//acts as full body check
	feet_origin[2] += BOUNDINGBOX_INFLATION_OFFSET;
	TR_TraceHullFilter(feet_origin, feet_origin, mins, maxs, MASK_ALL, TraceRayDontHitSelf);
	if (TR_DidHit())
	{
		//check 0.0 to 48.0 units starting from feet
		feet_origin[2] -= BOUNDINGBOX_INFLATION_OFFSET;
		mins[2] = 0.0;
		maxs[2] = crouch_min;
		TR_TraceHullFilter(feet_origin, feet_origin, mins, maxs, MASK_ALL, TraceRayDontHitSelf);
		if (!(TR_DidHit()))
		{
			//can crouch
			Format(message, sizeof(message), "hull info:crouch");
			if (is_autism_bot1(client))
			{
				send_socket_msg(message, strlen(message), ports[0]);
			}
			if (is_autism_bot2(client))
			{
				send_socket_msg(message, strlen(message), ports[1]);
			}
			if (is_autism_bot3(client))
                        {
				send_socket_msg(message, strlen(message), ports[2]);
                        }
			if (is_autism_bot4(client))
			{
				send_socket_msg(message, strlen(message), ports[3]);
                        }
			return;
		}
		//something blocks floor crouch
		eye_position[2] += 5.0;
		TR_TraceHullFilter(eye_position, eye_position, mins, maxs, MASK_ALL, TraceRayDontHitSelf);
		if (!(TR_DidHit()))
		{
			//should not block jump level
			Format(message, sizeof(message), "hull info:jump");
			if (is_autism_bot1(client))
			{
				send_socket_msg(message, strlen(message), ports[0]);
			}
			if (is_autism_bot2(client))
			{
				send_socket_msg(message, strlen(message), ports[1]);
			}
			if (is_autism_bot3(client))
                        {
				send_socket_msg(message, strlen(message), ports[2]);
                        }
			if (is_autism_bot4(client))
                        {
				send_socket_msg(message, strlen(message), ports[3]);
                        }
			return;
		}
		else
		{
			//still potentially crouch hole in wall or one side jumpable
			mins[2] = step_cap;
			float iterator = step_cap;
			while (iterator < stand_min)
			{
				maxs[2] = iterator;
				iterator += step_cap;
				for (int jj = 0; jj < 2; jj++)
					for (int ij = 0; ij < 2; ij++)
					{
						if (jj == 0)
							mins[ij] += BOUNDINGBOX_INFLATION_OFFSET;
						else
							maxs[ij] -= BOUNDINGBOX_INFLATION_OFFSET;
						TR_TraceHullFilter(feet_origin, feet_origin, mins, maxs, MASK_ALL, TraceRayDontHitSelf);
						if (!(TR_DidHit()))
						{
							Format(message, sizeof(message), "hull info:jump");
							if (is_autism_bot1(client))
							{
								send_socket_msg(message, strlen(message), ports[0]);
							}
							if (is_autism_bot2(client))
							{
								send_socket_msg(message, strlen(message), ports[1]);
							}
							if (is_autism_bot3(client))
							{
								send_socket_msg(message, strlen(message), ports[2]);
							}
							if (is_autism_bot4(client))
							{
								send_socket_msg(message, strlen(message), ports[3]);
							}
							return;
						}
						TR_TraceHullFilter(eye_position, eye_position, mins, maxs, MASK_ALL, TraceRayDontHitSelf);
						if (!(TR_DidHit()))
						{
							Format(message, sizeof(message), "hull info:jump");
							if (is_autism_bot1(client))
							{
								send_socket_msg(message, strlen(message), ports[0]);
							}
							if (is_autism_bot2(client))
							{
								send_socket_msg(message, strlen(message), ports[1]);
							}
							if (is_autism_bot3(client))
							{
								send_socket_msg(message, strlen(message), ports[2]);
							}
							if (is_autism_bot4(client))
							{
								send_socket_msg(message, strlen(message), ports[3]);
							}
							return;
						}
						if (jj == 0)
							mins[ij] -= BOUNDINGBOX_INFLATION_OFFSET;
						else
							maxs[ij] += BOUNDINGBOX_INFLATION_OFFSET;
                                       	}
			}
			//currently detects when two walls meet and create a corner
			float move_angles[3];
			GetClientEyeAngles(client, move_angles);
			move_angles[0] = 0.0;
			move_angles[1] += 35.0;
			move_angles[2] = 0.0;
			TeleportEntity(client, NULL_VECTOR, move_angles, NULL_VECTOR);
			return;
		}
	}
}

public Action surf_cooldown_timer(Handle timer, any data)
{
	surf_cooldown = false;
	return Plugin_Continue;
}

public bool TraceRayDontHitSelf(int entity, int mask, any data)
{
	return entity != data && !(0 < entity <= MaxClients);
}

public void face_call(int client, int selfclient)
{
	for (int j = 0; j < 5; j++)
		faceclient(client, selfclient);
}

public void faceclient(int target_human, int client)
{
	if (IsValidClient(client) && IsValidClient(target_human))
	{
		float TargetPos[3];
		float ClientPos[3];
		float Result[3];
		GetClientEyePosition(target_human, TargetPos);
		GetClientEyePosition(client, ClientPos);
		MakeVectorFromPoints(ClientPos, TargetPos, Result);
		GetVectorAngles(Result, Result);
		TeleportEntity(client, NULL_VECTOR, Result, NULL_VECTOR);
	}
}

stock bool IsValidClient(int client)
{
	if (client > 0 && client <= MaxClients && IsClientConnected(client) && IsClientInGame(client))
		return true;
	return false;
}

stock bool is_client_stuck_or_afk(int client)
{
	float min_distance_cap = 1.0;
	float client_own_distance = get_power_distance(client, client_old_coords[client]);
	GetEntPropVector(client, Prop_Send, "m_vecOrigin", client_old_coords[client]);
	return client_own_distance < min_distance_cap;
}

public bool check_client_team(int client, int i, bool finding_friend)
{
	return (finding_friend && GetClientTeam(client) == GetClientTeam(i)) || (!finding_friend && GetClientTeam(client) != GetClientTeam(i));
}

public int GetClosestClient_option1(bool finding_friend, int client)
{
	float nearestdistance = -1.0;
	int nearest = -1;
	if (GetEntityMoveType(client) == MOVETYPE_LADDER)
		return nearest;
	//are there other players than bots to follow
	bool other_players_than_bots = false;
	for (int i = 1; i <= MaxClients; i++)
		if (IsValidClient(i) && IsPlayerAlive(i) && i != client && !is_bot_player(i) && IsAbleToSee(client, i) && check_client_team(client, i, finding_friend))
		{
			other_players_than_bots = true;
			break;
		}
	for (int i = 1; i <= MaxClients; i++)
	if (IsValidClient(i) && IsPlayerAlive(i) && i != client && (!other_players_than_bots || !is_bot_player(i)) && check_client_team(client, i, finding_friend))
	{
		if (!IsAbleToSee(client, i))
		    continue;
		if (is_client_stuck_or_afk(i))
		{
		    if (i != targethuman[client])
			continue;
		    target_human_afk_counter[client]++;
		    int afk_cap = 4;
		    if (target_human_afk_counter[client] > afk_cap)
		    {
			target_human_afk_counter[client] = 0;
			continue;
		    }
		}
		float pos[3];
		GetEntPropVector(i, Prop_Send, "m_vecOrigin", pos);
		float dist_target = get_power_distance(client, pos);
		if (GetClientTeam(i) != GetClientTeam(client) && (admins[i] || vips[i]))
		{
			continue;
		}
		if ((admins[i] || vips[i] || i == targethuman[client]))
		    dist_target /= 5;
		if (nearestdistance < 0 || dist_target < nearestdistance)
		{
		    nearest = i;
		    nearestdistance = dist_target;
		}
	}
	return nearest;
}

public float get_power_distance(int target_player, float [3]pos)
{
	float vec[3];
	GetClientAbsOrigin(target_player, vec);
	return GetVectorDistance(vec, pos);
}

public void OnClientPostAdminCheck(int client)
{
	target_human_afk_counter[client] = 0;
	bot_avoid_edge[client] = -1;
	char auth[50];
	GetClientAuthId(client, AuthId_Engine, auth, sizeof(auth));
	char msg[generic_length];
        Format(msg, sizeof(msg), "autismo connected");
	if (is_autism_bot1(client))
	{
		send_socket_msg(msg, strlen(msg), ports[0]);
	}
	if (is_autism_bot2(client))
	{
		send_socket_msg(msg, strlen(msg), ports[1]);
	}
	if (is_autism_bot3(client))
	{
		send_socket_msg(msg, strlen(msg), ports[2]);
	}
	if (is_autism_bot4(client))
	{
		send_socket_msg(msg, strlen(msg), ports[3]);
	}
	if (CheckCommandAccess(client, "sm_kick", ADMFLAG_KICK))
		admins[client] = true;
	else if (CheckCommandAccess(client, "sm_reserved", ADMFLAG_RESERVATION))
		vips[client] = true;
	client_old_coords[client][0] = 0.0;
	client_old_coords[client][1] = 0.0;
	client_old_coords[client][2] = 0.0;
}

public OnSocketError(Handle socket, const int errorType, const int errorNum, any args)
{
	CloseHandle(socket);
	LogError("[MR] Socket error: %d (errno %d)", errorType, errorNum);
	CreateTimer(10.0, TimerConnect, INVALID_HANDLE, TIMER_HNDL_CLOSE);
}

stock void connect_socket()
{
    if (global_socket == INVALID_HANDLE || !SocketIsConnected(global_socket))
    {
   		//socket otherwise declare in public OnConfigsExecuted(){}
		global_socket = SocketCreate(SOCKET_UDP, OnSocketError);
		SocketSetOption(global_socket, SocketReuseAddr, 1);
		SocketBind(global_socket, "127.0.0.0", 48475);
		SocketConnect(global_socket, OnSocketConnected, OnSocketReceive, OnSocketDisconnected, "127.0.0.1", 48475);
    }
}

public void OnClientDisconnect(int client)
{
	admins[client] = false;
	bot_avoid_edge[client] = -1;
	vips[client] = false;
	client_old_coords[client][0] = 0.0;
	client_old_coords[client][1] = 0.0;
	client_old_coords[client][2] = 0.0;
	target_human_afk_counter[client] = 0;
}

//Socket callback
public OnSocketConnected(Handle socket, any arg)
{
	
}

//manage message
public OnSocketReceive(Handle socket, char[] receiveData, const dataSize, any hFile)
{
    //PrintToChatAll("receiveData: %s", receiveData);
}

public OnSocketDisconnected(Handle socket, any arg)
{
    CreateTimer(10.0, TimerConnect, INVALID_HANDLE, TIMER_HNDL_CLOSE);
}

public Action TimerConnect(Handle timer, any arg)
{
    connect_socket();
    return Plugin_Handled;
}

public bool IsAbleToSee(int entity, int client)
{
	float vecorigin[3]; 
	float vecEyePos[3];
	GetClientAbsOrigin(entity, vecorigin);
	GetClientEyePosition(client, vecEyePos);
	// Check if centre is visible.
	if (IsPointVisible(vecEyePos, vecorigin))
		return true;
	float vecEyePos_ent[3]; 
	float vecEyeAng[3];
	GetClientEyeAngles(entity, vecEyeAng);
	GetClientEyePosition(entity, vecEyePos_ent);
	// Check if weapon tip is visible.
	if (IsFwdVecVisible(vecEyePos, vecEyeAng, vecEyePos_ent))
		return true;
	float mins[3]; 
	float maxs[3];
	GetClientMins(client, mins);
	GetClientMaxs(client, maxs);
	// Check outer 4 corners of player.
	if (IsRectangleVisible(vecEyePos, vecorigin, mins, maxs, 1.30))
		return true;
	// Check inner 4 corners of player.
	if (IsRectangleVisible(vecEyePos, vecorigin, mins, maxs, 0.65))
		return true;
	return false;
}

public bool Filter_NoPlayers(int entity, int mask)
{
    return (entity > MaxClients && !(0 < GetEntPropEnt(entity, Prop_Data, "m_hOwnerEntity") <= MaxClients));
}

public bool IsPointVisible(const float start[3], const float end[3])
{
    TR_TraceRayFilter(start, end, MASK_SOLID, RayType_EndPoint, Filter_NoPlayers);
    return TR_GetFraction() == 1.0;
}

public bool IsFwdVecVisible(const float start[3], const float angles[3], const float end[3])
{
	float fwd[3];
	GetAngleVectors(angles, fwd, NULL_VECTOR, NULL_VECTOR);
	ScaleVector(fwd, 50.0); //ScaleVector(fwd, 50.0);
	AddVectors(end, fwd, fwd);
	return IsPointVisible(start, fwd);
}

public bool IsRectangleVisible(const float start[3], const float end[3], const float mins[3], const float maxs[3], float scale)
{
    float ZpozOffset = maxs[2];
    float ZnegOffset = mins[2];
    float WideOffset = ((maxs[0] - mins[0]) + (maxs[1] - mins[1])) / 4.0;
    // This rectangle is just a point!
    if (ZpozOffset == 0.0 && ZnegOffset == 0.0 && WideOffset == 0.0)
        return IsPointVisible(start, end);
    // Adjust to scale.
    ZpozOffset *= scale;
    ZnegOffset *= scale;
    WideOffset *= scale;
    // Prepare rotation matrix.
    float angles[3]; 
    float fwd[3];
    float right[3];
    SubtractVectors(start, end, fwd);
    NormalizeVector(fwd, fwd);
    GetVectorAngles(fwd, angles);
    GetAngleVectors(angles, fwd, right, NULL_VECTOR);
    float vRectangle[4][3];
    float vTemp[3];
    // If the player is on the same level as us, we can optimize by only rotating on the z-axis.
    if (FloatAbs(fwd[2]) <= 0.7071)
    {
        ScaleVector(right, WideOffset);
        
        // Corner 1, 2
        vTemp = end;
        vTemp[2] += ZpozOffset;
        AddVectors(vTemp, right, vRectangle[0]);
        SubtractVectors(vTemp, right, vRectangle[1]);
        
        // Corner 3, 4
        vTemp = end;
        vTemp[2] += ZnegOffset;
        AddVectors(vTemp, right, vRectangle[2]);
        SubtractVectors(vTemp, right, vRectangle[3]);
        
    }
    else if (fwd[2] > 0.0) // Player is below us.
    {
        fwd[2] = 0.0;
        NormalizeVector(fwd, fwd);
        ScaleVector(fwd, scale);
        ScaleVector(fwd, WideOffset);
        ScaleVector(right, WideOffset);
        // Corner 1
        vTemp = end;
        vTemp[2] += ZpozOffset;
        AddVectors(vTemp, right, vTemp);
        SubtractVectors(vTemp, fwd, vRectangle[0]);
        // Corner 2
        vTemp = end;
        vTemp[2] += ZpozOffset;
        SubtractVectors(vTemp, right, vTemp);
        SubtractVectors(vTemp, fwd, vRectangle[1]);
        // Corner 3
        vTemp = end;
        vTemp[2] += ZnegOffset;
        AddVectors(vTemp, right, vTemp);
        AddVectors(vTemp, fwd, vRectangle[2]);
        // Corner 4
        vTemp = end;
        vTemp[2] += ZnegOffset;
        SubtractVectors(vTemp, right, vTemp);
        AddVectors(vTemp, fwd, vRectangle[3]);
    }
    else // Player is above us.
    {
        fwd[2] = 0.0;
        NormalizeVector(fwd, fwd);
        ScaleVector(fwd, scale);
        ScaleVector(fwd, WideOffset);
        ScaleVector(right, WideOffset);
        // Corner 1
        vTemp = end;
        vTemp[2] += ZpozOffset;
        AddVectors(vTemp, right, vTemp);
        AddVectors(vTemp, fwd, vRectangle[0]);
        // Corner 2
        vTemp = end;
        vTemp[2] += ZpozOffset;
        SubtractVectors(vTemp, right, vTemp);
        AddVectors(vTemp, fwd, vRectangle[1]);
        // Corner 3
        vTemp = end;
        vTemp[2] += ZnegOffset;
        AddVectors(vTemp, right, vTemp);
        SubtractVectors(vTemp, fwd, vRectangle[2]);
        // Corner 4
        vTemp = end;
        vTemp[2] += ZnegOffset;
        SubtractVectors(vTemp, right, vTemp);
        SubtractVectors(vTemp, fwd, vRectangle[3]);
    }
    // Run traces on all corners.
    for (new i = 0; i < 4; i++)
        if (IsPointVisible(start, vRectangle[i]))
            return true;
    return false;
}
