2019-09-23 14:29:31 +02:00
|
|
|
package net.citizensnpcs.trait;
|
|
|
|
|
2020-06-10 20:24:03 +02:00
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.Comparator;
|
2021-01-15 15:06:03 +01:00
|
|
|
import java.util.EnumSet;
|
2019-09-23 14:29:31 +02:00
|
|
|
import java.util.List;
|
|
|
|
import java.util.Map;
|
2021-01-15 15:06:03 +01:00
|
|
|
import java.util.Set;
|
2021-03-13 15:17:55 +01:00
|
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import java.util.function.Function;
|
2019-09-23 14:29:31 +02:00
|
|
|
|
2021-03-13 15:17:55 +01:00
|
|
|
import org.apache.logging.log4j.core.lookup.StrSubstitutor;
|
2019-09-23 14:29:31 +02:00
|
|
|
import org.bukkit.Bukkit;
|
2021-02-01 15:35:28 +01:00
|
|
|
import org.bukkit.Material;
|
2019-09-23 14:29:31 +02:00
|
|
|
import org.bukkit.command.CommandSender;
|
2021-02-01 15:35:28 +01:00
|
|
|
import org.bukkit.entity.HumanEntity;
|
2019-09-23 14:29:31 +02:00
|
|
|
import org.bukkit.entity.Player;
|
2021-02-01 15:35:28 +01:00
|
|
|
import org.bukkit.event.inventory.InventoryType;
|
|
|
|
import org.bukkit.inventory.Inventory;
|
|
|
|
import org.bukkit.inventory.ItemStack;
|
2020-04-30 15:32:38 +02:00
|
|
|
import org.bukkit.permissions.PermissionAttachment;
|
2020-06-30 09:20:02 +02:00
|
|
|
import org.bukkit.plugin.RegisteredServiceProvider;
|
2019-09-23 14:29:31 +02:00
|
|
|
|
2020-06-10 20:24:03 +02:00
|
|
|
import com.google.common.base.Predicate;
|
2020-04-25 13:10:49 +02:00
|
|
|
import com.google.common.base.Splitter;
|
2020-06-10 20:24:03 +02:00
|
|
|
import com.google.common.collect.Iterables;
|
2019-09-23 14:29:31 +02:00
|
|
|
import com.google.common.collect.Lists;
|
|
|
|
import com.google.common.collect.Maps;
|
2020-08-12 17:40:44 +02:00
|
|
|
import com.google.common.io.BaseEncoding;
|
2020-04-25 13:10:49 +02:00
|
|
|
import com.google.common.io.ByteArrayDataOutput;
|
|
|
|
import com.google.common.io.ByteStreams;
|
2019-09-23 14:29:31 +02:00
|
|
|
|
2020-10-05 06:18:19 +02:00
|
|
|
import net.citizensnpcs.Settings.Setting;
|
2020-04-15 21:04:42 +02:00
|
|
|
import net.citizensnpcs.api.CitizensAPI;
|
2020-06-30 09:20:02 +02:00
|
|
|
import net.citizensnpcs.api.event.NPCCommandDispatchEvent;
|
2021-02-01 15:35:28 +01:00
|
|
|
import net.citizensnpcs.api.gui.InventoryMenuPage;
|
|
|
|
import net.citizensnpcs.api.gui.Menu;
|
|
|
|
import net.citizensnpcs.api.gui.MenuContext;
|
2019-09-23 14:29:31 +02:00
|
|
|
import net.citizensnpcs.api.npc.NPC;
|
2019-10-01 08:16:00 +02:00
|
|
|
import net.citizensnpcs.api.persistence.DelegatePersistence;
|
2019-09-23 14:29:31 +02:00
|
|
|
import net.citizensnpcs.api.persistence.Persist;
|
|
|
|
import net.citizensnpcs.api.persistence.Persister;
|
|
|
|
import net.citizensnpcs.api.trait.Trait;
|
|
|
|
import net.citizensnpcs.api.trait.TraitName;
|
|
|
|
import net.citizensnpcs.api.util.DataKey;
|
|
|
|
import net.citizensnpcs.api.util.Messaging;
|
2020-01-16 12:40:32 +01:00
|
|
|
import net.citizensnpcs.api.util.Placeholders;
|
2020-10-05 06:18:19 +02:00
|
|
|
import net.citizensnpcs.api.util.Translator;
|
2019-09-23 14:29:31 +02:00
|
|
|
import net.citizensnpcs.util.Messages;
|
2020-05-01 14:07:22 +02:00
|
|
|
import net.citizensnpcs.util.StringHelper;
|
2020-07-03 16:59:18 +02:00
|
|
|
import net.citizensnpcs.util.Util;
|
2020-06-30 09:20:02 +02:00
|
|
|
import net.milkbowl.vault.economy.Economy;
|
2019-09-23 14:29:31 +02:00
|
|
|
|
|
|
|
@TraitName("commandtrait")
|
|
|
|
public class CommandTrait extends Trait {
|
|
|
|
@Persist
|
2019-10-01 08:16:00 +02:00
|
|
|
@DelegatePersistence(NPCCommandPersister.class)
|
2019-09-23 14:29:31 +02:00
|
|
|
private final Map<String, NPCCommand> commands = Maps.newHashMap();
|
2021-02-07 11:45:10 +01:00
|
|
|
@Persist(reify = true)
|
2020-03-07 05:43:16 +01:00
|
|
|
private final Map<String, PlayerNPCCommand> cooldowns = Maps.newHashMap();
|
2020-04-30 15:32:38 +02:00
|
|
|
@Persist
|
2020-06-30 09:20:02 +02:00
|
|
|
private double cost = -1;
|
2021-01-15 15:06:03 +01:00
|
|
|
private final Map<String, Set<CommandTraitMessages>> executionErrors = Maps.newHashMap();
|
2020-06-30 09:20:02 +02:00
|
|
|
@Persist
|
2020-07-03 16:59:18 +02:00
|
|
|
private ExecutionMode executionMode = ExecutionMode.LINEAR;
|
2020-06-10 20:24:03 +02:00
|
|
|
@Persist
|
2020-12-16 11:12:37 +01:00
|
|
|
private final Map<String, Long> globalCooldowns = Maps.newHashMap();
|
|
|
|
@Persist
|
2021-02-01 15:35:28 +01:00
|
|
|
private List<ItemStack> itemRequirements = Lists.newArrayList();
|
|
|
|
@Persist
|
2020-04-30 15:32:38 +02:00
|
|
|
private final List<String> temporaryPermissions = Lists.newArrayList();
|
2019-09-23 14:29:31 +02:00
|
|
|
|
|
|
|
public CommandTrait() {
|
|
|
|
super("commandtrait");
|
|
|
|
}
|
|
|
|
|
2020-04-30 15:15:24 +02:00
|
|
|
public int addCommand(NPCCommandBuilder builder) {
|
2019-09-23 14:29:31 +02:00
|
|
|
int id = getNewId();
|
2020-06-10 20:24:03 +02:00
|
|
|
commands.put(String.valueOf(id), builder.build(id));
|
2019-09-23 14:29:31 +02:00
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2020-06-30 09:20:02 +02:00
|
|
|
private boolean checkPreconditions(Player player, Hand hand) {
|
|
|
|
if (cost > 0) {
|
|
|
|
try {
|
|
|
|
RegisteredServiceProvider<Economy> provider = Bukkit.getServicesManager()
|
|
|
|
.getRegistration(Economy.class);
|
|
|
|
if (provider != null && provider.getProvider() != null) {
|
|
|
|
Economy economy = provider.getProvider();
|
2020-10-05 06:18:19 +02:00
|
|
|
if (!economy.has(player, cost)) {
|
2021-03-13 15:17:55 +01:00
|
|
|
sendErrorMessage(player, CommandTraitMessages.MISSING_MONEY, null, cost);
|
2020-06-30 09:20:02 +02:00
|
|
|
return false;
|
2020-10-05 06:18:19 +02:00
|
|
|
}
|
2020-06-30 09:20:02 +02:00
|
|
|
economy.withdrawPlayer(player, cost);
|
|
|
|
}
|
|
|
|
} catch (NoClassDefFoundError e) {
|
2020-07-09 17:37:45 +02:00
|
|
|
Messaging.severe("Unable to find Vault when checking command cost - is it installed?");
|
2020-06-30 09:20:02 +02:00
|
|
|
}
|
|
|
|
}
|
2021-02-01 15:35:28 +01:00
|
|
|
if (itemRequirements.size() > 0) {
|
|
|
|
List<ItemStack> req = Lists.newArrayList(itemRequirements);
|
|
|
|
Inventory tempInventory = Bukkit.createInventory(null, 54);
|
|
|
|
for (int i = 0; i < player.getInventory().getSize(); i++) {
|
|
|
|
tempInventory.setItem(i, player.getInventory().getItem(i));
|
|
|
|
}
|
|
|
|
for (ItemStack stack : req) {
|
|
|
|
if (tempInventory.containsAtLeast(stack, stack.getAmount())) {
|
|
|
|
tempInventory.removeItem(stack);
|
|
|
|
} else {
|
2021-03-13 15:17:55 +01:00
|
|
|
sendErrorMessage(player, CommandTraitMessages.MISSING_ITEM, null, Util.prettyEnum(stack.getType()),
|
2021-02-01 15:35:28 +01:00
|
|
|
stack.getAmount());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (int i = 0; i < player.getInventory().getSize(); i++) {
|
|
|
|
player.getInventory().setItem(i, tempInventory.getItem(i));
|
|
|
|
}
|
|
|
|
}
|
2020-06-30 09:20:02 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2019-09-23 14:29:31 +02:00
|
|
|
/**
|
2020-02-14 15:48:40 +01:00
|
|
|
* Send a brief description of the current state of the trait to the supplied {@link CommandSender}.
|
2019-09-23 14:29:31 +02:00
|
|
|
*/
|
|
|
|
public void describe(CommandSender sender) {
|
|
|
|
List<NPCCommand> left = Lists.newArrayList();
|
|
|
|
List<NPCCommand> right = Lists.newArrayList();
|
|
|
|
for (NPCCommand command : commands.values()) {
|
2020-01-17 10:11:23 +01:00
|
|
|
if (command.hand == Hand.LEFT || command.hand == Hand.BOTH) {
|
2019-09-23 14:29:31 +02:00
|
|
|
left.add(command);
|
2020-01-17 10:11:23 +01:00
|
|
|
}
|
|
|
|
if (command.hand == Hand.RIGHT || command.hand == Hand.BOTH) {
|
2019-09-23 14:29:31 +02:00
|
|
|
right.add(command);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
String output = "";
|
|
|
|
if (left.size() > 0) {
|
|
|
|
output += Messaging.tr(Messages.COMMAND_LEFT_HAND_HEADER);
|
|
|
|
for (NPCCommand command : left) {
|
2020-02-22 05:57:03 +01:00
|
|
|
output += describe(command);
|
2019-09-23 14:29:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (right.size() > 0) {
|
|
|
|
output += Messaging.tr(Messages.COMMAND_RIGHT_HAND_HEADER);
|
|
|
|
for (NPCCommand command : right) {
|
2020-02-22 05:57:03 +01:00
|
|
|
output += describe(command);
|
2019-09-23 14:29:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (output.isEmpty()) {
|
|
|
|
output = Messaging.tr(Messages.COMMAND_NO_COMMANDS_ADDED);
|
|
|
|
}
|
|
|
|
Messaging.send(sender, output);
|
|
|
|
}
|
|
|
|
|
2020-02-22 05:57:03 +01:00
|
|
|
private String describe(NPCCommand command) {
|
2020-05-01 14:07:22 +02:00
|
|
|
String output = "<br> - [" + StringHelper.wrap(command.id) + "]: " + command.command + " ["
|
|
|
|
+ StringHelper.wrap(command.cooldown + "s") + "]";
|
2020-02-22 05:57:03 +01:00
|
|
|
if (command.op) {
|
|
|
|
output += " -o";
|
|
|
|
}
|
|
|
|
if (command.player) {
|
|
|
|
output += " -p";
|
|
|
|
}
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
|
2020-04-15 21:04:42 +02:00
|
|
|
public void dispatch(final Player player, final Hand hand) {
|
2020-06-30 09:20:02 +02:00
|
|
|
NPCCommandDispatchEvent event = new NPCCommandDispatchEvent(npc, player);
|
|
|
|
event.setCancelled(!checkPreconditions(player, hand));
|
|
|
|
Bukkit.getServer().getPluginManager().callEvent(event);
|
|
|
|
if (event.isCancelled()) {
|
|
|
|
return;
|
|
|
|
}
|
2020-04-15 21:04:42 +02:00
|
|
|
Runnable task = new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
2020-07-03 16:59:18 +02:00
|
|
|
List<NPCCommand> commandList = Lists
|
|
|
|
.newArrayList(Iterables.filter(commands.values(), new Predicate<NPCCommand>() {
|
|
|
|
@Override
|
|
|
|
public boolean apply(NPCCommand command) {
|
|
|
|
return command.hand == hand || command.hand == Hand.BOTH;
|
|
|
|
}
|
|
|
|
}));
|
2020-07-15 14:19:43 +02:00
|
|
|
if (executionMode == ExecutionMode.RANDOM) {
|
|
|
|
if (commandList.size() > 0) {
|
|
|
|
runCommand(player, commandList.get(Util.getFastRandom().nextInt(commandList.size())));
|
|
|
|
}
|
|
|
|
return;
|
2020-07-03 16:59:18 +02:00
|
|
|
}
|
2020-06-10 20:24:03 +02:00
|
|
|
int max = -1;
|
2020-07-03 16:59:18 +02:00
|
|
|
if (executionMode == ExecutionMode.SEQUENTIAL) {
|
|
|
|
Collections.sort(commandList, new Comparator<NPCCommand>() {
|
2020-06-10 20:24:03 +02:00
|
|
|
@Override
|
|
|
|
public int compare(NPCCommand o1, NPCCommand o2) {
|
|
|
|
return Integer.compare(o1.id, o2.id);
|
|
|
|
}
|
|
|
|
});
|
2020-07-03 16:59:18 +02:00
|
|
|
max = commandList.size() > 0 ? commandList.get(commandList.size() - 1).id : -1;
|
2020-06-10 20:24:03 +02:00
|
|
|
}
|
2021-01-15 15:06:03 +01:00
|
|
|
if (executionMode == ExecutionMode.LINEAR) {
|
|
|
|
executionErrors.put(player.getUniqueId().toString(), EnumSet.noneOf(CommandTraitMessages.class));
|
|
|
|
}
|
2020-06-10 20:24:03 +02:00
|
|
|
for (NPCCommand command : commandList) {
|
2020-07-03 16:59:18 +02:00
|
|
|
if (executionMode == ExecutionMode.SEQUENTIAL) {
|
2020-06-10 20:24:03 +02:00
|
|
|
PlayerNPCCommand info = cooldowns.get(player.getUniqueId().toString());
|
2021-04-25 06:06:59 +02:00
|
|
|
if (info != null && info.lastUsedHand != hand) {
|
|
|
|
info.lastUsedHand = hand;
|
|
|
|
info.lastUsedId = -1;
|
|
|
|
}
|
2020-06-11 10:23:48 +02:00
|
|
|
if (info != null && command.id <= info.lastUsedId) {
|
2020-06-10 20:24:03 +02:00
|
|
|
if (info.lastUsedId == max) {
|
|
|
|
info.lastUsedId = -1;
|
2020-06-11 10:23:48 +02:00
|
|
|
} else {
|
|
|
|
continue;
|
2020-06-10 20:24:03 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-07-03 16:59:18 +02:00
|
|
|
runCommand(player, command);
|
2020-10-03 09:40:53 +02:00
|
|
|
if (executionMode == ExecutionMode.SEQUENTIAL) {
|
|
|
|
break;
|
|
|
|
}
|
2020-07-03 16:59:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void runCommand(final Player player, NPCCommand command) {
|
|
|
|
Runnable runnable = new Runnable() {
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
PlayerNPCCommand info = cooldowns.get(player.getUniqueId().toString());
|
|
|
|
if (info == null && (executionMode == ExecutionMode.SEQUENTIAL
|
|
|
|
|| PlayerNPCCommand.requiresTracking(command))) {
|
|
|
|
cooldowns.put(player.getUniqueId().toString(), info = new PlayerNPCCommand());
|
|
|
|
}
|
2020-10-05 06:18:19 +02:00
|
|
|
if (info != null && !info.canUse(CommandTrait.this, player, command)) {
|
2020-07-03 16:59:18 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
PermissionAttachment attachment = player.addAttachment(CitizensAPI.getPlugin());
|
|
|
|
if (temporaryPermissions.size() > 0) {
|
|
|
|
for (String permission : temporaryPermissions) {
|
|
|
|
attachment.setPermission(permission, true);
|
2020-04-30 15:32:38 +02:00
|
|
|
}
|
2020-04-30 15:15:24 +02:00
|
|
|
}
|
2020-07-03 16:59:18 +02:00
|
|
|
command.run(npc, player);
|
|
|
|
attachment.remove();
|
2020-04-15 21:04:42 +02:00
|
|
|
}
|
2020-07-03 16:59:18 +02:00
|
|
|
};
|
|
|
|
if (command.delay <= 0) {
|
|
|
|
runnable.run();
|
|
|
|
} else {
|
|
|
|
Bukkit.getScheduler().scheduleSyncDelayedTask(CitizensAPI.getPlugin(), runnable, command.delay);
|
2020-04-15 21:04:42 +02:00
|
|
|
}
|
2020-02-22 05:57:03 +01:00
|
|
|
}
|
2020-04-15 21:04:42 +02:00
|
|
|
};
|
|
|
|
if (Bukkit.isPrimaryThread()) {
|
|
|
|
task.run();
|
|
|
|
} else {
|
2020-04-30 15:15:24 +02:00
|
|
|
Bukkit.getScheduler().scheduleSyncDelayedTask(CitizensAPI.getPlugin(), task);
|
2019-09-23 14:29:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-07 13:16:41 +02:00
|
|
|
public double getCost() {
|
|
|
|
return cost;
|
|
|
|
}
|
|
|
|
|
2020-07-03 16:59:18 +02:00
|
|
|
public ExecutionMode getExecutionMode() {
|
|
|
|
return executionMode;
|
|
|
|
}
|
|
|
|
|
2019-09-23 14:29:31 +02:00
|
|
|
private int getNewId() {
|
|
|
|
int i = 0;
|
|
|
|
while (commands.containsKey(String.valueOf(i))) {
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean hasCommandId(int id) {
|
|
|
|
return commands.containsKey(String.valueOf(id));
|
|
|
|
}
|
|
|
|
|
|
|
|
public void removeCommandById(int id) {
|
|
|
|
commands.remove(String.valueOf(id));
|
|
|
|
}
|
|
|
|
|
2021-03-13 15:17:55 +01:00
|
|
|
private void sendErrorMessage(Player player, CommandTraitMessages msg, Function<String, String> transform,
|
|
|
|
Object... objects) {
|
2021-01-15 15:06:03 +01:00
|
|
|
Set<CommandTraitMessages> sent = executionErrors.get(player.getUniqueId().toString());
|
|
|
|
if (sent != null) {
|
|
|
|
if (sent.contains(msg))
|
|
|
|
return;
|
|
|
|
sent.add(msg);
|
|
|
|
}
|
2020-10-05 06:18:19 +02:00
|
|
|
String messageRaw = msg.setting.asString();
|
2021-03-13 15:17:55 +01:00
|
|
|
if (transform != null) {
|
|
|
|
messageRaw = transform.apply(messageRaw);
|
|
|
|
}
|
2020-10-21 09:18:07 +02:00
|
|
|
if (messageRaw != null && messageRaw.trim().length() > 0) {
|
|
|
|
Messaging.send(player, Translator.format(messageRaw, objects));
|
|
|
|
}
|
2020-10-05 06:18:19 +02:00
|
|
|
}
|
|
|
|
|
2020-06-30 09:20:02 +02:00
|
|
|
public void setCost(double cost) {
|
|
|
|
this.cost = cost;
|
|
|
|
}
|
|
|
|
|
2020-07-03 16:59:18 +02:00
|
|
|
public void setExecutionMode(ExecutionMode mode) {
|
|
|
|
this.executionMode = mode;
|
2020-06-10 20:24:03 +02:00
|
|
|
}
|
|
|
|
|
2020-04-30 15:32:38 +02:00
|
|
|
public void setTemporaryPermissions(List<String> permissions) {
|
|
|
|
temporaryPermissions.clear();
|
|
|
|
temporaryPermissions.addAll(permissions);
|
|
|
|
}
|
|
|
|
|
2020-10-05 06:18:19 +02:00
|
|
|
private enum CommandTraitMessages {
|
|
|
|
MAXIMUM_TIMES_USED(Setting.NPC_COMMAND_MAXIMUM_TIMES_USED_MESSAGE),
|
2021-02-01 15:35:28 +01:00
|
|
|
MISSING_ITEM(Setting.NPC_COMMAND_MISSING_ITEM_MESSAGE),
|
2020-10-05 06:18:19 +02:00
|
|
|
MISSING_MONEY(Setting.NPC_COMMAND_NOT_ENOUGH_MONEY_MESSAGE),
|
|
|
|
NO_PERMISSION(Setting.NPC_COMMAND_NO_PERMISSION_MESSAGE),
|
2020-12-16 11:12:37 +01:00
|
|
|
ON_COOLDOWN(Setting.NPC_COMMAND_ON_COOLDOWN_MESSAGE),
|
|
|
|
ON_GLOBAL_COOLDOWN(Setting.NPC_COMMAND_ON_GLOBAL_COOLDOWN_MESSAGE);
|
2020-10-05 06:18:19 +02:00
|
|
|
|
|
|
|
private final Setting setting;
|
|
|
|
|
|
|
|
CommandTraitMessages(Setting setting) {
|
|
|
|
this.setting = setting;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-03 16:59:18 +02:00
|
|
|
public enum ExecutionMode {
|
|
|
|
LINEAR,
|
|
|
|
RANDOM,
|
|
|
|
SEQUENTIAL;
|
|
|
|
}
|
|
|
|
|
2019-10-01 08:16:00 +02:00
|
|
|
public static enum Hand {
|
2020-02-14 15:48:40 +01:00
|
|
|
BOTH,
|
|
|
|
LEFT,
|
|
|
|
RIGHT;
|
2019-09-23 14:29:31 +02:00
|
|
|
}
|
|
|
|
|
2021-02-01 15:35:28 +01:00
|
|
|
@Menu(title = "Drag items for requirements", type = InventoryType.CHEST, dimensions = { 5, 9 })
|
|
|
|
public static class ItemRequirementGUI extends InventoryMenuPage {
|
|
|
|
private Inventory inventory;
|
|
|
|
private int taskId;
|
|
|
|
private CommandTrait trait;
|
|
|
|
|
|
|
|
private ItemRequirementGUI() {
|
|
|
|
throw new UnsupportedOperationException();
|
|
|
|
}
|
|
|
|
|
|
|
|
public ItemRequirementGUI(CommandTrait trait) {
|
|
|
|
this.trait = trait;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void initialise(MenuContext ctx) {
|
|
|
|
this.taskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(CitizensAPI.getPlugin(), this, 0, 1);
|
|
|
|
this.inventory = ctx.getInventory();
|
|
|
|
for (ItemStack stack : trait.itemRequirements) {
|
|
|
|
inventory.addItem(stack.clone());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onClose(HumanEntity player) {
|
|
|
|
Bukkit.getScheduler().cancelTask(taskId);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void run() {
|
|
|
|
List<ItemStack> requirements = Lists.newArrayList();
|
|
|
|
for (ItemStack stack : inventory.getContents()) {
|
|
|
|
if (stack != null && stack.getType() != Material.AIR) {
|
|
|
|
requirements.add(stack);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
this.trait.itemRequirements = requirements;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-23 14:29:31 +02:00
|
|
|
private static class NPCCommand {
|
2020-04-25 13:10:49 +02:00
|
|
|
String bungeeServer;
|
2019-09-23 14:29:31 +02:00
|
|
|
String command;
|
2020-02-22 05:57:03 +01:00
|
|
|
int cooldown;
|
2020-04-30 15:15:24 +02:00
|
|
|
int delay;
|
2020-12-16 11:12:37 +01:00
|
|
|
int globalCooldown;
|
2019-09-23 14:29:31 +02:00
|
|
|
Hand hand;
|
2020-06-10 20:24:03 +02:00
|
|
|
int id;
|
2020-03-03 16:40:42 +01:00
|
|
|
int n;
|
2019-12-29 14:14:38 +01:00
|
|
|
boolean op;
|
2020-03-02 16:40:13 +01:00
|
|
|
List<String> perms;
|
2020-02-22 05:57:03 +01:00
|
|
|
boolean player;
|
2019-09-23 14:29:31 +02:00
|
|
|
|
2020-06-10 20:24:03 +02:00
|
|
|
public NPCCommand(int id, String command, Hand hand, boolean player, boolean op, int cooldown,
|
2020-12-16 11:12:37 +01:00
|
|
|
List<String> perms, int n, int delay, int globalCooldown) {
|
2019-09-23 14:29:31 +02:00
|
|
|
this.id = id;
|
|
|
|
this.command = command;
|
|
|
|
this.hand = hand;
|
2019-12-02 04:27:15 +01:00
|
|
|
this.player = player;
|
2019-12-29 14:14:38 +01:00
|
|
|
this.op = op;
|
2020-02-22 05:57:03 +01:00
|
|
|
this.cooldown = cooldown;
|
2020-03-02 16:40:13 +01:00
|
|
|
this.perms = perms;
|
2020-03-03 16:40:42 +01:00
|
|
|
this.n = n;
|
2020-04-30 15:15:24 +02:00
|
|
|
this.delay = delay;
|
2020-12-16 11:12:37 +01:00
|
|
|
this.globalCooldown = globalCooldown;
|
2020-04-25 13:10:49 +02:00
|
|
|
List<String> split = Splitter.on(' ').omitEmptyStrings().trimResults().splitToList(command);
|
|
|
|
this.bungeeServer = split.size() == 2 && split.get(0).equalsIgnoreCase("server") ? split.get(1) : null;
|
2019-09-23 14:29:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public void run(NPC npc, Player clicker) {
|
2020-01-16 12:40:32 +01:00
|
|
|
String interpolatedCommand = Placeholders.replace(command, clicker, npc);
|
2020-06-12 13:35:30 +02:00
|
|
|
if (Messaging.isDebugging()) {
|
|
|
|
Messaging.debug(
|
|
|
|
"Running command " + interpolatedCommand + " on NPC " + npc.getId() + " clicker " + clicker);
|
|
|
|
}
|
2020-04-30 15:15:24 +02:00
|
|
|
if (!player) {
|
2019-12-02 04:27:15 +01:00
|
|
|
Bukkit.getServer().dispatchCommand(Bukkit.getConsoleSender(), interpolatedCommand);
|
2020-04-30 15:15:24 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
boolean wasOp = clicker.isOp();
|
|
|
|
if (op) {
|
|
|
|
clicker.setOp(true);
|
2019-12-02 04:27:15 +01:00
|
|
|
}
|
2020-04-30 18:40:27 +02:00
|
|
|
|
2020-04-30 15:15:24 +02:00
|
|
|
if (bungeeServer != null) {
|
|
|
|
ByteArrayDataOutput out = ByteStreams.newDataOutput();
|
|
|
|
out.writeUTF("Connect");
|
|
|
|
out.writeUTF(bungeeServer);
|
|
|
|
|
|
|
|
clicker.sendPluginMessage(CitizensAPI.getPlugin(), "BungeeCord", out.toByteArray());
|
2020-04-30 17:45:06 +02:00
|
|
|
} else {
|
|
|
|
try {
|
|
|
|
clicker.chat("/" + interpolatedCommand);
|
|
|
|
} catch (Throwable t) {
|
|
|
|
t.printStackTrace();
|
|
|
|
}
|
2020-04-30 15:15:24 +02:00
|
|
|
}
|
2020-04-30 18:40:27 +02:00
|
|
|
|
2020-04-30 15:15:24 +02:00
|
|
|
if (op) {
|
|
|
|
clicker.setOp(wasOp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public static class NPCCommandBuilder {
|
|
|
|
String command;
|
|
|
|
int cooldown;
|
|
|
|
int delay;
|
2020-12-16 11:12:37 +01:00
|
|
|
private int globalCooldown;
|
2020-04-30 15:15:24 +02:00
|
|
|
Hand hand;
|
|
|
|
int n = -1;
|
|
|
|
boolean op;
|
|
|
|
List<String> perms = Lists.newArrayList();
|
|
|
|
boolean player;
|
|
|
|
|
|
|
|
public NPCCommandBuilder(String command, Hand hand) {
|
|
|
|
this.command = command;
|
|
|
|
this.hand = hand;
|
|
|
|
}
|
|
|
|
|
|
|
|
public NPCCommandBuilder addPerm(String permission) {
|
|
|
|
this.perms.add(permission);
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public NPCCommandBuilder addPerms(List<String> perms) {
|
|
|
|
this.perms.addAll(perms);
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2020-06-10 20:24:03 +02:00
|
|
|
private NPCCommand build(int id) {
|
2020-12-16 11:12:37 +01:00
|
|
|
return new NPCCommand(id, command, hand, player, op, cooldown, perms, n, delay, globalCooldown);
|
2020-04-30 15:15:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public NPCCommandBuilder command(String command) {
|
|
|
|
this.command = command;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public NPCCommandBuilder cooldown(int cooldown) {
|
|
|
|
this.cooldown = cooldown;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public NPCCommandBuilder delay(int delay) {
|
|
|
|
this.delay = delay;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2020-12-16 11:12:37 +01:00
|
|
|
public NPCCommandBuilder globalCooldown(int cooldown) {
|
|
|
|
this.globalCooldown = cooldown;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2020-04-30 15:15:24 +02:00
|
|
|
public NPCCommandBuilder n(int n) {
|
|
|
|
this.n = n;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public NPCCommandBuilder op(boolean op) {
|
|
|
|
this.op = op;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
public NPCCommandBuilder player(boolean player) {
|
|
|
|
this.player = player;
|
|
|
|
return this;
|
2019-09-23 14:29:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private static class NPCCommandPersister implements Persister<NPCCommand> {
|
|
|
|
public NPCCommandPersister() {
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public NPCCommand create(DataKey root) {
|
2020-03-02 16:40:13 +01:00
|
|
|
List<String> perms = Lists.newArrayList();
|
|
|
|
for (DataKey key : root.getRelative("permissions").getIntegerSubKeys()) {
|
|
|
|
perms.add(key.getString(""));
|
|
|
|
}
|
2020-06-10 20:24:03 +02:00
|
|
|
return new NPCCommand(Integer.parseInt(root.name()), root.getString("command"),
|
|
|
|
Hand.valueOf(root.getString("hand")), Boolean.valueOf(root.getString("player")),
|
|
|
|
Boolean.valueOf(root.getString("op")), root.getInt("cooldown"), perms, root.getInt("n"),
|
2020-12-16 11:12:37 +01:00
|
|
|
root.getInt("delay"), root.getInt("globalcooldown"));
|
2019-09-23 14:29:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void save(NPCCommand instance, DataKey root) {
|
|
|
|
root.setString("command", instance.command);
|
|
|
|
root.setString("hand", instance.hand.name());
|
2019-12-02 04:27:15 +01:00
|
|
|
root.setBoolean("player", instance.player);
|
2019-12-29 14:14:38 +01:00
|
|
|
root.setBoolean("op", instance.op);
|
2020-02-22 05:57:03 +01:00
|
|
|
root.setInt("cooldown", instance.cooldown);
|
2020-12-16 11:12:37 +01:00
|
|
|
root.setInt("globalcooldown", instance.globalCooldown);
|
2020-03-03 16:40:42 +01:00
|
|
|
root.setInt("n", instance.n);
|
2020-04-30 15:15:24 +02:00
|
|
|
root.setInt("delay", instance.delay);
|
2020-03-02 16:40:13 +01:00
|
|
|
for (int i = 0; i < instance.perms.size(); i++) {
|
|
|
|
root.setString("permissions." + i, instance.perms.get(i));
|
|
|
|
}
|
2020-02-22 05:57:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private static class PlayerNPCCommand {
|
2020-04-26 06:53:00 +02:00
|
|
|
@Persist(valueType = Long.class)
|
2020-02-22 05:57:03 +01:00
|
|
|
Map<String, Long> lastUsed = Maps.newHashMap();
|
2020-03-03 16:40:42 +01:00
|
|
|
@Persist
|
2021-04-25 06:06:59 +02:00
|
|
|
Hand lastUsedHand;
|
|
|
|
@Persist
|
2020-06-10 20:24:03 +02:00
|
|
|
int lastUsedId = -1;
|
|
|
|
@Persist
|
2020-03-03 16:40:42 +01:00
|
|
|
Map<String, Integer> nUsed = Maps.newHashMap();
|
2020-02-22 05:57:03 +01:00
|
|
|
|
|
|
|
public PlayerNPCCommand() {
|
|
|
|
}
|
|
|
|
|
2020-10-05 06:18:19 +02:00
|
|
|
public boolean canUse(CommandTrait trait, Player player, NPCCommand command) {
|
2020-03-02 16:40:13 +01:00
|
|
|
for (String perm : command.perms) {
|
2020-03-03 16:31:04 +01:00
|
|
|
if (!player.hasPermission(perm)) {
|
2021-03-13 15:17:55 +01:00
|
|
|
trait.sendErrorMessage(player, CommandTraitMessages.NO_PERMISSION, null);
|
2020-03-02 16:40:13 +01:00
|
|
|
return false;
|
2020-03-03 16:31:04 +01:00
|
|
|
}
|
2020-03-02 16:40:13 +01:00
|
|
|
}
|
2020-02-22 05:57:03 +01:00
|
|
|
long currentTimeSec = System.currentTimeMillis() / 1000;
|
2020-08-12 17:40:44 +02:00
|
|
|
String commandKey = BaseEncoding.base64().encode(command.command.getBytes());
|
|
|
|
if (lastUsed.containsKey(commandKey)) {
|
2021-06-13 08:53:19 +02:00
|
|
|
long deadline = ((Number) lastUsed.get(commandKey)).longValue() + command.cooldown;
|
|
|
|
if (currentTimeSec < deadline) {
|
|
|
|
long seconds = deadline - currentTimeSec;
|
2020-10-05 06:18:19 +02:00
|
|
|
trait.sendErrorMessage(player, CommandTraitMessages.ON_COOLDOWN,
|
2021-03-13 15:17:55 +01:00
|
|
|
new TimeVariableFormatter(seconds, TimeUnit.SECONDS), seconds);
|
2020-02-22 05:57:03 +01:00
|
|
|
return false;
|
|
|
|
}
|
2020-08-12 17:40:44 +02:00
|
|
|
lastUsed.remove(commandKey);
|
2020-02-22 05:57:03 +01:00
|
|
|
}
|
2020-12-16 11:12:37 +01:00
|
|
|
if (command.globalCooldown > 0 && trait.globalCooldowns.containsKey(commandKey)) {
|
2021-06-13 08:53:19 +02:00
|
|
|
long deadline = ((Number) trait.globalCooldowns.get(commandKey)).longValue() + command.cooldown;
|
|
|
|
if (currentTimeSec < deadline) {
|
|
|
|
long seconds = deadline - currentTimeSec;
|
2020-12-16 11:12:37 +01:00
|
|
|
trait.sendErrorMessage(player, CommandTraitMessages.ON_GLOBAL_COOLDOWN,
|
2021-03-13 15:17:55 +01:00
|
|
|
new TimeVariableFormatter(seconds, TimeUnit.SECONDS), seconds);
|
2020-12-16 11:12:37 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
trait.globalCooldowns.remove(commandKey);
|
|
|
|
}
|
2020-08-12 17:40:44 +02:00
|
|
|
int previouslyUsed = nUsed.getOrDefault(commandKey, 0);
|
2020-03-03 16:40:42 +01:00
|
|
|
if (command.n > 0 && command.n <= previouslyUsed) {
|
2021-03-13 15:17:55 +01:00
|
|
|
trait.sendErrorMessage(player, CommandTraitMessages.MAXIMUM_TIMES_USED, null, command.n);
|
2020-03-03 16:40:42 +01:00
|
|
|
return false;
|
|
|
|
}
|
2020-02-22 05:57:03 +01:00
|
|
|
if (command.cooldown > 0) {
|
2020-08-12 17:40:44 +02:00
|
|
|
lastUsed.put(commandKey, currentTimeSec);
|
2020-02-22 05:57:03 +01:00
|
|
|
}
|
2020-03-03 16:40:42 +01:00
|
|
|
if (command.n > 0) {
|
2020-08-12 17:40:44 +02:00
|
|
|
nUsed.put(commandKey, previouslyUsed + 1);
|
2020-03-03 16:40:42 +01:00
|
|
|
}
|
2020-12-16 11:12:37 +01:00
|
|
|
if (command.globalCooldown > 0) {
|
|
|
|
trait.globalCooldowns.put(commandKey, currentTimeSec);
|
|
|
|
}
|
2020-06-10 20:24:03 +02:00
|
|
|
lastUsedId = command.id;
|
2020-02-22 05:57:03 +01:00
|
|
|
return true;
|
|
|
|
}
|
2020-06-11 17:31:14 +02:00
|
|
|
|
|
|
|
public static boolean requiresTracking(NPCCommand command) {
|
|
|
|
return command.cooldown > 0 || command.n > 0 || (command.perms != null && command.perms.size() > 0);
|
|
|
|
}
|
2020-02-22 05:57:03 +01:00
|
|
|
}
|
2021-03-13 15:17:55 +01:00
|
|
|
|
|
|
|
private static class TimeVariableFormatter implements Function<String, String> {
|
|
|
|
private final Map<String, String> map = Maps.newHashMapWithExpectedSize(5);
|
|
|
|
|
|
|
|
public TimeVariableFormatter(long source, TimeUnit unit) {
|
|
|
|
long seconds = TimeUnit.SECONDS.convert(source, unit);
|
|
|
|
long minutes = TimeUnit.MINUTES.convert(source, unit);
|
|
|
|
long hours = TimeUnit.HOURS.convert(source, unit);
|
|
|
|
long days = TimeUnit.DAYS.convert(source, unit);
|
|
|
|
map.put("seconds", "" + seconds);
|
|
|
|
map.put("seconds_over", "" + (seconds - TimeUnit.SECONDS.convert(minutes, TimeUnit.MINUTES)));
|
|
|
|
map.put("minutes", "" + minutes);
|
|
|
|
map.put("minutes_over", "" + (minutes - TimeUnit.MINUTES.convert(hours, TimeUnit.HOURS)));
|
|
|
|
map.put("hours", "" + hours);
|
|
|
|
map.put("hours_over", "" + (hours - TimeUnit.HOURS.convert(days, TimeUnit.DAYS)));
|
|
|
|
map.put("days", "" + days);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public String apply(String t) {
|
2021-04-14 13:41:37 +02:00
|
|
|
return StrSubstitutor.replace(t, map, "{", "}");
|
2021-03-13 15:17:55 +01:00
|
|
|
}
|
|
|
|
}
|
2019-09-23 14:29:31 +02:00
|
|
|
}
|