mirror of
https://github.com/GTNewHorizons/WirelessCraftingTerminal.git
synced 2026-11-18 03:15:15 +00:00
498 lines
14 KiB
Java
498 lines
14 KiB
Java
package net.p455w0rd.wirelesscraftingterminal.common.container;
|
|
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.Set;
|
|
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.entity.player.InventoryPlayer;
|
|
import net.minecraft.inventory.Container;
|
|
import net.minecraft.inventory.Slot;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.util.MathHelper;
|
|
import net.minecraftforge.oredict.OreDictionary;
|
|
import net.p455w0rd.wirelesscraftingterminal.common.container.slot.SlotMagnetFilter;
|
|
import net.p455w0rd.wirelesscraftingterminal.common.inventory.WCTInventoryMagnetFilter;
|
|
import net.p455w0rd.wirelesscraftingterminal.common.utils.RandomUtils;
|
|
|
|
public class ContainerMagnet extends Container {
|
|
|
|
public final InventoryPlayer inventoryPlayer;
|
|
public ItemStack heldItem;
|
|
public WCTInventoryMagnetFilter magnetInventory;
|
|
private int distributeState = 0;
|
|
private int pressedKeyInRange = -1;
|
|
@SuppressWarnings("rawtypes")
|
|
private final Set distributeSlotSet = new HashSet();
|
|
private final int PLAYER_INV_START = 0, PLAYER_INV_END = 26, HOTBAR_START = 27, HOTBAR_END = 35, FILTERS_START = 36,
|
|
FILTERS_END = 62;
|
|
|
|
public ContainerMagnet(EntityPlayer player, InventoryPlayer inventoryPlayer) {
|
|
this.inventoryPlayer = inventoryPlayer;
|
|
this.heldItem = RandomUtils.getMagnet(inventoryPlayer);
|
|
this.magnetInventory = new WCTInventoryMagnetFilter(heldItem);
|
|
|
|
// Add player inventory slots
|
|
for (int i = 0; i < 3; ++i) {
|
|
for (int j = 0; j < 9; ++j) {
|
|
this.addSlotToContainer(new Slot(this.inventoryPlayer, j + i * 9 + 9, j * 18 + 8, 86 + i * 18));
|
|
}
|
|
}
|
|
|
|
// Add hotbar slots
|
|
for (int i = 0; i < 9; ++i) {
|
|
this.addSlotToContainer(new Slot(this.inventoryPlayer, i, i * 18 + 8, 144));
|
|
}
|
|
|
|
// Add filter slots
|
|
for (int i = 0; i < 3; i++) {
|
|
for (int j = 0; j < 9; j++) {
|
|
this.addSlotToContainer(new SlotMagnetFilter(this.magnetInventory, j + i * 9, j * 18 + 8, 18 + i * 18));
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean isInHotbar(int slotNum) {
|
|
return (slotNum >= HOTBAR_START) && (slotNum <= HOTBAR_END);
|
|
}
|
|
|
|
private boolean isInPlayerInventory(int slotNum) {
|
|
return (slotNum >= PLAYER_INV_START) && (slotNum <= PLAYER_INV_END);
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
private boolean isInFilters(int slotNum) {
|
|
return (slotNum >= FILTERS_START) && (slotNum <= FILTERS_END);
|
|
}
|
|
|
|
@Override
|
|
public boolean canInteractWith(EntityPlayer p) {
|
|
return true;
|
|
}
|
|
|
|
private boolean alreadyFiltered(ItemStack item) {
|
|
for (int i = 0; i < magnetInventory.getSizeInventory(); i++) {
|
|
if (isIdenticalItem(item, magnetInventory.getStackInSlot(i))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@SuppressWarnings({ "unchecked", "rawtypes" })
|
|
@Override
|
|
public ItemStack slotClick(int slotNum, int mouseButton, int modifier, EntityPlayer player) {
|
|
if (slotNum >= this.inventorySlots.size()) {
|
|
return null;
|
|
}
|
|
InventoryPlayer inventoryplayer = player.inventory;
|
|
ItemStack itemstack3;
|
|
ItemStack stack = null;
|
|
int sizeOrID;
|
|
if (slotNum == -999) {
|
|
|
|
if (inventoryplayer.getItemStack() != null && slotNum == -999) {
|
|
if (mouseButton == 0) {
|
|
player.dropPlayerItemWithRandomChoice(inventoryplayer.getItemStack(), true);
|
|
inventoryplayer.setItemStack((ItemStack) null);
|
|
}
|
|
|
|
if (mouseButton == 1) {
|
|
player.dropPlayerItemWithRandomChoice(inventoryplayer.getItemStack().splitStack(1), true);
|
|
|
|
if (inventoryplayer.getItemStack().stackSize == 0) {
|
|
inventoryplayer.setItemStack((ItemStack) null);
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
//Click+drag stack
|
|
else if (modifier == 5) {
|
|
//if (isInFilters(slotNum)) {
|
|
// return null;
|
|
//}
|
|
int currentDistributeState = this.distributeState;
|
|
this.distributeState = checkForPressedButton(mouseButton);
|
|
|
|
if ((currentDistributeState != 1 || this.distributeState != 2) && currentDistributeState != this.distributeState) {
|
|
this.resetDistributionVariables();
|
|
}
|
|
else if (inventoryplayer.getItemStack() == null) {
|
|
this.resetDistributionVariables();
|
|
}
|
|
else if (this.distributeState == 0) {
|
|
this.pressedKeyInRange = checkForPressedButton2(mouseButton);
|
|
|
|
if (checkValue(this.pressedKeyInRange)) {
|
|
this.distributeState = 1;
|
|
this.distributeSlotSet.clear();
|
|
}
|
|
else {
|
|
this.resetDistributionVariables();
|
|
}
|
|
}
|
|
else if (this.distributeState == 1) {
|
|
Slot slot = (Slot) this.inventorySlots.get(slotNum);
|
|
|
|
if (slot != null && stackFitsInSlot(slot, inventoryplayer.getItemStack(), true) && slot.isItemValid(inventoryplayer.getItemStack()) && inventoryplayer.getItemStack().stackSize > this.distributeSlotSet.size() && this.canDragIntoSlot(slot)) {
|
|
this.distributeSlotSet.add(slot);
|
|
}
|
|
}
|
|
else if (this.distributeState == 2) {
|
|
if (!this.distributeSlotSet.isEmpty()) {
|
|
itemstack3 = inventoryplayer.getItemStack().copy();
|
|
sizeOrID = inventoryplayer.getItemStack().stackSize;
|
|
Iterator iterator = this.distributeSlotSet.iterator();
|
|
|
|
while (iterator.hasNext()) {
|
|
Slot slot1 = (Slot) iterator.next();
|
|
|
|
if (slot1 != null && stackFitsInSlot(slot1, inventoryplayer.getItemStack(), true) && slot1.isItemValid(inventoryplayer.getItemStack()) && inventoryplayer.getItemStack().stackSize >= this.distributeSlotSet.size() && this.canDragIntoSlot(slot1)) {
|
|
ItemStack itemstack1 = itemstack3.copy();
|
|
int j1 = slot1.getHasStack() ? slot1.getStack().stackSize : 0;
|
|
setSlotStack(this.distributeSlotSet, this.pressedKeyInRange, itemstack1, j1);
|
|
|
|
if (itemstack1.stackSize > itemstack1.getMaxStackSize()) {
|
|
itemstack1.stackSize = itemstack1.getMaxStackSize();
|
|
}
|
|
|
|
if (itemstack1.stackSize > slot1.getSlotStackLimit()) {
|
|
itemstack1.stackSize = slot1.getSlotStackLimit();
|
|
}
|
|
|
|
sizeOrID -= itemstack1.stackSize - j1;
|
|
slot1.putStack(itemstack1);
|
|
}
|
|
}
|
|
|
|
itemstack3.stackSize = sizeOrID;
|
|
|
|
if (itemstack3.stackSize <= 0) {
|
|
itemstack3 = null;
|
|
}
|
|
|
|
inventoryplayer.setItemStack(itemstack3);
|
|
}
|
|
|
|
this.resetDistributionVariables();
|
|
}
|
|
else {
|
|
this.resetDistributionVariables();
|
|
}
|
|
}
|
|
|
|
else if (this.distributeState != 0) {
|
|
this.resetDistributionVariables();
|
|
}
|
|
|
|
else if (getSlot(slotNum) != null && getSlot(slotNum) instanceof SlotMagnetFilter) {
|
|
|
|
SlotMagnetFilter slot = (SlotMagnetFilter) getSlot(slotNum);
|
|
|
|
ItemStack stackSlot = slot.getStack();
|
|
if (alreadyFiltered(player.inventory.getItemStack()) && player.inventory.getItemStack() != null) {
|
|
return null;
|
|
}
|
|
if (stackSlot != null) {
|
|
stack = stackSlot.copy();
|
|
}
|
|
|
|
if (mouseButton == 2) {
|
|
fillPhantomSlot(slot, null, mouseButton);
|
|
}
|
|
else if (mouseButton == 0 || mouseButton == 1) {
|
|
InventoryPlayer playerInv = player.inventory;
|
|
|
|
ItemStack stackHeld = playerInv.getItemStack();
|
|
|
|
if (stackSlot == null) {
|
|
if (stackHeld != null && slot.isItemValid(stackHeld)) {
|
|
fillPhantomSlot(slot, stackHeld, mouseButton);
|
|
}
|
|
}
|
|
else if (stackHeld == null) {
|
|
adjustPhantomSlot(slot, mouseButton, modifier);
|
|
}
|
|
else if (slot.isItemValid(stackHeld)) {
|
|
if (isIdenticalItem(stackSlot, stackHeld)) {
|
|
adjustPhantomSlot(slot, mouseButton, modifier);
|
|
}
|
|
else {
|
|
fillPhantomSlot(slot, stackHeld, mouseButton);
|
|
}
|
|
}
|
|
}
|
|
return stack;
|
|
}
|
|
else {
|
|
return super.slotClick(slotNum, mouseButton, modifier, player);
|
|
}
|
|
return stack;
|
|
}
|
|
|
|
public boolean alwaysTrue(Slot slot) {
|
|
return true;
|
|
}
|
|
|
|
@SuppressWarnings("rawtypes")
|
|
public static void setSlotStack(Set slotSet, int stackSizeSelector, ItemStack stackToResize, int currentSlotStackSize) {
|
|
switch (stackSizeSelector) {
|
|
case 0:
|
|
stackToResize.stackSize = MathHelper.floor_float((float) stackToResize.stackSize / (float) slotSet.size());
|
|
break;
|
|
case 1:
|
|
stackToResize.stackSize = 1;
|
|
}
|
|
|
|
stackToResize.stackSize += currentSlotStackSize;
|
|
}
|
|
|
|
public static boolean stackFitsInSlot(Slot slot, ItemStack itemStack, boolean sizeMatters) {
|
|
boolean flag1 = slot == null || !slot.getHasStack();
|
|
|
|
if (slot != null && slot.getHasStack() && itemStack != null && itemStack.isItemEqual(slot.getStack()) && ItemStack.areItemStackTagsEqual(slot.getStack(), itemStack)) {
|
|
int i = sizeMatters ? 0 : itemStack.stackSize;
|
|
flag1 |= slot.getStack().stackSize + i <= itemStack.getMaxStackSize();
|
|
}
|
|
|
|
return flag1;
|
|
}
|
|
|
|
public static int checkForPressedButton(int btn) {
|
|
return btn & 3;
|
|
}
|
|
|
|
public static int checkForPressedButton2(int mouseButtonPressed) {
|
|
return mouseButtonPressed >> 2 & 3;
|
|
}
|
|
|
|
public static boolean checkValue(int value) {
|
|
return value == 0 || value == 1;
|
|
}
|
|
|
|
protected void resetDistributionVariables() {
|
|
this.distributeState = 0;
|
|
this.distributeSlotSet.clear();
|
|
}
|
|
|
|
private void arrangeSlots() {
|
|
int invSize = magnetInventory.getSizeInventory();
|
|
if (invSize <= 0) {
|
|
return;
|
|
}
|
|
for (int i = 0; i < invSize; i++) {
|
|
if (magnetInventory.getStackInSlot(i) == null) {
|
|
for (int j = 0; j < invSize; j++) {
|
|
if (j <= i) {
|
|
continue;
|
|
}
|
|
if (magnetInventory.getStackInSlot(j) != null) {
|
|
magnetInventory.setInventorySlotContents(i, magnetInventory.getStackInSlot(j));
|
|
magnetInventory.decrStackSize(j, 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void fillPhantomSlot(SlotMagnetFilter slot, ItemStack stackHeld, int mouseButton) {
|
|
if (!slot.canAdjustPhantom()) {
|
|
return;
|
|
}
|
|
if (stackHeld == null) {
|
|
slot.putStack(null);
|
|
return;
|
|
}
|
|
|
|
int stackSize = mouseButton == 0 ? stackHeld.stackSize : 1;
|
|
if (stackSize > slot.getSlotStackLimit()) {
|
|
stackSize = slot.getSlotStackLimit();
|
|
}
|
|
ItemStack phantomStack = stackHeld.copy();
|
|
phantomStack.stackSize = stackSize;
|
|
|
|
slot.putStack(phantomStack);
|
|
arrangeSlots();
|
|
}
|
|
|
|
private void adjustPhantomSlot(SlotMagnetFilter slot, int mouseButton, int modifier) {
|
|
if (!slot.canAdjustPhantom()) {
|
|
return;
|
|
}
|
|
ItemStack stackSlot = slot.getStack();
|
|
int stackSize;
|
|
if (modifier == 1) {
|
|
stackSize = mouseButton == 0 ? (stackSlot.stackSize + 1) / 2 : stackSlot.stackSize * 2;
|
|
}
|
|
else {
|
|
stackSize = mouseButton == 0 ? stackSlot.stackSize - 1 : stackSlot.stackSize + 1;
|
|
}
|
|
|
|
if (stackSize > slot.getSlotStackLimit()) {
|
|
stackSize = slot.getSlotStackLimit();
|
|
}
|
|
|
|
stackSlot.stackSize = stackSize;
|
|
|
|
if (stackSlot.stackSize <= 0) {
|
|
stackSlot = null;
|
|
}
|
|
|
|
slot.putStack(stackSlot);
|
|
arrangeSlots();
|
|
}
|
|
|
|
@Override
|
|
public ItemStack transferStackInSlot(final EntityPlayer p, final int slotIndex) {
|
|
Slot slot = (Slot) inventorySlots.get(slotIndex);
|
|
if (slot == null || slot.getStack() == null) {
|
|
return null;
|
|
}
|
|
ItemStack stack = slot.getStack();
|
|
if (isInHotbar(slotIndex)) {
|
|
if (!mergePhantomStack(stack)) {
|
|
if (!mergeItemStack(stack, PLAYER_INV_START, PLAYER_INV_END + 1, false)) {
|
|
return null;
|
|
}
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
else if (isInPlayerInventory(slotIndex)) {
|
|
if (!mergePhantomStack(stack)) {
|
|
if (!mergeItemStack(stack, HOTBAR_START, HOTBAR_END + 1, false)) {
|
|
return null;
|
|
}
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
if (stack.stackSize == 0) {
|
|
slot.putStack((ItemStack) null);
|
|
}
|
|
else {
|
|
slot.onSlotChanged();
|
|
}
|
|
slot.onPickupFromSlot(p, stack);
|
|
return stack;
|
|
}
|
|
|
|
protected boolean mergePhantomStack(ItemStack stack) {
|
|
if (!alreadyFiltered(stack)) {
|
|
for (int i = FILTERS_START; i <= FILTERS_END; i++) {
|
|
if (this.getSlot(i).getStack() != null) {
|
|
continue;
|
|
}
|
|
else {
|
|
fillPhantomSlot((SlotMagnetFilter) this.getSlot(i), stack, 0);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isIdenticalItem(ItemStack lhs, ItemStack rhs) {
|
|
if (lhs == rhs) {
|
|
return true;
|
|
}
|
|
|
|
if (lhs == null || rhs == null) {
|
|
return false;
|
|
}
|
|
|
|
if (lhs.getItem() != rhs.getItem()) {
|
|
return false;
|
|
}
|
|
|
|
if (lhs.getItemDamage() != OreDictionary.WILDCARD_VALUE) {
|
|
if (lhs.getItemDamage() != rhs.getItemDamage()) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return ItemStack.areItemStackTagsEqual(lhs, rhs);
|
|
}
|
|
|
|
@Override
|
|
protected boolean mergeItemStack(ItemStack stack, int start, int end, boolean backwards) {
|
|
boolean flag1 = false;
|
|
int k = (backwards ? end - 1 : start);
|
|
Slot slot;
|
|
ItemStack itemstack1;
|
|
|
|
if (stack.isStackable()) {
|
|
while (stack.stackSize > 0 && (!backwards && k < end || backwards && k >= start)) {
|
|
slot = (Slot) inventorySlots.get(k);
|
|
itemstack1 = slot.getStack();
|
|
|
|
if (!slot.isItemValid(stack)) {
|
|
k += (backwards ? -1 : 1);
|
|
continue;
|
|
}
|
|
|
|
if (itemstack1 != null && itemstack1.getItem() == stack.getItem() && (!stack.getHasSubtypes() || stack.getItemDamage() == itemstack1.getItemDamage()) && ItemStack.areItemStackTagsEqual(stack, itemstack1)) {
|
|
int l = itemstack1.stackSize + stack.stackSize;
|
|
|
|
if (l <= stack.getMaxStackSize() && l <= slot.getSlotStackLimit()) {
|
|
stack.stackSize = 0;
|
|
itemstack1.stackSize = l;
|
|
magnetInventory.markDirty();
|
|
flag1 = true;
|
|
}
|
|
else if (itemstack1.stackSize < stack.getMaxStackSize() && l < slot.getSlotStackLimit()) {
|
|
stack.stackSize -= stack.getMaxStackSize() - itemstack1.stackSize;
|
|
itemstack1.stackSize = stack.getMaxStackSize();
|
|
magnetInventory.markDirty();
|
|
flag1 = true;
|
|
}
|
|
}
|
|
|
|
k += (backwards ? -1 : 1);
|
|
}
|
|
}
|
|
if (stack.stackSize > 0) {
|
|
k = (backwards ? end - 1 : start);
|
|
while (!backwards && k < end || backwards && k >= start) {
|
|
slot = (Slot) inventorySlots.get(k);
|
|
itemstack1 = slot.getStack();
|
|
|
|
if (!slot.isItemValid(stack)) {
|
|
k += (backwards ? -1 : 1);
|
|
continue;
|
|
}
|
|
|
|
if (itemstack1 == null) {
|
|
int l = stack.stackSize;
|
|
if (l <= slot.getSlotStackLimit()) {
|
|
slot.putStack(stack.copy());
|
|
stack.stackSize = 0;
|
|
magnetInventory.markDirty();
|
|
flag1 = true;
|
|
break;
|
|
}
|
|
else {
|
|
putStackInSlot(k, new ItemStack(stack.getItem(), slot.getSlotStackLimit(), stack.getItemDamage()));
|
|
stack.stackSize -= slot.getSlotStackLimit();
|
|
magnetInventory.markDirty();
|
|
flag1 = true;
|
|
}
|
|
}
|
|
|
|
k += (backwards ? -1 : 1);
|
|
}
|
|
}
|
|
|
|
return flag1;
|
|
}
|
|
|
|
}
|