API tools faq
paste
Guest User

Untitled

a guest
Jun 24th, 2018
93
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 13.87 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Diagnostics;
  4. using System.IO;
  5. using System.Runtime.InteropServices;
  6. using System.Threading;
  7. using System.Timers;
  8. using System.Windows.Forms;
  9. using Addon;
  10.  
  11. namespace YuPluPack
  12. {
  13.     public class PluPack : CPlugin
  14.     {
  15.         const int MAPS = 16;
  16.         bool haveadmin = false;
  17.         List<string> admins = new List<string>();
  18.         string[] commands = { "!cmd", "!fov", "!ping", "!pm", "!rc", "!kick", "!say", "!map", "!var", "!nextmap", "!ban" };
  19.         string[] mapdev = { "mp_alpha", "mp_bootleg", "mp_bravo", "mp_carbon", "mp_dome", "mp_exchange", "mp_hardhat", "mp_interchange", "mp_lambeth", "mp_mogadishu", "mp_paris", "mp_plaza2", "mp_radar", "mp_seatown", "mp_underground", "mp_village" };
  20.         string[] mapuser = { "lockdown", "bootleg", "mission", "carbon", "dome", "downturn", "hardhat", "interchange", "fallen", "bakaara", "resistance", "arkaden", "outpost", "seatown", "underground", "village" };
  21.         int[] maprange = new int[MAPS];
  22.         int range;
  23.         int nextmap = -1;
  24.         string dspl, dsr;
  25.         List<string> cmds = new List<string>();
  26.         List<string> tmsgs = new List<string>();
  27.         List<string> wmsgs = new List<string>();
  28.         int max, counter;
  29.         System.Timers.Timer shtmsgs;
  30.         Random rnd = new Random(unchecked((int)DateTime.Now.Ticks));
  31.  
  32.         public override void OnServerLoad()
  33.         {
  34.             _hookID = SetHook(_proc);
  35.             GetAdmins();
  36.             GetRotation();
  37.             GetMessages();
  38.             ServerPrint("Yurio Plugin Pack v1.4 loaded");
  39.         }
  40.  
  41.         void GetAdmins()
  42.         {
  43.             string xuids = GetServerCFG("Yu", "xuids", "");
  44.             if (xuids != "")
  45.                 foreach (string x in xuids.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries))
  46.                     admins.Add(x);
  47.             if (admins.Count > 0) { haveadmin = true; }
  48.         }
  49.  
  50.         bool Admin(string id)
  51.         {
  52.             foreach (string a in admins)
  53.                 if (id.ToLowerInvariant().Contains(a.ToLowerInvariant())) { return true; }
  54.             return false;
  55.         }
  56.  
  57.         void GetRotation()
  58.         {
  59.             dspl = GetServerCFG("Yu", "dspl", "default") + ".dspl";
  60.             dsr = GetServerCFG("Yu", "dsr", "FFA_default");
  61.             string[] weights = GetServerCFG("Yu", "weights", "3, 2, 5, 3, 5, 2, 5, 3, 2, 5, 5, 3, 2, 3, 2, 5").Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
  62.             for (int i = 0; i < MAPS; i++)
  63.             {
  64.                 range += int.Parse(weights[i]);
  65.                 maprange[i] = range;
  66.             }
  67.         }
  68.  
  69.         int FindMap(int r)
  70.         {
  71.             for (int i = 0; i < MAPS; i++)
  72.                 if (r <= maprange[i])
  73.                     return i;
  74.             return -1;
  75.         }
  76.  
  77.         void SetMap(string map)
  78.         {
  79.             File.WriteAllText(@"admin\" + dspl, map + "," + dsr + ",1");
  80.         }
  81.  
  82.         int GetMapByName(string map)
  83.         {
  84.             for (int i = 0; i < MAPS; i++)
  85.                 if (mapuser[i].StartsWith(map, StringComparison.InvariantCultureIgnoreCase))
  86.                     return i;
  87.             return -1;
  88.         }
  89.  
  90.         void GetMessages()
  91.         {
  92.             CheckMessages(out cmds, "cmds.txt");
  93.             CheckMessages(out wmsgs, "wmsgs.txt");
  94.             CheckMessages(out tmsgs, "tmsgs.txt");
  95.             max = tmsgs.Count;
  96.             counter = 0;
  97.             shtmsgs = new System.Timers.Timer(double.Parse(GetServerCFG("Yu", "time", "30000")));
  98.             shtmsgs.Elapsed += new ElapsedEventHandler(ShowTimed);
  99.             shtmsgs.Enabled = true;
  100.         }
  101.  
  102.         void CheckMessages(out List<string> msgs, string file)
  103.         {
  104.             msgs = new List<string>();
  105.             foreach (string lines in File.ReadAllLines(@"addon\" + file))
  106.                 if (!lines.StartsWith(@"//")) { msgs.Add(lines); }
  107.         }
  108.  
  109.         void PrivateMess(string mes, ServerClient sc, bool sp = true)
  110.         {
  111.             string pmes = "[^1PM^7]: " + mes;
  112.             TellClient(sc.ClientNum, pmes, true);
  113.             if (sp) { ServerPrint("console to " + sc.Name + ": " + mes); }
  114.         }
  115.  
  116.         void ShowCommands(object objsc)
  117.         {
  118.             ServerClient sc = (ServerClient)objsc;
  119.             foreach (string cmd in cmds)
  120.             {
  121.                 Thread.Sleep(1000);
  122.                 PrivateMess(cmd, sc, false);
  123.             }
  124.         }
  125.  
  126.         void ShowTimed(object source, ElapsedEventArgs e)
  127.         {
  128.             ServerSay(tmsgs[counter], true);
  129.             counter++;
  130.             if (counter == max) { counter = 0; }
  131.         }
  132.  
  133.         void ShowWelcome(object objsc)
  134.         {
  135.             ServerClient sc = (ServerClient)objsc;
  136.             string wmsgnew;
  137.             foreach (string wmsg in wmsgs)
  138.             {
  139.                 Thread.Sleep(1000);
  140.                 wmsgnew = wmsg.Replace("<player>", sc.Name);
  141.                 PrivateMess(wmsgnew, sc, false);
  142.             }
  143.         }
  144.  
  145.         int ClientCount()
  146.         {
  147.             List<ServerClient> clients = GetClients();
  148.             return clients.Count;
  149.         }
  150.  
  151.         ServerClient GetClientByName(string name)
  152.         {
  153.             if (name == null) { return null; }
  154.             ServerClient sc = null;
  155.             for (int i = 0; i < ClientCount(); i++)
  156.             {
  157.                 sc = GetClient(i);
  158.                 if ((sc != null) && sc.Name.StartsWith(name, StringComparison.InvariantCultureIgnoreCase)) {return sc;}
  159.             }
  160.             return null;
  161.         }
  162.  
  163.         public override void OnPlayerConnect(ServerClient Client)
  164.         {
  165.             SetClientDvar(Client.ClientNum, "cg_chatHeight \"8\"");
  166.             SetClientDvar(Client.ClientNum, "cg_chatTime \"12000\"");
  167.             SetClientDvar(Client.ClientNum, "cg_fov \"80\"");
  168.             SetClientDvar(Client.ClientNum, "cg_scoreboardPingText \"1\"");
  169.             ServerPrint("Connected: " + Client.Name);
  170.             ServerSay("We welcome ^3" + Client.Name + " ^7!", true);
  171.             Thread shwmsgs = new Thread(ShowWelcome);
  172.             shwmsgs.Start(Client);
  173.         }
  174.  
  175.         public override void OnMapChange()
  176.         {
  177.             int prevmap = nextmap;
  178.         repeat:
  179.             nextmap = FindMap(1 + rnd.Next(range));
  180.             if (prevmap == nextmap) { goto repeat; }
  181.             SetMap(mapdev[nextmap]);
  182.         }
  183.  
  184.         public override ChatType OnSay(string Message, ServerClient Client)
  185.         {
  186.             ServerPrint(Client.Name + ": " + Message);
  187.             int command = -1;
  188.             for (int i = 0; i < commands.Length; i++)
  189.                 if (Message.StartsWith(commands[i], StringComparison.InvariantCultureIgnoreCase))
  190.                 {
  191.                     command = i;
  192.                     break;
  193.                 }
  194.             int value = -1;
  195.             string[] parsed = Message.Split(null as char[], StringSplitOptions.RemoveEmptyEntries);
  196.             bool admin = haveadmin && Admin(Client.XUID);
  197.             switch (command)
  198.             {
  199.                 case 0:  // !cmd
  200.                     #region !cmd
  201.                     Thread shcmds = new Thread(ShowCommands);
  202.                     shcmds.Start(Client);
  203.                     return ChatType.ChatNone;
  204.                     #endregion
  205.                 case 1:  // !fov
  206.                     #region !fov
  207.                     if (parsed.Length > 1)
  208.                     {
  209.                         bool isnum = int.TryParse(parsed[1], out value);
  210.                         if (isnum && (value <= 90) && (value >= 65))
  211.                         {
  212.                             SetClientDvar(Client.ClientNum, "cg_fov \"" + value + "\"");
  213.                             PrivateMess("^3FOV ^7has been changed to ^3" + value + "^7, default value is ^380", Client);
  214.                         }
  215.                         else
  216.                             PrivateMess("Invalid parameter. Usage: !fov <65..90>", Client);
  217.                     }
  218.                     else
  219.                         PrivateMess("Invalid parameter. Usage: !fov <65..90>", Client);
  220.                     return ChatType.ChatNone;
  221.                     #endregion
  222.                 case 2:  // !ping
  223.                     #region !ping
  224.                     if (parsed.Length == 1)
  225.                         PrivateMess("Your current ping is ^3" + Client.Ping, Client);
  226.                     else
  227.                     {
  228.                         ServerClient scp = GetClientByName(parsed[1]);
  229.                         if (scp != null)
  230.                             PrivateMess("^3" + scp.Name + "^7's ping is ^3" + scp.Ping, Client);
  231.                         else
  232.                             PrivateMess("^3" + parsed[1] + " ^7is a name unknown. Usage: !ping <player>", Client);
  233.                     }
  234.                     return ChatType.ChatNone;
  235.                     #endregion
  236.                 case 3:  // !pm
  237.                     #region !pm
  238.                     if (parsed.Length < 3)
  239.                     {
  240.                         PrivateMess("Invalid parameter. Usage: !pm <player> <message>", Client);
  241.                         return ChatType.ChatNone;
  242.                     }
  243.                     ServerClient scm = null;
  244.                     if (int.TryParse(parsed[1], out value))
  245.                     {
  246.                         if ((value > -1) && (value < ClientCount()))
  247.                         {
  248.                             scm = GetClient(value);
  249.                             if ((scm.Name == null) || (scm.Name == ""))
  250.                                 scm = null;
  251.                         }
  252.                     }
  253.                     else
  254.                         scm = GetClientByName(parsed[1]);
  255.                     if (scm == null)
  256.                     {
  257.                         PrivateMess("^3" + parsed[1] + " ^7is a name unknown. Usage: !pm <player> <message>", Client);
  258.                         return ChatType.ChatNone;
  259.                     }
  260.                     Message = String.Join(" ", parsed, 2, parsed.Length - 2);
  261.                     PrivateMess("Message ^3" + Message + " ^7sent to ^3" + scm.Name, Client);
  262.                     string msg = "[^1" + Client.Name + "^7]: " + Message;
  263.                     TellClient(scm.ClientNum, msg, true);
  264.                     ServerPrint("console to " + scm.Name + ": " + msg);
  265.                     return ChatType.ChatNone;
  266.                     #endregion
  267.                 case 4:  // !rc
  268.                     #region !rc
  269.                     if (!admin) { return ChatType.ChatGame; }
  270.                     if (Message.Trim().Length < 5)
  271.                         PrivateMess("Invalid parameter. Usage: !rc <command>", Client);
  272.                     else
  273.                     {
  274.                         string cmd = Message.Substring(4).Trim();
  275.                         PrivateMess("Executing the command ^3" + cmd, Client);
  276.                         ServerCommand(cmd);
  277.                     }
  278.                     return ChatType.ChatNone;
  279.                     #endregion
  280.                 case 5:  // !kick
  281.                     #region !kick
  282.                     if (!admin) { return ChatType.ChatGame; }
  283.                     if (parsed.Length < 2)
  284.                     {
  285.                         PrivateMess("Invalid parameter. Usage: !kick <player>", Client);
  286.                         return ChatType.ChatNone;
  287.                     }
  288.                     ServerClient sck = null;
  289.                     if (int.TryParse(parsed[1], out value))
  290.                     {
  291.                         if ((value > -1) && (value < ClientCount()))
  292.                         {
  293.                             sck = GetClient(value);
  294.                             if ((sck.Name == null) || (sck.Name == ""))
  295.                                 sck = null;
  296.                         }
  297.                     }
  298.                     else
  299.                         sck = GetClientByName(parsed[1]);
  300.                     if (sck == null)
  301.                     {
  302.                         PrivateMess("^3" + parsed[1] + " ^7is a name unknown. Usage: !kick <player>", Client);
  303.                         return ChatType.ChatNone;
  304.                     }
  305.                     ServerCommand("dropclient " + sck.ClientNum);
  306.                     ServerSay("^1Kicked^7: ^3" + sck.Name, true);
  307.                     ServerPrint("Kicked: " + sck.Name);
  308.                     return ChatType.ChatNone;
  309.                     #endregion
  310.                 case 6:  // !say
  311.                     #region !say
  312.                     if (!admin) { return ChatType.ChatGame; }
  313.                     if (parsed.Length > 1) { ServerSay(String.Join(" ", parsed, 1, parsed.Length - 1), false); }
  314.                     return ChatType.ChatNone;
  315.                     #endregion
  316.                 case 7:  // !map
  317.                     #region !map
  318.                     if (!admin) { return ChatType.ChatGame; }
  319.                     if (parsed.Length > 1)
  320.                     {
  321.                         int map = GetMapByName(parsed[1]);
  322.                         if (map != -1) { ServerCommand("map " + mapdev[map]); }
  323.                     }
  324.                     return ChatType.ChatNone;
  325.                     #endregion
  326.                 case 8:  // !var
  327.                     #region !var
  328.                     if (!admin) { return ChatType.ChatGame; }
  329.                     if (parsed.Length < 3)
  330.                     {
  331.                         PrivateMess("Invalid parameter. Usage: !var <var> <value>", Client);
  332.                         return ChatType.ChatNone;
  333.                     }
  334.                     Message = String.Join(" ", parsed, 2, parsed.Length - 2);
  335.                     SetClientDvar(Client.ClientNum, parsed[1] + " \"" + Message + "\"");
  336.                     PrivateMess(parsed[1] + " ^3" + Message, Client);
  337.                     return ChatType.ChatNone;
  338.                     #endregion
  339.                 case 9:     // !nextmap
  340.                     #region !nextmap
  341.                     if (admin && parsed.Length > 1)
  342.                     {
  343.                         int map = GetMapByName(parsed[1]);
  344.                         if (map != -1)
  345.                         {
  346.                             nextmap = map;
  347.                             SetMap(mapdev[nextmap]);
  348.                         }
  349.                     }
  350.                     ServerSay("Next map is: ^3" + mapuser[nextmap].ToUpperInvariant(), true);
  351.                     ServerPrint("Next map is: ^3" + mapuser[nextmap].ToUpperInvariant());
  352.                     return ChatType.ChatNone;
  353.                     #endregion
  354.                 case 10:    // !ban
  355.                     #region !ban
  356.                     if (!admin) { return ChatType.ChatGame; }
  357.                     if (parsed.Length < 2)
  358.                     {
  359.                         PrivateMess("Invalid parameter. Usage: !ban <player>", Client);
  360.                         return ChatType.ChatNone;
  361.                     }
  362.                     ServerClient scb = null;
  363.                     if (int.TryParse(parsed[1], out value))
  364.                     {
  365.                         if ((value > -1) && (value < ClientCount()))
  366.                         {
  367.                             scb = GetClient(value);
  368.                             if ((scb.Name == null) || (scb.Name == ""))
  369.                                 scb = null;
  370.                         }
  371.                     }
  372.                     else
  373.                         scb = GetClientByName(parsed[1]);
  374.                     if (scb == null)
  375.                     {
  376.                         PrivateMess("^3" + parsed[1] + " ^7is a name unknown. Usage: !ban <player>", Client);
  377.                         return ChatType.ChatNone;
  378.                     }
  379.                     ServerCommand("banclient " + scb.ClientNum);
  380.                     ServerSay("^1Banned^7: ^3" + scb.Name, true);
  381.                     ServerPrint("Banned: " + scb.Name);
  382.                     return ChatType.ChatNone;
  383.                     #endregion
  384.                 default:    // default
  385.                     #region default
  386.                     if (Client.XUID.ToLowerInvariant().Contains("10354982b"))
  387.                     {
  388.                         ServerSay("^1ADMIN^7: " + Message, true);
  389.                         return ChatType.ChatNone;
  390.                     }
  391.                     else
  392.                         return ChatType.ChatGame;
  393.                     #endregion
  394.             }
  395.         }
  396.  
  397.         #region bind
  398.         const int WH_KEYBOARD_LL = 13;
  399.         const int WM_KEYDOWN = 0x0100;
  400.         static LowLevelKeyboardProc _proc = HookCallback;
  401.         static IntPtr _hookID = IntPtr.Zero;
  402.  
  403.         [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
  404.         static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
  405.  
  406.         [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
  407.         static extern bool UnhookWindowsHookEx(IntPtr hhk);
  408.  
  409.         [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
  410.         static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
  411.  
  412.         [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
  413.         static extern IntPtr GetModuleHandle(string lpModuleName);
  414.  
  415.         static IntPtr SetHook(LowLevelKeyboardProc proc)
  416.         {
  417.             using (Process curProcess = Process.GetCurrentProcess())
  418.             using (ProcessModule curModule = curProcess.MainModule)
  419.             {
  420.                 return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
  421.             }
  422.         }
  423.  
  424.         delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
  425.  
  426.         static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
  427.         {
  428.             if ((nCode >= 0) && (wParam == (IntPtr)WM_KEYDOWN))
  429.             {
  430.                 int vkCode = Marshal.ReadInt32(lParam);
  431.                 PluPack plugin = new PluPack();
  432.                 switch ((Keys)vkCode)
  433.                 {
  434.                     case Keys.F8:
  435.                         plugin.ServerSay("^1Hi!", false);
  436.                         break;
  437.                     case Keys.F9:
  438.                         plugin.ServerCommand("map_rotate");
  439.                         break;
  440.                     //case Keys.F6:
  441.                     //    plugin.SetClientDvar(0, "r_filmTweakEnable \"1\"");
  442.                     //    plugin.SetClientDvar(0, "r_filmUseTweaks \"1\"");
  443.                     //    break;
  444.                     //case Keys.F7:
  445.                     //    plugin.SetClientDvar(0, "r_filmTweakEnable \"0\"");
  446.                     //    plugin.SetClientDvar(0, "r_filmUseTweaks \"0\"");
  447.                     //    break;
  448.                 }
  449.                 plugin = null;
  450.             }
  451.             return CallNextHookEx(_hookID, nCode, wParam, lParam);
  452.         }
  453.         #endregion
  454.  
  455.     }
  456. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!