#pragma semicolon 1
#pragma newdecls required

#include <sdktools>

Handle sdkCallVomitOnPlayer, sdkCallBileJarPlayer, sdkCallBileJarInfected;

public void OnPluginStart()
{
    Handle ConfigFile = LoadGameConfigFile("Vomit.Gamedata");

    StartPrepSDKCall(SDKCall_Player);
    PrepSDKCall_SetFromConf(ConfigFile, SDKConf_Signature, "CTerrorPlayer_OnVomitedUpon");
    PrepSDKCall_AddParameter(SDKType_CBasePlayer, SDKPass_Pointer);
    PrepSDKCall_AddParameter(SDKType_PlainOldData, SDKPass_Plain);
    sdkCallVomitOnPlayer = EndPrepSDKCall();

    StartPrepSDKCall(SDKCall_Player);
    PrepSDKCall_SetFromConf(ConfigFile, SDKConf_Signature, "CTerrorPlayer_OnHitByVomitJar");
    PrepSDKCall_AddParameter(SDKType_CBaseEntity, SDKPass_Pointer);
    sdkCallBileJarPlayer = EndPrepSDKCall();

    StartPrepSDKCall(SDKCall_Entity);
    PrepSDKCall_SetFromConf(ConfigFile, SDKConf_Signature, "Infected_OnHitByVomitJar");
    PrepSDKCall_AddParameter(SDKType_CBaseEntity, SDKPass_Pointer);
    sdkCallBileJarInfected = EndPrepSDKCall();

    HookEvent("player_death", EventHook);
}

public Action EventHook(Event event, const char[] name, bool dontBroadcast)
{
    int client = GetClientOfUserId(event.GetInt("userid"));
    if(client && IsClientInGame(client) && GetEntProp(client, Prop_Send, "m_zombieClass") == 2)
    {
        SetVomit(client);
    }
}

public void OnEntityDestroyed(int entity)
{
    if (IsValidEntity(entity))
    {
        char sTypeEx[56];
        GetEntityClassname(entity, sTypeEx, sizeof sTypeEx);
        if (strcmp(sTypeEx, "vomitjar_projectile") == 0)
        {
            SetVomit(entity);
        }
    }
}

stock void SetVomit(int client)
{
    if(client > 0 && client < 2049)
    {
        float fDistance;
        char entType[64];
        float vPos[3], vTargetPos[3];
        GetEntPropVector(client, Prop_Send, "m_vecOrigin", vPos);
        vPos[2] += 60;

        for (int i = 1; i <= 2048; i++)
        {
            if (!IsValidEntity(i) || i == client) continue;
            if (i <= MaxClients && IsClientInGame(i) && IsPlayerAlive(i))
            {
                GetClientAbsOrigin(i, vTargetPos);
                fDistance = GetVectorDistance(vPos, vTargetPos);
                if(fDistance < 150 && IsVisibleTo(vTargetPos, vPos))
                {
                    switch( GetClientTeam(i) )
                    {
                        case 2: SDKCall(sdkCallBileJarPlayer, i, client, true);
                        case 3: SDKCall(sdkCallVomitOnPlayer, i, client, true);
                    }
                }
            }
            else
            {
                GetEdictClassname(i, entType, sizeof(entType));
                if(strcmp(entType, "witch") == 0 || strcmp(entType, "infected") == 0)
                {
                    GetEntityAbsOrigin(i, vTargetPos);
                    fDistance = GetVectorDistance(vPos, vTargetPos);
                    if (fDistance < 150 && IsVisibleTo(vTargetPos, vPos))
                    {
                        SDKCall(sdkCallBileJarInfected, i, client);
                    }
                }
            }
        }
    }
}

stock bool bIsSurvivor(int client)
{
    return client > 0 && client <= MaxClients && IsClientInGame(client) && GetClientTeam(client) == 2 && !IsClientInKickQueue(client) && IsPlayerAlive(client);
}

static bool IsVisibleTo(float position[3], float targetposition[3])
{
    float vAngles[3], vLookAt[3];

    MakeVectorFromPoints(position, targetposition, vLookAt);
    GetVectorAngles(vLookAt, vAngles);

    Handle trace = TR_TraceRayFilterEx(position, vAngles, MASK_SHOT, RayType_Infinite, _TraceFilter);

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

        if ((GetVectorDistance(position, vStart, false) + 25.0) >= GetVectorDistance(position, targetposition))
        {
            isVisible = true;
        }
    }

    delete trace;
    return isVisible;
}

public bool _TraceFilter(int entity, int contentsMask)
{
    if (IsValidEntity(entity))
    {
        return false;
    }
    return true;
}

stock void GetEntityAbsOrigin(int entity, float origin[3])
{
    if (entity && IsValidEntity(entity)
    && (GetEntSendPropOffs(entity, "m_vecOrigin") != -1)
    && (GetEntSendPropOffs(entity, "m_vecMins") != -1)
    && (GetEntSendPropOffs(entity, "m_vecMaxs") != -1))
    {
        float mins[3], maxs[3];
        GetEntPropVector(entity, Prop_Send, "m_vecOrigin", origin);
        GetEntPropVector(entity, Prop_Send, "m_vecMins", mins);
        GetEntPropVector(entity, Prop_Send, "m_vecMaxs", maxs);

        origin[0] += (mins[0] + maxs[0]) * 0.5;
        origin[1] += (mins[1] + maxs[1]) * 0.5;
        origin[2] += (mins[2] + maxs[2]) * 0.5;
    }
}