public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Chat flood protection has been set to off"));
return;
}
else
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Chat flood protection has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Chat flood protection is already on"));
return;
}
}
else
{
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 override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (PlayerStats.IsEnabled)
{
PlayerStats.IsEnabled = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player stat check has been set to off"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player stat check is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!PlayerStats.IsEnabled)
{
PlayerStats.IsEnabled = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player stat check has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player stat check is already on"));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in PlayerStatCheckConsole.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 static void SetNewSpawnTele(ClientInfo _cInfo)
{
if (!GameManager.Instance.adminTools.CommandAllowedFor(_cmd, _cInfo))
{
Phrases.Dict.TryGetValue(217, out string _phrase217);
ChatHook.ChatMessage(_cInfo, Config.Chat_Response_Color + _phrase217 + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
else
{
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 _sposition = x + "," + y + "," + z;
New_Spawn_Tele_Position = _sposition;
Config.WriteXml();
Phrases.Dict.TryGetValue(211, out string _phrase211);
_phrase211 = _phrase211.Replace("{Position}", New_Spawn_Tele_Position);
ChatHook.ChatMessage(_cInfo, Config.Chat_Response_Color + _phrase211 + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output("[SERVERTOOLS] Wrong number of arguments.");
return;
}
if (!int.TryParse(_params[0], out HighPingKicker.Max_Ping))
{
SdtdConsole.Instance.Output("[SERVERTOOLS] Maxping is not an integer.");
return;
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Max ping limit set to {0}", HighPingKicker.Max_Ping));
Config.WriteXml();
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ReservedSlotConsole.Run: {0}.", e.Message));
}
}
public static void Set(ClientInfo _cInfo)
{
string[] _command = { Market.Command102 };
if (!GameManager.Instance.adminTools.CommandAllowedFor(_command, _cInfo))
{
Phrases.Dict.TryGetValue(257, out string _phrase257);
ChatHook.ChatMessage(_cInfo, Config.Chat_Response_Color + _phrase257 + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
else
{
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 _mposition = x + "," + y + "," + z;
Market_Position = _mposition;
Config.WriteXml();
Phrases.Dict.TryGetValue(257, out string _phrase257);
_phrase257 = _phrase257.Replace("{MarketPosition}", Market_Position);
ChatHook.ChatMessage(_cInfo, Config.Chat_Response_Color + _phrase257 + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 2)
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Gimme has been set to off"));
return;
}
else
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Gimme has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Gimme 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.SteamIDs.Count; i++)
{
string _id = PersistentContainer.Instance.Players.SteamIDs[i];
PersistentPlayer p = PersistentContainer.Instance.Players[_id];
{
PersistentContainer.Instance.Players[_id].LastGimme = DateTime.Now.AddYears(-1);
}
}
SdtdConsole.Instance.Output("[SERVERTOOLS] Gimme delay reset for all players.");
}
else
{
PersistentPlayer p = PersistentContainer.Instance.Players[_params[1]];
if (p != null)
{
PersistentContainer.Instance.Players[_params[1]].LastGimme = DateTime.Now.AddYears(-1);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Gimme delay reset for {0}.", _params[1]));
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not reset player. Invalid Id {0}.", _params[1]));
return;
}
}
}
else
{
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)
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wallet has been set to off"));
return;
}
else
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wallet has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wallet is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("all"))
{
if (!int.TryParse(_params[1], out int _adjustCoins))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not adjust wallet. Value {0} is invalid", _params[1]));
}
else
{
List <ClientInfo> _cInfoList = PersistentOperations.ClientList();
for (int i = 0; i < _cInfoList.Count; i++)
{
ClientInfo _cInfo = _cInfoList[i];
if (_cInfo != null)
{
if (_adjustCoins >= 0)
{
Wallet.AddCoinsToWallet(_cInfo.playerId, _adjustCoins);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added {0} {1} to player id {2} wallet", _params[1], Wallet.Coin_Name, _params[0]));
}
else
{
Wallet.SubtractCoinsFromWallet(_cInfo.playerId, _adjustCoins);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Subtracted {0} {1} from player id {2} wallet", _params[1], Wallet.Coin_Name, _params[0]));
}
}
}
}
}
else if (_params.Count == 2)
{
if (_params[0].Length < 1 || _params[0].Length > 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not adjust wallet: Invalid Id {0}", _params[0]));
return;
}
if (_params[1].Length < 1 || _params[1].Length > 5)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not adjust wallet. Value {0} is invalid", _params[1]));
return;
}
if (!int.TryParse(_params[1], out int _adjustCoins))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not adjust wallet. Value {0} is invalid", _params[1]));
}
else
{
PersistentPlayer p = PersistentContainer.Instance.Players[_params[0]];
if (p != null)
{
Wallet.AddCoinsToWallet(_params[0], _adjustCoins);
if (_adjustCoins >= 0)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added {0} {1} to player id {2} wallet", _params[1], Wallet.Coin_Name, _params[0]));
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Subtracted {0} {1} from player id {2} wallet", _params[1], Wallet.Coin_Name, _params[0]));
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player id not found: {0}", _params[0]));
}
}
}
else if (_params.Count == 1)
{
if (_params[0].Length < 1 || _params[0].Length > 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not check wallet value: Invalid Id {0}", _params[0]));
return;
}
int _currentWallet = Wallet.GetCurrentCoins(_params[0]);
string _playerName = PersistentContainer.Instance.Players[_params[0]].PlayerName;
if (string.IsNullOrEmpty(_playerName))
{
_playerName = "Unknown";
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player with id {0}, named {1}, has a wallet value of: {2}", _params[0], _playerName, _currentWallet));
}
else
{
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)
{
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 > 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 && _params.Count != 2 && _params.Count != 5)
{
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 (ProtectedSpaces.IsEnabled)
{
ProtectedSpaces.IsEnabled = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Protected spaces has been set to off"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Protected spaces is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!ProtectedSpaces.IsEnabled)
{
ProtectedSpaces.IsEnabled = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Protected spaces has been set to on"));
return;
}
else
{
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)
{
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)
{
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.playerId);
if (_player != null)
{
if (!ProtectedSpaces.Vectors.ContainsKey(_player.entityId))
{
int _x = (int)_player.position.x, _z = (int)_player.position.z;
string[] _vector1 = { _x.ToString(), _z.ToString() };
ProtectedSpaces.Vectors.Add(_player.entityId, _vector1);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] The first position has been set to {0}x,{1}z", _x, _z));
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
{
ProtectedSpaces.Vectors.TryGetValue(_player.entityId, out string[] _vector1);
ProtectedSpaces.Vectors.Remove(_player.entityId);
int xMin = int.Parse(_vector1[0]), zMin = int.Parse(_vector1[1]), xMax = (int)_player.position.x, zMax = (int)_player.position.z;
int _xMinFix = xMin, _zMinFix = zMin, _xMaxFix = xMax, _zMaxFix = zMax;
if (xMin > xMax)
{
_xMinFix = xMax;
_xMaxFix = xMin;
}
if (zMin > zMax)
{
_zMinFix = zMax;
_zMaxFix = zMin;
}
string[] _vectors = { _xMinFix.ToString(), _zMinFix.ToString(), _xMaxFix.ToString(), _zMaxFix.ToString() };
if (!ProtectedSpaces.Protected.Contains(_vectors))
{
ProtectedSpaces.Protected.Add(_vectors);
ProtectedSpaces.UpdateXml();
List <string[]> _protected = new List <string[]>();
_protected.Add(_vectors);
ProtectedSpaces.AddProtection(_protected);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added protected space from {0},{1} to {2},{3}", _xMinFix, _zMinFix, _xMaxFix, _zMaxFix));
return;
}
else
{
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))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid integer: {0}", _params[1]));
return;
}
if (!int.TryParse(_params[2], out int zMin))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid integer: {0}", _params[2]));
return;
}
if (!int.TryParse(_params[3], out int xMax))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid integer: {0}", _params[3]));
return;
}
if (!int.TryParse(_params[4], out int zMax))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid integer: {0}", _params[4]));
return;
}
int _xMinFix = xMin, _zMinFix = zMin, _xMaxFix = xMax, _zMaxFix = zMax;
if (xMin > xMax)
{
_xMinFix = xMax;
_xMaxFix = xMin;
}
if (zMin > zMax)
{
_zMinFix = zMax;
_zMaxFix = zMin;
}
string[] _vectors = { _xMinFix.ToString(), _zMinFix.ToString(), _xMaxFix.ToString(), _zMaxFix.ToString() };
if (!ProtectedSpaces.Protected.Contains(_vectors))
{
ProtectedSpaces.Protected.Add(_vectors);
ProtectedSpaces.UpdateXml();
List <string[]> _protected = new List <string[]>();
_protected.Add(_vectors);
ProtectedSpaces.AddProtection(_protected);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added protected space from {0},{1} to {2},{3}", _xMinFix, _zMinFix, _xMaxFix, _zMaxFix));
}
else
{
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)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Not a client"));
return;
}
if (ProtectedSpaces.Vectors.ContainsKey(_senderInfo.RemoteClientInfo.entityId))
{
ProtectedSpaces.Vectors.Remove(_senderInfo.RemoteClientInfo.entityId);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Cancelled your saved corner positions"));
return;
}
else
{
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 (ProtectedSpaces.Protected.Count > 0)
{
int _listNum;
if (int.TryParse(_params[1], out _listNum))
{
if (ProtectedSpaces.Protected.Count >= _listNum)
{
string[] _vectors = ProtectedSpaces.Protected[_listNum - 1];
ProtectedSpaces.Protected.Remove(_vectors);
ProtectedSpaces.UpdateXml();
List <string[]> _protected = new List <string[]>();
_protected.Add(_vectors);
ProtectedSpaces.RemoveProtection(_protected);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed protected space {0}: {1},{2} to {3},{4}", _listNum, _vectors[0], _vectors[1], _vectors[2], _vectors[3]));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid list number: {0}", _params[1]));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid integer: {0}", _params[1]));
return;
}
}
else
{
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 (ProtectedSpaces.Protected.Count > 0)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Protected spaces list:"));
for (int i = 0; i < ProtectedSpaces.Protected.Count; i++)
{
string[] _vectors = ProtectedSpaces.Protected[i];
SdtdConsole.Instance.Output(string.Format("#{0}: {1},{2} to {3},{4}", i + 1, _vectors[0], _vectors[1], _vectors[2], _vectors[3]));
}
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] There are no protected spaces"));
return;
}
}
else
{
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.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[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 != 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 > 1)
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Homes has been set to off"));
return;
}
else
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Homes has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Homes is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("reset"))
{
if (_params.Count != 2)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}.", _params.Count));
return;
}
if (_params[1].Length < 1 || _params[1].Length > 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not reset Id: Invalid Id {0}", _params[1]));
return;
}
PersistentPlayer p = PersistentContainer.Instance.Players[_params[1]];
if (p != null)
{
PersistentContainer.Instance.Players[_params[1]].LastHome = DateTime.Now.AddYears(-1);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Homes delay reset for {0}.", _params[1]));
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player with id {0} does not have a Homes delay to reset.", _params[1]));
}
}
else
{
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 || _params.Count > 3)
{
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 (WebPanel.IsEnabled)
{
WebPanel.IsEnabled = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Web panel has been set to off"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Web panel is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!WebPanel.IsEnabled)
{
WebPanel.IsEnabled = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Web panel has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Web panel is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 2)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, 2, found {0}", _params.Count));
return;
}
else if (_params[1].Length != 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Client id must be 17 characters in length, found {0}", _params[1].Length));
return;
}
else
{
if (!WebPanel.Clients.Contains(_params[1]) && !WebPanel.BannedIP.Contains(_params[1]))
{
string _password = WebPanel.SetPassword();
WebPanel.Clients.Add(_params[1]);
if (PersistentContainer.Instance.WebPanelClientList != null)
{
List <string> _clients = PersistentContainer.Instance.WebPanelClientList;
_clients.Add(_params[1]);
PersistentContainer.Instance.WebPanelClientList = _clients;
}
else
{
List <string> _clients = new List <string>();
_clients.Add(_params[1]);
PersistentContainer.Instance.WebPanelClientList = _clients;
}
PersistentContainer.Instance.Players[_params[1]].WP = _password;
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added {0} to the web panel client list. Their password is {1}", _params[1], _password));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add this id. Client is already on the list or banned"));
return;
}
}
}
else if (_params[0].ToLower().Equals("remove"))
{
if (_params.Count != 2)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, 2, found {0}", _params.Count));
return;
}
else if (_params[1].Length != 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Client id must be 17 characters in length, found {0}", _params[1].Length));
return;
}
else
{
if (WebPanel.Clients.Contains(_params[1]))
{
WebPanel.Clients.Remove(_params[1]);
if (PersistentContainer.Instance.WebPanelClientList != null)
{
List <string> _clients = PersistentContainer.Instance.WebPanelClientList;
_clients.Remove(_params[1]);
PersistentContainer.Instance.WebPanelClientList = _clients;
}
PersistentContainer.Instance.Players[_params[1]].WP = "";
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed {0} from the web panel client list", _params[1]));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not remove this id. Client is not on the list"));
return;
}
}
}
else if (_params[0].ToLower().Equals("reset"))
{
if (_params.Count != 2)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, 2, found {0}", _params.Count));
return;
}
else if (_params[1].Length != 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Client id must be 17 characters in length, found {0}", _params[1].Length));
return;
}
else
{
if (WebPanel.TimeOut.ContainsKey(_params[1]))
{
WebPanel.TimeOut.Remove(_params[1]);
if (PersistentContainer.Instance.WebPanelTimeoutList != null)
{
Dictionary <string, DateTime> _timeouts = PersistentContainer.Instance.WebPanelTimeoutList;
_timeouts.Remove(_params[1]);
PersistentContainer.Instance.WebPanelTimeoutList = _timeouts;
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] IP {0} has been removed from the time out list", _params[1]));
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] IP {0} not found on the time out list", _params[1]));
}
if (WebPanel.Clients.Contains(_params[1]))
{
if (WebPanel.Visitor.ContainsKey(_params[1]))
{
WebPanel.Visitor.Remove(_params[1]);
}
if (WebPanel.Authorized.ContainsKey(_params[1]))
{
WebPanel.Authorized.Remove(_params[1]);
WebPanel.AuthorizedTime.Remove(_params[1]);
}
string _password = WebPanel.SetPassword();
PersistentContainer.Instance.Players[_params[1]].WP = _password;
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Client {0} has been reset. Their password is {1}", _params[1], _password));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Client {0} was not found on the list", _params[1]));
return;
}
}
}
else if (_params[0].ToLower().Equals("ban"))
{
if (_params.Count != 3)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, 3, found {0}", _params.Count));
return;
}
else if (_params[1].ToLower() == "add")
{
string _ip = _params[3];
if (!WebPanel.BannedIP.Contains(_ip))
{
WebPanel.BannedIP.Add(_ip);
List <string> _banList = PersistentContainer.Instance.WebPanelBanList;
if (_banList != null && _banList.Count > 0)
{
if (_banList.Contains(_ip))
{
_banList.Add(_ip);
PersistentContainer.Instance.WebPanelBanList = _banList;
}
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] IP {0} has been added to the ban list", _ip));
return;
}
else
{
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 (WebPanel.BannedIP.Contains(_ip))
{
WebPanel.BannedIP.Remove(_ip);
List <string> _banList = PersistentContainer.Instance.WebPanelBanList;
if (_banList != null && _banList.Count > 0)
{
if (_banList.Contains(_ip))
{
_banList.Remove(_ip);
PersistentContainer.Instance.WebPanelBanList = _banList;
}
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] IP {0} has been removed from the ban list", _ip));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not remove IP {0}. It is not on the ban list", _ip));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[1]));
}
}
else if (_params[0].ToLower().Equals("timeout"))
{
if (_params.Count != 3)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, 3, found {0}", _params.Count));
return;
}
else if (_params[1].ToLower() == "add")
{
string _ip = _params[3];
if (!WebPanel.TimeOut.ContainsKey(_ip))
{
WebPanel.TimeOut.Add(_ip, DateTime.Now);
Dictionary <string, DateTime> _timeoutList = PersistentContainer.Instance.WebPanelTimeoutList;
if (_timeoutList != null && _timeoutList.Count > 0)
{
if (_timeoutList.ContainsKey(_ip))
{
_timeoutList.Add(_ip, DateTime.Now);
PersistentContainer.Instance.WebPanelTimeoutList = _timeoutList;
}
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] IP {0} has been added to the timeout list", _ip));
return;
}
else
{
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 (WebPanel.TimeOut.ContainsKey(_ip))
{
WebPanel.TimeOut.Remove(_ip);
Dictionary <string, DateTime> _timeoutList = PersistentContainer.Instance.WebPanelTimeoutList;
if (_timeoutList != null && _timeoutList.Count > 0)
{
if (_timeoutList.ContainsKey(_ip))
{
_timeoutList.Remove(_ip);
PersistentContainer.Instance.WebPanelTimeoutList = _timeoutList;
}
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] IP {0} has been removed from the timeout list", _ip));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not remove IP {0}. It is not on the timeout list", _ip));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[1]));
}
}
else if (_params[0].ToLower().Equals("restart"))
{
if (WebPanel.IsEnabled)
{
WebPanel.IsEnabled = false;
WebPanel.Authorized.Clear();
WebPanel.Visitor.Clear();
WebPanel.PageHits.Clear();
WebPanel.LoginAttempts.Clear();
WebPanel.TimeOut.Clear();
WebPanel.IsEnabled = true;
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Web panel server has been cleared and restarted. All users must relog"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Web panel is not enabled, unable to restart it"));
return;
}
}
else if (_params[0].ToLower().Equals("list"))
{
if (WebPanel.Clients.Count > 0)
{
for (int i = 0; i < WebPanel.Clients.Count; i++)
{
string _client = WebPanel.Clients[i];
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Client id = {0}", _client));
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] There are no clients on the web panel list"));
}
if (WebPanel.BannedIP.Count > 0)
{
for (int i = 0; i < WebPanel.BannedIP.Count; i++)
{
string _bannedIp = WebPanel.BannedIP[i];
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Banned IP = {0}", _bannedIp));
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] There are no banned ip address"));
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in WebPanelConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 && _params.Count > 2)
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Auction has been set to off"));
return;
}
else
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Auction has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Auction is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("cancel"))
{
if (_params.Count != 2)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}", _params.Count));
return;
}
int _id;
if (int.TryParse(_params[1], out _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.GetClientInfoFromSteamId(_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);
using (StreamWriter sw = new StreamWriter(filepath, true))
{
sw.WriteLine(string.Format("{0}: {1} {2} had their auction entry # {3} cancelled via console by {4}.", DateTime.Now, _cInfo.playerId, _cInfo.playerName, _id, _senderInfo.RemoteClientInfo.playerId));
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);
}
}
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);
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Id {0} has been removed from the auction list", _id));
}
}
}
}
else
{
SdtdConsole.Instance.Output("[SERVERTOOLS] Could not find this id listed in the auction. Unable to cancel.[-]");
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid integer {0}", _id));
}
return;
}
else if (_params[0].ToLower().Equals("clear"))
{
if (_params.Count != 2)
{
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);
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Id {0} has been removed from the auction", _id));
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Auction does not contain id {0}", _id));
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid integer {0}", _id));
}
return;
}
else if (_params[0].ToLower().Equals("list"))
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (Auction.AuctionItems.Count > 0)
{
if (PersistentContainer.Instance.Players.SteamIDs.Count > 0)
{
List <string> playerlist = PersistentContainer.Instance.Players.SteamIDs;
Dictionary <int, int> _auctionPrices = PersistentContainer.Instance.AuctionPrices;
for (int i = 0; i < playerlist.Count; i++)
{
string _steamId = playerlist[i];
if (PersistentContainer.Instance.Players[_steamId].Auction != null && PersistentContainer.Instance.Players[_steamId].Auction.Count > 0)
{
foreach (var _auctionItem in PersistentContainer.Instance.Players[_steamId].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.Coin_Name);
SdtdConsole.Instance.Output(_message);
}
}
}
}
}
else
{
SdtdConsole.Instance.Output("[SERVERTOOLS] No items are listed in the auction");
}
}
else
{
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 != 2 && _params.Count != 4)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, 2 or 4, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (ReservedSlots.IsEnabled)
{
ReservedSlots.IsEnabled = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Reserved slots has been set to off"));
return;
}
else
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Reserved slots has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Reserved slots is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 4)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 4, found {0}", _params.Count));
return;
}
if (_params[1].Length < 1 || _params[1].Length > 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add Id: Invalid Id {0}", _params[1]));
return;
}
if (ReservedSlots.Dict.ContainsKey(_params[1]))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add Id. {0} is already in the Reserved slots list", _params[1]));
return;
}
double _daysToExpire;
if (!double.TryParse(_params[3], out _daysToExpire))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid days to expire: {0}", _params[3]));
return;
}
DateTime _expireDate;
if (_daysToExpire > 0d)
{
_expireDate = DateTime.Now.AddDays(_daysToExpire);
}
else
{
_expireDate = DateTime.Now.AddDays(18250d);
}
ReservedSlots.Dict.Add(_params[1], _expireDate);
ReservedSlots.Dict1.Add(_params[1], _params[2]);
ReservedSlots.UpdateXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added Id {0} with the name of {1} that expires on {2} to the Reserved slots list", _params[1], _params[2], _expireDate.ToString()));
}
else if (_params[0].ToLower().Equals("remove"))
{
if (_params.Count != 2)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}", _params.Count));
return;
}
if (_params[1].Length < 1 || _params[1].Length > 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not remove Id: Invalid Id {0}", _params[1]));
return;
}
ClientInfo _cInfo = ConsoleHelper.ParseParamIdOrName(_params[1]);
if (_cInfo != null)
{
if (!ReservedSlots.Dict.ContainsKey(_cInfo.playerId))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Id {0} was not found on the Reserved slots list", _params[1]));
return;
}
ReservedSlots.Dict.Remove(_cInfo.playerId);
ReservedSlots.Dict1.Remove(_cInfo.playerId);
ReservedSlots.UpdateXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed Id {0} from Reserved slots list", _params[1]));
}
else
{
if (ReservedSlots.Dict.ContainsKey(_params[1]))
{
ReservedSlots.Dict.Remove(_params[1]);
ReservedSlots.Dict1.Remove(_params[1]);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed Id {0} from Reserved slots list", _params[1]));
ReservedSlots.UpdateXml();
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Id {0} was not found on the Reserved slots list", _params[1]));
}
}
}
else if (_params[0].ToLower().Equals("list"))
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (ReservedSlots.Dict.Count == 0)
{
SdtdConsole.Instance.Output("[SERVERTOOLS] There are no players on the Reserved slots list");
return;
}
else
{
foreach (var _key in ReservedSlots.Dict)
{
string _name;
if (ReservedSlots.Dict1.TryGetValue(_key.Key, out _name))
{
SdtdConsole.Instance.Output(string.Format("{0} {1} {2}", _key.Key, _name, _key.Value));
}
}
}
}
else
{
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)
{
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)
{
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)
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Watch list has been set to off"));
return;
}
else
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Watch list has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Watch list is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 3)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 3, found {0}.", _params.Count));
return;
}
if (_params[1].Length != 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add SteamId: Invalid SteamId {0}", _params[1]));
return;
}
if (Watchlist.Dict.ContainsKey(_params[1]))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add SteamId. {0} is already in the Watchlist.", _params[1]));
return;
}
if (_params.Count == 3)
{
Watchlist.Dict.Add(_params[1], _params[2]);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added SteamId {0} with the reason {1} the Watchlist.", _params[1], _params[2]));
}
Watchlist.UpdateXml();
}
else if (_params[0].ToLower().Equals("remove"))
{
if (_params.Count != 2)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}", _params.Count));
return;
}
if (!Watchlist.Dict.ContainsKey(_params[1]))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] SteamId {0} was not found", _params[1]));
return;
}
Watchlist.Dict.Remove(_params[1]);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed SteamId {0} from the Watchlist", _params[1]));
Watchlist.UpdateXml();
}
else if (_params[0].ToLower().Equals("list"))
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (Watchlist.Dict.Count < 1)
{
SdtdConsole.Instance.Output("[SERVERTOOLS] There are no steamIds on the Watchlist");
return;
}
foreach (KeyValuePair <string, string> _key in Watchlist.Dict)
{
string _output = string.Format("{0} {1}", _key.Key, _key.Value);
SdtdConsole.Instance.Output(_output);
}
}
else
{
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 || _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 (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 > 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
{
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 != 1 && _params.Count != 2 && _params.Count != 4 && _params.Count != 5 && _params.Count != 8)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, 2, 4, 5 or 8, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (ChatColorPrefix.IsEnabled)
{
ChatColorPrefix.IsEnabled = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Chat color prefix has been set to off"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Chat color prefix is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!ChatColorPrefix.IsEnabled)
{
ChatColorPrefix.IsEnabled = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Chat color prefix has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Chat color prefix is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 4 && _params.Count != 5 && _params.Count != 8)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 4, 5 or 8, found {0}", _params.Count));
return;
}
ClientInfo _cInfo = ConsoleHelper.ParseParamIdOrName(_params[1]);
if (_cInfo == null)
{
if (_params[1].Length == 17)
{
_cInfo = PersistentOperations.GetClientInfoFromSteamId(_params[1]);
if (_cInfo == null)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not find player data attached to {0}", _params[1]));
return;
}
}
else
{
if (int.TryParse(_params[1], out int _entId))
{
_cInfo = PersistentOperations.GetClientInfoFromEntityId(_entId);
if (_cInfo == null)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not find player data attached to {0}", _params[1]));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not find player data attached to {0}", _params[1]));
return;
}
}
}
if (_params.Count == 8)
{
foreach (var group in ChatColorPrefix.Dict)
{
if (group.Value[1] == _params[3])
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add id {0} to the chat color prefix list. Group {1} already exists on the list. Create a new entry or add them to this group", _cInfo.playerId, _params[3]));
return;
}
}
double _daysToExpire;
if (!double.TryParse(_params[7], out _daysToExpire))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid days to expire: {0}", _params[7]));
return;
}
DateTime _expireDate;
if (_daysToExpire > 0d)
{
_expireDate = DateTime.Now.AddDays(_daysToExpire);
}
else
{
_expireDate = DateTime.Now.AddDays(18250d);
}
if ((!_params[5].Contains("[") || !_params[5].Contains("]")) && _params[5] != "**")
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add id {0} to the chat color prefix list. Name color must be in HTML format, example [FFFFFF] with the brackets included. Found: {1}", _params[1], _params[5]));
return;
}
if ((!_params[6].Contains("[") || !_params[6].Contains("]")) && _params[6] != "**")
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add id {0} to the chat color prefix list. Prefix color must be in HTML format, example [FFFFFF] with the brackets included. Found: {1}", _params[1], _params[6]));
return;
}
string[] _c = new string[] { _params[2], _params[3], _params[4], _params[5], _params[6] };
if (ChatColorPrefix.Dict.ContainsKey(_params[1]))
{
ChatColorPrefix.Dict[_cInfo.playerId] = _c;
ChatColorPrefix.Dict1[_cInfo.playerId] = _expireDate;
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Updated id {0} with the name of {1} to the group {2} using prefix {3}, name color {4} and prefix color {5} that expires {6} to the chat color prefix list.", _cInfo.playerId, _params[2], _params[3], _params[4], _params[5], _params[6], _expireDate.ToString()));
}
else
{
ChatColorPrefix.Dict.Add(_cInfo.playerId, _c);
ChatColorPrefix.Dict1.Add(_cInfo.playerId, _expireDate);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added id {0} with the name of {1} to the group {2} using prefix {3}, name color {4} and prefix color {5} that expires {6} to the chat color prefix list.", _cInfo.playerId, _params[2], _params[3], _params[4], _params[5], _params[6], _expireDate.ToString()));
}
ChatColorPrefix.UpdateXml();
return;
}
else if (_params.Count == 5)
{
foreach (var group in ChatColorPrefix.Dict)
{
if (group.Value[1] == _params[3])
{
double _daysToExpire2;
if (!double.TryParse(_params[4], out _daysToExpire2))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid days to expire: {0}", _params[4]));
return;
}
DateTime _expireDate2;
if (_daysToExpire2 > 0d)
{
_expireDate2 = DateTime.Now.AddDays(_daysToExpire2);
}
else
{
_expireDate2 = DateTime.Now.AddDays(18250d);
}
string[] _c = new string[] { _params[2], group.Value[1], group.Value[2], group.Value[3], group.Value[4] };
if (ChatColorPrefix.Dict.ContainsKey(_cInfo.playerName))
{
ChatColorPrefix.Dict[_cInfo.playerId] = _c;
ChatColorPrefix.Dict1[_cInfo.playerId] = _expireDate2;
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Updated id {0} with the name of {1} to the group {2} using prefix {3}, name color {4} and prefix color {5} that expires {6} to the chat color prefix list.", _cInfo.playerId, _params[2], group.Value[1], group.Value[2], group.Value[3], group.Value[4], _expireDate2.ToString()));
}
else
{
ChatColorPrefix.Dict.Add(_cInfo.playerId, _c);
ChatColorPrefix.Dict1.Add(_cInfo.playerId, _expireDate2);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added id {0} with the name of {1} to the group {2} using prefix {3}, name color {4} and prefix color {5} that expires {6} to the chat color prefix list.", _cInfo.playerId, _params[2], group.Value[1], group.Value[2], group.Value[3], group.Value[4], _expireDate2.ToString()));
}
ChatColorPrefix.UpdateXml();
return;
}
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] No group with the name {0} was found.", _params[3]));
return;
}
else if (_params.Count == 4)
{
foreach (var group in ChatColorPrefix.Dict)
{
if (group.Value[1] == _params[3])
{
string[] _c = new string[] { _params[2], _params[3], group.Value[2], group.Value[3], group.Value[4] };
ChatColorPrefix.Dict1.TryGetValue(group.Key, out DateTime _dt);
ChatColorPrefix.Dict.Add(_cInfo.playerId, _c);
ChatColorPrefix.Dict1.Add(_cInfo.playerId, _dt);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Added Id {0} with the name of {1} to the group {2} using prefix {3} name color {4} and prefix color {5} that expires {6} to the chat color prefix list.", _cInfo.playerId, _params[2], _params[3], group.Value[2], group.Value[3], group.Value[4], _dt.ToString()));
ChatColorPrefix.UpdateXml();
return;
}
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] No group with the name {0} was found.", _params[3]));
return;
}
}
else if (_params[0].ToLower().Equals("remove"))
{
if (_params.Count != 2)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}.", _params.Count));
return;
}
foreach (var group in ChatColorPrefix.Dict)
{
if (group.Value[1] == _params[1])
{
ChatColorPrefix.Dict.Remove(group.Key);
ChatColorPrefix.Dict1.Remove(group.Key);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed {0} named {1} with group {2} from the chat color prefix list.", group.Key, group.Value[0], _params[1]));
}
if (group.Key == _params[1])
{
ChatColorPrefix.Dict.Remove(group.Key);
ChatColorPrefix.Dict1.Remove(group.Key);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed {0} named {1} with group {2} from the chat color prefix list.", _params[1], group.Value[0], group.Value[1]));
}
if (group.Value[0] == _params[1])
{
ChatColorPrefix.Dict.Remove(group.Key);
ChatColorPrefix.Dict1.Remove(group.Key);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Removed {0} named {1} with group {2} from the chat color prefix list.", group.Key, _params[1], group.Value[1]));
}
ChatColorPrefix.UpdateXml();
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Completed removing id and groups matching {0} from the chat color prefix list.", _params[1]));
}
else if (_params[0].ToLower().Equals("list"))
{
foreach (var group in ChatColorPrefix.Dict)
{
if (group.Value[2] == "")
{
group.Value[2] = "**";
}
if (group.Value[3] == "")
{
group.Value[3] = "**";
}
DateTime _dt;
ChatColorPrefix.Dict1.TryGetValue(group.Key, out _dt);
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Id {0} named {1} with group {2} prefix {3} color {4} expires {5}.", group.Key, group.Value[0], group.Value[1], group.Value[2], group.Value[3], _dt));
}
}
else
{
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
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (VehicleTeleport.IsEnabled)
{
VehicleTeleport.IsEnabled = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport has been set to off"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (!VehicleTeleport.IsEnabled)
{
VehicleTeleport.IsEnabled = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("bike"))
{
if (VehicleTeleport.Bike)
{
VehicleTeleport.Bike = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport bike has been set to off"));
return;
}
else
{
VehicleTeleport.Bike = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport bike has been set to on"));
return;
}
}
else if (_params[0].ToLower().Equals("minibike"))
{
if (VehicleTeleport.Mini_Bike)
{
VehicleTeleport.Mini_Bike = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport minibike has been set to off"));
return;
}
else
{
VehicleTeleport.Mini_Bike = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport minibike has been set to on"));
return;
}
}
else if (_params[0].ToLower().Equals("motorbike"))
{
if (VehicleTeleport.Motor_Bike)
{
VehicleTeleport.Motor_Bike = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport minibike has been set to off"));
return;
}
else
{
VehicleTeleport.Motor_Bike = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport minibike has been set to on"));
return;
}
}
else if (_params[0].ToLower().Equals("jeep"))
{
if (VehicleTeleport.Jeep)
{
VehicleTeleport.Jeep = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport jeep has been set to off"));
return;
}
else
{
VehicleTeleport.Jeep = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport jeep has been set to on"));
return;
}
}
else if (_params[0].ToLower().Equals("gyro"))
{
if (VehicleTeleport.Gyro)
{
VehicleTeleport.Gyro = false;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Vehicle teleport gyro has been set to off"));
return;
}
else
{
VehicleTeleport.Gyro = true;
Config.WriteXml();
SdtdConsole.Instance.Output(string.Format("Vehicle teleport gyro has been set to on"));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in VehicleTeleportConsole.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 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 > 3)
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Jail has been set to off"));
return;
}
else
{
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();
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Jail has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Jail is already on"));
return;
}
}
else if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 3)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 3, found {0}", _params.Count));
return;
}
if (_params[1].Length < 3 || _params[1].Length > 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add Id: Invalid Id {0}", _params[1]));
return;
}
if (Jail.Jailed.Contains(_params[1]))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not add Id. {0} is already in the Jail list", _params[1]));
return;
}
int _jailTime;
if (!int.TryParse(_params[2], out _jailTime))
{
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 == "")
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not put a player in jail: Jail position has not been set"));
return;
}
else
{
ClientInfo _cInfo = ConsoleHelper.ParseParamIdOrName(_params[1]);
if (_cInfo != null)
{
if (Jail.Jailed.Contains(_cInfo.playerId))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player with Id {0} is already in jail", _params[1]));
return;
}
else
{
EntityPlayer _player = GameManager.Instance.World.Players.dict[_cInfo.entityId];
if (_player != null && _player.IsSpawned())
{
int x, y, z;
string[] _cords = Jail.Jail_Position.Split(',');
int.TryParse(_cords[0], out x);
int.TryParse(_cords[1], out y);
int.TryParse(_cords[2], out z);
_cInfo.SendPackage(NetPackageManager.GetPackage <NetPackageTeleportPlayer>().Setup(new Vector3(x, y, z), null, false));
}
Jail.Jailed.Add(_cInfo.playerId);
PersistentContainer.Instance.Players[_cInfo.playerId].JailTime = _jailTime;
PersistentContainer.Instance.Players[_cInfo.playerId].JailName = _cInfo.playerName;
PersistentContainer.Instance.Players[_cInfo.playerId].JailDate = DateTime.Now;
PersistentContainer.DataChange = true;
if (_jailTime > 0)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] You have put {0} in jail for {1} minutes", _cInfo.playerName, _jailTime));
Phrases.Dict.TryGetValue(190, out string _phrase190);
ChatHook.ChatMessage(_cInfo, Config.Chat_Response_Color + _phrase190 + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
if (_jailTime == -1)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] You have put {0} in jail for life", _cInfo.playerName));
Phrases.Dict.TryGetValue(190, out string _phrase190);
ChatHook.ChatMessage(_cInfo, Config.Chat_Response_Color + _phrase190 + "[-]", -1, Config.Server_Response_Name, EChatType.Whisper, null);
}
}
}
else
{
if (PersistentContainer.Instance.Players[_params[1]] != null)
{
Jail.Jailed.Add(_cInfo.playerId);
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;
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 if (_params[0].ToLower().Equals("remove"))
{
if (_params.Count != 2)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 2, found {0}", _params.Count));
return;
}
if (_params[1].Length != 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not remove player Id: Invalid steam Id {0}", _params[1]));
return;
}
else
{
if (!Jail.Jailed.Contains(_params[1]))
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player with steam Id {0} is not in jail", _params[1]));
return;
}
else
{
ClientInfo _cInfo = ConnectionManager.Instance.Clients.ForPlayerId(_params[1]);
if (_cInfo != null)
{
EntityPlayer _player = GameManager.Instance.World.Players.dict[_cInfo.entityId];
if (_player != null)
{
EntityBedrollPositionList _position = _player.SpawnPoints;
Jail.Jailed.Remove(_cInfo.playerId);
PersistentContainer.Instance.Players[_cInfo.playerId].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));
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] You have released a player with steam id {0} from jail", _params[1]));
return;
}
}
else
{
}
}
}
}
else if (_params[0].ToLower().Equals("list"))
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found {0}.", _params.Count));
return;
}
if (Jail.Jailed.Count == 0)
{
SdtdConsole.Instance.Output("[SERVERTOOLS] There are no Ids 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;
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Jailed player: steam Id {0} named {1} for {2} more minutes.", _id, _jailName, _timeleft));
}
else if (_jailTime == -1)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Jailed player: steam Id {0} named {1} forever.", _id, _jailName));
}
}
}
}
else
{
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));
}
}
