public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (StartingItems.IsEnabled)
{
StartingItems.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Starting items has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Starting items is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!StartingItems.IsEnabled)
{
StartingItems.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Starting items has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Starting items is already on"));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
return;
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in StartingItemsConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (ChatHook.Normal_Player_Color_Prefix)
{
ChatHook.Normal_Player_Color_Prefix = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Normal player coloring has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Normal player coloring is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (ChatHook.Normal_Player_Color_Prefix)
{
ChatHook.Normal_Player_Color_Prefix = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Normal player coloring has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Normal player coloring is already on"));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in NormalPlayerColoringConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (ChatHook.ChatFlood)
{
ChatHook.ChatFlood = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Chat flood protection has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Chat flood protection is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!ChatHook.ChatFlood)
{
ChatHook.ChatFlood = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Chat flood protection has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Chat flood protection is already on"));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ChatFloodProtectionConsole.Execute: {0}", e.Message));
}
}
public static void GetCurrencyName()
{
List <ItemClass> itemClassCurrency = ItemClass.GetItemsWithTag(FastTags.Parse("currency"));
if (itemClassCurrency != null && itemClassCurrency.Count > 0)
{
Currency_Item = itemClassCurrency[0].Name;
Log.Out(string.Format("[SERVERTOOLS] Wallet and Bank tool set to utilize item named '{0}'", Currency_Item));
}
else
{
No_Currency = true;
Wallet.IsEnabled = false;
Bank.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
Log.Out(string.Format("[SERVERTOOLS] Unable to find an item with the tag 'currency' in the item list. Wallet and Bank tool are disabled until server restart"));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Homes.IsEnabled)
{
Homes.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Homes has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Homes is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Homes.IsEnabled)
{
Homes.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Homes has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Homes is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("reset"))
{
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 (PersistentContainer.Instance.Players[cInfo.CrossplatformId.CombinedString] != null)
{
PersistentContainer.Instance.Players[cInfo.CrossplatformId.CombinedString].LastHome = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Home tool delay reset for '{0}'", _params[1]));
}
}
else if (PersistentContainer.Instance.Players[_params[1]] != null)
{
PersistentContainer.Instance.Players[_params[1]].LastHome = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Home tool delay reset for '{0}'", _params[1]));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Player with EOS id '{0}' does not have a Home tool delay to reset", _params[1]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in HomeConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count > 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 0 or 1, found {0}", _params.Count));
return;
}
if (_params.Count == 0)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Starting backup"));
AutoBackup.Exec();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Backup complete"));
return;
}
else if (_params[0].ToLower().Equals("off"))
{
if (AutoBackup.IsEnabled)
{
AutoBackup.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Auto backup has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Auto backup is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!AutoBackup.IsEnabled)
{
AutoBackup.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Auto backup has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Auto backup is already on"));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in AutoBackup.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1 && _params.Count != 2 && _params.Count != 7)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, 2 or 7, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Shop.IsEnabled)
{
Shop.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Shop has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Shop is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Shop.IsEnabled)
{
Shop.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Shop has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Shop is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 7)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 7, found '{0}'", _params.Count));
return;
}
else
{
if (Shop.IsEnabled)
{
ItemValue _itemValue = ItemClass.GetItem(_params[1], false);
if (_itemValue.type == ItemValue.None.type)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Item could not be found '{0}'", _params[1]));
return;
}
else
{
if (!int.TryParse(_params[3], out int _count))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid item count '{0}'", _params[3]));
return;
}
else
{
if (_count > _itemValue.ItemClass.Stacknumber.Value)
{
_count = _itemValue.ItemClass.Stacknumber.Value;
}
if (!int.TryParse(_params[4], out int _quality))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid item quality '{0}'", _params[4]));
return;
}
else
{
if (!int.TryParse(_params[5], out int _price))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid item price '{0}'", _params[5]));
return;
}
else
{
if (_quality < 1)
{
_quality = 1;
}
else if (_quality > 600)
{
_quality = 600;
}
int _id = Shop.Dict.Count + 1;
string[] _item = new string[] { _id.ToString(), _params[1], _params[2], _params[3], _params[4], _params[5], _params[6] };
if (!Shop.Dict.Contains(_item))
{
if (!Shop.Categories.Contains(_params[6]))
{
Shop.Categories.Add(_params[6]);
}
Shop.Dict.Add(_item);
Shop.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Item {0} has been added to the shop", _params[1]));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to add item to Shop.xml. Entry is already on the list"));
return;
}
}
}
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Shop is not enabled. Unable to write to the xml file"));
return;
}
}
}
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;
}
else if (_params[1] != "0")
{
if (!int.TryParse(_params[1], out int _number))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid id '{0}'", _params[1]));
return;
}
if (Shop.Dict.Count >= _number - 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id '{0}' not found on the shop list", _params[1]));
return;
}
else
{
Shop.Dict.RemoveAt(_number - 1);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id '{0}' has been removed from the shop list", _number));
return;
}
}
}
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 (Shop.Dict.Count > 0)
{
for (int i = 0; i < Shop.Dict.Count; i++)
{
string[] _item = Shop.Dict[i];
if (int.Parse(_item[4]) > 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] # {0}: '{1}' '{2}' at '{3}' quality for '{4}' '{5}'", _item[0], _item[3], _item[2], _item[4], _item[5], Wallet.Currency_Name));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] # {0}: '{1}' '{2}' for '{3}' '{4}'", _item[0], _item[3], _item[2], _item[5], Wallet.Currency_Name));
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Shop list is empty"));
return;
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
return;
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ShopConsole.Execute: {0}", e.Message));
}
}
public static void Load()
{
if (!Directory.Exists(API.ConfigPath))
{
Directory.CreateDirectory(API.ConfigPath);
Log.Out(string.Format("[SERVERTOOLS] Created new directory '{0}'", API.ConfigPath));
}
else
{
Log.Out(string.Format("[SERVERTOOLS] Located directory '{0}'", API.ConfigPath));
}
if (!Directory.Exists(API.ConfigPath + "/Logs/ChatLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/ChatLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/DetectionLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/DetectionLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/BountyLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/BountyLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/AuctionLog"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/AuctionLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/BankLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/BankLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/DupeLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/DupeLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/PlayerLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/PlayerLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/PlayerReports"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/PlayerReports");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/PollLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/PollLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/ChatCommandLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/ChatCommandLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/DamageLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/DamageLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/BlockLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/BlockLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/ConsoleCommandLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/ConsoleCommandLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/WebPanelLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/WebPanelLogs");
}
if (!Directory.Exists(API.ConfigPath + "/Logs/OutputLogs"))
{
Directory.CreateDirectory(API.ConfigPath + "/Logs/OutputLogs");
}
if (!Directory.Exists(API.GamePath + "/Mods/ServerTools/Config"))
{
Directory.CreateDirectory(API.GamePath + "/Mods/ServerTools/Config");
}
if (!Directory.Exists(API.GamePath + "/Mods/ServerTools/Config/XUi"))
{
Directory.CreateDirectory(API.GamePath + "/Mods/ServerTools/Config/XUi");
}
StateManager.Awake();
RunTimePatch.PatchAll();
Config.Load();
Log.Out("[SERVERTOOLS] Running ServerTools v.{0}", Config.Version);
CommandList.BuildList();
CommandList.Load();
PersistentOperations.SetFolders();
PersistentOperations.CreateCustomXUi();
PersistentOperations.GetCurrencyName();
PersistentOperations.EntityIdList();
PersistentOperations.Player_Killing_Mode = GamePrefs.GetInt(EnumGamePrefs.PlayerKillingMode);
Mods.Load();
Phrases.Load();
HowToSetup.Load();
if (Fps.IsEnabled)
{
Fps.SetTarget();
}
if (SleeperRespawn.IsEnabled)
{
try
{
SingletonMonoBehaviour <SdtdConsole> .Instance.ExecuteSync(string.Format("sleeperreset"), null);
}
catch (XmlException e)
{
Log.Out("[SERVERTOOLS] Failed to reset sleeper spawn points. Error = {0}", e.Message);
}
}
try
{
DeleteFiles("DetectionLogs");
DeleteFiles("BountyLogs");
DeleteFiles("AuctionLogs");
DeleteFiles("BankLogs");
DeleteFiles("DupeLogs");
DeleteFiles("PlayerLogs");
DeleteFiles("PlayerReports");
DeleteFiles("PollLogs");
DeleteFiles("ChatLogs");
DeleteFiles("ChatCommandLogs");
DeleteFiles("DamageLogs");
DeleteFiles("BlockLogs");
DeleteFiles("ConsoleCommandLogs");
DeleteFiles("WebPanelLogs");
DeleteFiles("OutputLogs");
Log.Out(string.Format("[SERVERTOOLS] Xml log clean up complete"));
}
catch (XmlException e)
{
Log.Out("[SERVERTOOLS] Failed to delete old logs. Error = {0}", e.Message);
}
if (PersistentContainer.Instance.WorldSeed == 0)
{
PersistentContainer.Instance.WorldSeed = GameManager.Instance.World.Seed;
PersistentContainer.DataChange = true;
}
else if (PersistentContainer.Instance.WorldSeed != GameManager.Instance.World.Seed)
{
PersistentContainer.Instance.WorldSeed = GameManager.Instance.World.Seed;
PersistentContainer.DataChange = true;
if (!CleanBin.IsEnabled && PersistentContainer.Instance.Players.IDs.Count > 0)
{
Log.Out("[SERVERTOOLS] Detected a new world. You have old ServerTools data saved from the last map. Run the Clean_Bin tool to remove the data of your choice");
}
}
if (PersistentContainer.Instance.Connections == null)
{
Dictionary <string, byte[]> connections = new Dictionary <string, byte[]>();
PersistentContainer.Instance.Connections = connections;
Dictionary <string, DateTime> timeOuts = new Dictionary <string, DateTime>();
PersistentContainer.Instance.ConnectionTimeOut = timeOuts;
PersistentContainer.DataChange = true;
}
if (CleanBin.IsEnabled)
{
CleanBin.Exec();
Log.Out("[SERVERTOOLS] ServerTools.bin has been cleaned. The tool will now disable automatically");
CleanBin.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
}
Track.Cleanup();
DroppedBagProtection.BuildList();
BlackJack.BuildDeck();
ActiveTools.Exec(true);
Timers.Thirty_Second_Delay();
Timers.PersistentDataSave();
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count == 3 || _params.Count == 4 || _params.Count > 5)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, 2 or 5, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Track.IsEnabled)
{
Track.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Tracking has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Tracking is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Track.IsEnabled)
{
Track.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Tracking has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Tracking is already on"));
return;
}
}
else if (_params.Count == 2)
{
if (PersistentContainer.Instance.Track != null && PersistentContainer.Instance.Track.Count > 0)
{
bool _found = false;
if (int.TryParse(_params[0], out int _hours))
{
if (_hours > 48)
{
_hours = 48;
}
if (int.TryParse(_params[1], out int _range))
{
EntityPlayer player = PersistentOperations.GetEntityPlayer(_senderInfo.RemoteClientInfo.entityId);
if (player != null)
{
List <string[]> _tracking = PersistentContainer.Instance.Track;
for (int i = 0; i < _tracking.Count; i++)
{
string[] _trackData = _tracking[i];
DateTime.TryParse(_trackData[0], out DateTime _date);
if (_date.AddHours(_hours) >= DateTime.Now)
{
string[] _cords = _trackData[1].Split(',');
int.TryParse(_cords[0], out int _x);
int.TryParse(_cords[1], out int _y);
int.TryParse(_cords[2], out int _z);
Vector3 _trackedVecPos = new Vector3(_x, _y, _z);
if (RangeCheck(player.position, _trackedVecPos, _range))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Player '{0}' Id '{1}' Time '{2}' Position '{3}' Item Held '{4}'", _trackData[3], _trackData[2], _trackData[0], _trackData[1], _trackData[4]));
}
}
}
}
if (!_found)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Tracking log lists nobody at this time and range from your current position");
}
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[1]));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Tracking log has no data");
return;
}
}
else if (_params.Count == 5)
{
if (PersistentContainer.Instance.Track != null && PersistentContainer.Instance.Track.Count > 0)
{
bool _found = false;
if (int.TryParse(_params[0], out int _hours))
{
if (int.TryParse(_params[1], out int _range))
{
if (int.TryParse(_params[2], out int _worldX))
{
if (int.TryParse(_params[3], out int _worldY))
{
if (int.TryParse(_params[4], out int _worldZ))
{
EntityPlayer _player = GameManager.Instance.World.Players.dict[_senderInfo.RemoteClientInfo.entityId];
if (_player != null)
{
List <string[]> _tracking = PersistentContainer.Instance.Track;
for (int i = 0; i < _tracking.Count; i++)
{
string[] _trackData = _tracking[i];
DateTime.TryParse(_trackData[0], out DateTime _date);
if (_date.AddHours(_hours) >= DateTime.Now)
{
Vector3 _trackedVecPos = new Vector3(_worldX, _worldY, _worldZ);
if (RangeCheck(_player.position, _trackedVecPos, _range))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Player '{0}' Id '{1}' Time '{2}' Position '{3}' Item Held '{4}'", _trackData[3], _trackData[2], _trackData[0], _trackData[1], _trackData[4]));
}
}
}
}
if (!_found)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Tracking results found nobody at this time and range inside the specified position"));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[4]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[3]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[2]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[1]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Tracking log has no data");
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Invalid arguments");
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in TrackingConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1 && _params.Count != 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 or 2, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (WorldRadius.IsEnabled)
{
WorldRadius.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] World radius has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] World radius is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!WorldRadius.IsEnabled)
{
WorldRadius.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] World radius has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] World radius is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("normal"))
{
if (_params.Count != 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found '{0}'", _params.Count));
return;
}
int _radius = WorldRadius.Normal_Player;
if (int.TryParse(_params[1], out _radius))
{
WorldRadius.Normal_Player = _radius;
Config.WriteXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] World radius for normal players has been set to '{0}'", _radius));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid integer '{0}'", _params[1]));
return;
}
}
else if (_params[0].ToLower().Equals("reserved"))
{
if (_params.Count != 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found '{0}'", _params.Count));
return;
}
int _radius = WorldRadius.Reserved;
if (int.TryParse(_params[1], out _radius))
{
WorldRadius.Reserved = _radius;
Config.WriteXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] World radius for reserved players has been set to '{0}'", _radius));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid integer '{0}'", _params[1]));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in WorldRadiusConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 or 2, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (VoteReward.IsEnabled)
{
VoteReward.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Vote reward has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Vote reward is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!VoteReward.IsEnabled)
{
VoteReward.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Vote reward has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Vote reward is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("reset"))
{
if (_params.Count != 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found '{0}'", _params.Count));
return;
}
if (_params[1].ToLower().Equals("online"))
{
List <ClientInfo> ClientInfoList = ConnectionManager.Instance.Clients.List.ToList();
for (int i = 0; i < ClientInfoList.Count; i++)
{
ClientInfo _cInfo2 = ClientInfoList[i];
if (_cInfo2 != null)
{
PersistentContainer.Instance.Players[_cInfo2.CrossplatformId.CombinedString].LastVote = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Vote reward delay reset for '{0}'", _cInfo2.playerName));
}
}
return;
}
if (_params[1].ToLower().Equals("all"))
{
if (PersistentContainer.Instance.Players.IDs.Count > 0)
{
for (int i = 0; i < PersistentContainer.Instance.Players.IDs.Count; i++)
{
PersistentContainer.Instance.Players[PersistentContainer.Instance.Players.IDs[i]].LastVote = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Vote reward delay reset for all players");
return;
}
}
else
{
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
if (cInfo != null)
{
PersistentContainer.Instance.Players[cInfo.CrossplatformId.CombinedString].LastVote = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Vote reward delay reset for '{0}'", cInfo.playerName));
}
else if (_params[1].Contains("_"))
{
PersistentPlayer p = PersistentContainer.Instance.Players[_params[1]];
if (p != null)
{
PersistentContainer.Instance.Players[_params[1]].LastVote = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Vote reward delay reset for '{0}'", _params[1]));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Id '{0}' does not have a vote reward delay to reset", _params[1]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Invalid Id '{0}'", _params[1]));
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in VotingConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 or 2, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (AnimalTracking.IsEnabled)
{
AnimalTracking.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Animal tracking has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Animal tracking is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!AnimalTracking.IsEnabled)
{
AnimalTracking.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Animal tracking has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Animal tracking is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("reset"))
{
if (_params[1].ToLower().Equals("all"))
{
for (int i = 0; i < PersistentContainer.Instance.Players.IDs.Count; i++)
{
string _id = PersistentContainer.Instance.Players.IDs[i];
PersistentPlayer p = PersistentContainer.Instance.Players[_id];
{
PersistentContainer.Instance.Players[_id].LastAnimal = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
}
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Animal tracking delay reset for all players");
}
else
{
ClientInfo cInfo = ConsoleHelper.ParseParamIdOrName(_params[1]);
if (cInfo != null)
{
PersistentContainer.Instance.Players[_params[1]].LastAnimal = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Animal tracking delay reset for {0}", cInfo.playerName));
}
else
{
if (_params[1].Length != 17)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not reset Id: Invalid Id {0}", _params[1]));
return;
}
PersistentContainer.Instance.Players[_params[1]].LastAnimal = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Animal tracking delay reset for {0}", _params[1]));
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in AnimalTrackingConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 to 3, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (WatchList.IsEnabled)
{
WatchList.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Watch list has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Watch list is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!WatchList.IsEnabled)
{
WatchList.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Watch list has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Watch list is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 3, found '{0}'", _params.Count));
return;
}
if (_params[1].Contains("_"))
{
if (WatchList.Dict.ContainsKey(_params[1]))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not add '{0}'. Id is already in the watchlist", _params[1]));
return;
}
WatchList.Dict.Add(_params[1], _params[2]);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added Id '{0}' with the reason '{1}' to the watchlist", _params[1], _params[2]));
WatchList.UpdateXml();
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid Id '{0}'", _params[1]));
return;
}
}
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;
}
if (_params[1].Contains("_"))
{
if (!WatchList.Dict.ContainsKey(_params[1]))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id '{0}' was not found on the list", _params[1]));
return;
}
WatchList.Dict.Remove(_params[1]);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed Id '{0}' from the watchlist", _params[1]));
WatchList.UpdateXml();
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid Id '{0}'", _params[1]));
return;
}
}
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;
}
if (WatchList.Dict.Count < 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] There are no Id on the watchlist");
return;
}
foreach (KeyValuePair <string, string> _key in WatchList.Dict)
{
string _output = string.Format("{0} {1}", _key.Key, _key.Value);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(_output);
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in WatchlistConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 to 3, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (WebAPI.IsEnabled)
{
WebAPI.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Web panel has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Web panel is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!WebAPI.IsEnabled)
{
WebAPI.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Web panel has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Web panel is already on"));
return;
}
}
else 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;
}
else if (_params[1].Length < 6 || _params[1].Length > 30)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Client id must be 6 - 30 characters in length, found '{0}'", _params[1].Length));
return;
}
else
{
string password = PersistentOperations.CreatePassword(16);
if (!PersistentContainer.Instance.Players.Players.ContainsKey(_params[1]))
{
PersistentContainer.Instance.Players.Players.Add(_params[1], new PersistentPlayer(_params[1]));
}
PersistentContainer.Instance.Players[_params[1]].WebPass = password;
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added '{0}' to the web panel client list. Their password is '{1}'", _params[1], password));
return;
}
}
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;
}
else if (_params[1].Length < 6 || _params[1].Length > 30)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Client id must be 6 - 30 characters in length, found '{0}'", _params[1].Length));
return;
}
else
{
if (PersistentContainer.Instance.Players[_params[1]].WebPass != null && PersistentContainer.Instance.Players[_params[1]].WebPass != "")
{
PersistentContainer.Instance.Players[_params[1]].WebPass = "";
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed '{0}' from the web panel client list", _params[1]));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] '{0}' is not on the web panel client list", _params[1]));
}
return;
}
}
else if (_params[0].ToLower().Equals("reset"))
{
if (_params.Count != 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found '{0}'", _params.Count));
return;
}
else if (_params[1].Length < 6 || _params[1].Length > 30)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Client id must be 6 - 30 characters in length, found '{0}'", _params[1].Length));
return;
}
else
{
if (PersistentContainer.Instance.Players[_params[1]].WebPass != null && PersistentContainer.Instance.Players[_params[1]].WebPass != "")
{
string password = PersistentOperations.CreatePassword(16);
PersistentContainer.Instance.Players[_params[1]].WebPass = password;
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Client '{0}' has been reset. Their password is '{1}'", _params[1], password));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] '{0}' is not on the web panel client list", _params[1]));
return;
}
}
}
else if (_params[0].ToLower().Equals("reset") && _params[1].ToLower().Equals("all"))
{
if (WebAPI.IsEnabled)
{
WebAPI.AuthorizedIvKey.Clear();
WebAPI.AuthorizedTime.Clear();
WebAPI.Visitor.Clear();
WebAPI.PageHits.Clear();
WebAPI.LoginAttempts.Clear();
WebAPI.TimeOut.Clear();
if (PersistentContainer.Instance.WebTimeoutList != null && PersistentContainer.Instance.WebTimeoutList.Count > 0)
{
PersistentContainer.Instance.WebTimeoutList.Clear();
PersistentContainer.DataChange = true;
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Web panel has been reset of all session data. Clients must relog"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Web API is not enabled. There is no web panel data to clear"));
return;
}
}
else if (_params[0].ToLower().Equals("timeout"))
{
if (_params.Count != 2 && _params.Count != 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2 or 3, found '{0}'", _params.Count));
return;
}
else if (_params[1].ToLower() == "add")
{
string ip = _params[2];
if (!WebAPI.TimeOut.ContainsKey(ip))
{
WebAPI.TimeOut.Add(ip, DateTime.Now.AddMinutes(5));
if (PersistentContainer.Instance.WebTimeoutList != null)
{
PersistentContainer.Instance.WebTimeoutList.Add(ip, DateTime.Now.AddMinutes(5));
}
else
{
Dictionary <string, DateTime> timeouts = new Dictionary <string, DateTime>();
timeouts.Add(ip, DateTime.Now.AddMinutes(5));
PersistentContainer.Instance.WebTimeoutList = timeouts;
}
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] IP '{0}' has been added to the timeout list", ip));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not add IP '{0}'. It is already on the timeout list", ip));
return;
}
}
else if (_params[1].ToLower() == "remove")
{
string ip = _params[2];
if (WebAPI.TimeOut.ContainsKey(ip))
{
WebAPI.TimeOut.Remove(ip);
PersistentContainer.Instance.WebTimeoutList.Remove(ip);
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] IP '{0}' has been removed from the timeout list", ip));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not remove IP '{0}'. It is not on the timeout list", ip));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[1]));
}
}
else if (_params[0].ToLower().Equals("ban"))
{
if (_params.Count != 2 && _params.Count != 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2 or 3, found '{0}'", _params.Count));
return;
}
else if (_params[1].ToLower() == "add")
{
string ip = _params[2];
if (!WebAPI.Ban.Contains(ip))
{
WebAPI.Ban.Add(ip);
if (PersistentContainer.Instance.WebBanList != null)
{
PersistentContainer.Instance.WebBanList.Add(ip);
}
else
{
List <string> bans = new List <string>();
bans.Add(ip);
PersistentContainer.Instance.WebBanList = bans;
}
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] IP '{0}' has been added to the ban list", ip));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not add IP '{0}'. It is already on the ban list", ip));
return;
}
}
else if (_params[1].ToLower() == "remove")
{
string ip = _params[2];
if (WebAPI.Ban.Contains(ip))
{
WebAPI.Ban.Remove(ip);
if (PersistentContainer.Instance.WebBanList != null)
{
PersistentContainer.Instance.WebBanList.Remove(ip);
PersistentContainer.DataChange = true;
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] IP '{0}' has been removed from the ban list", ip));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not remove IP '{0}'. It is not on the ban list", ip));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[1]));
}
}
else if (_params[0].ToLower().Equals("list"))
{
List <string> _steamId = PersistentContainer.Instance.Players.IDs;
if (_steamId != null && _steamId.Count > 0)
{
for (int i = 0; i < _steamId.Count; i++)
{
if (!string.IsNullOrWhiteSpace(PersistentContainer.Instance.Players[_steamId[i]].WebPass))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Client id '{0}'", _steamId[i]));
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] There are no clients on the web panel list"));
}
if (WebAPI.TimeOut.Count > 0)
{
foreach (var timeout in WebAPI.TimeOut)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Timed out IP '{0}'. Lasts until '{1}'", timeout.Key, timeout.Value.AddMinutes(10)));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] There are no timed out ip address"));
}
if (WebAPI.Ban.Count > 0)
{
for (int i = 0; i < WebAPI.Ban.Count; i++)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Banned IP '{0}'", WebAPI.Ban[i]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] There are no banned ip address"));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in WebAPIConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (CleanBin.IsEnabled)
{
CleanBin.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Clean bin has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Clean bin is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!CleanBin.IsEnabled)
{
CleanBin.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Clean bin has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Clean bin is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("now"))
{
CleanBin.Exec();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] ServerTools.bin has been cleaned based on the active options");
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in CleanBinConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 && _params.Count > 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 or 2, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Auction.IsEnabled)
{
Auction.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Auction has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Auction is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Auction.IsEnabled)
{
Auction.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Auction has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Auction is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("cancel"))
{
if (_params.Count != 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}", _params.Count));
return;
}
if (int.TryParse(_params[1], out int _id))
{
if (Auction.AuctionItems.ContainsKey(_id))
{
Auction.AuctionItems.TryGetValue(_id, out string playerId);
if (PersistentContainer.Instance.Players[playerId].Auction != null && PersistentContainer.Instance.Players[playerId].Auction.Count > 0)
{
if (PersistentContainer.Instance.Players[playerId].Auction.ContainsKey(_id))
{
if (PersistentContainer.Instance.Players[playerId].Auction.TryGetValue(_id, out ItemDataSerializable _itemData))
{
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(playerId);
if (cInfo != null)
{
ItemValue itemValue = new ItemValue(ItemClass.GetItem(_itemData.name, false).type, false);
if (itemValue != null)
{
itemValue.UseTimes = _itemData.useTimes;
itemValue.Quality = _itemData.quality;
World world = GameManager.Instance.World;
var entityItem = (EntityItem)EntityFactory.CreateEntity(new EntityCreationData
{
entityClass = EntityClass.FromString("item"),
id = EntityFactory.nextEntityID++,
itemStack = new ItemStack(itemValue, _itemData.count),
pos = world.Players.dict[cInfo.entityId].position,
rot = new UnityEngine.Vector3(20f, 0f, 20f),
lifetime = 60f,
belongsPlayerId = cInfo.entityId
});
world.SpawnEntityInWorld(entityItem);
cInfo.SendPackage(NetPackageManager.GetPackage <NetPackageEntityCollect>().Setup(entityItem.entityId, cInfo.entityId));
world.RemoveEntity(entityItem.entityId, EnumRemoveEntityReason.Despawned);
Auction.AuctionItems.Remove(_id);
PersistentContainer.Instance.Players[playerId].Auction.Remove(_id);
PersistentContainer.Instance.AuctionPrices.Remove(_id);
PersistentContainer.DataChange = true;
using (StreamWriter sw = new StreamWriter(filepath, true, Encoding.UTF8))
{
sw.WriteLine(string.Format("{0}: {1} {2} had their auction entry # {3} cancelled via console by {4}.", DateTime.Now, cInfo.PlatformId.ReadablePlatformUserIdentifier, cInfo.playerName, _id, _senderInfo.RemoteClientInfo.PlatformId.ReadablePlatformUserIdentifier));
sw.WriteLine();
sw.Flush();
sw.Close();
}
ChatHook.ChatMessage(cInfo, Config.Chat_Response_Color + "Your auction item has returned to you.[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
else
{
Auction.AuctionItems.Remove(_id);
PersistentContainer.Instance.Players[playerId].Auction.Remove(_id);
PersistentContainer.Instance.AuctionPrices.Remove(_id);
PersistentContainer.DataChange = true;
}
}
else
{
if (PersistentContainer.Instance.Players[playerId].AuctionReturn != null && PersistentContainer.Instance.Players[playerId].AuctionReturn.Count > 0)
{
PersistentContainer.Instance.Players[playerId].AuctionReturn.Add(_id, _itemData);
}
else
{
Dictionary <int, ItemDataSerializable> _auctionReturn = new Dictionary <int, ItemDataSerializable>();
_auctionReturn.Add(_id, _itemData);
PersistentContainer.Instance.Players[playerId].AuctionReturn = _auctionReturn;
}
Auction.AuctionItems.Remove(_id);
PersistentContainer.Instance.Players[playerId].Auction.Remove(_id);
PersistentContainer.Instance.AuctionPrices.Remove(_id);
PersistentContainer.DataChange = true;
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id {0} has been removed from the auction list", _id));
}
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Could not find this id listed in the auction. Unable to cancel[-]");
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid integer {0}", _id));
}
return;
}
else if (_params[0].ToLower().Equals("clear"))
{
if (_params.Count != 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}", _params.Count));
}
if (int.TryParse(_params[1], out int _id))
{
if (Auction.AuctionItems.ContainsKey(_id))
{
Auction.AuctionItems.TryGetValue(_id, out string _playerId);
Auction.AuctionItems.Remove(_id);
if (PersistentContainer.Instance.Players[_playerId].Auction != null && PersistentContainer.Instance.Players[_playerId].Auction.Count > 0)
{
PersistentContainer.Instance.Players[_playerId].Auction.Remove(_id);
}
if (PersistentContainer.Instance.AuctionPrices != null && PersistentContainer.Instance.AuctionPrices.Count > 0)
{
PersistentContainer.Instance.AuctionPrices.Remove(_id);
}
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id {0} has been removed from the auction", _id));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Auction does not contain id {0}", _id));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid integer {0}", _id));
}
return;
}
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;
}
if (Auction.AuctionItems.Count > 0)
{
if (PersistentContainer.Instance.Players.IDs.Count > 0)
{
List <string> playerlist = PersistentContainer.Instance.Players.IDs;
Dictionary <int, int> _auctionPrices = PersistentContainer.Instance.AuctionPrices;
for (int i = 0; i < playerlist.Count; i++)
{
string id = playerlist[i];
if (PersistentContainer.Instance.Players[id].Auction != null && PersistentContainer.Instance.Players[id].Auction.Count > 0)
{
foreach (var auctionItem in PersistentContainer.Instance.Players[id].Auction)
{
_auctionPrices.TryGetValue(auctionItem.Key, out int _price);
string _message = "# {Id}: {Count} {Item} at {Quality} quality, {Durability} durability for {Price} {Name}";
_message = _message.Replace("{Id}", auctionItem.Key.ToString());
_message = _message.Replace("{Count}", auctionItem.Value.count.ToString());
_message = _message.Replace("{Item}", auctionItem.Value.name);
_message = _message.Replace("{Quality}", auctionItem.Value.quality.ToString());
_message = _message.Replace("{Durability}", (100 - auctionItem.Value.useTimes).ToString());
_message = _message.Replace("{Price}", _price.ToString());
_message = _message.Replace("{Name}", Wallet.Currency_Name);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(_message);
}
}
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] No items are listed in the auction");
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in AuctionConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 to 3, found {0}.", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Jail.IsEnabled)
{
Jail.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Jail has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Jail is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Jail.IsEnabled)
{
Jail.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Jail has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Jail is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 3, found {0}", _params.Count));
return;
}
if (Jail.Jailed.Contains(_params[1]))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not add Id. {0} is already in the Jail list", _params[1]));
return;
}
if (!int.TryParse(_params[2], out int jailTime))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Jail time is not valid '{0}'", _params[2]));
return;
}
if (Jail.Jail_Position == "0,0,0" || Jail.Jail_Position == "0 0 0" || Jail.Jail_Position == "")
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not put a player in jail. The jail position has not been set"));
return;
}
else
{
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
if (cInfo != null)
{
if (Jail.Jailed.Contains(cInfo.CrossplatformId.CombinedString))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Player with Id '{0}' is already in jail", _params[1]));
return;
}
else
{
EntityPlayer player = PersistentOperations.GetEntityPlayer(cInfo.entityId);
if (player != null && player.IsSpawned())
{
string[] cords = Jail.Jail_Position.Split(',');
int.TryParse(cords[0], out int x);
int.TryParse(cords[1], out int y);
int.TryParse(cords[2], out int z);
cInfo.SendPackage(NetPackageManager.GetPackage <NetPackageTeleportPlayer>().Setup(new Vector3(x, y, z), null, false));
}
Jail.Jailed.Add(cInfo.CrossplatformId.CombinedString);
PersistentContainer.Instance.Players[cInfo.CrossplatformId.CombinedString].JailTime = jailTime;
PersistentContainer.Instance.Players[cInfo.CrossplatformId.CombinedString].JailName = cInfo.playerName;
PersistentContainer.Instance.Players[cInfo.CrossplatformId.CombinedString].JailDate = DateTime.Now;
PersistentContainer.DataChange = true;
if (jailTime > 0)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] You have put '{0}' named '{1}' in jail for '{2}' minutes", cInfo.CrossplatformId.CombinedString, cInfo.playerName, jailTime));
Phrases.Dict.TryGetValue("Jail1", out string phrase);
ChatHook.ChatMessage(cInfo, Config.Chat_Response_Color + phrase + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
if (jailTime == -1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] You have put '{0}' named '{1}' in jail forever", cInfo.CrossplatformId.CombinedString, cInfo.playerName));
Phrases.Dict.TryGetValue("Jail1", out string phrase);
ChatHook.ChatMessage(cInfo, Config.Chat_Response_Color + phrase + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
}
}
else
{
if (PersistentContainer.Instance.Players[_params[1]] != null)
{
if (_params[1].Contains("_"))
{
Jail.Jailed.Add(_params[1]);
PersistentContainer.Instance.Players[_params[1]].JailTime = jailTime;
PersistentContainer.Instance.Players[_params[1]].JailName = cInfo.playerName;
PersistentContainer.Instance.Players[_params[1]].JailDate = DateTime.Now;
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Player with Id '{0}' can not be found online but has been set for jail", _params[1]));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid EOS Id '{0}' ", _params[1]));
return;
}
}
}
}
}
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;
}
else
{
if (!Jail.Jailed.Contains(_params[1]))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Player with Id '{0}' is not in jail", _params[1]));
return;
}
else
{
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
if (cInfo != null)
{
EntityPlayer player = PersistentOperations.GetEntityPlayer(cInfo.entityId);
if (player != null)
{
EntityBedrollPositionList position = player.SpawnPoints;
Jail.Jailed.Remove(cInfo.CrossplatformId.CombinedString);
PersistentContainer.Instance.Players[cInfo.CrossplatformId.CombinedString].JailTime = 0;
PersistentContainer.DataChange = true;
if (position != null && position.Count > 0)
{
cInfo.SendPackage(NetPackageManager.GetPackage <NetPackageTeleportPlayer>().Setup(new Vector3(position[0].x, -1, position[0].z), null, false));
}
else
{
Vector3[] pos = GameManager.Instance.World.GetRandomSpawnPointPositions(1);
cInfo.SendPackage(NetPackageManager.GetPackage <NetPackageTeleportPlayer>().Setup(new Vector3(pos[0].x, -1, pos[0].z), null, false));
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] You have released Id '{0}' from jail", _params[1]));
return;
}
}
else
{
if (PersistentContainer.Instance.Players[_params[1]] != null)
{
if (_params[1].Contains("_"))
{
Jail.Jailed.Remove(_params[1]);
PersistentContainer.Instance.Players[_params[1]].JailTime = 0;
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Player with Id '{0}' can not be found online but has been set for jail", _params[1]));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid EOS Id '{0}' ", _params[1]));
return;
}
}
}
}
}
}
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;
}
if (Jail.Jailed.Count == 0)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] There are no Id on the jail list");
return;
}
else
{
for (int i = 0; i < Jail.Jailed.Count; i++)
{
string id = Jail.Jailed[i];
int jailTime = PersistentContainer.Instance.Players[id].JailTime;
string jailName = PersistentContainer.Instance.Players[id].JailName;
if (jailTime > 0)
{
DateTime jailDate = PersistentContainer.Instance.Players[id].JailDate;
TimeSpan varTime = DateTime.Now - jailDate;
double fractionalMinutes = varTime.TotalMinutes;
int timepassed = (int)fractionalMinutes;
int timeleft = jailTime - timepassed;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id '{0}' named '{1}' is jailed for {2} more minutes", id, jailName, timeleft));
}
else if (jailTime == -1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id '{0}' named '{1}' is jailed forever", id, jailName));
}
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in CommandJailConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Lobby.IsEnabled)
{
Lobby.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Lobby has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Lobby is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Lobby.IsEnabled)
{
Lobby.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Lobby has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Lobby is already on"));
return;
}
}
else if (_params[0] == "set")
{
ClientInfo _cInfo = _senderInfo.RemoteClientInfo;
EntityPlayer _player = GameManager.Instance.World.Players.dict[_cInfo.entityId];
Vector3 _position = _player.GetPosition();
int x = (int)_position.x;
int y = (int)_position.y;
int z = (int)_position.z;
string _lposition = x + "," + y + "," + z;
Lobby.Lobby_Position = _lposition;
if (!Phrases.Dict.TryGetValue("Stuck1", out string _phrase))
{
_phrase = "{PlayerName} you have set the lobby position as {LobbyPosition}";
}
_phrase = _phrase.Replace("{PlayerName}", _cInfo.playerName);
_phrase = _phrase.Replace("{LobbyPosition}", _lposition);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] {0}", _phrase));
Config.WriteXml();
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in CommandJailConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 or 2, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Gimme.IsEnabled)
{
Gimme.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Gimme has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Gimme is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Gimme.IsEnabled)
{
Gimme.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Gimme has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Gimme is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("reset"))
{
if (_params[1].ToLower().Equals("all"))
{
if (PersistentContainer.Instance.Players.IDs.Count > 0)
{
for (int i = 0; i < PersistentContainer.Instance.Players.IDs.Count; i++)
{
string id = PersistentContainer.Instance.Players.IDs[i];
PersistentPlayer p = PersistentContainer.Instance.Players[id];
{
PersistentContainer.Instance.Players[id].LastGimme = DateTime.Now.AddYears(-1);
}
}
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Gimme delay reset for all players");
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] No players to reset");
}
}
else
{
if (PersistentContainer.Instance.Players[_params[1]] != null)
{
PersistentContainer.Instance.Players[_params[1]].LastGimme = DateTime.Now.AddYears(-1);
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Gimme tool delay has been reset for '{0}'", _params[1]));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not reset the delay on Gimme tool. Invalid id '{0}'", _params[1]));
return;
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in GimmeConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 or 2, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Wallet.IsEnabled)
{
Wallet.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wallet has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wallet is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Wallet.IsEnabled)
{
Wallet.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wallet has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wallet is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("all"))
{
bool negative = false;
if (_params[1].Contains("-"))
{
_params[1].Replace("-", "");
negative = true;
}
if (!int.TryParse(_params[1], out int adjustCoins))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not adjust wallet. Value '{0}' is invalid", _params[1]));
}
else
{
List <ClientInfo> clientList = PersistentOperations.ClientList();
if (clientList != null)
{
for (int i = 0; i < clientList.Count; i++)
{
ClientInfo cInfo = clientList[i];
if (cInfo != null)
{
if (negative)
{
if (Wallet.GetCurrency(cInfo.CrossplatformId.CombinedString) >= adjustCoins)
{
Wallet.RemoveCurrency(cInfo.CrossplatformId.CombinedString, adjustCoins);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed '{0}' '{1}' from Id '{2}' named '{3}'", _params[1], Wallet.Currency_Name, cInfo.CrossplatformId.CombinedString, cInfo.playerName));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to remove '{0}' '{1}'. Target '{2}' named '{3}' does not have enough", _params[1], Wallet.Currency_Name, cInfo.CrossplatformId.CombinedString, cInfo.playerName));
}
return;
}
else
{
Wallet.AddCurrency(cInfo.CrossplatformId.CombinedString, adjustCoins);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added '{0}' '{1}' to id '{2}' named '{3}'", _params[1], Wallet.Currency_Name, cInfo.CrossplatformId.CombinedString, cInfo.playerName));
return;
}
}
}
}
}
}
else if (_params.Count == 2)
{
if (_params[1].Length < 1 || _params[1].Length > 6)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not adjust wallet. Value '{0}' is invalid", _params[1]));
return;
}
bool negative = false;
if (_params[1].Contains("-"))
{
_params[1].Replace("-", "");
negative = true;
}
if (!int.TryParse(_params[1], out int adjustCoins))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not adjust wallet. Value '{0}' is invalid", _params[1]));
return;
}
if (_params[0].Contains("_"))
{
PersistentPlayer p = PersistentContainer.Instance.Players[_params[0]];
if (p != null)
{
if (negative)
{
Wallet.RemoveCurrency(_params[0], adjustCoins);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed '{0}' '{1}' from Id '{2}'", _params[1], Wallet.Currency_Name, _params[0]));
}
else
{
Wallet.AddCurrency(_params[0], adjustCoins);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added '{0}' '{1}' to wallet '{2}'", _params[1], Wallet.Currency_Name, _params[0]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id not found '{0}'", _params[0]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid Id '{0}'", _params[0]));
}
}
else if (_params.Count == 1)
{
if (_params[0].Contains("_"))
{
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[0]);
if (cInfo != null)
{
int currentWallet = Wallet.GetCurrency(cInfo.CrossplatformId.CombinedString);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Id '{0}' named '{1}' has '{2}' '{3}'", _params[0], cInfo.playerName, currentWallet, Wallet.Currency_Name));
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in WalletConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1 && _params.Count != 2 && _params.Count != 5)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, 2 or 5, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (ProtectedZones.IsEnabled)
{
ProtectedZones.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Protected spaces has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Protected spaces is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!ProtectedZones.IsEnabled)
{
ProtectedZones.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Protected spaces has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Protected spaces is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 1 && _params.Count != 5)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 or 5, found '{0}'", _params.Count));
return;
}
if (_params.Count == 1)
{
if (_senderInfo.RemoteClientInfo == null)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] No client info found. Join the server as a client before using this command"));
return;
}
EntityPlayer player = PersistentOperations.GetEntityPlayer(_senderInfo.RemoteClientInfo.entityId);
if (player != null)
{
int x = (int)player.position.x, z = (int)player.position.z;
if (!ProtectedZones.Vectors.ContainsKey(player.entityId))
{
int[] vectors = new int[5];
vectors[0] = x;
vectors[1] = z;
ProtectedZones.Vectors.Add(player.entityId, vectors);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] The first position has been set to {0}x,{1}z", x, z));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Stand in the opposite corner and use add again. Use cancel to clear the saved location and start again");
return;
}
else
{
ProtectedZones.Vectors.TryGetValue(player.entityId, out int[] vectors);
ProtectedZones.Vectors.Remove(player.entityId);
if (vectors[0] < x)
{
vectors[2] = x;
}
else
{
vectors[2] = vectors[0];
vectors[0] = x;
}
if (vectors[1] < z)
{
vectors[3] = z;
}
else
{
vectors[3] = vectors[1];
vectors[1] = z;
}
vectors[4] = 1;
if (!ProtectedZones.ProtectedList.Contains(vectors))
{
ProtectedZones.ProtectedList.Add(vectors);
ProtectedZones.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added protected space from {0}x,{1}z to {2}x,{3}z", vectors[0], vectors[1], vectors[2], vectors[3], vectors[4]));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] This protected space is already on the list"));
return;
}
}
}
}
else if (_params.Count == 5)
{
if (!int.TryParse(_params[1], out int xMin))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid integer '{0}'", _params[1]));
return;
}
if (!int.TryParse(_params[2], out int zMin))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid integer '{0}'", _params[2]));
return;
}
if (!int.TryParse(_params[3], out int xMax))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid integer '{0}'", _params[3]));
return;
}
if (!int.TryParse(_params[4], out int zMax))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid integer '{0}'", _params[4]));
return;
}
int[] vectors = new int[5];
if (xMin < xMax)
{
vectors[0] = xMin;
vectors[2] = xMax;
}
else
{
vectors[0] = xMax;
vectors[2] = xMin;
}
if (zMin < zMax)
{
vectors[1] = zMin;
vectors[3] = zMax;
}
else
{
vectors[1] = zMax;
vectors[3] = zMin;
}
vectors[4] = 1;
if (!ProtectedZones.ProtectedList.Contains(vectors))
{
ProtectedZones.ProtectedList.Add(vectors);
ProtectedZones.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added protected space from {0}x,{1}z to {2}x,{3}z", vectors[0], vectors[1], vectors[2], vectors[3], vectors[4]));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] This protected space is already on the list"));
return;
}
}
}
else if (_params[0].ToLower().Equals("cancel"))
{
if (_senderInfo.RemoteClientInfo == null)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] You are not in game. There is nothing to cancel"));
return;
}
if (ProtectedZones.Vectors.ContainsKey(_senderInfo.RemoteClientInfo.entityId))
{
ProtectedZones.Vectors.Remove(_senderInfo.RemoteClientInfo.entityId);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Cancelled your saved corner positions"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] You have no saved position for a protected space. Use add in the first corner you want to protect"));
return;
}
}
else if (_params[0].ToLower().Equals("remove"))
{
if (_params.Count == 2)
{
if (ProtectedZones.ProtectedList.Count > 0)
{
if (int.TryParse(_params[1], out int _listNum))
{
if (ProtectedZones.ProtectedList.Count >= _listNum)
{
int[] _vectors = ProtectedZones.ProtectedList[_listNum - 1];
ProtectedZones.ProtectedList.Remove(_vectors);
ProtectedZones.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed protected space {0}: {1}x,{2}z to {3}x,{4}z", _listNum, _vectors[0], _vectors[1], _vectors[2], _vectors[3]));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid list number '{0}'", _params[1]));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid integer '{0}'", _params[1]));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] There are no protected spaces"));
return;
}
}
else if (_senderInfo.RemoteClientInfo != null)
{
PersistentOperations.ClearChunkProtection(_senderInfo.RemoteClientInfo);
return;
}
}
else if (_params[0].ToLower().Equals("list"))
{
if (ProtectedZones.ProtectedList.Count > 0)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Protected spaces list:"));
for (int i = 0; i < ProtectedZones.ProtectedList.Count; i++)
{
int[] _vectors = ProtectedZones.ProtectedList[i];
if (_vectors[4] == 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("#{0}: {1}x,{2}z to {3}x,{4}z is active", i + 1, _vectors[0], _vectors[1], _vectors[2], _vectors[3]));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("#{0}: {1}x,{2}z to {3}x,{4}z is deactivated", i + 1, _vectors[0], _vectors[1], _vectors[2], _vectors[3]));
}
}
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] There are no protected spaces"));
return;
}
}
else if (_params[0].ToLower().Equals("active"))
{
if (_params.Count != 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found '{0}'", _params.Count));
return;
}
int.TryParse(_params[1], out int _listEntry);
if (ProtectedZones.ProtectedList.Count >= _listEntry)
{
int[] _protectedSpace = ProtectedZones.ProtectedList[_listEntry - 1];
if (_protectedSpace[4] == 1)
{
_protectedSpace[4] = 0;
ProtectedZones.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Deactivated protected space #{0}", _listEntry));
}
else
{
_protectedSpace[4] = 1;
ProtectedZones.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Activated protected space #{0}", _listEntry));
}
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] This number does not exist on the protected spaces list. Unable to active or deactivate"));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ProtectedSpaceConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params[0].ToLower().Equals("off"))
{
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (Badwords.IsEnabled)
{
Badwords.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Bad word filter has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Bad word filter is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (!Badwords.IsEnabled)
{
Badwords.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Bad word filter has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Bad word filter is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count < 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected more than 2, found {0}", _params.Count));
return;
}
_params.RemoveAt(0);
string _word = _params.ToString().ToLower();
if (Badwords.Dict.Contains(_word))
{
Badwords.Dict.Add(_word);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added bad word to the list: {0}", _word));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Could not add entry. Bad word already found");
return;
}
}
else if (_params[0].ToLower().Equals("remove"))
{
if (_params.Count < 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected more than 2, found {0}", _params.Count));
return;
}
_params.RemoveAt(0);
string _word = _params.ToString().ToLower();
if (Badwords.Dict.Contains(_word))
{
Badwords.Dict.Remove(_word);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed bad word from the list: {0}", _word));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Could not remove entry. Bad word not found");
return;
}
}
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;
}
if (Badwords.Dict.Count > 0)
{
for (int i = 0; i < Badwords.Dict.Count; i++)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Bad word: {0}", Badwords.Dict[i]));
}
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] No entries were found on the bad word filter list");
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in BadWordFilterConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 && _params.Count > 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 to 3, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Bounties.IsEnabled)
{
Bounties.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Bounties has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Bounties is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Bounties.IsEnabled)
{
Bounties.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Bounties has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Bounties is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("edit"))
{
if (_params.Count != 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 3, found {0}", _params.Count));
return;
}
if (!int.TryParse(_params[2], out int _value))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Must input a valid interger: {0}", _params[2]));
return;
}
ClientInfo _cInfo = ConsoleHelper.ParseParamIdOrName(_params[1]);
if (_cInfo != null)
{
Bounties.ConsoleEdit(_cInfo.PlatformId.ReadablePlatformUserIdentifier, _value);
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] No player found online with id or name: {0}. Checking steam id", _params[1]));
if (_params[1].Length != 17)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not edit: Invalid steam id {0}", _params[1]));
return;
}
Bounties.ConsoleEdit(_params[1], _value);
}
}
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 = ConsoleHelper.ParseParamIdOrName(_params[1]);
if (_cInfo != null)
{
Bounties.ConsoleRemoveBounty(_cInfo.PlatformId.ReadablePlatformUserIdentifier);
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] No player found online with id or name: {0}. Checking steam id", _params[1]));
if (_params[1].Length != 17)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not remove: Invalid steam id {0}", _params[1]));
return;
}
Bounties.ConsoleRemoveBounty(_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;
}
Bounties.ConsoleBountyList();
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in BountiesConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1 && _params.Count != 3 && _params.Count != 6)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, 3 or 6, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Waypoints.IsEnabled)
{
Waypoints.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Waypoints has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Waypoints is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Waypoints.IsEnabled)
{
Waypoints.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Waypoints has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Waypoints is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count == 3)
{
if (_senderInfo.RemoteClientInfo == null)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] No client info found. Join the server as a client before using this command"));
return;
}
EntityPlayer player = PersistentOperations.GetEntityPlayer(_senderInfo.RemoteClientInfo.entityId);
if (player != null)
{
int x = (int)player.position.x;
int y = (int)player.position.y;
int z = (int)player.position.z;
string position = x + "," + y + "," + z;
string name = _params[1];
string cost = _params[2];
if (!int.TryParse(_params[2], out int _commandCost))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid command cost '{0}'", _params[2]));
return;
}
string[] waypoint = { position, cost };
if (!Waypoints.Dict.ContainsKey(name))
{
Waypoints.Dict.Add(name, waypoint);
Waypoints.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added public waypoint named '{0}' at position '{1}'. Cost set to '{2}'", name, position, cost));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] A public waypoint with this name already exists. Use a unique name or delete the other waypoint first"));
return;
}
}
}
else if (_params.Count == 6)
{
string name = _params[1];
int.TryParse(_params[2], out int x);
int.TryParse(_params[3], out int y);
int.TryParse(_params[4], out int z);
string position = x + "," + y + "," + z;
string cost = _params[5];
if (!int.TryParse(_params[5], out int commandCost))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid command cost '{0}'", _params[5]));
return;
}
string[] waypoint = { position, cost };
if (!Waypoints.Dict.ContainsKey(name))
{
Waypoints.Dict.Add(name, waypoint);
Waypoints.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added public waypoint named '{0}' at position '{1}'. Cost set to '{2}'", name, position, cost));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] A public waypoint with this name already exists. Use a unique name or delete the other waypoint first"));
return;
}
}
}
else if (_params[0].ToLower().Equals("remove"))
{
string name = _params[1];
if (Waypoints.Dict.ContainsKey(name))
{
Waypoints.Dict.Remove(name);
Waypoints.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed waypoint named '{0}'", name));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to remove waypoint named '{0}'. Waypoint not found", name));
return;
}
}
else if (_params[0].ToLower().Equals("list"))
{
if (Waypoints.Dict.Count > 0)
{
foreach (var _waypoint in Waypoints.Dict)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Waypoint named '{0}' @ position '{1}' with a cost of '{2}' '{3}'", _waypoint.Key, _waypoint.Value[0], _waypoint.Value[1], Wallet.Currency_Name));
}
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] There are no waypoints on the list");
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in WaypointsConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 && _params.Count > 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 or 2, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (ClanManager.IsEnabled)
{
ClanManager.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Clan manager has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Clan manager is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!ClanManager.IsEnabled)
{
ClanManager.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Clan manager has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Clan manager is already on"));
return;
}
}
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;
}
if (ClanManager.Clans.Count > 0)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Clan List:"));
foreach (KeyValuePair <string, string> i in ClanManager.Clans)
{
string _playerName = PersistentContainer.Instance.Players[i.Key].PlayerName;
if (!string.IsNullOrEmpty(_playerName))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Clan named {0}, owned by {1}, with id {2}", i.Value, _playerName, i.Key));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Clan named {0}, owned by player with id {1}", i.Value, i.Key));
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] No clans were found"));
}
return;
}
else if (_params[0].ToLower().Equals("delete"))
{
if (_params.Count != 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}", _params.Count));
return;
}
if (int.TryParse(_params[1], out int _steamId))
{
if (ClanManager.ClanMember.Contains(_params[1]))
{
string _clanName = PersistentContainer.Instance.Players[_params[1]].ClanName;
string _playerName = PersistentContainer.Instance.Players[_params[1]].PlayerName;
if (PersistentContainer.Instance.Players[_params[1]].ClanOwner)
{
ClanManager.Clans.Remove(_params[1]);
PersistentContainer.Instance.Players[_params[1]].ClanOwner = false;
PersistentContainer.Instance.Players[_params[1]].ClanRequestToJoin = null;
for (int i = 0; i < PersistentContainer.Instance.Players.IDs.Count; i++)
{
string _id = PersistentContainer.Instance.Players.IDs[i];
PersistentPlayer p = PersistentContainer.Instance.Players[_id];
{
if (p.ClanName != null && p.ClanName == _clanName)
{
p.ClanOfficer = false;
p.ClanName = "";
ClanManager.ClanMember.Remove(_id);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Deleted {0} with id {1} from the clan system", p.PlayerName, _id));
ClientInfo _cInfo2 = PersistentOperations.GetClientInfoFromNameOrId(_id);
if (_cInfo2 != null)
{
Phrases.Dict.TryGetValue("Clan21", out string _phrase);
_phrase = _phrase.Replace("{ClanName}", _clanName);
ChatHook.ChatMessage(_cInfo2, Config.Chat_Response_Color + _phrase + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
}
else if (p.ClanInvite != null && p.ClanInvite == _clanName)
{
PersistentContainer.Instance.Players[_id].ClanInvite = "";
}
PersistentContainer.DataChange = true;
}
}
}
PersistentContainer.Instance.Players[_params[1]].ClanOfficer = false;
PersistentContainer.Instance.Players[_params[1]].ClanName = "";
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Deleted {0} with id {1} from the clan system", _playerName, _params[1]));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] {0} was not found in the clan system", _params[1]));
}
}
else
{
if (ClanManager.Clans.ContainsValue(_params[1]))
{
foreach (KeyValuePair <string, string> _clan in ClanManager.Clans)
{
if (_clan.Value == _params[1])
{
ClanManager.Clans.Remove(_clan.Key);
break;
}
}
for (int i = 0; i < PersistentContainer.Instance.Players.IDs.Count; i++)
{
string _id = PersistentContainer.Instance.Players.IDs[i];
PersistentPlayer p = PersistentContainer.Instance.Players[_id];
{
if (p.ClanName != null && p.ClanName == _params[1])
{
p.ClanOwner = false;
p.ClanOfficer = false;
p.ClanRequestToJoin = null;
ClanManager.ClanMember.Remove(_id);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Deleted {0} with id {1} from the clan system", p.PlayerName, _id));
ClientInfo _cInfo2 = PersistentOperations.GetClientInfoFromNameOrId(_id);
if (_cInfo2 != null)
{
Phrases.Dict.TryGetValue("Clan21", out string _phrase);
_phrase = _phrase.Replace("{ClanName}", p.ClanName);
ChatHook.ChatMessage(_cInfo2, Config.Chat_Response_Color + _phrase + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
p.ClanName = "";
}
else if (p.ClanInvite != null && p.ClanInvite == _params[1])
{
PersistentContainer.Instance.Players[_id].ClanInvite = "";
}
PersistentContainer.DataChange = true;
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] {0} was not found in the clan system", _params[1]));
}
}
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ClanManagerConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1 && _params.Count != 2 && _params.Count != 3 && _params.Count != 5 && _params.Count != 6)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, 2, 3, 5 or 6, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (ChatColor.IsEnabled)
{
ChatColor.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Chat color prefix has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Chat color prefix is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!ChatColor.IsEnabled)
{
ChatColor.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Chat color prefix has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Chat color prefix is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
string id = "", playerName = "";
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
if (cInfo != null)
{
id = cInfo.PlatformId.CombinedString;
playerName = cInfo.playerName;
}
else
{
PlayerDataFile pdf = PersistentOperations.GetPlayerDataFileFromId(_params[1]);
if (pdf != null)
{
id = _params[1];
playerName = pdf.ecd.entityName;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to locate player '{0}' online or offline", _params[1]));
return;
}
}
if (_params.Count == 3)
{
if (!double.TryParse(_params[2], out double daysToExpire))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to add player. Invalid days to expire: '{0}'", _params[2]));
return;
}
DateTime expiryDate;
if (daysToExpire > 0d)
{
expiryDate = DateTime.Now.AddDays(daysToExpire);
}
else
{
expiryDate = DateTime.Now.AddDays(18250d);
}
string[] c = new string[] { playerName, "", "", "" };
if (ChatColor.ExpireDate.ContainsKey(id))
{
ChatColor.ExpireDate.TryGetValue(id, out DateTime oldDate);
if (daysToExpire > 0d)
{
oldDate.AddDays(daysToExpire);
}
else
{
oldDate.AddDays(18250d);
}
ChatColor.Players[id] = c;
ChatColor.ExpireDate[id] = oldDate;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added player id '{0}' with name '{1}' using no colors or prefix. Expiration set to '{2}'", id, playerName, expiryDate.ToString()));
ChatColor.UpdateXml();
}
else
{
ChatColor.Players.Add(id, c);
ChatColor.ExpireDate.Add(id, expiryDate);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added player id '{0}' with name '{1}' using no colors or prefix. Expiration set to '{2}'", id, playerName, expiryDate.ToString()));
ChatColor.UpdateXml();
}
return;
}
else if (_params.Count == 6)
{
string colorTag1;
if (ColorList.Colors.ContainsKey(_params[2].ToLower()))
{
ColorList.Colors.TryGetValue(_params[2].ToLower(), out colorTag1);
}
else
{
colorTag1 = _params[2].ToUpper();
if (colorTag1 != "" && !colorTag1.StartsWith("["))
{
colorTag1 = colorTag1.Insert(0, "[");
colorTag1 = colorTag1.Insert(colorTag1.Length, "]");
}
}
string colorTag2;
if (ColorList.Colors.ContainsKey(_params[4].ToLower()))
{
ColorList.Colors.TryGetValue(_params[4].ToLower(), out colorTag2);
}
else
{
colorTag2 = _params[4].ToUpper();
if (colorTag2 != "" && !colorTag2.StartsWith("["))
{
colorTag2 = colorTag2.Insert(0, "[");
colorTag2 = colorTag2.Insert(colorTag2.Length, "]");
}
}
if (!double.TryParse(_params[5], out double daysToExpire))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to add player. Invalid days to expire: '{0}'", _params[5]));
return;
}
DateTime expiryDate;
if (daysToExpire > 0d)
{
expiryDate = DateTime.Now.AddDays(daysToExpire);
}
else
{
expiryDate = DateTime.Now.AddDays(18250d);
}
string[] c = new string[] { playerName, colorTag1, _params[3], colorTag2 };
if (ChatColor.ExpireDate.ContainsKey(id))
{
ChatColor.ExpireDate.TryGetValue(id, out DateTime oldDate);
if (daysToExpire > 0d)
{
oldDate.AddDays(daysToExpire);
}
else
{
oldDate.AddDays(18250d);
}
ChatColor.Players[id] = c;
ChatColor.ExpireDate[id] = oldDate;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added player id '{0}' with name '{1}' using color '{2}' and prefix '{3}' using color '{4}'. Expiration set to '{5}'", id, playerName, colorTag1, _params[3], colorTag2, expiryDate.ToString()));
ChatColor.UpdateXml();
}
else
{
ChatColor.Players.Add(id, c);
ChatColor.ExpireDate.Add(id, expiryDate);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added player id '{0}' with name '{1}' using color '{2}' and prefix '{3}' using color '{4}'. Expiration set to '{5}'", id, playerName, colorTag1, _params[3], colorTag2, expiryDate.ToString()));
ChatColor.UpdateXml();
}
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, 2, 3, 5 or 6, found {0}", _params.Count));
return;
}
}
else if (_params[0].ToLower().Equals("edit"))
{
string id = "", playerName = "";
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
if (cInfo != null)
{
id = cInfo.CrossplatformId.CombinedString;
playerName = cInfo.playerName;
}
else
{
PlayerDataFile pdf = PersistentOperations.GetPlayerDataFileFromId(_params[1]);
if (pdf != null)
{
id = _params[1];
playerName = pdf.ecd.entityName;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to locate player '{0}' online or offline", _params[1]));
return;
}
}
if (_params.Count == 3)
{
if (ChatColor.Players.ContainsKey(id))
{
if (!int.TryParse(_params[2], out int daysToExpire))
{
ChatColor.Players.TryGetValue(id, out string[] tags);
string[] c = new string[] { tags[0], tags[1], _params[2], tags[3] };
ChatColor.Players[id] = c;
ChatColor.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Edited chat color prefix for player id '{0}'. Prefix set to '{1}'", id, _params[2]));
return;
}
ChatColor.ExpireDate[id] = DateTime.Now.AddDays(daysToExpire);
ChatColor.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Edited chat color prefix for player id '{0}'. Expiry date set to '{1}'", id, DateTime.Now.AddDays(daysToExpire)));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to edit player id '{0}'. They are not on the chat color prefix list", _params[1]));
return;
}
}
else if (_params.Count == 5)
{
if (ChatColor.Players.ContainsKey(id))
{
string colorTag1;
if (ColorList.Colors.ContainsKey(_params[2].ToLower()))
{
ColorList.Colors.TryGetValue(_params[2].ToLower(), out colorTag1);
}
else
{
colorTag1 = _params[2].ToUpper();
if (colorTag1 != "" && !colorTag1.StartsWith("["))
{
colorTag1 = colorTag1.Insert(0, "[");
colorTag1 = colorTag1.Insert(colorTag1.Length, "]");
}
}
string colorTag2;
if (ColorList.Colors.ContainsKey(_params[4].ToLower()))
{
ColorList.Colors.TryGetValue(_params[4].ToLower(), out colorTag2);
}
else
{
colorTag2 = _params[4].ToUpper();
if (colorTag2 != "" && !colorTag2.StartsWith("["))
{
colorTag2 = colorTag2.Insert(0, "[");
colorTag2 = colorTag2.Insert(colorTag2.Length, "]");
}
}
string[] c = new string[] { playerName, colorTag1, _params[3], colorTag2 };
ChatColor.Players[id] = c;
ChatColor.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Edited chat color prefix for player id '{0}'. Name color set to '{1}' and prefix set to '{2}' using color '{3}'", id, colorTag1, _params[3], colorTag2));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to edit player id '{0}'. They are not on the chat color prefix list", _params[1]));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 3 or 5, found '{0}'", _params.Count));
return;
}
}
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;
}
string id = "";
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
if (cInfo != null)
{
id = cInfo.CrossplatformId.CombinedString;
}
else
{
PersistentPlayerData ppd = PersistentOperations.GetPersistentPlayerDataFromId(_params[1]);
if (ppd != null)
{
id = ppd.UserIdentifier.CombinedString;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to locate player '{0}' online or offline", _params[1]));
return;
}
}
if (ChatColor.Players.ContainsKey(id))
{
ChatColor.Players.Remove(id);
ChatColor.ExpireDate.Remove(id);
ChatColor.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed player id '{0}' from the chat color prefix list", _params[1]));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to remove player id '{0}'. They are not on the chat color prefix list", _params[1]));
return;
}
}
else if (_params[0].ToLower().Equals("list"))
{
if (ChatColor.Players.Count > 0)
{
foreach (var player in ChatColor.Players)
{
ChatColor.ExpireDate.TryGetValue(player.Key, out DateTime expiry);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Player id '{0}' named '{1}' using color '{2}' and prefix '{3}' using color '{4}' expires '{5}'", player.Key, player.Value[0], player.Value[1], player.Value[2], player.Value[3], expiry));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] No players on the chat color list");
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ChatColorPrefixConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
var _cInfo = _senderInfo.RemoteClientInfo;
if (_cInfo != null)
{
if (_params[0].ToLower().Equals("off"))
{
if (Zones.IsEnabled)
{
Zones.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Zones has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Zones is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Zones.IsEnabled)
{
Zones.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Zones has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Zones is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("new"))
{
if (SetupStage.ContainsKey(_cInfo.entityId))
{
SetupStage[_cInfo.entityId] = 1;
}
else
{
SetupStage.Add(_cInfo.entityId, 1);
}
if (Zones.ZoneSetup.ContainsKey(_cInfo.entityId))
{
Zones.ZoneSetup.Remove(_cInfo.entityId);
}
string[] _newZone = new string[11];
_params.RemoveAt(0);
string _name = string.Join(" ", _params);
_newZone[0] = _name;
Zones.ZoneSetup.Add(_cInfo.entityId, _newZone);
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Started a new zone setup. Zone name set to {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Stand at the first corner of the zone and type zns save"));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] If you would like a circle, stand in the middle of the circle and type zns circle"));
}
else if (_params[0].ToLower().Equals("list"))
{
if (Zones.ZoneList.Count > 0)
{
for (int i = 0; i < Zones.ZoneList.Count; i++)
{
string[] _zone = Zones.ZoneList[i];
if (_zone != null)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Zone number {0}:", i));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _zone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _zone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _zone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _zone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry message = {0}", _zone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit message = {0}", _zone[5]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry Command = {0}", _zone[6]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit Command = {0}", _zone[7]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Reminder Notice = {0}", _zone[8]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("PvPvE = {0}", _zone[9]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("No zombie = {0}", _zone[10]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format(""));
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] There are no zones setup"));
}
}
else if (_params[0].ToLower().Equals("delete"))
{
if (Zones.ZoneList.Count > 0)
{
if (int.TryParse(_params[1], out int _number))
{
if (Zones.ZoneList.Count >= _number)
{
Zones.ZoneList.RemoveAt(_number);
Zones.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed zone entry number {0} from the list", _number));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Could not delete number {0} from the list. Entry not found", _number));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid format or non numeric entry. Type zns delete <number> from the list of zones"));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] There are no zones setup"));
return;
}
}
else if (_params[0].ToLower().Equals("circle"))
{
if (SetupStage.ContainsKey(_cInfo.entityId))
{
SetupStage.TryGetValue(_cInfo.entityId, out int _stage);
if (_stage == 1)
{
EntityPlayer _player = GameManager.Instance.World.Players.dict[_cInfo.entityId];
Vector3 _position = _player.GetPosition();
Zones.ZoneSetup.TryGetValue(_cInfo.entityId, out string[] _newZone);
int _x = (int)_position.x;
int _y = (int)_position.y;
int _z = (int)_position.z;
_newZone[1] = _x + "," + _y + "," + _z;
_newZone[3] = "true";
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 2;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Circle center point = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns circle 'number' to set the amount of blocks from center the zone will reach"));
}
else if (_stage == 2)
{
Zones.ZoneSetup.TryGetValue(_cInfo.entityId, out string[] _newZone);
if (_newZone[3].ToLower() == "true")
{
if (int.TryParse(_params[1], out int _radius))
{
_newZone[2] = _radius.ToString();
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 3;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Saved the circular zone radius to {0} blocks", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"message\". This is the message players receive upon entering the zone"));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid radius for circlular zone, try again"));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] This zone is not setup as a circle, go back by typing zns back"));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Start a new zone setup or go back to the circle setup if you need to change it by typing zns back."));
}
}
}
else if (_params[0].ToLower().Equals("save"))
{
if (SetupStage.ContainsKey(_cInfo.entityId))
{
SetupStage.TryGetValue(_cInfo.entityId, out int _stage);
Zones.ZoneSetup.TryGetValue(_cInfo.entityId, out string[] _newZone);
switch (_stage)
{
case 1:
EntityPlayer _player = GameManager.Instance.World.Players.dict[_cInfo.entityId];
Vector3 _position = _player.GetPosition();
int _x = (int)_position.x;
int _y = (int)_position.y;
int _z = (int)_position.z;
_newZone[1] = _x + "," + _y + "," + _z;
_newZone[3] = "false";
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 2;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Stand in the opposite corner of the zone and type zns save"));
break;
case 2:
_player = GameManager.Instance.World.Players.dict[_cInfo.entityId];
_position = _player.GetPosition();
_x = (int)_position.x;
_y = (int)_position.y;
_z = (int)_position.z;
if (_newZone[1].Contains(_y.ToString()))
{
_y++;
}
_newZone[2] = _x + "," + _y + "," + _z;
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 3;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"message\". This is the message players receive upon entering the zone"));
break;
case 3:
_params.RemoveAt(0);
string _entryMessage = string.Join(" ", _params);
_newZone[4] = _entryMessage;
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 4;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Entry message = \"{0}\"", _newZone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"message\". This is the message players receive upon exiting the zone"));
break;
case 4:
_params.RemoveAt(0);
string _exitMessage = string.Join(" ", _params);
_newZone[5] = _exitMessage;
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 5;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Exit message = \"{0}\"", _newZone[5]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"command\". This is the console command that will occur when a player enters this zone"));
break;
case 5:
_params.RemoveAt(0);
string _entryCommand = string.Join(" ", _params);
if (_entryCommand == "")
{
_entryCommand = "***";
}
_newZone[6] = _entryCommand;
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 6;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Entry command = \"{0}\"", _newZone[6]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"command\". This is the console command that will occur when a player exits this zone"));
break;
case 6:
_params.RemoveAt(0);
string _exitCommand = string.Join(" ", _params);
if (_exitCommand == "")
{
_exitCommand = "***";
}
_newZone[7] = _exitCommand;
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 7;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Exit command = \"{0}\"", _newZone[7]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"message\". This will set the message players receive if they stay in this zone long enough"));
break;
case 7:
_params.RemoveAt(0);
string _reminder = string.Join(" ", _params);
_newZone[8] = _reminder;
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 8;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Reminder message = \"{0}\"", _newZone[8]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save '0 to 3'. This will set PvPvE to a specific player killing mode"));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] 0 = No Killing, 1 = Kill Allies Only, 2 = Kill Strangers Only, 3 = Kill Everyone"));
break;
case 8:
if (int.TryParse(_params[1], out int _playerKillingMode))
{
_newZone[9] = _playerKillingMode.ToString();
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 9;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Zone PvPvE = {0}", _newZone[9]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save 'true or false'. This will set no zombie to true or false"));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Incorrect format. Type zns save '0 to 3'"));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] 0 = No Killing, 1 = Kill Allies Only, 2 = Kill Strangers Only, 3 = Kill Everyone"));
}
break;
case 9:
if (bool.TryParse(_params[1], out bool _noZombie))
{
if (_noZombie)
{
_newZone[10] = "true";
}
else
{
_newZone[10] = "false";
}
Zones.ZoneSetup[_cInfo.entityId] = _newZone;
SetupStage[_cInfo.entityId] = 10;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] No zombie = {0}", _newZone[10]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("");
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Zone Review:"));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _newZone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry message = {0}", _newZone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit message = {0}", _newZone[5]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry Command = {0}", _newZone[6]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit Command = {0}", _newZone[7]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Reminder notice = {0}", _newZone[8]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("PvPvE = {0}", _newZone[9]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("No zombie = {0}", _newZone[10]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Type zns save. This will complete the setup"));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Incorrect format. Type zns save 'true or false'"));
}
break;
case 10:
if (!Zones.ZoneList.Contains(_newZone))
{
Zones.ZoneList.Add(_newZone);
Zones.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] New zone setup has been completed"));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] This zone is already setup. Setup a new zone by typing zns new"));
}
Zones.ZoneSetup.Remove(_cInfo.entityId);
SetupStage.Remove(_cInfo.entityId);
break;
}
}
else if (_params[0].ToLower().Equals("back"))
{
if (SetupStage.ContainsKey(_cInfo.entityId))
{
SetupStage.TryGetValue(_cInfo.entityId, out int _stage);
Zones.ZoneSetup.TryGetValue(_cInfo.entityId, out string[] _newZone);
switch (_stage)
{
case 1:
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Stand at the first corner of the zone and type zns save"));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] If you would like a circle, stand in the middle of the circle and type zns circle"));
break;
case 2:
SetupStage[_cInfo.entityId] = 1;
if (_newZone[3].ToLower() == "true")
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Stand at the furthest point from the center and type zns circle"));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Corner 1 is saved. Stand in the opposite corner of the zone and type zns save"));
}
break;
case 3:
SetupStage[_cInfo.entityId] = 2;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _newZone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"message\". This is the message players receive upon entering the zone"));
break;
case 4:
SetupStage[_cInfo.entityId] = 3;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _newZone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry message = {0}", _newZone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"message\". This is the message players receive upon exiting the zone"));
break;
case 5:
SetupStage[_cInfo.entityId] = 4;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _newZone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry message = {0}", _newZone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit message = {0}", _newZone[5]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"command\". This is the console command that will occur when a player enters this zone"));
break;
case 6:
SetupStage[_cInfo.entityId] = 5;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _newZone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry message = {0}", _newZone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit message = {0}", _newZone[5]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry Command = {0}", _newZone[6]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"command\". This is the console command that will occur when a player exits this zone"));
break;
case 7:
SetupStage[_cInfo.entityId] = 6;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _newZone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry message = {0}", _newZone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit message = {0}", _newZone[5]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry Command = {0}", _newZone[6]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit Command = {0}", _newZone[7]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save \"message\". This will set the message players receive if they stay in this zone long enough"));
break;
case 8:
SetupStage[_cInfo.entityId] = 7;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _newZone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry message = {0}", _newZone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit message = {0}", _newZone[5]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry Command = {0}", _newZone[6]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit Command = {0}", _newZone[7]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Reminder notice = {0}", _newZone[8]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save '0 to 3'. This will set PvPvE to a specific player killing mode"));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] 0 = No Killing, 1 = Kill Allies Only, 2 = Kill Strangers Only, 3 = Kill Everyone"));
break;
case 9:
SetupStage[_cInfo.entityId] = 8;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _newZone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry message = {0}", _newZone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit message = {0}", _newZone[5]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry Command = {0}", _newZone[6]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit Command = {0}", _newZone[7]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Reminder notice = {0}", _newZone[8]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("PvPvE = {0}", _newZone[9]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Type zns save 'true or false'. This will set no zombie to true or false"));
break;
case 10:
SetupStage[_cInfo.entityId] = 9;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Name = {0}", _newZone[0]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 1 = {0}", _newZone[1]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Corner 2 = {0}", _newZone[2]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Circle = {0}", _newZone[3]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry message = {0}", _newZone[4]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit message = {0}", _newZone[5]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Entry Command = {0}", _newZone[6]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Exit Command = {0}", _newZone[7]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Reminder notice = {0}", _newZone[8]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("PvPvE = {0}", _newZone[9]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("No zombie = {0}", _newZone[10]));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Type zns save. This will complete the setup"));
break;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] You have not started the setup of a new zone. Type zns new 'name' to begin setting up a new zone"));
}
}
else if (_params[0].ToLower().Equals("forward"))
{
if (SetupStage.ContainsKey(_cInfo.entityId))
{
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] You have not started the setup of a new zone. Type zns new 'name' to begin setting up a new zone"));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ZonesConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 0 && _params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 0 or 1, found '{0}'", _params.Count));
return;
}
if (_params.Count == 0)
{
int _zombies = 0, _animals = 0, _bicycles = 0, _miniBikes = 0, _motorcycles = 0, _4x4 = 0, _gyros = 0, _supplyCrates = 0;
int _daysRemaining = Day7.DaysRemaining(GameUtils.WorldTimeToDays(GameManager.Instance.World.GetWorldTime()));
List <Entity> _entities = GameManager.Instance.World.Entities.list;
foreach (Entity _e in _entities)
{
if (_e.IsClientControlled())
{
continue;
}
string _tags = _e.EntityClass.Tags.ToString();
if (_tags.Contains("zombie") && _e.IsAlive())
{
_zombies++;
}
else if (_tags.Contains("animal") && _e.IsAlive())
{
_animals++;
}
else
{
string _name = EntityClass.list[_e.entityClass].entityClassName;
if (_name == "vehicleBicycle")
{
_bicycles++;
}
else if (_name == "vehicleMinibike")
{
_miniBikes++;
}
else if (_name == "vehicleMotorcycle")
{
_motorcycles++;
}
else if (_name == "vehicle4x4Truck")
{
_4x4++;
}
else if (_name == "vehicleGyrocopter")
{
_gyros++;
}
else if (_name == "sc_General")
{
_supplyCrates++;
}
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Server FPS '{0}'", GameManager.Instance.fps.Counter));
if (_daysRemaining == 0 && !GameManager.Instance.World.aiDirector.BloodMoonComponent.BloodMoonActive)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("Next horde night is today");
}
else if (GameManager.Instance.World.aiDirector.BloodMoonComponent.BloodMoonActive)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("The horde is here!");
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Next horde night in '{0}' days", _daysRemaining));
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Players '{0}' Zombies '{1}' Animals '{2}'", ConnectionManager.Instance.ClientCount(), _zombies, _animals));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Bicycles '{0}' Minibikes '{1}' Motorcycles '{2}' 4x4 '{3}' Gyros '{4}'", _bicycles, _miniBikes, _motorcycles, _4x4, _gyros));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Supply crates '{0}'", _supplyCrates));
}
}
else
{
if (_params[0].ToLower().Equals("off"))
{
if (Day7.IsEnabled)
{
Day7.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Day7 has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Day7 is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!Day7.IsEnabled)
{
Day7.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Day7 has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Day7 is already on"));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in Day7Console.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 to 3, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (ReservedSlots.IsEnabled)
{
ReservedSlots.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Reserved slots has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Reserved slots is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!ReservedSlots.IsEnabled)
{
ReservedSlots.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Reserved slots has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Reserved slots is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 3, found '{0}'", _params.Count));
return;
}
string id = "", playerName = "";
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
if (cInfo != null)
{
id = cInfo.CrossplatformId.CombinedString;
playerName = cInfo.playerName;
}
else
{
PersistentPlayerData ppd = PersistentOperations.GetPersistentPlayerDataFromId(_params[1]);
if (ppd != null)
{
id = ppd.UserIdentifier.CombinedString;
playerName = ppd.PlayerName;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to locate '{0}' online or offline. Use EOS id for offline player", _params[1]));
return;
}
}
if (ReservedSlots.Dict.ContainsKey(id))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not add id '{0}'. Id is already on the reserved slots list", id));
return;
}
if (!double.TryParse(_params[2], out double daysToExpire))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid days to expire '{0}'", _params[2]));
return;
}
DateTime expireDate;
if (daysToExpire > 0d)
{
expireDate = DateTime.Now.AddDays(daysToExpire);
}
else
{
expireDate = DateTime.Now.AddDays(18250d);
}
ReservedSlots.Dict.Add(id, expireDate);
ReservedSlots.Dict1.Add(id, playerName);
ReservedSlots.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Added id '{0}' named '{1}' with expiry '{2}' to the reserved slots list", id, playerName, expireDate.ToString()));
return;
}
else if (_params[0].ToLower().Equals("edit"))
{
if (_params.Count != 3)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 3, found '{0}'", _params.Count));
return;
}
string id = "", playerName = "";
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
if (cInfo != null)
{
id = cInfo.CrossplatformId.CombinedString;
playerName = cInfo.playerName;
}
else if (_params[1].Contains("_"))
{
PersistentPlayerData ppd = PersistentOperations.GetPersistentPlayerDataFromId(_params[1]);
if (ppd != null)
{
id = ppd.UserIdentifier.CombinedString;
playerName = ppd.PlayerName;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to locate '{0}' online or offline. Use EOS id for offline players", _params[1]));
return;
}
}
if (!ReservedSlots.Dict.ContainsKey(id))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not edit id '{0}'. This id is not on the reserved slots list", id));
return;
}
if (!double.TryParse(_params[2], out double daysToExpire))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid days to expire '{0}'", _params[2]));
return;
}
DateTime expireDate;
if (daysToExpire > 0d)
{
expireDate = DateTime.Now.AddDays(daysToExpire);
}
else
{
expireDate = DateTime.Now.AddDays(18250d);
}
ReservedSlots.Dict[id] = expireDate;
ReservedSlots.Dict1[id] = playerName;
ReservedSlots.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Edited id '{0}' named '{1}' to expiry '{2}' on the reserved slots list", id, playerName, expireDate.ToString()));
return;
}
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;
}
string id = "";
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[1]);
if (cInfo != null)
{
id = cInfo.CrossplatformId.CombinedString;
}
else if (_params[1].Contains("_"))
{
PersistentPlayerData ppd = PersistentOperations.GetPersistentPlayerDataFromId(_params[1]);
if (ppd != null)
{
id = ppd.UserIdentifier.CombinedString;
}
}
if (ReservedSlots.Dict.ContainsKey(id))
{
ReservedSlots.Dict.Remove(id);
ReservedSlots.Dict1.Remove(id);
ReservedSlots.UpdateXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Removed id '{0}' from the reserved slots list", id));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to remove id '{0}'. Id was not on the reserved slots list", _params[1]));
return;
}
}
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;
}
if (ReservedSlots.Dict.Count == 0)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] There are no players on the Reserved slots list");
return;
}
else
{
foreach (var key in ReservedSlots.Dict)
{
if (ReservedSlots.Dict1.TryGetValue(key.Key, out string name))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("Id '{0}' named '{1}' expires '{2}'", key.Key, name, key.Value));
}
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ReservedSlotConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 2)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1 or 2, found '{0}'", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (FirstClaimBlock.IsEnabled)
{
FirstClaimBlock.IsEnabled = false;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] First claim block has been set to off"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] First claim block is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!FirstClaimBlock.IsEnabled)
{
FirstClaimBlock.IsEnabled = true;
Config.WriteXml();
Config.LoadXml();
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] First claim block has been set to on"));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] First claim block is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("reset"))
{
if (_params[1].ToLower().Equals("all"))
{
for (int i = 0; i < PersistentContainer.Instance.Players.IDs.Count; i++)
{
string id = PersistentContainer.Instance.Players.IDs[i];
PersistentContainer.Instance.Players[id].FirstClaimBlock = false;
PersistentContainer.DataChange = true;
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] First claim block reset for all players");
}
else if (PersistentContainer.Instance.Players[_params[1]] != null)
{
if (PersistentContainer.Instance.Players[_params[1]].FirstClaimBlock)
{
PersistentContainer.Instance.Players[_params[1]].FirstClaimBlock = false;
PersistentContainer.DataChange = true;
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] First claim block reset for '{0}'", _params[1]));
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Reset is unnecessary for '{0}'", _params[1]));
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Can not reset player's first claim block. No saved data could be located for '{0}'", _params[1]));
return;
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid argument '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in FirstClaimBlockConsole.Execute: {0}", e.Message));
}
}
