s_utils.inc

/*----------------------------------------------------------------------------*\
                    s_utils - Include
@Descrição:
    Esta include conténs várias funções e macros para simplificar e ajudar a escrever
    códigos mais rápidamente.
@Legal:
    Este código-fonte está sob os termos de licença da Mozilla Public
    License, v. 2.0. Se uma cópia do MPL não for distribuida com este
    arquivo, você pode obter uma em http://mozilla.org/MPL/2.0/

    O inicial desenvolvedor deste código é Lucas "Larceny" Godoy.
    Códigos criados pelos iniciais desenvolvedores são Copyright (C) 2012
    Inicial desenvolvedor.
    Todos os direitos reservados.
@Versão:
    1.0 - 02:41 02/09/2011 - linhas: 582
    1.1 - 14:27 27/11/2012 - linhas: 1249
@Change-log:
    1.0:
        Primeira versão.
    1.1:
        Documentação do código, novas funções: GetVehicleDistanceFromVehicle(),
        RemovePlayerSlotWeapon(), GetVehicleDriver(), GetFreeVehicleSeat(),
        IsValidSkin(), IsAValidRPName(), GetPlayerRPName(playerid),
        IsPlayerSpectating() e IsPlayerPassenger(), correções e melhorias.
@Autor:
    Lucas "Larceny" Godoy
@Obrigado-a:
    SA-MP Team -> (c) SA-MP
\*----------------------------------------------------------------------------*/

#include <a_samp>

#if defined _rgutils_included
    #endinput
#endif

#define _rgutils_included

#if !defined isnull
    #define isnull(%1) \
                ((!(%1[0])) || (((%1[0]) == '\1') && (!(%1[1]))))
#endif

#define SetVehicleInterior LinkVehicleToInterior

#define INVALID_SEAT_ID -1

/*
native SetPlayerPosEx(playerid, Float:x, Float:y, Float:z, Float:a);
native IsPlayerInRangeOfVehicle(playerid, vehicleid, Float: radius);
native GetVehicleDistanceFromVehicle(vehicleid, vtargetid);
native GetPlayerDistanceFromVehicle(playerid, vehicleid);
native GetPlayerDistanceFromPlayer(playerid, targetid);
native TeleportPlayerToVehicle(playerid, vehicleid);
native TeleportPlayerToPlayer(playerid, targetid);
native SendAdminMessage(color, const message[]);
native RemovePlayerSlotWeapon(playerid, slotid);
native SetVehicleInterior(vehicleid, interior);
native GivePlayerWantedLevel(playerid, level);
native RemovePlayerWeapon(playerid, weaponid);
native GetVehicleEngineStatus(vehicleid);
native SetPlayerMoney(playerid, money);
native GetPlayerFacingAnglef(playerid);
native GetFreeVehicleSeat(vehicleid);
native GetPlayerWeaponName(playerid);
native GetVehicleHealthf(vehicleid);
native GetVehicleZAnglef(vehicleid);
native FreezePlayer(playerid, time);
native IsVehicleOccupied(vehicleid);
native IsPlayerPassenger(playerid);
native ClearPlayerScreen(playerid);
native GetVehicleDriver(vehicleid);
native GetPlayerArmourf(playerid);
native GetPlayerHealthf(playerid);
native IsPlayerSwimming(playerid);
native IsVehicleLocked(vehicleid);
native GetVehicleName(vehicleid);
native GetPlayerRPName(playerid);
native UnlockVehicle(vehicleid);
native GetWeaponNamef(weaponid);
native GetPlayerNamef(playerid);
native IsPlayerDriver(playerid);
native GetPlayerIpf(playerid);
native LockVehicle(vehicleid);
native FlipVehicle(vehicleid);
native IsAValidRPName(name);
native IsValidSkin(skinid);
*/

forward OnPlayerUnfreeze(playerid);

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o nome do jogador sem necessidade de uma variável intermediária.

    Params:
        - playerid: ID do jogador que obterá o nome.

    Retorna:
        - 'desconhecido' caso o id do jogador for inválido.
        - O nome do jogador (string) caso o id for válido.
\*----------------------------------------------------------------------------*/
stock GetPlayerNamef(playerid)
{
    new s_PLAYER_NAME[MAX_PLAYER_NAME];
    GetPlayerName(playerid, s_PLAYER_NAME, MAX_PLAYER_NAME);
    if(isnull(s_PLAYER_NAME)) s_PLAYER_NAME = "desconhecido";
    return s_PLAYER_NAME;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o valor da saúde do colete do jogador, sem necessidade de uma
        variável intermediária.

    Params:
        - playerid: ID do jogador que obterá a saúde do colete.

    Retorna:
        - 0 caso o id do jogador for inválido.
        - A saúde do colete (float) caso o id for válido.
\*----------------------------------------------------------------------------*/
stock Float:GetPlayerArmourf(playerid)
{
    new Float:f_PLAYER_AMOUR;
    GetPlayerArmour(playerid, f_PLAYER_AMOUR);
    return f_PLAYER_AMOUR;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o valor da saúde do jogador, sem necessidade de uma
        variável intermediária.

    Params:
        - playerid: ID do jogador que obterá a saúde.

    Retorna:
        - 0 caso o id do jogador for inválido.
        - A saúde (float) caso o id for válido.
\*----------------------------------------------------------------------------*/
stock Float:GetPlayerHealthf(playerid)
{
    new Float:f_PLAYER_HEALTH;
    GetPlayerHealth(playerid, f_PLAYER_HEALTH);
    return f_PLAYER_HEALTH;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o ângulo do jogador, sem necessidade de uma
        variável intermediária.

    Params:
        - playerid: ID do jogador que obterá o ângulo.

    Retorna:
        - 0 caso o id do jogador for inválido.
        - O ângulo (float) caso o id for válido.
\*----------------------------------------------------------------------------*/
stock Float:GetPlayerFacingAnglef(playerid)
{
    new Float:f_PLAYER_ANGLE;
    GetPlayerFacingAngle(playerid, f_PLAYER_ANGLE);
    return f_PLAYER_ANGLE;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o ângulo Z do veículo.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - O ângulo do veículo (float).
\*----------------------------------------------------------------------------*/
stock Float:GetVehicleZAnglef(vehicleid)
{
    new Float:f_VEHICLE_ANGLE;
    GetVehicleZAngle(vehicleid, f_VEHICLE_ANGLE);
    return f_VEHICLE_ANGLE;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Verificar se um jogador está de espectador.

    Params:
        - playerid: ID do jogador.

    Retorna:
        - 1 se o jogador estiver de espectador.
        - 0 se o jogador não estiver.
\*----------------------------------------------------------------------------*/
stock IsPlayerSpectating(playerid) {
    return (GetPlayerState(playerid) == PLAYER_STATE_SPECTATING) ? 1 : 0; }

/*----------------------------------------------------------------------------*\
    Função:
        - Verificar se é uma skin válida.

    Params:
        - skin: ID da skin.

    Retorna:
        - 1 se a skin for válida.
        - 0 se a skin for inválida.
\*----------------------------------------------------------------------------*/
stock IsValidSkin(skinid) {
    return  (skinid != 74) ? 1 : 0; }

/*----------------------------------------------------------------------------*\
    Função:
        Retornar se um nome é um nome RolePlay válido.

    Param:
        - name: O nome que será checado.
    Retorna:
        - 0 se o nome não possuir underline "_",
        - 1 se o nome é valído,
        - 2 se o nome conter números,
        - 3 se a primeira letra do nome for minúscula,
        - 4 se a primeira letra do sobrenome for minúscula,
        - 5 se o nome tiver mais letras maiúsculas além das iniciais.
(c) Larceny
\*----------------------------------------------------------------------------*/
stock IsAValidRPName(name[])
{
    new ch = name[0], chr;
    if(strfind(name, "_") != -1)
    {
        if(ch >= 'A' && ch <= 'Z')
        {
            if(strfind(name, "0", true) != -1 ||
                strfind(name, "1", true) != -1 ||
                strfind(name, "2", true) != -1 ||
                strfind(name, "3", true) != -1 ||
                strfind(name, "4", true) != -1 ||
                strfind(name, "5", true) != -1 ||
                strfind(name, "6", true) != -1 ||
                strfind(name, "7", true) != -1 ||
                strfind(name, "8", true) != -1 ||
                strfind(name, "9", true) != -1)
            {
                return 2;
            }
            for(new i=0, j=strlen(name); i < j; i++)
            {
                if(!strfind(name[i], "_"))
                {
                    name[++i];
                    chr = i;
                    if(name[i] >= 'A' && name[i] <= 'Z'){} //return 1;
                    else
                    {
                        return 4;
                    }
                }
                if(name[i] >= 'A' && name[i] <= 'Z' && i != 0 && chr != i)
                {
                    return 5;
                }
                else continue;
            }
            return 1;
        }
        else
        {
            return 3;
        }
    }
    else
    {
        return 0;
    }
}

/*----------------------------------------------------------------------------*\
    Função:
        Retornar se um jogador tem um nome RolePlay válido.

    Param:
        - playerid: O ID do jogador.
    Retorna:
        - 0 se o nome não possuir underline "_",
        - 1 se o nome é valído,
        - 2 se o nome conter números,
        - 3 se a primeira letra do nome for minúscula,
        - 4 se a primeira letra do sobrenome for minúscula,
        - 5 se o nome tiver mais letras maiúsculas além das iniciais.
(c) Larceny
\*----------------------------------------------------------------------------*/
stock GetPlayerRPName(playerid)
{
    new name[MAX_PLAYER_NAME];
    GetPlayerName(playerid, name, MAX_PLAYER_NAME);

    new ch = name[0], chr;
    if(strfind(name, "_") != -1)
    {
        if(ch >= 'A' && ch <= 'Z')
        {
            if(strfind(name, "0", true) != -1 ||
                strfind(name, "1", true) != -1 ||
                strfind(name, "2", true) != -1 ||
                strfind(name, "3", true) != -1 ||
                strfind(name, "4", true) != -1 ||
                strfind(name, "5", true) != -1 ||
                strfind(name, "6", true) != -1 ||
                strfind(name, "7", true) != -1 ||
                strfind(name, "8", true) != -1 ||
                strfind(name, "9", true) != -1)
            {
                return 2;
            }
            for(new i=0, j=strlen(name); i < j; i++)
            {
                if(!strfind(name[i], "_"))
                {
                    name[++i];
                    chr = i;
                    if(name[i] >= 'A' && name[i] <= 'Z'){} //return 1;
                    else
                    {
                        return 4;
                    }
                }
                if(name[i] >= 'A' && name[i] <= 'Z' && i != 0 && chr != i)
                {
                    return 5;
                }
                else continue;
            }
            return 1;
        }
        else
        {
            return 3;
        }
    }
    else
    {
        return 0;
    }
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter próximo banco disponível de um veículo.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - O ID do assento caso houver disponível.
        - INVALID_SEAT_ID (ou -1) caso não houver bancos disponíveis.
\*----------------------------------------------------------------------------*/
stock GetFreeVehicleSeat(vehicleid)
{
    new bool:anVehicleSeats[5];
    for ( new slots = GetMaxPlayers( ), i; i < slots; i++ ) {
        if(IsPlayerInVehicle(i, vehicleid))
            if(GetPlayerVehicleSeat(i) != 128)
                anVehicleSeats[GetPlayerVehicleSeat(i)] = true;
    }

    for ( new s; s < sizeof anVehicleSeats; s++ ) {
        if(anVehicleSeats[s])
            continue;

        return s;
    }
    return INVALID_SEAT_ID;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o motorista de um veículo.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - O ID do jogador que estiver pilotando o veículo.
        - INVALID_PLAYER_ID caso não tiver motorista.
\*----------------------------------------------------------------------------*/
stock GetVehicleDriver(vehicleid)
{
    for ( new slots = GetMaxPlayers( ), i; i < slots; i++ ) {
        if(!IsPlayerConnected(playerid))
            continue;
        if(IsPlayerInVehicle(playerid, vehicleid))
            return i;
    }
    return INVALID_PLAYER_ID;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter a distância entre dois jogadores.

    Params:
        - playerid: ID do jogador 1.
        - targetid: ID do jogador 2.

    Retorna:
        - A distância (float) entre os dois jogadores.
\*----------------------------------------------------------------------------*/
stock Float:GetPlayerDistanceFromPlayer(playerid, targetid)
{
    new Float:fDist[3];
    GetPlayerPos(playerid, fDist[0], fDist[1], fDist[2]);
    return GetPlayerDistanceFromPoint(targetid, fDist[0],
        fDist[1], fDist[2]);
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter a distância entre um jogador e um veículo.

    Params:
        - playerid: ID do jogador.
        - vehicleid: ID do veículo.

    Retorna:
        - A distância (float) entre o jogador e o veículo.
\*----------------------------------------------------------------------------*/
stock Float:GetPlayerDistanceFromVehicle(playerid, vehicleid)
{
    new Float:fDist[3];
    GetPlayerPos(playerid, fDist[0], fDist[1], fDist[2]);
    return GetVehicleDistanceFromPoint(vehicleid, fDist[0],
        fDist[1], fDist[2]);
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter a distância entre um dois veículos.

    Params:
        - vehicleid: ID do veículo 1.
        - vtargetid: ID do veículo 2.

    Retorna:
        - A distância (float) entre os dois veículos.
\*----------------------------------------------------------------------------*/
stock Float:GetVehicleDistanceFromVehicle(vehicleid, vtargetid)
{
    new Float:fDist[3];
    GetVehiclePos(vtargetid, fDist[0], fDist[1], fDist[2]);
    return GetVehicleDistanceFromPoint(vehicleid, fDist[0],
        fDist[1], fDist[2]);
}

/*----------------------------------------------------------------------------*\
    Função:
        - Verificar se o jogador está próximo de um veículo, dentro de uma
        determinada radiação.

    Params:
        - playerid: ID do jogador.
        - vehicleid: ID do veículo.
        - radius: Radiação máxima (float) a ser checada.

    Retorna:
        - 1 se o jogador estiver dentro da radiação do veículo.
        - 0 se o jogador não estiver.
\*----------------------------------------------------------------------------*/
stock IsPlayerInRangeOfVehicle(playerid, vehicleid, Float:radius)
{
    new Float:fDist[3];
    GetVehiclePos(vehicleid, fDist[0], fDist[1], fDist[2]);
    return IsPlayerInRangeOfPoint(playerid, radius, fDist[0],
        fDist[1], fDist[2]);
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o IP de um jogador, sem a necessidade de uma variável
        intermediária.

    Params:
        - playerid: ID do jogador.

    Retorna:
        - O ip do jogador (string).
\*----------------------------------------------------------------------------*/
stock GetPlayerIpf(playerid)
{
    new s_PLAYER_IP[18];
    GetPlayerIp(playerid, s_PLAYER_IP, sizeof(s_PLAYER_IP));
    return s_PLAYER_IP;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o nome da arma do jogador.

    Params:
        - playerid: ID do jogador.

    Retorna:
        - O nome da arma do jogador (string).
\*----------------------------------------------------------------------------*/
stock GetPlayerWeaponName(playerid)
{
    new s_WEAPON_NAME[21];
    GetWeaponName(GetPlayerWeapon(playerid), s_WEAPON_NAME,
        sizeof(s_WEAPON_NAME));

    if(GetPlayerWeapon(playerid) == 0)
        s_WEAPON_NAME = "Nenhuma";
    else if(GetPlayerWeapon(playerid) == 18)
        s_WEAPON_NAME = "Molotov Cocktail";
    else if(GetPlayerWeapon(playerid) == 44)
        s_WEAPON_NAME = "Night Vis Goggles";
    else if(GetPlayerWeapon(playerid) == 45)
        s_WEAPON_NAME = "Thermal Goggles";

    return s_WEAPON_NAME;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Limpar o chat de um jogador.

    Params:
        - playerid: ID do jogador.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock ClearPlayerScreen(playerid)
{
    for(new i = 0; i < 100; i++){SendClientMessage(playerid, -1, " ");}
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Definir o dinheiro de um jogador.

    Params:
        - playerid: ID do jogador.
        - money: Quantia de dinheiro.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock SetPlayerMoney(playerid, money)
{
    ResetPlayerMoney(playerid);
    GivePlayerMoney(playerid, money);
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Definir a posição e ângulo do jogador.

    Params:
        - playerid: ID do jogador.
        - Floatx: Posição X.
        - Floaty: Posição Y.
        - Floatz: Posição Z.
        - Floata: Ângulo.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock SetPlayerPosEx(playerid, Float:x, Float:y, Float:z, Float:a)
{
    SetPlayerPos(playerid, x, y, z);
    SetPlayerFacingAngle(playerid, a);
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Acrescentar nível de procurar a um jogador.

    Params:
        - playerid: ID do jogador.
        - level: Nível de procurado a ser acrescentado.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock GivePlayerWantedLevel(playerid, level)
{
    if(level + GetPlayerWantedLevel(playerid) > 6) {
        SetPlayerWantedLevel(playerid, 6);
        return;
    }

    SetPlayerWantedLevel(playerid, GetPlayerWantedLevel(playerid)+level);
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Congelar um jogador por um período de tempo.

    Params:
        - playerid: ID do jogador.
        - time: Tempo em que o jogador ficará congelado.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock FreezePlayer(playerid, time = 5000)
{
    TogglePlayerControllable(playerid, false);

    if(GetPVarInt(playerid, "FreezeTimer") != 0)
        KillTimer(GetPVarInt(playerid, "FreezeTimer"));

    SetPVarInt(playerid, "FreezeTimer",
        SetTimerEx("OnPlayerUnfreeze", time, false, "i", playerid));
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Remover uma arma específica de um jogador.

    Params:
        - playerid: ID do jogador.
        - weaponid: ID da arma que será removida.

    Retorna:
        - 0 caso o id do jogador inválido ou arma inválida.
        - 1 caso for executada com sucesso.
\*----------------------------------------------------------------------------*/
stock RemovePlayerWeapon(playerid, weaponid)
{
    if(playerid == INVALID_PLAYER_ID ||
        !IsPlayerConnected(playerid) ||
        weaponid < 0 ||
        weaponid > 46) return 0;

    new e_OLD_WEAPON[13], e_OLD_AMMO[13];

    for(new slot = 0; slot < 13; slot++) {
        GetPlayerWeaponData(playerid,
            slot,
            e_OLD_WEAPON[slot],
            e_OLD_AMMO[slot]);
    }

    ResetPlayerWeapons(playerid);

    for(new slot; slot < 13; slot++) {

        if(e_OLD_WEAPON[slot] == weaponid || e_OLD_AMMO[slot] == 0) {
            continue;
        }

        GivePlayerWeapon(playerid, e_OLD_WEAPON[slot], e_OLD_AMMO[slot]);
    }
    GivePlayerWeapon(playerid, 0, 1);
    return 1;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter a saúde do veículo.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - A saúde do veículo (float).
\*----------------------------------------------------------------------------*/
stock Float:GetVehicleHealthf(vehicleid)
{
    new Float:f_VEHICLE_HEALTH;
    GetVehicleHealth(vehicleid, f_VEHICLE_HEALTH);
    return f_VEHICLE_HEALTH;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Remover qualquer arma de um slot específico de um jogador.

    Params:
        - playerid: ID do jogador.
        - slotid: ID do slot que a arma será removida.

    Retorna:
        - 0 caso o id do jogador inválido ou slot inválido.
        - 1 caso for executada com sucesso.
\*----------------------------------------------------------------------------*/
stock RemovePlayerSlotWeapon(playerid, slotid)
{
    if(playerid == INVALID_PLAYER_ID ||
        !IsPlayerConnected(playerid) ||
        slotid < 0 ||
        slotid > 12) return 0;

    new e_OLD_WEAPON[13], e_OLD_AMMO[13];

    for(new slot = 0; slot < 13; slot++) {
        GetPlayerWeaponData(playerid,
            slot,
            e_OLD_WEAPON[slot],
            e_OLD_AMMO[slot]);
    }

    ResetPlayerWeapons(playerid);

    for(new slot; slot < 13; slot++) {

        if(slot == slotid) {
            continue;
        }

        GivePlayerWeapon(playerid, e_OLD_WEAPON[slot], e_OLD_AMMO[slot]);
    }
    GivePlayerWeapon(playerid, 0, 1);
    return 1;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Verificar se um veículo está ocupado com algum jogador.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - 0 caso o id do jogador inválido ou slot inválido.
        - 1 caso for executada com sucesso.
\*----------------------------------------------------------------------------*/
stock IsVehicleOccupied(vehicleid)
{
    for ( new slots = GetMaxPlayers( ), i; i < slots; i++ ) {
        if(!IsPlayerConnected(i))
            continue;

        if(IsPlayerInVehicle(i, vehicleid))
            return 1;
    }
    return 0;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Teleportar um jogador para um veículo.

    Params:
        - playerid: ID do jogador.
        - vehicleid: ID do veículo.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock TeleportPlayerToVehicle(playerid, vehicleid)
{
    new Float:fDist[3];
    GetVehiclePos(vehicleid, fDist[0], fDist[1], fDist[2]);
    SetPlayerPos(playerid, fDist[0], fDist[1], fDist[2]);
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Teleportar um jogador para outro jogador.

    Params:
        - playerid: ID do jogador 1.
        - targetid: ID do jogador 2.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock TeleportPlayerToPlayer(playerid, targetid)
{
    new Float:fDist[3];
    GetPlayerPos(targetid, fDist[0], fDist[1], fDist[2]);
    SetPlayerPos(playerid, fDist[0], fDist[1], fDist[2]);
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Verificar se um jogador é motorista de algum veículo.

    Params:
        - playerid: ID do jogador.

    Retorna:
        - 0 caso o jogador não for um motorista.
        - 1 caso o jogador for um motorista.
\*----------------------------------------------------------------------------*/
stock IsPlayerDriver(playerid)
{
    if(GetPlayerState(playerid) == PLAYER_STATE_DRIVER) return true;
    return false;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Verificar se um jogador é um passageiro de algum veículo.

    Params:
        - playerid: ID do jogador.

    Retorna:
        - 0 caso o jogador não for um passageiro.
        - 1 caso o jogador for um passageiro.
\*----------------------------------------------------------------------------*/
stock IsPlayerPassenger(playerid)
{
    if(GetPlayerState(playerid) == PLAYER_STATE_PASSENGER) return true;
    return false;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Verificar se um jogador está nadando.

    Params:
        - playerid: ID do jogador.

    Retorna:
        - 0 caso o jogador não estiver nadando.
        - 1 caso o jogador estiver nadando.
\*----------------------------------------------------------------------------*/
stock IsPlayerSwimming(playerid)
{
    if(IsPlayerInAnyVehicle(playerid) ||
        GetPlayerState(playerid) != PLAYER_STATE_ONFOOT)
        return 0;

    new animlib[32], animname[32];
    GetAnimationName(GetPlayerAnimationIndex(playerid),
        animlib, 32, animname,32);

    if(!strcmp(animlib, "SWIM", true) &&
        (!strcmp(animname, "SWIM_CRAWL", true) ||
        !strcmp(animname, "SWIM_GLIDE", true) ||
        !strcmp(animname, "SWIM_UNDER", true) ||
        !strcmp(animname, "SWIM_TREAD", true) ||
        !strcmp(animname, "SWIM_BREAST", true) ||
        !strcmp(animname, "SWIM_DIVE_UNDER", true) ||
        !strcmp(animname, "SWIM_DIVE_GLIDE", true)))
        return 1;
    return 0;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Desvirar um veículo.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock FlipVehicle(vehicleid)
{
    SetVehicleZAngle(vehicleid, GetVehicleZAnglef(vehicleid));
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o nome do veículo.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - 'invalído' caso o id do veículo seja inválido.
        - O nome do veículo (string) caso for válido.
\*----------------------------------------------------------------------------*/
stock GetVehicleName(vehicleid)
{
    new a_VEHICLE_NAME[22];
    switch(GetVehicleModel(vehicleid)) {
        case 400: a_VEHICLE_NAME = "Landstalker";
        case 401: a_VEHICLE_NAME = "Bravura";
        case 402: a_VEHICLE_NAME = "Buffalo";
        case 403: a_VEHICLE_NAME = "Linerunner";
        case 404: a_VEHICLE_NAME = "Perenniel";
        case 405: a_VEHICLE_NAME = "Sentinel";
        case 406: a_VEHICLE_NAME = "Dumper";
        case 407: a_VEHICLE_NAME = "Firetruck";
        case 408: a_VEHICLE_NAME = "Trashmaster";
        case 409: a_VEHICLE_NAME = "Stretch";
        case 410: a_VEHICLE_NAME = "Manana";
        case 411: a_VEHICLE_NAME = "Infernus";
        case 412: a_VEHICLE_NAME = "Voodoo";
        case 413: a_VEHICLE_NAME = "Pony";
        case 414: a_VEHICLE_NAME = "Mule";
        case 415: a_VEHICLE_NAME = "Cheetah";
        case 416: a_VEHICLE_NAME = "Ambulance";
        case 417: a_VEHICLE_NAME = "Leviathan";
        case 418: a_VEHICLE_NAME = "Moonbeam";
        case 419: a_VEHICLE_NAME = "Esperanto";
        case 420: a_VEHICLE_NAME = "Taxi";
        case 421: a_VEHICLE_NAME = "Washigton";
        case 422: a_VEHICLE_NAME = "Bobcat";
        case 423: a_VEHICLE_NAME = "Mr Whoopee";
        case 424: a_VEHICLE_NAME = "BF Injection";
        case 425: a_VEHICLE_NAME = "Hunter";
        case 426: a_VEHICLE_NAME = "Premier";
        case 427: a_VEHICLE_NAME = "Enforcer";
        case 428: a_VEHICLE_NAME = "Securicar";
        case 429: a_VEHICLE_NAME = "Banshee";
        case 430: a_VEHICLE_NAME = "Predator";
        case 431: a_VEHICLE_NAME = "Bus";
        case 432: a_VEHICLE_NAME = "Rhino";
        case 433: a_VEHICLE_NAME = "Barracks";
        case 434: a_VEHICLE_NAME = "Hotknife";
        case 435: a_VEHICLE_NAME = "Article Trailer";
        case 436: a_VEHICLE_NAME = "Previon";
        case 437: a_VEHICLE_NAME = "Coach";
        case 438: a_VEHICLE_NAME = "Cabbie";
        case 439: a_VEHICLE_NAME = "Stallion";
        case 440: a_VEHICLE_NAME = "Rumpo";
        case 441: a_VEHICLE_NAME = "RC Bandit";
        case 442: a_VEHICLE_NAME = "Romero";
        case 443: a_VEHICLE_NAME = "Packer";
        case 444: a_VEHICLE_NAME = "Monster";
        case 445: a_VEHICLE_NAME = "Admiral";
        case 446: a_VEHICLE_NAME = "Squallo";
        case 447: a_VEHICLE_NAME = "Seasparrow";
        case 448: a_VEHICLE_NAME = "Pizzaboy";
        case 449: a_VEHICLE_NAME = "Tram";
        case 450: a_VEHICLE_NAME = "Article Trailer 2";
        case 451: a_VEHICLE_NAME = "Turismo";
        case 452: a_VEHICLE_NAME = "Speeder";
        case 453: a_VEHICLE_NAME = "Reefer";
        case 454: a_VEHICLE_NAME = "Tropic";
        case 455: a_VEHICLE_NAME = "Flatbed";
        case 456: a_VEHICLE_NAME = "Yankee";
        case 457: a_VEHICLE_NAME = "Caddy";
        case 458: a_VEHICLE_NAME = "Solair";
        case 459: a_VEHICLE_NAME = "Topfun Van";
        case 460: a_VEHICLE_NAME = "Skimmer";
        case 461: a_VEHICLE_NAME = "PCJ-600";
        case 462: a_VEHICLE_NAME = "Faggio";
        case 463: a_VEHICLE_NAME = "Freeway";
        case 464: a_VEHICLE_NAME = "RC Baron";
        case 465: a_VEHICLE_NAME = "RC Raider";
        case 466: a_VEHICLE_NAME = "Glendale";
        case 467: a_VEHICLE_NAME = "Oceanic";
        case 468: a_VEHICLE_NAME = "Sanchez";
        case 469: a_VEHICLE_NAME = "Sparrow";
        case 470: a_VEHICLE_NAME = "Patriot";
        case 471: a_VEHICLE_NAME = "Quad";
        case 472: a_VEHICLE_NAME = "Coastguard";
        case 473: a_VEHICLE_NAME = "Dinghy";
        case 474: a_VEHICLE_NAME = "Hermes";
        case 475: a_VEHICLE_NAME = "Sabre";
        case 476: a_VEHICLE_NAME = "Rustler";
        case 477: a_VEHICLE_NAME = "ZR-350";
        case 478: a_VEHICLE_NAME = "Walton";
        case 479: a_VEHICLE_NAME = "Regina";
        case 480: a_VEHICLE_NAME = "Comet";
        case 481: a_VEHICLE_NAME = "BMX";
        case 482: a_VEHICLE_NAME = "Burrito";
        case 483: a_VEHICLE_NAME = "Camper";
        case 484: a_VEHICLE_NAME = "Marquis";
        case 485: a_VEHICLE_NAME = "Baggage";
        case 486: a_VEHICLE_NAME = "Dozer";
        case 487: a_VEHICLE_NAME = "Maverick";
        case 488: a_VEHICLE_NAME = "San News Maverick";
        case 489: a_VEHICLE_NAME = "Rancher";
        case 490: a_VEHICLE_NAME = "FBI Rancher";
        case 491: a_VEHICLE_NAME = "Virgo";
        case 492: a_VEHICLE_NAME = "Greenwood";
        case 493: a_VEHICLE_NAME = "Jetmax";
        case 494: a_VEHICLE_NAME = "Hotring Racer";
        case 495: a_VEHICLE_NAME = "Sandking";
        case 496: a_VEHICLE_NAME = "Blista Compact";
        case 497: a_VEHICLE_NAME = "Police Maverick";
        case 498: a_VEHICLE_NAME = "Boxville";
        case 499: a_VEHICLE_NAME = "Benson";
        case 500: a_VEHICLE_NAME = "Mesa";
        case 501: a_VEHICLE_NAME = "RC Goblin";
        case 502: a_VEHICLE_NAME = "Hotring Racer";
        case 503: a_VEHICLE_NAME = "Hotring Racer";
        case 504: a_VEHICLE_NAME = "Bloodring Banger";
        case 505: a_VEHICLE_NAME = "Rancher";
        case 506: a_VEHICLE_NAME = "Super GT";
        case 507: a_VEHICLE_NAME = "Elegant";
        case 508: a_VEHICLE_NAME = "Journey";
        case 509: a_VEHICLE_NAME = "Bike";
        case 510: a_VEHICLE_NAME = "Mountain Bike";
        case 511: a_VEHICLE_NAME = "Beagle";
        case 512: a_VEHICLE_NAME = "Cropduster";
        case 513: a_VEHICLE_NAME = "Stuntplane";
        case 514: a_VEHICLE_NAME = "Tanker";
        case 515: a_VEHICLE_NAME = "Roadtrain";
        case 516: a_VEHICLE_NAME = "Nebula";
        case 517: a_VEHICLE_NAME = "Majestic";
        case 518: a_VEHICLE_NAME = "Buccaneer";
        case 519: a_VEHICLE_NAME = "Shamal";
        case 520: a_VEHICLE_NAME = "Hydra";
        case 521: a_VEHICLE_NAME = "FCR-900";
        case 522: a_VEHICLE_NAME = "NRG-500";
        case 523: a_VEHICLE_NAME = "HPV-1000";
        case 524: a_VEHICLE_NAME = "Cement Truck";
        case 525: a_VEHICLE_NAME = "TowTruck";
        case 526: a_VEHICLE_NAME = "Fortune";
        case 527: a_VEHICLE_NAME = "Cadrona";
        case 528: a_VEHICLE_NAME = "FBI Truck";
        case 529: a_VEHICLE_NAME = "Willard";
        case 530: a_VEHICLE_NAME = "Forklift";
        case 531: a_VEHICLE_NAME = "Tractor";
        case 532: a_VEHICLE_NAME = "Combine Harvester";
        case 533: a_VEHICLE_NAME = "Feltzer";
        case 534: a_VEHICLE_NAME = "Remington";
        case 535: a_VEHICLE_NAME = "Slamvan";
        case 536: a_VEHICLE_NAME = "Blade";
        case 537: a_VEHICLE_NAME = "Freight (Train)";
        case 538: a_VEHICLE_NAME = "Brownstreak (Train)";
        case 539: a_VEHICLE_NAME = "Vortex";
        case 540: a_VEHICLE_NAME = "Vincent";
        case 541: a_VEHICLE_NAME = "Bullet";
        case 542: a_VEHICLE_NAME = "Clover";
        case 543: a_VEHICLE_NAME = "Sadler";
        case 544: a_VEHICLE_NAME = "Firetruck LA";
        case 545: a_VEHICLE_NAME = "Hustler";
        case 546: a_VEHICLE_NAME = "Intruder";
        case 547: a_VEHICLE_NAME = "Primo";
        case 548: a_VEHICLE_NAME = "Cargobob";
        case 549: a_VEHICLE_NAME = "Tampa";
        case 550: a_VEHICLE_NAME = "Sunrise";
        case 551: a_VEHICLE_NAME = "Merit";
        case 552: a_VEHICLE_NAME = "Utility Van";
        case 553: a_VEHICLE_NAME = "Nevada";
        case 554: a_VEHICLE_NAME = "Yosemite";
        case 555: a_VEHICLE_NAME = "Windsor";
        case 556: a_VEHICLE_NAME = "Monster ''A''";
        case 557: a_VEHICLE_NAME = "Monster ''B''";
        case 558: a_VEHICLE_NAME = "Uranus";
        case 559: a_VEHICLE_NAME = "Jester";
        case 560: a_VEHICLE_NAME = "Sultan";
        case 561: a_VEHICLE_NAME = "Stratum";
        case 562: a_VEHICLE_NAME = "Elegy";
        case 563: a_VEHICLE_NAME = "Raindance";
        case 564: a_VEHICLE_NAME = "RC Tiger";
        case 565: a_VEHICLE_NAME = "Flash";
        case 566: a_VEHICLE_NAME = "Tahoma";
        case 567: a_VEHICLE_NAME = "Savanna";
        case 568: a_VEHICLE_NAME = "Bandito";
        case 569: a_VEHICLE_NAME = "Freight Flat Trailer";
        case 570: a_VEHICLE_NAME = "Streak Trailer";
        case 571: a_VEHICLE_NAME = "Kart";
        case 572: a_VEHICLE_NAME = "Mower";
        case 573: a_VEHICLE_NAME = "Dune";
        case 574: a_VEHICLE_NAME = "Sweeper";
        case 575: a_VEHICLE_NAME = "Broadway";
        case 576: a_VEHICLE_NAME = "Tornado";
        case 577: a_VEHICLE_NAME = "AT400";
        case 578: a_VEHICLE_NAME = "DFT-30";
        case 579: a_VEHICLE_NAME = "Huntley";
        case 580: a_VEHICLE_NAME = "Stafford";
        case 581: a_VEHICLE_NAME = "BF-400";
        case 582: a_VEHICLE_NAME = "Newsvan";
        case 583: a_VEHICLE_NAME = "Tug";
        case 584: a_VEHICLE_NAME = "Petrol Trailer";
        case 585: a_VEHICLE_NAME = "Emperor";
        case 586: a_VEHICLE_NAME = "Wayfarer";
        case 587: a_VEHICLE_NAME = "Euros";
        case 588: a_VEHICLE_NAME = "Hotdog";
        case 589: a_VEHICLE_NAME = "Club";
        case 590: a_VEHICLE_NAME = "Freight Box Trailer";
        case 591: a_VEHICLE_NAME = "Article Trailer 3";
        case 592: a_VEHICLE_NAME = "Andromada";
        case 593: a_VEHICLE_NAME = "Dodo";
        case 594: a_VEHICLE_NAME = "RC Cam";
        case 595: a_VEHICLE_NAME = "Launch";
        case 596: a_VEHICLE_NAME = "Police Car (LSPD)";
        case 597: a_VEHICLE_NAME = "Police Car (SFPD)";
        case 598: a_VEHICLE_NAME = "Police Car (LVPD)";
        case 599: a_VEHICLE_NAME = "Police Ranger";
        case 600: a_VEHICLE_NAME = "Picador";
        case 601: a_VEHICLE_NAME = "S.W.A.T";
        case 602: a_VEHICLE_NAME = "Alpha";
        case 603: a_VEHICLE_NAME = "Phoenix";
        case 604: a_VEHICLE_NAME = "Glendale Shit";
        case 605: a_VEHICLE_NAME = "Sadler Shit";
        case 606: a_VEHICLE_NAME = "Baggage Trailer ''A''";
        case 607: a_VEHICLE_NAME = "Baggage Trailer ''B''";
        case 608: a_VEHICLE_NAME = "Tug Stairs Trailer";
        case 609: a_VEHICLE_NAME = "Boxville";
        case 610: a_VEHICLE_NAME = "Farm Trailer";
        case 611: a_VEHICLE_NAME = "Utility Trailer";
        default: a_VEHICLE_NAME = "inválido";
    }
    return a_VEHICLE_NAME;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o status do motor do veículo.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - 1 caso o motor do veículo estiver ligado.
        - 0 caso o motor do veículo estiver desligado.
\*----------------------------------------------------------------------------*/
stock GetVehicleEngineStatus(vehicleid)
{
    new v_ENGINE, v_LIGHTS, v_ALARM, v_DOORS, v_BONNET, v_BOOT, v_OBJECTIVE;
    GetVehicleParamsEx(vehicleid, v_ENGINE, v_LIGHTS, v_ALARM,
        v_DOORS, v_BONNET, v_BOOT, v_OBJECTIVE);
    if(v_ENGINE == VEHICLE_PARAMS_ON) return 1;
    return 0;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Verificar se um veículo está trancado.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - 1 caso o veículo estiver trancado.
        - 0 caso o veículo estiver destrancado.
\*----------------------------------------------------------------------------*/
stock IsVehicleLocked(vehicleid)
{
    new v_ENGINE, v_LIGHTS, v_ALARM, v_DOORS, v_BONNET, v_BOOT, v_OBJECTIVE;
    GetVehicleParamsEx(vehicleid, v_ENGINE, v_LIGHTS, v_ALARM,
        v_DOORS, v_BONNET, v_BOOT, v_OBJECTIVE);
    if(v_DOORS == true) return 1;
    return 0;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Trancar um veículo.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock LockVehicle(vehicleid)
{
    new v_ENGINE, v_LIGHTS, v_ALARM, v_DOORS, v_BONNET, v_BOOT, v_OBJECTIVE;
    GetVehicleParamsEx(vehicleid, v_ENGINE, v_LIGHTS, v_ALARM,
        v_DOORS, v_BONNET, v_BOOT, v_OBJECTIVE);
    SetVehicleParamsEx(vehicleid, v_ENGNIE, v_LIGHTS, v_ALARM,
        true, v_BONNET, v_BOOT, v_OBJECTIVE);
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Destrancar um veículo.

    Params:
        - vehicleid: ID do veículo.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock UnlockVehicle(vehicleid)
{
    new v_ENGINE, v_LIGHTS, v_ALARM, v_DOORS, v_BONNET, v_BOOT, v_OBJECTIVE;
    GetVehicleParamsEx(vehicleid, v_ENGINE, v_LIGHTS, v_ALARM,
        v_DOORS, v_BONNET, v_BOOT, v_OBJECTIVE);
    SetVehicleParamsEx(vehicleid, v_ENGNIE, v_LIGHTS, v_ALARM,
        false, v_BONNET, v_BOOT, v_OBJECTIVE);
    return 0;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Obter o nome de uma arma sem necessidade de uma variável
        intermediária.

    Params:
        - weaponid: ID da arma.

    Retorna:
        - 'desconhecida' caso o id da arma for inválido.
        - O nome da arma (string) caso o id for válido.
\*----------------------------------------------------------------------------*/
stock GetWeaponNamef(weaponid)
{
    new e_WEAPON_NAME[21];
    GetWeaponName(weaponid, e_WEAPON_NAME, sizeof(e_WEAPON_NAME));

    if(weaponid == 0) s_WEAPON_NAME = "Nenhuma";
    else if(weaponid == 18) s_WEAPON_NAME = "Molotov Cocktail";
    else if(weaponid == 44) s_WEAPON_NAME = "Night Vis Goggles";
    else if(weaponid == 45) s_WEAPON_NAME = "Thermal Goggles";
    else if(isnull(e_WEAPON_NAME)) e_WEAPON_NAME = "desconhecida";

    return e_WEAPON_NAME;
}

/*----------------------------------------------------------------------------*\
    Função:
        - Enviar uma mensagem aos administradores RCON.

    Params:
        - color: Cor (hex) da mensagem.
        - message: Mensagem (string) a ser enviada.

    Retorna:
        - Esta função não retorna um valor específico.
\*----------------------------------------------------------------------------*/
stock SendAdminMessage(color, const message[])
{
    for ( new slots = GetMaxPlayers( ), i; i < slots; i++ ) {
        if(!IsPlayerConnected(i))
            continue;

        if(IsPlayerAdmin(i)){
            SendClientMessage(i, color, message);
        }
    }
    return;
}

/*----------------------------------------------------------------------------*\
    Função:
        -

    Params:
        -

    Retorna:
        -
\*----------------------------------------------------------------------------*/
public OnPlayerUnfreeze(playerid)
{
    TogglePlayerControllable(playerid, true);
    DeletePVar(playerid, "FreezeTimer");
    return 1;
}

#undef isnull