|
Junior Member
Join Date: Oct 2018
Location: São Paulo, Brazil
|
10-21-2018
, 03:43
Re: [CS:GO] Lasermines 1.5.1
|
#50
|
Quote:
Originally Posted by Grey83
|
Oh yes thank you but in order to register on this website I have to deposit money and I can't do that 
BUT, I did find out how to make the mines for ct only 
Also only version 1.5 is working for me, 1.5.1 doesn't work.
So I just updated 1.5 to have solid mines (that you can jump on) and ct works with ct only. Also mines don't do damage when explode but you can edit that.
Source
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"
#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"
/*
------------------------------------------------
*/
/*
|G| |L| |O| |B| |A| |L| |S|
------------------------------------------------
*/
new Handle:h_enable, bool:b_enable,
Handle:h_message, bool:b_message,
Handle:h_amount, i_amount,
Handle:h_maxamount, i_maxamount,
Handle:h_damage, i_damage,
Handle:h_explode_damage, i_explode_damage,
Handle:h_explode_radius, i_explode_radius,
Handle:h_health, i_health,
Handle:h_color_t, String:s_color_t[16],
Handle:h_color_ct, String:s_color_ct[16],
Handle:h_activate_time, Float:f_activate_time,
Handle:h_use_buy_mode, bool:b_use_buy_mode,
Handle:h_should_buy_zone, bool:b_should_buy_zone,
Handle:h_allow_pickup, bool:b_allow_pickup,
Handle:h_allow_friendly_pickup, bool:b_allow_friendly_pickup,
Handle:h_allow_enemy_pickup, bool:b_allow_enemy_pickup,
Handle:h_price, i_price,
Handle:h_wpn_dmg, String:s_wpn_dmg[16],
Handle:h_lm_hs, bool:b_lm_hs;
new Handle:h_friendlyfire, bool: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: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;
}
/*
Fires when the plugin starts
------------------------------------------------
*/
public OnPluginStart()
{
// Creates console variable version
CreateConVar("csgo_lasermines_version", PLUGIN_VERSION, "The version of the plugin", FCVAR_PLUGIN|FCVAR_REPLICATED|FCVAR_NOTIFY|FCVAR_DONTRECORD);
// Creates console variables
h_enable = CreateConVar("sm_lasermines_enable", "1", "Enables/Disables the plugin", FCVAR_PLUGIN|FCVAR_NOTIFY, true, 0.0, true, 1.0);
h_message = CreateConVar("sm_lasermines_welcome_message", "1", "Show Plugin Message at the beginning of each round.", FCVAR_PLUGIN, true, 0.0, true, 1.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)", FCVAR_PLUGIN, true, -1.0);
h_maxamount = CreateConVar("sm_lasermines_maxamount", "3", "The maximum amount of laser mines a player can carry. (0-Unlimited)", FCVAR_PLUGIN, true, 0.0);
h_damage = CreateConVar("sm_lasermines_damage", "500", "The damage to deal to a player by the laser", FCVAR_PLUGIN, true, 1.0, true, 100000.0);
h_explode_damage = CreateConVar("sm_lasermines_explode_damage", "0", "The damage to deal to a player when a laser mine breaks", FCVAR_PLUGIN, true, 0.0, true, 100000.0);
h_explode_radius = CreateConVar("sm_lasermines_explode_radius", "0", "The radius of the explosion", FCVAR_PLUGIN, true, 1.0, true, 100000.0);
h_health = CreateConVar("sm_lasermines_health", "300", "The laser mines health. 0 = never breaked", FCVAR_PLUGIN, true, 0.0, true, 100000.0);
h_activate_time = CreateConVar("sm_lasermines_activatetime", "1", "The delay of laser mines' activation", FCVAR_PLUGIN, true, 0.0, true, 10.0);
h_use_buy_mode = CreateConVar("sm_lasermines_buymode", "0", "Enables buy mode. In this mode you will have to buy mines", FCVAR_PLUGIN|FCVAR_NOTIFY, true, 0.0, true, 1.0);
h_should_buy_zone = CreateConVar("sm_lasermines_buyzone", "1", "Whether a player have to stay in buy zone to buy mines", FCVAR_PLUGIN|FCVAR_NOTIFY, true, 0.0, true, 1.0);
h_price = CreateConVar("sm_lasermines_price", "500", "The price of the laser mines", FCVAR_PLUGIN|FCVAR_NOTIFY, true, 0.0);
h_color_t = CreateConVar("sm_lasermines_color_t", "255 63 0", "Terrorist's color. Set by RGB", FCVAR_PLUGIN);
h_color_ct = CreateConVar("sm_lasermines_color_ct", "0 127 255", "Counter-Terrorist's color. Set by RGB", FCVAR_PLUGIN);
h_allow_pickup = CreateConVar("sm_lasermines_allow_pickup", "1", "Allow players to pickup their planted lasermines", FCVAR_PLUGIN);
h_allow_friendly_pickup = CreateConVar("sm_lasermines_allow_friendly_pickup", "0", "Allow players to pickup allies planted lasermines", FCVAR_PLUGIN);
h_allow_enemy_pickup = CreateConVar("sm_lasermines_allow_enemy_pickup", "0", "Allow players to pickup enemys planted lasermines", FCVAR_PLUGIN);
h_wpn_dmg = CreateConVar("sm_lasermines_wpn", "taser", "Enemy has died from this weapon", FCVAR_PLUGIN);
h_lm_hs = CreateConVar("sm_lasermines_hs", "1", "Headshot On/Off", FCVAR_PLUGIN, true, 0.0, true, 1.0);
h_friendlyfire = FindConVar("mp_friendlyfire");
// 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_t, s_color_t, sizeof(s_color_t));
GetConVarString(h_color_ct, s_color_ct, sizeof(s_color_ct));
GetConVarString(h_wpn_dmg, s_wpn_dmg, sizeof(s_wpn_dmg));
b_lm_hs = GetConVarBool(h_lm_hs);
b_friendlyfire = GetConVarBool(h_friendlyfire);
// Hooks their change
HookConVarChange(h_enable, OnConVarChanged);
HookConVarChange(h_message, OnConVarChanged);
HookConVarChange(h_amount, OnConVarChanged);
HookConVarChange(h_maxamount, OnConVarChanged);
HookConVarChange(h_damage, OnConVarChanged);
HookConVarChange(h_explode_damage, OnConVarChanged);
HookConVarChange(h_explode_radius, OnConVarChanged);
HookConVarChange(h_health, OnConVarChanged);
HookConVarChange(h_activate_time, OnConVarChanged);
HookConVarChange(h_use_buy_mode, OnConVarChanged);
HookConVarChange(h_should_buy_zone, OnConVarChanged);
HookConVarChange(h_price, OnConVarChanged);
HookConVarChange(h_color_t, OnConVarChanged);
HookConVarChange(h_color_ct, OnConVarChanged);
HookConVarChange(h_allow_pickup, OnConVarChanged);
HookConVarChange(h_allow_friendly_pickup, OnConVarChanged);
HookConVarChange(h_allow_enemy_pickup, OnConVarChanged);
HookConVarChange(h_wpn_dmg, OnConVarChanged);
HookConVarChange(h_lm_hs, OnConVarChanged);
HookConVarChange(h_friendlyfire, OnConVarChanged);
// Hooks event changes
HookEvent("player_spawn", OnPlayerSpawn);
// HookEvent("player_death", OnPlayerDeath);
HookEvent("player_death", OnPlayerDeath_Pre, EventHookMode_Pre);
HookEvent("round_start", RoundStart);
// Registers new console commands
RegConsoleCmd("sm_plantlm", Command_PlantMine, "Plant a laser mine");
RegConsoleCmd("sm_blm", Command_PlantMine, "Plant a laser mine");
RegConsoleCmd("sm_lm", Command_PlantMine, "Plant a laser mine");
RegConsoleCmd("sm_buylm", Command_BuyMines, "Buy laser mines");
RegConsoleCmd("sm_blm", Command_BuyMines, "Buy laser mines");
RegConsoleCmd("sm_bm", 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 = FindSendPropOffs("CCSPlayer", "m_bInBuyZone")) == -1)
SetFailState("Could not find offset \"m_bInBuyZone\"");
if ((gAccount = FindSendPropOffs("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_t, sizeof(s_color_t), newValue);
}
else if (convar == h_color_ct)
{
strcopy(s_color_ct, sizeof(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_dmg, sizeof(s_wpn_dmg), newValue);
}
else if (convar == h_lm_hs)
{
b_lm_hs = bool:StringToInt(newValue);
}
}
LookupClients()
{
for (new i = 1; i <= MaxClients; i++)
{
OnClientConnected(i);
}
}
/*
Fires when the map starts
------------------------------------------------
*/
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(b_enable && b_message)
{
if(b_use_buy_mode) CPrintToChatAll("%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+1; index <= 2048; index++)
{
if (GetClientByLasermine(index) == client)
{
SDKUnhook(index, SDKHook_OnTakeDamage, OnTakeDamage);
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[], 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;
}
decl dummy_caller, dummy_owner, damage, dummy_lasermine;
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;
}
}
// Make custom damage to the client
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)
{
new client = GetClientOfUserId(GetEventInt(event, "userid"));
if (!b_use_buy_mode)
{
i_clients_amount[client] = i_clients_myamount[client];
}
}
//public OnPlayerDeath(Handle:event, const String:name[], bool:dontBroadcast)
//{
// 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 (1 <= 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:Command_BuyMines(client, argc)
{
// 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] == -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
}
// 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(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 (bool:i_clients_maxlimit[client])
{
if (amount > i_clients_maxlimit[client])
{
amount = i_clients_maxlimit[client];
}
else if (amount < 1)
{
amount = 1;
}
}
}
decl dummy_amount, cost, boughtamount;
dummy_amount = amount;
cost = i_price;
boughtamount = 0;
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 (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(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:Command_PlantMine(client, argc)
{
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];
if (GetClientTeam(client) == 3)
{
StringToColor(s_color_t, color, 255);
}
else
{
PrintHintText(client, "%t", "Can't use, while spec"); // Need add new phrase, like "Can't use, if not ct"
return Plugin_Handled;
}
decl Float:delay_time, dummy_damage, dummy_radius, health, dummy_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(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;
}
decl Float:delay_time, dummy_damage, dummy_radius, health, dummy_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(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:OnPlayerRunCmd(client, &buttons, &impulse, Float: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(client, ent, owner);
return;
}
if (GetClientTeam(owner) == GetClientTeam(client))
{
if (b_allow_friendly_pickup)
{
PickupLasermine(client, ent, owner);
}
}
else if (b_allow_enemy_pickup)
{
PickupLasermine(client, ent, owner);
}
}
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] = startent[0] + end[0] * 10.0;
startent[1] = startent[1] + end[1] * 10.0;
startent[2] = 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);
}
/*
------------------------------------------------
*/
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", 5);
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 (1 <= 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(entity, contentsMask)
{
return false;
}
public bool:FilterPlayers(entity, contentsMask)
{
return !(1 <= 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;
}
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;
}
/*
N A T I V E S
------------------------------------------------
*/
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 <= 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: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)
{
if (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 <= 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: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;
}
/*
F O R W A R D S
------------------------------------------------
*/
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();
}
/*
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, " ", 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=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;
}
|
|
Linear Mode
