395 lines
18 KiB
Java
395 lines
18 KiB
Java
package de.mviper.adventskalender;
|
|
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.command.*;
|
|
import org.bukkit.OfflinePlayer;
|
|
import org.bukkit.entity.Player;
|
|
import java.time.MonthDay;
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
public class AdventCommand implements CommandExecutor, TabCompleter {
|
|
|
|
private static final int MAX_DAYS = 36;
|
|
|
|
@Override
|
|
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
|
|
Adventskalender plugin = Adventskalender.getInstance();
|
|
|
|
// Christmas+-Kurzbefehle: /ac test und /ac reset <Spieler> <Tag|all>
|
|
boolean elevated = false;
|
|
if (args.length == 1 && args[0].equalsIgnoreCase("test")
|
|
&& sender instanceof Player tp && tp.hasPermission("christmasplus.adventcalendar.test")) {
|
|
boolean on = de.mviper.adventskalender.christmas.CalendarPerks.toggle(tp);
|
|
var xm = de.mviper.adventskalender.christmas.ChristmasManager.get();
|
|
tp.sendMessage(xm != null ? xm.msg(on ? "calendar-test-on" : "calendar-test-off") : (on ? "Testmodus an" : "Testmodus aus"));
|
|
return true;
|
|
}
|
|
if (args.length == 3 && args[0].equalsIgnoreCase("reset")
|
|
&& sender.hasPermission("christmasplus.adventcalendar.reset")) {
|
|
args = args[2].equalsIgnoreCase("all")
|
|
? new String[]{"admin", "reset", args[1]}
|
|
: new String[]{"admin", "resetday", args[1], args[2]};
|
|
elevated = true;
|
|
}
|
|
|
|
if (args.length > 0 && args[0].equalsIgnoreCase("admin")) {
|
|
if (!elevated && !sender.hasPermission("adventskalender.admin")) {
|
|
sender.sendMessage(LanguageManager.getMessage("messages.no_permission"));
|
|
return true;
|
|
}
|
|
|
|
// /ak admin reload
|
|
if (args.length == 2 && args[1].equalsIgnoreCase("reload")) {
|
|
plugin.reloadConfig();
|
|
plugin.reloadSettings();
|
|
LanguageManager.setup();
|
|
DataHandler.setup();
|
|
AdventInventory.initCache();
|
|
de.mviper.adventskalender.christmas.ChristmasManager.reload();
|
|
sender.sendMessage(LanguageManager.getMessage("messages.admin.reload_success"));
|
|
return true;
|
|
}
|
|
|
|
// /ak admin test [Event] <Tag/reset>
|
|
if ((args.length == 3 || args.length == 4) && args[1].equalsIgnoreCase("test")) {
|
|
CalendarEvent ev = null;
|
|
if (args.length == 4) {
|
|
ev = EventManager.getAny(args[2]);
|
|
if (ev == null) {
|
|
sendUnknownEvent(sender, args[2]);
|
|
return true;
|
|
}
|
|
}
|
|
String value = args[args.length - 1];
|
|
List<CalendarEvent> targets = ev != null ? List.of(ev) : EventManager.allConfigured();
|
|
|
|
if (value.equalsIgnoreCase("reset")) {
|
|
for (CalendarEvent t : targets) t.setTestDay(0);
|
|
sender.sendMessage(LanguageManager.getString("messages.admin.test_mode_off").replace("%event%", label(ev)));
|
|
return true;
|
|
}
|
|
|
|
int day = parseDay(value, ev != null ? ev.getDays() : MAX_DAYS);
|
|
if (day == -1) {
|
|
sender.sendMessage(LanguageManager.getString("messages.admin.invalid_day"));
|
|
return true;
|
|
}
|
|
for (CalendarEvent t : targets) t.setTestDay(day);
|
|
sender.sendMessage(LanguageManager.getString("messages.admin.test_mode_on")
|
|
.replace("%day%", String.valueOf(day)).replace("%event%", label(ev)));
|
|
return true;
|
|
}
|
|
|
|
// /ak admin resetday [Event] <global/Spieler> <Tag>
|
|
if ((args.length == 4 || args.length == 5) && args[1].equalsIgnoreCase("resetday")) {
|
|
CalendarEvent ev = null;
|
|
int shift = 0;
|
|
if (args.length == 5) {
|
|
ev = EventManager.getAny(args[2]);
|
|
if (ev == null) {
|
|
sendUnknownEvent(sender, args[2]);
|
|
return true;
|
|
}
|
|
shift = 1;
|
|
}
|
|
String target = args[2 + shift];
|
|
int day = parseDay(args[3 + shift], ev != null ? ev.getDays() : MAX_DAYS);
|
|
if (day == -1) {
|
|
sender.sendMessage(LanguageManager.getString("messages.admin.invalid_day"));
|
|
return true;
|
|
}
|
|
|
|
final CalendarEvent event = ev;
|
|
runAsync(() -> {
|
|
if (target.equalsIgnoreCase("global")) {
|
|
DataHandler.resetGlobalDay(event, day);
|
|
reply(sender, LanguageManager.getString("messages.admin.reset_day_global")
|
|
.replace("%day%", String.valueOf(day)).replace("%event%", label(event)));
|
|
} else {
|
|
boolean found = DataHandler.resetPlayerDay(target, event, day);
|
|
reply(sender, found
|
|
? LanguageManager.getString("messages.admin.reset_day_player")
|
|
.replace("%day%", String.valueOf(day)).replace("%player%", target).replace("%event%", label(event))
|
|
: LanguageManager.getString("messages.admin.player_not_found").replace("%player%", target));
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
// /ak admin reset [Event] <global/Spieler>
|
|
if (args.length >= 3 && args[1].equalsIgnoreCase("reset")) {
|
|
CalendarEvent ev = null;
|
|
String targetName = args[2];
|
|
if (args.length >= 4) {
|
|
ev = EventManager.getAny(args[2]);
|
|
if (ev == null) {
|
|
sendUnknownEvent(sender, args[2]);
|
|
return true;
|
|
}
|
|
targetName = args[3];
|
|
}
|
|
final CalendarEvent event = ev;
|
|
final String name = targetName;
|
|
|
|
if (name.equalsIgnoreCase("global")) {
|
|
runAsync(() -> {
|
|
DataHandler.resetAll(event);
|
|
Bukkit.getScheduler().runTask(plugin, AdventInventory::closeAll);
|
|
reply(sender, LanguageManager.getString("messages.admin.reset_all").replace("%event%", label(event)));
|
|
});
|
|
} else {
|
|
Player target = Bukkit.getPlayerExact(name);
|
|
if (target != null) {
|
|
runAsync(() -> {
|
|
DataHandler.resetPlayer(target, event);
|
|
Bukkit.getScheduler().runTask(plugin, () -> AdventInventory.closeFor(target));
|
|
reply(sender, LanguageManager.getString("messages.admin.reset_player")
|
|
.replace("%player%", target.getName()).replace("%event%", label(event)));
|
|
});
|
|
} else {
|
|
runAsync(() -> {
|
|
boolean found = DataHandler.resetOfflinePlayer(name, event);
|
|
reply(sender, found
|
|
? LanguageManager.getString("messages.admin.reset_offline")
|
|
.replace("%player%", name).replace("%event%", label(event))
|
|
: LanguageManager.getString("messages.admin.player_not_found").replace("%player%", name));
|
|
});
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// /ak admin birthday <set|remove|reset> <Spieler> [TT.MM]
|
|
if (args.length >= 4 && args[1].equalsIgnoreCase("birthday")) {
|
|
String action = args[2].toLowerCase();
|
|
String targetName = args[3];
|
|
MonthDay date = null;
|
|
if (action.equals("set")) {
|
|
date = args.length == 5 ? BirthdayManager.parse(args[4]) : null;
|
|
if (date == null) {
|
|
sender.sendMessage(LanguageManager.getMessage("birthday.invalid_date", "birthday.prefix"));
|
|
return true;
|
|
}
|
|
} else if (!action.equals("remove") && !action.equals("reset")) {
|
|
for (String line : LanguageManager.getStringList("messages.admin.help")) sender.sendMessage(line);
|
|
return true;
|
|
}
|
|
|
|
final MonthDay md = date;
|
|
runAsync(() -> {
|
|
@SuppressWarnings("deprecation")
|
|
OfflinePlayer target = Bukkit.getOfflinePlayer(targetName);
|
|
if (!target.isOnline() && !target.hasPlayedBefore()) {
|
|
reply(sender, LanguageManager.getString("messages.admin.player_not_found").replace("%player%", targetName));
|
|
return;
|
|
}
|
|
String shownName = target.getName() != null ? target.getName() : targetName;
|
|
try {
|
|
switch (action) {
|
|
case "set" -> {
|
|
DataHandler.setBirthday(target.getUniqueId(), shownName, md.getMonthValue(), md.getDayOfMonth(), false);
|
|
reply(sender, LanguageManager.getString("birthday.admin_set")
|
|
.replace("%player%", shownName).replace("%date%", BirthdayManager.format(md)));
|
|
}
|
|
case "remove" -> {
|
|
boolean removed = DataHandler.removeBirthday(target.getUniqueId(), shownName);
|
|
reply(sender, LanguageManager.getString(removed ? "birthday.admin_removed" : "birthday.admin_none")
|
|
.replace("%player%", shownName));
|
|
}
|
|
default -> {
|
|
boolean reset = DataHandler.resetBirthdayClaim(target.getUniqueId(), shownName);
|
|
reply(sender, LanguageManager.getString(reset ? "birthday.admin_reset" : "birthday.admin_none")
|
|
.replace("%player%", shownName));
|
|
}
|
|
}
|
|
} catch (DataHandler.DataException e) {
|
|
reply(sender, LanguageManager.getMessage("messages.db_error"));
|
|
}
|
|
});
|
|
return true;
|
|
}
|
|
|
|
for (String line : LanguageManager.getStringList("messages.admin.help")) {
|
|
sender.sendMessage(line);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
if (!(sender instanceof Player player)) {
|
|
sender.sendMessage(LanguageManager.getMessage("messages.only_player"));
|
|
return true;
|
|
}
|
|
if (!player.hasPermission("adventskalender.use")) {
|
|
player.sendMessage(LanguageManager.getMessage("messages.no_permission"));
|
|
return true;
|
|
}
|
|
|
|
// /ak birthday [set <TT.MM> | claim | remove]
|
|
if (args.length >= 1 && args[0].equalsIgnoreCase("birthday")) {
|
|
if (!player.hasPermission("adventskalender.birthday")) {
|
|
player.sendMessage(LanguageManager.getMessage("messages.no_permission"));
|
|
return true;
|
|
}
|
|
if (args.length == 1) {
|
|
BirthdayManager.handleInfo(player);
|
|
BirthdayManager.sendHelp(player);
|
|
} else if (args[1].equalsIgnoreCase("set") && args.length == 3) {
|
|
BirthdayManager.handleSet(player, args[2]);
|
|
} else if (args[1].equalsIgnoreCase("claim")) {
|
|
BirthdayManager.handleClaim(player);
|
|
} else if (args[1].equalsIgnoreCase("remove")) {
|
|
BirthdayManager.handleRemove(player);
|
|
} else {
|
|
BirthdayManager.sendHelp(player);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// /ak [Event]
|
|
CalendarEvent event;
|
|
if (args.length >= 1) {
|
|
event = EventManager.get(args[0]);
|
|
if (event == null) {
|
|
sendUnknownEvent(player, args[0]);
|
|
return true;
|
|
}
|
|
} else {
|
|
event = EventManager.defaultEvent();
|
|
if (event == null) {
|
|
player.sendMessage(LanguageManager.getMessage("messages.no_events"));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
AdventInventory.open(player, event);
|
|
return true;
|
|
}
|
|
|
|
private void sendUnknownEvent(CommandSender sender, String given) {
|
|
String ids = EventManager.allConfigured().stream().map(CalendarEvent::getId).collect(Collectors.joining(", "));
|
|
sender.sendMessage(LanguageManager.getMessage("messages.unknown_event")
|
|
.replace("%event%", given).replace("%events%", ids));
|
|
}
|
|
|
|
/** Tag zwischen 1 und max, sonst -1. */
|
|
private static int parseDay(String value, int max) {
|
|
try {
|
|
int day = Integer.parseInt(value);
|
|
return (day >= 1 && day <= max) ? day : -1;
|
|
} catch (NumberFormatException e) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
private static String label(CalendarEvent ev) {
|
|
return ev != null ? ev.getId() : LanguageManager.getString("messages.admin.all_events");
|
|
}
|
|
|
|
private void runAsync(Runnable task) {
|
|
Bukkit.getScheduler().runTaskAsynchronously(Adventskalender.getInstance(), task);
|
|
}
|
|
|
|
/** Sendet die Antwort im Main-Thread. */
|
|
private void reply(CommandSender sender, String message) {
|
|
Bukkit.getScheduler().runTask(Adventskalender.getInstance(), () -> sender.sendMessage(message));
|
|
}
|
|
|
|
// ------------------------------------------------------------------ Tab-Completion
|
|
|
|
private static List<String> filter(Collection<String> options, String prefix) {
|
|
return options.stream()
|
|
.filter(opt -> opt.toLowerCase().startsWith(prefix.toLowerCase()))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
private static List<String> eventIds() {
|
|
return EventManager.allConfigured().stream().map(CalendarEvent::getId).collect(Collectors.toList());
|
|
}
|
|
|
|
private static List<String> targets() {
|
|
List<String> options = new ArrayList<>();
|
|
options.add("global");
|
|
Bukkit.getOnlinePlayers().forEach(p -> options.add(p.getName()));
|
|
return options;
|
|
}
|
|
|
|
private static List<String> dayOptions(int max) {
|
|
List<String> days = new ArrayList<>();
|
|
for (int i = 1; i <= max; i++) days.add(String.valueOf(i));
|
|
return days;
|
|
}
|
|
|
|
@Override
|
|
public List<String> onTabComplete(CommandSender s, Command c, String a, String[] args) {
|
|
boolean admin = s.hasPermission("adventskalender.admin");
|
|
|
|
if (args.length == 1) {
|
|
List<String> options = new ArrayList<>(EventManager.all().stream().map(CalendarEvent::getId).toList());
|
|
if (BirthdayManager.isEnabled() && s.hasPermission("adventskalender.birthday")) options.add("birthday");
|
|
if (admin) options.add("admin");
|
|
return filter(options, args[0]);
|
|
}
|
|
|
|
if (args[0].equalsIgnoreCase("birthday")) {
|
|
if (args.length == 2) return filter(Arrays.asList("set", "claim", "remove"), args[1]);
|
|
return Collections.emptyList();
|
|
}
|
|
|
|
if (!admin || !args[0].equalsIgnoreCase("admin")) return Collections.emptyList();
|
|
|
|
if (args.length == 2) return filter(Arrays.asList("reload", "test", "reset", "resetday", "birthday"), args[1]);
|
|
|
|
if (args[1].equalsIgnoreCase("birthday")) {
|
|
if (args.length == 3) return filter(Arrays.asList("set", "remove", "reset"), args[2]);
|
|
if (args.length == 4) return filter(targets().stream().filter(t -> !t.equals("global")).collect(Collectors.toList()), args[3]);
|
|
return Collections.emptyList();
|
|
}
|
|
|
|
String sub = args[1].toLowerCase();
|
|
String last = args[args.length - 1];
|
|
CalendarEvent ev = EventManager.getAny(args[2]);
|
|
|
|
switch (sub) {
|
|
case "test": {
|
|
if (args.length == 3) {
|
|
List<String> options = new ArrayList<>(eventIds());
|
|
options.add(0, "reset");
|
|
options.addAll(dayOptions(MAX_DAYS));
|
|
return filter(options, last);
|
|
}
|
|
if (args.length == 4 && ev != null) {
|
|
List<String> options = new ArrayList<>(dayOptions(ev.getDays()));
|
|
options.add(0, "reset");
|
|
return filter(options, last);
|
|
}
|
|
break;
|
|
}
|
|
case "reset": {
|
|
if (args.length == 3) {
|
|
List<String> options = new ArrayList<>(eventIds());
|
|
options.addAll(targets());
|
|
return filter(options, last);
|
|
}
|
|
if (args.length == 4 && ev != null) return filter(targets(), last);
|
|
break;
|
|
}
|
|
case "resetday": {
|
|
if (args.length == 3) {
|
|
List<String> options = new ArrayList<>(eventIds());
|
|
options.addAll(targets());
|
|
return filter(options, last);
|
|
}
|
|
if (args.length == 4) {
|
|
return ev != null ? filter(targets(), last) : filter(dayOptions(MAX_DAYS), last);
|
|
}
|
|
if (args.length == 5 && ev != null) return filter(dayOptions(ev.getDays()), last);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
return Collections.emptyList();
|
|
}
|
|
}
|