OPLAV Version 2 - iPLEOMAX

/*
    * @name: OnPlayerLookAtVehicle Version 2
    * @author: iPLEOMAX (c) 2012
    * Do not not release any other version of this script without
    * my permission. Thank you for downloading it.

    * Details:
    * This Include allows to detect the vehicleidif a player looks at it.
    * To use it, add #include <vla> to your Filterscript/Gamemode.

    * Credits:
    * Jernjel & cracK: Trignometry Help.
    * Y_Less: YSI Server Includes.

    * For any Help/Bug report/Suggestion, visit the release topic.
*/

#if defined vla
    #endinput
#endif

#define vla

#include        <a_samp>
#include        <YSI\y_hooks>
//#include      <foreach>

#define         MAX_STORED_VEHICLES     60
#define         VLA_UPDATE_RATE         200
#define         MAX_VLA_DISTANCE        300

new
    VLA_Timer,
    Float:PositionX, Float:PositionY, Float:PositionZ,
    Float:VehicleX, Float:VehicleY, Float:VehicleZ,
    Float:vCamX, Float:vCamY, Float:vCamZ,
    Float:VecX, Float:VecY, Float:VecZ,
    Float:TempX, Float:TempY, Float:TempZ,
    Float:TargetDistance, Float:vTemp,
    Float:vRadius,

    Float:vDistance[MAX_PLAYERS],
    Vehicle_Current[MAX_PLAYERS],
    Vehicle_Temp[MAX_PLAYERS],

    bool:VehicleOnSight[MAX_PLAYERS],
    bool:LookAtEnabled[MAX_PLAYERS],

    //IteratorArray:StreamedVehicles[MAX_PLAYERS]<MAX_STORED_VEHICLES>,
    PlayerStreamedVehicles[MAX_PLAYERS][MAX_STORED_VEHICLES]
;

forward OnPlayerLookAtVehicle(playerid, vehicleid, Float:distance);

#if defined FILTERSCRIPT

Hook:vla_OnFilterScriptInit()
{
    printf(" * OnPlayerLookAtVehicle V2.0 (c) iPLEOMAX 2012");
    //Iter_Init(StreamedVehicles);
    VLA_Timer = SetTimer("VLA_Tick", VLA_UPDATE_RATE, true);
    return true;
}

Hook:vla_OnFilterScriptExit()
{
    KillTimer(VLA_Timer);
    return true;
}

#else

Hook:vla_OnGameModeInit()
{
    printf(" * OnPlayerLookAtVehicle V2.0 (c) iPLEOMAX 2012");
    //Iter_Init(StreamedVehicles);
    VLA_Timer = SetTimer("VLA_Tick", VLA_UPDATE_RATE, true);
    return true;
}

Hook:vla_OnGameModeExit()
{
    KillTimer(VLA_Timer);
    return true;
}

#endif

Hook:vla_OnPlayerDisconnect(playerid, reason)
{
    vDistance[playerid] = 0;
    Vehicle_Current[playerid] = 0;
    Vehicle_Temp[playerid] = 0;
    VehicleOnSight[playerid] = false;
    LookAtEnabled[playerid] = false;
    //Iter_Clear(StreamedVehicles[playerid]);
    for(new xid = 0; xid < MAX_STORED_VEHICLES; xid++)
    {
        PlayerStreamedVehicles[playerid][xid] = 0;
    }
    return true;
}

forward VLA_Tick();
public VLA_Tick()
{
    for(new i=0; i<MAX_PLAYERS; i++)
    //foreach(Player, i) <-- Doesn't work sometimes.
    {
        if(!IsPlayerConnected(i)) continue;
        if(!LookAtEnabled[i]) continue;

        VehicleOnSight[i] = false;
        vDistance[i] = MAX_VLA_DISTANCE;

        //foreach(StreamedVehicles[i], v)
        for (new vidx = 0; vidx < MAX_STORED_VEHICLES; vidx++)
        {
            //if(!PlayerStreamedVehicles[i][vidx]) continue;
            //if(Vehicle_Current[i] == PlayerStreamedVehicles[i][vidx]) continue;
            if(!GetVehicleModel(PlayerStreamedVehicles[i][vidx])) continue;
            if(GetPlayerVehicleID(i) == PlayerStreamedVehicles[i][vidx]) continue;

            GetVehiclePos(PlayerStreamedVehicles[i][vidx], VehicleX,  VehicleY,  VehicleZ);
            GetPlayerPos(i, PositionX, PositionY, PositionZ);

            vRadius = 2.0;
            TargetDistance =
            floatsqroot
            (
                floatpower((PositionX - VehicleX), 2)+
                floatpower((PositionY - VehicleY), 2)+
                floatpower((PositionZ - VehicleZ), 2)
            );

            if (TargetDistance > MAX_VLA_DISTANCE) continue;
            if (TargetDistance > vDistance[i]) continue;
            vDistance[i] = TargetDistance;
            if (TargetDistance < 5) vRadius = 3.5;

            if(CheckLookAt(i, vRadius))
            {
                //printf("Looking at: %i", PlayerStreamedVehicles[i][vidx]);
                VehicleOnSight[i] = true;
                Vehicle_Temp[i] = PlayerStreamedVehicles[i][vidx];
            }
        }

        switch(VehicleOnSight[i])
        {
            case true: {
                if(Vehicle_Temp[i] != Vehicle_Current[i])
                {
                    CallLocalFunction("OnPlayerLookAtVehicle", "iif", i, Vehicle_Temp[i], vDistance[i]);
                    Vehicle_Current[i] = Vehicle_Temp[i];
                }
            }
            case false: {
                if(Vehicle_Current[i]) CallLocalFunction("OnPlayerLookAtVehicle", "iif", i, 0, 0);
                Vehicle_Current[i] = 0;
            }
        }
    }
    return true;
}

stock CheckLookAt(playerid, Float:radius)
{
    GetPlayerCameraPos(playerid, vCamX, vCamY, vCamZ);
    GetPlayerCameraFrontVector(playerid, VecX, VecY, VecZ);

    TargetDistance = floatsqroot
    (
        floatpower((vCamX - VehicleX), 2) +
        floatpower((vCamY - VehicleY), 2) +
        floatpower((vCamZ - VehicleZ), 2)
    );

    TempX = VecX * TargetDistance + vCamX;
    TempY = VecY * TargetDistance + vCamY;
    TempZ = VecZ * TargetDistance + vCamZ;

    vTemp = floatsqroot
    (
        floatpower((TempX - VehicleX), 2) +
        floatpower((TempY - VehicleY), 2) +
        floatpower((TempZ - VehicleZ), 2)
    );

    if(radius >= vTemp) return true;
    return false;
}

Hook:vla_OnVehicleStreamIn(vehicleid, forplayerid)
{
    AddToSVList(forplayerid, vehicleid);
    //Iter_Add(StreamedVehicles[forplayerid], vehicleid);
    //printf("OnVehicleStreamIn: vehicleid: %i, forplayerid: %i", vehicleid, forplayerid);
    return true;
}

Hook:vla_OnVehicleStreamOut(vehicleid, forplayerid)
{
    RemoveFromSVList(forplayerid, vehicleid);
    //Iter_Remove(StreamedVehicles[forplayerid], vehicleid);
    //printf("vla_OnVehicleStreamOut: vehicleid: %i, forplayerid: %i", vehicleid, forplayerid);
    return true;
}

/*
public OnPlayerLookAtVehicle(playerid, vehicleid, Float:distance)
{
    new message[128];
    format(message, sizeof message,
    "LookAt: %i, Distance: %f", vehicleid, distance);
    SendClientMessage(playerid, -1, message);
    return true;
}
*/

stock EnableVehicleLookAt(forplayerid)
{
    //Iter_Clear(StreamedVehicles[forplayerid]);
    for(new vid=0; vid<MAX_VEHICLES; vid++)
    {
        if(!IsVehicleStreamedIn(vid, forplayerid)) continue;
        AddToSVList(forplayerid, vid);
        //Iter_Add(StreamedVehicles[forplayerid], vid);
    }
    LookAtEnabled[forplayerid] = true;
}

stock DisableVehicleLookAt(forplayerid)
{
    for(new xid = 0; xid < MAX_STORED_VEHICLES; xid++)
    {
        PlayerStreamedVehicles[forplayerid][xid] = 0;
    }
    //Iter_Clear(StreamedVehicles[forplayerid]);
    LookAtEnabled[forplayerid] = false;
}

stock AddToSVList(playerid, vehicleid)
{
    for(new xid = 0; xid < MAX_STORED_VEHICLES; xid++)
    {
        if(PlayerStreamedVehicles[playerid][xid] == 0)
        {
            PlayerStreamedVehicles[playerid][xid] = vehicleid;
            break;
        }
    }
}

stock RemoveFromSVList(playerid, vehicleid)
{
    for(new xid = 0; xid < MAX_STORED_VEHICLES; xid++)
    {
        if(PlayerStreamedVehicles[playerid][xid] == vehicleid)
        PlayerStreamedVehicles[playerid][xid] = 0;
    }
}

/*
native EnableVehicleLookAt(forplayerid);
native DisableVehicleLookAt(forplayerid);
*/