Files
src
build.gradle.kts
settings.gradle.kts
Code
8 692
src/main/java/me/ofrocha/bigbundle/BigBundlePlugin.java
package me.ofrocha.bigbundle;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.PrepareSmithingEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.RecipeChoice;
import org.bukkit.inventory.SmithingTransformRecipe;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.inventory.EquipmentSlot;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public final class BigBundlePlugin extends JavaPlugin {
private final Map<UUID, BundleSession> sessionsByPlayer = new HashMap<>();
private final Map<UUID, BundleSession> sessionsByBundle = new HashMap<>();
private BigBundleItem itemData;
private NamespacedKey recipeKey;
@Override
public void onEnable() {
itemData = new BigBundleItem(this);
recipeKey = new NamespacedKey(this, "big_bundle");
registerRecipe();
getServer().getPluginManager().registerEvents(new BigBundleListener(this), this);
}
@Override
public void onDisable() {
for (BundleSession session : new ArrayList<>(sessionsByPlayer.values())) {
closeSession(session);
}
sessionsByBundle.clear();
}
private void registerRecipe() {
Bukkit.removeRecipe(recipeKey);
Material chest = material("CHEST");
Material bundle = material("BUNDLE");
Material leather = material("LEATHER");
SmithingTransformRecipe recipe = new SmithingTransformRecipe(
recipeKey,
itemData.create(),
new RecipeChoice.MaterialChoice(chest),
new RecipeChoice.MaterialChoice(bundle),
new RecipeChoice.MaterialChoice(leather)
);
Bukkit.addRecipe(recipe);
}
private Material material(String name) {
Material material = Material.matchMaterial(name);
if (material == null) {
throw new IllegalStateException("Missing required material: " + name);
}
return material;
}
public BigBundleItem itemData() {
return itemData;
}
public void prepareSmithingResult(PrepareSmithingEvent event) {
ItemStack result = event.getInventory().getResult();
if (itemData.isBigBundle(result)) {
event.setResult(itemData.create());
}
}
public void openBundle(Player player, EquipmentSlot hand) {
if (sessionsByPlayer.containsKey(player.getUniqueId())) {
return;
}
int sourceSlot = hand == EquipmentSlot.OFF_HAND ? 40 : player.getInventory().getHeldItemSlot();
ItemStack source = player.getInventory().getItem(sourceSlot);
UUID bundleId = itemData.getBundleId(source);
if (bundleId == null || source.getAmount() != 1 || sessionsByBundle.containsKey(bundleId)) {
return;
}
ItemStack[] contents = itemData.readContents(source);
for (ItemStack content : contents) {
if (itemData.isBigBundle(content)) {
getLogger().warning("Refused to open corrupted nested Big Bundle " + bundleId);
return;
}
}
BigBundleGUI gui = new BigBundleGUI(bundleId);
gui.load(contents);
BundleSession session = new BundleSession(this, player, sourceSlot, hand, bundleId, gui, contents);
sessionsByPlayer.put(player.getUniqueId(), session);
sessionsByBundle.put(bundleId, session);
player.openInventory(gui.getInventory());
}
BundleSession sessionFor(Player player) {
return sessionsByPlayer.get(player.getUniqueId());
}
void closeSession(BundleSession session) {
if (sessionsByPlayer.remove(session.playerId, session)) {
sessionsByBundle.remove(session.bundleId, session);
session.finish();
}
}
public static final class BundleSession {
private final BigBundlePlugin plugin;
private final Player player;
private final UUID playerId;
private final int sourceSlot;
private final EquipmentSlot hand;
private final UUID bundleId;
private final BigBundleGUI gui;
private final ItemStack[] initialContents;
private BundleSession(BigBundlePlugin plugin, Player player, int sourceSlot, EquipmentSlot hand,
UUID bundleId, BigBundleGUI gui, ItemStack[] initialContents) {
this.plugin = plugin;
this.player = player;
this.playerId = player.getUniqueId();
this.sourceSlot = sourceSlot;
this.hand = hand;
this.bundleId = bundleId;
this.gui = gui;
this.initialContents = cloneContents(initialContents);
}
public Player player() {
return player;
}
public int sourceSlot() {
return sourceSlot;
}
public EquipmentSlot hand() {
return hand;
}
public UUID bundleId() {
return bundleId;
}
public BigBundleGUI gui() {
return gui;
}
public boolean isSource(ItemStack item) {
return item != null && item.getAmount() == 1 && bundleId.equals(plugin.itemData().getBundleId(item));
}
private void finish() {
ItemStack[] contents = gui.contents();
ItemStack source = player.getInventory().getItem(sourceSlot);
boolean saved = isSource(source) && plugin.itemData().writeContents(source, contents);
if (!saved) {
int uniqueSlot = findUniqueBundleSlot();
if (uniqueSlot >= 0) {
ItemStack movedSource = player.getInventory().getItem(uniqueSlot);
saved = plugin.itemData().writeContents(movedSource, contents);
}
}
if (!saved) {
recoverOnlyNewContents(contents);
plugin.getLogger().warning("Could not verify Big Bundle " + bundleId
+ " for player " + playerId + "; recovered only newly-added GUI contents.");
}
gui.clear();
}
private int findUniqueBundleSlot() {
int found = -1;
for (int slot = 0; slot < player.getInventory().getSize(); slot++) {
if (!isSource(player.getInventory().getItem(slot))) {
continue;
}
if (found >= 0) {
return -1;
}
found = slot;
}
return found;
}
private void recoverOnlyNewContents(ItemStack[] contents) {
ArrayList<ItemStack> remainingOriginal = new ArrayList<>();
for (ItemStack original : initialContents) {
if (original != null && !original.getType().isAir() && original.getAmount() > 0) {