/*
Enter/Level Pickups
by Mike

Pickups that act like checkpoints. Instead of just detecting when a player
picks up a pickup, this allows you to detect when a player enters a pickup,
and then when they leave it again.

There may be problems if two pickups are very close to eachother.

===[FUNCTIONS]===

native ELP_GetPlayerPickup(playerid); // Get the ID of the current ELP pickup the player is standing in

*/

// PREFIX: ELP_ (In Out Pickups)

#include <YSI_Coding\y_hooks>

// Settings
#define MAX_ELP_PICKUPS 256

// This is the timer interval to check when a player leaves a pickup.
//It is only running when needed, and only once (using foreach).
//#define ELP_TIMER_INTERVAL 661
// ** using OnPlayerUpdate now **

// The distance away from the pickup the player has to be to be detected as leaving it
#define ELP_PICKUP_RANGE (1.7)

// FUNCTIONS
/*

// CREATE - Create an 'in/out' pickup (note that the following are all the
// same function, they're aliases
native ELP_CreatePickup(model, Float:x, Float:y, Float:z, virtualworld = -1);

// DELETE
native ELP_DeletePickup(ELP_id); // ELP_id is returned by CreatePickupEx
native ELP_DestroyPickup(ELP_id); // ELP_id is returned by CreatePickupEx

// CHECKS
native IsPlayerInPickup(playerid, ELP_id);
*/

#define ELP_GetPlayerPickup(%0) ELP_playerCurPickupID[%0]

// CALLBACKS

forward OnEnterLeavePickup(playerid, pickupid, enterleave);
#define PICKUP_LEAVE 0
#define PICKUP_ENTER 1

enum E_INOUT_PICKUP_DATA
{
    ELP_pickupid, // The actual pickup ID created
    Float:ELP_pos[3]

}
new ELP_gPickupData[MAX_ELP_PICKUPS][E_INOUT_PICKUP_DATA];

new ELP_playerCurPickupID[MAX_PLAYERS];

//new Iterator:ELP_Iter<MAX_PICKUPS>;

//new ELP_TimerID;

// ============================================================================

hook OnGameModeInit()
{
    for(new i=0; i<MAX_ELP_PICKUPS; i++)
    {
        ELP_gPickupData[i][ELP_pickupid] = -1;
    }

    // END OF CALLBACK.
    #if defined ELP_OnGameModeInit
        ELP_OnGameModeInit();
    #endif
    return 1;
}
#if defined _ALS_OnGameModeInit
    #undef OnGameModeInit
#else
    #define _ALS_OnGameModeInit
#endif
#define OnGameModeInit ELP_OnGameModeInit
#if defined ELP_OnGameModeInit
    forward ELP_OnGameModeInit();
#endif

stock ELP_CreatePickup(model, Float:x, Float:y, Float:z, virtualworld = -1)
{
    for(new i=0; i<MAX_ELP_PICKUPS; i++)
    {
        if(ELP_gPickupData[i][ELP_pickupid] == -1)
        {
            ELP_gPickupData[i][ELP_pickupid] = CreatePickup(model, 1, x, y, z, virtualworld);
            ELP_gPickupData[i][ELP_pos][0] = x;
            ELP_gPickupData[i][ELP_pos][1] = y;
            ELP_gPickupData[i][ELP_pos][2] = z;

            return i;
        }
    }

    print("ERROR: Maximum number of ELP created ("#MAX_ELP_PICKUPS")");
    return -1;
}

#define ELP_DestroyPickup ELP_DeletePickup
stock ELP_DeletePickup(ELP_id)
{
    if(ELP_id == -1) return 0;
    if(ELP_gPickupData[ELP_id][ELP_pickupid] == -1) return 0;

    DestroyPickup(ELP_gPickupData[ELP_id][ELP_pickupid]);
    ELP_gPickupData[ELP_id][ELP_pickupid] = -1;

    foreach(new i : Player)
    {
        if(ELP_playerCurPickupID[i] == ELP_id)
        {
            CallLocalFunction("OnEnterLeavePickup", "iii", i, ELP_id, PICKUP_LEAVE);
            ELP_playerCurPickupID[i] = -1;
        }
    }
    return 1;
}

hook OnPlayerConnect(playerid)
{
    ELP_playerCurPickupID[playerid] = -1;
    return 1;
}

hook OnPlayerPickUpPickup(playerid, pickupid)
{
    // Check if this is an ELP
    for(new i=0; i<MAX_ELP_PICKUPS; i++)
    {
        if(pickupid == ELP_gPickupData[i][ELP_pickupid])
        {
            if(ELP_playerCurPickupID[playerid] == i) return 1;

            // Leave current pickup (if any)
            if(ELP_playerCurPickupID[playerid] != -1)
            {
                CallLocalFunction("OnEnterLeavePickup", "iii", playerid, ELP_playerCurPickupID[playerid], PICKUP_LEAVE);
            }

            ELP_playerCurPickupID[playerid] = i;
            CallLocalFunction("OnEnterLeavePickup", "iii", playerid, i, PICKUP_ENTER);

            /*if(Iter_Count(ELP_Iter) == 0) // No players being tracked, start the check timer
            {
                ELP_TimerID = SetTimer("TMR_ELP_CheckPlayers", ELP_TIMER_INTERVAL, true);
            }
            Iter_Add(ELP_Iter, playerid);*/
            return 1;
        }
    }
    return 1;
}

hook OnPlayerDisconnect(playerid, reason)
{
    if(ELP_playerCurPickupID[playerid] != -1)
    {
        //Iter_Remove(ELP_Iter, playerid);
        CallLocalFunction("OnEnterLeavePickup", "iii", playerid, ELP_playerCurPickupID[playerid], PICKUP_LEAVE);
        ELP_playerCurPickupID[playerid] = -1;
        //if(Iter_Count(ELP_Iter) == 0) KillTimer(ELP_TimerID);
    }
    return 1;
}

/*forward TMR_ELP_CheckPlayers();
public TMR_ELP_CheckPlayers()
{
    print("TMR_ELP_CheckPlayers");
    foreach(new i : ELP_Iter) // Go through all PLAYERS
    {
        new next;
        if(!IsPlayerInRangeOfPoint(i,
        ELP_PICKUP_RANGE,
        ELP_gPickupData[ELP_playerCurPickupID[i]][ELP_pos][0],
        ELP_gPickupData[ELP_playerCurPickupID[i]][ELP_pos][1],
        ELP_gPickupData[ELP_playerCurPickupID[i]][ELP_pos][2]
        ))
        {
            Iter_SafeRemove(ELP_Iter, i, next);
            CallLocalFunction("OnEnterLeavePickup", "iii", i, ELP_playerCurPickupID[i], PICKUP_LEAVE);
            ELP_playerCurPickupID[i] = -1;

            // If there's no more players to watch, kill the timer
            if(Iter_Count(ELP_Iter) == 0) KillTimer(ELP_TimerID);
        }
        i = next;
    }
    return 1;
}*/

hook OnPlayerUpdate(playerid)
{
    if(ELP_playerCurPickupID[playerid] != -1)
    {
        if(!IsPlayerInRangeOfPoint(playerid, ELP_PICKUP_RANGE, ELP_gPickupData[ELP_playerCurPickupID[playerid]][ELP_pos][0], ELP_gPickupData[ELP_playerCurPickupID[playerid]][ELP_pos][1], ELP_gPickupData[ELP_playerCurPickupID[playerid]][ELP_pos][2]))
        {
            CallLocalFunction("OnEnterLeavePickup", "iii", playerid, ELP_playerCurPickupID[playerid], PICKUP_LEAVE);
            ELP_playerCurPickupID[playerid] = -1;
        }
    }
    return 1;
}