829 lines
34 KiB
Java
829 lines
34 KiB
Java
package net.minecraft.world.inventory;
|
|
|
|
import com.google.common.base.Suppliers;
|
|
import com.google.common.collect.HashBasedTable;
|
|
import com.google.common.collect.Lists;
|
|
import com.google.common.collect.Sets;
|
|
import com.google.common.collect.Table;
|
|
import com.mojang.logging.LogUtils;
|
|
import it.unimi.dsi.fastutil.ints.IntArrayList;
|
|
import it.unimi.dsi.fastutil.ints.IntList;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Optional;
|
|
import java.util.OptionalInt;
|
|
import java.util.Set;
|
|
import java.util.function.Supplier;
|
|
import javax.annotation.Nullable;
|
|
import net.minecraft.CrashReport;
|
|
import net.minecraft.CrashReportCategory;
|
|
import net.minecraft.ReportedException;
|
|
import net.minecraft.core.BlockPos;
|
|
import net.minecraft.core.NonNullList;
|
|
import net.minecraft.core.registries.BuiltInRegistries;
|
|
import net.minecraft.network.HashedStack;
|
|
import net.minecraft.server.level.ServerPlayer;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.world.Container;
|
|
import net.minecraft.world.entity.Entity;
|
|
import net.minecraft.world.entity.SlotAccess;
|
|
import net.minecraft.world.entity.player.Inventory;
|
|
import net.minecraft.world.entity.player.Player;
|
|
import net.minecraft.world.flag.FeatureFlagSet;
|
|
import net.minecraft.world.item.BundleItem;
|
|
import net.minecraft.world.item.ItemStack;
|
|
import net.minecraft.world.level.Level;
|
|
import net.minecraft.world.level.block.Block;
|
|
import net.minecraft.world.level.block.entity.BlockEntity;
|
|
import org.slf4j.Logger;
|
|
|
|
public abstract class AbstractContainerMenu {
|
|
private static final Logger LOGGER = LogUtils.getLogger();
|
|
public static final int SLOT_CLICKED_OUTSIDE = -999;
|
|
public static final int QUICKCRAFT_TYPE_CHARITABLE = 0;
|
|
public static final int QUICKCRAFT_TYPE_GREEDY = 1;
|
|
public static final int QUICKCRAFT_TYPE_CLONE = 2;
|
|
public static final int QUICKCRAFT_HEADER_START = 0;
|
|
public static final int QUICKCRAFT_HEADER_CONTINUE = 1;
|
|
public static final int QUICKCRAFT_HEADER_END = 2;
|
|
public static final int CARRIED_SLOT_SIZE = Integer.MAX_VALUE;
|
|
public static final int SLOTS_PER_ROW = 9;
|
|
public static final int SLOT_SIZE = 18;
|
|
private final NonNullList<ItemStack> lastSlots = NonNullList.create();
|
|
public final NonNullList<Slot> slots = NonNullList.create();
|
|
private final List<DataSlot> dataSlots = Lists.newArrayList();
|
|
private ItemStack carried = ItemStack.EMPTY;
|
|
private final NonNullList<RemoteSlot> remoteSlots = NonNullList.create();
|
|
private final IntList remoteDataSlots = new IntArrayList();
|
|
private RemoteSlot remoteCarried = RemoteSlot.PLACEHOLDER;
|
|
private int stateId;
|
|
@Nullable
|
|
private final MenuType<?> menuType;
|
|
public final int containerId;
|
|
private int quickcraftType = -1;
|
|
private int quickcraftStatus;
|
|
private final Set<Slot> quickcraftSlots = Sets.newHashSet();
|
|
private final List<ContainerListener> containerListeners = Lists.newArrayList();
|
|
@Nullable
|
|
private ContainerSynchronizer synchronizer;
|
|
private boolean suppressRemoteUpdates;
|
|
|
|
protected AbstractContainerMenu(@Nullable MenuType<?> p_38851_, int p_38852_) {
|
|
this.menuType = p_38851_;
|
|
this.containerId = p_38852_;
|
|
}
|
|
|
|
protected void addInventoryHotbarSlots(Container p_368706_, int p_367313_, int p_367317_) {
|
|
for (int i = 0; i < 9; i++) {
|
|
this.addSlot(new Slot(p_368706_, i, p_367313_ + i * 18, p_367317_));
|
|
}
|
|
}
|
|
|
|
protected void addInventoryExtendedSlots(Container p_364073_, int p_361926_, int p_362472_) {
|
|
for (int i = 0; i < 3; i++) {
|
|
for (int j = 0; j < 9; j++) {
|
|
this.addSlot(new Slot(p_364073_, j + (i + 1) * 9, p_361926_ + j * 18, p_362472_ + i * 18));
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void addStandardInventorySlots(Container p_365358_, int p_363774_, int p_366806_) {
|
|
this.addInventoryExtendedSlots(p_365358_, p_363774_, p_366806_);
|
|
int i = 4;
|
|
int j = 58;
|
|
this.addInventoryHotbarSlots(p_365358_, p_363774_, p_366806_ + 58);
|
|
}
|
|
|
|
protected static boolean stillValid(ContainerLevelAccess p_38890_, Player p_38891_, Block p_38892_) {
|
|
return p_38890_.evaluate((p_327069_, p_327070_) -> !p_327069_.getBlockState(p_327070_).is(p_38892_) ? false : p_38891_.canInteractWithBlock(p_327070_, 4.0), true);
|
|
}
|
|
|
|
public MenuType<?> getType() {
|
|
if (this.menuType == null) {
|
|
throw new UnsupportedOperationException("Unable to construct this menu by type");
|
|
} else {
|
|
return this.menuType;
|
|
}
|
|
}
|
|
|
|
protected static void checkContainerSize(Container p_38870_, int p_38871_) {
|
|
int i = p_38870_.getContainerSize();
|
|
if (i < p_38871_) {
|
|
throw new IllegalArgumentException("Container size " + i + " is smaller than expected " + p_38871_);
|
|
}
|
|
}
|
|
|
|
protected static void checkContainerDataCount(ContainerData p_38887_, int p_38888_) {
|
|
int i = p_38887_.getCount();
|
|
if (i < p_38888_) {
|
|
throw new IllegalArgumentException("Container data count " + i + " is smaller than expected " + p_38888_);
|
|
}
|
|
}
|
|
|
|
public boolean isValidSlotIndex(int p_207776_) {
|
|
return p_207776_ == -1 || p_207776_ == -999 || p_207776_ < this.slots.size();
|
|
}
|
|
|
|
protected Slot addSlot(Slot p_38898_) {
|
|
p_38898_.index = this.slots.size();
|
|
this.slots.add(p_38898_);
|
|
this.lastSlots.add(ItemStack.EMPTY);
|
|
this.remoteSlots.add(this.synchronizer != null ? this.synchronizer.createSlot() : RemoteSlot.PLACEHOLDER);
|
|
return p_38898_;
|
|
}
|
|
|
|
protected DataSlot addDataSlot(DataSlot p_38896_) {
|
|
this.dataSlots.add(p_38896_);
|
|
this.remoteDataSlots.add(0);
|
|
return p_38896_;
|
|
}
|
|
|
|
protected void addDataSlots(ContainerData p_38885_) {
|
|
for (int i = 0; i < p_38885_.getCount(); i++) {
|
|
this.addDataSlot(DataSlot.forContainer(p_38885_, i));
|
|
}
|
|
}
|
|
|
|
public void addSlotListener(ContainerListener p_38894_) {
|
|
if (!this.containerListeners.contains(p_38894_)) {
|
|
this.containerListeners.add(p_38894_);
|
|
this.broadcastChanges();
|
|
}
|
|
}
|
|
|
|
public void setSynchronizer(ContainerSynchronizer p_150417_) {
|
|
this.synchronizer = p_150417_;
|
|
this.remoteCarried = p_150417_.createSlot();
|
|
this.remoteSlots.replaceAll(p_390772_ -> p_150417_.createSlot());
|
|
this.sendAllDataToRemote();
|
|
}
|
|
|
|
public void sendAllDataToRemote() {
|
|
List<ItemStack> list = new ArrayList<>(this.slots.size());
|
|
int i = 0;
|
|
|
|
for (int j = this.slots.size(); i < j; i++) {
|
|
ItemStack itemstack = this.slots.get(i).getItem();
|
|
list.add(itemstack.copy());
|
|
this.remoteSlots.get(i).force(itemstack);
|
|
}
|
|
|
|
ItemStack itemstack1 = this.getCarried();
|
|
this.remoteCarried.force(itemstack1);
|
|
int k = 0;
|
|
|
|
for (int l = this.dataSlots.size(); k < l; k++) {
|
|
this.remoteDataSlots.set(k, this.dataSlots.get(k).get());
|
|
}
|
|
|
|
if (this.synchronizer != null) {
|
|
this.synchronizer.sendInitialData(this, list, itemstack1.copy(), this.remoteDataSlots.toIntArray());
|
|
}
|
|
}
|
|
|
|
public void removeSlotListener(ContainerListener p_38944_) {
|
|
this.containerListeners.remove(p_38944_);
|
|
}
|
|
|
|
public NonNullList<ItemStack> getItems() {
|
|
NonNullList<ItemStack> nonnulllist = NonNullList.create();
|
|
|
|
for (Slot slot : this.slots) {
|
|
nonnulllist.add(slot.getItem());
|
|
}
|
|
|
|
return nonnulllist;
|
|
}
|
|
|
|
public void broadcastChanges() {
|
|
for (int i = 0; i < this.slots.size(); i++) {
|
|
ItemStack itemstack = this.slots.get(i).getItem();
|
|
Supplier<ItemStack> supplier = Suppliers.memoize(itemstack::copy);
|
|
this.triggerSlotListeners(i, itemstack, supplier);
|
|
this.synchronizeSlotToRemote(i, itemstack, supplier);
|
|
}
|
|
|
|
this.synchronizeCarriedToRemote();
|
|
|
|
for (int j = 0; j < this.dataSlots.size(); j++) {
|
|
DataSlot dataslot = this.dataSlots.get(j);
|
|
int k = dataslot.get();
|
|
if (dataslot.checkAndClearUpdateFlag()) {
|
|
this.updateDataSlotListeners(j, k);
|
|
}
|
|
|
|
this.synchronizeDataSlotToRemote(j, k);
|
|
}
|
|
}
|
|
|
|
public void broadcastFullState() {
|
|
for (int i = 0; i < this.slots.size(); i++) {
|
|
ItemStack itemstack = this.slots.get(i).getItem();
|
|
this.triggerSlotListeners(i, itemstack, itemstack::copy);
|
|
}
|
|
|
|
for (int j = 0; j < this.dataSlots.size(); j++) {
|
|
DataSlot dataslot = this.dataSlots.get(j);
|
|
if (dataslot.checkAndClearUpdateFlag()) {
|
|
this.updateDataSlotListeners(j, dataslot.get());
|
|
}
|
|
}
|
|
|
|
this.sendAllDataToRemote();
|
|
}
|
|
|
|
private void updateDataSlotListeners(int p_182421_, int p_182422_) {
|
|
for (ContainerListener containerlistener : this.containerListeners) {
|
|
containerlistener.dataChanged(this, p_182421_, p_182422_);
|
|
}
|
|
}
|
|
|
|
private void triggerSlotListeners(int p_150408_, ItemStack p_150409_, Supplier<ItemStack> p_150410_) {
|
|
ItemStack itemstack = this.lastSlots.get(p_150408_);
|
|
if (!ItemStack.matches(itemstack, p_150409_)) {
|
|
ItemStack itemstack1 = p_150410_.get();
|
|
this.lastSlots.set(p_150408_, itemstack1);
|
|
|
|
for (ContainerListener containerlistener : this.containerListeners) {
|
|
containerlistener.slotChanged(this, p_150408_, itemstack1);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void synchronizeSlotToRemote(int p_150436_, ItemStack p_150437_, Supplier<ItemStack> p_150438_) {
|
|
if (!this.suppressRemoteUpdates) {
|
|
RemoteSlot remoteslot = this.remoteSlots.get(p_150436_);
|
|
if (!remoteslot.matches(p_150437_)) {
|
|
remoteslot.force(p_150437_);
|
|
if (this.synchronizer != null) {
|
|
this.synchronizer.sendSlotChange(this, p_150436_, p_150438_.get());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void synchronizeDataSlotToRemote(int p_150441_, int p_150442_) {
|
|
if (!this.suppressRemoteUpdates) {
|
|
int i = this.remoteDataSlots.getInt(p_150441_);
|
|
if (i != p_150442_) {
|
|
this.remoteDataSlots.set(p_150441_, p_150442_);
|
|
if (this.synchronizer != null) {
|
|
this.synchronizer.sendDataChange(this, p_150441_, p_150442_);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void synchronizeCarriedToRemote() {
|
|
if (!this.suppressRemoteUpdates) {
|
|
ItemStack itemstack = this.getCarried();
|
|
if (!this.remoteCarried.matches(itemstack)) {
|
|
this.remoteCarried.force(itemstack);
|
|
if (this.synchronizer != null) {
|
|
this.synchronizer.sendCarriedChange(this, itemstack.copy());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setRemoteSlot(int p_150405_, ItemStack p_150406_) {
|
|
this.remoteSlots.get(p_150405_).force(p_150406_);
|
|
}
|
|
|
|
public void setRemoteSlotUnsafe(int p_392411_, HashedStack p_392993_) {
|
|
if (p_392411_ >= 0 && p_392411_ < this.remoteSlots.size()) {
|
|
this.remoteSlots.get(p_392411_).receive(p_392993_);
|
|
} else {
|
|
LOGGER.debug("Incorrect slot index: {} available slots: {}", p_392411_, this.remoteSlots.size());
|
|
}
|
|
}
|
|
|
|
public void setRemoteCarried(HashedStack p_395611_) {
|
|
this.remoteCarried.receive(p_395611_);
|
|
}
|
|
|
|
public boolean clickMenuButton(Player p_38875_, int p_38876_) {
|
|
return false;
|
|
}
|
|
|
|
public Slot getSlot(int p_38854_) {
|
|
return this.slots.get(p_38854_);
|
|
}
|
|
|
|
public abstract ItemStack quickMoveStack(Player p_38941_, int p_38942_);
|
|
|
|
public void setSelectedBundleItemIndex(int p_361298_, int p_369398_) {
|
|
if (p_361298_ >= 0 && p_361298_ < this.slots.size()) {
|
|
ItemStack itemstack = this.slots.get(p_361298_).getItem();
|
|
BundleItem.toggleSelectedItem(itemstack, p_369398_);
|
|
}
|
|
}
|
|
|
|
public void clicked(int p_150400_, int p_150401_, ClickType p_150402_, Player p_150403_) {
|
|
try {
|
|
this.doClick(p_150400_, p_150401_, p_150402_, p_150403_);
|
|
} catch (Exception exception) {
|
|
CrashReport crashreport = CrashReport.forThrowable(exception, "Container click");
|
|
CrashReportCategory crashreportcategory = crashreport.addCategory("Click info");
|
|
crashreportcategory.setDetail(
|
|
"Menu Type", () -> this.menuType != null ? BuiltInRegistries.MENU.getKey(this.menuType).toString() : "<no type>"
|
|
);
|
|
crashreportcategory.setDetail("Menu Class", () -> this.getClass().getCanonicalName());
|
|
crashreportcategory.setDetail("Slot Count", this.slots.size());
|
|
crashreportcategory.setDetail("Slot", p_150400_);
|
|
crashreportcategory.setDetail("Button", p_150401_);
|
|
crashreportcategory.setDetail("Type", p_150402_);
|
|
throw new ReportedException(crashreport);
|
|
}
|
|
}
|
|
|
|
private void doClick(int p_150431_, int p_150432_, ClickType p_150433_, Player p_150434_) {
|
|
Inventory inventory = p_150434_.getInventory();
|
|
if (p_150433_ == ClickType.QUICK_CRAFT) {
|
|
int i = this.quickcraftStatus;
|
|
this.quickcraftStatus = getQuickcraftHeader(p_150432_);
|
|
if ((i != 1 || this.quickcraftStatus != 2) && i != this.quickcraftStatus) {
|
|
this.resetQuickCraft();
|
|
} else if (this.getCarried().isEmpty()) {
|
|
this.resetQuickCraft();
|
|
} else if (this.quickcraftStatus == 0) {
|
|
this.quickcraftType = getQuickcraftType(p_150432_);
|
|
if (isValidQuickcraftType(this.quickcraftType, p_150434_)) {
|
|
this.quickcraftStatus = 1;
|
|
this.quickcraftSlots.clear();
|
|
} else {
|
|
this.resetQuickCraft();
|
|
}
|
|
} else if (this.quickcraftStatus == 1) {
|
|
Slot slot = this.slots.get(p_150431_);
|
|
ItemStack itemstack = this.getCarried();
|
|
if (canItemQuickReplace(slot, itemstack, true)
|
|
&& slot.mayPlace(itemstack)
|
|
&& (this.quickcraftType == 2 || itemstack.getCount() > this.quickcraftSlots.size())
|
|
&& this.canDragTo(slot)) {
|
|
this.quickcraftSlots.add(slot);
|
|
}
|
|
} else if (this.quickcraftStatus == 2) {
|
|
if (!this.quickcraftSlots.isEmpty()) {
|
|
if (this.quickcraftSlots.size() == 1) {
|
|
int i1 = this.quickcraftSlots.iterator().next().index;
|
|
this.resetQuickCraft();
|
|
this.doClick(i1, this.quickcraftType, ClickType.PICKUP, p_150434_);
|
|
return;
|
|
}
|
|
|
|
ItemStack itemstack3 = this.getCarried().copy();
|
|
if (itemstack3.isEmpty()) {
|
|
this.resetQuickCraft();
|
|
return;
|
|
}
|
|
|
|
int k1 = this.getCarried().getCount();
|
|
|
|
for (Slot slot1 : this.quickcraftSlots) {
|
|
ItemStack itemstack1 = this.getCarried();
|
|
if (slot1 != null
|
|
&& canItemQuickReplace(slot1, itemstack1, true)
|
|
&& slot1.mayPlace(itemstack1)
|
|
&& (this.quickcraftType == 2 || itemstack1.getCount() >= this.quickcraftSlots.size())
|
|
&& this.canDragTo(slot1)) {
|
|
int j = slot1.hasItem() ? slot1.getItem().getCount() : 0;
|
|
int k = Math.min(itemstack3.getMaxStackSize(), slot1.getMaxStackSize(itemstack3));
|
|
int l = Math.min(getQuickCraftPlaceCount(this.quickcraftSlots, this.quickcraftType, itemstack3) + j, k);
|
|
k1 -= l - j;
|
|
slot1.setByPlayer(itemstack3.copyWithCount(l));
|
|
}
|
|
}
|
|
|
|
itemstack3.setCount(k1);
|
|
this.setCarried(itemstack3);
|
|
}
|
|
|
|
this.resetQuickCraft();
|
|
} else {
|
|
this.resetQuickCraft();
|
|
}
|
|
} else if (this.quickcraftStatus != 0) {
|
|
this.resetQuickCraft();
|
|
} else if ((p_150433_ == ClickType.PICKUP || p_150433_ == ClickType.QUICK_MOVE) && (p_150432_ == 0 || p_150432_ == 1)) {
|
|
ClickAction clickaction = p_150432_ == 0 ? ClickAction.PRIMARY : ClickAction.SECONDARY;
|
|
if (p_150431_ == -999) {
|
|
if (!this.getCarried().isEmpty()) {
|
|
if (clickaction == ClickAction.PRIMARY) {
|
|
p_150434_.drop(this.getCarried(), true);
|
|
this.setCarried(ItemStack.EMPTY);
|
|
} else {
|
|
p_150434_.drop(this.getCarried().split(1), true);
|
|
}
|
|
}
|
|
} else if (p_150433_ == ClickType.QUICK_MOVE) {
|
|
if (p_150431_ < 0) {
|
|
return;
|
|
}
|
|
|
|
Slot slot6 = this.slots.get(p_150431_);
|
|
if (!slot6.mayPickup(p_150434_)) {
|
|
return;
|
|
}
|
|
|
|
ItemStack itemstack8 = this.quickMoveStack(p_150434_, p_150431_);
|
|
|
|
while (!itemstack8.isEmpty() && ItemStack.isSameItem(slot6.getItem(), itemstack8)) {
|
|
itemstack8 = this.quickMoveStack(p_150434_, p_150431_);
|
|
}
|
|
} else {
|
|
if (p_150431_ < 0) {
|
|
return;
|
|
}
|
|
|
|
Slot slot7 = this.slots.get(p_150431_);
|
|
ItemStack itemstack9 = slot7.getItem();
|
|
ItemStack itemstack10 = this.getCarried();
|
|
p_150434_.updateTutorialInventoryAction(itemstack10, slot7.getItem(), clickaction);
|
|
if (!this.tryItemClickBehaviourOverride(p_150434_, clickaction, slot7, itemstack9, itemstack10)) {
|
|
if (itemstack9.isEmpty()) {
|
|
if (!itemstack10.isEmpty()) {
|
|
int i3 = clickaction == ClickAction.PRIMARY ? itemstack10.getCount() : 1;
|
|
this.setCarried(slot7.safeInsert(itemstack10, i3));
|
|
}
|
|
} else if (slot7.mayPickup(p_150434_)) {
|
|
if (itemstack10.isEmpty()) {
|
|
int j3 = clickaction == ClickAction.PRIMARY ? itemstack9.getCount() : (itemstack9.getCount() + 1) / 2;
|
|
Optional<ItemStack> optional1 = slot7.tryRemove(j3, Integer.MAX_VALUE, p_150434_);
|
|
optional1.ifPresent(p_150421_ -> {
|
|
this.setCarried(p_150421_);
|
|
slot7.onTake(p_150434_, p_150421_);
|
|
});
|
|
} else if (slot7.mayPlace(itemstack10)) {
|
|
if (ItemStack.isSameItemSameComponents(itemstack9, itemstack10)) {
|
|
int k3 = clickaction == ClickAction.PRIMARY ? itemstack10.getCount() : 1;
|
|
this.setCarried(slot7.safeInsert(itemstack10, k3));
|
|
} else if (itemstack10.getCount() <= slot7.getMaxStackSize(itemstack10)) {
|
|
this.setCarried(itemstack9);
|
|
slot7.setByPlayer(itemstack10);
|
|
}
|
|
} else if (ItemStack.isSameItemSameComponents(itemstack9, itemstack10)) {
|
|
Optional<ItemStack> optional = slot7.tryRemove(itemstack9.getCount(), itemstack10.getMaxStackSize() - itemstack10.getCount(), p_150434_);
|
|
optional.ifPresent(p_150428_ -> {
|
|
itemstack10.grow(p_150428_.getCount());
|
|
slot7.onTake(p_150434_, p_150428_);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
slot7.setChanged();
|
|
}
|
|
} else if (p_150433_ == ClickType.SWAP && (p_150432_ >= 0 && p_150432_ < 9 || p_150432_ == 40)) {
|
|
ItemStack itemstack2 = inventory.getItem(p_150432_);
|
|
Slot slot5 = this.slots.get(p_150431_);
|
|
ItemStack itemstack7 = slot5.getItem();
|
|
if (!itemstack2.isEmpty() || !itemstack7.isEmpty()) {
|
|
if (itemstack2.isEmpty()) {
|
|
if (slot5.mayPickup(p_150434_)) {
|
|
inventory.setItem(p_150432_, itemstack7);
|
|
slot5.onSwapCraft(itemstack7.getCount());
|
|
slot5.setByPlayer(ItemStack.EMPTY);
|
|
slot5.onTake(p_150434_, itemstack7);
|
|
}
|
|
} else if (itemstack7.isEmpty()) {
|
|
if (slot5.mayPlace(itemstack2)) {
|
|
int j2 = slot5.getMaxStackSize(itemstack2);
|
|
if (itemstack2.getCount() > j2) {
|
|
slot5.setByPlayer(itemstack2.split(j2));
|
|
} else {
|
|
inventory.setItem(p_150432_, ItemStack.EMPTY);
|
|
slot5.setByPlayer(itemstack2);
|
|
}
|
|
}
|
|
} else if (slot5.mayPickup(p_150434_) && slot5.mayPlace(itemstack2)) {
|
|
int k2 = slot5.getMaxStackSize(itemstack2);
|
|
if (itemstack2.getCount() > k2) {
|
|
slot5.setByPlayer(itemstack2.split(k2));
|
|
slot5.onTake(p_150434_, itemstack7);
|
|
if (!inventory.add(itemstack7)) {
|
|
p_150434_.drop(itemstack7, true);
|
|
}
|
|
} else {
|
|
inventory.setItem(p_150432_, itemstack7);
|
|
slot5.setByPlayer(itemstack2);
|
|
slot5.onTake(p_150434_, itemstack7);
|
|
}
|
|
}
|
|
}
|
|
} else if (p_150433_ == ClickType.CLONE && p_150434_.hasInfiniteMaterials() && this.getCarried().isEmpty() && p_150431_ >= 0) {
|
|
Slot slot4 = this.slots.get(p_150431_);
|
|
if (slot4.hasItem()) {
|
|
ItemStack itemstack5 = slot4.getItem();
|
|
this.setCarried(itemstack5.copyWithCount(itemstack5.getMaxStackSize()));
|
|
}
|
|
} else if (p_150433_ == ClickType.THROW && this.getCarried().isEmpty() && p_150431_ >= 0) {
|
|
Slot slot3 = this.slots.get(p_150431_);
|
|
int j1 = p_150432_ == 0 ? 1 : slot3.getItem().getCount();
|
|
if (!p_150434_.canDropItems()) {
|
|
return;
|
|
}
|
|
|
|
ItemStack itemstack6 = slot3.safeTake(j1, Integer.MAX_VALUE, p_150434_);
|
|
p_150434_.drop(itemstack6, true);
|
|
p_150434_.handleCreativeModeItemDrop(itemstack6);
|
|
if (p_150432_ == 1) {
|
|
while (!itemstack6.isEmpty() && ItemStack.isSameItem(slot3.getItem(), itemstack6)) {
|
|
if (!p_150434_.canDropItems()) {
|
|
return;
|
|
}
|
|
|
|
itemstack6 = slot3.safeTake(j1, Integer.MAX_VALUE, p_150434_);
|
|
p_150434_.drop(itemstack6, true);
|
|
p_150434_.handleCreativeModeItemDrop(itemstack6);
|
|
}
|
|
}
|
|
} else if (p_150433_ == ClickType.PICKUP_ALL && p_150431_ >= 0) {
|
|
Slot slot2 = this.slots.get(p_150431_);
|
|
ItemStack itemstack4 = this.getCarried();
|
|
if (!itemstack4.isEmpty() && (!slot2.hasItem() || !slot2.mayPickup(p_150434_))) {
|
|
int l1 = p_150432_ == 0 ? 0 : this.slots.size() - 1;
|
|
int i2 = p_150432_ == 0 ? 1 : -1;
|
|
|
|
for (int l2 = 0; l2 < 2; l2++) {
|
|
for (int l3 = l1; l3 >= 0 && l3 < this.slots.size() && itemstack4.getCount() < itemstack4.getMaxStackSize(); l3 += i2) {
|
|
Slot slot8 = this.slots.get(l3);
|
|
if (slot8.hasItem() && canItemQuickReplace(slot8, itemstack4, true) && slot8.mayPickup(p_150434_) && this.canTakeItemForPickAll(itemstack4, slot8)) {
|
|
ItemStack itemstack11 = slot8.getItem();
|
|
if (l2 != 0 || itemstack11.getCount() != itemstack11.getMaxStackSize()) {
|
|
ItemStack itemstack12 = slot8.safeTake(itemstack11.getCount(), itemstack4.getMaxStackSize() - itemstack4.getCount(), p_150434_);
|
|
itemstack4.grow(itemstack12.getCount());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean tryItemClickBehaviourOverride(Player p_249615_, ClickAction p_250300_, Slot p_249384_, ItemStack p_251073_, ItemStack p_252026_) {
|
|
FeatureFlagSet featureflagset = p_249615_.level().enabledFeatures();
|
|
return p_252026_.isItemEnabled(featureflagset) && p_252026_.overrideStackedOnOther(p_249384_, p_250300_, p_249615_)
|
|
? true
|
|
: p_251073_.isItemEnabled(featureflagset) && p_251073_.overrideOtherStackedOnMe(p_252026_, p_249384_, p_250300_, p_249615_, this.createCarriedSlotAccess());
|
|
}
|
|
|
|
private SlotAccess createCarriedSlotAccess() {
|
|
return new SlotAccess() {
|
|
@Override
|
|
public ItemStack get() {
|
|
return AbstractContainerMenu.this.getCarried();
|
|
}
|
|
|
|
@Override
|
|
public boolean set(ItemStack p_150452_) {
|
|
AbstractContainerMenu.this.setCarried(p_150452_);
|
|
return true;
|
|
}
|
|
};
|
|
}
|
|
|
|
public boolean canTakeItemForPickAll(ItemStack p_38908_, Slot p_38909_) {
|
|
return true;
|
|
}
|
|
|
|
public void removed(Player p_38940_) {
|
|
if (p_38940_ instanceof ServerPlayer) {
|
|
ItemStack itemstack = this.getCarried();
|
|
if (!itemstack.isEmpty()) {
|
|
dropOrPlaceInInventory(p_38940_, itemstack);
|
|
this.setCarried(ItemStack.EMPTY);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void dropOrPlaceInInventory(Player p_364172_, ItemStack p_363234_) {
|
|
boolean flag = p_364172_.isRemoved() && p_364172_.getRemovalReason() != Entity.RemovalReason.CHANGED_DIMENSION;
|
|
boolean flag1 = p_364172_ instanceof ServerPlayer serverplayer && serverplayer.hasDisconnected();
|
|
if (flag || flag1) {
|
|
p_364172_.drop(p_363234_, false);
|
|
} else if (p_364172_ instanceof ServerPlayer) {
|
|
p_364172_.getInventory().placeItemBackInInventory(p_363234_);
|
|
}
|
|
}
|
|
|
|
protected void clearContainer(Player p_150412_, Container p_150413_) {
|
|
for (int i = 0; i < p_150413_.getContainerSize(); i++) {
|
|
dropOrPlaceInInventory(p_150412_, p_150413_.removeItemNoUpdate(i));
|
|
}
|
|
}
|
|
|
|
public void slotsChanged(Container p_38868_) {
|
|
this.broadcastChanges();
|
|
}
|
|
|
|
public void setItem(int p_182407_, int p_182408_, ItemStack p_182409_) {
|
|
this.getSlot(p_182407_).set(p_182409_);
|
|
this.stateId = p_182408_;
|
|
}
|
|
|
|
public void initializeContents(int p_182411_, List<ItemStack> p_182412_, ItemStack p_182413_) {
|
|
for (int i = 0; i < p_182412_.size(); i++) {
|
|
this.getSlot(i).set(p_182412_.get(i));
|
|
}
|
|
|
|
this.carried = p_182413_;
|
|
this.stateId = p_182411_;
|
|
}
|
|
|
|
public void setData(int p_38855_, int p_38856_) {
|
|
this.dataSlots.get(p_38855_).set(p_38856_);
|
|
}
|
|
|
|
public abstract boolean stillValid(Player p_38874_);
|
|
|
|
protected boolean moveItemStackTo(ItemStack p_38904_, int p_38905_, int p_38906_, boolean p_38907_) {
|
|
boolean flag = false;
|
|
int i = p_38905_;
|
|
if (p_38907_) {
|
|
i = p_38906_ - 1;
|
|
}
|
|
|
|
if (p_38904_.isStackable()) {
|
|
while (!p_38904_.isEmpty() && (p_38907_ ? i >= p_38905_ : i < p_38906_)) {
|
|
Slot slot = this.slots.get(i);
|
|
ItemStack itemstack = slot.getItem();
|
|
if (!itemstack.isEmpty() && ItemStack.isSameItemSameComponents(p_38904_, itemstack)) {
|
|
int j = itemstack.getCount() + p_38904_.getCount();
|
|
int k = slot.getMaxStackSize(itemstack);
|
|
if (j <= k) {
|
|
p_38904_.setCount(0);
|
|
itemstack.setCount(j);
|
|
slot.setChanged();
|
|
flag = true;
|
|
} else if (itemstack.getCount() < k) {
|
|
p_38904_.shrink(k - itemstack.getCount());
|
|
itemstack.setCount(k);
|
|
slot.setChanged();
|
|
flag = true;
|
|
}
|
|
}
|
|
|
|
if (p_38907_) {
|
|
i--;
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!p_38904_.isEmpty()) {
|
|
if (p_38907_) {
|
|
i = p_38906_ - 1;
|
|
} else {
|
|
i = p_38905_;
|
|
}
|
|
|
|
while (p_38907_ ? i >= p_38905_ : i < p_38906_) {
|
|
Slot slot1 = this.slots.get(i);
|
|
ItemStack itemstack1 = slot1.getItem();
|
|
if (itemstack1.isEmpty() && slot1.mayPlace(p_38904_)) {
|
|
int l = slot1.getMaxStackSize(p_38904_);
|
|
slot1.setByPlayer(p_38904_.split(Math.min(p_38904_.getCount(), l)));
|
|
slot1.setChanged();
|
|
flag = true;
|
|
break;
|
|
}
|
|
|
|
if (p_38907_) {
|
|
i--;
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return flag;
|
|
}
|
|
|
|
public static int getQuickcraftType(int p_38929_) {
|
|
return p_38929_ >> 2 & 3;
|
|
}
|
|
|
|
public static int getQuickcraftHeader(int p_38948_) {
|
|
return p_38948_ & 3;
|
|
}
|
|
|
|
public static int getQuickcraftMask(int p_38931_, int p_38932_) {
|
|
return p_38931_ & 3 | (p_38932_ & 3) << 2;
|
|
}
|
|
|
|
public static boolean isValidQuickcraftType(int p_38863_, Player p_38864_) {
|
|
if (p_38863_ == 0) {
|
|
return true;
|
|
} else {
|
|
return p_38863_ == 1 ? true : p_38863_ == 2 && p_38864_.hasInfiniteMaterials();
|
|
}
|
|
}
|
|
|
|
protected void resetQuickCraft() {
|
|
this.quickcraftStatus = 0;
|
|
this.quickcraftSlots.clear();
|
|
}
|
|
|
|
public static boolean canItemQuickReplace(@Nullable Slot p_38900_, ItemStack p_38901_, boolean p_38902_) {
|
|
boolean flag = p_38900_ == null || !p_38900_.hasItem();
|
|
return !flag && ItemStack.isSameItemSameComponents(p_38901_, p_38900_.getItem())
|
|
? p_38900_.getItem().getCount() + (p_38902_ ? 0 : p_38901_.getCount()) <= p_38901_.getMaxStackSize()
|
|
: flag;
|
|
}
|
|
|
|
public static int getQuickCraftPlaceCount(Set<Slot> p_279393_, int p_279288_, ItemStack p_279172_) {
|
|
return switch (p_279288_) {
|
|
case 0 -> Mth.floor((float)p_279172_.getCount() / p_279393_.size());
|
|
case 1 -> 1;
|
|
case 2 -> p_279172_.getMaxStackSize();
|
|
default -> p_279172_.getCount();
|
|
};
|
|
}
|
|
|
|
public boolean canDragTo(Slot p_38945_) {
|
|
return true;
|
|
}
|
|
|
|
public static int getRedstoneSignalFromBlockEntity(@Nullable BlockEntity p_38919_) {
|
|
return p_38919_ instanceof Container ? getRedstoneSignalFromContainer((Container)p_38919_) : 0;
|
|
}
|
|
|
|
public static int getRedstoneSignalFromContainer(@Nullable Container p_38939_) {
|
|
if (p_38939_ == null) {
|
|
return 0;
|
|
} else {
|
|
float f = 0.0F;
|
|
|
|
for (int i = 0; i < p_38939_.getContainerSize(); i++) {
|
|
ItemStack itemstack = p_38939_.getItem(i);
|
|
if (!itemstack.isEmpty()) {
|
|
f += (float)itemstack.getCount() / p_38939_.getMaxStackSize(itemstack);
|
|
}
|
|
}
|
|
|
|
f /= p_38939_.getContainerSize();
|
|
return Mth.lerpDiscrete(f, 0, 15);
|
|
}
|
|
}
|
|
|
|
public void setCarried(ItemStack p_150439_) {
|
|
this.carried = p_150439_;
|
|
}
|
|
|
|
public ItemStack getCarried() {
|
|
return this.carried;
|
|
}
|
|
|
|
public void suppressRemoteUpdates() {
|
|
this.suppressRemoteUpdates = true;
|
|
}
|
|
|
|
public void resumeRemoteUpdates() {
|
|
this.suppressRemoteUpdates = false;
|
|
}
|
|
|
|
public void transferState(AbstractContainerMenu p_150415_) {
|
|
Table<Container, Integer, Integer> table = HashBasedTable.create();
|
|
|
|
for (int i = 0; i < p_150415_.slots.size(); i++) {
|
|
Slot slot = p_150415_.slots.get(i);
|
|
table.put(slot.container, slot.getContainerSlot(), i);
|
|
}
|
|
|
|
for (int j = 0; j < this.slots.size(); j++) {
|
|
Slot slot1 = this.slots.get(j);
|
|
Integer integer = table.get(slot1.container, slot1.getContainerSlot());
|
|
if (integer != null) {
|
|
this.lastSlots.set(j, p_150415_.lastSlots.get(integer));
|
|
RemoteSlot remoteslot = p_150415_.remoteSlots.get(integer);
|
|
RemoteSlot remoteslot1 = this.remoteSlots.get(j);
|
|
if (remoteslot instanceof RemoteSlot.Synchronized remoteslot$synchronized
|
|
&& remoteslot1 instanceof RemoteSlot.Synchronized remoteslot$synchronized1) {
|
|
remoteslot$synchronized1.copyFrom(remoteslot$synchronized);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public OptionalInt findSlot(Container p_182418_, int p_182419_) {
|
|
for (int i = 0; i < this.slots.size(); i++) {
|
|
Slot slot = this.slots.get(i);
|
|
if (slot.container == p_182418_ && p_182419_ == slot.getContainerSlot()) {
|
|
return OptionalInt.of(i);
|
|
}
|
|
}
|
|
|
|
return OptionalInt.empty();
|
|
}
|
|
|
|
public int getStateId() {
|
|
return this.stateId;
|
|
}
|
|
|
|
public int incrementStateId() {
|
|
this.stateId = this.stateId + 1 & 32767;
|
|
return this.stateId;
|
|
}
|
|
} |