gsd
/
Facti13.HundredPlayers.Plugins
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

fsb

master
gsd 2 years ago
parent
3106891ad7
commit
f45696cb11
6 changed files with 800 additions and 0 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      FSB_BanSystem/README
  2. 26
      FSB_BanSystem/fsb.cfg
  3. 133
      FSB_BanSystem/fsb.sp
  4. 260
      FSB_BanSystem/modules/bans.sp
  5. 337
      FSB_BanSystem/modules/mutes.sp
  6. 43
      FSB_BanSystem/modules/steam_backend.sp

1
FSB_BanSystem/README
View File

@ -0,0 +1 @@
fsb.cfg -> tf/addons/sourcemod/configs

26
FSB_BanSystem/fsb.cfg
View File

@ -0,0 +1,26 @@
"fsb"
{
"responds"
{
"ban" "tf2.pblr-nyk.pro/unban
ТЫ В БАНЕ, РАЗБАН ЧЕРЕЗ {minutes_remain} МИНУТ !!!
ID:{banid} Причина: {reason}"
"perma_ban" "tf2.pblr-nyk.pro/unban
ТЫ В БАНЕ, НАВСЕГДА !!!
ID:{banid} Причина: {reason}"
"detect_new_client" "ХИТРАЯ РУСНЯ БЫЛА ПОЙМАНА!!!
Причиной отлючения послужило что ты подключаешься с другого аккаунта, когда на твоем другом имеется бан!"
}
"settings"
{
"table_name" "light_bans"
"bans_tablename" "light_bans"
"ban_prefix" "[Facti13.Bans]"
"localhost" "127.0.0.1"
}
"steam_backend"
{
"address" "192.168.3.3"
"port" "27100"
}
}

133
FSB_BanSystem/fsb.sp
View File

@ -0,0 +1,133 @@
#include <sourcemod>
#define _ban_module
//#define _mute_module
//#define _steam_backend
#if defined _ban_module
#include "modules/bans.sp"
#endif
#if defined _mute_module
#include "modules/mutes.sp"
#endif
#define PLUGIN_VERSION "2.0"
public Plugin:myinfo = {
name = "Facti13 System Browser",
author = "gsd",
description = "Threaded mysql control plugin",
version = PLUGIN_VERSION,
url = "https://vk.me/re1ard"
};
char g_Database_Name[32] = "sql_bans";
char g_MainChatPrefix[32] = "[FSB]"
//MAIN
public OnPluginStart() {
LoadConfig();
SetupDB();
#if defined _mute_module
MuteSetup()
#endif
RegAdminCmd("sm_fsb_reload", COMMAND_ReloadCfg, ADMFLAG_ROOT);
}
public OnPluginEnd() {
#if defined _mute_module
MuteDeSetup()
#endif
}
public OnClientAuthorized(int client) {
if(IsFakeClient(client)) {
return;
}
#if defined _ban_module
BanCheckPlayer(client);
#endif
#if defined _mute_module
MuteCheckPlayer(client);
#endif
}
public OnClientDisconnect(int client) {
#if defined _mute_module
MuteClearPlayer(client);
#endif
}
//MYSQL CALLBACK
public GotDatabase(Handle:owner, Handle:hndl, const String:error[], any:data) {
if (hndl == INVALID_HANDLE) {
LogError("%s Database Connection Error: %s", g_MainChatPrefix, error);
} else {
LogError("%s Database Connected", g_MainChatPrefix);
///////////////////////////////
#if defined _ban_module
g_hBansDatabase = hndl;
#endif
///////////////////////////////
#if defined _mute_module
g_hMuteDatabase = hndl;
#endif
}
}
//FUNCTIONS
stock void SetupDB(){
SQL_TConnect(GotDatabase, g_Database_Name);
}
stock void LoadConfig(){
char confPath[256]; BuildPath(Path_SM, confPath, sizeof(confPath), "configs/fsb.cfg");
PrintToServer("%s Loading config from file: %s", g_MainChatPrefix, confPath);
char main_kv[32] = "fsb";
KeyValues FSB_config = new KeyValues(main_kv);
/////////////////////////////////////////////////////////////////////////////////////////////
if(FSB_config.ImportFromFile(confPath)){
FSB_config.JumpToKey("responds");
#if defined _ban_module
FSB_config.GetString("ban", g_Responde_ClientInBan, sizeof(g_Responde_ClientInBan));
FSB_config.GetString("perma_ban", g_Responde_ClientInPermaBan, sizeof(g_Responde_ClientInPermaBan));
FSB_config.GetString("detect_new_client", g_Responde_DetectNewClient, sizeof(g_Responde_DetectNewClient));
#endif
FSB_config.Rewind();
/////////////////////////
FSB_config.JumpToKey("settings");
#if defined _ban_module
FSB_config.GetString("bans_tablename", g_BansTableName, sizeof(g_BansTableName));
FSB_config.GetString("ban_prefix", g_BansChatPrefix, sizeof(g_BansChatPrefix));
FSB_config.GetString("localhost", g_LocalhostIP, sizeof(g_LocalhostIP));
#endif
FSB_config.Rewind();
/////////////////////////
#if defined _steam_backend
char address[64]; int port;
FSB_config.JumpToKey("steam_backend");
FSB_config.GetString("address", address, sizeof(address));
port = FSB_config.GetNum("port")
SetupBackend(address, port);
#endif
//FSB_config.GetString("mute_tablename", g_MuteTableName, sizeof(g_MuteTableName));
PrintToServer("%s Success load config!", g_MainChatPrefix);
}
}
//ACTIONS
public Action:COMMAND_ReloadCfg(int cid, int args){
LoadConfig();
if (cid == 0){
PrintToServer("%s Конфигурация была перезагружена.", g_MainChatPrefix);
} else {
PrintToChat(cid, "%s Конфигурация была перезагружена.", g_MainChatPrefix);
}
return Plugin_Handled;
}

260
FSB_BanSystem/modules/bans.sp
View File

@ -0,0 +1,260 @@
#include <sourcemod>
#if defined _steam_backend
#include "steam_backend.sp"
#endif
//MYSQL QUERYS
char g_SQL_QUERY_UNBAN[512] = "UPDATE %s SET active = '0', unbanned_by_id = '%s', unbanned_timestamp = CURRENT_TIMESTAMP WHERE id = %i";
char g_SQL_QUERY_DETECT_NEW_BAN[512] = "INSERT INTO %s (player_name, steam_id, account_id, ban_length, ban_reason, banned_by, banned_by_id, ip, timestamp, active) VALUES ('%s','%s','%d','%d','%s','SERVER','STEAM_0:0:63666481','%s',CURRENT_TIMESTAMP, '1')";
char g_SQL_QUERY_SEARCH_BAN[512] = "SELECT ban_length*60, ban_reason, UNIX_TIMESTAMP(timestamp), steam_id, ip, player_name, id, active FROM %s WHERE active = '1' and steam_id = '%s' OR active = '1' and ip = '%s' ORDER BY `id` DESC";
char g_SQL_QUERY_SEARCH_BAN_WITHOUT_IP[512] = "SELECT ban_length*60, ban_reason, UNIX_TIMESTAMP(timestamp), steam_id, ip, player_name, id, active FROM %s WHERE active = '1' and steam_id = '%s' ORDER BY `id` DESC";
char g_SQL_QUERY_NEW_BAN[512] = "INSERT INTO %s (player_name, steam_id, account_id, ban_length, ban_reason, banned_by, banned_by_id, ip, timestamp) VALUES ('%s','%s','%d','%d','%s','%s','%s','%s',CURRENT_TIMESTAMP)";
//RESPONDES
char g_Responde_ClientInBan[256] = "You banned on this server!\nTime remain: {minutes_remain}";
char g_Responde_ClientInPermaBan[256] = "You perma banned on this server!";
char g_Responde_DetectNewClient[256] = "You use new account on banned IP";
//CONST
char g_LocalhostIP[15] = "127.0.0.1";
char g_BansChatPrefix[16] = "[FSB.Bans]";
char g_BansTableName[32] = "bans_tablename";
Handle g_hBansDatabase = INVALID_HANDLE;
bool g_ipCheckNewAccount = false;
//FUNCTIONS
stock void BanCheckPlayer(int client){
char Query[512], client_ip[15], client_auth[32];
GetClientIP(client, client_ip, sizeof(client_ip));
GetClientAuthId(client, AuthId_Steam2, client_auth, sizeof(client_auth));
Format(Query, sizeof(Query), g_SQL_QUERY_SEARCH_BAN, g_BansTableName, client_auth, client_ip);
SQL_TQuery(g_hBansDatabase, Callback_BanCheck, Query, GetClientUserId(client));
return;
}
//MYSQL
public DB_Processing(Handle:owner, Handle:hndl, const String:error[], any:data) {
if (hndl == INVALID_HANDLE) {
LogError("%s Query failed! %s", g_BansChatPrefix, error);
}
return;
}
stock bool BansTable_VerifyTable(const char[] database_name, const char[] table_name){
char error[255], query[2048];
new db = SQL_Connect(database_name, true, error, sizeof(error));
if (db == INVALID_HANDLE) {
LogError("%s Cannot connect to Database: %s", g_BansChatPrefix, database_name);
return false;
}
Format(query, sizeof(query), "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
"CREATE TABLE IF NOT EXISTS `",
g_BansTableName,
"` (",
" `id` int(11) NOT NULL,",
" `steam_id` varchar(32) NOT NULL,",
" `account_id` bigint(20) NOT NULL,",
" `player_name` varchar(65) NOT NULL,",
" `ban_length` int(1) NOT NULL DEFAULT 0,",
" `ban_reason` varchar(100) NOT NULL,",
" `banned_by` varchar(100) NOT NULL,",
" `banned_by_id` varchar(32) NOT NULL,",
" `ip` varchar(15) NOT NULL,",
" `timestamp` timestamp NOT NULL DEFAULT current_timestamp(),",
" `active` tinyint(1) NOT NULL DEFAULT 1,",
" `unbanned_by_id` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci DEFAULT NULL,",
" `unbanned_timestamp` timestamp NULL DEFAULT NULL",
" PRIMARY KEY (`id`)",
" ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 AUTO_INCREMENT=1;");
bool success = SQL_FastQuery(db, query);
if(!success) {
SQL_GetError(db, error, sizeof(error));
LogError("%s [ERROR] Unable to verify mysql_bans table:%s", g_BansChatPrefix, query);
LogError("%s [ERROR] %s", g_BansChatPrefix, error);
}
CloseHandle(db);
return true;
}
//MYSQL CALLBACKS
public Callback_BanCheck(Handle:owner, Handle:hndl, const String:error[], any:data) {
int client;
if ((client = GetClientOfUserId(data)) == 0) {
return;
}
if (hndl == INVALID_HANDLE) {
LogError("%s Query failed! %s", g_BansChatPrefix, error);
char lKickReason[256] = "DB ERROR";
//GetConVarString(cvKickReasonIfQueryFailed, lKickReason, 256);
///////////////////////////////////////
#if defined _steam_backend
KickClient_WithBackendMessage(client, lKickReason);
#else
KickClient(client, lKickReason);
#endif
///////////////////////////////////////
return;
}
if (SQL_FetchRow(hndl)) {
char Query[512];
/////////////////////////////////////////////////////////////////////////
char cl_PlayerName[64];
GetClientName(client, cl_PlayerName, sizeof(cl_PlayerName));
char cl_SteamID[32];
GetClientAuthId(client, AuthId_Steam2, cl_SteamID, sizeof(cl_SteamID));
char cl_IP[15];
GetClientIP(client, cl_IP, sizeof(cl_IP));
//Get VARS from DB
int db_BanLength = SQL_FetchInt(hndl, 0);
char db_BanReason[256]; SQL_FetchString(hndl, 1, db_BanReason, 256);
int db_BanRemaining = db_BanLength - (GetTime() - SQL_FetchInt(hndl, 2));
char db_SteamID[32]; SQL_FetchString(hndl, 3, db_SteamID, 32);
char db_IP[15]; SQL_FetchString(hndl, 4, db_IP, 15);
int db_BanID = SQL_FetchInt(hndl, 6);
//PrintToServer("Time Remaining: %d sec", db_BanRemaining);
//Check Ban is done if not perma
if (db_BanLength != 0) {
if (db_BanRemaining <= 0) {
Format(Query, sizeof(Query), g_SQL_QUERY_UNBAN, g_BansTableName, "STEAM_0:0:0", db_BanID);
SQL_TQuery(g_hBansDatabase, DB_Processing, Query);
LogMessage("User %s(%s) has been unbanned by elapse of time: %d seconds", cl_PlayerName, cl_SteamID, db_BanRemaining);
return;
}
}
//Check if client conncted from other steam, use old IP
//DONT CHECKING NEW ACCOUNT ALREADY IN DB OR NOT!!!!!!!!
char kick_reason[256];
if (g_ipCheckNewAccount && !StrEqual(g_LocalhostIP,db_IP) && !StrEqual(cl_SteamID, db_SteamID) && StrEqual(cl_IP, db_IP)) {
int cl_AccountID = GetSteamAccountID(client, true);
char db_PlayerName[64];
SQL_FetchString(hndl, 5, db_PlayerName, sizeof(db_PlayerName));
//LogMessage("%s(%s) new account, other banned account %s(%s), have equal IP Addresses. Ban new account perma.", cl_PlayerName, cl_SteamID, db_PlayerName, db_SteamID);
char es_PlayerName[64];
SQL_EscapeString(g_hBansDatabase, cl_PlayerName, es_PlayerName, sizeof(es_PlayerName));
char cl_BanReason[256];
Format(cl_BanReason, sizeof(cl_BanReason), "Use new account, other account(%s) is banned", db_SteamID);
char es_BanReason[256];
SQL_EscapeString(g_hBansDatabase, cl_BanReason, es_BanReason, sizeof(es_BanReason));
Format(Query, sizeof(Query), g_SQL_QUERY_DETECT_NEW_BAN, g_BansTableName, es_PlayerName, cl_SteamID, cl_AccountID, 0, es_BanReason, cl_IP);
//LogMessage(Query);
SQL_TQuery(g_hBansDatabase, DB_Processing, Query);
Format(kick_reason, sizeof(kick_reason), g_Responde_DetectNewClient);
}
//
if (db_BanLength == 0) {
Format(kick_reason, sizeof(kick_reason), g_Responde_ClientInPermaBan);
} else {
Format(kick_reason, sizeof(kick_reason), g_Responde_ClientInBan);
}
///////////////////////////////////////
if (StrContains(kick_reason, "{reason}") != 0){
ReplaceString(kick_reason, sizeof(kick_reason), "{reason}", db_BanReason);
}
if (StrContains(kick_reason, "{minutes_remain}") != 0){
char s_time[16];
IntToString(db_BanRemaining / 60, s_time, sizeof(s_time));
ReplaceString(kick_reason, sizeof(kick_reason), "{minutes_remain}", s_time);
}
if (StrContains(kick_reason, "{banid}") != 0){
char banid[16];
IntToString(db_BanID, banid, sizeof(banid));
ReplaceString(kick_reason, sizeof(kick_reason), "{banid}", banid);
}
///////////////////////////////////////
#if defined _steam_backend
KickClient_WithBackendMessage(client, kick_reason);
#else
KickClient(client, kick_reason);
#endif
///////////////////////////////////////
return;
}
else {
return;
}
}
public Callback_SearchAndUnban(Handle:owner, Handle:hndl, const String:error[], any:data) {
int admin;
if ((admin = GetClientOfUserId(data)) == 0) {
return;
}
if (hndl == INVALID_HANDLE) {
LogError("Query failed! %s", error);
return;
}
if (SQL_FetchRow(hndl)) {
char Query[1024], admin_steam[32];
GetClientAuthId(admin, AuthId_Steam2, admin_steam, sizeof(admin_steam));
int db_BanID = SQL_FetchInt(hndl, 6);
Format(Query, sizeof(Query), g_SQL_QUERY_UNBAN, g_BansTableName, admin_steam, db_BanID);
SQL_TQuery(g_hBansDatabase, Callback_Unban, Query, GetClientUserId(admin));
} else {
ReplyToCommand(admin, "%s Karlik not found in bans...", g_BansChatPrefix);
}
return;
}
public Callback_Unban(Handle:owner, Handle:hndl, const String:error[], any:data) {
int admin;
if ((admin = GetClientOfUserId(data)) == 0) {
return;
}
if (hndl == INVALID_HANDLE) {
LogError("Query failed! %s", error);
return;
}
if(SQL_HasResultSet(hndl)) {
ReplyToCommand(admin, "%s Karlik unbanned", g_BansChatPrefix);
} else {
ReplyToCommand(admin, "%s Karlik not found in bans...", g_BansChatPrefix);
}
return;
}
//ACTIONS
public Action:OnBanClient(int client, int time, int flags, const String:reason[], const String:kick_message[], const String:command[], any:admin) {
char Query[512];
char QueryPayload[11][256];
/* 0/5 - Client SteamID
1/6 - Admin SteamID
2/7 - Client Name
3/8 - Admin Name
4/9 - Client IP
10 - Ban Reason */
GetClientAuthId(client, AuthId_Steam2, QueryPayload[0], sizeof(QueryPayload[]));
GetClientAuthId(admin, AuthId_Steam2, QueryPayload[1], sizeof(QueryPayload[]));
GetClientName(client, QueryPayload[2], sizeof(QueryPayload[]));
GetClientName(admin, QueryPayload[3], sizeof(QueryPayload[]));
GetClientIP(client,QueryPayload[4], sizeof(QueryPayload[]));
for (new i = 0; i < 5; i++) {
SQL_EscapeString(g_hBansDatabase, QueryPayload[i], QueryPayload[5+i], 256);
}
SQL_EscapeString(g_hBansDatabase, reason, QueryPayload[10], 256);
int cl_AccountID = GetSteamAccountID(client, true);
Format(Query, sizeof(Query), g_SQL_QUERY_NEW_BAN, g_BansTableName, QueryPayload[7], QueryPayload[5], cl_AccountID, time, QueryPayload[10], QueryPayload[8], QueryPayload[6], QueryPayload[9]);
SQL_TQuery(g_hBansDatabase, Callback_BanCheck, Query, GetClientOfUserId(admin));
return Plugin_Stop;
}
public Action:OnRemoveBan(const String:steam_id[], flags, const String:command[], any:admin) {
char Query[512];
Format(Query, sizeof(Query), g_SQL_QUERY_SEARCH_BAN_WITHOUT_IP, g_BansTableName, steam_id);
SQL_TQuery(g_hBansDatabase, Callback_SearchAndUnban, Query, GetClientOfUserId(admin));
return Plugin_Stop;
}

337
FSB_BanSystem/modules/mutes.sp
View File

@ -0,0 +1,337 @@
#include <sourcemod>
#include <sdktools_voice>
enum MUTE_SQL_SLOTS {
MUTE_SQL_SLOT_ID = 0,
MUTE_SQL_SLOT_STEAM_ID,
MUTE_SQL_SLOT_PLAYER_NAME,
MUTE_SQL_SLOT_MUTE_LENGTH,
MUTE_SQL_SLOT_MUTE_REASON,
MUTE_SQL_SLOT_MUTE_BY,
MUTE_SQL_SLOT_MUTE_BY_ID,
MUTE_SQL_SLOT_TIMESTAMP,
MUTE_SQL_SLOT_ACTIVE,
MUTE_SQL_SLOT_UNMUTE_TIMESTAMP,
MUTE_SQL_SLOT_UNMUTE_BY_ID,
MUTE_SQL_SLOT_TIMESTAMP_UNIX
}
enum struct player_settings {
bool muted;
int muted_time;
int last_ping;
}
player_settings g_MutePlayers[MAXPLAYERS];
//MYSQL QUERYS
char g_SQL_QUERY_SEARCH_MUTE[512] = "SELECT *, UNIX_TIMESTAMP(timestamp) FROM %s WHERE active = '1' AND steam_id = '%s' ORDER BY `id` DESC";
char g_SQL_QUERY_MUTE[512] = "INSERT INTO %s (steam_id, player_name, mute_length, mute_reason, mute_by, mute_by_id, timestamp) VALUES ('%s','%s','%i','%s','%s','%s',CURRENT_TIMESTAMP)";
char g_SQL_QUERY_UNMUTE[512] = "UPDATE %s SET active = '0', unmute_by_id = '%s', unmute_timestamp = CURRENT_TIMESTAMP WHERE id = %i";
//CONST
int g_ping_in_seconds = 300;
char g_MuteChatPrefix[16] = "[FSB.Mutes]";
char g_MuteTableName[32] = "light_mutes";
Handle g_hMuteDatabase = INVALID_HANDLE;
Handle g_MuteTimer = INVALID_HANDLE;
//FUNCTIONS
stock void MuteSetup(){
RegConsoleCmd("sm_fsb_mutecheck", MuteSelfStatus);
RegAdminCmd("sm_fsb_mute", MuteAddCmd, ADMFLAG_ROOT);
RegAdminCmd("sm_fsb_unmute", MuteRemoveCmd, ADMFLAG_ROOT);
if(g_MuteTimer != INVALID_HANDLE) KillTimer(g_MuteTimer);
g_MuteTimer = CreateTimer(1.0, MuteTimerCallback, _, TIMER_REPEAT|TIMER_FLAG_NO_MAPCHANGE)
}
stock void MuteDeSetup(){
if(g_MuteTimer != INVALID_HANDLE) KillTimer(g_MuteTimer);
}
stock void MuteSetPlayer(int client, int mute_end){
g_MutePlayers[client].muted = true;
g_MutePlayers[client].muted_time = mute_end;
g_MutePlayers[client].last_ping = 0;
SetClientListeningFlags(client, VOICE_MUTED);
LogMessage("%L now muted", client);
}
stock void MuteClearPlayer(int client, bool broadcast = false){
g_MutePlayers[client].muted = false;
g_MutePlayers[client].muted_time = 0;
g_MutePlayers[client].last_ping = 0;
SetClientListeningFlags(client, VOICE_LISTENALL);
if(broadcast) PrintToChat(client, "У тебя включен микрофон");
}
stock void MuteCheckPlayer(int client){
char Query[1024], client_auth[32];
GetClientAuthId(client, AuthId_Steam2, client_auth, sizeof(client_auth));
Format(Query, sizeof(Query), g_SQL_QUERY_SEARCH_MUTE, g_MuteTableName, client_auth);
SQL_TQuery(g_hMuteDatabase, Callback_MuteCheck, Query, GetClientUserId(client));
return;
}
stock void SecondsToHuman(int seconds, char[] human, int human_size){
if(seconds > 60){
int minutes = seconds / 60;
int seconds = seconds % 60;
if(minutes > 60){
int hours = minutes / 60;
int minutes = minutes % 60;
if(hours > 24){
int days = hours / 24;
int hours = hours % 24;
Format(human, human_size, "%i дней %i часов %i минут %i секунд", days, hours, minutes, seconds);
} else {
Format(human, human_size, "%i часов %i минут %i секунд", hours, minutes, seconds);
}
} else {
Format(human, human_size, "%i минут %i секунд", minutes, seconds);
}
} else {
Format(human, human_size, "%i секунд", seconds);
}
}
stock void MuteAddToDB(int client, int length, const char[] mute_reason, const char[] mute_by_id = "STEAM_0:0:0"){
if(g_MutePlayers[client].muted) return;
MuteSetPlayer(client, GetTime()+length);
char steam_id[32], player_name[65];
GetClientAuthId(client, AuthId_Steam2, steam_id, sizeof(steam_id));
GetClientName(client, player_name, sizeof(player_name));
char query[1024];
Format(query, sizeof(query), g_SQL_QUERY_MUTE, g_MuteTableName, steam_id, player_name, length, mute_reason, "console", mute_by_id);
SQL_TQuery(g_hMuteDatabase, DB_MuteProcessing, query, GetClientUserId(client));
return;
}
stock void MuteRemoveFromDB(int admin, const char[] steam_id){
char query[1024];
Format(query, sizeof(query), g_SQL_QUERY_SEARCH_MUTE, g_MuteTableName, steam_id);
SQL_TQuery(g_hMuteDatabase, Callback_MuteUnMute, query, GetClientUserId(admin));
ReplyToCommand(admin, "Try found %s on DB and unmute", steam_id);
return;
}
stock bool MuteOnServerCheck(const char[] steam_id){
char auth[32];
for (int client = 1; client <= MaxClients; client++){
if(g_MutePlayers[client].muted){
GetClientAuthId(client, AuthId_Steam2, auth, sizeof(auth));
if(strcmp(steam_id, auth) == 0){
MuteClearPlayer(client, true);
return true;
}
auth[0] = '\0';
}
}
}
stock MuteUserCheck(int client) {
if(!g_MutePlayers[client].muted) return;
bool ping_client = false;
if(GetTime() - g_MutePlayers[client].last_ping > g_ping_in_seconds){
g_MutePlayers[client].last_ping = GetTime();
ping_client = true;
}
if(g_MutePlayers[client].muted_time > 0) {
if(GetTime() > g_MutePlayers[client].muted_time){
MuteCheckPlayer(client);
return;
} else {
if(ping_client){
int mute_range = g_MutePlayers[client].muted_time - GetTime();
char human_time[128];
SecondsToHuman(mute_range, human_time, sizeof(human_time));
PrintToChat(client, "У тебя выключен микрофон на %s", human_time);
//ShowSyncHudText(client, g_MuteHUD, "У тебя выключен микрофон на %s", human_time);
}
return;
}
} else {
if(ping_client) PrintToChat(client, "У тебя выключен микрофон навсегда!");
return;
}
}
//TIMERS
public Action MuteTimerCallback(Handle timer){
for (int client = 1; client <= MaxClients; client++){
MuteUserCheck(client);
}
}
//LISTENERS
/*
public Action VoiceTransmit(int client, const char[] command, int args){
if(!g_MutePlayers[client].muted) return Plugin_Continue;
if(g_MutePlayers[client].muted_time > 0) {
if(GetTime() > g_MutePlayers[client].muted_time){
MuteCheckPlayer(client);
return Plugin_Continue;
} else {
int mute_range = g_MutePlayers[client].muted_time - GetTime();
SetHudTextParams(-1.0, 0.55, 1.0, GetRandomInt(0, 255), GetRandomInt(0, 255), GetRandomInt(0, 255), 255);
char human_time[128];
SecondsToHuman(mute_range, human_time, sizeof(human_time));
ShowSyncHudText(client, g_MuteHUD, "У тебя выключен микрофон на %s", human_time);
return Plugin_Stop;
}
} else {
ShowSyncHudText(client, g_MuteHUD, "У тебя выключен микрофон навсегда!");
return Plugin_Stop;
}
}
*/
//MYSQL
public DB_MuteProcessing(Handle:owner, Handle:hndl, const String:error[], any:data) {
if (hndl == INVALID_HANDLE) {
LogError("%s Query failed! %s", g_MuteChatPrefix, error);
}
return;
}
//MYSQL CALLBACKS
public Callback_MuteCheck(Handle:owner, Handle:hndl, const String:error[], any:data) {
int client;
if ((client = GetClientOfUserId(data)) == 0) {
return;
}
if (hndl == INVALID_HANDLE) {
LogError("%s Query failed! %s", g_MuteChatPrefix, error);
return;
}
if (SQL_FetchRow(hndl)) {
int length = SQL_FetchInt(hndl, MUTE_SQL_SLOT_MUTE_LENGTH);
if(length > 0){
int mute_end = SQL_FetchInt(hndl, MUTE_SQL_SLOT_TIMESTAMP_UNIX) + length;
if (GetTime() > mute_end){
MuteClearPlayer(client);
char Query[1024];
int mute_id = SQL_FetchInt(hndl, MUTE_SQL_SLOT_ID);
Format(Query, sizeof(Query), g_SQL_QUERY_UNMUTE, g_MuteTableName, "STEAM_0:0:0", mute_id);
SQL_TQuery(g_hMuteDatabase, DB_MuteProcessing, Query);
LogMessage("%s Player: %L unmuted by elapse of time: %i seconds", g_MuteChatPrefix, client, GetTime() - mute_end);
return;
} else {
MuteSetPlayer(client, mute_end);
}
} else {
MuteSetPlayer(client, 0);
}
} else {
MuteClearPlayer(client);
return;
}
}
public Callback_MuteUnMute(Handle:owner, Handle:hndl, const String:error[], any:data) {
int client;
if ((client = GetClientOfUserId(data)) == 0) {
return;
}
if (hndl == INVALID_HANDLE) {
LogError("%s Query failed! %s", g_MuteChatPrefix, error);
return;
}
if (SQL_FetchRow(hndl)) {
char query[1024];
int mute_id = SQL_FetchInt(hndl, MUTE_SQL_SLOT_ID);
char steam_id[32];
SQL_FetchString(hndl, MUTE_SQL_SLOT_STEAM_ID, steam_id, sizeof(steam_id));
MuteOnServerCheck(steam_id);
char admin_auth[32];
if(client == 0) admin_auth = "STEAM_0:0:0";
else GetClientAuthId(client, AuthId_Steam2, admin_auth, sizeof(admin_auth));
Format(query, sizeof(query), g_SQL_QUERY_UNMUTE, g_MuteTableName, admin_auth, mute_id);
SQL_TQuery(g_hMuteDatabase, DB_MuteProcessing, query);
LogMessage("%s Player: %L unmuted by command", g_MuteChatPrefix, client);
ReplyToCommand(client, "SteamID now unmuted!");
return;
} else {
ReplyToCommand(client, "SteamID not found");
return;
}
}
//COMMANDS
public Action MuteAddCmd(int client, int args){
if(args != 3){
ReplyToCommand(client, "[SM] Usage: sm_fsb_mute \"target\" \"seconds\"\"reason\"");
return Plugin_Handled;
}
char arg_target[MAX_TARGET_LENGTH], target_name[MAX_TARGET_LENGTH];
int target_count, target_list[MAXPLAYERS];
bool tn_is_ml;
GetCmdArg(1, arg_target, sizeof(arg_target));
if((target_count = ProcessTargetString(arg_target, client, target_list, MAXPLAYERS, 0, target_name, sizeof(target_name), tn_is_ml)) <= 0){
ReplyToCommand(client, "Cannot mute, none targets found!");
return Plugin_Handled;
}
char arg_length[32]; int length;
GetCmdArg(2, arg_length, sizeof(arg_length));
length = StringToInt(arg_length);
char reason[64];
GetCmdArg(3, reason, sizeof(reason));
char admin_auth[32];
if (client == 0) admin_auth = "STEAM_0:0:0";
else GetClientAuthId(client, AuthId_Steam2, admin_auth, sizeof(admin_auth));
for(int i = 0; i < target_count; i++){
MuteAddToDB(target_list[i], length, reason, admin_auth);
}
ReplyToCommand(client, "Targeted on %i clients", target_count);
return Plugin_Handled;
}
public Action MuteRemoveCmd(int client, int args){
if(args == 0){
ReplyToCommand(client, "[SM] Usage: sm_fsb_unmute \"steam_id\" ");
return Plugin_Handled;
}
char steam_id[32];
GetCmdArgString(steam_id, sizeof(steam_id));
MuteRemoveFromDB(client, steam_id);
return Plugin_Handled;
}
public Action MuteSelfStatus(int client, int args){
if(g_MutePlayers[client].muted){
if(g_MutePlayers[client].muted_time){
char human_time[256];
SecondsToHuman(g_MutePlayers[client].muted_time - GetTime(), human_time, sizeof(human_time));
ReplyToCommand(client, "Ты в муте! Кончается: %s", human_time);
} else {
ReplyToCommand(client, "Ты в муте! НАВСЕГДА");
}
} else {
ReplyToCommand(client, "Ты НЕ в муте!");
}
return Plugin_Handled;
}

43
FSB_BanSystem/modules/steam_backend.sp
View File

@ -0,0 +1,43 @@
#include <sourcemod>
#include <ripext>
new HTTPClient:hSteamClient = INVALID_HANDLE;
stock void SetupBackend(const char[] address, int port, bool https=false){
if(hSteamClient != INVALID_HANDLE) CloseHandle(hSteamClient);
char url[256];
if(https){
Format(url, sizeof(url), "https://%s:%i", address, port);
} else {
Format(url, sizeof(url), "http://%s:%i", address, port);
}
PrintToServer("[SteamBackend] Setup backend on: %s", url);
hSteamClient = new HTTPClient(url);
return;
}
stock void KickClient_WithBackendMessage(int client, const char[] reason){
char auth[32];
GetClientAuthId(client, AuthId_Steam2, auth, sizeof(auth));
//////////////////////////
KickClient(client, reason);
//////////////////////////
if(hSteamClient == INVALID_HANDLE) return;
//////////////////////////
char url[256];
Format(url, 256, "show_ban/%s", auth);
hSteamClient.Get(url, SteamClient_Callback);
return;
}
static void SteamClient_Callback(HTTPResponse response, any value){
if (response.Status > 200 && response.Status < 210){
return;
} else {
PrintToServer("Failed response! Code: %i", response.Status);
return;
}
}
Write Preview
Loading…
Cancel
Save