public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
if (_params.Count < 1) {
SdtdConsole.Instance.Output ("Utilisation: played <NomDuJoueur>");
return;
}
try
{
string nameFilter = _params[0].ToLower();
string text = string.Empty;
foreach (string sid in PersistentContainer.Instance.Players.SteamIDs) {
Player p = PersistentContainer.Instance.Players [sid,false];
if (nameFilter.Length == 0 || p.Name.ToLower ().Contains (nameFilter)) {
text = String.Format("{0} a joue sur le serveur {1}, {2} minutes (=> {3} heure(s)) depuis le 06-08-2015.",
p.Name,
"KFP",
(p.TotalPlayTime / 60),
(p.TotalPlayTime / 3600)
);
GameManager.Instance.GameMessageServer(null, text, string.Empty);
return;
}
}
} catch (Exception e) {
Log.Out ("Error in PlayedTime.Run: " + e);
SdtdConsole.Instance.Output("Error in PlayedTime.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count != 1 || _params [0].Length == 0) {
SdtdConsole.Instance.Output ("Usage: listitems <searchString>");
SdtdConsole.Instance.Output (" or: li <All>");
return;
}
int num = 0;
if (_params[0].Equals("All")) {
SdtdConsole.Instance.Output ("Liste des objets de base.");
foreach (string s in ItemList.Instance.ItemNames) {
SdtdConsole.Instance.Output (num + ". " + s);
num++;
}
}else{
if (_params[0].Equals("Save")) {
Execute2();
return;
}
else {
SdtdConsole.Instance.Output ("Liste des objets de base.");
foreach (string s in ItemList.Instance.ItemNames) {
if (s.ToLower ().Contains (_params [0].ToLower ())) {
SdtdConsole.Instance.Output (num + ". " + s);
num++;
}
}
}
}
SdtdConsole.Instance.Output ("La liste contient " + num + " objets.");
} catch (Exception e) {
Log.Out ("Error in ListItems.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
World w = GameManager.Instance.World;
int num = 0;
string playersList = "<playersList>";
foreach (KeyValuePair<int, EntityPlayer> current in w.Players.dict) {
ClientInfo clientInfoFromEntityID = ConnectionManager.Instance.GetClientInfoForEntityId(current.Key);
playersList += "<player id=\"" + ++num + "\" steamId=\"" + clientInfoFromEntityID.entityId;
playersList += "\" name=\"" + current.Value.EntityName;
playersList += "\" pos=\"" + current.Value.GetPosition ();
playersList += "\" />";
playersList += "\n";
}
playersList += "</playersList>";
playersList = playersList.Replace("(","").Replace(")","");
//SdtdConsole.Instance.Output (playersList);
StreamWriter sw = new StreamWriter("D:\\Inventories\\playersList.xml");
sw.Write(playersList);
sw.Close();
playersList = null;
} catch (Exception e) {
SdtdConsole.Instance.Output ("Error in WritePlayersList.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1) {
SdtdConsole.Instance.Output("Utilisation: sound <nomdujoueur1|gameid1> ...");
return;
}
ClientInfo ci1 = ConsoleHelper.ParseParamIdOrName (_params [0]);
if (ci1 == null) {
SdtdConsole.Instance.Output("Pseudo1 ou GameId1 introuvable.");
return;
}
else {
EntityPlayer player1 = (EntityPlayer)GameManager.Instance.World.GetEntity(ci1.entityId);
string text2 = "Enemies/Acid_Puking_Hulk/hulkpain1";
player1.PlayOneShot(text2);
player1.PlayOneShot(text2);
SdtdConsole.Instance.Output("Son joue chez le joueur " + _params[0]);
return;
}
}
catch (Exception e)
{
Log.Out("Error in Heal.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1) {
SdtdConsole.Instance.Output("Utilisation: sound <nomdujoueur1|gameid1> ...");
return;
}
int x = int.MinValue;
int.TryParse (_params [0], out x);
World world = GameManager.Instance.World;
for (int i = world.Entities.list.Count - 1; i >= 0; i--) {
Entity item = world.Entities.list[i];
SdtdConsole.Instance.Output("item.entityId: " + item.entityId);
SdtdConsole.Instance.Output("x: " + x);
if(item.entityId == x) {
item.PlayOneShot("Weapons/Ranged/44Magnum/44magnum_fire");
SdtdConsole.Instance.Output("Sound played.");
return;
}
}
}
catch (Exception e)
{
Log.Out("Error in Heal.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
int _entityId = int.MinValue;
if (!int.TryParse(_params[0], out _entityId))
{
SdtdConsole.Instance.Output(string.Format("Invalid entityId: {0}", _entityId));
return;
}
else
{
GameManager.Instance.World.RemoveEntity(_entityId, EnumRemoveEntityReason.Despawned);
SdtdConsole.Instance.Output(string.Format("Removed entity {0} ", _entityId));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in EntityRemove.Run: {0}.", e));
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (_params[0].Length != 17)
{
SdtdConsole.Instance.Output(string.Format("Can not add SteamId: Invalid SteamId {0}", _params[0]));
return;
}
string _filepath = string.Format("{0}/Player/{1}.map", GameUtils.GetSaveGameDir(), _params[0]);
string _filepath1 = string.Format("{0}/Player/{1}.ttp", GameUtils.GetSaveGameDir(), _params[0]);
List<ClientInfo> _cInfoList = ConnectionManager.Instance.GetClients();
foreach (ClientInfo _cInfo in _cInfoList)
{
if (_cInfo.playerId == _params[0])
{
string _phrase400;
if (!Phrases.Dict.TryGetValue(400, out _phrase400))
{
_phrase400 = "Reseting your player profile.";
}
SdtdConsole.Instance.ExecuteSync(string.Format("kick {0} \"{1}\"", _cInfo.entityId, _phrase400), _cInfo);
break;
}
}
if (!File.Exists(_filepath))
{
SdtdConsole.Instance.Output(string.Format("Could not find file {0}.map", _params[0]));
}
else
{
File.Delete(_filepath);
}
if (!File.Exists(_filepath1))
{
SdtdConsole.Instance.Output(string.Format("Could not find file {0}.ttp", _params[0]));
}
else
{
File.Delete(_filepath1);
}
string _phrase401;
if (!Phrases.Dict.TryGetValue(401, out _phrase401))
{
_phrase401 = "You have reset the profile for player {SteamId}.";
}
_phrase401 = _phrase401.Replace("{SteamId}", _params[0]);
SdtdConsole.Instance.Output(string.Format("{0}", _phrase401));
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ResetPlayer.Run: {0}.", e));
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
if (_senderInfo.RemoteClientInfo == null) {
Log.Out ("Command \"reply\" can only be used on clients!");
} else {
RunInternal (_senderInfo.RemoteClientInfo, _params);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
RunInternal (_params);
}
catch (Exception e) {
Log.Out ("Error in SayToteam.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count != 4 && _params.Count != 2) {
SdtdConsole.Instance.Output ("Usage: teleportplayer <entityid|playername|steamid> <x> <y> <z>");
SdtdConsole.Instance.Output (" or: teleportplayer <entityid|playername|steamid> <target entityid|playername|steamid>");
} else {
ClientInfo ci1 = ConsoleHelper.ParseParamIdOrName (_params [0]);//ci1.SendPackage (pkg);
if (ci1 == null) {
SdtdConsole.Instance.Output ("Playername or entity/steamid id not found.");
return;
}
EntityPlayer ep1 = GameManager.Instance.World.Players.dict [ci1.entityId];
if (_params.Count == 4) {
int x = int.MinValue;
int y = int.MinValue;
int z = int.MinValue;
int.TryParse (_params [1], out x);
int.TryParse (_params [2], out y);
int.TryParse (_params [3], out z);
if (x == int.MinValue || y == int.MinValue || z == int.MinValue) {
SdtdConsole.Instance.Output ("At least one of the given coordinates is not a valid integer");
return;
}
ep1.position.x = x;
ep1.position.y = y;
ep1.position.z = z;
} else {
ClientInfo ci2 = ConsoleHelper.ParseParamIdOrName (_params [1]);
if (ci2 == null) {
SdtdConsole.Instance.Output ("Target playername or entity/steamid id not found.");
return;
}
EntityPlayer ep2 = GameManager.Instance.World.Players.dict [ci2.entityId];
ep1.position = ep2.GetPosition();
ep1.position.y += 1;
ep1.position.z += 1;
}
NetPackageEntityTeleport pkg = new NetPackageEntityTeleport (ep1);
//NetPackagePlayerInventory pkh = new NetPackagePlayerInventory(ep2
ci1.SendPackage (pkg);
}
} catch (Exception e) {
Log.Out ("Error in TeleportPlayer.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_senderInfo.RemoteClientInfo != null) {
RunInternal (_senderInfo.RemoteClientInfo, _params);
} else {
RunInternal (null, _params);
}
} catch (Exception e) {
Log.Out ("Error in SayToPlayer.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count != 3 && _params.Count != 4) {
SdtdConsole.Instance.Output ("Wrong number of arguments, expected 3 or 4, found " + _params.Count + ".");
return;
}
ClientInfo ci = ConsoleHelper.ParseParamIdOrName (_params [0]);
if (ci == null) {
SdtdConsole.Instance.Output ("Playername or entity id not found.");
return;
}
ItemValue iv = ItemList.Instance.GetItemValue (_params [1]);
if (iv == null) {
SdtdConsole.Instance.Output ("Item not found.");
return;
}
int n = int.MinValue;
if (!int.TryParse (_params [2], out n) || n <= 0) {
SdtdConsole.Instance.Output ("Amount is not an integer or not greater than zero.");
return;
}
if (_params.Count == 4) {
if (!iv.HasQuality) {
SdtdConsole.Instance.Output ("Item " + _params [1] + " does not support quality.");
return;
}
int quality = int.MinValue;
if (!int.TryParse (_params [3], out quality) || quality <= 0) {
SdtdConsole.Instance.Output ("Quality is not an integer or not greater than zero.");
return;
}
iv.Quality = quality;
}
EntityPlayer p = GameManager.Instance.World.Players.dict [ci.entityId];
ItemStack invField = new ItemStack (iv, n);
GameManager.Instance.ItemDropServer (invField, p.GetPosition (), Vector3.zero, -1, 50);
SdtdConsole.Instance.Output ("Dropped item");
} catch (Exception e) {
Log.Out ("Error in Give.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count == 1) {
removeById (_params [0]);
} else if (_params.Count == 3) {
removeByPosition (_params);
} else {
SdtdConsole.Instance.Output ("Usage: removelandprotection <x> <y> <z> OR removelandprotection <steamid>");
}
} catch (Exception e) {
Log.Out ("Error in RemoveLandProtection.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
int num;
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Concat("Wrong number of arguments, expected 1, found ", _params.Count, "."));
SdtdConsole.Instance.Output("Utilisation: heal <nomdujouer|gameid>");
return;
}
Entity item = null;
ClientInfo clientInfoForNameOrId = ConsoleHelper.ParseParamIdOrName (_params [0]);
if (clientInfoForNameOrId != null)
{
item = GameManager.Instance.World.Players.dict[clientInfoForNameOrId.entityId];
}
else if (int.TryParse(_params[0], out num) && GameManager.Instance.World.Entities.dict.ContainsKey(num))
{
item = GameManager.Instance.World.Entities.dict[num];
}
if (item == null)
{
SdtdConsole.Instance.Output("Pseudo ou GameId introuvable.");
return;
}
item.DamageEntity(new DamageSource(EnumDamageSourceType.Bullet), -9999, false);
/*try {
CommonMappingFunctions.GetGameManager().GetRPCNetworkView().RPC("RPC_ChatMessage", ci.networkPlayer,
new object[]
{
"ZBot vient de vous soigner.",
-1,
string.Empty,
false
});
SdtdConsole.Instance.Output ("Message prive a destination du joueur " + (receiverName != null ? "\"" + receiverName + "\"" : "unknownName"));
} catch (Exception e) {
Log.Out("Error in Heal1.Run: " + e);
}*/
SdtdConsole.Instance.Output("Joueur soigne " + _params[0]);
} catch (Exception e) {
Log.Out("Error in Heal2.Run: " + e);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (Prayer.IsEnabled)
{
Prayer.IsEnabled = false;
LoadConfig.WriteXml();
SdtdConsole.Instance.Output(string.Format("Prayer has been set to off"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("Prayer is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (Prayer.IsEnabled)
{
Prayer.IsEnabled = true;
LoadConfig.WriteXml();
SdtdConsole.Instance.Output(string.Format("Prayer has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("Prayer is already on"));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in PrayerConsole.Execute: {0}", e));
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count < 1) {
SdtdConsole.Instance.Output ("Usage: ShowEquipment <steamid|playername|entityid>");
SdtdConsole.Instance.Output (" or: ShowEquipment <steamid|playername|entityid> <1>");
return;
}
string steamid = PersistentContainer.Instance.Players.GetSteamID (_params [0], true);
if (steamid == null) {
SdtdConsole.Instance.Output ("Playername or entity/steamid id not found or no inventory saved (first saved after a player has been online for 30s).");
return;
}
Player p = PersistentContainer.Instance.Players [steamid, false];
PersistentData.Inventory inv = p.Inventory;
if (p.IsOnline == true) {
EntityPlayer ply = p.Entity;
int num = 0;
int vc = ply.equipment.GetSlotCount();
SdtdConsole.Instance.Output ("**** Equipment of player " + ply.EntityName + " ****");
for (int i = 0; i < vc; i++){
//ib[k].itemValue.type =
ItemValue gg = p.Entity.equipment.GetSlotItem(i);
if (gg != null)
{
try
{
if (gg.type >= 1){
ItemClass itemClass = ItemClass.GetForId(gg.type);
string name = itemClass.GetItemName(); //ib..GetItemName ();
if (name != null) {
num ++;
SdtdConsole.Instance.Output (num + ". * Slot # " + i +"/" + vc + " => " + name + " *");
}
}
}catch (Exception e) {
}
}
}
SdtdConsole.Instance.Output ("**** Total of " + num + " slots equiped ****");
}
} catch (Exception e) {
Log.Out ("Error in ShowEquipment.Run: " + e);
}
}
public override void Execute(List <string> parameters, CommandSenderInfo senderInfo)
{
TelemetryTools.CollectEvent("command", "execute", GetCommands()[0]);
try
{
ParseParams(parameters, out var tasks, out bool simulate, out bool auto, out int?timerInterval);
timerInterval = timerInterval ?? 60 * 10; // every 10 minutes by default
if (auto)
{
if (!PersistentData.Instance.RepairAuto)
{
PersistentData.Instance.RepairAuto = true;
PersistentData.Instance.RepairTasks = tasks;
PersistentData.Instance.RepairSimulate = simulate;
PersistentData.Instance.RepairInterval = timerInterval.Value; // every 10 minutes by default;
PersistentData.Instance.Save();
RepairEngine.AutoOn();
}
else
{
RepairEngine.AutoOff();
PersistentData.Instance.RepairAuto = false;
PersistentData.Instance.RepairCounter = 0;
PersistentData.Instance.Save();
}
}
else
{
ThreadManager.AddSingleTask(delegate
{
try
{
var repairEngine = new RepairEngine(tasks, simulate, senderInfo);
repairEngine.Start();
}
catch (Exception ex)
{
Log.Exception(ex);
SdtdConsole.Instance.OutputAsync(senderInfo, string.Format(Resources.ErrorDuringCommand, ex.Message));
}
});
}
}
catch (Exception ex)
{
CommandTools.HandleCommandException(ex);
}
}
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("Wrong number of arguments, expected 1, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("off"))
{
if (ChatHook.Normal_Player_Color_Prefix)
{
ChatHook.Normal_Player_Color_Prefix = false;
LoadConfig.WriteXml();
SdtdConsole.Instance.Output(string.Format("Normal player coloring has been set to off"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("Normal player coloring is already off"));
return;
}
}
else if (_params[0].ToLower().Equals("on"))
{
if (ChatHook.Normal_Player_Color_Prefix)
{
ChatHook.Normal_Player_Color_Prefix = true;
LoadConfig.WriteXml();
SdtdConsole.Instance.Output(string.Format("Normal player coloring has been set to on"));
return;
}
else
{
SdtdConsole.Instance.Output(string.Format("Normal player coloring is already on"));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("Invalid argument {0}", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in NormalPlayerColoringConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count != 1) {
SdtdConsole.Instance.Output ("Usage: ListBlocks <playername> or lb <playername>");
return;
}
if (_params.Count == 1 ){
RemoveBlock (_params);
}
} catch (Exception ex) {
Log.Out("RemoveBlocks error: " + ex.Message);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output("Wrong number of arguments.");
return;
}
if (!int.TryParse(_params[0], out HighPingKicker.MAXPING))
{
SdtdConsole.Instance.Output("Maxping is not an integer.");
return;
}
SdtdConsole.Instance.Output(string.Format("Max ping limit set to {0}", HighPingKicker.MAXPING));
Config.UpdateConfig();
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_senderInfo.RemoteClientInfo != null)
{
RunInternal(_senderInfo.RemoteClientInfo, _params);
}
else
{
RunInternal(null, _params);
}
} catch (Exception e) {
Log.Out("Error in SayToPlayer.Run: " + e);
}
}
/// <summary>
/// Sends the given message asynchronously and immediately to the sender of the command.
/// Note: SdtdConsole.Instance.Out does NOT work asynchronously!
/// </summary>
/// <param name="target"></param>
/// <param name="senderInfo">Either NetworkConnection (telnet) or RemoteClientInfo (game client) must be set.</param>
/// <param name="msg">Message to send; newline is added automatically</param>
public static void OutputAsync(this SdtdConsole target, CommandSenderInfo senderInfo, string msg)
{
if (senderInfo.NetworkConnection != null) // telnet
{
senderInfo.NetworkConnection.SendLine(msg);
}
else if (senderInfo.RemoteClientInfo != null) // 7dtd client
{
senderInfo.RemoteClientInfo.SendPackage(new NetPackageConsoleCmdClient(msg, false));
}
else
{
Log.Warning("Could not find a way to send output to console asynchronously: " + msg);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output("Wrong number of arguments.");
return;
}
if (!int.TryParse(_params[0], out PingChecker.MAXPING))
{
SdtdConsole.Instance.Output("Maxping is not an integer.");
return;
}
SdtdConsole.Instance.Output("Max ping limit set to " + PingChecker.MAXPING);
PingChecker.UpdateXml();
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try {
int num;
if (_params.Count != 1)
{
SdtdConsole.Instance.Output(string.Concat("Wrong number of arguments, expected 1, found ", _params.Count, "."));
SdtdConsole.Instance.Output("Utilisation: heal <nomdujouer|gameid>");
return;
}
Entity item = null;
ClientInfo clientInfoForNameOrId = ConsoleHelper.ParseParamIdOrName(_params [0]);
if (clientInfoForNameOrId != null)
{
item = GameManager.Instance.World.Players.dict[clientInfoForNameOrId.entityId];
}
else if (int.TryParse(_params[0], out num) && GameManager.Instance.World.Entities.dict.ContainsKey(num))
{
item = GameManager.Instance.World.Entities.dict[num];
}
if (item == null)
{
SdtdConsole.Instance.Output("Pseudo ou GameId introuvable.");
return;
}
item.DamageEntity(new DamageSource(EnumDamageSourceType.Bullet), -9999, false);
/*try {
* CommonMappingFunctions.GetGameManager().GetRPCNetworkView().RPC("RPC_ChatMessage", ci.networkPlayer,
* new object[]
* {
* "ZBot vient de vous soigner.",
* -1,
* string.Empty,
* false
* });
*
* SdtdConsole.Instance.Output ("Message prive a destination du joueur " + (receiverName != null ? "\"" + receiverName + "\"" : "unknownName"));
* } catch (Exception e) {
* Log.Out("Error in Heal1.Run: " + e);
* }*/
SdtdConsole.Instance.Output("Joueur soigne " + _params[0]);
} catch (Exception e) {
Log.Out("Error in Heal2.Run: " + e);
}
}
public override void Execute(List <string> parameters, CommandSenderInfo senderInfo)
{
TelemetryTools.CollectEvent("command", "execute", GetCommands()[0]);
try
{
var modInfo = Api.GetExecutingMod()?.ModInfo;
if (modInfo == null)
{
SdtdConsole.Instance.Output(Constants.ModName);
SdtdConsole.Instance.Output("Could not load mod infos.");
}
else
{
// ReSharper disable once UnreachableCode
SdtdConsole.Instance.Output(modInfo.Name.Value + " - Version " + modInfo.Version.Value + (Log.IsDebug ? " DEBUG" : ""));
if (modInfo.Name.Value != Constants.ModName)
{
SdtdConsole.Instance.Output("Original mod name: " + Constants.ModName);
}
SdtdConsole.Instance.Output(modInfo.Description.Value);
if (!string.IsNullOrEmpty(modInfo.Website.Value))
{
SdtdConsole.Instance.Output("Website: " + modInfo.Website.Value);
}
}
SdtdConsole.Instance.Output("");
SdtdConsole.Instance.Output("Operating System: " + Environment.OSVersion);
SdtdConsole.Instance.Output("Unity version: " + Application.unityVersion);
var displayName = Type.GetType("Mono.Runtime")?.GetMethod("GetDisplayName", BindingFlags.NonPublic | BindingFlags.Static);
if (displayName != null)
{
SdtdConsole.Instance.Output("Mono display name: " + displayName.Invoke(null, null));
}
var monoRuntimeVersion = Type.GetType("Mono.Runtime")?.Assembly.ImageRuntimeVersion;
if (monoRuntimeVersion != null)
{
SdtdConsole.Instance.Output("Mono runtime version: " + monoRuntimeVersion);
}
}
catch (Exception ex)
{
CommandTools.HandleCommandException(ex);
}
}
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].Length < 1 || _params.Count > 17)
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not ban Id: Invalid Id {0}", _params[0]));
return;
}
int _time;
if (!int.TryParse(_params[1], out _time))
{
_time = 15;
}
ClientInfo _cInfo = ConsoleHelper.ParseParamIdOrName(_params[0]);
if (_cInfo != null)
{
if (GameManager.Instance.adminTools.GetUserPermissionLevel(_cInfo) > Admin_Level)
{
if (_time > 60)
{
SdtdConsole.Instance.ExecuteSync(string.Format("ban add {0} {1} minutes \"You have been temporarily banned for {2} minutes\"", _cInfo.playerId, _time, _time), _cInfo);
}
else
{
SdtdConsole.Instance.ExecuteSync(string.Format("ban add {0} {1} minutes \"You have been temporarily banned for {2} minutes\"", _cInfo.playerId, _params[1], _params[1]), _cInfo);
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Can not ban Id: {0}. The Id belongs to an Admin", _params[1]));
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player with Id {0} does not exist", _cInfo.entityId));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in TempBanConsole.Run: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try {
AdminTools admTools = GameManager.Instance.adminTools;
bool onlineOnly = false;
bool notBannedOnly = false;
string nameFilter = string.Empty;
if (_params.Count == 1)
{
if (_params [0].ToLower().Equals("-online"))
{
onlineOnly = true;
}
else if (_params [0].ToLower().Equals("-notbanned"))
{
notBannedOnly = true;
}
else
{
nameFilter = _params [0].ToLower();
}
}
int num = 0;
foreach (string sid in PersistentContainer.Instance.Players.SteamIDs)
{
Player p = PersistentContainer.Instance.Players [sid, false];
if (
(!onlineOnly || p.IsOnline) &&
(!notBannedOnly || !admTools.IsBanned(sid)) &&
(nameFilter.Length == 0 || p.Name.ToLower().Contains(nameFilter))
)
{
SdtdConsole.Instance.Output(String.Format("{0}. {1}, id={2}, steamid={3}, online={4}, ip={5}, playtime={6} m, seen={7}",
++num, p.Name, p.EntityID, sid, p.IsOnline, p.IP,
p.TotalPlayTime / 60,
p.LastOnline.ToString("yyyy-MM-dd HH:mm"))
);
}
}
SdtdConsole.Instance.Output("Total of " + PersistentContainer.Instance.Players.Count + " known");
} catch (Exception e) {
Log.Out("Error in ListKnownPlayers.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count != 6) {
SdtdConsole.Instance.Output ("Usage: removeblock <target entityid|playername|steamid> <targetBlockId> <newBlockId> <sizex> <sizez> <sizey>");
SdtdConsole.Instance.Output ("Usage: removeblock ketchu13 295 200");
return;
}
if (_params.Count == 6 ){
RemoveBlock (_params);
}
} catch (Exception ex) {
Log.Out("RemoveBlocks error: " + ex.Message);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count != 1)
{
SdtdConsole.Instance.Output("Usage: ListBlocks <playername> or lb <playername>");
return;
}
if (_params.Count == 1)
{
RemoveBlock(_params);
}
} catch (Exception ex) {
Log.Out("RemoveBlocks error: " + ex.Message);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (GameManager.Instance.World == null)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] The world is not loaded. Unable to run command");
return;
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in TestConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo senderInfo)
{
SenderInfo = senderInfo;
Params = new List <string>();
Options = new Dictionary <string, string>();
ParseParams(_params);
try
{
Process();
}
catch (Exception e)
{
SendOutput("Error while executing command.");
Log.Out($"{Config.ModPrefix} Error in {GetType().Name}.{MethodBase.GetCurrentMethod().Name}: {e}");
}
}
public override void Execute(List <string> _p, CommandSenderInfo _s)
{
_senderInfo = _s;
_params = new List <string>();
_options = new Dictionary <string, string>();
ParseParams(_p);
try
{
Process();
}
catch (Exception e)
{
SdtdConsole.Instance.Output("Error while executing command.");
Log.Out(Config.ModPrefix + " Error in " + GetType().Name + "." + MethodBase.GetCurrentMethod().Name + ": " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 2)
{
SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1 or 2, found {0}", _params.Count));
return;
}
if (_params[0] == "cancel")
{
if (!isCountingDown)
{
SdtdConsole.Instance.Output("Stopserver is not running.");
}
else
{
th.Abort();
isCountingDown = false;
SdtdConsole.Instance.Output("Stopserver has stopped.");
}
}
else
{
if (isCountingDown)
{
SdtdConsole.Instance.Output(string.Format("Server is already stopping in {0} mins", _mins));
}
else
{
if (!int.TryParse(_params[0], out _mins))
{
SdtdConsole.Instance.Output(string.Format("Invalid time specified: {0}", _mins));
}
else
{
Start();
}
}
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in StopServer.Run: {0}.", e));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_senderInfo.RemoteClientInfo == null)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output("[SERVERTOOLS] Invalid operation. This command must be used manually by an administrator in game");
return;
}
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found '{0}'", _params.Count));
return;
}
if (!int.TryParse(_params[0], out int _entityId))
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid entityId value '{0}'", _entityId));
return;
}
Entity Entity = GameManager.Instance.World.Entities.dict[_entityId];
if (Entity == null)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Invalid entityId. Entity not found '{0}'", _entityId));
return;
}
if (Entity is EntityPlayer)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Entity with id '{0}' can not be a player", _entityId));
return;
}
EntityPlayer _player = PersistentOperations.GetEntityPlayer(_senderInfo.RemoteClientInfo.entityId);
if (_player != null)
{
Entity.SetRotation(new UnityEngine.Vector3(_player.position.x, _player.position.y, _player.position.z));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Rotated entity {0} to face away from you", _entityId));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in EntityRotateConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count < 1)
{
SdtdConsole.Instance.Output("Usage: showinventory <steamid|playername|entityid>");
SdtdConsole.Instance.Output(" or: showinventory <steamid|playername|entityid> <1>");
return;
}
string steamid = PersistentContainer.Instance.Players.GetSteamID(_params [0], true);
if (steamid == null)
{
SdtdConsole.Instance.Output("Playername or entity/steamid id not found or no inventory saved (first saved after a player has been online for 30s).");
return;
}
Player p = PersistentContainer.Instance.Players [steamid, false];
PersistentData.Inventory inv = p.Inventory;
if (_params.Count == 2)
{
saveInventory(p, inv, steamid);
return;
}
SdtdConsole.Instance.Output("Belt of player " + p.Name + ":");
for (int i = 0; i < inv.belt.Count; i++)
{
if (inv.belt [i] != null)
{
SdtdConsole.Instance.Output(string.Format(" Slot {0}: {1:000} * {2}", i, inv.belt [i].count, inv.belt [i].itemName));
}
}
SdtdConsole.Instance.Output(string.Empty);
SdtdConsole.Instance.Output("Bagpack of player " + p.Name + ":");
for (int i = 0; i < inv.bag.Count; i++)
{
if (inv.bag [i] != null)
{
SdtdConsole.Instance.Output(string.Format(" Slot {0}: {1:000} * {2}", i, inv.bag [i].count, inv.bag [i].itemName));
}
}
SdtdConsole.Instance.Output(string.Empty);
} catch (Exception e) {
Log.Out("Error in ShowInventory.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
//if (_params.Length > 1) {
Process runMapReader = new Process();
string mapReaderPath = "D:\\Inventories\\map_reader1.3.0_64bits.exe";
string mapFilesPath = "D:\\Inventories\\map";
string mapTilesPath = "D:\\Inventories\\tiles";
runMapReader.StartInfo.CreateNoWindow = false;
runMapReader.StartInfo.UseShellExecute = false;
runMapReader.StartInfo.FileName = mapReaderPath;
runMapReader.StartInfo.Arguments = "-g \"" + mapFilesPath + "\" -t \"" + mapTilesPath + "\"";
runMapReader.Start(); //}
} catch (Exception ex) {
Log.Out("LoadPrefab error: " + ex.Message);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count != 6)
{
SdtdConsole.Instance.Output("Usage: removeblock <target entityid|playername|steamid> <targetBlockId> <newBlockId> <sizex> <sizez> <sizey>");
SdtdConsole.Instance.Output("Usage: removeblock ketchu13 295 200");
return;
}
if (_params.Count == 6)
{
RemoveBlock(_params);
}
} catch (Exception ex) {
Log.Out("RemoveBlocks error: " + ex.Message);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1 || _params.Count > 2)
{
SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1 or 2, found {0}", _params.Count));
return;
}
if (_params[0] == "cancel")
{
if (!isCountingDown)
{
SdtdConsole.Instance.Output("Stopserver is not running.");
}
else
{
th.Abort();
isCountingDown = false;
SdtdConsole.Instance.Output("Stopserver has stopped.");
}
}
else
{
if (isCountingDown)
{
SdtdConsole.Instance.Output(string.Format("Server is already stopping in {0} mins", _mins));
}
else
{
if (!int.TryParse(_params[0], out _mins))
{
SdtdConsole.Instance.Output(string.Format("Invalid time specified: {0}", _mins));
}
else
{
Start();
}
}
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in StopServer.Run: {0}.", e));
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found '{0}'", _params.Count));
return;
}
if (!string.IsNullOrEmpty(_senderInfo.RemoteClientInfo.CrossplatformId.CombinedString))
{
LinkedList <Chunk> chunkArray = new LinkedList <Chunk>();
DictionaryList <Vector3i, TileEntity> tiles = new DictionaryList <Vector3i, TileEntity>();
ChunkClusterList chunklist = GameManager.Instance.World.ChunkClusters;
for (int i = 0; i < chunklist.Count; i++)
{
ChunkCluster chunk = chunklist[i];
chunkArray = chunk.GetChunkArray();
foreach (Chunk _c in chunkArray)
{
tiles = _c.GetTileEntities();
foreach (TileEntity tile in tiles.dict.Values)
{
TileEntityType type = tile.GetTileEntityType();
if (type.ToString().Equals("SecureLoot"))
{
TileEntitySecureLootContainer SecureLoot = (TileEntitySecureLootContainer)tile;
if (!SecureLoot.IsUserAllowed(_senderInfo.RemoteClientInfo.CrossplatformId))
{
List <PlatformUserIdentifierAbs> _users = SecureLoot.GetUsers();
_users.Add(_senderInfo.RemoteClientInfo.CrossplatformId);
SecureLoot.SetModified();
}
}
}
}
}
}
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Secure loot access set for '{0}' in all loaded areas. Unloaded areas have not changed", _senderInfo.RemoteClientInfo.CrossplatformId.CombinedString));
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in SecureLootAccessConsole.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.Count == 1)
{
ClientInfo _cInfo = _senderInfo.RemoteClientInfo;
ClientInfo _cInfo2 = ConsoleHelper.ParseParamIdOrName(_params[0]);
if (_cInfo2 != null)
{
EntityPlayer _player2 = GameManager.Instance.World.Players.dict[_cInfo2.entityId];
if ((int)_player2.position.y < 13)
{
_cInfo.SendPackage(NetPackageManager.GetPackage <NetPackageTeleportPlayer>().Setup(new Vector3((int)_player2.position.x, 0, (int)_player2.position.z), null, false));
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Teleport successful"));
return;
}
else
{
_cInfo.SendPackage(NetPackageManager.GetPackage <NetPackageTeleportPlayer>().Setup(new Vector3((int)_player2.position.x, (int)_player2.position.y - 10, (int)_player2.position.z), null, false));
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Teleport successful"));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Player id {0} not found", _params[0]));
return;
}
}
else
{
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Invalid argument {0}", _params[0]));
return;
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in TeleportUnderPlayerConsole.Run: {0}", e.Message));
}
}
private void DoExec(List <string> _params, CommandSenderInfo _senderInfo)
{
int maxCount = 2;
if (int.TryParse(_params[0], out maxCount))
{
if (maxCount <= 15)
{
ClearPlayerTeams();
SetupTeams(maxCount);
}
else
{
SdtdConsole.Instance.Output("15 Teams Max");
}
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try {
//if (_params.Length > 1) {
Process runMapReader = new Process();
string mapReaderPath = "D:\\Inventories\\map_reader1.3.0_64bits.exe";
string mapFilesPath = "D:\\Inventories\\map";
string mapTilesPath = "D:\\Inventories\\tiles";
runMapReader.StartInfo.CreateNoWindow = false;
runMapReader.StartInfo.UseShellExecute = false;
runMapReader.StartInfo.FileName = mapReaderPath;
runMapReader.StartInfo.Arguments = "-g \"" + mapFilesPath + "\" -t \"" + mapTilesPath + "\"";
runMapReader.Start(); //}
} catch (Exception ex) {
Log.Out("LoadPrefab error: " + ex.Message);
}
}
/// <inheritdoc/>
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
if (_params.Count < 1)
{
SdtdConsole.Instance.Output("SevenMod Plugins Menu:");
SdtdConsole.Instance.Output(" info - Information about a plugin");
SdtdConsole.Instance.Output(" list - Show loaded plugins");
SdtdConsole.Instance.Output(" load - Load a plugin");
SdtdConsole.Instance.Output(" refresh - Reloads/refreshes all plugins in the plugins.ini file");
SdtdConsole.Instance.Output(" reload - Reload a plugin");
SdtdConsole.Instance.Output(" unload - Unload a plugin");
SdtdConsole.Instance.Output(" unload_all - Unload all plugins");
return;
}
switch (_params[0])
{
case "info":
this.Info(_params.Count > 1 ? _params[1] : null);
break;
case "list":
this.List();
break;
case "load":
this.Load(_params.Count > 1 ? _params[1] : null);
break;
case "refresh":
this.Refresh();
break;
case "reload":
this.Reload(_params.Count > 1 ? _params[1] : null);
break;
case "unload":
this.Unload(_params.Count > 1 ? _params[1] : null);
break;
case "unload_all":
this.UnloadAll();
break;
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
int _counter = 1;
SdtdConsole.Instance.Output("Minibike List:");
List <Entity> Entities = GameManager.Instance.World.Entities.list;
for (int i = 0; i < Entities.Count; i++)
{
Entity _entity = Entities[i];
string _name = EntityClass.list[_entity.entityClass].entityClassName;
if (_name == "minibike")
{
Vector3 _pos = _entity.position;
int x = (int)_pos.x;
int y = (int)_pos.y;
int z = (int)_pos.z;
Entity _attachedPlayer = _entity.AttachedMainEntity;
if (_attachedPlayer != null)
{
List <ClientInfo> _cInfoList = ConnectionManager.Instance.Clients.List.ToList();
for (int j = 0; j < _cInfoList.Count; j++)
{
ClientInfo _cInfo = _cInfoList[j];
if (_cInfo != null)
{
if (_attachedPlayer.entityId == _cInfo.entityId)
{
SdtdConsole.Instance.Output(string.Format("#{0}: Id {1}, Located at x {2} y {3} z {4}, Player {5} is riding this bike.", _counter, _entity.entityId, x, y, z, _cInfo.playerName));
}
}
}
}
else
{
SdtdConsole.Instance.Output(string.Format("#{0}: Id {1}, Located at x {2} y {3} z {4}.", _counter, _entity.entityId, x, y, z));
}
_counter++;
}
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in BikeListConsole.Run: {0}.", e));
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_params.Count < 1) {
SdtdConsole.Instance.Output ("Usage: showinventory <steamid|playername|entityid>");
return;
}
string steamid = PersistentContainer.Instance.Players.GetSteamID (_params [0], true);
if (steamid == null) {
SdtdConsole.Instance.Output ("Playername or entity/steamid id not found or no inventory saved (first saved after a player has been online for 30s).");
return;
}
Player p = PersistentContainer.Instance.Players [steamid, false];
PersistentData.Inventory inv = p.Inventory;
SdtdConsole.Instance.Output ("Belt of player " + p.Name + ":");
for (int i = 0; i < inv.belt.Count; i++) {
if (inv.belt [i] != null){
if (inv.belt [i].quality < 0) {
SdtdConsole.Instance.Output (string.Format (" Slot {0}: {1:000} * {2}", i, inv.belt [i].count, inv.belt [i].itemName));
}else
{
SdtdConsole.Instance.Output (string.Format (" Slot {0}: {1:000} * {2}", i, inv.belt [i].count, inv.belt [i].itemName, inv.belt[i].quality));
}
}
}
SdtdConsole.Instance.Output (string.Empty);
SdtdConsole.Instance.Output ("Bagpack of player " + p.Name + ":");
for (int i = 0; i < inv.bag.Count; i++) {
if (inv.bag [i] != null){
if (inv.bag [i].quality < 0) {
SdtdConsole.Instance.Output (string.Format (" Slot {0}: {1:000} * {2}", i, inv.bag [i].count, inv.bag [i].itemName));
}else
{
SdtdConsole.Instance.Output (string.Format (" Slot {0}: {1:000} * {2} -- {3}", i, inv.bag [i].count, inv.bag [i].itemName, inv.bag[i].quality));
}
}
}
SdtdConsole.Instance.Output (string.Empty);
} catch (Exception e) {
Log.Out ("Error in ShowInventory.Run: " + e);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Wrong number of arguments, expected 1, found '{0}'", _params.Count));
return;
}
ClientInfo cInfo = PersistentOperations.GetClientInfoFromNameOrId(_params[0]);
if (cInfo != null)
{
Phrases.Dict.TryGetValue("ResetPlayer1", out string phrase);
SingletonMonoBehaviour <SdtdConsole> .Instance.ExecuteSync(string.Format("kick {0} \"{1}\"", cInfo.CrossplatformId.CombinedString, phrase), null);
GameManager.Instance.World.aiDirector.RemoveEntity(PersistentOperations.GetEntityPlayer(cInfo.entityId));
GC.Collect();
MemoryPools.Cleanup();
ResetProfileExec(cInfo.CrossplatformId.CombinedString);
}
else if (_params[0].Contains("_"))
{
PersistentPlayerData ppd = PersistentOperations.GetPersistentPlayerDataFromId(_params[0]);
if (ppd != null)
{
GC.Collect();
MemoryPools.Cleanup();
ResetProfileExec(ppd.UserIdentifier.ReadablePlatformUserIdentifier);
}
else
{
Log.Out(string.Format("[SERVERTOOLS] Unable to find player data for id '{0}'", _params[0]));
}
}
else
{
Log.Out(string.Format("[SERVERTOOLS] Unable to find player data for id '{0}'", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ResetPlayerConsole.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 (!string.IsNullOrEmpty(_senderInfo.RemoteClientInfo.playerId))
{
LinkedList <Chunk> chunkArray = new LinkedList <Chunk>();
DictionaryList <Vector3i, TileEntity> tiles = new DictionaryList <Vector3i, TileEntity>();
ChunkClusterList chunklist = GameManager.Instance.World.ChunkClusters;
for (int i = 0; i < chunklist.Count; i++)
{
ChunkCluster chunk = chunklist[i];
chunkArray = chunk.GetChunkArray();
foreach (Chunk _c in chunkArray)
{
tiles = _c.GetTileEntities();
foreach (TileEntity tile in tiles.dict.Values)
{
TileEntityType type = tile.GetTileEntityType();
if (type.ToString().Equals("SecureDoor"))
{
TileEntitySecureDoor SecureDoor = (TileEntitySecureDoor)tile;
if (!SecureDoor.IsUserAllowed(_senderInfo.RemoteClientInfo.playerId))
{
List <string> _users = SecureDoor.GetUsers();
_users.Add(_senderInfo.RemoteClientInfo.playerId);
SecureDoor.SetModified();
}
}
}
}
}
}
SdtdConsole.Instance.Output(string.Format("[SERVERTOOLS] Door access set for {0}", _senderInfo.RemoteClientInfo.playerId));
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in SecureDoorAccess.Execute: {0}", e.Message));
}
}
public override void Execute(List <string> parameters, CommandSenderInfo senderInfo)
{
TelemetryTools.CollectEvent("command", "execute", GetCommands()[0]);
try
{
if (parameters.Count == 0)
{
ListStatus();
return;
}
bool isModeOn = parameters.Remove("/on");
bool isModeOff = parameters.Remove("/off");
if (parameters.Count == 0)
{
throw new FriendlyMessageException("No event names given. See help.");
}
if (isModeOn && isModeOff)
{
throw new FriendlyMessageException("Parameters /on and /off cannot be used simultaneously.");
}
if (!isModeOn && !isModeOff)
{
throw new FriendlyMessageException("Neither parameter /on nor /off was specified. See help.");
}
if (parameters.Contains("all"))
{
if (parameters.Count > 1)
{
throw new FriendlyMessageException("When using the \"all\" keyword as event name you can't use other event names additionally.");
}
UpdateAllEvents(isModeOn);
}
else
{
UpdateLogEvents(parameters, isModeOn);
}
}
catch (Exception ex)
{
CommandTools.HandleCommandException(ex);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
Printer.Print("ConsoleCmdZBTest");
// GameManager.Instance.StartCoroutine(TestRouts());
// testGetBiome(_params);
//GetZBiome(_params);
// ShowBlockMap(_params);
//ShowInventory(_params);
// ShowSurface(_params);
//ShowInitialLocalScale(_params);
// ShowSpeed(_params);
// TestDamage(_params);
// TestCoordAlign(_params);
// TestEveryS(_params);
//TestWriter(_params);
Zombiome.Routines.Start(TestMB(_params));
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
if (_params.Count < 1) {
SdtdConsole.Instance.Output ("Utilisation: annonce <Message>");
return;
}
try {
string text = string.Empty;
for (int i = 0; i < _params.Count; i++) {
text = text + " " + _params[i];
}
//ConnectionManager.Instance.SendPackage (new NetPackage_GameInfoMessage (text, string.Empty ), new pac);
GameManager.Instance.GameMessageServer(null,text, string.Empty);
} catch (Exception e) {
Log.Out ("Error in SayToPlayer.Run: " + e);
SdtdConsole.Instance.Output ("Error in SayToPlayer.Run: " + e);
}
}
public override void Execute(List <string> _params, CommandSenderInfo _senderInfo)
{
try
{
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[0]);
if (cInfo != null)
{
EntityPlayer player = PersistentOperations.GetEntityPlayer(cInfo.entityId);
if (player != null)
{
if (GameEventManager.GameEventSequences.ContainsKey(_params[1]))
{
GameEventManager.Current.HandleAction(_params[1], null, player, false, "");
cInfo.SendPackage(NetPackageManager.GetPackage <NetPackageGameEventResponse>().Setup(_params[1], cInfo.playerName, "", "", NetPackageGameEventResponse.ResponseTypes.Approved));
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Ran game event named '{0}' on player '{1}'", _params[1], cInfo.CrossplatformId.CombinedString));
return;
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to locate '{0}' in the game events list", _params[1]));
return;
}
}
}
else
{
SingletonMonoBehaviour <SdtdConsole> .Instance.Output(string.Format("[SERVERTOOLS] Unable to locate player '{0}' online", _params[0]));
return;
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in RunGameEventConsole.Execute: {0}", e.Message));
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
if (_params.Count < 1) {
SdtdConsole.Instance.Output ("Utilisation: zbotsay <Message>");
return;
}
try {
string text = string.Empty;
for (int i = 0; i < _params.Count; i++)
{
text = text + " " + _params[i];
}
//Chat.SendMessage (null, "ZBot", text);
GameManager.Instance.GameMessageServer(null, text, "ZBot");
} catch (Exception e) {
Log.Out ("Error in ZBotSay.Run: " + e);
SdtdConsole.Instance.Output ("Error in ZBotSay.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
if (_params.Count < 2) {
SdtdConsole.Instance.Output ("Utilisation: say+ <Pseudo> <Message>");
return;
}
try {
string text = string.Empty;
for (int i = 1; i < _params.Count; i++)
{
text = text + " " + _params[i];
}
GameManager.Instance.GameMessageServer(null,text, _params[0]);
} catch (Exception e) {
Log.Out ("Error in sayk.Run: " + e);
SdtdConsole.Instance.Output("Error in sayk.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
AdminTools admTools = GameManager.Instance.adminTools;
bool onlineOnly = false;
bool notBannedOnly = false;
string nameFilter = string.Empty;
if (_params.Count == 1) {
if (_params [0].ToLower ().Equals ("-online")) {
onlineOnly = true;
} else if (_params [0].ToLower ().Equals ("-notbanned")) {
notBannedOnly = true;
} else {
nameFilter = _params [0].ToLower ();
}
}
int num = 0;
foreach (string sid in PersistentContainer.Instance.Players.SteamIDs) {
Player p = PersistentContainer.Instance.Players [sid, false];
if (
(!onlineOnly || p.IsOnline)
&& (!notBannedOnly || !admTools.IsBanned (sid))
&& (nameFilter.Length == 0 || p.Name.ToLower ().Contains (nameFilter))
) {
SdtdConsole.Instance.Output (String.Format ("{0}. {1}, id={2}, steamid={3}, online={4}, ip={5}, playtime={6} m, seen={7}",
++num, p.Name, p.EntityID, sid, p.IsOnline, p.IP,
p.TotalPlayTime / 60,
p.LastOnline.ToString ("yyyy-MM-dd HH:mm"))
);
}
}
SdtdConsole.Instance.Output ("Total of " + PersistentContainer.Instance.Players.Count + " known");
} catch (Exception e) {
Log.Out ("Error in ListKnownPlayers.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count != 1)
{
SdtdConsole.Instance.Output("Wrong number of arguments.");
return;
}
if (!int.TryParse(_params[0], out HighPingKicker.MAXPING))
{
SdtdConsole.Instance.Output("Maxping is not an integer.");
return;
}
SdtdConsole.Instance.Output(string.Format("Max ping limit set to {0}", HighPingKicker.MAXPING));
Config.UpdateXml();
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in ReservedSlot.Run: {0}.", e));
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
if (_senderInfo.RemoteClientInfo != null) {
if (_params.Count >= 1 && _params [0].ToLower ().Equals ("nearby")) {
_params.Add (_senderInfo.RemoteClientInfo.playerId);
}
}
World w = GameManager.Instance.World;
PersistentPlayerList ppl = GameManager.Instance.GetPersistentPlayerList ();
bool summaryOnly = false;
string steamIdFilter = string.Empty;
Vector3i closeTo = default(Vector3i);
bool onlyCloseToPlayer = false;
int closeToDistance = 32;
if (_params.Count == 1) {
long tempLong;
if (_params [0].ToLower ().Equals ("summary")) {
summaryOnly = true;
} else if (_params [0].Length == 17 && long.TryParse (_params [0], out tempLong)) {
steamIdFilter = _params [0];
} else {
ClientInfo ci = ConsoleHelper.ParseParamIdOrName (_params [0]);
if (ci != null) {
steamIdFilter = ci.playerId;
} else {
SdtdConsole.Instance.Output ("Player name or entity id \"" + _params [0] + "\" not found.");
return;
}
}
} else if (_params.Count >= 2) {
if (_params [0].ToLower ().Equals ("nearby")) {
try {
if (_params.Count == 3) {
if (!int.TryParse (_params[1], out closeToDistance)) {
SdtdConsole.Instance.Output ("Given radius is not an integer!");
}
}
ClientInfo ci = ConsoleHelper.ParseParamSteamIdOnline (_params [_params.Count - 1]);
EntityPlayer ep = w.Players.dict [ci.entityId];
closeTo = new Vector3i (ep.GetPosition ());
onlyCloseToPlayer = true;
} catch (Exception e) {
SdtdConsole.Instance.Output ("Error getting current player's position");
Log.Out ("Error in ListLandProtection.Run: " + e);
}
} else {
SdtdConsole.Instance.Output ("Illegal parameter list");
return;
}
}
Boolean Bol = false;
Dictionary<Vector3i, PersistentPlayerData> d = ppl.m_lpBlockMap;
if (d != null) {
Dictionary<PersistentPlayerData, List<Vector3i>> owners = new Dictionary<PersistentPlayerData, List<Vector3i>> ();
foreach (KeyValuePair<Vector3i, PersistentPlayerData> kvp in d) {
if (!onlyCloseToPlayer || (Math.Abs (kvp.Key.x - closeTo.x) <= closeToDistance && Math.Abs (kvp.Key.z - closeTo.z) <= closeToDistance)) {
if (!owners.ContainsKey (kvp.Value)) {
owners.Add (kvp.Value, new List<Vector3i> ());
}
owners [kvp.Value].Add (kvp.Key);
}
}
foreach (KeyValuePair<PersistentPlayerData, List<Vector3i>> kvp in owners) {
if (steamIdFilter.Length == 0 || kvp.Key.PlayerId.Equals (steamIdFilter)) {
PersistentData.Player p = PersistentData.PersistentContainer.Instance.Players [kvp.Key.PlayerId, false];
string name = string.Empty;
if (p != null) {
name = p.Name;
}
name += " (" + kvp.Key.PlayerId + ")";
Bol = true;
SdtdConsole.Instance.Output (String.Format (
"Player \"{0}\" owns {3} keystones (protected: {1}, current hardness multiplier: {2})",
name,
w.IsLandProtectionValidForPlayer (kvp.Key),
w.GetLandProtectionHardnessModifierForPlayer (kvp.Key),
kvp.Value.Count)
);
if (!summaryOnly) {
foreach (Vector3i v in kvp.Value) {
SdtdConsole.Instance.Output (" (" + v.ToString () + ")");
}
}
}
}
}
if (Bol == false)
SdtdConsole.Instance.Output ("Player not found...");
if (steamIdFilter.Length == 0)
SdtdConsole.Instance.Output ("Total of " + d.Count + " keystones in the game");
} catch (Exception e) {
Log.Out ("Error in ListLandProtection.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 4) {
SdtdConsole.Instance.Output("Usage: spawnentityk <EntityId> <x> <y> <z>");
SdtdConsole.Instance.Output(" or: spawnentityk <EntityId> <nbr> <x> <y> <z>");
return;
}
if (_params.Count >= 4) {
int num = 1;
int num2 = -1;
int nbr = 1;
int x = int.MinValue;
int y = int.MinValue;
int z = int.MinValue;
int.TryParse(_params[0], out num2);
int.TryParse (_params [1], out x);
int.TryParse (_params [2], out y);
int.TryParse (_params [3], out z);
if (_params.Count == 5){
int.TryParse(_params[1], out nbr);
int.TryParse (_params [2], out x);
int.TryParse (_params [3], out y);
int.TryParse (_params [4], out z);
if (nbr >= 80) {
SdtdConsole.Instance.Output("More than 80 entities ?! 80 is too much...");
}
}
Vector3 transformPos = new Vector3(x, y, z);
foreach (int current3 in EntityClass.list.Keys)
{
if (EntityClass.list[current3].bAllowUserInstantiate)
{
if (num == num2 || EntityClass.list[current3].entityClassName.Equals(_params[0])) {
for(int k = 1; k <= nbr; k++){
Entity entity = EntityFactory.CreateEntity(current3, transformPos);
GameManager.Instance.World.SpawnEntityInWorld(entity);
}
SdtdConsole.Instance.Output("Spawned " + nbr + " entity " + EntityClass.list[current3].entityClassName);
return;
}
else {
num++;
}
}
}
SdtdConsole.Instance.Output("Entity '" + _params[0] + "' not found");
}
} catch (Exception e) {
Log.Out ("Error in SpawnEntityK.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try {
World w = GameManager.Instance.World;
int num = 0;
foreach (KeyValuePair<int, EntityPlayer> current in w.Players.dict) {
ClientInfo clientInfoFromEntityID = ConnectionManager.Instance.GetClientInfoForEntityId(current.Key);
//CommonMappingFunctions.GetClientInfoFromEntityID (current.Key);
string ip = string.Empty;
//int str1 = 0;
int str2 = 0;
string str3 = "unk";
string str4 = "unk";
if (clientInfoFromEntityID != null) {
ip = clientInfoFromEntityID.ip;
//str1 = clientInfoFromEntityID.netConnection.clientId;
str2 = clientInfoFromEntityID.entityId;
str3 = clientInfoFromEntityID.ownerId;
str4 = clientInfoFromEntityID.playerId;
}
PersistentData.Player p = PersistentData.PersistentContainer.Instance.Players ["" + current.Value.entityId, false];
SdtdConsole.Instance.Output(string.Concat (new object[]
{
string.Empty,
++num,
". id=",
current.Value.entityId,
", ",
current.Value.EntityName,
", pos=",
current.Value.GetPosition (),
", Hp=",
current.Value.Health,
", dth=",
current.Value.Died,
", zkill=",
current.Value.KilledZombies,
", pkill=",
current.Value.KilledPlayers,
", scr=",
current.Value.Score,
", Sid=",
str4,
", ip=",
ip,
", ping=",
current.Value.pingToServer,
", level=",
current.Value.GetLevel(),
", playtime=",
p.TotalPlayTime / 60
/*,
" clid=",
str1,
". entid=",
str2,
", ownid",
str3,
", plyid",
str4*/
}));
}
SdtdConsole.Instance.Output("Total of " + w.Players.list.Count + " in the KFP game");
} catch (Exception e) {
Log.Out ("Error in ListPlayersExtended.Run: " + e);
}
}
public override void Execute(List<string> _params, CommandSenderInfo _senderInfo)
{
try
{
if (_params.Count < 1)
{
SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 1 to 3, found {0}", _params.Count));
return;
}
if (_params[0].ToLower().Equals("add"))
{
if (_params.Count != 3)
{
SdtdConsole.Instance.Output(string.Format("Wrong number of arguments, expected 3, found {0}.", _params.Count));
return;
}
if (_params[1].Length != 17)
{
SdtdConsole.Instance.Output(string.Format("Can not add SteamId: Invalid SteamId {0}", _params[1]));
return;
}
if (Watchlist.Dict.ContainsKey(_params[1]))
{
SdtdConsole.Instance.Output(string.Format("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("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("Wrong number of arguments, expected 2, found {0}", _params.Count));
return;
}
if (!Watchlist.Dict.ContainsKey(_params[1]))
{
SdtdConsole.Instance.Output(string.Format("SteamId {0} was not found.", _params[1]));
return;
}
Watchlist.Dict.Remove(_params[1]);
SdtdConsole.Instance.Output(string.Format("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("Wrong number of arguments, expected 1, found {0}.", _params.Count));
return;
}
if (Watchlist.Dict.Count < 1)
{
SdtdConsole.Instance.Output("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("Invalid argument {0}.", _params[0]));
}
}
catch (Exception e)
{
Log.Out(string.Format("[SERVERTOOLS] Error in WatchlistCommand.Run: {0}.", e));
}
}
