UpdateXml() public static method

public static UpdateXml ( ) : void
return void
 public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
 {
     try
     {
         if (_params.Count < 1)
         {
             SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1 to 3, found {0}", _params.Count));
             return;
         }
         if (_params[0].ToLower().Equals("add"))
         {
             if (_params.Count != 2 && _params.Count != 3)
             {
                 SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 2 or 3, found {0}.", _params.Count));
                 return;
             }
             if (HighPingKicker._whiteListPlayers.ContainsKey(_params[1]))
             {
                 SdtdConsole.Instance.Output(string.Format("Can not add SteamId. {0} is already in the Ping Immunity list.", _params[1]));
                 return;
             }
             if (_params.Count == 2)
             {
                 HighPingKicker._whiteListPlayers.Add(_params[1], null);
                 SdtdConsole.Instance.Output(string.Format("Added SteamId {0} to the Ping Immunity list.", _params[1]));
             }
             else
             {
                 HighPingKicker._whiteListPlayers.Add(_params[1], _params[2]);
                 SdtdConsole.Instance.Output(string.Format("Added SteamId {0} with the name {1} the Ping Immunity list.", _params[1], _params[2]));
             }
             HighPingKicker.UpdateXml();
         }
         else if (_params[0].ToLower().Equals("remove"))
         {
             if (_params.Count != 2)
             {
                 SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 2, found {0}", _params.Count));
                 return;
             }
             if (!HighPingKicker._whiteListPlayers.ContainsKey(_params[1]))
             {
                 SdtdConsole.Instance.Output(string.Format("SteamId {0} was not found.", _params[1]));
                 return;
             }
             HighPingKicker._whiteListPlayers.Remove(_params[1]);
             SdtdConsole.Instance.Output(string.Format("Removed SteamId {0} from Ping Immunity list.", _params[1]));
             HighPingKicker.UpdateXml();
         }
         else if (_params[0].ToLower().Equals("list"))
         {
             if (_params.Count != 1)
             {
                 SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1, found {0}.", _params.Count));
                 return;
             }
             if (HighPingKicker.SteamId.Count < 1)
             {
                 SdtdConsole.Instance.Output("There are no steamIds on the Ping Immunity list.");
                 return;
             }
             foreach (string _steamid in HighPingKicker.SteamId)
             {
                 SdtdConsole.Instance.Output(_steamid);
             }
         }
         else
         {
             SdtdConsole.Instance.Output(string.Format("Invalid argument {0}.", _params[0]));
         }
     }
     catch (Exception e)
     {
         Log.Out(string.Format("Error in PingImmunityCommand.Run: {0}.", e));
     }
 }
Exemplo n.º 2
0
 public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
 {
     try
     {
         if (_params.Count < 1 || _params.Count > 3)
         {
             SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1 to 3, found {0}", _params.Count));
             return;
         }
         if (_params[0].ToLower().Equals("add"))
         {
             if (_params.Count != 3)
             {
                 SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 3, found {0}.", _params.Count));
                 return;
             }
             if (_params[1].Length != 17)
             {
                 SdtdConsole.Instance.Output(string.Format("Can not add SteamId: Invalid SteamId {0}", _params[1]));
                 return;
             }
             if (HighPingKicker.Dict.ContainsKey(_params[1]))
             {
                 SdtdConsole.Instance.Output(string.Format("Can not add SteamId. {0} is already in the Ping Immunity list.", _params[1]));
                 return;
             }
             HighPingKicker.Dict.Add(_params[1], _params[2]);
             SdtdConsole.Instance.Output(string.Format("Added SteamId {0} with the name of {1} the Ping Immunity list.", _params[1], _params[2]));
             HighPingKicker.UpdateXml();
         }
         else if (_params[0].ToLower().Equals("remove"))
         {
             if (_params.Count != 2)
             {
                 SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 2, found {0}", _params.Count));
                 return;
             }
             if (!HighPingKicker.Dict.ContainsKey(_params[1]))
             {
                 SdtdConsole.Instance.Output(string.Format("SteamId {0} was not found.", _params[1]));
                 return;
             }
             HighPingKicker.Dict.Remove(_params[1]);
             SdtdConsole.Instance.Output(string.Format("Removed SteamId {0} from Ping Immunity list.", _params[1]));
             HighPingKicker.UpdateXml();
         }
         else if (_params[0].ToLower().Equals("list"))
         {
             if (_params.Count != 1)
             {
                 SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1, found {0}.", _params.Count));
                 return;
             }
             if (HighPingKicker.Dict.Count < 1)
             {
                 SdtdConsole.Instance.Output("There are no steamIds on the Ping Immunity list.");
                 return;
             }
             foreach (KeyValuePair <string, string> _key in HighPingKicker.Dict)
             {
                 SdtdConsole.Instance.Output(string.Format("{0} {1}", _key.Key, _key.Value));
             }
         }
         else
         {
             SdtdConsole.Instance.Output(string.Format("Invalid argument {0}.", _params[0]));
         }
     }
     catch (Exception e)
     {
         Log.Out(string.Format("[SERVERTOOLS] Error in PingImmunityCommand.Run: {0}.", e));
     }
 }
Exemplo n.º 3
0
 public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
 {
     try
     {
         if (_params[0].ToLower().Equals("add"))
         {
             if (_params.Count != 2)
             {
                 SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}", _params.Count));
                 return;
             }
             ClientInfo _cInfo = ConsoleHelper.ParseParamIdOrName(_params[1]);
             if (_cInfo != null)
             {
                 if (HighPingKicker.Dict.ContainsKey(_cInfo.playerId))
                 {
                     SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add Id. {0} is already in the Ping Immunity list", _params[1]));
                 }
                 else
                 {
                     HighPingKicker.Dict.Add(_cInfo.playerId, _cInfo.playerName);
                     HighPingKicker.UpdateXml();
                     SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added Id {0} to the Ping Immunity list", _params[1]));
                 }
             }
             else
             {
                 if (_params[1].Length != 17)
                 {
                     SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player must be online or when offline use their steam Id which must be 17 numbers in length. Can not add Id: {0}", _params[1]));
                     return;
                 }
                 else
                 {
                     PersistentPlayerData _ppd = PersistentOperations.GetPersistentPlayerDataFromSteamId(_params[1]);
                     if (_ppd != null)
                     {
                         if (HighPingKicker.Dict.ContainsKey(_ppd.PlayerId))
                         {
                             SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add Id. {0} is already in the Ping Immunity list", _ppd.PlayerId));
                         }
                         else
                         {
                             PlayerDataFile _pdf = PersistentOperations.GetPlayerDataFileFromSteamId(_ppd.PlayerId);
                             if (_pdf != null)
                             {
                                 HighPingKicker.Dict.Add(_ppd.PlayerId, _pdf.ecd.entityName);
                                 HighPingKicker.UpdateXml();
                                 SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added Id {0}, with player name {1} to the Ping Immunity list", _params[1], _pdf.ecd.entityName));
                             }
                         }
                     }
                     else
                     {
                         SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add Id. {0} could not be found", _params[1]));
                     }
                 }
             }
         }
         else if (_params[0].ToLower().Equals("remove"))
         {
             if (_params.Count != 2)
             {
                 SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}", _params.Count));
                 return;
             }
             ClientInfo _cInfo = ConsoleHelper.ParseParamIdOrName(_params[1]);
             if (_cInfo != null)
             {
                 if (!HighPingKicker.Dict.ContainsKey(_cInfo.playerId))
                 {
                     SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not remove Id. {0} is not in the Ping Immunity list", _params[1]));
                 }
                 else
                 {
                     HighPingKicker.Dict.Remove(_cInfo.playerId);
                     HighPingKicker.UpdateXml();
                     SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed Id {0} from the Ping Immunity list", _params[1]));
                 }
             }
             else
             {
                 if (_params[1].Length != 17)
                 {
                     SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player must be online to use their name or entity id. Otherwise you must use their steam Id. Can not remove Id: {0}", _params[1]));
                     return;
                 }
                 else
                 {
                     if (!HighPingKicker.Dict.ContainsKey(_params[1]))
                     {
                         SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not remove Id. {0} is not in the Ping Immunity list", _params[1]));
                     }
                     else
                     {
                         HighPingKicker.Dict.Remove(_params[1]);
                         HighPingKicker.UpdateXml();
                         SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed Id {0} from the Ping Immunity list", _params[1]));
                     }
                 }
             }
         }
         else if (_params[0].ToLower().Equals("list"))
         {
             if (_params.Count != 1)
             {
                 SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
                 return;
             }
             else
             {
                 if (HighPingKicker.Dict.Count == 0)
                 {
                     SdtdConsole.Instance.Output("[SERVERTOOLS] There are no players on the Ping Immunity list.");
                     return;
                 }
                 else
                 {
                     SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] High Ping List:"));
                     foreach (KeyValuePair <string, string> _c in HighPingKicker.Dict)
                     {
                         SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player Id {0}, player name {1}", _c.Key, _c.Value));
                     }
                 }
             }
         }
         else
         {
             SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
         }
     }
     catch (Exception e)
     {
         Log.Out(string.Format("[SERVERTOOLS] Error in PingImmunityCommandConsole.Execute: {0}", e.Message));
     }
 }
Exemplo n.º 4
0
        public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
        {
            try
            {
                if (_params[0].ToLower().Equals("add"))
                {
                    if (_params.Count != 2)
                    {
                        SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found '{0}'", _params.Count));

                        return;
                    }
                    ClientInfo _cInfo = ConsoleHelper.ParseParamIdOrName(_params[1]);
                    if (_cInfo != null)
                    {
                        if (HighPingKicker.Dict.ContainsKey(_cInfo.CrossplatformId.CombinedString))
                        {
                            SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not add Id. '{0}' is already in the ping immunity list", _params[1]));
                        }
                        else
                        {
                            HighPingKicker.Dict.Add(_cInfo.CrossplatformId.CombinedString, _cInfo.playerName);
                            HighPingKicker.UpdateXml();
                            SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added Id '{0}' to the ping immunity list", _params[1]));
                        }
                    }
                    else if (_params[1].Contains("_"))
                    {
                        PersistentPlayerData ppd = PersistentOperations.GetPersistentPlayerDataFromId(_params[1]);
                        if (ppd != null)
                        {
                            if (HighPingKicker.Dict.ContainsKey(ppd.UserIdentifier.CombinedString))
                            {
                                SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not add Id. '{0}' named '{1}' is already in the ping immunity list", ppd.UserIdentifier.CombinedString, ppd.PlayerName));
                            }
                            else
                            {
                                HighPingKicker.Dict.Add(ppd.UserIdentifier.CombinedString, ppd.PlayerName);
                                HighPingKicker.UpdateXml();
                                SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added Id '{0}' named '{1}' to the ping immunity list", ppd.UserIdentifier.CombinedString, ppd.PlayerName));
                            }
                        }
                        else
                        {
                            SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not add Id. No data for '{0}' could not be found", _params[1]));
                        }
                    }
                }
                else if (_params[0].ToLower().Equals("remove"))
                {
                    if (_params.Count != 2)
                    {
                        SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found '{0}'", _params.Count));

                        return;
                    }
                    ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
                    if (cInfo != null)
                    {
                        if (!HighPingKicker.Dict.ContainsKey(cInfo.CrossplatformId.CombinedString))
                        {
                            SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not remove Id '{0}'. It is not in the ping immunity list", _params[1]));
                        }
                        else
                        {
                            HighPingKicker.Dict.Remove(cInfo.CrossplatformId.CombinedString);
                            HighPingKicker.UpdateXml();
                            SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed Id '{0}' from the ping immunity list", _params[1]));
                        }
                    }
                    else if (_params[1].Contains("_"))
                    {
                        PersistentPlayerData ppd = PersistentOperations.GetPersistentPlayerDataFromId(_params[1]);
                        if (ppd != null)
                        {
                            if (!HighPingKicker.Dict.ContainsKey(_params[1]))
                            {
                                SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not remove Id '{0}'. It is not in the ping immunity list", _params[1]));
                            }
                            else
                            {
                                HighPingKicker.Dict.Remove(_params[1]);
                                HighPingKicker.UpdateXml();
                                SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed Id {0} from the ping immunity list", _params[1]));
                            }
                        }
                        else
                        {
                            SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not remove Id '{0}'. No data could not be found", _params[1]));
                        }
                    }
                }
                else if (_params[0].ToLower().Equals("list"))
                {
                    if (_params.Count != 1)
                    {
                        SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found '{0}'", _params.Count));

                        return;
                    }
                    else
                    {
                        if (HighPingKicker.Dict.Count == 0)
                        {
                            SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] There are no players on the ping immunity list");

                            return;
                        }
                        else
                        {
                            SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] High ping immunity list:"));

                            foreach (KeyValuePair <string, string> _c in HighPingKicker.Dict)
                            {
                                SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id '{0}' named '{1}'", _c.Key, _c.Value));
                            }
                        }
                    }
                }
                else
                {
                    SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
                }
            }
            catch (Exception e)
            {
                Log.Out(string.Format("[SERVERTOOLS] Error in PingImmunityCommandConsole.Execute: {0}", e.Message));
            }
        }