· 8 years ago · Dec 29, 2017, 11:52 AM
1#pragma semicolon 1
2#include <sourcemod>
3#include <sdktools>
4#include <adminmenu>
5
6#undef REQUIRE_PLUGIN
7#include <sourcebans>
8#undef REQUIRE_EXTENSIONS
9#define REQUIRE_EXTENSIONS
10#define REQUIRE_PLUGIN
11
12
13#define PLUGIN_VERSION "1.2.0"
14
15// Handles
16new Handle:hDatabase = INVALID_HANDLE;
17new Handle:DHhostname = INVALID_HANDLE;
18new Handle:hAdminMenu = INVALID_HANDLE;
19
20// Chaos up here, fuck that
21new Handle:g_cVar_maxwarns = INVALID_HANDLE;
22new Handle:g_cVar_max_punishment = INVALID_HANDLE;
23new Handle:g_cVar_banlength = INVALID_HANDLE;
24new Handle:g_cVar_punishment = INVALID_HANDLE;
25new Handle:g_cVar_slapdamage = INVALID_HANDLE;
26new Handle:g_cVar_PrintToAdmins = INVALID_HANDLE;
27new Handle:g_cVar_LogWarnings = INVALID_HANDLE;
28new Handle:g_cVar_warnsound = INVALID_HANDLE;
29new Handle:g_cVar_warnsoundPath = INVALID_HANDLE;
30new Handle:g_cVar_motdpanel = INVALID_HANDLE;
31new Handle:g_cVar_warnpaneltitel = INVALID_HANDLE;
32new Handle:g_cVar_warnpanelurl = INVALID_HANDLE;
33new Handle:g_cVar_reset_warnings = INVALID_HANDLE;
34
35// Bools
36new bool:g_UseSourcebans = false;
37
38new g_target[MAXPLAYERS+1];
39
40// Paths
41new String:pathwarn[PLATFORM_MAX_PATH];
42new String:pathunwarn[PLATFORM_MAX_PATH];
43new String:pathresetwarn[PLATFORM_MAX_PATH];
44new String:pathagree[PLATFORM_MAX_PATH];
45
46// Store info for natives
47new g_iWarnings[MAXPLAYERS+1] = -1;
48
49public Plugin:myinfo =
50{
51 name = "SM warn",
52 author = "ecca",
53 description = "Warn players when they are doing something wrong.",
54 version = PLUGIN_VERSION,
55 url = ""
56};
57
58public OnPluginStart()
59{
60 // Translations
61 LoadTranslations("common.phrases");
62 LoadTranslations("warn.phrases");
63
64 // ConVars
65 CreateConVar("sm_warn_version", PLUGIN_VERSION, "SM_warn plugin version", FCVAR_PLUGIN|FCVAR_SPONLY|FCVAR_REPLICATED|FCVAR_NOTIFY|FCVAR_DONTRECORD);
66
67 // Core cVars
68 g_cVar_reset_warnings = CreateConVar("sm_warn_reset_warnings", "0", "Reset warnings when they reach the max warnings: 0 - Keep warnings, 1 - Delete warnings", FCVAR_PLUGIN, true, 0.0, true, 1.0);
69
70 // Punishment cVars
71 g_cVar_maxwarns = CreateConVar("sm_warn_maxwarns", "3", "Set max warnings reached before action", FCVAR_PLUGIN, true, 1.0, true, 10.0); // Man i dont wanna create a own category for you.. :P
72 g_cVar_punishment = CreateConVar("sm_warn_punishment", "2", "Action to set when a player gets a warning: 1 - message player, 2 - slap player and message, 3 - slay player and message, 4 - Popup agreement and message, 5 - kick player with reason, 6 - ban player with reason", FCVAR_PLUGIN, true, 1.0, true, 6.0);
73 g_cVar_max_punishment = CreateConVar("sm_warn_max_punishment", "1", "Action to set when a player reach max warnings: 1 - kick, 2 - ban", FCVAR_PLUGIN, true, 1.0, true, 2.0);
74 g_cVar_banlength = CreateConVar("sm_warn_banlength", "1", "Time to ban target: 0 - permanent", FCVAR_PLUGIN);
75 g_cVar_slapdamage = CreateConVar("sm_warn_slapdamage", "0", "Slap player with damage: 0 - no damage", FCVAR_PLUGIN, true, 0.0, true, 100.0);
76
77 // Sound cVars
78 g_cVar_warnsound = CreateConVar("sm_warn_warnsound", "0", "Play a sound when a user receives a warning: 0 - disabled, 1 - enabled", FCVAR_PLUGIN, true, 0.0, true, 1.0);
79 g_cVar_warnsoundPath = CreateConVar("sm_warn_warnsoundpath", "buttons/weapon_cant_buy.wav", "Path to the sound that will play when a user receives a warning", FCVAR_PLUGIN);
80
81 // Motd panel cVars
82 g_cVar_motdpanel = CreateConVar("sm_warn_motdpanel", "0", "Show a motd panel to client on warn: 0 - disabled, 1 - enabled", FCVAR_PLUGIN, true, 0.0, true, 1.0);
83 g_cVar_warnpaneltitel = CreateConVar("sm_warn_motdpaneltitel", "SM warn panel titel", "Titel of the motd page that will popup", FCVAR_PLUGIN);
84 g_cVar_warnpanelurl = CreateConVar("sm_warn_motdpanelurl", "", "Path to the motd panel that will popup", FCVAR_PLUGIN);
85
86 // other cVars
87 g_cVar_PrintToAdmins = CreateConVar("sm_warn_printtoadmins", "1", "Print previous warnings on connect to admins: 0 - disabled, 1 - enabled", FCVAR_PLUGIN, true, 0.0, true, 1.0);
88 g_cVar_LogWarnings = CreateConVar("sm_warn_logwarnings", "1", "Log the admin commands: 0 - disabled, 1 - enabled", FCVAR_PLUGIN, true, 0.0, true, 1.0);
89
90 AutoExecConfig(true, "SM_warn");
91
92 // Commands
93 RegAdminCmd("sm_warn", Command_WarnPlayer, ADMFLAG_BAN);
94 RegAdminCmd("sm_unwarn", Command_UnWarnPlayer, ADMFLAG_BAN);
95 RegAdminCmd("sm_checkwarn", Command_CheckWarnPlayer, ADMFLAG_BAN);
96 RegAdminCmd("sm_resetwarn", Command_WarnReset, ADMFLAG_BAN);
97
98 // Build paths
99 BuildPath(Path_SM, pathwarn, sizeof(pathwarn), "configs/sm_warn_reasons.cfg");
100 BuildPath(Path_SM, pathunwarn, sizeof(pathunwarn), "configs/sm_unwarn_reasons.cfg");
101 BuildPath(Path_SM, pathresetwarn, sizeof(pathresetwarn), "configs/sm_resetwarn_reasons.cfg");
102 BuildPath(Path_SM, pathagree, sizeof(pathagree), "configs/sm_warn_agreement.cfg");
103
104 // Initialize database
105 SetupDatabase();
106
107 // Find hostname yarrr
108 DHhostname = FindConVar("hostname");
109
110 // Setup admin menu
111 new Handle:topmenu;
112
113 if (LibraryExists("adminmenu") && ((topmenu = GetAdminTopMenu()) != INVALID_HANDLE))
114 {
115 OnAdminMenuReady(topmenu);
116 }
117}
118
119public APLRes:AskPluginLoad2(Handle:myself, bool:late, String:error[], err_max)
120{
121 // Warn natives
122 CreateNative("smwarn_warn", Native_WarnPlayer);
123 CreateNative("smwarn_unwarn", Native_UnWarnPlayer);
124 CreateNative("smwarn_resetwarn", Native_ResetWarnPlayer);
125 CreateNative("smwarn_getwarns", Native_GetActiveWarnings);
126
127 // Not everyone is using sourcebans are they, or do theY ?????
128 MarkNativeAsOptional("SBBanPlayer");
129
130 RegPluginLibrary("smwarn");
131
132 return APLRes_Success;
133}
134
135public OnAllPluginsLoaded()
136{
137 if (LibraryExists("sourcebans"))
138 {
139 g_UseSourcebans = true;
140 }
141}
142
143public OnLibraryAdded(const String:name[])
144{
145 if (StrEqual("sourcebans", name))
146 {
147 g_UseSourcebans = true;
148 }
149}
150
151public OnLibraryRemoved(const String:name[])
152{
153 if (StrEqual("sourcebans", name))
154 {
155 g_UseSourcebans = false;
156 }
157 else if(StrEqual(name, "adminmenu"))
158 {
159 hAdminMenu = INVALID_HANDLE;
160 }
161}
162
163public Native_WarnPlayer(Handle:plugin, numParams)
164{
165 new client = GetNativeCell(1);
166
167 new len;
168 GetNativeStringLength(2, len);
169
170 if (len <= 0)
171 {
172 return;
173 }
174
175 new String:Reason[len+1];
176 GetNativeString(2, Reason, len+1);
177
178 ServerCommand("sm_warn #%d \"%s\"", GetClientUserId(client), Reason);
179}
180
181public Native_UnWarnPlayer(Handle:plugin, numParams)
182{
183 new client = GetNativeCell(1);
184
185 new len;
186 GetNativeStringLength(2, len);
187
188 if (len <= 0)
189 {
190 return;
191 }
192
193 new String:Reason[len+1];
194 GetNativeString(2, Reason, len+1);
195
196 ServerCommand("sm_unwarn #%d \"%s\"", GetClientUserId(client), Reason);
197}
198
199public Native_ResetWarnPlayer(Handle:plugin, numParams)
200{
201 new client = GetNativeCell(1);
202
203 new len;
204 GetNativeStringLength(2, len);
205
206 if (len <= 0)
207 {
208 return;
209 }
210
211 new String:Reason[len+1];
212 GetNativeString(2, Reason, len+1);
213
214 ServerCommand("sm_resetwarn #%d \"%s\"", GetClientUserId(client), Reason);
215}
216
217public Native_GetActiveWarnings(Handle:plugin, numParams)
218{
219 new client = GetNativeCell(1);
220
221 if(g_iWarnings[client] == -1)
222 return false;
223
224 return g_iWarnings[client];
225}
226
227public SetupDatabase()
228{
229 SQL_TConnect(SQL_OnConnect, "warn");
230}
231
232public OnMapStart()
233{
234 if(GetConVarBool(g_cVar_warnsound))
235 {
236 new String:g_Path[214];
237 GetConVarString(g_cVar_warnsoundPath, g_Path, sizeof(g_Path));
238 PrecacheSound(g_Path, true);
239 }
240}
241
242public SQL_OnConnect(Handle:owner, Handle:hndl, const String:error[], any:data)
243{
244 if (hndl == INVALID_HANDLE)
245 {
246 SetFailState("[SM warn] Database failure: %s", error);
247 }
248 else
249 {
250 hDatabase = hndl;
251
252 new String:buffer[1024];
253
254 SQL_GetDriverIdent(SQL_ReadDriver(hDatabase), buffer, sizeof(buffer));
255
256 new UseMySQL = StrEqual(buffer, "mysql", false) ? 1 : 0;
257
258 if (UseMySQL == 1)
259 {
260 Format(buffer, sizeof(buffer), "CREATE TABLE IF NOT EXISTS `smwarn` (`target` VARCHAR(64), `tsteamid` VARCHAR(32), `admin` VARCHAR(64), `asteamid` VARCHAR(32), `reason` VARCHAR(64), `time` VARCHAR(64), `expired` VARCHAR(1), `hostname` VARCHAR(254))");
261 }
262 else
263 {
264 Format(buffer, sizeof(buffer), "CREATE TABLE IF NOT EXISTS smwarn (target TEXT, tsteamid TEXT, admin TEXT, asteamid TEXT, reason TEXT, time TEXT, expired TEXT, hostname TEXT);");
265 }
266
267 SQL_TQuery(hDatabase, SQL_EmptyCallback, buffer);
268
269 if (UseMySQL == 1)
270 {
271 new String:dbQuery[254];
272 Format(dbQuery, sizeof(dbQuery), "SET NAMES 'utf8'");
273
274 SQL_TQuery(hDatabase, SQL_EmptyCallback, dbQuery);
275 }
276 }
277}
278
279public OnClientPostAdminCheck(client)
280{
281 if(!IsFakeClient(client))
282 {
283 new String:steamid[32];
284 GetClientAuthString(client, steamid, sizeof(steamid));
285
286 new String:dbQuery[254];
287 FormatEx(dbQuery, sizeof(dbQuery), "SELECT * FROM smwarn WHERE tsteamid='%s' AND expired != '1'", steamid);
288
289 SQL_TQuery(hDatabase, SQL_CheckWarnings, dbQuery, client);
290 }
291}
292
293public OnClientDisconnect(client)
294{
295 g_iWarnings[client] = -1;
296}
297
298public SQL_CheckWarnings(Handle:owner, Handle:hndl, const String:error[], any:client)
299{
300 if (hndl == INVALID_HANDLE)
301 {
302 SetupDatabase();
303 return;
304 }
305
306 if (SQL_FetchRow(hndl))
307 {
308 g_iWarnings[client] = SQL_GetRowCount(hndl);
309
310 if (GetConVarBool(g_cVar_PrintToAdmins))
311 {
312 PrintToAdmins("\x03[Warn] \x01%t", "warn_warnconnect", client, g_iWarnings[client]);
313 }
314 }
315}
316
317public Action:Command_WarnPlayer(client, args)
318{
319 if (args < 2)
320 {
321 ReplyToCommand(client, "\x03[Warn] \x01%t", "warn_arguments");
322 return Plugin_Handled;
323 }
324
325 new String:argument[32], String:reason[64], String:buffer[100];
326 GetCmdArg(1, argument, sizeof(argument));
327
328 if(args >= 2)
329 {
330 for(new i = 2; i <= args; i++)
331 {
332 GetCmdArg(i, buffer, sizeof(buffer));
333 Format(reason, sizeof(reason), "%s %s", reason, buffer);
334 }
335 }
336
337 new target = FindTarget(client, argument, true, true);
338
339 if (target > 0 && target <= MaxClients )
340 {
341 new String:csteamid[32], String:tsteamid[32], String:cip[32], String:tip[32];
342 GetClientAuthString(target, tsteamid, sizeof(tsteamid));
343 GetClientIP(target, tip, sizeof(tip));
344
345 new Handle:datapack = CreateDataPack();
346
347 if (client != 0)
348 {
349 GetClientAuthString(client, csteamid, sizeof(csteamid));
350 GetClientIP(client, cip, sizeof(cip));
351 WritePackCell(datapack, GetClientUserId(client));
352
353 }
354 else
355 {
356 Format(csteamid, sizeof(csteamid), "CONSOLE");
357 Format(cip, sizeof(cip), "Unknown");
358 WritePackCell(datapack, 0);
359 }
360
361 WritePackCell(datapack, GetClientUserId(target));
362 WritePackString(datapack, reason);
363 ResetPack(datapack);
364
365 new String:dbQuery[254];
366 FormatEx(dbQuery, sizeof(dbQuery), "SELECT * FROM smwarn WHERE tsteamid='%s' AND expired != '1'", tsteamid);
367
368 SQL_TQuery(hDatabase, SQL_WarnPlayer, dbQuery, datapack);
369
370 ShowActivity2(client, "\x03[Warn] \x01", "%t", "warn_warnplayer", target, reason);
371
372 if(GetConVarBool(g_cVar_LogWarnings))
373 {
374 LogWarnings("[SM warn] %t", "warn_warnlog", client, csteamid, cip, target, tsteamid, tip, reason);
375 }
376
377 if(GetConVarBool(g_cVar_warnsound))
378 {
379 new String:g_Path[214];
380 GetConVarString(g_cVar_warnsoundPath, g_Path, sizeof(g_Path));
381
382 EmitSoundToClient(target, g_Path);
383 }
384
385 if(GetConVarBool(g_cVar_motdpanel) && GetConVarInt(g_cVar_punishment) != 4)
386 {
387 new String:g_titel[214], String:g_url[214];
388 GetConVarString(g_cVar_warnpaneltitel, g_titel, sizeof(g_titel));
389 GetConVarString(g_cVar_warnpanelurl, g_url, sizeof(g_url));
390
391 ShowMOTDPanel(target, g_titel, g_url, MOTDPANEL_TYPE_URL);
392 }
393 }
394 return Plugin_Handled;
395}
396
397public SQL_WarnPlayer(Handle:owner, Handle:hndl, const String:error[], any:datapack)
398{
399 new client;
400 new target;
401 new time = GetTime();
402 new String:tempreason[64], String:dbQuery[1024], String:asteamid[32], String:tsteamid[64], String:nickname[64], String:nickname2[64], String:tempnick[64], String:tempnick2[64], String:Reason[64], String:hostname[1024], String:ehostname[1024];
403
404 if(datapack != INVALID_HANDLE)
405 {
406 client = GetClientOfUserId(ReadPackCell(datapack));
407 target = GetClientOfUserId(ReadPackCell(datapack));
408 ReadPackString(datapack, tempreason, sizeof(tempreason));
409 CloseHandle(datapack);
410 }
411
412 if (hndl == INVALID_HANDLE)
413 {
414 SetupDatabase();
415 return;
416 }
417
418 if (client != 0)
419 {
420 GetClientAuthString(client, asteamid, sizeof(asteamid));
421 GetClientName(client, tempnick2, sizeof(tempnick2));
422 SQL_EscapeString(hDatabase, tempnick2, nickname2, sizeof(nickname2));
423 }
424 else
425 {
426 Format(asteamid, sizeof(asteamid), "CONSOLE");
427 Format(nickname2, sizeof(nickname2), "CONSOLE");
428 }
429
430 GetClientName(target, tempnick, sizeof(tempnick));
431 GetConVarString(DHhostname, hostname, sizeof(hostname));
432 ReplaceString(hostname, sizeof(hostname), "/", "");
433 ReplaceString(hostname, sizeof(hostname), "'", "");
434 SQL_EscapeString(hDatabase, tempnick, nickname, sizeof(nickname));
435 SQL_EscapeString(hDatabase, tempreason, Reason, sizeof(Reason));
436 SQL_EscapeString(hDatabase, hostname, ehostname, sizeof(ehostname));
437
438 GetClientAuthString(target, tsteamid, sizeof(tsteamid));
439
440 if (SQL_FetchRow(hndl))
441 {
442 g_iWarnings[client]++;
443
444 Format(dbQuery, sizeof(dbQuery), "INSERT INTO smwarn (target, tsteamid, admin, asteamid, reason, time, expired, hostname) VALUES ('%s', '%s', '%s', '%s', '%s', '%i', '0', '%s')", nickname, tsteamid, nickname2, asteamid, Reason, time, ehostname);
445 SQL_TQuery(hDatabase, SQL_EmptyCallback, dbQuery);
446
447 if (g_iWarnings[client] >= GetConVarInt(g_cVar_maxwarns))
448 {
449 if(GetConVarBool(g_cVar_reset_warnings))
450 {
451 Format(dbQuery, sizeof(dbQuery), "DELETE FROM smwarn WHERE tsteamid = '%s'", tsteamid);
452 SQL_TQuery(hDatabase, SQL_EmptyCallback, dbQuery);
453 }
454 else
455 {
456 Format(dbQuery, sizeof(dbQuery), "UPDATE smwarn SET expired = '1' WHERE tsteamid = '%s'", tsteamid);
457 SQL_TQuery(hDatabase, SQL_EmptyCallback, dbQuery);
458 }
459
460 switch (GetConVarInt(g_cVar_max_punishment))
461 {
462 case 0:
463 {
464 }
465 case 1:
466 {
467 KickClient(target, "[SM warn] %t", "warn_max_kickonly");
468 }
469 case 2:
470 {
471 new String:kickReason[100], String:banReason[100];
472
473 Format(kickReason, sizeof(kickReason), "[SM warn] %t", "warn_max_kick");
474 Format(banReason, sizeof(banReason), "[SM warn] %t", "warn_max_ban", Reason);
475
476 if (g_UseSourcebans)
477 {
478 SourceBans_BanPlayer(0, target, GetConVarInt(g_cVar_banlength), banReason);
479 }
480 }
481 }
482 }
483 }
484 else
485 {
486 Format(dbQuery, sizeof(dbQuery), "INSERT INTO smwarn (target, tsteamid, admin, asteamid, reason, time, expired, hostname) VALUES ('%s', '%s', '%s', '%s', '%s', '%i', '0', '%s')", nickname, tsteamid, nickname2, asteamid, Reason, time, hostname);
487 SQL_TQuery(hDatabase, SQL_EmptyCallback, dbQuery);
488 }
489
490 if(IsClientInGame(target) && !IsFakeClient(target))
491 {
492 switch (GetConVarInt(g_cVar_punishment))
493 {
494 case 1:
495 {
496 // Aww, i want to punish them, aaarr
497 PrintToChat(target, "\x03[Warn] \x01%t", "warn_message");
498 }
499 case 2:
500 {
501 SlapPlayer(target, GetConVarInt(g_cVar_slapdamage), true);
502 PrintToChat(target, "[\x03[Warn] \x01%t", "warn_message");
503 }
504 case 3:
505 {
506 ForcePlayerSuicide(target);
507 PrintToChat(target, "\x03[Warn] \x01%t", "warn_message");
508 }
509 case 4:
510 {
511 SetEntityMoveType(target, MOVETYPE_NONE);
512 BuildAgreement(target);
513 PrintToChat(target, "\x03[Warn] \x01%t", "warn_message");
514 }
515 case 5:
516 {
517 new String:kickreason[1024];
518 Format(kickreason, sizeof(kickreason), "[SM warn] %t", "warn_punish_kick", Reason);
519
520 KickClient(target, kickreason);
521 }
522 case 6:
523 {
524 new String:kickReason[1024], String:banReason[1024];
525
526 Format(kickReason, sizeof(kickReason), "[SM warn] %t", "warn_punish_kickban", Reason);
527 Format(banReason, sizeof(banReason), "[SM warn] %t", "warn_punish_ban", Reason);
528
529 if (g_UseSourcebans)
530 {
531 SourceBans_BanPlayer(0, target, GetConVarInt(g_cVar_banlength), banReason);
532 }
533 }
534 }
535 }
536}
537
538public Action:Command_UnWarnPlayer(client, args)
539{
540 if (args < 2)
541 {
542 ReplyToCommand(client, "\x03[Warn] \x01%t", "warn_arguments2");
543 return Plugin_Handled;
544 }
545
546 new String:argument[32], String:reason[64], String:buffer[100];
547 GetCmdArg(1, argument, sizeof(argument));
548
549 if(args >= 2)
550 {
551 for(new i = 2; i <= args; i++)
552 {
553 GetCmdArg(i, buffer, sizeof(buffer));
554 Format(reason, sizeof(reason), "%s %s", reason, buffer);
555 }
556 }
557
558 new target = FindTarget(client, argument, true, true);
559
560 if (target > 0 && target <= MaxClients )
561 {
562 new String:steamid[32];
563 GetClientAuthString(target, steamid, sizeof(steamid));
564
565 new String:dbQuery[254];
566 FormatEx(dbQuery, sizeof(dbQuery), "SELECT * FROM smwarn WHERE tsteamid='%s' AND expired != '1' ORDER BY time DESC LIMIT 1", steamid);
567
568 new Handle:datapack = CreateDataPack();
569
570 if (client != 0)
571 {
572 WritePackCell(datapack, GetClientUserId(client));
573
574 }
575 else
576 {
577 WritePackCell(datapack, 0);
578 }
579
580 WritePackCell(datapack, GetClientUserId(target));
581 WritePackString(datapack, steamid);
582 WritePackString(datapack, reason);
583 ResetPack(datapack);
584
585 SQL_TQuery(hDatabase, SQL_UnWarnPlayer, dbQuery, datapack);
586 }
587 return Plugin_Handled;
588}
589
590public SQL_UnWarnPlayer(Handle:owner, Handle:hndl, const String:error[], any:datapack)
591{
592 new client;
593 new target;
594 new String:tsteamid[32], String:reason[32];
595
596 if(datapack != INVALID_HANDLE)
597 {
598 client = GetClientOfUserId(ReadPackCell(datapack));
599 target = GetClientOfUserId(ReadPackCell(datapack));
600 ReadPackString(datapack, tsteamid, sizeof(tsteamid));
601 ReadPackString(datapack, reason, sizeof(reason));
602 CloseHandle(datapack);
603 }
604
605 if (hndl == INVALID_HANDLE)
606 {
607 SetupDatabase();
608 return;
609 }
610
611 new String:dbQuery[500];
612
613 if (SQL_FetchRow(hndl))
614 {
615 new String:csteamid[32], String:cip[32], String:tip[32], String:timestring[64];
616
617 if (client != 0)
618 {
619 GetClientAuthString(client, csteamid, sizeof(csteamid));
620 GetClientIP(client, cip, sizeof(cip));
621 }
622 else
623 {
624 Format(csteamid, sizeof(csteamid), "CONSOLE");
625 Format(cip, sizeof(cip), "Unknown");
626 }
627
628 GetClientIP(target, tip, sizeof(tip));
629 SQL_FetchString(hndl, 5, timestring, sizeof(timestring));
630
631 Format(dbQuery, sizeof(dbQuery), "DELETE FROM smwarn WHERE time = '%s' AND tsteamid = '%s'", timestring, tsteamid);
632
633 SQL_TQuery(hDatabase, SQL_EmptyCallback, dbQuery);
634
635 ShowActivity2(client, "\x03[Warn] \x01", "%t", "warn_unwarn_player", target, reason);
636
637 if(GetConVarBool(g_cVar_LogWarnings))
638 {
639 LogWarnings("[SM warn] %t", "warn_unwarn_log", client, csteamid, cip, target, tsteamid, tip, reason);
640 }
641 }
642 else
643 {
644 PrintToChat(client, "\x03[Warn] \x01%t", "warn_notwarned", target);
645 }
646}
647
648public Action:Command_WarnReset(client, args)
649{
650 if(!GetConVarBool(g_cVar_reset_warnings))
651 {
652 ReplyToCommand(client, "\x03[Warn] \x01Command has been disabled");
653 return Plugin_Handled;
654 }
655
656 if (args < 2)
657 {
658 ReplyToCommand(client, "\x03[Warn] \x01%t", "warn_arguments4");
659 return Plugin_Handled;
660 }
661
662 new String:argument[32], String:reason[64], String:buffer[100];
663 GetCmdArg(1, argument, sizeof(argument));
664
665 if(args >= 2)
666 {
667 for(new i = 2; i <= args; i++)
668 {
669 GetCmdArg(i, buffer, sizeof(buffer));
670 Format(reason, sizeof(reason), "%s %s", reason, buffer);
671 }
672 }
673
674 new target = FindTarget(client, argument, true, true);
675
676 if (target > 0 && target <= MaxClients )
677 {
678 new String:steamid[32];
679 GetClientAuthString(target, steamid, sizeof(steamid));
680
681 new String:dbQuery[254];
682 FormatEx(dbQuery, sizeof(dbQuery), "SELECT * FROM smwarn WHERE tsteamid='%s'", steamid);
683
684 new Handle:dbpack = CreateDataPack();
685
686 if (client != 0)
687 {
688 WritePackCell(dbpack, GetClientUserId(client));
689 }
690 else
691 {
692 WritePackCell(dbpack, 0);
693 }
694
695 WritePackCell(dbpack, GetClientUserId(target));
696 WritePackString(dbpack, steamid);
697 WritePackString(dbpack, reason);
698 ResetPack(dbpack);
699
700 SQL_TQuery(hDatabase, SQL_ResetWarnPlayer, dbQuery, dbpack);
701 }
702 return Plugin_Handled;
703}
704
705public SQL_ResetWarnPlayer(Handle:owner, Handle:hndl, const String:error[], any:dbpack)
706{
707 new client;
708 new target;
709 new String:tsteamid[32], String:reason[32];
710
711 if(dbpack != INVALID_HANDLE)
712 {
713 client = GetClientOfUserId(ReadPackCell(dbpack));
714 target = GetClientOfUserId(ReadPackCell(dbpack));
715 ReadPackString(dbpack, tsteamid, sizeof(tsteamid));
716 ReadPackString(dbpack, reason, sizeof(reason));
717 CloseHandle(dbpack);
718 }
719
720 if (hndl == INVALID_HANDLE)
721 {
722 SetupDatabase();
723 return;
724 }
725
726 new String:dbQuery[254];
727
728 if (SQL_FetchRow(hndl))
729 {
730 Format(dbQuery, sizeof(dbQuery), "DELETE FROM smwarn WHERE tsteamid = '%s'", tsteamid);
731 SQL_TQuery(hDatabase, SQL_EmptyCallback, dbQuery);
732
733 ShowActivity2(client, "\x03[Warn] \x01", "%t", "warn_resetplayer", target, reason);
734
735 new String:csteamid[32], String:cip[32], String:tip[32];
736
737 if (client != 0)
738 {
739 GetClientAuthString(client, csteamid, sizeof(csteamid));
740 GetClientIP(client, cip, sizeof(cip));
741 }
742 else
743 {
744 Format(csteamid, sizeof(csteamid), "CONSOLE");
745 Format(cip, sizeof(cip), "Unknown");
746 }
747
748
749 if(GetConVarBool(g_cVar_LogWarnings))
750 {
751 LogWarnings("[SM warn] %t", "warn_resetwarn_log", client, csteamid, cip, target, tsteamid, tip, reason);
752 }
753 }
754 else
755 {
756 PrintToChat(client, "\x03[Warn] \x01%t", "warn_notwarned", target);
757 }
758}
759
760public Action:Command_CheckWarnPlayer(client, args)
761{
762 if (client == 0)
763 {
764 PrintToServer("[SM warn] In-game command only!");
765 return Plugin_Handled;
766 }
767
768 if (args < 1)
769 {
770 ReplyToCommand(client, "\x03[Warn] \x01%t", "warn_arguments3");
771 return Plugin_Handled;
772 }
773
774 new String:argument[32];
775 GetCmdArg(1, argument, sizeof(argument));
776 new target = FindTarget(client, argument, true, true);
777
778 if (target > 0 && target <= MaxClients )
779 {
780 new String:steamid[32];
781 GetClientAuthString(target, steamid, sizeof(steamid));
782
783 new String:dbQuery[254];
784 FormatEx(dbQuery, sizeof(dbQuery), "SELECT * FROM smwarn WHERE tsteamid='%s'", steamid);
785
786 new Handle:datapacket = CreateDataPack();
787 WritePackCell(datapacket, GetClientUserId(client));
788 WritePackCell(datapacket, GetClientUserId(target));
789 ResetPack(datapacket);
790
791 SQL_TQuery(hDatabase, SQL_CheckPlayer, dbQuery, datapacket);
792 }
793 return Plugin_Handled;
794}
795
796public SQL_CheckPlayer(Handle:owner, Handle:hndl, const String:error[], any:datapacket)
797{
798 new client;
799 new target;
800
801 if(datapacket != INVALID_HANDLE)
802 {
803 client = GetClientOfUserId(ReadPackCell(datapacket));
804 target = GetClientOfUserId(ReadPackCell(datapacket));
805 CloseHandle(datapacket);
806 }
807
808 if (hndl == INVALID_HANDLE)
809 {
810 SetupDatabase();
811 return;
812 }
813
814 if (SQL_GetRowCount(hndl) == 0)
815 {
816 PrintToChat(client, "\x03[Warn] \x01%t", "warn_notwarned", target);
817 return;
818 }
819
820 PrintToChat(client, "\x03[Warn] \x01Check console for output");
821
822 new warnings = SQL_GetRowCount(hndl);
823 new String:nickname[15], String:admin[15], String:Reason[32], String:Date[32], String:Expired[4], String:hostname[254];
824 PrintToConsole(client, "");
825 PrintToConsole(client, "");
826 PrintToConsole(client, "[SM warn] %t", "warn_consoleoutput", target, warnings);
827 PrintToConsole(client, "%-15s %-16s %-22s %-33s %-3s %s", "Player", "Admin", "Date", "Reason", "Expired", "Server");
828 PrintToConsole(client, "----------------------------------------------------------------------------------------------------");
829
830 while (SQL_FetchRow(hndl))
831 {
832 SQL_FetchString(hndl, 0, nickname, sizeof(nickname));
833 SQL_FetchString(hndl, 2, admin, sizeof(admin));
834 SQL_FetchString(hndl, 4, Reason, sizeof(Reason));
835 SQL_FetchString(hndl, 5, Date, sizeof(Date));
836 SQL_FetchString(hndl, 6, Expired, sizeof(Expired));
837 SQL_FetchString(hndl, 7, hostname, sizeof(hostname));
838
839 if(StrEqual(Expired, "0", false))
840 {
841 Format(Expired, sizeof(Expired), "No");
842 }
843 else
844 {
845 Format(Expired, sizeof(Expired), "Yes");
846 }
847
848 new buffer;
849 buffer = StringToInt(Date);
850 FormatTime(Date, sizeof(Date), "%Y-%m-%d %X", buffer);
851
852 PrintToConsole(client, "%-15s %-16s %-22s %-33s %-3s %s", nickname, admin, Date, Reason, Expired, hostname);
853 }
854}
855
856public SQL_EmptyCallback(Handle:owner, Handle:hndl, const String:error[], any:data)
857{
858 if (!StrEqual(error, "", false))
859 {
860 LogError("Query failure: %s", error);
861 }
862}
863
864public OnAdminMenuReady(Handle:topmenu)
865{
866 if (topmenu == hAdminMenu)
867 {
868 return;
869 }
870
871 hAdminMenu = topmenu;
872
873 // new TopMenuObject:player_commands = FindTopMenuCategory(hAdminMenu, ADMINMENU_PLAYERCOMMANDS);
874 new TopMenuObject:player_commands = FindTopMenuCategory(hAdminMenu, "warnmenu");
875
876
877 if (player_commands == INVALID_TOPMENUOBJECT)
878 {
879 player_commands = AddToTopMenu(hAdminMenu, "warnmenu", TopMenuObject_Category, Handle_AdminCategory, INVALID_TOPMENUOBJECT, "sm_warnmenu", ADMFLAG_BAN);
880 }
881
882 AddToTopMenu(hAdminMenu, "sm_warn", TopMenuObject_Item, AdminMenu_Warn, player_commands, "sm_warn", ADMFLAG_BAN);
883 AddToTopMenu(hAdminMenu, "sm_unwarn", TopMenuObject_Item, AdminMenu_UnWarn, player_commands, "sm_unwarn", ADMFLAG_BAN);
884 AddToTopMenu(hAdminMenu, "sm_resetwarn", TopMenuObject_Item, AdminMenu_ResetWarn, player_commands, "sm_resetwarn", ADMFLAG_BAN);
885 AddToTopMenu(hAdminMenu, "sm_checkwarn", TopMenuObject_Item, AdminMenu_CheckWarn, player_commands, "sm_checkwarn", ADMFLAG_BAN);
886}
887
888public Handle_AdminCategory( Handle:topmenu, TopMenuAction:action, TopMenuObject:object_id, param, String:buffer[], maxlength )
889{
890 switch(action)
891 {
892 case TopMenuAction_DisplayTitle:
893 {
894 Format(buffer, maxlength, "Warning Commands");
895 }
896 case TopMenuAction_DisplayOption:
897 {
898 Format(buffer, maxlength, "Warnings Commands");
899 }
900 }
901}
902
903public AdminMenu_Warn(Handle:topmenu, TopMenuAction:action, TopMenuObject:object_id, param, String:buffer[], maxlength)
904{
905 if (action == TopMenuAction_DisplayOption)
906 {
907 Format(buffer, maxlength, "%t", "warn_warn_adminmenu_title", param);
908 }
909 else if (action == TopMenuAction_SelectOption)
910 {
911 DisplayWarnTargetMenu(param);
912 }
913}
914
915public AdminMenu_UnWarn(Handle:topmenu, TopMenuAction:action, TopMenuObject:object_id, param, String:buffer[], maxlength)
916{
917 if (action == TopMenuAction_DisplayOption)
918 {
919 Format(buffer, maxlength, "%t", "warn_unwarn_adminmenu_title", param);
920 }
921 else if (action == TopMenuAction_SelectOption)
922 {
923 DisplayUnWarnTargetMenu(param);
924 }
925}
926
927public AdminMenu_ResetWarn(Handle:topmenu, TopMenuAction:action, TopMenuObject:object_id, param, String:buffer[], maxlength)
928{
929 if (action == TopMenuAction_DisplayOption)
930 {
931 Format(buffer, maxlength, "%t", "warn_resetwarn_adminmenu_title", param);
932 }
933 else if (action == TopMenuAction_SelectOption)
934 {
935 DisplayRestetWarnTargetMenu(param);
936 }
937}
938
939public AdminMenu_CheckWarn(Handle:topmenu, TopMenuAction:action, TopMenuObject:object_id, param, String:buffer[], maxlength)
940{
941 if (action == TopMenuAction_DisplayOption)
942 {
943 Format(buffer, maxlength, "%t", "warn_checkwarn_adminmenu_title", param);
944 }
945 else if (action == TopMenuAction_SelectOption)
946 {
947 DisplayCheckWarnTargetMenu(param);
948 }
949}
950
951DisplayWarnTargetMenu(client)
952{
953 new Handle:menu = CreateMenu(MenuHandler_Warn);
954
955 new String:title[32];
956 Format(title, sizeof(title), "%t", "warn_warn_targetmenutitle", client);
957
958 SetMenuTitle(menu, title);
959 SetMenuExitBackButton(menu, true);
960
961 AddTargetsToMenu2(menu, client, COMMAND_FILTER_NO_BOTS|COMMAND_FILTER_CONNECTED);
962
963 DisplayMenu(menu, client, MENU_TIME_FOREVER);
964}
965
966DisplayUnWarnTargetMenu(client)
967{
968 new Handle:menu = CreateMenu(MenuHandler_UnWarn);
969
970 new String:title[32];
971 Format(title, sizeof(title), "%t", "warn_unwarn_targetmenutitle", client);
972
973 SetMenuTitle(menu, title);
974 SetMenuExitBackButton(menu, true);
975
976 AddTargetsToMenu2(menu, client, COMMAND_FILTER_NO_BOTS|COMMAND_FILTER_CONNECTED);
977
978 DisplayMenu(menu, client, MENU_TIME_FOREVER);
979}
980
981DisplayCheckWarnTargetMenu(client)
982{
983 new Handle:menu = CreateMenu(MenuHandler_CheckWarn);
984
985 new String:title[32];
986 Format(title, sizeof(title), "%t", "warn_checkwarn_targetmenutitle", client);
987
988 SetMenuTitle(menu, title);
989 SetMenuExitBackButton(menu, true);
990
991 AddTargetsToMenu2(menu, client, COMMAND_FILTER_NO_BOTS|COMMAND_FILTER_CONNECTED);
992
993 DisplayMenu(menu, client, MENU_TIME_FOREVER);
994}
995
996DisplayRestetWarnTargetMenu(client)
997{
998 new Handle:menu = CreateMenu(MenuHandler_ResetWarn);
999
1000 new String:title[32];
1001 Format(title, sizeof(title), "%t", "warn_resetwarn_targetmenutitle", client);
1002
1003 SetMenuTitle(menu, title);
1004 SetMenuExitBackButton(menu, true);
1005
1006 AddTargetsToMenu2(menu, client, COMMAND_FILTER_NO_BOTS|COMMAND_FILTER_CONNECTED);
1007
1008 DisplayMenu(menu, client, MENU_TIME_FOREVER);
1009}
1010
1011public MenuHandler_Warn(Handle:menu, MenuAction:action, param1, param2)
1012{
1013 if (action == MenuAction_End)
1014 {
1015 CloseHandle(menu);
1016 }
1017 else if (action == MenuAction_Cancel)
1018 {
1019 if (param2 == MenuCancel_ExitBack && hAdminMenu != INVALID_HANDLE)
1020 {
1021 DisplayTopMenu(hAdminMenu, param1, TopMenuPosition_LastCategory);
1022 }
1023 }
1024 else if (action == MenuAction_Select)
1025 {
1026
1027 new String:info[32];
1028 new userid, target;
1029
1030 GetMenuItem(menu, param2, info, sizeof(info));
1031 userid = StringToInt(info);
1032
1033 if ((target = GetClientOfUserId(userid)) == 0)
1034 {
1035 PrintToChat(param1, "\x03[Warn] \x01%t", "warn_notavailable");
1036 }
1037 else if (!CanUserTarget(param1, target))
1038 {
1039 PrintToChat(param1, "\x03[Warn] \x01%t", "warn_canttarget");
1040 }
1041 else
1042 {
1043 g_target[param1] = userid;
1044 DisplayWarnReasons(param1);
1045 }
1046 }
1047}
1048
1049public MenuHandler_UnWarn(Handle:menu, MenuAction:action, param1, param2)
1050{
1051 if (action == MenuAction_End)
1052 {
1053 CloseHandle(menu);
1054 }
1055 else if (action == MenuAction_Cancel)
1056 {
1057 if (param2 == MenuCancel_ExitBack && hAdminMenu != INVALID_HANDLE)
1058 {
1059 DisplayTopMenu(hAdminMenu, param1, TopMenuPosition_LastCategory);
1060 }
1061 }
1062 else if (action == MenuAction_Select)
1063 {
1064
1065 new String:info[32];
1066 new userid, target;
1067
1068 GetMenuItem(menu, param2, info, sizeof(info));
1069 userid = StringToInt(info);
1070
1071 if ((target = GetClientOfUserId(userid)) == 0)
1072 {
1073 PrintToChat(param1, "\x03[Warn] \x01%t", "warn_notavailable");
1074 }
1075 else if (!CanUserTarget(param1, target))
1076 {
1077 PrintToChat(param1, "\x03[Warn] \x01%t", "warn_canttarget");
1078 }
1079 else
1080 {
1081 g_target[param1] = userid;
1082 DisplayUnWarnReasons(param1);
1083 }
1084 }
1085}
1086
1087public MenuHandler_CheckWarn(Handle:menu, MenuAction:action, param1, param2)
1088{
1089 if (action == MenuAction_End)
1090 {
1091 CloseHandle(menu);
1092 }
1093 else if (action == MenuAction_Cancel)
1094 {
1095 if (param2 == MenuCancel_ExitBack && hAdminMenu != INVALID_HANDLE)
1096 {
1097 DisplayTopMenu(hAdminMenu, param1, TopMenuPosition_LastCategory);
1098 }
1099 }
1100 else if (action == MenuAction_Select)
1101 {
1102
1103 new String:info[32];
1104 new userid, target;
1105
1106 GetMenuItem(menu, param2, info, sizeof(info));
1107 userid = StringToInt(info);
1108
1109 if ((target = GetClientOfUserId(userid)) == 0)
1110 {
1111 PrintToChat(param1, "\x03[Warn] \x01%t", "warn_notavailable");
1112 }
1113 else if (!CanUserTarget(param1, target))
1114 {
1115 PrintToChat(param1, "\x03[Warn] \x01%t", "warn_canttarget");
1116 }
1117 else
1118 {
1119 FakeClientCommand(param1, "sm_checkwarn \"#%d\"", userid);
1120 }
1121 }
1122}
1123
1124public MenuHandler_ResetWarn(Handle:menu, MenuAction:action, param1, param2)
1125{
1126 if (action == MenuAction_End)
1127 {
1128 CloseHandle(menu);
1129 }
1130 else if (action == MenuAction_Cancel)
1131 {
1132 if (param2 == MenuCancel_ExitBack && hAdminMenu != INVALID_HANDLE)
1133 {
1134 DisplayTopMenu(hAdminMenu, param1, TopMenuPosition_LastCategory);
1135 }
1136 }
1137 else if (action == MenuAction_Select)
1138 {
1139
1140 new String:info[32];
1141 new userid, target;
1142
1143 GetMenuItem(menu, param2, info, sizeof(info));
1144 userid = StringToInt(info);
1145
1146 if ((target = GetClientOfUserId(userid)) == 0)
1147 {
1148 PrintToChat(param1, "\x03[Warn] \x01%t", "warn_notavailable");
1149 }
1150 else if (!CanUserTarget(param1, target))
1151 {
1152 PrintToChat(param1, "\x03[Warn] \x01%t", "warn_canttarget");
1153 }
1154 else
1155 {
1156 g_target[param1] = userid;
1157 DisplayResetWarnReasons(param1);
1158 }
1159 }
1160}
1161
1162DisplayWarnReasons(client)
1163{
1164 new Handle:menu = CreateMenu(MenuHandler_PreformWarn);
1165
1166 new String:title[32];
1167 Format(title, sizeof(title), "%t", "warn_warn_reasontitle", client);
1168
1169 SetMenuTitle(menu, title);
1170 SetMenuExitBackButton(menu, true);
1171
1172 new Handle:g_FilePath = OpenFile(pathwarn, "rt");
1173
1174 if (g_FilePath == INVALID_HANDLE)
1175 {
1176 LogWarnings("Could not find the config file (addons/sourcemod/configs/sm_unwarn_reasons.cfg)");
1177 return;
1178 }
1179
1180 new String:reason[255];
1181
1182 while (!IsEndOfFile(g_FilePath) && ReadFileLine(g_FilePath, reason, sizeof(reason)))
1183 {
1184 AddMenuItem(menu, reason, reason);
1185 }
1186
1187 CloseHandle(g_FilePath);
1188
1189 DisplayMenu(menu, client, MENU_TIME_FOREVER);
1190}
1191
1192DisplayUnWarnReasons(client)
1193{
1194 new Handle:menu = CreateMenu(MenuHandler_PreformUnWarn);
1195
1196 new String:title[32];
1197 Format(title, sizeof(title), "%t", "warn_unwarn_reasontitle", client);
1198
1199 SetMenuTitle(menu, title);
1200 SetMenuExitBackButton(menu, true);
1201
1202 new Handle:g_FilePath = OpenFile(pathunwarn, "rt");
1203
1204 if (g_FilePath == INVALID_HANDLE)
1205 {
1206 LogWarnings("Could not find the config file (addons/sourcemod/configs/sm_unwarn_reasons.cfg)");
1207 return;
1208 }
1209
1210 new String:reason[255];
1211
1212 while (!IsEndOfFile(g_FilePath) && ReadFileLine(g_FilePath, reason, sizeof(reason)))
1213 {
1214 AddMenuItem(menu, reason, reason);
1215 }
1216
1217 CloseHandle(g_FilePath);
1218
1219 DisplayMenu(menu, client, MENU_TIME_FOREVER);
1220}
1221
1222DisplayResetWarnReasons(client)
1223{
1224 new Handle:menu = CreateMenu(MenuHandler_PreformResetWarn);
1225
1226 new String:title[32];
1227 Format(title, sizeof(title), "%t", "warn_restwarn_reasontitle", client);
1228
1229 SetMenuTitle(menu, title);
1230 SetMenuExitBackButton(menu, true);
1231
1232 new Handle:g_FilePath = OpenFile(pathresetwarn, "rt");
1233
1234 if (g_FilePath == INVALID_HANDLE)
1235 {
1236 LogWarnings("Could not find the config file (addons/sourcemod/configs/sm_resetwarn_reasons.cfg)");
1237 return;
1238 }
1239
1240 new String:reason[255];
1241
1242 while (!IsEndOfFile(g_FilePath) && ReadFileLine(g_FilePath, reason, sizeof(reason)))
1243 {
1244 AddMenuItem(menu, reason, reason);
1245 }
1246
1247 CloseHandle(g_FilePath);
1248
1249 DisplayMenu(menu, client, MENU_TIME_FOREVER);
1250}
1251
1252public MenuHandler_PreformWarn(Handle:menu, MenuAction:action, param1, param2)
1253{
1254 if (action == MenuAction_End)
1255 {
1256 CloseHandle(menu);
1257 }
1258 else if (action == MenuAction_Cancel)
1259 {
1260 if (param2 == MenuCancel_ExitBack && hAdminMenu != INVALID_HANDLE)
1261 {
1262 DisplayTopMenu(hAdminMenu, param1, TopMenuPosition_LastCategory);
1263 }
1264 }
1265 else if (action == MenuAction_Select)
1266 {
1267 new String:info[64];
1268
1269 GetMenuItem(menu, param2, info, sizeof(info));
1270
1271 FakeClientCommand(param1, "sm_warn #%d %s", g_target[param1], info);
1272 }
1273}
1274
1275public MenuHandler_PreformUnWarn(Handle:menu, MenuAction:action, param1, param2)
1276{
1277 if (action == MenuAction_End)
1278 {
1279 CloseHandle(menu);
1280 }
1281 else if (action == MenuAction_Cancel)
1282 {
1283 if (param2 == MenuCancel_ExitBack && hAdminMenu != INVALID_HANDLE)
1284 {
1285 DisplayTopMenu(hAdminMenu, param1, TopMenuPosition_LastCategory);
1286 }
1287 }
1288 else if (action == MenuAction_Select)
1289 {
1290 new String:info[64];
1291
1292 GetMenuItem(menu, param2, info, sizeof(info));
1293
1294 FakeClientCommand(param1, "sm_unwarn #%d %s", g_target[param1], info);
1295 }
1296}
1297
1298public MenuHandler_PreformResetWarn(Handle:menu, MenuAction:action, param1, param2)
1299{
1300 if (action == MenuAction_End)
1301 {
1302 CloseHandle(menu);
1303 }
1304 else if (action == MenuAction_Cancel)
1305 {
1306 if (param2 == MenuCancel_ExitBack && hAdminMenu != INVALID_HANDLE)
1307 {
1308 DisplayTopMenu(hAdminMenu, param1, TopMenuPosition_LastCategory);
1309 }
1310 }
1311 else if (action == MenuAction_Select)
1312 {
1313 new String:info[64];
1314
1315 GetMenuItem(menu, param2, info, sizeof(info));
1316
1317 FakeClientCommand(param1, "sm_unwarn #%d %s", g_target[param1], info);
1318 }
1319}
1320
1321BuildAgreement(client)
1322{
1323 new Handle:g_FilePath = OpenFile(pathagree, "rt");
1324
1325 if (g_FilePath == INVALID_HANDLE)
1326 {
1327 LogWarnings("Could not find the config file (addons/sourcemod/configs/sm_warn_agreement.cfg)");
1328 return;
1329 }
1330
1331 new String:title[32], String:agree[32], String:g_Data[128];
1332 Format(title, sizeof(title), "[SM warn] %t", "warn_agreement_title");
1333 Format(agree, sizeof(agree), "%t", "warn_agreement_agree");
1334
1335 new Handle:g_Menu = CreatePanel();
1336
1337 SetPanelTitle(g_Menu, title);
1338 DrawPanelItem(g_Menu, " ", ITEMDRAW_SPACER|ITEMDRAW_RAWLINE);
1339
1340 while(!IsEndOfFile(g_FilePath) && ReadFileLine(g_FilePath, g_Data, sizeof(g_Data)))
1341 {
1342 DrawPanelText(g_Menu, g_Data);
1343 }
1344
1345 DrawPanelItem(g_Menu, " ", ITEMDRAW_SPACER|ITEMDRAW_RAWLINE);
1346 DrawPanelItem(g_Menu, agree);
1347
1348 SendPanelToClient(g_Menu, client, MenuHandler_WarnAgreement, MENU_TIME_FOREVER);
1349
1350 CloseHandle(g_Menu);
1351
1352 CloseHandle(g_FilePath);
1353}
1354
1355public MenuHandler_WarnAgreement(Handle:hMenu, MenuAction:action, param1, param2)
1356{
1357 if(action == MenuAction_Select)
1358 {
1359 if(param2 == 1)
1360 {
1361 PrintToChat(param1, "\x03[Warn] \x01%t", "warn_agreement_message");
1362 SetEntityMoveType(param1, MOVETYPE_WALK);
1363 }
1364 }
1365}
1366
1367PrintToAdmins(const String:format[], any:...)
1368{
1369 new String:g_Buffer[256];
1370
1371 for (new i=1;i<=MaxClients;i++)
1372 {
1373 if (CheckCommandAccess(i, "sm_warn_printtoadmins", ADMFLAG_BAN) && IsClientInGame(i))
1374 {
1375 VFormat(g_Buffer, sizeof(g_Buffer), format, 2);
1376
1377 PrintToChat(i, "%s", g_Buffer);
1378 }
1379 }
1380}
1381
1382LogWarnings(const String:format[], any:...)
1383{
1384 new String:g_Buffer[256], String:g_Path[100];
1385
1386 VFormat(g_Buffer, sizeof(g_Buffer), format, 2);
1387 BuildPath(Path_SM, g_Path, sizeof(g_Path), "logs/SM_warn.log");
1388
1389 LogToFileEx(g_Path, "%s", g_Buffer);
1390}