You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
606 lines
21 KiB
606 lines
21 KiB
#include <sourcemod>
|
|
#include <sdktools>
|
|
#include <sdkhooks>
|
|
#include <tf2>
|
|
#include <tf2_stocks>
|
|
|
|
#pragma semicolon 1
|
|
|
|
#define UID(%0) GetClientUserId(%0)
|
|
#define CID(%0) GetClientOfUserId(%0)
|
|
#define PLUGIN_VERSION "1.0"
|
|
|
|
#define HUD_X -1.0;
|
|
#define HUD_Y 0.4;
|
|
#define HUD_HOLD 1.0;
|
|
|
|
new Handle:g_cmd_timeout;
|
|
new Handle:g_cmd_timeout_vip;
|
|
|
|
new Handle:g_EffectTimer[MAXPLAYERS+2] = {INVALID_HANDLE, ...};
|
|
|
|
char g_SQL_RANDOM[256];
|
|
//char g_SQL_EFFECT[256];
|
|
|
|
int g_ClientStartTime[MAXPLAYERS+2] = {0, ...};
|
|
int g_ClientEndTime[MAXPLAYERS+2] = {0, ...};
|
|
int g_ClientLastUse[MAXPLAYERS+2] = {0, ...};
|
|
int g_ClientLastActivate[MAXPLAYERS+2] = {0, ...};
|
|
|
|
char g_ClientActivateCmd[MAXPLAYERS+2][256];
|
|
char g_ClientDeactivateCmd[MAXPLAYERS+2][256];
|
|
|
|
bool g_ClientDeactivateIfDead[MAXPLAYERS+2] = {false, ...};
|
|
char g_ClientEffectName[MAXPLAYERS+2][256];
|
|
bool g_ClientSettedEffect[MAXPLAYERS+2] = {false, ...};
|
|
bool g_ClientUpdatedEffect[MAXPLAYERS+2] = {false, ...};
|
|
bool g_ClientShowHud[MAXPLAYERS+2] = {false, ...};
|
|
|
|
new Handle:g_Database = INVALID_HANDLE;
|
|
new Handle:g_hCounterHud = INVALID_HANDLE;
|
|
|
|
public Plugin:myinfo =
|
|
{
|
|
name = "RTD ULTIMATE",
|
|
author = "gsd",
|
|
description = "SQL RTD VERSION WITH WEIGHT RANDOM AND SERVER COMMAND EXECUTE",
|
|
version = PLUGIN_VERSION,
|
|
url = "http://vk.com/facti13"
|
|
}
|
|
|
|
public OnPluginStart(){
|
|
SQL_Start();
|
|
HookEvent("post_inventory_application", Event_Spawn);
|
|
CreateConVar("sm_rtd_version", PLUGIN_VERSION, "RTD ULTIMATE VERSION", FCVAR_SPONLY|FCVAR_REPLICATED|FCVAR_NOTIFY|FCVAR_DONTRECORD);
|
|
|
|
g_cmd_timeout = CreateConVar("sm_rtd_timeout", "120", "Amount of time in seconds a player roll the ULTIMATE DICE FACTI 13", FCVAR_NOTIFY, true, 0.0);
|
|
g_cmd_timeout_vip = CreateConVar("sm_rtd_timeout_vip", "180", "Amount of time in seconds a vip player roll the ULTIMATE DICE FACTI 13", FCVAR_NOTIFY, true, 0.0);
|
|
|
|
RegConsoleCmd("rtd", User_roll);
|
|
//RegAdminCmd("sm_rrtd", User_roll, ADMFLAG_RESERVATION, "Roll the ULTIMATE DICE");
|
|
RegAdminCmd("sm_rtd_use", Admin_roll, ADMFLAG_ROOT, "Roll the ULTIMATE DICE to user");
|
|
|
|
RegAdminCmd("sm_rtd_addcond", Command_AddCondition, ADMFLAG_GENERIC, "Add a condition to the target(s), Usage: sm_rtd_addcond \"target\" \"condition number\" \"duration\"");
|
|
RegAdminCmd("sm_rtd_removecond", Command_RemoveCondition, ADMFLAG_GENERIC, "Add a condition to the target(s), Usage: sm_rtd_removecond \"target\" \"condition number\"");
|
|
RegAdminCmd("sm_rtd_kill", Command_Kill, ADMFLAG_GENERIC, "Kill target', Usage: sm_rtd_kill \"target\" \"condition number\"");
|
|
RegAdminCmd("sm_rtd_reset", Command_Reset, ADMFLAG_GENERIC, "Reset RTD timeout on target', Usage: sm_rtd_reset \"target\"");
|
|
RegAdminCmd("sm_rtd_playsound", Command_PlaySound, ADMFLAG_GENERIC, "Play sound on target', Usage: sm_rtd_playsound \"target\"");
|
|
g_hCounterHud = CreateHudSynchronizer();
|
|
}
|
|
|
|
public OnPluginEnd(){
|
|
for (new i = 0; i < MAXPLAYERS + 2; i ++){
|
|
if(g_EffectTimer[i] != INVALID_HANDLE){
|
|
TriggerTimer(g_EffectTimer[i]);
|
|
} else {
|
|
DeactivateEffect(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
//SQL INIT FUNCTIONS
|
|
stock SQL_Start(){
|
|
Format(g_SQL_RANDOM, sizeof(g_SQL_RANDOM), "SELECT name, activate, deactivate, time, de_ondead, alarm_all, -LOG(random()) / chance as priority FROM rtd_ultimate ORDER BY priority LIMIT 1");
|
|
//Format(g_SQL_EFFECT, sizeof(g_SQL_EFFECT), "SELECT name, activate, deactivate, time, de_ondead FROM rtd_ultimate WHERE id LIKE %i LIMIT 1");
|
|
SQL_TConnect(SQL_SetDatabase, "rtd_ultimate");
|
|
}
|
|
|
|
public SQL_SetDatabase(Handle:owner, Handle:hndl, const String:error[], any:data) {
|
|
if (hndl == INVALID_HANDLE) {
|
|
LogError("Database Connection Error: %s", error);
|
|
} else {
|
|
g_Database = hndl;
|
|
}
|
|
}
|
|
|
|
//CLIENT CONNECTION/SPAWN
|
|
public void OnClientAuthorized(client){
|
|
DeactivateEffect(client);
|
|
g_ClientLastUse[client] = GetTime();
|
|
g_EffectTimer[client] = INVALID_HANDLE;
|
|
}
|
|
|
|
public void OnClientDisconnect(client){
|
|
if(g_EffectTimer[client] != INVALID_HANDLE){
|
|
KillTimer(g_EffectTimer[client]);
|
|
}
|
|
g_EffectTimer[client] = INVALID_HANDLE;
|
|
DeactivateEffect(client);
|
|
}
|
|
|
|
public Event_Spawn(Event event, const char[] name, bool dontBroadcast){
|
|
new client = CID(GetEventInt(event, "userid"));
|
|
//LogMessage("Client effect setted: %b Client currenly updating: %b", g_ClientSettedEffect[cid], g_ClientUpdatedEffect[cid]);
|
|
if (g_ClientSettedEffect[client] && !g_ClientUpdatedEffect[client]) {
|
|
/*
|
|
if (g_ClientDeactivateIfDead[client]){
|
|
LogMessage("Deactivate effect on %i client", cid);
|
|
DeactivateEffect(cid);
|
|
} else {
|
|
LogMessage("Refresh effect on %i client", cid);
|
|
RefreshEffect(cid);
|
|
}
|
|
*/
|
|
//LogMessage("Refresh effect on %i client", cid);
|
|
|
|
float time = float(g_ClientEndTime[client] - GetTime());
|
|
if (time <= 2.0){
|
|
DeactivateEffect(client);
|
|
} else {
|
|
RefreshEffect(client);
|
|
}
|
|
}
|
|
return Plugin_Continue;
|
|
}
|
|
|
|
public void OnGameFrame(){
|
|
for(int i = 1; i < MaxClients; i++){
|
|
if(IsClientInGame(i) && g_ClientShowHud[i]){
|
|
if (g_ClientEndTime[i] - GetTime() >= 0){
|
|
SetHudTextParams(-1.0, 0.45, 1, 255, 255, 255, 255);
|
|
ShowSyncHudText(i, g_hCounterHud,"%i", g_ClientEndTime[i] - GetTime());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//STOCK's FUNCTiONs
|
|
stock SecToHuman(int i_time, char[] s_time, int str_size){
|
|
int s, m;
|
|
m = i_time / 60;
|
|
s = i_time % 60;
|
|
char minutes[64];
|
|
char seconds[64];
|
|
//////////////////////////////////////////////////////////////
|
|
if (m > 10 && m < 20){
|
|
Format(minutes, sizeof(minutes), "%i минут", m);
|
|
} else {
|
|
if (m % 10 > 1 && m % 10 < 5){
|
|
Format(minutes, sizeof(minutes), "%i минуты", m);
|
|
} else {
|
|
if (m % 10 == 1){
|
|
Format(minutes, sizeof(minutes), "%i минута", m);
|
|
} else {
|
|
Format(minutes, sizeof(minutes), "%i минут", m);
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
if (s > 10 && s < 20){
|
|
Format(seconds, sizeof(seconds), "%i секунд", s);
|
|
} else {
|
|
if (s % 10 > 1 && s % 10 < 5){
|
|
Format(seconds, sizeof(seconds), "%i секунды", s);
|
|
} else {
|
|
if (s % 10 == 1){
|
|
Format(seconds, sizeof(seconds), "%i секунда", s);
|
|
} else {
|
|
Format(seconds, sizeof(seconds), "%i секунд", s);
|
|
}
|
|
}
|
|
}
|
|
//////////////////////////////////////////////////////////////
|
|
if (m > 0){
|
|
Format(s_time, str_size, "%s %s", minutes, seconds);
|
|
} else {
|
|
Format(s_time, str_size, "%s", seconds);
|
|
}
|
|
}
|
|
|
|
stock ActivateEffect(int client, const char[] name, const char[] act_cmd, const char[] deact_cmd, int time, bool reset_on_dead){
|
|
if (g_ClientSettedEffect[client]){
|
|
DeactivateEffect(client);
|
|
}
|
|
|
|
strcopy(g_ClientActivateCmd[client], 256, act_cmd);
|
|
strcopy(g_ClientDeactivateCmd[client], 256, deact_cmd);
|
|
ReplaceCmdString(client);
|
|
|
|
strcopy(g_ClientEffectName[client],256, name);
|
|
g_ClientStartTime[client] = GetTime();
|
|
if (time < 0){
|
|
g_ClientEndTime[client] = GetTime();
|
|
} else {
|
|
g_ClientEndTime[client] = GetTime() + time;
|
|
}
|
|
g_ClientDeactivateIfDead[client] = reset_on_dead;
|
|
g_ClientSettedEffect[client] = true;
|
|
RefreshEffect(client);
|
|
}
|
|
|
|
stock ReplaceCmdString(int client){
|
|
char s_uid[32];
|
|
Format(s_uid, sizeof(s_uid), "#%i", UID(client));
|
|
ReplaceString(g_ClientActivateCmd[client], 256, "%i", s_uid);
|
|
ReplaceString(g_ClientDeactivateCmd[client], 256, "%i", s_uid);
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
if (StrContains(g_ClientActivateCmd[client], "%team%") != -1){
|
|
switch (TF2_GetClientTeam(client)) {
|
|
case TFTeam_Red: ReplaceString(g_ClientActivateCmd[client], 256, "%team%", "@red");
|
|
case TFTeam_Blue: ReplaceString(g_ClientActivateCmd[client], 256, "%team%", "@blue");
|
|
default: ReplaceString(g_ClientActivateCmd[client], 256, "%team%", "");
|
|
}
|
|
}
|
|
if (StrContains(g_ClientActivateCmd[client], "%class") != -1){
|
|
switch (TF2_GetPlayerClass(client)){
|
|
case TFClass_Scout: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "scout");
|
|
case TFClass_Soldier: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "soldier");
|
|
case TFClass_Pyro: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "pyro");
|
|
case TFClass_DemoMan: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "demoman");
|
|
case TFClass_Heavy: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "heavy");
|
|
case TFClass_Engineer: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "engineer");
|
|
case TFClass_Medic: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "medic");
|
|
case TFClass_Sniper: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "sniper");
|
|
case TFClass_Spy: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "spy");
|
|
default: ReplaceString(g_ClientActivateCmd[client], 256, "%class%", "");
|
|
}
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////////////////////
|
|
if (StrContains(g_ClientDeactivateCmd[client], "%team%") != -1){
|
|
switch (TF2_GetClientTeam(client)) {
|
|
case TFTeam_Red: ReplaceString(g_ClientDeactivateCmd[client], 256, "%team%", "@red");
|
|
case TFTeam_Blue: ReplaceString(g_ClientDeactivateCmd[client], 256, "%team%", "@blue");
|
|
default: ReplaceString(g_ClientDeactivateCmd[client], 256, "%team%", "");
|
|
}
|
|
}
|
|
if (StrContains(g_ClientDeactivateCmd[client], "%class%") != -1){
|
|
switch (TF2_GetPlayerClass(client)){
|
|
case TFClass_Scout: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "scout");
|
|
case TFClass_Soldier: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "soldier");
|
|
case TFClass_Pyro: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "pyro");
|
|
case TFClass_DemoMan: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "demoman");
|
|
case TFClass_Heavy: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "heavy");
|
|
case TFClass_Engineer: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "engineer");
|
|
case TFClass_Medic: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "medic");
|
|
case TFClass_Sniper: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "sniper");
|
|
case TFClass_Spy: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "spy");
|
|
default: ReplaceString(g_ClientDeactivateCmd[client], 256, "%class%", "");
|
|
}
|
|
}
|
|
}
|
|
|
|
stock RefreshEffect(int client){
|
|
//LogMessage("Effect setted: %b, De_ondead:%b, Start: %i, End: %i",g_ClientSettedEffect[client], g_ClientDeactivateIfDead[client], g_ClientStartTime[client], g_ClientEndTime[client]);
|
|
if (g_ClientUpdatedEffect[client]){
|
|
//LogMessage("Effect currently try update...");
|
|
return;
|
|
} else {
|
|
g_ClientUpdatedEffect[client] = true;
|
|
}
|
|
if (!IsClientInGame(client) || !IsPlayerAlive(client))
|
|
{
|
|
g_ClientUpdatedEffect[client] = false;
|
|
return;
|
|
}
|
|
|
|
if (GetTime() - g_ClientLastActivate[client] >= 0.5){
|
|
if(g_EffectTimer[client] != INVALID_HANDLE){
|
|
if (g_ClientDeactivateIfDead[client]) {
|
|
TriggerTimer(g_EffectTimer[client]);
|
|
g_ClientUpdatedEffect[client] = false;
|
|
return;
|
|
}
|
|
}
|
|
ExecuteActivateCmd(client);
|
|
}/* else {
|
|
LogMessage("Ignore refresh effect on %i client", client);
|
|
}*/
|
|
|
|
if (g_ClientStartTime[client] != g_ClientEndTime[client]){
|
|
float time = float(g_ClientEndTime[client] - GetTime());
|
|
if (time <= 2){
|
|
DeactivateEffect(client);
|
|
return;
|
|
}
|
|
}
|
|
g_ClientUpdatedEffect[client] = false;
|
|
return;
|
|
}
|
|
|
|
stock ExecuteActivateCmd(int client){
|
|
g_ClientShowHud[client] = true;
|
|
g_ClientLastActivate[client] = GetTime();
|
|
if (g_ClientStartTime[client] == g_ClientEndTime[client]){
|
|
ServerCommand(g_ClientActivateCmd[client]);
|
|
PrintCenterText(client, "Наложен эффект: %s", g_ClientEffectName[client]);
|
|
LogMessage("(%L) Наложен эффект: %s", client, g_ClientEffectName[client]);
|
|
g_ClientUpdatedEffect[client] = false;
|
|
return;
|
|
} else {
|
|
float time = float(g_ClientEndTime[client] - GetTime());
|
|
if(time > 0){
|
|
ServerCommand(g_ClientActivateCmd[client]);
|
|
if (g_EffectTimer[client] == INVALID_HANDLE){
|
|
g_EffectTimer[client] = CreateTimer(time, DeactivateTimer, client, TIMER_FLAG_NO_MAPCHANGE);
|
|
}
|
|
PrintCenterText(client, "Наложен эффект:%s, длительностью %i секунд", g_ClientEffectName[client], RoundFloat(time));
|
|
LogMessage("(%L) Наложен эффект:%s, длительностью %i секунд", client, g_ClientEffectName[client], RoundFloat(time));
|
|
} else {
|
|
DeactivateEffect(client);
|
|
}
|
|
g_ClientUpdatedEffect[client] = false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
stock DeactivateEffect(int client){
|
|
if(g_EffectTimer[client] != INVALID_HANDLE) TriggerTimer(g_EffectTimer[client]);
|
|
g_ClientShowHud[client] = false;
|
|
g_ClientUpdatedEffect[client] = false;
|
|
g_ClientSettedEffect[client] = false;
|
|
strcopy(g_ClientActivateCmd[client], 256,"");
|
|
strcopy(g_ClientDeactivateCmd[client], 256, "");
|
|
strcopy(g_ClientEffectName[client], 256, "");
|
|
g_ClientStartTime[client] = 0;
|
|
g_ClientEndTime[client] = 0;
|
|
g_ClientDeactivateIfDead[client] = false;
|
|
}
|
|
|
|
// TIMERs
|
|
|
|
public Action:DeactivateTimer(Handle:timer, any:client){
|
|
g_ClientUpdatedEffect[client] = true;
|
|
ServerCommand(g_ClientDeactivateCmd[client]);
|
|
PrintCenterText(client, "Эффект: %s, был снят", g_ClientEffectName[client]);
|
|
LogMessage("(%L) Эффект: %s, был снят", client, g_ClientEffectName[client]);
|
|
DeactivateEffect(client);
|
|
g_EffectTimer[client] = INVALID_HANDLE;
|
|
return Plugin_Stop;
|
|
}
|
|
|
|
// SQL FUNCTIONs
|
|
public SQL_SetEffect(Handle:owner, Handle:hndl, const String:error[], any:data) {
|
|
int client;
|
|
if ((client = CID(data)) == 0) {
|
|
return;
|
|
}
|
|
|
|
if(g_EffectTimer[client] != INVALID_HANDLE){
|
|
TriggerTimer(g_EffectTimer[client]);
|
|
} else {
|
|
DeactivateEffect(client);
|
|
}
|
|
|
|
if (hndl == INVALID_HANDLE) {
|
|
LogError("Query failed! %s", error);
|
|
g_ClientLastUse[client] = 0;
|
|
PrintToChat(client, "Невозможно выдать рандомный эффект из-за ошибки базы данных!");
|
|
return;
|
|
} else {
|
|
g_ClientLastUse[client] = GetTime();
|
|
}
|
|
|
|
if (SQL_FetchRow(hndl)) {
|
|
char effect_name[256];
|
|
SQL_FetchString(hndl, 0, effect_name, sizeof(effect_name));
|
|
char activate_cmd[256];
|
|
SQL_FetchString(hndl, 1, activate_cmd, sizeof(activate_cmd));
|
|
char deactivate_cmd[256];
|
|
SQL_FetchString(hndl, 2, deactivate_cmd, sizeof(deactivate_cmd));
|
|
int time = SQL_FetchInt(hndl, 3);
|
|
bool de_ondead = SQL_FetchInt(hndl, 4);
|
|
bool alarm_all = SQL_FetchInt(hndl, 5);
|
|
|
|
if (alarm_all) {
|
|
PrintCenterTextAll("Игрок: %N, применил для всех эффект: %s", client, effect_name);
|
|
LogMessage("Игрок: %L, применил для всех эффект: %s", client, effect_name);
|
|
}
|
|
|
|
ActivateEffect(client, effect_name, activate_cmd, deactivate_cmd, time, de_ondead);
|
|
if (time == 0) {
|
|
DeactivateEffect(client);
|
|
}
|
|
} else {
|
|
PrintToChat(client, "Применяемый эффект не найден в базе...");
|
|
}
|
|
return;
|
|
}
|
|
|
|
// COMMAND FUNTION's
|
|
public Action:User_roll(client, args){
|
|
if (g_ClientSettedEffect[client]){
|
|
PrintToChat(client, "У тебя уже присутствует эффект: %s", g_ClientEffectName[client]);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
int timeout = GetTime() - g_ClientLastUse[client];
|
|
int cmd_timeout;
|
|
if (CheckCommandAccess(client, "sm_rtd_vip", ADMFLAG_RESERVATION, false)){
|
|
cmd_timeout = GetConVarInt(g_cmd_timeout_vip);
|
|
} else {
|
|
cmd_timeout = GetConVarInt(g_cmd_timeout);
|
|
cmd_timeout = cmd_timeout + cmd_timeout * GetClientCount(true) / 5;
|
|
}
|
|
|
|
//if (GetClientCount(true)/5 > 0){
|
|
// cmd_timeout = cmd_timeout + cmd_timeout * GetClientCount(true) / 5;
|
|
//}
|
|
|
|
if (timeout < cmd_timeout){
|
|
char s_timeout[64];
|
|
SecToHuman(cmd_timeout - timeout, s_timeout, sizeof(s_timeout));
|
|
PrintToChat(client, "Ты еще не можешь ролить рандомный эффект, подожди еще %s", s_timeout);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
PrintToChat(client, "Крутим колесо фартуны......");
|
|
SQL_TQuery(g_Database, SQL_SetEffect, g_SQL_RANDOM, UID(client));
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Admin_roll(client, args){
|
|
if (args > 2 || args == 0) {
|
|
ReplyToCommand(client, "Usage: sm_rtd_player <client>");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:buffer[64];GetCmdArg(1, buffer, sizeof(buffer));
|
|
new String:target_name[MAX_NAME_LENGTH];
|
|
new target_list[MAXPLAYERS]; new target_count; new bool:tn_is_ml;
|
|
if ((target_count = ProcessTargetString(
|
|
buffer,
|
|
client,
|
|
target_list,
|
|
MAXPLAYERS,
|
|
COMMAND_FILTER_CONNECTED,
|
|
target_name,
|
|
sizeof(target_name),
|
|
tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
if(target_count > 0){
|
|
new count = 0;
|
|
for (new i = 0; i < target_count; i ++){
|
|
if (args == 1){
|
|
SQL_TQuery(g_Database, SQL_SetEffect, g_SQL_RANDOM, UID(target_list[i]));
|
|
count++;
|
|
} else {
|
|
char SQL[256];
|
|
char strBuffer[16];
|
|
GetCmdArg(2, strBuffer, sizeof(strBuffer));
|
|
int effect_id = StringToInt(strBuffer);
|
|
Format(SQL, sizeof(SQL), "SELECT name, activate, deactivate, time, de_ondead, alarm_all FROM rtd_ultimate WHERE id LIKE %i LIMIT 1", effect_id);
|
|
SQL_TQuery(g_Database, SQL_SetEffect, SQL, UID(target_list[i]));
|
|
count++;
|
|
}
|
|
}
|
|
ReplyToCommand(client, "Было заролено %i раз", count);
|
|
return Plugin_Handled;
|
|
} else {
|
|
ReplyToCommand(client, "Не было найдено целей для использования команды...");
|
|
return Plugin_Handled;
|
|
}
|
|
}
|
|
|
|
public Action:Command_Kill(client, args){
|
|
if(args != 1){
|
|
ReplyToCommand(client, "[SM] Usage: sm_rtd_kill \"target\"");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:strBuffer[MAX_NAME_LENGTH], String:target_name[MAX_TARGET_LENGTH], target_list[MAXPLAYERS], target_count, bool:tn_is_ml;
|
|
GetCmdArg(1, strBuffer, sizeof(strBuffer));
|
|
if ((target_count = ProcessTargetString(strBuffer, client, target_list, MAXPLAYERS, COMMAND_FILTER_ALIVE, target_name, sizeof(target_name), tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
for(new i = 0; i < target_count; i++)
|
|
{
|
|
FakeClientCommand(target_list[i], "explode");
|
|
//SDKHooks_TakeDamage(target_list[i], target_list[i], target_list[i], 99999999.0);
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_Reset(client, args){
|
|
if(args != 1){
|
|
ReplyToCommand(client, "[SM] Usage: sm_rtd_reset \"target\"");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:strBuffer[MAX_NAME_LENGTH], String:target_name[MAX_TARGET_LENGTH], target_list[MAXPLAYERS], target_count, bool:tn_is_ml;
|
|
GetCmdArg(1, strBuffer, sizeof(strBuffer));
|
|
if ((target_count = ProcessTargetString(strBuffer, client, target_list, MAXPLAYERS, COMMAND_FILTER_ALIVE, target_name, sizeof(target_name), tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
int count = 0;
|
|
for(new i = 0; i < target_count; i++)
|
|
{
|
|
g_ClientLastUse[target_list[i]] = 0;
|
|
count++;
|
|
}
|
|
ReplyToCommand(client, "RTD таймер был сброшен у %i игроков", count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_AddCondition(client, args){
|
|
|
|
if(args != 3)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_rtd_addcond \"target\" \"condition number\" \"duration\"");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:strBuffer[MAX_NAME_LENGTH], String:target_name[MAX_TARGET_LENGTH], target_list[MAXPLAYERS], target_count, bool:tn_is_ml;
|
|
GetCmdArg(1, strBuffer, sizeof(strBuffer));
|
|
if ((target_count = ProcessTargetString(strBuffer, client, target_list, MAXPLAYERS, COMMAND_FILTER_ALIVE, target_name, sizeof(target_name), tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new iCondition, Float:flDuration;
|
|
|
|
GetCmdArg(2, strBuffer, sizeof(strBuffer));
|
|
iCondition = StringToInt(strBuffer);
|
|
|
|
GetCmdArg(3, strBuffer, sizeof(strBuffer));
|
|
flDuration = StringToFloat(strBuffer);
|
|
|
|
for(new i = 0; i < target_count; i++)
|
|
{
|
|
TF2_AddCondition(target_list[i], TFCond:iCondition, flDuration);
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_RemoveCondition(client, args){
|
|
|
|
if(args != 2)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_rtd_removecond \"target\" \"condition number\"");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:strBuffer[MAX_NAME_LENGTH], String:target_name[MAX_TARGET_LENGTH], target_list[MAXPLAYERS], target_count, bool:tn_is_ml;
|
|
GetCmdArg(1, strBuffer, sizeof(strBuffer));
|
|
if ((target_count = ProcessTargetString(strBuffer, client, target_list, MAXPLAYERS, COMMAND_FILTER_ALIVE, target_name, sizeof(target_name), tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new iCondition;
|
|
|
|
GetCmdArg(2, strBuffer, sizeof(strBuffer));
|
|
iCondition = StringToInt(strBuffer);
|
|
|
|
for(new i = 0; i < target_count; i++)
|
|
{
|
|
TF2_RemoveCondition(target_list[i], TFCond:iCondition);
|
|
}
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
public Action:Command_PlaySound(client, args){
|
|
if(args != 2)
|
|
{
|
|
ReplyToCommand(client, "[SM] Usage: sm_rtd_playsound \"target\" \"filepath\"");
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
new String:strBuffer[MAX_NAME_LENGTH], String:target_name[MAX_TARGET_LENGTH], target_list[MAXPLAYERS], target_count, bool:tn_is_ml;
|
|
GetCmdArg(1, strBuffer, sizeof(strBuffer));
|
|
if ((target_count = ProcessTargetString(strBuffer, client, target_list, MAXPLAYERS, COMMAND_FILTER_ALIVE, target_name, sizeof(target_name), tn_is_ml)) <= 0)
|
|
{
|
|
ReplyToTargetError(client, target_count);
|
|
return Plugin_Handled;
|
|
}
|
|
|
|
char SoundPath[256];
|
|
GetCmdArg(2, SoundPath, sizeof(SoundPath));
|
|
|
|
for(new i = 0; i < target_count; i++)
|
|
{
|
|
EmitSoundToClient(target_list[i], SoundPath);
|
|
}
|
|
return Plugin_Handled;
|
|
}
|