[Elitcky]

The Lasermine actually starts pushing everyone when its like deploying... idk is there an action to do that or what ?

PHP Code:

#pragma semicolon 1

#include <sdktools>
#include <sdkhooks>
#include <lasermines>
#include <csgocolors>

#define PLUGIN_NAME        "[CS:GO] Lasermines"
#define PLUGIN_VERSION    "1.5.2"

#define MDL_LASER        "materials/sprites/purplelaser1.vmt"
#define MDL_MINE        "models/lasermine/lasermine.mdl"

#define SND_MINEPUT        "npc/roller/blade_cut.wav"
#define SND_MINEACT        "npc/roller/mine/rmine_blades_in2.wav"
#define SND_BUYMINE        "items/itempickup.wav"
#define SND_CANTBUY        "buttons/weapon_cant_buy.wav"

new i_enable,
    bool:b_message,
    i_amount,
    i_maxamount,
    bool:b_purge,
    i_damage,
    i_explode_damage,
    i_explode_radius,
    i_health,
    String:s_color_t[16],
    String:s_color_ct[16],
    Float:f_activate_time,
    bool:b_use_buy_mode,
    bool:b_should_buy_zone,
    bool:b_pickup,
    bool:b_friendly_pickup,
    bool:b_enemy_pickup,
    i_price,
    String:s_wpn_dmg[16],
    bool:b_lm_hs,
    bool:b_friendlyfire;

new Handle:h_fwdOnPlantLasermine,
    Handle:h_fwdOnLaserminePlanted,
    Handle:h_fwdOnPreHitByLasermine,
    Handle:h_fwdOnPostHitByLasermine,
    Handle:h_fwdOnPreBuyLasermine,
    Handle:h_fwdOnPostBuyLasermine,
    Handle:h_fwdOnPrePickupLasermine,
    Handle:h_fwdOnPostPickupLasermine;

new i_clients_amount[MAXPLAYERS+1],
    i_clients_myamount[MAXPLAYERS+1],
    i_clients_maxlimit[MAXPLAYERS+1],
    b_used_by_native[MAXPLAYERS+1],
    i_buy_limit[MAXPLAYERS+1];

new gInBuyZone = -1,
    gAccount = -1;

public Plugin:myinfo = 
{
    name        = PLUGIN_NAME,
    author        = "FrozDark (rewrited by Grey83)",
    description    = "Plants a laser mines in the CS:GO",
    version        = PLUGIN_VERSION,
    url            = "https://steamcommunity.com/groups/grey83ds"
};

new bool:b_late;

public APLRes:AskPluginLoad2(Handle:myself, bool:late, String:error[], err_max)
{
    CreateNative("AddClientLasermines", Native_AddMines);
    CreateNative("SetClientLasermines", Native_SetMines);
    CreateNative("SubClientLasermines", Native_SubstractMines);
    CreateNative("GetClientLasermines", Native_GetMines);
    CreateNative("PlantClientLasermine", Native_PlantMine);
    CreateNative("ClearMapClientLasermines", Native_ClearMapMines);
    CreateNative("IsEntityLasermine", Native_IsLasermine);
    CreateNative("GetClientByLasermine", Native_GetClientByLasermine);
    CreateNative("SetClientMaxLasermines", Native_SetClientMaxLasermines);
    CreateNative("ResetClientMaxLasermines", Native_ResetClientMaxLasermines);
    CreateNative("GetBeamByLasermine", Native_GetBeamByLasermine);
    CreateNative("GetLasermineByBeam", Native_GetLasermineByBeam);

    h_fwdOnPlantLasermine        = CreateGlobalForward("OnPlantLasermine",        ET_Hook,    Param_Cell,    Param_FloatByRef,    Param_CellByRef,    Param_CellByRef,    Param_CellByRef,    Param_Array);
    h_fwdOnLaserminePlanted        = CreateGlobalForward("OnLaserminePlanted",        ET_Ignore,    Param_Cell,    Param_Cell,            Param_Float,        Param_Cell,            Param_Cell,            Param_Cell,        Param_Array);

    h_fwdOnPreHitByLasermine    = CreateGlobalForward("OnPreHitByLasermine",    ET_Hook,    Param_Cell,    Param_CellByRef,    Param_CellByRef,    Param_CellByRef,    Param_CellByRef);
    h_fwdOnPostHitByLasermine    = CreateGlobalForward("OnPostHitByLasermine",    ET_Ignore,    Param_Cell,    Param_Cell,            Param_Cell,            Param_Cell,            Param_Cell);

    h_fwdOnPreBuyLasermine        = CreateGlobalForward("OnPreBuyLasermine",        ET_Hook,    Param_Cell,    Param_CellByRef,    Param_CellByRef);
    h_fwdOnPostBuyLasermine        = CreateGlobalForward("OnPostBuyLasermine",        ET_Ignore,    Param_Cell,    Param_Cell,            Param_Cell);

    h_fwdOnPrePickupLasermine    = CreateGlobalForward("OnPrePickupLasermine",    ET_Event,    Param_Cell,    Param_Cell,            Param_Cell);
    h_fwdOnPostPickupLasermine    = CreateGlobalForward("OnPostPickupLasermine",    ET_Ignore,    Param_Cell,    Param_Cell,            Param_Cell);

    RegPluginLibrary("lasermines");

    b_late = late;

    return APLRes_Success;
}

public OnPluginStart()
{
    if(GetEngineVersion() != Engine_CSGO)
        SetFailState("This plugin for the CS:GO only!");

    if((gInBuyZone = FindSendPropInfo("CCSPlayer", "m_bInBuyZone")) == -1)
        SetFailState("Could not find offset \"m_bInBuyZone\"");
    if((gAccount = FindSendPropInfo("CCSPlayer", "m_iAccount")) == -1)
        SetFailState("Could not find offset \"m_iAccount\"");

    CreateConVar("csgo_lasermines_version", PLUGIN_VERSION, PLUGIN_NAME, FCVAR_REPLICATED|FCVAR_NOTIFY|FCVAR_DONTRECORD);

    new Handle:CVar;
    HookConVarChange((CVar = CreateConVar("sm_lasermines_enable", "1", "0 - disabled, 1 - enabled for all teams, 2 - only for Terrorists, 3 - only for Counter-terrorists", FCVAR_NOTIFY, true, _, true, 3.0)), CVarChanged_Enable);
    i_enable = GetConVarInt(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_welcome_message", "0", "Show Plugin Message at the beginning of each round.", _, true, _, true, 1.0)), CVarChanged_Msg);
    b_message = GetConVarBool(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_amount", "3", "The amount to give laser mines to a player each spawn (if buy mode is disabled, -1 = Infinity)", _, true, -1.0)), CVarChanged_Amt);
    i_amount = GetConVarInt(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_maxamount", "3", "The maximum amount of laser mines a player can carry. (0-Unlimited)", _, true, _, true, 1024.0)), CVarChanged_MaxAmt);
    i_maxamount = GetConVarInt(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_death_purge", "0", "Remove mines after the death of their owner.", _, true, _, true, 1.0)), CVarChanged_Purge);
    b_purge = GetConVarBool(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_damage", "500", "The damage to deal to a player by the laser", _, true, 1.0, true, 100000.0)), CVarChanged_Dmg);
    i_damage = GetConVarInt(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_explode_damage", "80", "The damage to deal to a player when a laser mine breaks", _, true, _, true, 100000.0)), CVarChanged_Explode);
    i_explode_damage = GetConVarInt(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_explode_radius", "250", "The radius of the explosion", _, true, 1.0, true, 100000.0)), CVarChanged_Radius);
    i_explode_radius = GetConVarInt(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_health", "150", "The laser mines health. 0 = never breaked", _, true, _, true, 100000.0)), CVarChanged_HP);
    i_health = GetConVarInt(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_activatetime", "2", "The delay of laser mines' activation", _, true, _, true, 10.0)), CVarChanged_Time);
    f_activate_time = GetConVarFloat(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_buymode", "0", "Enables buy mode. In this mode you will have to buy mines", FCVAR_NOTIFY, true, _, true, 1.0)), CVarChanged_Mode);
    b_use_buy_mode = GetConVarBool(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_buyzone", "1", "Whether a player have to stay in buy zone to buy mines", FCVAR_NOTIFY, true, _, true, 1.0)), CVarChanged_Zone);
    b_should_buy_zone = GetConVarBool(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_price", "0", "The price of the laser mines", FCVAR_NOTIFY, true)), CVarChanged_Price);
    i_price = GetConVarInt(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_color_t", "255 0 0", "Terrorist's color. Set by RGB", FCVAR_PRINTABLEONLY)), CVarChanged_TColor);
    GetConVarString(CVar, s_color_t, sizeof(s_color_t));

    HookConVarChange((CVar = CreateConVar("sm_lasermines_color_ct", "0 0 255", "Counter-Terrorist's color. Set by RGB", FCVAR_PRINTABLEONLY)), CVarChanged_CtColor);
    GetConVarString(CVar, s_color_ct, sizeof(s_color_ct));

    HookConVarChange((CVar = CreateConVar("sm_lasermines_allow_pickup", "1", "Allow players to pickup their planted lasermines", _, true, 0.0, true, 1.0)), CVarChanged_PickUp);
    b_pickup = GetConVarBool(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_allow_friendly_pickup", "0", "Allow players to pickup allies planted lasermines", _, true, 0.0, true, 1.0)), CVarChanged_FPickUp);
    b_friendly_pickup = GetConVarBool(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_allow_enemy_pickup", "0", "Allow players to pickup enemys planted lasermines", _, true, 0.0, true, 1.0)), CVarChanged_EPickUp);
    b_enemy_pickup = GetConVarBool(CVar);

    HookConVarChange((CVar = CreateConVar("sm_lasermines_wpn", "taser", "Enemy has died from this weapon", FCVAR_PRINTABLEONLY)), CVarChanged_Wpn);
    GetConVarString(CVar, s_wpn_dmg, sizeof(s_wpn_dmg));

    HookConVarChange((CVar = CreateConVar("sm_lasermines_hs", "1", "Headshot On/Off", _, true, 0.0, true, 1.0)), CVarChanged_HS);
    b_lm_hs = GetConVarBool(CVar);

    HookConVarChange((CVar = FindConVar("mp_friendlyfire")), CVarChanged_FF);
    b_friendlyfire = GetConVarBool(CVar);

    HookEvent("player_spawn", OnPlayerSpawn);
    HookEvent("player_death", OnPlayerDeath);
    HookEvent("player_death", OnPlayerDeath_Pre, EventHookMode_Pre);
    HookEvent("round_start", RoundStart);

    RegConsoleCmd("sm_colocar",    Cmd_PlantMine,    "Plant a laser mine");
    RegConsoleCmd("sm_setlaser",    Cmd_PlantMine,    "Plant a laser mine");

    RegConsoleCmd("sm_lm",    Cmd_BuyMines,    "Buy laser mines");
    RegConsoleCmd("sm_lasermine",        Cmd_BuyMines,    "Buy laser mines");

    RegConsoleCmd("sm_sacar",Cmd_RemoveMines, "Remove all your laser mines");
    RegConsoleCmd("sm_dellaser",        Cmd_RemoveMines, "Remove all your laser mines");

    HookEntityOutput("env_beam", "OnTouchedByEntity", OnTouchedByEntity);

    LoadTranslations("csgo_lasermines.phrases");

    AutoExecConfig(true, "plugin.csgo_lasermines");

    if(b_late)
    {
        b_late = false;
        OnMapStart();
    }
}

public CVarChanged_Enable(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    i_enable = GetConVarInt(CVar);
}

public CVarChanged_Msg(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    b_message = GetConVarBool(CVar);
}

public CVarChanged_Amt(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    i_amount = GetConVarInt(CVar);
    LookupClients();
}

public CVarChanged_MaxAmt(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    i_maxamount = GetConVarInt(CVar);
    LookupClients();
}

public CVarChanged_Purge(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    b_purge = GetConVarBool(CVar);
}

public CVarChanged_Dmg(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    i_damage = GetConVarInt(CVar);
}

public CVarChanged_Explode(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    i_explode_damage = GetConVarInt(CVar);
}

public CVarChanged_Radius(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    i_explode_radius = GetConVarInt(CVar);
}

public CVarChanged_HP(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    i_health = GetConVarInt(CVar);
}

public CVarChanged_Time(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    f_activate_time = GetConVarFloat(CVar);
}

public CVarChanged_Mode(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    b_use_buy_mode = GetConVarBool(CVar);
}

public CVarChanged_Zone(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    b_should_buy_zone = GetConVarBool(CVar);
}

public CVarChanged_Price(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    i_price = GetConVarInt(CVar);
}

public CVarChanged_TColor(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    strcopy(s_color_t, sizeof(s_color_t), newValue);
}

public CVarChanged_CtColor(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    strcopy(s_color_ct, sizeof(s_color_ct), newValue);
}

public CVarChanged_PickUp(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    b_pickup = GetConVarBool(CVar);
}

public CVarChanged_FPickUp(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    b_friendly_pickup = GetConVarBool(CVar);
}

public CVarChanged_EPickUp(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    b_enemy_pickup = GetConVarBool(CVar);
}

public CVarChanged_Wpn(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    strcopy(s_wpn_dmg, sizeof(s_wpn_dmg), newValue);
}

public CVarChanged_HS(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    b_lm_hs = GetConVarBool(CVar);
}

public CVarChanged_FF(Handle:CVar, const String:oldValue[], const String:newValue[])
{
    b_friendlyfire = GetConVarBool(CVar);
}

LookupClients()
{
    for(new i = 1; i <= MaxClients; i++) OnClientConnected(i);
}

public OnMapStart()
{
    PrecacheModel(MDL_MINE, true);
    PrecacheModel(MDL_LASER, true);

    PrecacheSound(SND_MINEPUT, true);
    PrecacheSound(SND_MINEACT, true);
    PrecacheSound(SND_BUYMINE, true);
    PrecacheSound(SND_CANTBUY, true);

    AddFileToDownloadsTable("models/lasermine/lasermine.dx80.vtx");
    AddFileToDownloadsTable("models/lasermine/lasermine.dx90.vtx");
    AddFileToDownloadsTable("models/lasermine/lasermine.mdl");
    AddFileToDownloadsTable("models/lasermine/lasermine.phy");
    AddFileToDownloadsTable("models/lasermine/lasermine.vvd");

    AddFileToDownloadsTable("materials/models/lasermine/lasermine.vmt");
    AddFileToDownloadsTable("materials/models/lasermine/lasermine.vtf");
}

public RoundStart(Handle:event, const String:name[], bool:dontBroadcast)
{
    if(i_enable && b_message)
        CPrintToChatAll("%t", b_use_buy_mode ? "Welcome Message 2" : "Welcome Message 1");
}

public OnClientConnected(client)
{
    if(!b_used_by_native[client])
    {
        i_clients_maxlimit[client] = i_maxamount;
        i_clients_myamount[client] = i_amount;
    }
}

public OnClientDisconnect(client)
{
    i_buy_limit[client] = 0;
    new i = -1;
    while ((i = FindEntityByClassname(i, "prop_physics_override")) != -1 && GetClientByLasermine(i) == client)
        AcceptEntityInput(i, "KillHierarchy");
}

public OnClientDisconnect_Post(client)
{
    i_clients_amount[client] = 0;
    b_used_by_native[client] = false;
}

public OnTouchedByEntity(const String:output[], caller, activator, Float:delay)
{
    if(!(1 <= activator <= MaxClients))
        return;
    new owner = GetEntPropEnt(caller, Prop_Data, "m_hOwnerEntity");
    new lasermine = GetLasermineByBeam(caller);

    if(owner == -1 || lasermine == -1 || activator == owner || (!b_friendlyfire && GetClientTeam(activator) == GetClientTeam(owner)))
        return;

    new dummy_caller = caller, dummy_owner = owner, damage = i_damage, dummy_lasermine = lasermine;

    new Action:result = Forward_OnPreHit(activator, dummy_owner, dummy_caller, dummy_lasermine, damage);

    switch(result)
    {
        case Plugin_Handled, Plugin_Stop:
            return;
        case Plugin_Continue:
        {
            dummy_caller    = caller;
            dummy_owner        = owner;
            damage            = i_damage;
            dummy_lasermine    = lasermine;
        }
    }

    SDKHooks_TakeDamage(activator, dummy_caller, dummy_owner, float(damage), DMG_ENERGYBEAM);

    Forward_OnPostHit(activator, dummy_owner, dummy_caller, dummy_lasermine, damage);
}

public OnPlayerSpawn(Handle:event, const String:name[], bool:dontBroadcast)
{
    if(b_use_buy_mode)
        return;
    new client = GetClientOfUserId(GetEventInt(event, "userid"));
    i_clients_amount[client] = i_clients_myamount[client];
}

public OnPlayerDeath(Handle:event, const String:name[], bool:dontBroadcast)
{
    if(!b_purge)
        return;

    new client = GetClientOfUserId(GetEventInt(event, "userid"));
    OnClientDisconnect(client);
}

public Action:OnPlayerDeath_Pre(Handle:event, const String:name[], bool:dontBroadcast)
{
    new attacker = GetClientOfUserId(GetEventInt(event, "attacker"));
    if(0 < attacker <= MaxClients)
    {
        decl String:g_szWeapon[32];
        GetEventString(event, "weapon", g_szWeapon, sizeof(g_szWeapon));
        if(StrEqual(g_szWeapon, "env_beam"))
        {
            SetEventString(event, "weapon", s_wpn_dmg);
            if(b_lm_hs)
                SetEventBool(event, "headshot", true);
        }
    }
    return Plugin_Continue;
}

public Action:Cmd_BuyMines(client, argc)
{
    // client = 0    or    disabled    or    buy mode disabled    or    unlimited amount    or    client is not in game
    if(!client || !i_enable || !b_use_buy_mode || i_clients_myamount[client] == -1 || !IsClientInGame(client))
        return Plugin_Continue;    // Stop trigger the command

    // client is dead
    if(!IsPlayerAlive(client))
    {
        PrintHintText(client, "%t", "Can't buy, while dead");
        return Plugin_Handled;    // Stop trigger the command
    }
    new team = GetClientTeam(client);
    // client is spectator
    if(team < 2)
    {
        PrintHintText(client, "%t", "Can't use, while spec");
        return Plugin_Handled;    // Stop trigger the command
    }
    // client in restricted team
    if(i_enable > 1 && team != i_enable)
    {
        PrintHintText(client, "%t", i_enable == 2 ? "Only for Terrorists" : "Only for Counter-terrorists");
        return Plugin_Handled;    // Stop trigger the command
    }
    // If  buy zone mode is enabled and player is out of buy zone range
    if(b_should_buy_zone && !GetEntData(client, gInBuyZone, 1))
    {
        PrintHintText(client, "%t", "Out of buy zone");
        return Plugin_Handled;    // Stop trigger the command
    }

    new amount = 1;
    if(argc)
    {
        decl String:txt[6];
        GetCmdArg(1, txt, sizeof(txt));
        amount = StringToInt(txt);
        if(i_clients_maxlimit[client])
        {
            if(amount > i_clients_maxlimit[client])
                amount = i_clients_maxlimit[client];
            else if(amount < 1)
                amount = 1;
        }
    }

    new dummy_amount = amount, cost = i_price, boughtamount;
    new Action:result = Forward_OnPreBuy(client, dummy_amount, cost);

    switch(result)
    {
        case Plugin_Handled, Plugin_Stop:
            return result;
        case Plugin_Continue:
        {
            dummy_amount    = amount;
            cost            = i_price;
        }
    }

    new money = GetEntData(client, gAccount);
    do
    {
        if(i_clients_maxlimit[client] && (i_clients_amount[client] >= i_clients_maxlimit[client]) || (i_buy_limit[client] >= i_clients_maxlimit[client]))
        {
            PrintHintText(client, "%t", "Can't buy, max amount", i_clients_maxlimit[client]);
            return Plugin_Handled;
        }

        money -= cost;

        if(money < 0)
        {
            PrintHintText(client, "%t", "Can't buy, not enough money", i_clients_amount[client]);
            EmitSoundToClient(client, SND_CANTBUY);
            return Plugin_Handled;
        }
        SetEntData(client, gAccount, money);
        i_clients_amount[client]++;
        i_buy_limit[client]++;
        boughtamount++;
    } while (--dummy_amount);

    if(boughtamount)
    {
        PrintHintText(client, "%t", "Mines", i_clients_amount[client]);
        EmitSoundToClient(client, SND_BUYMINE);
        Forward_OnPostBuy(client, boughtamount, boughtamount*cost);
    }

    return Plugin_Handled;
}

public Action:Cmd_PlantMine(client, argc)
{
    if(!client || !i_enable || !IsClientInGame(client))
        return Plugin_Continue;
    if(!i_clients_amount[client])
    {
        PrintHintText(client, "%t", "Mines", i_clients_amount[client]);
        return Plugin_Handled;
    }
    if(!IsPlayerAlive(client))
    {
        PrintHintText(client, "%t", "Can't plant, while dead");
        return Plugin_Handled;
    }
    new team = GetClientTeam(client);
    // client in restricted team
    if(i_enable > 1 && team != i_enable)
    {
        PrintHintText(client, "%t", i_enable == 2 ? "Only for Terrorists" : "Only for Counter-terrorists");
        return Plugin_Handled;    // Stop trigger the command
    }

    decl color[3];
    switch(team)
    {
        case 2:    StringToColor(s_color_t, color, 255);
        case 3:    StringToColor(s_color_ct, color, 255);
        default :
        {
            PrintHintText(client, "%t", "Can't use, while spec");
            return Plugin_Handled;
        }
    }

    new Float:delay_time = f_activate_time, dummy_damage = i_explode_damage, dummy_radius = i_explode_radius, health = i_health, dummy_color[3];
    dummy_color = color;

    new Action:result = Forward_OnPlantMine(client, delay_time, dummy_damage, dummy_radius, health, dummy_color);

    switch(result)
    {
        case Plugin_Handled, Plugin_Stop:
            return result;
        case Plugin_Continue:
        {
            delay_time        = f_activate_time;
            dummy_damage    = i_explode_damage;
            dummy_radius    = i_explode_radius;
            health            = i_health;
            dummy_color        = color;
        }
    }

    new mine;
    if((mine = PlantMine(client, delay_time, dummy_damage, dummy_radius, health, dummy_color)) == -1)
        return Plugin_Handled;

    Forward_OnMinePlanted(client, mine, delay_time, dummy_damage, dummy_radius, health, dummy_color);

    switch(i_clients_amount[client])
    {
        case -1:    PrintHintText(client, "%t", "Infinity mines");
        default :
        {
            i_clients_amount[client]--;
            PrintHintText(client, "%t", "Mines", i_clients_amount[client]);
        }
    }

    return Plugin_Handled;
}

public Action:Cmd_RemoveMines(client, argc)
{
    if(!b_pickup || IsFakeClient(client) || !IsPlayerAlive(client))
        return Plugin_Handled;

    new i = -1;
    while ((i = FindEntityByClassname(i, "prop_physics_override")) != -1 && GetClientByLasermine(i) == client)
        PickupLasermine(client, i, client);

    return Plugin_Handled;
}

public Action:OnPlayerRunCmd(client, &buttons, &impulse, Float:vel[3], Float:angles[3], &weapon)
{
    if(!b_pickup || IsFakeClient(client) || !IsPlayerAlive(client))
        return Plugin_Continue;

    static iPrevButtons[MAXPLAYERS+1];
    if((buttons & IN_USE) && !(iPrevButtons[client] & IN_USE))
        OnButtonPressed(client);
    iPrevButtons[client] = buttons;

    return Plugin_Continue;
}

OnButtonPressed(client)
{
    new Handle:trace = TraceRay(client);

    new ent = -1;
    if(TR_DidHit(trace) && (ent = TR_GetEntityIndex(trace)) > MaxClients)
    {
        CloseHandle(trace);
        new owner = GetClientByLasermine(ent);
        if(owner == -1)
            return;
        if(owner == client)
        {
            PickupLasermine(client, ent, owner);
            return;
        }
        if((b_friendly_pickup && GetClientTeam(owner) == GetClientTeam(client)) || b_enemy_pickup)
            PickupLasermine(client, ent, owner);
        else
        {
            EmitSoundToAll(SND_CANTBUY, ent);
            decl String:nick[MAX_NAME_LENGTH];
            if(GetClientName(owner, nick, sizeof(nick)))
                PrintCenterText(client,"%t", "Not yours lasermine", nick);
        }
    }
    else CloseHandle(trace);
}

PickupLasermine(client, lasermine, owner)
{
    if(i_clients_amount[client] >= 0 && i_clients_amount[client] == AddClientLasermines(client))
        return;

    new Action:result = Forward_OnPrePickup(client, lasermine, owner);

    switch(result)
    {
        case Plugin_Handled, Plugin_Stop:
            return;
    }

    AcceptEntityInput(lasermine, "KillHierarchy");
    if(i_clients_amount[client] >= 0)
        PrintHintText(client, "%t", "Mines", i_clients_amount[client]);
    else PrintHintText(client, "%t", "Infinity mines");
    EmitSoundToClient(client, SND_BUYMINE);

    Forward_OnPostPickup(client, lasermine, owner);
}

Handle:TraceRay(client)
{
    new Float:startent[3], Float:angle[3], Float:end[3];
    GetClientEyePosition(client, startent);
    GetClientEyeAngles(client, angle);
    GetAngleVectors(angle, end, NULL_VECTOR, NULL_VECTOR);
    NormalizeVector(end, end);

    startent[0] += end[0] * 10.0;
    startent[1] += end[1] * 10.0;
    startent[2] += end[2] * 10.0;

    end[0] = startent[0] + end[0] * 80.0;
    end[1] = startent[1] + end[1] * 80.0;
    end[2] = startent[2] + end[2] * 80.0;

    return TR_TraceRayFilterEx(startent, end, CONTENTS_SOLID, RayType_EndPoint, FilterPlayers);
}

stock PlantMine(client, Float:activation_delay = 0.0, explode_damage, explode_radius, const health = 0, const color[3] = {255, 255, 255})
{
    if(activation_delay > 10.0)
        activation_delay = 10.0;
    else if(activation_delay < 0.0)
        activation_delay = 0.0;

    new Handle:trace = TraceRay(client);

    decl Float:end[3], Float:normal[3], Float:beamend[3];
    if(TR_DidHit(trace) && TR_GetEntityIndex(trace) < 1)
    {
        TR_GetEndPosition(end, trace);
        TR_GetPlaneNormal(trace, normal);
        CloseHandle(trace);

        GetVectorAngles(normal, normal);

        TR_TraceRayFilter(end, normal, CONTENTS_SOLID, RayType_Infinite, FilterAll);
        TR_GetEndPosition(beamend, INVALID_HANDLE);

        new ent = CreateEntityByName("prop_physics_override");
        if(ent == -1 || !IsValidEdict(ent))
        {
            LogError("Could not create entity \"prop_physics_override\"");
            return -1;
        }

        new beament = CreateEntityByName("env_beam");
        if(beament == -1 || !IsValidEdict(beament))
        {
            LogError("Could not create entity \"env_beam\"");
            return -1;
        }

        decl String:start[30], String:tmp[200];
        Format(start, sizeof(start), "Beam%i", beament);

        SetEntityModel(ent, MDL_MINE);

        decl String:buffer[16];
        IntToString(explode_damage, buffer, sizeof(buffer));
        DispatchKeyValue(ent, "ExplodeDamage", buffer);
        IntToString(explode_radius, buffer, sizeof(buffer));
        DispatchKeyValue(ent, "ExplodeRadius", buffer);

        DispatchKeyValue(ent, "spawnflags", "3");
        DispatchSpawn(ent);

        AcceptEntityInput(ent, "DisableMotion");
        SetEntityMoveType(ent, MOVETYPE_NONE);
        TeleportEntity(ent, end, normal, NULL_VECTOR);

        SetEntProp(ent, Prop_Data, "m_nSolidType", 6);
//        до своей активации мина будет выталкивать игрока со своей позиции
        SetEntProp(ent, Prop_Data, "m_CollisionGroup", 17);
        
        if(health)
        {
            SetEntProp(ent, Prop_Data, "m_takedamage", 2);
            SetEntProp(ent, Prop_Data, "m_iHealth", health);
        }

        Format(tmp, sizeof(tmp), "%s,Kill,,0,-1", start);
        DispatchKeyValue(ent, "OnBreak", tmp);

        EmitSoundToAll(SND_MINEPUT, ent);

        // Set keyvalues on the beam.
        DispatchKeyValue(beament, "targetname",        start);
        DispatchKeyValue(beament, "damage",            "0");
        DispatchKeyValue(beament, "framestart",        "0");
        DispatchKeyValue(beament, "BoltWidth",        "4.0");
        DispatchKeyValue(beament, "renderfx",        "0");
        DispatchKeyValue(beament, "TouchType",        "3"); // 0 = none, 1 = player only, 2 = NPC only, 3 = player or NPC, 4 = player, NPC or physprop
        DispatchKeyValue(beament, "framerate",        "0");
        DispatchKeyValue(beament, "decalname",        "Bigshot");
        DispatchKeyValue(beament, "TextureScroll",    "35");
        DispatchKeyValue(beament, "HDRColorScale",    "1.0");
        DispatchKeyValue(beament, "texture",        MDL_LASER);
        DispatchKeyValue(beament, "life",            "0"); // 0 = infinite, beam life time in seconds
        DispatchKeyValue(beament, "StrikeTime",        "1"); // If beam life time not infinite, this repeat it back
        DispatchKeyValue(beament, "LightningStart",    start);
        DispatchKeyValue(beament, "spawnflags",        "0"); // 0 disable, 1 = start on, etc etc. look from hammer editor
        DispatchKeyValue(beament, "NoiseAmplitude",    "0"); // straight beam = 0, other make noise beam
        DispatchKeyValue(beament, "Radius",            "256");
        DispatchKeyValue(beament, "renderamt",        "100");
        DispatchKeyValue(beament, "rendercolor",    "0 0 0");

        AcceptEntityInput(beament, "TurnOff");

        SetEntityModel(beament, MDL_LASER);

        TeleportEntity(beament, beamend, NULL_VECTOR, NULL_VECTOR); // Teleport the beam

        SetEntPropVector(beament,    Prop_Data,    "m_vecEndPos",    end);
        SetEntPropFloat(beament,    Prop_Data,    "m_fWidth",        3.0);
        SetEntPropFloat(beament,    Prop_Data,    "m_fEndWidth",    3.0);

        SetEntPropEnt(beament,    Prop_Data,    "m_hOwnerEntity",    client); // Sets the owner of the beam
        SetEntPropEnt(ent,        Prop_Data,    "m_hMoveChild",        beament);
        SetEntPropEnt(beament,    Prop_Data,    "m_hEffectEntity",    ent);

        new Handle:datapack = CreateDataPack();
        WritePackCell(datapack, beament);
        WritePackCell(datapack, ent);
        WritePackCell(datapack, color[0]);
        WritePackCell(datapack, color[1]);
        WritePackCell(datapack, color[2]);
        WritePackString(datapack, start);
        CreateTimer(activation_delay, OnActivateLaser, datapack, TIMER_FLAG_NO_MAPCHANGE|TIMER_HNDL_CLOSE);

        SDKHook(ent, SDKHook_OnTakeDamage, OnTakeDamage);

        return ent;
    }
    else CloseHandle(trace);
    return -1;
}

public Action:OnTakeDamage(victim, &attacker, &inflictor, &Float:damage, &damagetype)
{
    if(IsEntityLasermine(victim))
    {
        if(0 < attacker <= MaxClients)
        {
            static client;
            if((client = GetClientByLasermine(victim)) != -1 && client != attacker && GetClientTeam(client) == GetClientTeam(attacker))
                return Plugin_Handled;
        }
        else if(!IsEntityLasermine(inflictor))
            return Plugin_Handled;
    }

    return Plugin_Continue;
}

public bool:FilterAll(entity, contentsMask)
{
    return false;
}

public bool:FilterPlayers(entity, contentsMask)
{
    return !(0 < entity <= MaxClients);
}

public Action:OnActivateLaser(Handle:timer, any:hDataPack)
{
    ResetPack(hDataPack);
    decl String:start[30], String:tmp[200], color[3];
    new beament = ReadPackCell(hDataPack);
    new ent = ReadPackCell(hDataPack);
    color[0] = ReadPackCell(hDataPack);
    color[1] = ReadPackCell(hDataPack);
    color[2] = ReadPackCell(hDataPack);
    ReadPackString(hDataPack, start, sizeof(start));

    if(!IsValidEdict(beament) || !IsValidEdict(ent))
        return Plugin_Stop;
//    будем надеяться, что в этот момент мина уже вытолкнула игрока
    SetEntProp(ent, Prop_Data, "m_CollisionGroup", 5);
    AcceptEntityInput(beament, "TurnOn");

    SetEntityRenderColor(beament, color[0], color[1], color[2]);

    Format(tmp, sizeof(tmp), "%s,TurnOff,,0.001,-1", start);
    DispatchKeyValue(beament, "OnTouchedByEntity", tmp);
    Format(tmp, sizeof(tmp), "%s,TurnOn,,0.002,-1", start);
    DispatchKeyValue(beament, "OnTouchedByEntity", tmp);

    EmitSoundToAll(SND_MINEACT, ent);

    return Plugin_Stop;
}

public Native_AddMines(Handle:plugin, numParams)
{
    new client = GetNativeCell(1);
    if(client < 1 || client > MaxClients)
    {
        ThrowNativeError(SP_ERROR_INDEX, "Client index %i is invalid", client);
        return 0;
    }
    else if(!IsClientInGame(client))
    {
        ThrowNativeError(SP_ERROR_NOT_FOUND, "Client %i is not in game", client);
        return 0;
    }

    new amount = GetNativeCell(2);
    new bool:limit = bool:GetNativeCell(3);

    if(amount < 1)
        return i_clients_amount[client];
    if(i_clients_amount[client] < 0)
        return -1;

    i_clients_amount[client] += amount;

    if(limit && i_clients_amount[client] > i_clients_maxlimit[client])
        i_clients_amount[client] = i_clients_maxlimit[client];

    return i_clients_amount[client];
}

public Native_SetMines(Handle:plugin, numParams)
{
    new client = GetNativeCell(1);
    if(client < 1 || client > MaxClients)
    {
        ThrowNativeError(SP_ERROR_INDEX, "Client index %i is invalid", client);
        return false;
    }
    else if(!IsClientInGame(client))
    {
        ThrowNativeError(SP_ERROR_NOT_FOUND, "Client %i is not in game", client);
        return false;
    }

    new amount = GetNativeCell(2);
    new bool:limit = bool:GetNativeCell(3);

    if(amount < -1)
        amount = -1;

    i_clients_amount[client] = amount;

    if(limit && i_clients_amount[client] > i_clients_maxlimit[client])
        i_clients_amount[client] = i_clients_maxlimit[client];

    return true;
}

public Native_SubstractMines(Handle:plugin, numParams)
{
    new client = GetNativeCell(1);
    if(client < 1 || client > MaxClients)
    {
        ThrowNativeError(SP_ERROR_INDEX, "Client index %i is invalid", client);
        return 0;
    }
    else if(!IsClientInGame(client))
    {
        ThrowNativeError(SP_ERROR_NOT_FOUND, "Client %i is not in game", client);
        return 0;
    }

    new amount = GetNativeCell(2);

    if(i_clients_amount[client] == -1)
        return i_clients_amount[client];

    if(amount < 1)
        return i_clients_amount[client];

    i_clients_amount[client] -= amount;
    if(i_clients_amount[client] < 0)
        i_clients_amount[client] = 0;

    return i_clients_amount[client];
}

public Native_GetMines(Handle:plugin, numParams)
{
    new client = GetNativeCell(1);
    if(client < 1 || client > MaxClients)
    {
        ThrowNativeError(SP_ERROR_INDEX, "Client index %i is invalid", client);
        return 0;
    }
    else if(!IsClientInGame(client))
    {
        ThrowNativeError(SP_ERROR_NOT_FOUND, "Client %i is not in game", client);
        return 0;
    }

    return i_clients_amount[client];
}

public Native_ClearMapMines(Handle:plugin, numParams)
{
    new client = GetNativeCell(1);
    if(client < 1 || client > MaxClients)
    {
        ThrowNativeError(SP_ERROR_INDEX, "Client index %i is invalid", client);
        return;
    }
    else if(!IsClientInGame(client))
    {
        ThrowNativeError(SP_ERROR_NOT_FOUND, "Client %i is not in game", client);
        return;
    }

    OnClientDisconnect(client);
}

public Native_PlantMine(Handle:plugin, numParams)
{
    new client = GetNativeCell(1);

    if(client < 1 || client > MaxClients)
    {
        ThrowNativeError(SP_ERROR_INDEX, "Client index %i is invalid", client);
        return false;
    }
    else if(!IsClientInGame(client))
    {
        ThrowNativeError(SP_ERROR_NOT_FOUND, "Client %i is not in game", client);
        return false;
    }

    new Float:f_delay = GetNativeCell(2);
    new i_exp_damage = GetNativeCell(3);
    new i_exp_radius = GetNativeCell(4);
    new health = GetNativeCell(5);
    decl color[3]; GetNativeArray(6, color, sizeof(color));

    new mine;
    if((mine = PlantMine(client, f_delay, i_exp_damage, i_exp_radius, health, color)) != -1)
        Forward_OnMinePlanted(client, mine, f_delay, i_exp_damage, i_exp_radius, health, color);

    return mine != -1;
}

public Native_IsLasermine(Handle:plugin, numParams)
{
    new entity = GetNativeCell(1);
    if(entity <= MaxClients || !IsValidEdict(entity))
        return false;
    decl String:g_szModel[PLATFORM_MAX_PATH];
    GetEntPropString(entity, Prop_Data, "m_ModelName", g_szModel, sizeof(g_szModel));

    return StrEqual(g_szModel, MDL_MINE, false) && GetEntPropEnt(entity, Prop_Data, "m_hMoveChild") != -1;
}

public Native_GetClientByLasermine(Handle:plugin, numParams)
{
    new entity = GetNativeCell(1);
    new beam;
    if((beam = GetBeamByLasermine(entity)) == -1)
        return -1;

    return GetEntPropEnt(beam, Prop_Data, "m_hOwnerEntity");
}

public Native_SetClientMaxLasermines(Handle:plugin, numParams)
{
    new client = GetNativeCell(1);
    if(client < 1 || client > MaxClients)
        ThrowNativeError(SP_ERROR_INDEX, "Client index %i is invalid", client);
    else if(!IsClientAuthorized(client))
        ThrowNativeError(SP_ERROR_NOT_FOUND, "Client %i is not authorized", client);
    new amount = GetNativeCell(2);
    if(amount < -1)
        amount = -1;
    i_clients_maxlimit[client] = amount;
    i_clients_myamount[client] = amount;
    b_used_by_native[client] = true;
}

public Native_ResetClientMaxLasermines(Handle:plugin, numParams)
{
    new client = GetNativeCell(1);
    if(client < 1 || client > MaxClients)
        ThrowNativeError(SP_ERROR_INDEX, "Client index %i is invalid", client);
    else if(!IsClientConnected(client))
        ThrowNativeError(SP_ERROR_NOT_FOUND, "Client %i is not connected", client);
    OnClientConnected(client);
}

public Native_GetBeamByLasermine(Handle:plugin, numParams)
{
    new entity = GetNativeCell(1);
    if(IsEntityLasermine(entity))
        return GetEntPropEnt(entity, Prop_Data, "m_hMoveChild");
    return -1;
}

public Native_GetLasermineByBeam(Handle:plugin, numParams)
{
    new mine = GetEntPropEnt(GetNativeCell(1), Prop_Data, "m_hEffectEntity");
    if(mine != -1 && IsEntityLasermine(mine))
        return mine;
    return -1;
}

Action:Forward_OnPlantMine(client, &Float:activate_time, &exp_damage, &exp_radius, &health, color[3])
{
    decl Action:result;
    result = Plugin_Continue;

    Call_StartForward(h_fwdOnPlantLasermine);
    Call_PushCell(client);
    Call_PushFloatRef(activate_time);
    Call_PushCellRef(exp_damage);
    Call_PushCellRef(exp_radius);
    Call_PushCellRef(health);
    Call_PushArrayEx(color, sizeof(color), SM_PARAM_COPYBACK);
    Call_Finish(result);

    return result;
}

Forward_OnMinePlanted(client, mine, Float:activate_time, exp_damage, exp_radius, health, color[3])
{
    Call_StartForward(h_fwdOnLaserminePlanted);
    Call_PushCell(client);
    Call_PushCell(mine);
    Call_PushFloat(activate_time);
    Call_PushCell(exp_damage);
    Call_PushCell(exp_radius);
    Call_PushCell(health);
    Call_PushArray(color, sizeof(color));
    Call_Finish();
}

Action:Forward_OnPreHit(victim, &attacker, &beam, &lasermine, &damage)
{
    decl Action:result;
    result = Plugin_Continue;

    Call_StartForward(h_fwdOnPreHitByLasermine);
    Call_PushCell(victim);
    Call_PushCellRef(attacker);
    Call_PushCellRef(beam);
    Call_PushCellRef(lasermine);
    Call_PushCellRef(damage);
    Call_Finish(result);

    return result;
}

Forward_OnPostHit(victim, attacker, beam, lasermine, damage)
{
    Call_StartForward(h_fwdOnPostHitByLasermine);
    Call_PushCell(victim);
    Call_PushCell(attacker);
    Call_PushCell(beam);
    Call_PushCell(lasermine);
    Call_PushCell(damage);
    Call_Finish();
}

Action:Forward_OnPreBuy(client, &amount, &price)
{
    decl Action:result;
    result = Plugin_Continue;

    Call_StartForward(h_fwdOnPreBuyLasermine);
    Call_PushCell(client);
    Call_PushCellRef(amount);
    Call_PushCellRef(price);
    Call_Finish(result);

    return result;
}

Forward_OnPostBuy(client, amount, sum)
{
    Call_StartForward(h_fwdOnPostBuyLasermine);
    Call_PushCell(client);
    Call_PushCell(amount);
    Call_PushCell(sum);
    Call_Finish();
}

Action:Forward_OnPrePickup(client, lasermine, owner)
{
    decl Action:result;
    result = Plugin_Continue;

    Call_StartForward(h_fwdOnPrePickupLasermine);
    Call_PushCell(client);
    Call_PushCell(lasermine);
    Call_PushCell(owner);
    Call_Finish(result);

    return result;
}

Forward_OnPostPickup(client, lasermine, owner)
{
    Call_StartForward(h_fwdOnPostPickupLasermine);
    Call_PushCell(client);
    Call_PushCell(lasermine);
    Call_PushCell(owner);
    Call_Finish();
}

stock bool:StringToColor(const String:str[], color[3], const defvalue = -1)
{
    new bool:result = false;
    decl String:Splitter[3][64];
    if(ExplodeString(str, " ", Splitter, sizeof(Splitter), sizeof(Splitter[])) == 3 && String_IsNumeric(Splitter[0]) && String_IsNumeric(Splitter[1]) && String_IsNumeric(Splitter[2]))
    {
        color[0] = StringToInt(Splitter[0]);
        color[1] = StringToInt(Splitter[1]);
        color[2] = StringToInt(Splitter[2]);
        result = true;
    }
    else
    {
        color[0] = defvalue;
        color[1] = defvalue;
        color[2] = defvalue;
    }
    return result;
}

stock bool:String_IsNumeric(const String:str[])
{
    new x, numbersFound;

    if(str[x] == '+' || str[x] == '-')
        x++;

    while (str[x])
    {
        if(IsCharNumeric(str[x]))
            numbersFound++;
        else return false;
        x++;
    }

    return bool:numbersFound;
} 


Actually Found the way reinstalling all again and just copying a code from another version there and editing some kinda little things, now im with VECTOR problems :/ when they pick up the lasers, it actually pick it up all, now i tried setting some vectors of distance, but its not picking them

PHP Code:

PickupLasermine(client, lasermine, owner)
{
    new Float:vOriCliente[3];
    new Float:tOriCliente[3];
    new pev_origin;

    if (i_clients_amount[client] >= 0 && i_clients_amount[client] == AddClientLasermines(client))
    {
        return;
    }
    
    new Action:result = Forward_OnPrePickup(client, lasermine, owner);
    
    switch (result)
    {
        case Plugin_Handled, Plugin_Stop :
        {
            return;
        }
    }
    GetEntDataVector(owner, pev_origin, vOriCliente);
    GetEntDataVector(lasermine, pev_origin, tOriCliente);

    if(GetVectorDistance(vOriCliente, tOriCliente) > 70.0)
        return;

    AcceptEntityInput(lasermine, "KillHierarchy");
    if (i_clients_amount[client] >= 0)
        PrintHintText(client, "%t", "Mines", i_clients_amount[client]);
    else
        PrintHintText(client, "%t", "Infinity mines");
    EmitSoundToClient(client, SND_BUYMINE);
    
    Forward_OnPostPickup(client, lasermine, owner);
} 


Tried this if(GetVectorDistance(vOriCliente, tOriCliente) > 70.0) but its not taking the client position from the entity laser position