projects-jenz/AutismBotIngame/scripting/autism_bot_info.sp

#pragma semicolon 1
#pragma newdecls required
#define DEBUG

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

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

int target_friend_afk_counter[MAXPLAYERS][MAXPLAYERS + 1];
int target_friend[MAXPLAYERS + 1];
int target_enemy[MAXPLAYERS + 1];
int buttons_old[MAXPLAYERS + 1];
int flags_old[MAXPLAYERS + 1];
int ports[7] = {48470, 48471, 48472, 48473, 48474, 48479, 48480}; //last three indexes are ports its sending udp from in plugin
int server_ports[2] = {27015, 27035}; //server ports: ze, ze2
int bot_avoid_edge[MAXPLAYERS + 1];
float client_old_coords[MAXPLAYERS + 1][3];
float targethuman_self_teleported[MAXPLAYERS + 1][3];
bool chat_cooldown = false;

//socket for bot input
Handle global_socket;

//timer handle
Handle g_hTimer_pressing = null;
Handle g_hTimer_bot_connect = null;

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

public void OnPluginStart()
{
    for (int i = 1; i <= MaxClients; i++)
        if (IsValidClient(i))
        {
            target_friend[i] = 0;
            target_enemy[i] = 0;
            OnClientPostAdminCheck(i);
        }
    //talking
    RegConsoleCmd("sm_autism", cmd_talk, "talking to the bot through java application");
    RegConsoleCmd("sm_botrtv", cmd_botrtv, "making bots rtv");

    //UDP connection
    connect_socket();
    chat_cooldown = false;
    
    g_hTimer_bot_connect = CreateTimer(15.0, bot_check_connect, _, TIMER_REPEAT);
    g_hTimer_pressing = CreateTimer(0.30, recursive_pressing, _, TIMER_REPEAT);
}

public void OnPluginEnd()
{
    if (g_hTimer_pressing != null)
    {
        delete g_hTimer_pressing;
    }
    if (g_hTimer_bot_connect != null)
    {
        delete g_hTimer_bot_connect;
    }
}

public void reset_target_tp(int client)
{
	if (IsValidClient(client) && is_bot_player(client))
    {
        targethuman_self_teleported[client][0] = 0.0;
        targethuman_self_teleported[client][1] = 0.0;
        targethuman_self_teleported[client][2] = 0.0;
    }
}

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

public bool distance_check(int client, int botclient, bool nowpos)
{
	float dist_target = 0.0;
	if (nowpos)
	{
		float pos[3];
		GetEntPropVector(botclient, Prop_Send, "m_vecOrigin", pos);
		dist_target = get_power_distance(client, pos);
	}
	else
	{
		dist_target = get_power_distance(client, targethuman_self_teleported[botclient]);
	}
	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 ((CheckCommandAccess(client, "sm_kick", ADMFLAG_KICK)) || (CheckCommandAccess(client, "sm_reserved", ADMFLAG_RESERVATION)))
    {
		for (int i = 1; i <= MaxClients; i++)
		{
			if (IsValidClient(i) && !IsFakeClient(i))
			{
				char msg[generic_length];
				Format(msg, sizeof(msg), "rtv");
				if (is_autism_bot1(i))
				{
					send_socket_msg(msg, strlen(msg), ports[0]);
				}
				else if (is_autism_bot2(i))
				{
					send_socket_msg(msg, strlen(msg), ports[1]);
				}
				else if (is_autism_bot3(i))
				{
					send_socket_msg(msg, strlen(msg), ports[2]);
				}
				else if(is_autism_bot4(i))
				{
					send_socket_msg(msg, strlen(msg), ports[3]);
				}
			}
		}
    }
    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 did_target_tp(int client, int bot_client)
{
	if (client == bot_client && targethuman_self_teleported[client][0] != 0.0  && !distance_check(client, bot_client, false))
	{
		reset_target_tp(client);
	}
	else if (client != bot_client && targethuman_self_teleported[bot_client][0] == 0.0 && !distance_check(client, bot_client, true))
	{
		GetEntPropVector(client, Prop_Send, "m_vecOrigin", targethuman_self_teleported[bot_client]);
		CreateTimer(6.0, reset_target_tp_timer, bot_client);
	}
}

public void OnMapStart()
{
	chat_cooldown = false;
}

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_check_connect(Handle timer, any data)
{
	//this is designed for being ran from several css servers
	int client_count = GetClientCount(false);
	char msg[generic_length];
	int i_port = GetConVarInt(FindConVar("hostport"));
	bool is_host_ze = false;
	if (i_port == server_ports[0])
	{
		is_host_ze = true;
	}
	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 > 60)
			{
				found_bot1 = true;
				found_bot2 = true;
				found_bot3 = true;
				found_bot4 = true;
				if (is_bot_player(i))
				{
					KickClient(i, "server full you need to leave");
				}
			}
			if (is_host_ze)
			{
				if (client_count < 50)
				{
					Format(msg, sizeof(msg), "connect to ze");
					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;
					}
				}
				else if (client_count > 55)
				{
					found_bot1 = true;
					found_bot2 = true;
					found_bot3 = true;
					found_bot4 = true;
					Format(msg, sizeof(msg), "connect to ze2");
					send_socket_msg(msg, strlen(msg), ports[0]);
					send_socket_msg(msg, strlen(msg), ports[1]);
					send_socket_msg(msg, strlen(msg), ports[2]);
					send_socket_msg(msg, strlen(msg), ports[3]);
					break;
				}
			}
			else
			{
				if (is_bot_player(i))
                                {
                                        Format(msg, sizeof(msg), "connected to ze2");
                                }

				if (is_autism_bot1(i))
                                {
                                        send_socket_msg(msg, strlen(msg), ports[0]);
					found_bot1 = true;
                                }
                                if (is_autism_bot2(i))
                                {
                                        send_socket_msg(msg, strlen(msg), ports[1]);
					found_bot2 = true;
                                }
                                if (is_autism_bot3(i))
                                {
                                        send_socket_msg(msg, strlen(msg), ports[2]);
					found_bot3 = true;
                                }
                                if (is_autism_bot4(i))
                                {
                                        send_socket_msg(msg, strlen(msg), ports[3]);
					found_bot4 = true;
                                }
			}
		}
	//this check ensures servers dont overlap each other regarding not connected messages
	if (!is_host_ze)
	{
		Format(msg, sizeof(msg), "not connected");
		if (!found_bot1 && i_port == server_ports[1])
                {
			//ze2
                        send_socket_msg(msg, strlen(msg), ports[0]);
                }
                if (!found_bot2 && i_port == server_ports[1])
                {
			//ze2
                        send_socket_msg(msg, strlen(msg), ports[1]);
                }
                if (!found_bot3 && i_port == server_ports[1])
                {
			//ze2
                        send_socket_msg(msg, strlen(msg), ports[2]);
                }
                if (!found_bot4 && i_port == server_ports[1])
                {
			//ze2
                        send_socket_msg(msg, strlen(msg), ports[3]);
                }
	}
	else
	{
		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) > 1)
        {
            found_valid_ct = true;
            break;
        }
    }
    for (int client = 1; client <= MaxClients; client++)
    {
        if (!IsValidClient(client)) continue;
        if (!found_valid_ct && is_bot_player(client))
        {
            if (GetClientTeam(client) != 0)
                ChangeClientTeam(client, 0);
            continue;
        }
        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 (IsValidClient(target_friend[client]))
                {
                    did_target_tp(target_friend[client], client);
                }
                else if (IsValidClient(target_enemy[client]))
                {
                    did_target_tp(target_enemy[client], client);
                }
                if (targethuman_self_teleported[client][0] != 0.0)
                {
                    float ClientPos[3];
                    float Result[3];
                    GetClientEyePosition(client, ClientPos);
                    MakeVectorFromPoints(ClientPos, targethuman_self_teleported[client], Result);
                    GetVectorAngles(Result, Result);
                    TeleportEntity(client, NULL_VECTOR, Result, NULL_VECTOR);
                    if (!distance_check(client, client, false))
                        reset_target_tp(client);
                    continue;
                }
                //no target in water somehow
                target_enemy[client] = GetClosestClient_option1(false, client);
                target_friend[client] = GetClosestClient_option1(true, client);
                float pos[3];
                did_target_tp(client, client);
                float enemy_distance = -1.0;
                float dist_target = -1.0;
                if (IsValidClient(target_friend[client]))
                {
                    GetEntPropVector(target_friend[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);
                }
                float max_range_dist = 150.0;
                int state = -1;
                if (GetEntityMoveType(client) == MOVETYPE_LADDER)
                {
                    state = 8;
                }
                //if bot is ct: is close enough to friend, can stop following friend and focus on shooting zombies
                else if (targeteam == 3 && 0 < dist_target < max_range_dist && IsValidClient(target_enemy[client]))
                {
                    face_call(target_enemy[client], client);
                    state = 0;
                }
                //if bot is ct: if bot is not close enough to friend follow him
                else if (targeteam == 3 && dist_target > max_range_dist)
                {
                    face_call(target_friend[client], client);
                    state = 1;
                }
                //if bot is ct and close enough to friend then just do nothing in case of there being no enemy to shoot at
                else if (targeteam == 3)
                {
                    state = 2;
                }
                //if bot is zm follow enemy sometimes
                else if (targeteam == 2 && 0 < enemy_distance < max_range_dist * 5 && IsValidClient(target_enemy[client]))
                {
                    face_call(target_enemy[client], client);
                    state = 3;
                }
                //if bot is zm just follow the closest friend zm, but not constantly when too close because people start bitching then
                else if (targeteam == 2 && dist_target > max_range_dist / 2)
                {
                    face_call(target_friend[client], client);
                    state = 4;
                }
                //if bot is zm and no close enemies and no friends far away enough to follow then check if friend is close, if its the case then do nothing
                else if (targeteam == 2 && 0 < dist_target < max_range_dist / 2)
                {
                    face_call(target_friend[client], client);
                    state = 5;
                }
                //if bot is zm and there are no friends close or far away but there is also no enemy close check if there is an enemy far away
                else if (targeteam == 2 && IsValidClient(target_enemy[client]))
                {
                    face_call(target_enemy[client], client);
                    state = 6;
                }
                //else nothing to do as zm
                else if (targeteam == 2)
                {
                    state = 7;
                }
                if (GetEntProp(client, Prop_Data, "m_nWaterLevel") <= 2 && GetEntityMoveType(client) != MOVETYPE_LADDER)
                    trace_hulling_bot(client);
                char message[generic_length * 7];
                Format(message, sizeof(message), "dist_target: %f enemy_distance: %f targeteam: %i state: %i", dist_target, enemy_distance, targeteam, state);
                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]);
                }
            }
        }
    }
    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;
            break;
        }
    }
    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 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, int i)
{
	//triggers between 6-8 times per second
	target_friend_afk_counter[client][i]++;
	if (target_friend_afk_counter[client][i] >= 24)
	{
		float min_distance_cap = 1.0;
		float i_own_distance = get_power_distance(i, client_old_coords[i]);
		GetEntPropVector(i, Prop_Send, "m_vecOrigin", client_old_coords[i]);
		bool not_moved = i_own_distance < min_distance_cap;
		if (!not_moved)
		{
			target_friend_afk_counter[client][i] = 0;
		}
		return not_moved;
	}
	return false;
}

public int GetClosestClient_option1(bool finding_friend, int client)
{
	float nearestdistance = -1.0;
	int nearest = -1;
	for (int i = 1; i <= MaxClients; i++)
	if (IsValidClient(i) && IsPlayerAlive(i) && i != client && !is_bot_player(i))
	{
		if (!IsAbleToSee(client, i) || is_client_stuck_or_afk(client, i))
		{
			continue; 
		}
		float pos[3];
		GetEntPropVector(i, Prop_Send, "m_vecOrigin", pos);
		float dist_target = get_power_distance(client, pos);
		if ((finding_friend && GetClientTeam(i) != GetClientTeam(client)) || (!finding_friend && GetClientTeam(i) == GetClientTeam(client)))
		{
			continue;
		}
        /*
		if (i == target_friend[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)
{
	for (int i = 1; i <= MaxClients; i++)
	{
		if (IsValidClient(i) && is_bot_player(i) && i != client)
			target_friend_afk_counter[i][client] = 0;
	}
	bot_avoid_edge[client] = -1;
	char auth[64];
	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]);
	}
	client_old_coords[client][0] = 0.0;
	client_old_coords[client][1] = 0.0;
	client_old_coords[client][2] = 0.0;
	reset_target_tp(client);
}

public void 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))
    {
		int i_port = GetConVarInt(FindConVar("hostport"));
		int target_port = ports[4]; //default ze
		if (i_port == server_ports[1])
		{
			//ze2
			target_port = ports[5];
		}
   		//socket otherwise declare in public OnConfigsExecuted(){}
		global_socket = SocketCreate(SOCKET_UDP, OnSocketError);
		SocketSetOption(global_socket, SocketReuseAddr, 1);
		SocketBind(global_socket, "127.0.0.0", target_port);
		SocketConnect(global_socket, OnSocketConnected, OnSocketReceive, OnSocketDisconnected, "127.0.0.1", target_port); //48474 on ze
    }
}

public void OnClientDisconnect(int client)
{
	bot_avoid_edge[client] = -1;
	client_old_coords[client][0] = 0.0;
	client_old_coords[client][1] = 0.0;
	client_old_coords[client][2] = 0.0;
	for (int i = 1; i <= MaxClients; i++)
    {
        if (IsValidClient(i) && is_bot_player(i) && i != client)
            target_friend_afk_counter[i][client] = 0;
    }
	reset_target_tp(client);
}

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

//manage message
public void OnSocketReceive(Handle socket, char[] receiveData, const char dataSize, any hFile)
{
	
}

public void 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)) //1.30
		return true;
	// Check inner 4 corners of player.
	if (IsRectangleVisible(vecEyePos, vecorigin, mins, maxs, 0.65)) //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 (int i = 0; i < 4; i++)
        if (IsPointVisible(start, vRectangle[i]))
            return true;
    return false;
}