Raised This Month: $276 Target: $400
 69% 

Lasermine kill event not working anymore


Post New Thread Reply   
 
Thread Tools Display Modes
Author Message
Elitcky
AlliedModders Donor
Join Date: Jun 2016
Location: Antofagasta, Chile
Old 07-26-2020 , 02:15   Lasermine kill event not working anymore
Reply With Quote #1

Hi all!

Well I have this lasermine plugin which i kinda edited... it had all working so far, until the last update of csgo o.o

Now the "Killing" events when the beam touches the enemy are not working anymore, i dont know why, tried to set other event but not working either.

PHP Code:
#pragma semicolon 1

/*
            I N C L U D E S
    ------------------------------------------------
*/
#include <sourcemod>
#include <sdktools>
#include <sdkhooks>
#include <lasermines>
#include <csgocolors>
/*
    ------------------------------------------------
*/

/*
            D E F I N E S
    ------------------------------------------------
*/
#define PLUGIN_VERSION "1.5.1"

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

#define SND_MINEPUT "laser/mine_deploy.mp3"
#define SND_MINEACT "laser/mine_activate.mp3"
#define SND_BUYMINE "laser/gunpickup2.mp3"
#define SND_CANTBUY "buttons/weapon_cant_buy.wav"
/*
    ------------------------------------------------
*/

/*
        |G|  |L| |O| |B| |A| |L| |S|
    ------------------------------------------------
*/

new Handle:h_enablebool:b_enable,
    
Handle:h_messagebool:b_message,
    
Handle:h_amounti_amount,
    
Handle:h_maxamounti_maxamount,
    
Handle:h_damagei_damage,
    
Handle:h_explode_damagei_explode_damage,
    
Handle:h_explode_radiusi_explode_radius,
    
Handle:h_healthi_health,
    
Handle:h_color_tString:s_color_t[16],
    
Handle:h_color_ctString:s_color_ct[16],
    
Handle:h_activate_timeFloat:f_activate_time,
    
Handle:h_use_buy_modebool:b_use_buy_mode,
    
Handle:h_should_buy_zonebool:b_should_buy_zone,
    
Handle:h_allow_pickupbool:b_allow_pickup,
    
Handle:h_allow_friendly_pickupbool:b_allow_friendly_pickup,
    
Handle:h_allow_enemy_pickupbool:b_allow_enemy_pickup,
    
Handle:h_pricei_price,
    
Handle:h_wpn_dmgString:s_wpn_dmg[16],
    
Handle:h_lm_hsbool:b_lm_hs;

//new Handle:UpdateTime = INVALID_HANDLE;
//new Handle:Timer = INVALID_HANDLE;
new Handle:h_friendlyfirebool:b_friendlyfire;

/*
        F O R W A R D S
    ------------------------------------------------
*/
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;
new 
gAccount = -1;

/*
        P L U G I N    I N F O
    ------------------------------------------------
*/

public Plugin:myinfo 
{
    
name "[CS:GO] Lasermines",
    
author "FrozDark (adapting by Grey83) ",
    
description "Plants a laser mine in CS:GO",
    
version PLUGIN_VERSION,
    
url "http://www.hlmod.ru/"
};

new 
bool:b_late;
/*
    Fires when the plugin is asked to be loaded
    -------------------------------------------------------
*/
public APLRes:AskPluginLoad2(Handle:myselfbool:lateString: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_HookParam_CellParam_FloatByRefParam_CellByRefParam_CellByRefParam_CellByRefParam_Array);
    
h_fwdOnLaserminePlanted CreateGlobalForward("OnLaserminePlanted"ET_IgnoreParam_CellParam_CellParam_FloatParam_CellParam_CellParam_CellParam_Array);
    
    
h_fwdOnPreHitByLasermine CreateGlobalForward("OnPreHitByLasermine"ET_HookParam_CellParam_CellByRefParam_CellByRefParam_CellByRefParam_CellByRef);
    
h_fwdOnPostHitByLasermine CreateGlobalForward("OnPostHitByLasermine"ET_IgnoreParam_CellParam_CellParam_CellParam_CellParam_Cell);
    
    
h_fwdOnPreBuyLasermine CreateGlobalForward("OnPreBuyLasermine"ET_HookParam_CellParam_CellByRefParam_CellByRef);
    
h_fwdOnPostBuyLasermine CreateGlobalForward("OnPostBuyLasermine"ET_IgnoreParam_CellParam_CellParam_Cell);
    
    
h_fwdOnPrePickupLasermine CreateGlobalForward("OnPrePickupLasermine"ET_EventParam_CellParam_CellParam_Cell);
    
h_fwdOnPostPickupLasermine CreateGlobalForward("OnPostPickupLasermine"ET_IgnoreParam_CellParam_CellParam_Cell);
    
    
RegPluginLibrary("lasermines");
    
    
b_late late;
    
    return 
APLRes_Success;
}

/*
        Fires when the plugin starts
    ------------------------------------------------
*/
public OnPluginStart()
{
    
// Creates console variable version
    
CreateConVar("csgo_lasermines_version"PLUGIN_VERSION"The version of the plugin"FCVAR_REPLICATED|FCVAR_NOTIFY|FCVAR_DONTRECORD);
    
    
// Creates console variables
    
h_enable CreateConVar("sm_lasermines_enable""1""Enables/Disables the plugin"FCVAR_NOTIFYtrue0.0true1.0);
    
h_message CreateConVar("sm_lasermines_welcome_message""1""Show Plugin Message at the beginning of each round."_true0.0true1.0);
    
h_amount 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);
    
h_maxamount CreateConVar("sm_lasermines_maxamount""3""The maximum amount of laser mines a player can carry. (0-Unlimited)"_true0.0);
    
h_damage CreateConVar("sm_lasermines_damage""500""The damage to deal to a player by the laser"_true1.0true100000.0);
    
h_explode_damage CreateConVar("sm_lasermines_explode_damage""300""The damage to deal to a player when a laser mine breaks"_true0.0true100000.0);
    
h_explode_radius CreateConVar("sm_lasermines_explode_radius""300""The radius of the explosion"_true1.0true100000.0);
    
h_health CreateConVar("sm_lasermines_health""300""The laser mines health. 0 = never breaked"_true0.0true100000.0);
    
h_activate_time CreateConVar("sm_lasermines_activatetime""2""The delay of laser mines' activation"_true0.0true10.0);
    
h_use_buy_mode CreateConVar("sm_lasermines_buymode""0""Enables buy mode. In this mode you will have to buy mines"FCVAR_NOTIFYtrue0.0true1.0);
    
h_should_buy_zone CreateConVar("sm_lasermines_buyzone""1""Whether a player have to stay in buy zone to buy mines"FCVAR_NOTIFYtrue0.0true1.0);
    
h_price CreateConVar("sm_lasermines_price""500""The price of the laser mines"FCVAR_NOTIFYtrue0.0);
    
h_color_t CreateConVar("sm_lasermines_color_t""255 127 0""Terrorist's color. Set by RGB"_);
    
h_color_ct CreateConVar("sm_lasermines_color_ct""0 127 255""Counter-Terrorist's color. Set by RGB"_);
    
h_allow_pickup CreateConVar("sm_lasermines_allow_pickup""1""Allow players to pickup their planted lasermines"_);
    
h_allow_friendly_pickup CreateConVar("sm_lasermines_allow_friendly_pickup""0""Allow players to pickup allies planted lasermines"_);
    
h_allow_enemy_pickup CreateConVar("sm_lasermines_allow_enemy_pickup""0""Allow players to pickup enemys planted lasermines"_);
    
h_wpn_dmg CreateConVar("sm_lasermines_wpn""taser""Enemy has died from this weapon"_);
    
h_lm_hs CreateConVar("sm_lasermines_hs""1""Headshot On/Off"_true0.0true1.0);
    
    
h_friendlyfire FindConVar("mp_friendlyfire");
    
    
//UpdateTime = CreateConVar("timer_hud_update_time", "0.5", "", 0, true, 0.01);

    // Gets them to the global
    
b_enable GetConVarBool(h_enable);
    
b_message GetConVarBool(h_message);
    
i_amount GetConVarInt(h_amount);
    
i_maxamount GetConVarInt(h_maxamount);
    
i_damage GetConVarInt(h_damage);
    
i_explode_damage GetConVarInt(h_explode_damage);
    
i_explode_radius GetConVarInt(h_explode_radius);
    
i_health GetConVarInt(h_health);
    
f_activate_time GetConVarFloat(h_activate_time);
    
b_use_buy_mode GetConVarBool(h_use_buy_mode);
    
b_should_buy_zone GetConVarBool(h_should_buy_zone);
    
i_price GetConVarInt(h_price);
    
b_allow_pickup GetConVarBool(h_allow_pickup);
    
b_allow_friendly_pickup GetConVarBool(h_allow_friendly_pickup);
    
b_allow_enemy_pickup GetConVarBool(h_allow_enemy_pickup);
    
    
GetConVarString(h_color_ts_color_tsizeof(s_color_t));
    
GetConVarString(h_color_cts_color_ctsizeof(s_color_ct));
    
GetConVarString(h_wpn_dmgs_wpn_dmgsizeof(s_wpn_dmg));
    
b_lm_hs GetConVarBool(h_lm_hs);
    
    
b_friendlyfire GetConVarBool(h_friendlyfire);
    
    
// Hooks their change
    
HookConVarChange(h_enableOnConVarChanged);
    
HookConVarChange(h_messageOnConVarChanged);
    
HookConVarChange(h_amountOnConVarChanged);
    
HookConVarChange(h_maxamountOnConVarChanged);
    
HookConVarChange(h_damageOnConVarChanged);
    
HookConVarChange(h_explode_damageOnConVarChanged);
    
HookConVarChange(h_explode_radiusOnConVarChanged);
    
HookConVarChange(h_healthOnConVarChanged);
    
HookConVarChange(h_activate_timeOnConVarChanged);
    
HookConVarChange(h_use_buy_modeOnConVarChanged);
    
HookConVarChange(h_should_buy_zoneOnConVarChanged);
    
HookConVarChange(h_priceOnConVarChanged);
    
HookConVarChange(h_color_tOnConVarChanged);
    
HookConVarChange(h_color_ctOnConVarChanged);
    
HookConVarChange(h_allow_pickupOnConVarChanged);
    
HookConVarChange(h_allow_friendly_pickupOnConVarChanged);
    
HookConVarChange(h_allow_enemy_pickupOnConVarChanged);
    
HookConVarChange(h_wpn_dmgOnConVarChanged);
    
HookConVarChange(h_lm_hsOnConVarChanged);
    
    
HookConVarChange(h_friendlyfireOnConVarChanged);
    
    
// Hooks event changes
    
HookEvent("player_spawn"OnPlayerSpawn);
//    HookEvent("player_death", OnPlayerDeath);
    
HookEvent("player_death"OnPlayerDeath_PreEventHookMode_Pre);
    
HookEvent("round_start"RoundStart);
    
    
// Registers new console commands
    
RegConsoleCmd("sm_colocar"Command_PlantMine"Plant a laser mine");

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

    
RegConsoleCmd("sm_lm"Command_BuyMines"Buy laser mines");
    
RegConsoleCmd("sm_lasermine"Command_BuyMines"Buy laser mines");

    
// Hooks entity env_beam ouput events
    
HookEntityOutput("env_beam""OnTouchedByEntity"OnTouchedByEntity);
    
    
// Loads the translation
    
LoadTranslations("csgo_lasermines.phrases");
    
    
// Finds offsets
    
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\"");
    
    
AutoExecConfig(true"plugin.csgo_lasermines");
    
    if (
b_late)
    {
        
b_late false;
        
OnMapStart();
    }
}
/*
    ------------------------------------------------
*/

/*
            Cvars changes
    ------------------------------------------------
*/
public OnConVarChanged(Handle:convar, const String:oldValue[], const String:newValue[])
{
    if (
convar == h_enable)
    {
        
b_enable bool:StringToInt(newValue);
    }
    else if (
convar == h_message)
    {
        
b_message bool:StringToInt(newValue);
    }
    else if (
convar == h_amount)
    {
        
i_amount StringToInt(newValue);
        
LookupClients();
    }
    else if (
convar == h_maxamount)
    {
        
i_maxamount StringToInt(newValue);
        
LookupClients();
    }
    else if (
convar == h_damage)
    {
        
i_damage StringToInt(newValue);
    }
    else if (
convar == h_explode_damage)
    {
        
i_explode_damage StringToInt(newValue);
    }
    else if (
convar == h_explode_radius)
    {
        
i_explode_radius StringToInt(newValue);
    }
    else if (
convar == h_health)
    {
        
i_health StringToInt(newValue);
    }
    else if (
convar == h_activate_time)
    {
        
f_activate_time StringToFloat(newValue);
    }
    else if (
convar == h_use_buy_mode)
    {
        
b_use_buy_mode bool:StringToInt(newValue);
    }
    else if (
convar == h_should_buy_zone)
    {
        
b_should_buy_zone bool:StringToInt(newValue);
    }
    else if (
convar == h_price)
    {
        
i_price StringToInt(newValue);
    }
    else if (
convar == h_color_t)
    {
        
strcopy(s_color_tsizeof(s_color_t), newValue);
    }
    else if (
convar == h_color_ct)
    {
        
strcopy(s_color_ctsizeof(s_color_ct), newValue);
    }
    else if (
convar == h_friendlyfire)
    {
        
b_friendlyfire bool:StringToInt(newValue);
    }
    else if (
convar == h_allow_pickup)
    {
        
b_allow_pickup bool:StringToInt(newValue);
    }
    else if (
convar == h_allow_friendly_pickup)
    {
        
b_allow_friendly_pickup bool:StringToInt(newValue);
    }
    else if (
convar == h_allow_enemy_pickup)
    {
        
b_allow_enemy_pickup bool:StringToInt(newValue);
    }
    else if (
convar == h_wpn_dmg)
    {
        
strcopy(s_wpn_dmgsizeof(s_wpn_dmg), newValue);
    }
    else if (
convar == h_lm_hs)
    {
        
b_lm_hs bool:StringToInt(newValue);
    }
}

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


/*
        Fires when the map starts
    ------------------------------------------------
*/
public OnMapStart()
{
    
PrecacheModel(MDL_MINEtrue);
    
PrecacheModel(MDL_LASERtrue);

    
PrecacheSound(SND_MINEPUTtrue);
    
PrecacheSound(SND_MINEACTtrue);
    
PrecacheSound(SND_BUYMINEtrue);
    
PrecacheSound(SND_CANTBUYtrue);

    
AddFileToDownloadsTable"models/sharks/tripmine/tripmine.dx90.vtx" );
    
AddFileToDownloadsTable"models/sharks/tripmine/tripmine.mdl" );
    
AddFileToDownloadsTable"models/sharks/tripmine/tripmine.phy" );
    
AddFileToDownloadsTable"models/sharks/tripmine/tripmine.vvd" );

    
AddFileToDownloadsTable"materials/models/sharks/tripmine/tripmine.vmt" );
    
AddFileToDownloadsTable"materials/models/sharks/tripmine/tripmine.vtf" );
    
AddFileToDownloadsTable"materials/models/sharks/tripmine/tripmine_normal.vtf" );
    
AddFileToDownloadsTable"materials/models/sharks/tripmine/tripmine2.vmt" );
    
AddFileToDownloadsTable"materials/models/sharks/tripmine/tripmine2.vtf" );
    
AddFileToDownloadsTable"materials/models/sharks/tripmine/tripmine2_normal.vtf" );
}
/*
    ------------------------------------------------
*/

public RoundStart(Handle:event, const String:name[], bool:dontBroadcast)
{
    if(
b_enable && b_message)
    {
          if(
b_use_buy_modeCPrintToChatAll("%t""Welcome Message 2");
         else 
CPrintToChatAll("%t""Welcome Message 1");
    }
}
/*
    ------------------------------------------------
*/

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

/*
    Fires when a client disconnects
    ------------------------------------------------
*/
public OnClientDisconnect(client)
{
    
i_buy_limit[client] = 0;
    for (new 
index MaxClients+1index <= 2048index++)
    {
        if (
GetClientByLasermine(index) == client)
        {
            
SDKUnhook(indexSDKHook_OnTakeDamageOnTakeDamage);
            
AcceptEntityInput(index"KillHierarchy");
        }
    }
}

/*
    Fires when a client fully disconnected
    ------------------------------------------------
*/
public OnClientDisconnect_Post(client)
{
    
i_clients_amount[client] = 0;
    
b_used_by_native[client] = false;
}

/*
            Touch event
    ------------------------------------------------
*/
public OnTouchedByEntity(const String:output[], calleractivatorFloat:delay)
{
    if (!(
<= activator <= MaxClients))
    {
        return;
    }
    new 
owner GetEntPropEnt(callerProp_Data"m_hOwnerEntity");
    new 
lasermine GetLasermineByBeam(caller);
    
    if (
owner == -|| lasermine == -|| activator == owner || (!b_friendlyfire && GetClientTeam(activator) == GetClientTeam(owner)))
    {
        return;
    }
    
    
decl dummy_callerdummy_ownerdamagedummy_lasermine;
    
dummy_caller caller;
    
dummy_owner owner;
    
damage i_damage;
    
dummy_lasermine lasermine;
    
    new 
Action:result Forward_OnPreHit(activatordummy_ownerdummy_callerdummy_laserminedamage);
    
    switch (
result)
    {
        case 
Plugin_HandledPlugin_Stop :
        {
            return;
        }
        case 
Plugin_Continue :
        {
            
dummy_caller caller;
            
dummy_owner owner;
            
damage i_damage;
            
dummy_lasermine lasermine;
        }
    }
    
    
// Make custom damage to the client
    
SDKHooks_TakeDamage(activatordummy_callerdummy_ownerfloat(damage), DMG_ENERGYBEAM);
    
    
Forward_OnPostHit(activatordummy_ownerdummy_callerdummy_laserminedamage);
}

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

    if( 
IsFakeClientclient ) || !IsPlayerAlive(client) )
        return;

    
//Timer = CreateTimer(GetConVarFloat(UpdateTime), HUDTimer, client, TIMER_FLAG_NO_MAPCHANGE|TIMER_REPEAT);
}

//public OnPlayerDeath(Handle:event, const String:name[], bool:dontBroadcast)
//{
//    new client = GetClientOfUserId(GetEventInt(event, "userid"));
//    OnClientDisconnect(client);
//}

public Action:HUDTimer(Handle:timerany:client)
{
    
int iLaser GetClientAimTargetclientfalse );

    if (
client && IsClientInGame(client) && !IsClientSourceTV(client) && !IsClientReplay(client) && iLaser != -&& IsEntityLasermineiLaser ))
    {
        
UpdateHUD(clientiLaser);
    }

    return 
Plugin_Continue;
}

public 
Action:OnPlayerDeath_Pre(Handle:event, const String:name[], bool:dontBroadcast)
{
    new 
attacker GetClientOfUserId(GetEventInt(event"attacker"));
    if (
<= attacker <= MaxClients)
    {
        
decl String:g_szWeapon[32];
        
GetEventString(event"weapon"g_szWeaponsizeof(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:Command_BuyMines(clientargc)
{
    
// client = 0    or    disabled    or    buy mode disabled    or    unlimited amount    or    client is not in game
    
if (!client || !b_enable || !b_use_buy_mode || i_clients_myamount[client] == -|| !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
    
}
    
// client is spectator
    
if (GetClientTeam(client) <= 1)
    {
        
PrintHintText(client"%t""Can't use, while spec");
        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 && !bool:GetEntData(clientgInBuyZone1))
    {
        
PrintHintText(client"%t""Out of buy zone");
        return 
Plugin_Handled;    // Stop trigger the command
    
}
    
    new 
amount 1;
    if (
argc)
    {
        
decl String:txt[6];
        
GetCmdArg(1txtsizeof(txt));
        
amount StringToInt(txt);
        if (
bool:i_clients_maxlimit[client])
        {
            if (
amount i_clients_maxlimit[client])
            {
                
amount i_clients_maxlimit[client];
            }
            else if (
amount 1)
            {
                
amount 1;
            }
        }
    }
    
    
decl dummy_amountcostboughtamount;
    
dummy_amount amount;
    
cost i_price;
    
boughtamount 0;
    new 
Action:result Forward_OnPreBuy(clientdummy_amountcost);
    
    switch (
result)
    {
        case 
Plugin_HandledPlugin_Stop :
        {
            return 
result;
        }
        case 
Plugin_Continue :
        {
            
dummy_amount amount;
            
cost i_price;
        }
    }
    
    new 
money GetEntData(clientgAccount);
    do
    {
        if (
bool: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(clientSND_CANTBUY);
            return 
Plugin_Handled;
        }
        
SetEntData(clientgAccountmoney);
        
i_clients_amount[client]++;
        
i_buy_limit[client]++;
        
boughtamount++;
    } while (--
dummy_amount);
    
    if (
boughtamount)
    {
        
PrintHintText(client"%t""Mines"i_clients_amount[client]);
        
EmitSoundToClient(clientSND_BUYMINE);
        
Forward_OnPostBuy(clientboughtamountboughtamount*cost);
    }
    
    return 
Plugin_Handled;
}

/*
    ------------------------------------------------
*/
public Action:Command_PlantMine(clientargc)
{
    if (!
client || !b_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;
    }
    
    
decl color[3];
    switch (
GetClientTeam(client))
    {
        case 
:
        {
            
StringToColor(s_color_tcolor255);
        }
        case 
:
        {
            
StringToColor(s_color_ctcolor255);
        }
        default :
        {
            
PrintHintText(client"%t""Can't use, while spec");
            return 
Plugin_Handled;
        }
    }
    
    
decl Float:delay_timedummy_damagedummy_radiushealthdummy_color[3];
    
delay_time f_activate_time;
    
dummy_damage i_explode_damage;
    
dummy_radius i_explode_radius;
    
health i_health;
    
dummy_color color;
    
    new 
Action:result Forward_OnPlantMine(clientdelay_timedummy_damagedummy_radiushealthdummy_color);
    
    switch (
result)
    {
        case 
Plugin_HandledPlugin_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(clientdelay_timedummy_damagedummy_radiushealthdummy_color)) == -1)
        return 
Plugin_Handled;
    
    
Forward_OnMinePlanted(clientminedelay_timedummy_damagedummy_radiushealthdummy_color);
    
    switch (
i_clients_amount[client])
    {
        case -
:
        {
            
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(int clientint argc) {
    if( !
b_allow_pickup || IsFakeClientclient ) || !IsPlayerAlive(client) )
        return 
Plugin_Handled;

    
int iLaser GetClientAimTargetclientfalse );
    if ( 
iLaser != -&& IsEntityLasermineiLaser ) && GetClientByLasermine(iLaser) == client )
        
PickupLasermineclientiLaserclient );
    else
        
PrintToChatclient"[Sharks.cL] No estas mirando hacia una mina laser!" );
 
    return 
Plugin_Handled;
}

public 
Action:OnPlayerRunCmd(client, &buttons, &impulseFloat:vel[3], Float:angles[3], &weapon)
{
    static 
iPrevButtons[MAXPLAYERS+1];

    if (!
b_allow_pickup || IsFakeClient(client) || !IsPlayerAlive(client))
        return 
Plugin_Continue;
    
    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(cliententowner);
            return;
        }
        if (
GetClientTeam(owner) == GetClientTeam(client))
        {
            if (
b_allow_friendly_pickup)
            {
                
PickupLasermine(cliententowner);
            }
        }
        else if (
b_allow_enemy_pickup)
        {
            
PickupLasermine(cliententowner);
        }
    }
    else
        
CloseHandle(trace);
}

PickupLasermine(clientlasermineowner)
{
    
float vecMinePos], vecPlayerPos];
    
GetEntPropVectorlasermineProp_Send"m_vecOrigin"vecMinePos );
    
GetEntPropVectorownerProp_Send"m_vecOrigin"vecPlayerPos );

    if ( 
GetVectorDistancevecMinePosvecPlayerPos ) >= 85.0 
    {
        
PrintToChatclient"[Sharks.cL] Necesitas estar cerca de tu mina laser!" );
        return;
    }
    
    if (
i_clients_amount[client] >= && i_clients_amount[client] == AddClientLasermines(client))
    {
        return;
    }
    
    new 
Action:result Forward_OnPrePickup(clientlasermineowner);
    
    switch (
result)
    {
        case 
Plugin_HandledPlugin_Stop :
        {
            return;
        }
    }
    
    
RemoveEntity(lasermine);
    if (
i_clients_amount[client] >= 0)
        
PrintHintText(client"%t""Mines"i_clients_amount[client]);
    else
        
PrintHintText(client"%t""Infinity mines");
    
EmitSoundToClient(clientSND_BUYMINE);
    
    
Forward_OnPostPickup(clientlasermineowner);
}

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

    
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(startentendCONTENTS_SOLIDRayType_EndPointFilterPlayers);
}


/*
    ------------------------------------------------
*/

PlantMine(clientFloat:activation_delay 0.0explode_damageexplode_radius, const health 0, const color[3] = {255255255})
{
    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(endtrace);
        
TR_GetPlaneNormal(tracenormal);
        
CloseHandle(trace);
        
        
GetVectorAngles(normalnormal);
        
        
TR_TraceRayFilter(endnormalCONTENTS_SOLIDRayType_InfiniteFilterAll);
        
TR_GetEndPosition(beamendINVALID_HANDLE);
        
        new 
ent CreateEntityByName("prop_physics_override");
        if (
ent == -|| !IsValidEdict(ent))
        {
            
LogError("Could not create entity \"prop_physics_override\"");
            return -
1;
        }
        
        new 
beament CreateEntityByName("env_beam");
        if (
beament == -|| !IsValidEdict(beament))
        {
            
LogError("Could not create entity \"env_beam\"");
            return -
1;
        }
        
//CreateTimer(2.0, MakeSolid, EntIndexToEntRef(ent), TIMER_FLAG_NO_MAPCHANGE);

        
decl String:start[30], String:tmp[200];
        
Format(startsizeof(start), "Beam%i"beament);
        
        
SetEntityModel(entMDL_MINE);
        
        
decl String:buffer[16];
        
IntToString(explode_damagebuffersizeof(buffer));
        
DispatchKeyValue(ent"ExplodeDamage"buffer);
        
IntToString(explode_radiusbuffersizeof(buffer));
        
DispatchKeyValue(ent"ExplodeRadius"buffer);
        
        
DispatchKeyValue(ent"spawnflags""3");
        
SetEntProp(entProp_Data"m_nSolidType"6);   //Hacer no solido
        
SetEntProp(entProp_Data"m_CollisionGroup"5); //Hacer no solido
        
DispatchSpawn(ent);
        
        
AcceptEntityInput(ent"DisableMotion");
        
SetEntityMoveType(entMOVETYPE_NONE);
        
TeleportEntity(entendnormalNULL_VECTOR);
        
        if (
health)
        {
            
SetEntProp(entProp_Data"m_takedamage"2);
            
SetEntProp(entProp_Data"m_iHealth"health);
        }
        
        
Format(tmpsizeof(tmp), "%s,Kill,,0,-1"start);
        
DispatchKeyValue(ent"OnBreak"tmp);
        
        
EmitSoundToAll(SND_MINEPUTent);
        
        
        
        
// 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(beamentMDL_LASER);
        
        
TeleportEntity(beamentbeamendNULL_VECTORNULL_VECTOR); // Teleport the beam
        
        
SetEntPropVector(beamentProp_Data"m_vecEndPos"end);
        
SetEntPropFloat(beamentProp_Data"m_fWidth"3.0);
        
SetEntPropFloat(beamentProp_Data"m_fEndWidth"3.0);
        
        
SetEntPropEnt(beamentProp_Data"m_hOwnerEntity"client); // Sets the owner of the beam
        
SetEntPropEnt(entProp_Data"m_hMoveChild"beament);
        
SetEntPropEnt(beamentProp_Data"m_hEffectEntity"ent);
        
        new 
Handle:datapack CreateDataPack();
        
WritePackCell(datapackbeament);
        
WritePackCell(datapackent);
        
WritePackCell(datapackcolor[0]);
        
WritePackCell(datapackcolor[1]);
        
WritePackCell(datapackcolor[2]);
        
WritePackString(datapackstart);
        
CreateTimer(activation_delayOnActivateLaserdatapackTIMER_FLAG_NO_MAPCHANGE|TIMER_HNDL_CLOSE);
        
        
SDKHook(entSDKHook_OnTakeDamageOnTakeDamage);
        
        return 
ent;
    }
    else
        
CloseHandle(trace);
    return -
1;
}

UpdateHUD(clientent)
{
    if(!
client)
    return;
    
GetEntPropEnt(entProp_Data"m_hOwnerEntity");
    
//new client2 = GetEntPropEnt(lasermine, Prop_Data, "m_hOwnerEntity");
    
PrintHintText(client"[Escondidas Mod]\n\nVIDA: 100\nCREADOR:%N"GetClientByLasermine(client));
}

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

/*
    ------------------------------------------------
*/

public bool:FilterAll(entitycontentsMask)
{
    return 
false;
}

public 
bool:FilterPlayers(entitycontentsMask)
{
    return !(
<= entity <= MaxClients);
}

public 
Action MakeSolid(Handle timerint entlaseraction)
{
    
int entity EntRefToEntIndex(entlaseraction);
    if(
entity != -1)
    {
        
// Make solid
        
SetEntProp(entityProp_Data"m_nSolidType"6);
        
SetEntProp(entityProp_Data"m_CollisionGroup"5);
    }
}

public 
Action:OnActivateLaser(Handle:timerany: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(hDataPackstartsizeof(start));
    
    if (!
IsValidEdict(beament) || !IsValidEdict(ent))
    {
        return 
Plugin_Stop;
    }

    
AcceptEntityInput(beament"TurnOn");
    
    
SetEntityRenderColor(beamentcolor[0], color[1], color[2]);

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

    
EmitSoundToAll(SND_MINEACTent);
    
    return 
Plugin_Stop;
}

/*
            N A T I V E S
    ------------------------------------------------
*/

public Native_AddMines(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if (
client || 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 <= 0)
    {
        return 
i_clients_amount[client];
    }
    if (
i_clients_amount[client] < 0)
    {
        return -
1;
    }
    
    
i_clients_amount[client] += amount;
    
    if (
limit)
    {
        if (
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:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if (
client || 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)
    {
        if (
i_clients_amount[client] > i_clients_maxlimit[client])
        {
            
i_clients_amount[client] = i_clients_maxlimit[client];
        }
    }
    
    return 
true;
}

public 
Native_SubstractMines(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if (
client || 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 <= 0)
    {
        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:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if (
client || 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:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if (
client || 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:pluginnumParams)
{
    new 
client GetNativeCell(1);
    
    if (
client || 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(6colorsizeof(color));
    
    new 
mine;
    if ((
mine PlantMine(clientf_delayi_exp_damagei_exp_radiushealthcolor)) != -1)
    {
        
Forward_OnMinePlanted(clientminef_delayi_exp_damagei_exp_radiushealthcolor);
    }
    return (
mine != -1);
}

public 
Native_IsLasermine(Handle:pluginnumParams)
{
    new 
entity GetNativeCell(1);
    if (
entity <= MaxClients || !IsValidEdict(entity))
    {
        return 
false;
    }
    
decl String:g_szModel[PLATFORM_MAX_PATH];
    
GetEntPropString(entityProp_Data"m_ModelName"g_szModelsizeof(g_szModel));
    return (
StrEqual(g_szModelMDL_MINEfalse) && GetEntPropEnt(entityProp_Data"m_hMoveChild") != -1);
}

public 
Native_GetClientByLasermine(Handle:pluginnumParams)
{
    new 
entity GetNativeCell(1);
    new 
beam;
    if ((
beam GetBeamByLasermine(entity)) == -1)
    {
        return -
1;
    }
    return 
GetEntPropEnt(beamProp_Data"m_hOwnerEntity");
}

public 
Native_SetClientMaxLasermines(Handle:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if (
client || 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:pluginnumParams)
{
    new 
client GetNativeCell(1);
    if (
client || 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:pluginnumParams)
{
    new 
entity GetNativeCell(1);
    if (
IsEntityLasermine(entity))
    {
        return 
GetEntPropEnt(entityProp_Data"m_hMoveChild");
    }
    return -
1;
}

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

/*
        F O R W A R D S
    ------------------------------------------------
*/

Action:Forward_OnPlantMine(client, &Float:activate_time, &exp_damage, &exp_radius, &healthcolor[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(colorsizeof(color), SM_PARAM_COPYBACK);
    
Call_Finish(result);
    
    return 
result;
}

Forward_OnMinePlanted(clientmineFloat:activate_timeexp_damageexp_radiushealthcolor[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(colorsizeof(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(victimattackerbeamlaserminedamage)
{
    
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(clientamountsum)
{
    
Call_StartForward(h_fwdOnPostBuyLasermine);
    
Call_PushCell(client);
    
Call_PushCell(amount);
    
Call_PushCell(sum);
    
Call_Finish();
}

Action:Forward_OnPrePickup(clientlasermineowner)
{
    
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(clientlasermineowner)
{
    
Call_StartForward(h_fwdOnPostPickupLasermine);
    
Call_PushCell(client);
    
Call_PushCell(lasermine);
    
Call_PushCell(owner);
    
Call_Finish();
}

/*
            S T O C K S
    ------------------------------------------------
*/


stock bool:StringToColor(const String:str[], color[3], const defvalue = -1)
{
    new 
bool:result false;
    
decl String:Splitter[3][64];
    if (
ExplodeString(str" "Splittersizeof(Splitter), sizeof(Splitter[])) == && 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=0;
    new 
numbersFound=0;

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

    while (
str[x] != '\0')
    {
        if (
IsCharNumeric(str[x]))
            
numbersFound++;
        else
            return 
false;
        
x++;
    }
    
    if (!
numbersFound)
        return 
false;
    
    return 
true;

It's showing the kill like this

IMAGE

What could be ?
__________________

Last edited by Elitcky; 07-26-2020 at 02:17.
Elitcky is offline
DJ Tsunami
DJ Post Spammer
Join Date: Feb 2008
Old 07-26-2020 , 07:10   Re: Lasermine kill event not working anymore
Reply With Quote #2

Make sure you update to SourceMod 1.10.0.6492 or 1.11.0.6603, which fixes OnTakeDamage after the last CS:GO update.
__________________
DJ Tsunami is offline
Elitcky
AlliedModders Donor
Join Date: Jun 2016
Location: Antofagasta, Chile
Old 07-26-2020 , 18:36   Re: Lasermine kill event not working anymore
Reply With Quote #3

Thanks, all working.
__________________
Elitcky is offline
Reply


Thread Tools
Display Modes

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off

Forum Jump


All times are GMT -4. The time now is 08:40.


Powered by vBulletin®
Copyright ©2000 - 2020, vBulletin Solutions, Inc.
Theme made by Freecode