#pragma semicolon 1
#pragma newdecls required

#include <sourcemod>
#include <sdktools>
#include <sdkhooks>

ConVar cDamage, cRange, cDistance, cSpeed;
float g_iDamage, g_iRange, g_iDistance, g_iSpeed;

int g_iVelocity;

public Plugin myinfo =
{
    name = "[L4D2] Spitter",
    author = "BHaType",
    description = "spitter",
    version = "0.0.1",
    url = "N/A"
}

public void OnPluginStart()
{
    cDamage     = CreateConVar("magic_spitter_damage"       , "5.0" , "Number of damage"        , FCVAR_NONE);
    cRange      = CreateConVar("magic_spitter_range"        , "60.0"    , "Range of hit"            , FCVAR_NONE);
    cDistance   = CreateConVar("magic_spitter_distance" , "950.0"   , "Distance of detect"      , FCVAR_NONE);
    cSpeed      = CreateConVar("magic_spitter_speed"        , "5.5" , "Speed of magic items"    , FCVAR_NONE);

    g_iDamage   = cDamage.FloatValue;
    g_iRange    = cRange.FloatValue;
    g_iDistance = cDistance.FloatValue;
    g_iSpeed    = cSpeed.FloatValue;

    cDamage.AddChangeHook(IntsCvar);
    cRange.AddChangeHook(IntsCvar);
    cDistance.AddChangeHook(IntsCvar);
    cSpeed.AddChangeHook(IntsCvar);

    g_iVelocity = FindSendPropInfo("CBasePlayer", "m_vecVelocity[0]");

    AutoExecConfig(true, "spitter_aimbot");
}
public void IntsCvar(ConVar convar, const char[] oldValue, const char[] newValue)
{
    g_iDamage   = cDamage.FloatValue;
    g_iRange    = cRange.FloatValue;
    g_iDistance = cDistance.FloatValue;
    g_iSpeed = cSpeed.FloatValue;
}

public void OnEntityCreated(int entity, const char[] name)
{
    if(IsValidEntity(entity) && strcmp(name, "spitter_projectile") == 0)
        CreateTimer(0.1, PreThink, EntIndexToEntRef(entity), TIMER_REPEAT);
}


public Action PreThink (Handle timer, int index)
{
    index = EntRefToEntIndex(index);
    if(index != INVALID_ENT_REFERENCE && IsValidEntity(index))
    {
        Tracering(index);
    }
    else
        return Plugin_Stop;
    return Plugin_Continue;
}

void Tracering(int iEnt)
{
    float vPos[3], vVel[3], flDistance;

    GetEntPropVector(iEnt, Prop_Send, "m_vecOrigin", vPos);
    GetEntDataVector(iEnt, g_iVelocity, vVel);

    float vLenght = GetVectorLength(vVel);

    NormalizeVector(vVel, vVel);

    int client = lucker(iEnt);

    if(client > 0 && IsValidEntity(client))
    {
        float vEnemy[3], vVelEnemy[3], vDir[3], doubleVel[3];

        GetClientEyePosition(client, vEnemy);
        GetEntDataVector(client, g_iVelocity, vVelEnemy);

        flDistance = GetVectorDistance(vPos, vEnemy);
        if(flDistance <= g_iRange)
        {
            SDKHooks_TakeDamage(client, iEnt, iEnt, g_iDamage, 1);
            AcceptEntityInput(iEnt, "kill");
        }

        SetEntityGravity(iEnt, 0.01);

        SubtractVectors(vEnemy, vPos, vDir);
        NormalizeVector(vDir, vDir);
        ScaleVector(vDir, 0.5);
        AddVectors(vVel, vDir, doubleVel);
        NormalizeVector(doubleVel, doubleVel);
        ScaleVector(doubleVel, vLenght + g_iSpeed);
        TeleportEntity(iEnt, NULL_VECTOR, NULL_VECTOR, doubleVel);

    }
    else
        SetEntProp(iEnt, Prop_Data, "m_iHammerID", 0);
}

int lucker(int index)
{
    float vPos[3], vPosEntity[3], vDistance = 100000.0, flDistance;
    int count = -1;
    GetEntPropVector(index, Prop_Send, "m_vecOrigin", vPos);
    for(int i = 1; i <= MaxClients; i++)
    {
        if(IsClientInGame(i) && GetClientTeam(i) == 2 && IsPlayerAlive(i) && IsVisibleTo(i, index))
        {
            GetEntPropVector(i, Prop_Send, "m_vecOrigin", vPosEntity);
            flDistance = GetVectorDistance(vPosEntity, vPos);
            if(flDistance < vDistance && flDistance <= g_iDistance)
            {
                vDistance = flDistance;
                count = i;
            }
        }
    }

    return count;
}

static bool IsVisibleTo(int client, int entity)
{
    float vAngles[3], vOrigin[3], vEnt[3], vLookAt[3];

    GetClientEyePosition(client, vOrigin);
    GetEntPropVector(entity, Prop_Send, "m_vecOrigin", vEnt);
    vEnt[2] += 64.0;

    MakeVectorFromPoints(vOrigin, vEnt, vLookAt);

    GetVectorAngles(vLookAt, vAngles);

    Handle trace = TR_TraceRayFilterEx(vOrigin, vAngles, MASK_SHOT, RayType_Infinite, TraceFilter, entity);

    bool isVisible = false;
    if (TR_DidHit(trace))
    {
        float vStart[3];
        TR_GetEndPosition(vStart, trace);

        if ((GetVectorDistance(vOrigin, vStart, false) + 25.0) >= GetVectorDistance(vOrigin, vEnt))
        {
            isVisible = true;
        }
    }
    delete trace;
    return isVisible;
}

public bool TraceFilter(int entity, int mask, any data)
{
    if(entity == data)
        return false;
    return true;
}