C-Guns | V0.25

#include <a_samp>

#define DANGER_HEALTH   100

new Float:DangerHealth = 100.0;

stock SetDangerHealth(Float:danger) return DangerHealth = danger;
stock GetDangerHealth() return DangerHealth;

forward OnPlayerWeaponHack(playerid, weaponid, allowed_ammo, owned_ammo);

/*
native SetDangerHealth(Float:danger); // if the player's health is less than this, it'll do PlayerBulletCheck
native GetDangerHealth();

native GetPlayerBulletsShot(playerid); //Returns the amount of bullets shot
native GetPlayerBulletsHit(playerid); // Returns the amount of bullets HIT
native Float:GetBulletsHitAccuracy(playerid); //Returns accuracy in % PERCENTAGE
native GivePlayerWeaponEx(playerid, weaponid, ammo);
native ResetPlayerWeaponsEx(playerid);
native SetPlayerAmmoEx(playerid, weaponid, ammo);

native GetPlayerAllowedAmmo(playerid, weaponid); //returns the player's ALLOWED ammo
native GetPlayerActualAmmo(playerid, weaponid);  //returns the ammo the player POSSESSES

//only use these func's if you know them
native GetWeaponSlot(weaponid);
native IsWeaponGun(weaponid); //Returns if the weapon ID is a gun
native WeaponHackCheck(playerid);   // Checking for player weapon hacks
native GiveValidWeapons(playerid);  // DO NOT USE
native PlayerBulletCheck(playerid); //DO NOT USE
*/

stock GetWeaponSlot(weaponid)
{
    new slot;
    switch(weaponid)
    {
        case 0,1: slot = 0;
        case 2 .. 9: slot = 1;
        case 10 .. 15: slot = 10;
        case 16 .. 18, 39: slot = 8;
        case 22 .. 24: slot =2;
        case 25 .. 27: slot = 3;
        case 28, 29, 32: slot = 4;
        case 30, 31: slot = 5;
        case 33, 34: slot = 6;
        case 35 .. 38: slot = 7;
        case 40: slot = 12;
        case 41 .. 43: slot = 9;
        case 44 .. 46: slot = 11;
    }
    return slot;
}

enum e_B_p
{
    BulletsShot,
    BulletsHit,
    bool:Weapons[45],
    WeaponsAmmo[45]
}

new eB[MAX_PLAYERS][e_B_p];

stock PlayerBulletCheck(playerid)
{
    new weapdata[12][2], totalbullets;
    for(new x=0; x < 12; x++)
    {
        GetPlayerWeaponData(playerid, x, weapdata[x][0], weapdata[x][1]);
        for(new d =0; d < 45; d++)
        {
            if(IsWeaponGun(d) && eB[playerid][Weapons][d] == true && eB[playerid][WeaponsAmmo][d] == 0) eB[playerid][Weapons][d] = false;
            if(eB[playerid][Weapons][d] == true && eB[playerid][WeaponsAmmo][d] != 0 && weapdata[x][0] == d && IsWeaponGun(weapdata[x][0]))
            {
                totalbullets += eB[playerid][WeaponsAmmo][d]-weapdata[x][1];
                eB[playerid][WeaponsAmmo][d] = weapdata[x][1];

            }
        }
    }
    eB[playerid][BulletsShot] += totalbullets;
    GiveValidWeapons(playerid);
    WeaponHackCheck(playerid);
    return 1;
}

stock RemovePlayerWeapon(playerid, weaponid)
{
    if(IsWeaponGun(weaponid)) return SetPlayerAmmoEx(playerid, weaponid, 0);
    else if(!IsWeaponGun(weaponid))
    {
        ResetPlayerWeapons(playerid);
        SetPlayerAmmoEx(playerid, weaponid, 0);
        for(new x=0; x < 46; x++)
        {
            GivePlayerWeapon(playerid, eB[playerid][Weapons][weaponid], eB[playerid][WeaponsAmmo][weaponid]);
        }
    }
    return 1;
}

stock GiveValidWeapons(playerid)
{
    for(new x=0; x < 45; x++)
    {
        SetPlayerAmmo(playerid, x, eB[playerid][WeaponsAmmo][x]);
    }
    return 1;
}


stock GetPlayerAllowedAmmo(playerid, weaponid) return eB[WeaponsAmmo][weaponid];
stock GetPlayerActualAmmo(playerid, weaponid)
{
    new weapon[3];
    weapon[0] = GetWeaponSlot(weaponid);
    GetPlayerWeaponData(playerid, weapon[0], weapon[1], weapon[2]);
    return weapon[2];
}


stock IsWeaponGun(weaponid)
{
    switch(weaponid)
    {
        case 22,23,24,25,26,27,28,29,30,31,32,33,34,38: return 1;
    }
    return 0;
}

stock GetPlayerActAmmo_(playerid)
{
    new weap = GetPlayerWeapon(playerid);
    return eB[playerid][WeaponsAmmo][weap];
}

stock GetPlayerAmmo_(playerid)
{
    new weapon[3];
    weapon[0] = GetWeaponSlot(GetPlayerWeapon(playerid) );
    GetPlayerWeaponData(playerid, weapon[0], weapon[1], weapon[2]);
    return weapon[2];
}

stock SetPlayerAmmoEx(playerid, weapon, ammo)
{
    PlayerBulletCheck(playerid);
    if(eB[playerid][Weapons][weapon] == false) return 0;
    eB[playerid][WeaponsAmmo][weapon] = ammo;
    SetPlayerAmmo(playerid, weapon, ammo);
    return 1;
}

stock WeaponHackCheck(playerid)
{
    new weaponid = GetPlayerWeapon(playerid);
    if(eB[playerid][Weapons][weaponid] == false || GetPlayerAmmo_(playerid) > GetPlayerActAmmo_(playerid) && GetPlayerState(playerid) != 7) return 1;
    return 0;
}

stock GivePlayerWeaponEx(playerid, weaponid, ammo)
{
    new slot = GetWeaponSlot(weaponid);
    new wap, amu;
    GetPlayerWeaponData(playerid, slot, wap, amu);
    eB[playerid][Weapons][wap] = false;
    eB[playerid][WeaponsAmmo][wap] = 0;

    eB[playerid][Weapons][weaponid] = true;
    eB[playerid][WeaponsAmmo][weaponid] += ammo;
    GivePlayerWeapon(playerid, weaponid, ammo);
    return 1;
}

stock ResetPlayerWeaponsEx(playerid)
{
    for(new x=0; x < 45; x++)
    {
        eB[playerid][Weapons][x] = false;
        eB[playerid][WeaponsAmmo][x] = 0;
    }
    ResetPlayerWeapons(playerid);
    return 1;
}

stock GetPlayerBulletsShot(playerid) return eB[playerid][BulletsShot];
stock GetPlayerBulletsHit(playerid) return eB[playerid][BulletsHit];
stock Float:GetBulletsHitAccuracy(playerid)
{
    new Float:acu = floatdiv(eB[playerid][BulletsHit], eB[playerid][BulletsShot]);
    new Float:moacu = floatmul(acu, 100);
    return moacu;
}

public OnPlayerTakeDamage(playerid, issuerid, Float:amount, weaponid)
{
    if(IsWeaponGun(weaponid) && issuerid != INVALID_PLAYER_ID)
    {
        eB[issuerid][BulletsHit]++;
    }
    if(WeaponHackCheck(issuerid) == 1)
    {
        CallRemoteFunction("OnPlayerWeaponHack", "iddd", issuerid, weaponid, weaponid, GetPlayerActAmmo_(issuerid), GetPlayerAmmo_(issuerid) );
    }
    new Float:HP;
    GetPlayerHealth(playerid, HP);
    if(HP <= DangerHealth) PlayerBulletCheck(playerid);
    GetPlayerHealth(issuerid, HP);
    if(HP <= DangerHealth) PlayerBulletCheck(issuerid);
    CallRemoteFunction("Hooked_OPTD", "iifi", playerid, issuerid, amount, weaponid);
    return 1;
}


public OnPlayerConnect(playerid)
{
        eB[playerid][BulletsHit] = 0;
        eB[playerid][BulletsShot] = 0;
        CallRemoteFunction("Hooked_OPC", "i", playerid);
        return 1;
}

#if defined _ALS_OnPlayerTakeDamage
 #undef OnPlayerTakeDamage
#else
 #define _ALS_OnPlayerTakeDamage
#endif

#if defined _ALS_OnPlayerConnect
 #undef OnPlayerConnect
#else
 #define _ALS_OnPlayerConnect
#endif

#define OnPlayerTakeDamage Hooked_OPTD
#define OnPlayerConnect Hooked_OPC

forward Hooked_OPTD(playerid, issuerid, Float:amount, weaponid);
forward Hooked_OPC(playerid);

#if defined _ALS_GivePlayerWeapon
 #undef GivePlayerWeapon
#else
 #define _ALS_GivePlayerWeapon
#endif

#if defined _ALS_ResetPlayerWeapons
 #undef ResetPlayerWeapons
#else
 #define _ALS_ResetPlayerWeapons
#endif

#if defined _ALS_SetPlayerAmmo
 #undef SetPlayerAmmo
#else
 #define _ALS_SetPlayerAmmo
#endif

#if defined _ALS_GetPlayerAmmo
 #undef GetPlayerAmmo
#else
 #define _ALS_GetPlayerAmmo
#endif

#define GivePlayerWeapon GivePlayerWeaponEx
#define ResetPlayerWeapons ResetPlayerWeaponsEx
#define SetPlayerAmmo SetPlayerAmmoEx
#define GetPlayerAmmo GetPlayerActualAmmo