M_Viper/Wireless-Redstone-Reborn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Dateien nach "src/main/java/net/licks92/wirelessredstone/commands" hochladen

Browse Source
This commit is contained in:
M_Viper
2025-08-15 19:21:17 +00:00
parent 8808b0fd8e
commit 2fd40d7f90
12 changed files with 807 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
src/main/java/net/licks92/wirelessredstone/commands/Activate.java Normal file
View File

@@ -0,0 +1,68 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.ConfigManager;
import net.licks92.wirelessredstone.signs.WirelessChannel;
import net.licks92.wirelessredstone.Utils;
import net.licks92.wirelessredstone.WirelessRedstone;
import org.bukkit.command.CommandSender;
@CommandInfo(description = "Activate a channel (for a certain amount of ms)", usage = "<channel> [time] [-s]", aliases = {"activate", "a"},
tabCompletion = {WirelessCommandTabCompletion.CHANNEL},
permission = "activate", canUseInConsole = true, canUseInCommandBlock = true)
public class Activate extends WirelessCommand {
@Override
public void onCommand(CommandSender sender, String[] args) {
if (args.length == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandTooFewArguments, sender, true);
return;
}
WirelessChannel channel = WirelessRedstone.getStorageManager().getChannel(args[0]);
if (channel == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().channelNotFound, sender, true);
return;
}
if (!hasAccessToChannel(sender, args[0])) {
Utils.sendFeedback(WirelessRedstone.getStrings().permissionChannelAccess, sender, true);
return;
}
boolean silence = false;
Integer time = ConfigManager.getConfig().getInteractTransmitterTime();
if (args.length >= 2) {
int timeIndex = 1;
for (String arg : args) {
if (arg.equalsIgnoreCase("-s")) {
silence = true;
timeIndex++;
break;
}
}
try {
time = Integer.parseInt(args[timeIndex]);
} catch (NumberFormatException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandNoNumber, sender, true);
return;
}
}
if (time < 50 && time > 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandActivationMin, sender, true);
return;
}
if (time < 0) {
time = 0;
}
channel.turnOn(time);
if (!silence) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandActivated, sender, false, true);
}
}
}

20
src/main/java/net/licks92/wirelessredstone/commands/CommandInfo.java Normal file
View File

@@ -0,0 +1,20 @@
package net.licks92.wirelessredstone.commands;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface CommandInfo {
String description();
String usage();
String[] aliases();
WirelessCommandTabCompletion[] tabCompletion() default {};
String permission();
boolean canUseInConsole();
boolean canUseInCommandBlock();
}

211
src/main/java/net/licks92/wirelessredstone/commands/CommandManager.java Normal file
View File

@@ -0,0 +1,211 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.signs.SignType;
import net.licks92.wirelessredstone.storage.StorageType;
import net.licks92.wirelessredstone.Utils;
import net.licks92.wirelessredstone.WirelessRedstone;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandException;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.command.TabCompleter;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.Player;
import org.bukkit.util.StringUtil;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import java.util.logging.Level;
import java.util.stream.Collectors;
public class CommandManager implements CommandExecutor, TabCompleter {
private final ArrayList<WirelessCommand> cmds;
public CommandManager() {
cmds = new ArrayList<>();
cmds.add(new Help());
cmds.add(new Version());
cmds.add(new Create());
cmds.add(new Remove());
cmds.add(new Info());
cmds.add(new Activate());
cmds.add(new Teleport());
cmds.add(new Lock());
}
@Override
public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
if (cmd.getName().equalsIgnoreCase("wr") || cmd.getName().equalsIgnoreCase("wredstone")
|| cmd.getName().equalsIgnoreCase("wifi") || cmd.getName().equalsIgnoreCase("wirelessredstone")) {
if (args.length == 0) {
int timer = 0;
for (WirelessCommand gcmd : cmds) {
if (timer == 0)
Utils.sendFeedback(ChatColor.WHITE + "WirelessRedstone help menu", sender, false); //TODO: Add this string to the stringloader
if (timer >= 8) {
Utils.sendFeedback("Use /wr help 2 for the next page.", sender, false); //TODO: Add this string to the stringloader
break;
}
CommandInfo info = gcmd.getClass().getAnnotation(CommandInfo.class);
if (sender.hasPermission("wirelessredstone.commands." + info.permission())) {
Utils.sendCommandFeedback(ChatColor.GRAY + "- " + ChatColor.GREEN + "/wr "
+ String.join("|", info.aliases()) + getCommandUsage(info) + ChatColor.WHITE + " - "
+ ChatColor.GRAY + info.description(), sender, false);
timer++;
}
}
if (timer == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().permissionGeneral, sender, true, true);
}
return true;
}
WirelessCommand wanted = null;
for (WirelessCommand gcmd : cmds) {
CommandInfo info = gcmd.getClass().getAnnotation(CommandInfo.class);
for (String alias : info.aliases()) {
if (alias.equals(args[0])) {
wanted = gcmd;
break;
}
}
}
if (wanted == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandNotFound, sender, true, true);
return true;
}
if (!sender.hasPermission("wirelessredstone.commands." + wanted.getClass().getAnnotation(CommandInfo.class).permission())) {
Utils.sendFeedback(WirelessRedstone.getStrings().permissionGeneral, sender, true, true);
return true;
}
if (!wanted.getClass().getAnnotation(CommandInfo.class).canUseInCommandBlock() && !(sender instanceof Player || sender instanceof ConsoleCommandSender)) {
WirelessRedstone.getWRLogger().info("Commandblocks are not allowed to run command: /wr " + args[0]);
return true;
}
if (!wanted.getClass().getAnnotation(CommandInfo.class).canUseInConsole() && sender instanceof ConsoleCommandSender) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandOnlyInGame, sender, true);
return true;
}
Vector<String> a = new Vector<String>(Arrays.asList(args));
a.remove(0);
args = a.toArray(new String[0]);
try {
wanted.onCommand(sender, args);
} catch (RuntimeException ex) {
sender.sendMessage(ChatColor.RED + "An internal error occurred while attempting to perform this command");
CommandException commandException = new CommandException(ex.getMessage(), ex);
WirelessRedstone.getInstance().getLogger().log(Level.SEVERE, "An exception was raised", commandException);
}
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
if (sender.isOp() || sender.hasPermission("wirelessredstone.Admin.isAdmin") ||
sender.hasPermission("wirelessredstone.commands." + args[0])) {
List<String> completions = new ArrayList<>();
if (args.length == 1) {
String partialCommand = args[0];
List<String> commands = new ArrayList<>();
for (WirelessCommand cmd : cmds) {
commands.add(cmd.getClass().getAnnotation(CommandInfo.class).aliases()[0]);
}
StringUtil.copyPartialMatches(partialCommand, commands, completions);
}
if (args.length >= 2) {
WirelessCommand wanted = null;
for (WirelessCommand gcmd : cmds) {
CommandInfo info = gcmd.getClass().getAnnotation(CommandInfo.class);
for (String alias : info.aliases()) {
if (alias.equals(args[0])) {
wanted = gcmd;
break;
}
}
}
if (wanted != null) {
if (args.length == 2) {
String partial = args[1];
List<String> availableCompletions = getPossibleTabCompletions(wanted, 0);
StringUtil.copyPartialMatches(partial, availableCompletions, completions);
} else if (args.length == 3) {
String partial = args[2];
List<String> availableCompletions = getPossibleTabCompletions(wanted, 1);
StringUtil.copyPartialMatches(partial, availableCompletions, completions);
}
}
}
Collections.sort(completions);
return completions;
}
return null;
}
public List<WirelessCommand> getCommands() {
return cmds;
}
private String getCommandUsage(CommandInfo info) {
if (info.usage().equalsIgnoreCase(""))
return "";
else
return " " + info.usage();
}
private List<String> getPossibleTabCompletions(WirelessCommand command, int index) {
List<String> availableCompletions = new ArrayList<>();
WirelessCommandTabCompletion[] tabCompletion = command.getClass().getAnnotation(CommandInfo.class).tabCompletion();
if (tabCompletion.length >= index + 1) {
if (tabCompletion[index] == WirelessCommandTabCompletion.BOOL) {
availableCompletions.add(Boolean.TRUE.toString());
availableCompletions.add(Boolean.FALSE.toString());
} else if (tabCompletion[index] == WirelessCommandTabCompletion.PLAYER) {
availableCompletions.addAll(Bukkit.getOnlinePlayers().stream()
.map(HumanEntity::getName)
.collect(Collectors.toList()));
} else if (tabCompletion[index] == WirelessCommandTabCompletion.CHANNEL) {
WirelessRedstone.getStorageManager().getChannels()
.forEach(c -> availableCompletions.add(c.getName()));
} else if (tabCompletion[index] == WirelessCommandTabCompletion.SIGNTYPE) {
for (SignType type : SignType.values()) {
availableCompletions.add(type.name());
}
} else if (tabCompletion[index] == WirelessCommandTabCompletion.STORAGETYPE) {
for (StorageType type : StorageType.values()) {
availableCompletions.add(type.name());
}
}
}
return availableCompletions;
}
}

106
src/main/java/net/licks92/wirelessredstone/commands/Create.java Normal file
View File

@@ -0,0 +1,106 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.signs.SignType;
import net.licks92.wirelessredstone.signs.WirelessChannel;
import net.licks92.wirelessredstone.Utils;
import net.licks92.wirelessredstone.WirelessRedstone;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.Collections;
@CommandInfo(description = "Create a WirelessPoint", usage = "<channel> <signtype> [sign details]", aliases = {"create", "c"},
tabCompletion = {WirelessCommandTabCompletion.CHANNEL, WirelessCommandTabCompletion.SIGNTYPE},
permission = "create", canUseInConsole = false, canUseInCommandBlock = false)
public class Create extends WirelessCommand {
@Override
public void onCommand(CommandSender sender, String[] args) {
if (args.length < 2) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandTooFewArguments, sender, true);
return;
}
if (Utils.getType(args[1]) == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandIncorrectSignType, sender, true);
return;
}
String cname = args[0];
SignType type = Utils.getType(args[1]);
if (type == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandIncorrectSignType, sender, true);
return;
}
if (type == SignType.RECEIVER_CLOCK || type == SignType.RECEIVER_DELAYER) {
if (args.length < 3) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandTooFewArguments, sender, true);
return;
}
}
WirelessChannel channel = WirelessRedstone.getStorageManager().getChannel(cname);
if (channel != null) {
if (!hasAccessToChannel(sender, cname)) {
Utils.sendFeedback(WirelessRedstone.getStrings().permissionChannelAccess, sender, true);
return;
}
}
Player player = (Player) sender;
Location location = player.getLocation();
if (location.getBlock().getType() != Material.AIR) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandInvalidSignLocation, sender, true);
return;
}
int extraData = 0;
if (type == SignType.RECEIVER_DELAYER) {
try {
extraData = Integer.parseInt(args[2]);
} catch (NumberFormatException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().delayNumberOnly, sender, true);
location.getBlock().setType(Material.AIR);
return;
}
} else if (type == SignType.RECEIVER_CLOCK) {
try {
extraData = Integer.parseInt(args[2]);
} catch (NumberFormatException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().intervalNumberOnly, sender, true);
location.getBlock().setType(Material.AIR);
return;
}
}
if (!WirelessRedstone.getSignManager().placeSign(cname, location, type, extraData)) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandInvalidSignLocation, sender, true);
return;
}
//TODO: #registerSign Implement error message if failed
int result = WirelessRedstone.getSignManager().registerSign(
cname, location.getBlock(), type, Utils.yawToFace(location.getYaw()),
Collections.singletonList(player.getUniqueId().toString()), extraData
);
if (result == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().channelExtended, sender, false);
} else if (result == 1) {
Utils.sendFeedback(WirelessRedstone.getStrings().channelCreated, sender, false);
} else if (result == -1) {
location.getBlock().setType(Material.AIR);
Utils.sendFeedback(WirelessRedstone.getStrings().commandDelayMin, sender, true);
} else if (result == -2) {
location.getBlock().setType(Material.AIR);
Utils.sendFeedback(WirelessRedstone.getStrings().commandIntervalMin, sender, true);
}
}
}

70
src/main/java/net/licks92/wirelessredstone/commands/Help.java Normal file
View File

@@ -0,0 +1,70 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.Utils;
import net.licks92.wirelessredstone.WirelessRedstone;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import java.util.ArrayList;
@CommandInfo(aliases = {"help", "h"}, description = "Show all available commands",
permission = "help", usage = "[page]", canUseInConsole = true, canUseInCommandBlock = true)
public class Help extends WirelessCommand {
@Override
public void onCommand(CommandSender sender, String[] args) { //TODO: Add all these strings to the stringloader
int page = 1;
if (args.length > 0) {
try {
page = Integer.parseInt(args[0]);
} catch (NumberFormatException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandInferiorZero, sender, true);
return;
}
}
ArrayList<String> commandList = new ArrayList<>();
for (WirelessCommand gcmd : WirelessRedstone.getCommandManager().getCommands()) {
CommandInfo info = gcmd.getClass().getAnnotation(CommandInfo.class);
commandList.add(ChatColor.GRAY + "- " + ChatColor.GREEN + "/wr "
+ String.join(":", info.aliases()) + " "
+ info.usage() + ChatColor.WHITE + " - "
+ ChatColor.GRAY + info.description());
}
int commandListLength = WirelessRedstone.getCommandManager().getCommands().size();
int maxItemsPerPage = 8;
int totalPages = 1;
for (int i = 0; i < commandListLength / maxItemsPerPage; i++) {
totalPages++;
}
if (commandListLength % maxItemsPerPage == 0) {
totalPages--;
}
if (page > totalPages) {
if (totalPages > 1)
Utils.sendFeedback("There are only " + totalPages + " pages.", sender, true);
else
Utils.sendFeedback("There is only 1 page.", sender, true);
return;
}
int currentItem = ((page * maxItemsPerPage) - maxItemsPerPage);
// 2*3 = 6 ; 6 - 3 = 3
Utils.sendFeedback(ChatColor.WHITE + "WirelessRedstone help menu", sender, false);
Utils.sendFeedback(ChatColor.WHITE + "Page " + page + " of " + totalPages, sender, false);
if (totalPages == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandNoData, sender, true);
} else {
for (int i = currentItem; i < (currentItem + maxItemsPerPage); i++) {
if (!(i >= commandListLength))
Utils.sendCommandFeedback(commandList.get(i), sender, false);
}
}
}
}

114
src/main/java/net/licks92/wirelessredstone/commands/Info.java Normal file
View File

@@ -0,0 +1,114 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.signs.SignType;
import net.licks92.wirelessredstone.signs.WirelessChannel;
import net.licks92.wirelessredstone.signs.WirelessReceiver;
import net.licks92.wirelessredstone.signs.WirelessScreen;
import net.licks92.wirelessredstone.signs.WirelessTransmitter;
import net.licks92.wirelessredstone.Utils;
import net.licks92.wirelessredstone.WirelessRedstone;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@CommandInfo(description = "Shows WirelessChannel information", usage = "<channel> [signtype]", aliases = {"info", "i"},
tabCompletion = {WirelessCommandTabCompletion.CHANNEL, WirelessCommandTabCompletion.SIGNTYPE},
permission = "info", canUseInConsole = true, canUseInCommandBlock = true)
public class Info extends WirelessCommand {
@Override
public void onCommand(CommandSender sender, String[] args) {
if (args.length == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandTooFewArguments, sender, true);
return;
}
WirelessChannel channel = WirelessRedstone.getStorageManager().getChannel(args[0]);
if (channel == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().channelNotFound, sender, true);
return;
}
SignType signType = null;
if (args.length >= 2)
signType = Utils.getType(args[1]);
if (signType == null) {
Utils.sendFeedback(ChatColor.GRAY + "---- " + ChatColor.GREEN + "WirelessChannel " + channel.getName() + ChatColor.GRAY + " ----",
sender, false);
Utils.sendFeedback(ChatColor.GRAY + "Is active: " +
((channel.isActive()) ? ChatColor.GREEN + "Yes" : ChatColor.RED + "No"), sender, false);
Utils.sendFeedback(ChatColor.GRAY + "Is locked: " +
((channel.isLocked()) ? ChatColor.GREEN + "Yes" : ChatColor.RED + "No"), sender, false);
Utils.sendFeedback(ChatColor.GRAY + "Sign Types:", sender, false);
Utils.sendFeedback(ChatColor.GRAY.toString() + channel.getTransmitters().size() + ChatColor.GREEN + " transmitters, "
+ ChatColor.GRAY + channel.getReceivers().size() + ChatColor.GREEN + " receivers, "
+ ChatColor.GRAY + channel.getScreens().size() + ChatColor.GREEN + " screens", sender, false);
} else {
if (!(sender instanceof Player)) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandOnlyInGame, sender, true);
return;
}
int index;
switch (signType) {
case TRANSMITTER:
if (channel.getTransmitters().size() == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandSignNotFound, sender, true);
return;
}
index = 0;
for (WirelessTransmitter transmitter : channel.getTransmitters()) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), Utils.getTeleportString(sender.getName())
.replaceAll("%%HOVERTEXT", "Click me to teleport to the sign location!")
.replaceAll("%%NAME", channel.getName()).replaceAll("%%TYPE", "transmitter")
.replaceAll("%%WORLD", transmitter.getWorld()).replaceAll("%%XCOORD", transmitter.getX() + "")
.replaceAll("%%YCOORD", transmitter.getY() + "").replaceAll("%%ZCOORD", transmitter.getZ() + "")
.replaceAll("%%COMMAND", "/wr tp " + channel.getName() + " transmitter " + index));
index++;
}
break;
case RECEIVER:
if (channel.getReceivers().size() == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandSignNotFound, sender, true);
return;
}
index = 0;
for (WirelessReceiver receiver : channel.getReceivers()) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), Utils.getTeleportString(sender.getName())
.replaceAll("%%HOVERTEXT", "Click me to teleport to the sign location!")
.replaceAll("%%NAME", channel.getName()).replaceAll("%%TYPE", "receiver")
.replaceAll("%%WORLD", receiver.getWorld()).replaceAll("%%XCOORD", receiver.getX() + "")
.replaceAll("%%YCOORD", receiver.getY() + "").replaceAll("%%ZCOORD", receiver.getZ() + "")
.replaceAll("%%COMMAND", "/wr tp " + channel.getName() + " receiver " + index));
index++;
}
break;
case SCREEN:
if (channel.getScreens().size() == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandSignNotFound, sender, true);
return;
}
index = 0;
for (WirelessScreen screen : channel.getScreens()) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), Utils.getTeleportString(sender.getName())
.replaceAll("%%HOVERTEXT", "Click me to teleport to the sign location!")
.replaceAll("%%NAME", channel.getName()).replaceAll("%%TYPE", "screen")
.replaceAll("%%WORLD", screen.getWorld()).replaceAll("%%XCOORD", screen.getX() + "")
.replaceAll("%%YCOORD", screen.getY() + "").replaceAll("%%ZCOORD", screen.getZ() + "")
.replaceAll("%%COMMAND", "/wr tp " + channel.getName() + " screen " + index));
index++;
}
break;
default:
Utils.sendFeedback(WirelessRedstone.getStrings().commandSignNotFound, sender, true);
break;
}
}
}
}

37
src/main/java/net/licks92/wirelessredstone/commands/Lock.java Normal file
View File

@@ -0,0 +1,37 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.signs.WirelessChannel;
import net.licks92.wirelessredstone.Utils;
import net.licks92.wirelessredstone.WirelessRedstone;
import org.bukkit.command.CommandSender;
@CommandInfo(description = "Toggle/set locked state for WirelessChannel", usage = "<channel> [state]", aliases = {"lock"},
tabCompletion = {WirelessCommandTabCompletion.CHANNEL, WirelessCommandTabCompletion.BOOL},
permission = "lock", canUseInConsole = true, canUseInCommandBlock = true)
public class Lock extends WirelessCommand {
@Override
public void onCommand(CommandSender sender, String[] args) {
if (args.length == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandTooFewArguments, sender, true);
return;
}
String cname = args[0];
WirelessChannel channel = WirelessRedstone.getStorageManager().getChannel(cname);
if (channel == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().channelNotFound, sender, true);
return;
}
boolean newState = !channel.isLocked();
if (args.length >= 2) {
if (args[1].equalsIgnoreCase("true") || args[1].equalsIgnoreCase("false"))
newState = args[1].equalsIgnoreCase("true");
}
channel.setLocked(newState);
WirelessRedstone.getStorage().updateChannel(args[0], channel);
Utils.sendFeedback(newState ? WirelessRedstone.getStrings().channelLocked : WirelessRedstone.getStrings().channelUnlocked, sender, false);
}
}

38
src/main/java/net/licks92/wirelessredstone/commands/Remove.java Normal file
View File

@@ -0,0 +1,38 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.Utils;
import net.licks92.wirelessredstone.WirelessRedstone;
import org.bukkit.command.CommandSender;
@CommandInfo(description = "Remove WirelessChannel", usage = "<channel> [remove signs]", aliases = {"remove"},
tabCompletion = {WirelessCommandTabCompletion.CHANNEL, WirelessCommandTabCompletion.BOOL},
permission = "remove", canUseInConsole = true, canUseInCommandBlock = false)
public class Remove extends WirelessCommand {
@Override
public void onCommand(CommandSender sender, String[] args) {
if (args.length == 0) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandTooFewArguments, sender, true);
return;
}
if (WirelessRedstone.getStorageManager().getChannel(args[0]) == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().channelNotFound, sender, true);
return;
}
if (!hasAccessToChannel(sender, args[0])) {
Utils.sendFeedback(WirelessRedstone.getStrings().permissionChannelAccess, sender, true);
return;
}
boolean removeSigns = false;
if (args.length >= 2) {
if (args[1].equalsIgnoreCase("true") || args[1].equalsIgnoreCase("false"))
removeSigns = args[1].equalsIgnoreCase("true");
}
WirelessRedstone.getStorage().removeChannel(args[0], removeSigns);
Utils.sendFeedback(WirelessRedstone.getStrings().channelRemoved, sender, false);
}
}

107
src/main/java/net/licks92/wirelessredstone/commands/Teleport.java Normal file
View File

@@ -0,0 +1,107 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.Utils;
import net.licks92.wirelessredstone.WirelessRedstone;
import net.licks92.wirelessredstone.signs.WirelessChannel;
import org.bukkit.Location;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@CommandInfo(description = "Teleport to specific sign", usage = "<channel> <type> <signID>", aliases = {"teleport", "tp"},
tabCompletion = {WirelessCommandTabCompletion.CHANNEL, WirelessCommandTabCompletion.SIGNTYPE},
permission = "teleport", canUseInConsole = false, canUseInCommandBlock = false)
public class Teleport extends WirelessCommand {
@Override
public void onCommand(CommandSender sender, String[] args) {
if (args.length < 3) {
//TODO: Add this to stringloader
Utils.sendFeedback("This command is for advanced users only. Use /wr info <channel> <signtype> for more user-friendly version.", sender, true);
return;
}
WirelessChannel channel = WirelessRedstone.getStorageManager().getChannel(args[0]);
if (channel == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().channelNotFound, sender, true);
return;
}
if (!hasAccessToChannel(sender, args[0])) {
Utils.sendFeedback(WirelessRedstone.getStrings().permissionChannelAccess, sender, true);
return;
}
int index;
try {
index = Integer.parseInt(args[2]);
} catch (NumberFormatException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandNoNumber, sender, true);
return;
}
Player player = (Player) sender;
switch (args[1].toUpperCase()) {
case "TRANSMITTER":
case "TRANSMITTERS":
case "T":
try {
if (channel.getTransmitters().get(index).getWorld() == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandInvalidLocation, player, true);
return;
}
Location locTransmitter = channel.getTransmitters().get(index).getLocation().add(0.5, 0, 0.5);
locTransmitter.setYaw(player.getLocation().getYaw());
locTransmitter.setPitch(player.getLocation().getPitch());
player.teleport(locTransmitter);
} catch (IndexOutOfBoundsException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandSignNotFound, player, true);
} catch (IllegalArgumentException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandInvalidLocation, player, true);
}
break;
case "RECEIVER":
case "RECEIVERS":
case "R":
try {
if (channel.getReceivers().get(index).getWorld() == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandInvalidLocation, player, true);
return;
}
Location locReceiver = channel.getReceivers().get(index).getLocation().add(0.5, 0, 0.5);
locReceiver.setYaw(player.getLocation().getYaw());
locReceiver.setPitch(player.getLocation().getPitch());
player.teleport(locReceiver);
} catch (IndexOutOfBoundsException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandSignNotFound, player, true);
} catch (IllegalArgumentException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandInvalidLocation, player, true);
}
break;
case "SCREEN":
case "SCREENS":
case "S":
try {
if (channel.getScreens().get(index).getWorld() == null) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandInvalidLocation, player, true);
return;
}
Location locScreen = channel.getScreens().get(index).getLocation().add(0.5, 0, 0.5);
locScreen.setYaw(player.getLocation().getYaw());
locScreen.setPitch(player.getLocation().getPitch());
player.teleport(locScreen);
} catch (IndexOutOfBoundsException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandSignNotFound, player, true);
} catch (IllegalArgumentException ex) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandInvalidLocation, player, true);
}
break;
}
}
}

16
src/main/java/net/licks92/wirelessredstone/commands/Version.java Normal file
View File

@@ -0,0 +1,16 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.Utils;
import net.licks92.wirelessredstone.WirelessRedstone;
import org.bukkit.command.CommandSender;
@CommandInfo(description = "Get WirelessRedstone version", usage = "", aliases = {"version", "v"},
permission = "version", canUseInConsole = true, canUseInCommandBlock = true)
public class Version extends WirelessCommand {
@Override
public void onCommand(CommandSender sender, String[] args) {
Utils.sendFeedback(WirelessRedstone.getStrings().commandVersion.replaceAll("%%VERSION", WirelessRedstone.getInstance().getDescription().getVersion()),
sender, false);
}
}

15
src/main/java/net/licks92/wirelessredstone/commands/WirelessCommand.java Normal file
View File

@@ -0,0 +1,15 @@
package net.licks92.wirelessredstone.commands;
import net.licks92.wirelessredstone.WirelessRedstone;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public abstract class WirelessCommand {
public abstract void onCommand(CommandSender sender, String[] args);
public boolean hasAccessToChannel(CommandSender sender, String channelName) {
return !(sender instanceof Player) || WirelessRedstone.getSignManager().hasAccessToChannel((Player) sender, channelName); //If it's console or commandBlock, it has access to channel.
}
}

5
src/main/java/net/licks92/wirelessredstone/commands/WirelessCommandTabCompletion.java Normal file
View File

@@ -0,0 +1,5 @@
package net.licks92.wirelessredstone.commands;
public enum WirelessCommandTabCompletion {
BOOL, PLAYER, CHANNEL, SIGNTYPE, STORAGETYPE
}