From anon, 1 Year ago, written in Plain Text.
This paste will run down the curtain in 1 Second.
Embed
  1. #pragma semicolon 1
  2.  
  3. #define DEBUG
  4.  
  5. #define PLUGIN_AUTHOR "Urbana"
  6. #define PLUGIN_VERSION "v1.0.5"
  7. #define SOURCEMOD "[\x02SM\x01]"
  8. #define PATH "ttt_slays_log.txt"
  9.  
  10. #include <sourcemod>
  11. #include <sdktools>
  12. #include <ttt>
  13.  
  14. #pragma newdecls required
  15.  
  16. public Plugin myinfo =
  17. {
  18.         name = "TTT Slays",
  19.         author = PLUGIN_AUTHOR,
  20.         description = "Custom slays for TTT",
  21.         version = PLUGIN_VERSION,
  22.         url = "https://tangoworldwide.net/index.php?action=profile;u=4472"
  23. };
  24.  
  25. int slayRounds[MAXPLAYERS + 1];
  26.  
  27. public void OnPluginStart()
  28. {
  29.         RegAdminCmd("sm_aslay", Command_ASlay, ADMFLAG_SLAY, "Slays target for number of rounds given.");
  30.         RegAdminCmd("sm_rslay", Command_RSlay, ADMFLAG_SLAY, "Removes slays from target.");
  31.         RegAdminCmd("sm_cslay", Command_CSlay, ADMFLAG_SLAY, "Checks target's remaining slays.");
  32.         RegAdminCmd("sm_slaynr", Command_SlayNR, ADMFLAG_SLAY, "Slays target on next round.");
  33. }
  34.  
  35. public void TTT_OnRoundStart(int innocents, int traitors, int detective)
  36. {
  37.        
  38.         char authID[64];
  39.        
  40.         for (int i = 1; i < MAXPLAYERS; i++)
  41.         {
  42.                 if (slayRounds[i] != 0)
  43.                 {
  44.                         ForcePlayerSuicide(i);
  45.                         slayRounds[i]--;
  46.                         PrintToChat(i, "%s You were automatically slayed this round.", SOURCEMOD);
  47.                         GetClientAuthId(i, AuthId_Steam2, authID, sizeof(authID));
  48.                         LogToFile(PATH, "(%s) %N was auto-slayed.", authID, i);
  49.                 }
  50.         }
  51. }
  52.  
  53. public Action Command_CSlay(int client, int args)
  54. {
  55.         if (args != 1)
  56.         {
  57.                 ReplyToCommand(client, "%s Usage: sm_cslay <target>", SOURCEMOD);
  58.                 return Plugin_Handled;
  59.         }
  60.  
  61.         {
  62.  
  63.                 char name[128];
  64.                 char targetName[128];
  65.                 bool tn_is_ml;
  66.                 int targets[MAXPLAYERS + 1];
  67.        
  68.                 GetCmdArg(1, name, sizeof(name));
  69.                 int found = ProcessTargetString(name, 0, targets, sizeof(targets), COMMAND_FILTER_NO_BOTS, targetName, sizeof(targetName), tn_is_ml);
  70.                 int target = targets[0];
  71.  
  72.                 if (found < 1)
  73.                 {
  74.                         ReplyToCommand(client, "%s No one by that name found on the server.", SOURCEMOD);
  75.                 }
  76.                 else
  77.                 {
  78.                
  79.                         ReplyToCommand(client, "%s %N has %d rounds in the slay queue.", SOURCEMOD, target, slayRounds[target]);
  80.                 }
  81.         }
  82.         return Plugin_Handled;
  83. }
  84.  
  85. public Action Command_SlayNR(int client, int args)
  86. {
  87.         if (args != 1)
  88.         {
  89.                 ReplyToCommand(client, "%s Usage: sm_slaynr <target>", SOURCEMOD);
  90.                 return Plugin_Handled;
  91.         }
  92.        
  93.         char name[128];
  94.         char targetName[128];
  95.         bool tn_is_ml;
  96.         int targets[MAXPLAYERS + 1];
  97.        
  98.         GetCmdArg(1, name, sizeof(name));
  99.         int found = ProcessTargetString(name, 0, targets, sizeof(targets), COMMAND_FILTER_NO_BOTS, targetName, sizeof(targetName), tn_is_ml);
  100.         int target = targets[0];
  101.        
  102.         if (found < 1)
  103.         {
  104.                 ReplyToCommand(client, "%s No one by that name found on the server.", SOURCEMOD);
  105.         }
  106.         else
  107.         {
  108.                
  109.                 char authAdmin[64];
  110.                 char authTarget[64];
  111.                 GetClientAuthId(client, AuthId_Steam2, authAdmin, sizeof(authAdmin));
  112.                 GetClientAuthId(target, AuthId_Steam2, authTarget, sizeof(authTarget));
  113.                
  114.                 {
  115.                         slayRounds[target]++;
  116.                         ReplyToCommand(client, "%s \x03%N will be slayed next round", SOURCEMOD, target);
  117.                         LogToFile(PATH, "(%s) %N added 1 slay for (%s) %N", authAdmin, client, authTarget, target);
  118.                 }
  119.         }
  120.         return Plugin_Handled;
  121. }
  122.  
  123. public Action Command_ASlay(int client, int args)
  124. {
  125.         if (args > 2)
  126.         {
  127.                 ReplyToCommand(client, "%s Usage: sm_aslay <target> optional:<rounds> optional:<reason>", SOURCEMOD);
  128.                 return Plugin_Handled;
  129.         }
  130.        
  131.         char name[128];
  132.         char targetName[128];
  133.         bool tn_is_ml;
  134.         int targets[MAXPLAYERS + 1];
  135.        
  136.         GetCmdArg(1, name, sizeof(name));
  137.         int found = ProcessTargetString(name, 0, targets, sizeof(targets), COMMAND_FILTER_NO_BOTS, targetName, sizeof(targetName), tn_is_ml);
  138.         int target = targets[0];
  139.        
  140.         if (found < 1)
  141.         {
  142.                 ReplyToCommand(client, "%s No one by that name found on the server.", SOURCEMOD);
  143.         }
  144.         else
  145.         {
  146.                
  147.                 char authAdmin[64];
  148.                 char authTarget[64];
  149.                 GetClientAuthId(client, AuthId_Steam2, authAdmin, sizeof(authAdmin));
  150.                 GetClientAuthId(target, AuthId_Steam2, authTarget, sizeof(authTarget));
  151.                
  152.                 if (args == 1)
  153.                 {
  154.                         slayRounds[target]++;
  155.                         ReplyToCommand(client, "%s Added \x031 slay to \x03%N", SOURCEMOD, target);
  156.                         LogToFile(PATH, "(%s) %N queued 1 slay for (%s) %N", authAdmin, client, authTarget, target);
  157.                 }
  158.                 else
  159.                 {
  160.                        
  161.                         char reason[512];
  162.                         bool hasReason = false;
  163.                        
  164.                         if (args == 3)
  165.                         {
  166.                                 char argString[1028];
  167.                                 GetCmdArgString(argString, sizeof(argString));
  168.                                 char explodedStrings[3][512];
  169.                                 ExplodeString(argString, " ", explodedStrings, 3, 512, true);
  170.                                 strcopy(reason, sizeof(reason), explodedStrings[2]);
  171.                                 hasReason = true;
  172.                         }
  173.                         char roundBuffer[64];
  174.                         GetCmdArg(2, roundBuffer, sizeof(roundBuffer));
  175.                         int rounds = StringToInt(roundBuffer);
  176.                         if (rounds <= 0)
  177.                         {
  178.                                 ReplyToCommand(client, "%s Invalid round count.", SOURCEMOD);
  179.                         }
  180.                         else
  181.                         {
  182.                                 slayRounds[target] += rounds;
  183.                                 if (!hasReason)
  184.                                 {
  185.                                         ReplyToCommand(client, "%s Added \x03%d slays to \x03%N", SOURCEMOD, rounds, target);
  186.                                         LogToFile(PATH, "(%s) %N queued %d slay for (%s) %N", authAdmin, client, rounds, authTarget, target);
  187.                                 }
  188.                                 else
  189.                                 {
  190.                                         ReplyToCommand(client, "%s Added \x03%d slays to \x03%N for \"%s\"", SOURCEMOD, rounds, target, reason);
  191.                                         LogToFile(PATH, "(%s) %N queued %d slay for (%s) %N with reason \"%s\"", authAdmin, client, rounds, authTarget, target, reason);       
  192.                                 }
  193.                         }
  194.                 }
  195.         }
  196.         return Plugin_Handled;
  197. }
  198.  
  199. public Action Command_RSlay(int client, int args)
  200. {
  201.         if (args > 3)
  202.         {
  203.                 ReplyToCommand(client, "%s Usage: sm_rslay <target> optional:<rounds> optional:<reason>", SOURCEMOD);
  204.                 return Plugin_Handled; 
  205.         }
  206.        
  207.         char name[128];
  208.         char targetName[128];
  209.         bool tn_is_ml;
  210.         int targets[MAXPLAYERS + 1];
  211.        
  212.         GetCmdArg(1, name, sizeof(name));
  213.         int found = ProcessTargetString(name, 0, targets, sizeof(targets), COMMAND_FILTER_NO_BOTS, targetName, sizeof(targetName), tn_is_ml);
  214.         int target = targets[0];
  215.        
  216.         if (found < 1)
  217.         {
  218.                 ReplyToCommand(client, "%s No one by that name found on the server.", SOURCEMOD);
  219.         }
  220.         else
  221.         {
  222.                
  223.                 char authAdmin[64];
  224.                 char authTarget[64];
  225.                 GetClientAuthId(client, AuthId_Steam2, authAdmin, sizeof(authAdmin));
  226.                 GetClientAuthId(target, AuthId_Steam2, authTarget, sizeof(authTarget));
  227.                
  228.                 if (args == 1)
  229.                 {
  230.                         slayRounds[target]--;
  231.                         ReplyToCommand(client, "%s Removed \x031 slays from \x03%N", SOURCEMOD, target);
  232.                         LogToFile(PATH, "(%s) %N removed 1 slay for (%s) %N", authAdmin, client, authTarget, target);
  233.                         PrintToAdmins(client, target, 1);
  234.                 }
  235.                 else
  236.                 {
  237.                         char reason[512];
  238.                         bool hasReason = false;
  239.                
  240.                         if (args == 3)
  241.                         {
  242.                                 char argString[1028];
  243.                                 GetCmdArgString(argString, sizeof(argString));
  244.                                 char explodedStrings[3][512];
  245.                                 ExplodeString(argString, " ", explodedStrings, 3, 512, true);
  246.                                 strcopy(reason, sizeof(reason), explodedStrings[2]);
  247.                                 hasReason = true;
  248.                         }
  249.                         char roundBuffer[64];
  250.                         GetCmdArg(2, roundBuffer, sizeof(roundBuffer));
  251.                         int rounds = StringToInt(roundBuffer);
  252.                        
  253.                         if (rounds <= 0)
  254.                         {
  255.                                 ReplyToCommand(client, "%s Invalid round count.", SOURCEMOD);
  256.                         }
  257.                         else
  258.                         {
  259.                                 if (rounds >= slayRounds[target])
  260.                                 {
  261.                                         if (!hasReason)
  262.                                         {
  263.                                                 ReplyToCommand(client, "%s Removed \x03%d slays from \x03%N", SOURCEMOD, slayRounds[target], target);
  264.                                                 slayRounds[target] = 0;
  265.                                                 LogToFile(PATH, "(%s) %N removed %d slays for (%s) %N", authAdmin, client, slayRounds[target], authTarget, target);
  266.                                                 PrintToAdmins(client, target, slayRounds[target]);
  267.                                         }
  268.                                         else
  269.                                         {
  270.                                                 ReplyToCommand(client, "%s Removed \x03%d slays from \x03%N for %s", SOURCEMOD, slayRounds[target], target, reason);
  271.                                                 slayRounds[target] = 0;
  272.                                                 LogToFile(PATH, "(%s) %N removed %d slays for (%s) %N with reason %s", authAdmin, client, slayRounds[target], authTarget, target, reason);
  273.                                                 PrintToAdmins(client, target, slayRounds[target]);
  274.                                         }
  275.                                 }
  276.                                 else
  277.                                 {
  278.                                         if (!hasReason)
  279.                                         {
  280.                                                 slayRounds[target] -= rounds;
  281.                                                 ReplyToCommand(client, "%s Removed \x03%d slays from \x03%N", SOURCEMOD, rounds, target);
  282.                                                 LogToFile(PATH, "(%s) %N removed %d slays for (%s) %N", authAdmin, client, rounds, authTarget, target);
  283.                                                 PrintToAdmins(client, target, rounds);
  284.                                         }
  285.                                         else
  286.                                         {
  287.                                                 ReplyToCommand(client, "%s Removed \x03%d slays from \x03%N for %s", SOURCEMOD, rounds, target, reason);
  288.                                                 LogToFile(PATH, "(%s) %N removed %d slays for (%s) %N for reason %s", authAdmin, client, rounds, authTarget, target, reason);
  289.                                         }
  290.                                 }
  291.                         }
  292.                 }
  293.         }
  294.         return Plugin_Handled;
  295. }
  296.  
  297. public void PrintToAdmins(int admin, int target, int rounds)
  298. {
  299.         for (int i = 1; i < MAXPLAYERS; i++)
  300.         {
  301.                 if (CheckCommandAccess(i, "sm_slay", ADMFLAG_SLAY, false))
  302.                 {
  303.                         PrintToChat(i, "%s \x03%N queued \x03%d slays for \x03%N", SOURCEMOD, admin, rounds, target);
  304.                 }
  305.         }
  306. }

Replies to Untitled rss

Title Name Language When
Re: Untitled anon text 1 Year ago.