private void SpawnNpc(ICommandSender sender, NpcId npcId, [Option("x")] int x, [Option("y")] int y, [Option("amount")] int amount)
{
if ((x <= 0 || y <= 0) && sender is ConsoleCommandSender)
{
sender.SendMessage("You must provide coordinates when spawning mobs via console: spawnmob <npc ID or name> -x <tile x> -y <tile y>");
return;
}
if (npcId == NpcId.None)
{
sender.SendMessage("Invalid NPC.");
return;
}
var playerSender = sender as PlayerCommandSender;
x = x <= 0 ? (int)playerSender.Player.Position.X / 16 : x;
y = y <= 0 ? (int)playerSender.Player.Position.Y / 16 : y;
amount = Math.Max(1, amount);
for (var i = 0; i < amount; ++i)
{
_server.Npcs.Spawn(npcId, new Vector2f(x * 16, y * 16));
}
sender.SendMessage($"You have spawned {amount} '{npcId.ToString().SplitPascalCase()}' NPC(s).");
}
public override void Execute(ICommandSender sender, string[] args)
{
var prefabName = args[0].ToLower();
if (!int.TryParse(args[1], out int amount))
{
sender.SendMessage("Not a number: " + args[1], MessageType.Error);
return;
}
var animalType = animalTypeSet.values.SingleOrDefault(
x => x.Name.Equals(prefabName, System.StringComparison.OrdinalIgnoreCase));
if (animalType == null)
{
sender.SendMessage("Could not find \"" + prefabName + "\"");
sender.SendMessage(GetAvailableAnimals());
return;
}
var prefab = animalType.Baby;
if (worldGridSystem == null)
{
worldGridSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem <WorldGridSystem>();
}
PrefabSpawner.Spawn(prefab, amount, worldGridSystem);
sender.SendMessage("Spawned " + amount + " " + prefab.name + "s");
}
/// <summary>
/// Sends the command usage to the given command sender.
/// </summary>
/// <param name="commandSender">The command sender to send to.</param>
/// <param name="ipBan">Whether the command was for an IP ban.</param>
/// <param name="unban">Whether the command was for an unban.</param>
/// <param name="addArgument">Whether the 'add' argument was supplied.</param>
private void SendUsage(ICommandSender commandSender, bool ipBan, bool unban, bool addArgument = false)
{
if (ipBan)
{
if (unban)
{
commandSender.SendMessage($"{Aliases[2]} <ip address>");
}
else
{
commandSender.SendMessage($"{Aliases[1]} {(addArgument ? "add" : "")} <auth key|username|ip address>");
}
}
else
{
if (unban)
{
commandSender.SendMessage($"{Aliases[0]} <auth key>");
}
else
{
commandSender.SendMessage($"{Trigger} {(addArgument ? "add" : "")} <auth key|username>");
}
}
}
public override void Execute(ICommandSender sender, string[] args)
{
if (!float.TryParse(args[0], out var value))
{
sender.SendMessage("Not a number: " + args[0], MessageType.Error);
return;
}
Time.timeScale = value;
sender.SendMessage("Timescale set to " + Time.timeScale);
}
public override void Perform(CommandContext context)
{
ICommandSender sender = context.Sender;
sender.SendMessage(ChatColor.LIGHT_GREEN + "Saving data async...");
// Throws error because of #GetCitizenPlayer() being called and no network id being available
Task task = LegacyPlayers.Instance.ForceSaveAsync();
task.ContinueWith(t => sender.SendMessage(ChatColor.LIGHT_GREEN + "Done saving."));
}
/// <inheritdoc />
public void Execute(ICommandSender commandSender, string[] arguments)
{
if (commandSender.Type == CommandSenderType.Console)
{
_serverManager.Stop();
commandSender.SendMessage("Exiting server...");
Environment.Exit(5);
return;
}
commandSender.SendMessage("This command can only be execute as the console");
}
public override void Perform(CommandContext context)
{
// Shift player
LegacyPlayer target = context.ShiftPlayer();
// Notify sender of information
ICommandSender sender = context.Sender;
sender.SendMessage(ChatColor.LIGHT_RED + "Checking: " + ChatColor.LIGHT_GREEN + target.GetName() + ChatColor.LIGHT_RED + ", their identifiers are:");
sender.SendMessage(ChatColor.LIGHT_RED + "- network: " + ChatColor.LIGHT_GREEN + Convert.ToString(target.NetworkId));
sender.SendMessage(ChatColor.LIGHT_RED + "- steam: " + ChatColor.LIGHT_GREEN + target.Id);
sender.SendMessage(ChatColor.LIGHT_RED + "and more information:");
sender.SendMessage(ChatColor.LIGHT_RED + "- ping: " + ChatColor.LIGHT_GREEN + target.GetCitizenPlayer().Ping);
}
/// <inheritdoc />
public void Execute(ICommandSender commandSender, string[] args)
{
if (args.Length < 2)
{
SendUsage(commandSender);
return;
}
// Store whether the action is to authorize or whether to de-authorize
var authAction = !args[0].Contains("deauth");
var identifier = args[1];
if (AuthUtil.IsValidAuthKey(identifier))
{
if (authAction)
{
_authorizedList.Add(identifier);
commandSender.SendMessage("Auth key has been authorized");
}
else
{
_authorizedList.Remove(identifier);
commandSender.SendMessage("Auth key has been deauthorized");
}
}
else
{
// Since the given argument was not a valid auth key, we try player names instead
if (!CommandUtil.TryGetPlayerByName(_serverManager.Players, identifier, out var player))
{
commandSender.SendMessage($"Could not find player with name '{identifier}'");
return;
}
var playerData = (ServerPlayerData)player;
if (authAction)
{
_authorizedList.Add(playerData.AuthKey);
commandSender.SendMessage($"Auth key of player '{player.Username}' has been authorized");
}
else
{
_authorizedList.Remove(playerData.AuthKey);
commandSender.SendMessage($"Auth key of player '{player.Username}' has been de-authorized");
}
}
}
public override bool Execute(ICommandSender sender, string commandLabel, string[] args)
{
bool success = false;
if (!owningPlugin.IsEnabled())
{
return(false);
}
if (!TestPermission(sender))
{
return(true);
}
try
{
success = executor.OnCommand(sender, this, commandLabel, args);
}
catch (Exception ex)
{
throw new CommandException("Unhandled exception executing command '" + commandLabel + "' in plugin " + owningPlugin.GetPluginInfo().FullName, ex);
}
if (!success && usageMessage.Length > 0)
{
foreach (string line in usageMessage.Replace("<command>", commandLabel).Split('\n'))
{
sender.SendMessage(line);
}
}
return(success);
}
/// <summary>
/// Executes command with context
/// </summary>
/// <param name="context">Context of command</param>
/// <returns>Success state</returns>
public bool Execute(CommandContext context)
{
// Sender of command
ICommandSender sender = context.Sender;
if (!sender.IsPermised(info.PermissionLevel))
{
sender.SendMessage(ColorScheme.ERROR, "Error", "You do not have permission to do that");
return(true);
}
// Make sure required arguments are provided
bool correctUsage = context.HasArgs(info.RequiredArgs);
if (correctUsage)
{
// Now perform
try
{
Perform(context);
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
return(false);
}
}
else
{
this.SendUsageMessage(sender);
}
return(true);
}
/// <summary>
/// Try to process a command given the sender and the message.
/// </summary>
/// <param name="commandSender">The sender of the command.</param>
/// <param name="message">A user-input string message.</param>
/// <returns>True if the message was processed as a command, false otherwise.</returns>
public bool ProcessCommand(ICommandSender commandSender, string message)
{
var arguments = GetArguments(message);
if (arguments.Length == 0)
{
return(false);
}
var commandString = arguments[0];
if (Commands.TryGetValue(commandString, out var command))
{
if (command.AuthorizedOnly && !commandSender.IsAuthorized)
{
commandSender.SendMessage("You are not authorized to execute this command");
return(true);
}
command.Execute(commandSender, arguments);
return(true);
}
return(false);
}
public override void Execute(ICommandSender sender, string[] args)
{
if (args.Length == 0 || (args.Length == 1 && args[0] == "list"))
{
StringBuilder sb = new StringBuilder();
sb.Append("Initial populations:");
foreach (var pop in simulationSettings.InitialPopulations)
{
sb.Append("\n ").Append(pop.Prefab.name).Append(": ").Append(pop.Amount);
}
sender.SendMessage(sb.ToString());
return;
}
if (args.Length == 1 && args[0] == "clear")
{
foreach (var pop in simulationSettings.InitialPopulations)
{
pop.Amount = 0;
}
sender.SendMessage("All initial populations set to 0");
return;
}
if (args.Length != 2)
{
return;
}
var prefabName = args[0].ToLower();
var population = simulationSettings.InitialPopulations.SingleOrDefault(x => x.Prefab.name == prefabName);
if (population == null)
{
sender.SendMessage("Could not find \"" + prefabName + "\"");
return;
}
if (!int.TryParse(args[1], out int amount))
{
sender.SendMessage("Not a number: " + args[1], MessageType.Error);
return;
}
population.Amount = amount;
sender.SendMessage("Initial " + population.Prefab.name + " population set to " + amount);
}
/// <inheritdoc />
public void Execute(ICommandSender commandSender, string[] arguments)
{
var players = _serverManager.Players;
var playerNames = string.Join(", ", players.Select(p => p.Username));
commandSender.SendMessage($"Online players ({players.Count}): {playerNames}");
}
public bool TestPermission(ICommandSender target)
{
if (TestPermissionSilent(target))
{
return(true);
}
if (permissionMessage == null)
{
target.SendMessage(ChatColor.RED + "I'm sorry, but you do not have permission to perform this command. Please contact the server administrators if you believe that this is in error.");
}
else if (permissionMessage.Length != 0)
{
foreach (String line in permissionMessage.Replace("<permission>", permission).Split('\n'))
{
target.SendMessage(line);
}
}
return(false);
}
public static ChunkGenerator GetGeneratorForName(string world, string name, ICommandSender output)
{
ChunkGenerator result = null;
if (world == null)
{
throw new ArgumentException("World name must be specified");
}
if (output == null)
{
output = Bukkit.ConsoleSender;
}
if (name != null)
{
string[] split = name.Split(':');
string id = (split.Length > 1) ? split[1] : null;
IPlugin plugin = Bukkit.PluginManager.GetPlugin(split[0]);
if (plugin == null)
{
output.SendMessage("Could not set generator for world '" + world + "': Plugin '" + split[0] + "' does not exist");
}
else if (!plugin.IsEnabled())
{
output.SendMessage("Could not set generator for world '" + world + "': Plugin '" + plugin.GetPluginInfo().FullName + "' is not enabled");
}
else
{
result = plugin.GetDefaultWorldGenerator(world, id);
}
}
return(result);
}
public static void BroadcastCommandMessage(ICommandSender source, String message, bool sendToSource)
{
string result = source.Name + ": " + message;
if (source is IBlockCommandSender && ((IBlockCommandSender)source).GetBlock().GetWorld().GetGameRuleValue("commandBlockOutput").Equals("false", StringComparison.OrdinalIgnoreCase))
{
Bukkit.ConsoleSender.SendMessage(result);
return;
}
HashSet <IPermissible> users = Bukkit.PluginManager.GetPermissionSubscriptions(Bukkit.BROADCAST_CHANNEL_ADMINISTRATIVE);
String colored = ChatColor.GRAY + "" + ChatColor.ITALIC + "[" + result + "]";
if (sendToSource && !(source is IConsoleCommandSender))
{
source.SendMessage(message);
}
foreach (IPermissible user in users)
{
var sender = user as ICommandSender;
if (sender != null)
{
ICommandSender target = sender;
if (target is IConsoleCommandSender)
{
target.SendMessage(result);
}
else if (target != source)
{
target.SendMessage(colored);
}
}
}
}
/// <inheritdoc />
public void Execute(ICommandSender commandSender, string[] args)
{
if (args.Length < 2)
{
commandSender.SendMessage($"Invalid usage: {Trigger} <message>");
return;
}
var message = $"<SERVER>: {string.Join(" ", args).Substring(Trigger.Length + 1)}";
foreach (var playerData in _playerData.GetCopy().Values)
{
_netServer.GetUpdateManagerForClient(playerData.Id).AddChatMessage(message);
}
}
private void Butcher(ICommandSender sender)
{
var npcCount = 0;
var npcService = _server.Npcs;
var playerService = _server.Players;
var npcInfoPacket = new NpcInfo();
foreach (var npc in npcService.Where(n => n != null && n.IsActive && n.Health > 0 && !Terraria.Main.npc[n.Index].friendly && !Terraria.Main.npc[n.Index].townNPC))
{
npc.IsActive = false;
npcInfoPacket.NpcIndex = (short)npc.Index;
playerService.BroadcastPacket(npcInfoPacket);
++npcCount;
}
sender.SendMessage($"Butchered {npcCount} NPC(s).");
}
public override void Execute(ICommandSender sender, string[] args)
{
string m = null;
if (args.Length == 0)
{
m = ResultMessage(ToggleRendering());
}
else if (Array.Exists(ENABLE_WORDS, e => e == args[0]))
{
m = ResultMessage(Rendering(true));
}
else if (Array.Exists(DISABLE_WORDS, e => e == args[0]))
{
m = ResultMessage(Rendering(false));
}
if (m != null)
{
sender.SendMessage(m);
}
}
/// <inheritdoc />
public void Execute(ICommandSender commandSender, string[] args)
{
if (args.Length < 2)
{
commandSender.SendMessage($"Invalid usage: {Trigger} <auth key|username|ip address>");
return;
}
var identifier = args[1];
// Cast each element in the collection of players to ServerPlayerData
var players = _serverManager.Players.Select(p => (ServerPlayerData)p).ToList();
// Check if the identifier argument is an authentication key, which by definition means that it can't
// be a player name or IP address
if (AuthUtil.IsValidAuthKey(identifier))
{
if (!CommandUtil.TryGetPlayerByAuthKey(players, identifier, out var playerWithAuthKey))
{
commandSender.SendMessage("Could not find player with given auth key");
return;
}
commandSender.SendMessage("Player with auth key has been kicked");
KickPlayer(playerWithAuthKey);
return;
}
// Check if a player is connected that has the same IP as the given argument
if (CommandUtil.TryGetPlayerByIpAddress(players, identifier, out var playerWithIp))
{
commandSender.SendMessage($"Player with IP '{identifier}' has been kicked");
KickPlayer(playerWithIp);
return;
}
// Check if a player is connected with the same name as the given argument
if (CommandUtil.TryGetPlayerByName(_serverManager.Players, identifier, out var playerWithName))
{
commandSender.SendMessage($"Player '{playerWithName.Username}' has been kicked");
KickPlayer(playerWithName);
return;
}
commandSender.SendMessage($"Could not find player with name, auth key or IP address '{identifier}'");
}
/// <summary>
/// Executes command with context
/// </summary>
/// <param name="context">Context of command</param>
/// <returns>Success state</returns>
public bool Execute(CommandContext context)
{
// Sender of command
ICommandSender sender = context.Sender;
if (!sender.IsPermised(info.PermissionLevel))
{
sender.SendMessage(ColorScheme.ERROR, "Error", "You do not have permission to do that");
return(true);
}
// Make sure required arguments are provided
if (context.HasArgs(info.RequiredArgs))
{
this.SendUsageMessage(sender);
}
else
{
// Now perform
Perform(context);
}
return(true);
}
public override void Perform(CommandContext context)
{
ICommandSender sender = context.Sender;
int netId;
try
{
netId = context.ShiftInt();
}
catch
{
sender.SendMessage("[network id] must be an Integer.");
return;
}
if (netId == 0)
{
return;
}
// Shift player
MPlayer target = MCoreServer.Instance.GetMPlayerBynetId(netId);
if (target != null)
{
// Notify sender of information
sender.SendMessage(ChatColor.LIGHT_RED + "Checking: " + ChatColor.LIGHT_GREEN + target.Name + ChatColor.LIGHT_RED + ", their identifiers are:");
sender.SendMessage(ChatColor.LIGHT_RED + "- network: " + ChatColor.LIGHT_GREEN + Convert.ToString(target.netId));
sender.SendMessage(ChatColor.LIGHT_RED + "- PlayerId: " + ChatColor.LIGHT_GREEN + target.Id);
sender.SendMessage(ChatColor.LIGHT_RED + "- steamId: " + ChatColor.LIGHT_GREEN + target.MUser.SteamId);
sender.SendMessage(ChatColor.LIGHT_RED + "and more information:");
}
else
{
sender.SendMessage(ChatColor.LIGHT_RED + "Player is not online.");
}
}
/// <inheritdoc />
public void Execute(ICommandSender commandSender, string[] args)
{
if (args.Length < 2)
{
SendUsage(commandSender);
return;
}
var action = args[1].ToLower();
if (action == "on")
{
if (_whiteList.IsEnabled)
{
commandSender.SendMessage("Whitelist was already enabled");
return;
}
_whiteList.IsEnabled = true;
commandSender.SendMessage("Whitelist has been enabled");
}
else if (action == "off")
{
if (!_whiteList.IsEnabled)
{
commandSender.SendMessage("Whitelist was already disabled");
return;
}
_whiteList.IsEnabled = false;
commandSender.SendMessage("Whitelist has been disabled");
}
else if (action == "add" || action == "remove")
{
if (args.Length < 3)
{
commandSender.SendMessage($"Invalid usage: {Trigger} <add|remove> <auth key|username>");
return;
}
// Store whether the action is to add or whether to remove
var addAction = action == "add";
var identifier = args[2];
if (AuthUtil.IsValidAuthKey(identifier))
{
if (addAction)
{
_whiteList.Add(identifier);
commandSender.SendMessage("Auth key has been added to whitelist");
}
else
{
_whiteList.Remove(identifier);
commandSender.SendMessage("Auth key has been removed from whitelist");
}
}
else
{
// Since the given argument was not a valid auth key, we try player names instead
if (!CommandUtil.TryGetPlayerByName(_serverManager.Players, identifier, out var player))
{
if (addAction)
{
_whiteList.AddPreList(identifier);
commandSender.SendMessage(
$"Added player name '{identifier}' to pre-list. The next player that logs in with that name will be whitelisted.");
}
else
{
_whiteList.RemovePreList(identifier);
commandSender.SendMessage(
$"Removed player name '{identifier}' from pre-list. The next player that logs in with that name will no longer be whitelisted.");
}
return;
}
var playerData = (ServerPlayerData)player;
if (addAction)
{
_whiteList.Add(playerData.AuthKey);
commandSender.SendMessage(
$"Auth key of player '{player.Username}' has been added to whitelist");
}
else
{
_whiteList.Remove(playerData.AuthKey);
commandSender.SendMessage(
$"Auth key of player '{player.Username}' has been removed from whitelist");
}
}
}
else if (action == "prelist")
{
commandSender.SendMessage($"Pre-listed player names: {_whiteList.GetPreListed()}");
}
else if (action == "clear")
{
if (args.Length < 3)
{
_whiteList.Clear();
commandSender.SendMessage("Cleared whitelist");
return;
}
if (args[2] == "prelist")
{
_whiteList.ClearPreList();
commandSender.SendMessage("Clear pre-list of whitelist");
}
else
{
commandSender.SendMessage($"Invalid usage: '{Trigger} clear prelist' to clear pre-list");
}
}
else
{
SendUsage(commandSender);
}
}
/// <summary>
/// Send the general command usage to the given command sender.
/// </summary>
/// <param name="commandSender">The command sender to send to.</param>
private void SendUsage(ICommandSender commandSender)
{
commandSender.SendMessage($"Invalid usage: {Trigger} <on|off|add|remove|prelist|clear> [arguments]");
}
// You are not required to override this method, as LegacyCore has a default
// sending message using the usage specified in the constructor
protected override void SendUsageMessage(ICommandSender sender)
{
sender.SendMessage(ColorScheme.ERROR, "Usage!", ChatColor.DARK_RED + "That is not the correct usage? Use: " + this.info.Usage);
}
/// <summary>
/// Sends a usage message to sender
/// </summary>
/// <param name="sender">Sender of command</param>
protected virtual void SendUsageMessage(ICommandSender sender)
{
sender.SendMessage(ColorScheme.ERROR, "Error", "Wrong usage! " + info.Usage);
}
public override void Execute(ICommandSender sender, string[] args)
{
Time.timeScale = Time.timeScale == 0 ? 1 : 0;
sender.SendMessage(Time.timeScale == 0 ? "Paused" : "Unpaused");
}
/// <inheritdoc />
public virtual void Execute(ICommandSender commandSender, string[] args)
{
if (args.Length < 2)
{
commandSender.SendMessage($"Usage: {Trigger} <name> [value]");
return;
}
var settingName = args[1];
var propertyInfos = typeof(Settings.GameSettings).GetProperties();
PropertyInfo settingProperty = null;
foreach (var prop in propertyInfos)
{
if (prop.Name.Equals(settingName))
{
settingProperty = prop;
}
}
if (settingProperty == null || !settingProperty.CanRead)
{
commandSender.SendMessage($"Could not find setting with name: {settingName}");
return;
}
if (args.Length < 3)
{
// The user only supplied the name of the setting, so we print its value
var currentValue = settingProperty.GetValue(GameSettings, null);
commandSender.SendMessage($"Setting '{settingName}' currently has value: {currentValue}");
return;
}
var newValueString = args[2];
if (!settingProperty.CanWrite)
{
commandSender.SendMessage($"Could not change value of setting with name: {settingName} (non-writable)");
return;
}
object newValueObject;
if (settingProperty.PropertyType == typeof(bool))
{
if (!bool.TryParse(newValueString, out var newValueBool))
{
commandSender.SendMessage("Please provide a boolean value (true/false) for this setting");
return;
}
newValueObject = newValueBool;
}
else if (settingProperty.PropertyType == typeof(byte))
{
if (!byte.TryParse(newValueString, out var newValueByte))
{
commandSender.SendMessage("Please provide a byte value (>= 0 and <= 255) for this setting");
return;
}
newValueObject = newValueByte;
}
else
{
commandSender.SendMessage($"Could not change value of setting with name: {settingName} (unhandled type)");
return;
}
settingProperty.SetValue(GameSettings, newValueObject, null);
commandSender.SendMessage($"Changed setting '{settingName}' to: {newValueObject}");
_serverManager.OnUpdateGameSettings();
}
/// <summary>
/// Sends the command usage to the given command sender.
/// </summary>
/// <param name="commandSender">The command sender to send to.</param>
private void SendUsage(ICommandSender commandSender)
{
commandSender.SendMessage($"Invalid usage: <{Trigger}|{Aliases[0]}> <auth key|username>");
}
public override void Execute(ICommandSender sender, string[] args)
{
sender.SendMessage("Reloading scene...");
SceneManager.sceneUnloaded += OnSceneUnloaded;
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
}
