equivalent-exchange-3/src/main/java/com/pahimar/ee3/inventory/ContainerTransmutationTablet.java

533 lines
22 KiB
Java
Raw Normal View History

package com.pahimar.ee3.inventory;
2015-04-21 06:06:44 +02:00
import com.pahimar.ee3.api.EnergyValueRegistryProxy;
import com.pahimar.ee3.exchange.EnergyValueRegistry;
import com.pahimar.ee3.inventory.element.IElementButtonHandler;
2015-04-02 07:26:01 +02:00
import com.pahimar.ee3.inventory.element.IElementSliderHandler;
import com.pahimar.ee3.inventory.element.IElementTextFieldHandler;
import com.pahimar.ee3.item.ItemAlchemicalTome;
import com.pahimar.ee3.item.ItemMiniumStone;
import com.pahimar.ee3.item.ItemPhilosophersStone;
import com.pahimar.ee3.knowledge.AbilityRegistry;
2015-04-02 07:26:01 +02:00
import com.pahimar.ee3.knowledge.TransmutationKnowledge;
import com.pahimar.ee3.knowledge.TransmutationKnowledgeRegistry;
import com.pahimar.ee3.network.PacketHandler;
import com.pahimar.ee3.network.message.MessageTransmutationKnowledgeUpdate;
import com.pahimar.ee3.reference.Comparators;
import com.pahimar.ee3.tileentity.TileEntityTransmutationTablet;
2015-04-02 07:26:01 +02:00
import com.pahimar.ee3.util.FilterUtils;
2015-03-22 03:02:35 +01:00
import com.pahimar.ee3.util.ItemHelper;
2015-04-02 07:26:01 +02:00
import cpw.mods.fml.common.network.NetworkRegistry;
2015-03-26 23:12:22 +01:00
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
2015-03-22 03:02:35 +01:00
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
2015-04-02 07:26:01 +02:00
import net.minecraft.inventory.ICrafting;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
2015-04-02 07:26:01 +02:00
import java.util.*;
public class ContainerTransmutationTablet extends ContainerEE implements IElementTextFieldHandler, IElementSliderHandler, IElementButtonHandler
{
2015-04-02 07:26:01 +02:00
private InventoryTransmutationTablet inventoryTransmutationTablet;
public final TileEntityTransmutationTablet tileEntityTransmutationTablet;
2015-04-02 07:26:01 +02:00
private float energyValue;
private String searchTerm;
private int sortOrder;
private int scrollBarPosition;
public ContainerTransmutationTablet(InventoryPlayer inventoryPlayer, TileEntityTransmutationTablet tileEntityTransmutationTablet)
{
this.tileEntityTransmutationTablet = tileEntityTransmutationTablet;
2015-04-02 07:26:01 +02:00
TreeSet<ItemStack> knownTransmutations = new TreeSet<ItemStack>(ItemHelper.displayNameComparator);
if (tileEntityTransmutationTablet.getStackInSlot(TileEntityTransmutationTablet.ALCHEMICAL_TOME_INDEX) != null)
{
2015-04-02 07:26:01 +02:00
ItemStack itemStack = tileEntityTransmutationTablet.getStackInSlot(TileEntityTransmutationTablet.ALCHEMICAL_TOME_INDEX);
if (itemStack.getItem() instanceof ItemAlchemicalTome && ItemHelper.hasOwnerUUID(itemStack))
{
2015-04-02 07:26:01 +02:00
knownTransmutations.addAll(TransmutationKnowledgeRegistry.getInstance().getPlayersKnownTransmutations(ItemHelper.getOwnerUUID(itemStack)));
}
2015-04-02 07:26:01 +02:00
}
inventoryTransmutationTablet = new InventoryTransmutationTablet(knownTransmutations);
this.sortOrder = 0;
this.scrollBarPosition = 0;
2015-04-19 21:01:35 +02:00
this.energyValue = tileEntityTransmutationTablet.getAvailableEnergyValue().getValue();
2015-04-02 07:26:01 +02:00
this.addSlotToContainer(new SlotTabletInput(this, tileEntityTransmutationTablet, TileEntityTransmutationTablet.ITEM_INPUT_1, 62, 24));
this.addSlotToContainer(new SlotTabletInput(this, tileEntityTransmutationTablet, TileEntityTransmutationTablet.ITEM_INPUT_2, 35, 35));
this.addSlotToContainer(new SlotTabletInput(this, tileEntityTransmutationTablet, TileEntityTransmutationTablet.ITEM_INPUT_3, 26, 61));
this.addSlotToContainer(new SlotTabletInput(this, tileEntityTransmutationTablet, TileEntityTransmutationTablet.ITEM_INPUT_4, 35, 87));
this.addSlotToContainer(new SlotTabletInput(this, tileEntityTransmutationTablet, TileEntityTransmutationTablet.ITEM_INPUT_5, 62, 99));
this.addSlotToContainer(new SlotTabletInput(this, tileEntityTransmutationTablet, TileEntityTransmutationTablet.ITEM_INPUT_6, 89, 87));
this.addSlotToContainer(new SlotTabletInput(this, tileEntityTransmutationTablet, TileEntityTransmutationTablet.ITEM_INPUT_7, 98, 61));
this.addSlotToContainer(new SlotTabletInput(this, tileEntityTransmutationTablet, TileEntityTransmutationTablet.ITEM_INPUT_8, 89, 35));
this.addSlotToContainer(new Slot(tileEntityTransmutationTablet, TileEntityTransmutationTablet.STONE_INDEX, 62, 61)
{
@Override
public int getSlotStackLimit()
{
return 1;
}
@Override
public boolean isItemValid(ItemStack itemStack)
{
2015-04-02 07:26:01 +02:00
return itemStack.getItem() instanceof ItemMiniumStone || itemStack.getItem() instanceof ItemPhilosophersStone;
2015-03-26 23:12:22 +01:00
}
});
2015-04-02 07:26:01 +02:00
this.addSlotToContainer(new SlotAlchemicalTome(this, tileEntityTransmutationTablet, TileEntityTransmutationTablet.ALCHEMICAL_TOME_INDEX, 152, 15));
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 3; j++)
{
2015-04-02 07:26:01 +02:00
this.addSlotToContainer(new SlotTabletOutput(this, inventoryTransmutationTablet, i * 3 + j, 175 + j * 20, 38 + i * 20));
}
}
// Add the player's inventory slots to the container
for (int inventoryRowIndex = 0; inventoryRowIndex < PLAYER_INVENTORY_ROWS; ++inventoryRowIndex)
{
for (int inventoryColumnIndex = 0; inventoryColumnIndex < PLAYER_INVENTORY_COLUMNS; ++inventoryColumnIndex)
{
this.addSlotToContainer(new Slot(inventoryPlayer, inventoryColumnIndex + inventoryRowIndex * 9 + 9, 8 + inventoryColumnIndex * 18, 164 + inventoryRowIndex * 18));
}
}
// Add the player's action bar slots to the container
for (int actionBarSlotIndex = 0; actionBarSlotIndex < PLAYER_INVENTORY_COLUMNS; ++actionBarSlotIndex)
{
this.addSlotToContainer(new Slot(inventoryPlayer, actionBarSlotIndex, 8 + actionBarSlotIndex * 18, 222));
}
2015-04-02 07:26:01 +02:00
this.updateInventory();
}
@Override
public void detectAndSendChanges()
{
super.detectAndSendChanges();
2015-04-02 07:26:01 +02:00
for (Object crafter : this.crafters)
{
ICrafting iCrafting = (ICrafting) crafter;
2015-04-19 21:01:35 +02:00
if (this.energyValue != this.tileEntityTransmutationTablet.getAvailableEnergyValue().getValue())
2015-04-02 07:26:01 +02:00
{
2015-04-19 21:01:35 +02:00
this.energyValue = this.tileEntityTransmutationTablet.getAvailableEnergyValue().getValue();
2015-04-02 07:26:01 +02:00
this.updateInventory();
2015-04-19 21:01:35 +02:00
int energyValueAsInt = Float.floatToRawIntBits(this.tileEntityTransmutationTablet.getAvailableEnergyValue().getValue());
2015-04-02 07:26:01 +02:00
iCrafting.sendProgressBarUpdate(this, 0, energyValueAsInt & 0xffff);
iCrafting.sendProgressBarUpdate(this, 1, energyValueAsInt >>> 16);
}
}
}
@SideOnly(Side.CLIENT)
public void updateProgressBar(int valueType, int updatedValue)
{
if (valueType == 0)
{
int energyValueAsInt = Float.floatToRawIntBits(energyValue);
energyValueAsInt = (energyValueAsInt & 0xffff0000) | updatedValue;
energyValue = Float.intBitsToFloat(energyValueAsInt);
}
else if (valueType == 1)
{
int energyValueAsInt = Float.floatToRawIntBits(energyValue);
energyValueAsInt = (energyValueAsInt & 0xffff) | (updatedValue << 16);
energyValue = Float.intBitsToFloat(energyValueAsInt);
}
else if (valueType == 2)
{
sortOrder = updatedValue;
}
else if (valueType == 3)
{
scrollBarPosition = updatedValue;
}
2015-04-02 07:26:01 +02:00
if (valueType >= 0 && valueType <= 3)
2015-04-02 07:26:01 +02:00
{
updateInventory();
2015-04-02 07:26:01 +02:00
}
}
@Override
2015-04-02 07:26:01 +02:00
public void handleElementTextFieldUpdate(String elementName, String updatedText)
{
2015-04-02 07:26:01 +02:00
if (elementName.equalsIgnoreCase("searchField"))
{
this.searchTerm = updatedText;
updateInventory();
}
}
2015-04-02 07:26:01 +02:00
@Override
public void handleElementSliderUpdate(String elementName, int elementValue)
{
if (elementName.equals("scrollBar"))
{
this.scrollBarPosition = elementValue;
updateInventory();
}
2015-04-02 07:26:01 +02:00
}
public void handleTransmutationKnowledgeUpdate(TransmutationKnowledge transmutationKnowledge)
{
if (transmutationKnowledge != null)
{
this.inventoryTransmutationTablet = new InventoryTransmutationTablet(transmutationKnowledge.getKnownTransmutations());
this.updateInventory();
}
}
private void updateInventory()
{
2015-04-02 07:26:01 +02:00
ItemStack[] newInventory = new ItemStack[30];
Set<ItemStack> filteredSet = FilterUtils.filterByNameContains(this.inventoryTransmutationTablet.getKnownTransmutations(), searchTerm);
List<ItemStack> filteredList = new ArrayList(FilterUtils.filterByEnergyValue(filteredSet, energyValue));
int adjustedStartIndex = (int) ((scrollBarPosition / 187f) * filteredList.size());
if (sortOrder >= 0 && sortOrder < Comparators.itemComparators.length)
{
Collections.sort(filteredList, Comparators.itemComparators[sortOrder]);
}
2015-04-02 07:26:01 +02:00
if (filteredList.size() <= 30)
{
newInventory = filteredList.toArray(newInventory);
}
else if (adjustedStartIndex + 30 <= filteredList.size())
{
newInventory = filteredList.subList(adjustedStartIndex, adjustedStartIndex + 30).toArray(newInventory);
}
2015-04-02 07:26:01 +02:00
else
{
newInventory = filteredList.subList(filteredList.size() - 30, filteredList.size()).toArray(newInventory);
2015-04-02 07:26:01 +02:00
}
2015-04-02 07:26:01 +02:00
for (int i = 0; i < 30; i++)
{
this.getSlot(i + 10).putStack(newInventory[i]);
}
}
2015-03-22 03:02:35 +01:00
@Override
public ItemStack transferStackInSlot(EntityPlayer entityPlayer, int slotIndex)
{
ItemStack itemStack = null;
Slot slot = (Slot) inventorySlots.get(slotIndex);
if (slot != null && slot.getHasStack())
{
ItemStack slotItemStack = slot.getStack();
itemStack = slotItemStack.copy();
/**
* If we are shift-clicking an item out of the Transmutation Tablet's container,
* attempt to put it in the first available slot in the entityPlayer's
* inventory
*/
if (slotIndex < TileEntityTransmutationTablet.INVENTORY_SIZE)
{
if (!this.mergeItemStack(slotItemStack, TileEntityTransmutationTablet.INVENTORY_SIZE, inventorySlots.size(), false))
{
return null;
}
}
2015-04-21 03:16:48 +02:00
else if (slotIndex >= TileEntityTransmutationTablet.INVENTORY_SIZE && slotIndex < 40)
{
2015-04-21 06:06:44 +02:00
if (!this.mergeTransmutationItemStack(slotItemStack, 40, inventorySlots.size(), false))
{
return null;
}
2015-04-21 03:16:48 +02:00
}
2015-03-22 03:02:35 +01:00
else
{
if (slotItemStack.getItem() instanceof ItemAlchemicalTome)
{
if (!this.mergeItemStack(slotItemStack, TileEntityTransmutationTablet.ALCHEMICAL_TOME_INDEX, TileEntityTransmutationTablet.INVENTORY_SIZE, false))
{
return null;
}
}
else if (slotItemStack.getItem() instanceof ItemMiniumStone || slotItemStack.getItem() instanceof ItemPhilosophersStone)
{
if (!this.mergeItemStack(slotItemStack, TileEntityTransmutationTablet.STONE_INDEX, TileEntityTransmutationTablet.INVENTORY_SIZE, false))
{
return null;
}
}
else
{
if (!this.mergeItemStack(slotItemStack, TileEntityTransmutationTablet.ITEM_INPUT_1, TileEntityTransmutationTablet.INVENTORY_SIZE, false))
{
return null;
}
}
}
if (slotItemStack.stackSize == 0)
{
slot.putStack(null);
}
else
{
slot.onSlotChanged();
}
}
return itemStack;
}
2015-04-21 06:06:44 +02:00
protected boolean mergeTransmutationItemStack(ItemStack itemStack, int slotMin, int slotMax, boolean ascending)
2015-04-21 03:16:48 +02:00
{
2015-04-21 06:06:44 +02:00
if (this.tileEntityTransmutationTablet.getAvailableEnergyValue().compareTo(EnergyValueRegistryProxy.getEnergyValue(itemStack)) < 0)
2015-04-21 03:16:48 +02:00
{
2015-04-21 06:06:44 +02:00
return false;
2015-04-21 03:16:48 +02:00
}
2015-04-21 06:06:44 +02:00
boolean slotFound = false;
int currentSlotIndex = ascending ? slotMax - 1 : slotMin;
Slot slot;
ItemStack stackInSlot;
if (itemStack.isStackable())
2015-04-21 03:16:48 +02:00
{
2015-04-21 06:06:44 +02:00
while (itemStack.stackSize > 0 && (!ascending && currentSlotIndex < slotMax || ascending && currentSlotIndex >= slotMin))
{
slot = (Slot) this.inventorySlots.get(currentSlotIndex);
stackInSlot = slot.getStack();
if (slot.isItemValid(itemStack) && ItemHelper.equalsIgnoreStackSize(itemStack, stackInSlot))
{
int combinedStackSize = stackInSlot.stackSize + itemStack.stackSize;
int slotStackSizeLimit = Math.min(stackInSlot.getMaxStackSize(), slot.getSlotStackLimit());
if (combinedStackSize <= slotStackSizeLimit)
{
itemStack.stackSize = 1;
stackInSlot.stackSize = combinedStackSize;
slot.onSlotChanged();
slotFound = true;
}
else if (stackInSlot.stackSize < slotStackSizeLimit)
{
itemStack.stackSize -= slotStackSizeLimit - stackInSlot.stackSize;
stackInSlot.stackSize = slotStackSizeLimit;
slot.onSlotChanged();
slotFound = true;
}
}
currentSlotIndex += ascending ? -1 : 1;
}
2015-04-21 03:16:48 +02:00
}
2015-04-21 06:06:44 +02:00
if (itemStack.stackSize > 0)
{
currentSlotIndex = ascending ? slotMax - 1 : slotMin;
while (!ascending && currentSlotIndex < slotMax || ascending && currentSlotIndex >= slotMin)
{
slot = (Slot) this.inventorySlots.get(currentSlotIndex);
stackInSlot = slot.getStack();
if (slot.isItemValid(itemStack) && stackInSlot == null)
{
slot.putStack(ItemHelper.cloneItemStack(itemStack, Math.min(itemStack.stackSize, slot.getSlotStackLimit())));
slot.onSlotChanged();
if (slot.getStack() != null)
{
itemStack.stackSize = 0;
slotFound = true;
}
break;
}
currentSlotIndex += ascending ? -1 : 1;
}
itemStack.stackSize = 1;
}
return slotFound;
2015-04-21 03:16:48 +02:00
}
@Override
public void handleElementButtonClick(String elementName, int mouseButton)
{
if (elementName.equals("sortOrder"))
{
if (mouseButton == 0)
{
if (sortOrder == 0)
{
sortOrder = 1;
}
else if (sortOrder == 1)
{
sortOrder = 2;
}
else if (sortOrder == 2)
{
sortOrder = 0;
}
}
else if (mouseButton == 1)
{
if (sortOrder == 0)
{
sortOrder = 2;
}
else if (sortOrder == 1)
{
sortOrder = 0;
}
else if (sortOrder == 2)
{
sortOrder = 1;
}
}
}
for (Object crafter : this.crafters)
{
ICrafting iCrafting = (ICrafting) crafter;
iCrafting.sendProgressBarUpdate(this, 2, sortOrder);
}
}
2015-04-02 07:26:01 +02:00
private class SlotAlchemicalTome extends Slot
{
private ContainerTransmutationTablet containerTransmutationTablet;
private TileEntityTransmutationTablet tileEntityTransmutationTablet;
public SlotAlchemicalTome(ContainerTransmutationTablet containerTransmutationTablet, IInventory iInventory, int slotIndex, int x, int y)
{
super(iInventory, slotIndex, x, y);
this.containerTransmutationTablet = containerTransmutationTablet;
this.tileEntityTransmutationTablet = containerTransmutationTablet.tileEntityTransmutationTablet;
}
@Override
public int getSlotStackLimit()
{
return 1;
}
@Override
public boolean isItemValid(ItemStack itemStack)
{
return itemStack.getItem() instanceof ItemAlchemicalTome;
}
@Override
public void onPickupFromSlot(EntityPlayer entityPlayer, ItemStack itemStack)
{
super.onPickupFromSlot(entityPlayer, itemStack);
this.containerTransmutationTablet.inventoryTransmutationTablet = new InventoryTransmutationTablet();
2015-04-02 07:26:01 +02:00
this.containerTransmutationTablet.updateInventory();
if (!this.tileEntityTransmutationTablet.getWorldObj().isRemote && itemStack != null && itemStack.getItem() instanceof ItemAlchemicalTome && ItemHelper.hasOwnerUUID(itemStack))
{
PacketHandler.INSTANCE.sendToAllAround(new MessageTransmutationKnowledgeUpdate(this.containerTransmutationTablet.tileEntityTransmutationTablet, null), new NetworkRegistry.TargetPoint(this.tileEntityTransmutationTablet.getWorldObj().provider.dimensionId, (double) this.tileEntityTransmutationTablet.xCoord, (double) this.tileEntityTransmutationTablet.yCoord, (double) this.tileEntityTransmutationTablet.zCoord, 5d));
2015-04-02 07:26:01 +02:00
}
}
@Override
public void putStack(ItemStack itemStack)
{
super.putStack(itemStack);
2015-04-02 07:26:01 +02:00
if (!this.tileEntityTransmutationTablet.getWorldObj().isRemote && itemStack != null && itemStack.getItem() instanceof ItemAlchemicalTome && ItemHelper.hasOwnerUUID(itemStack))
{
Set<ItemStack> knownTransmutations = TransmutationKnowledgeRegistry.getInstance().getPlayersKnownTransmutations(ItemHelper.getOwnerUUID(itemStack));
this.containerTransmutationTablet.inventoryTransmutationTablet = new InventoryTransmutationTablet(knownTransmutations);
this.containerTransmutationTablet.updateInventory();
PacketHandler.INSTANCE.sendToAllAround(new MessageTransmutationKnowledgeUpdate(this.containerTransmutationTablet.tileEntityTransmutationTablet, knownTransmutations), new NetworkRegistry.TargetPoint(this.tileEntityTransmutationTablet.getWorldObj().provider.dimensionId, (double) this.tileEntityTransmutationTablet.xCoord, (double) this.tileEntityTransmutationTablet.yCoord, (double) this.tileEntityTransmutationTablet.zCoord, 5d));
2015-04-02 07:26:01 +02:00
}
}
}
private class SlotTabletOutput extends Slot
{
2015-04-02 07:26:01 +02:00
private ContainerTransmutationTablet containerTransmutationTablet;
public SlotTabletOutput(ContainerTransmutationTablet containerTransmutationTablet, IInventory iInventory, int slotIndex, int x, int y)
{
super(iInventory, slotIndex, x, y);
2015-04-02 07:26:01 +02:00
this.containerTransmutationTablet = containerTransmutationTablet;
}
@Override
public boolean isItemValid(ItemStack itemStack)
{
return false;
}
2015-04-02 07:26:01 +02:00
@Override
public boolean canTakeStack(EntityPlayer entityPlayer)
{
2015-04-21 03:16:48 +02:00
return true;
2015-04-02 07:26:01 +02:00
}
@Override
public void onPickupFromSlot(EntityPlayer entityPlayer, ItemStack itemStack)
{
super.onPickupFromSlot(entityPlayer, itemStack);
2015-04-21 06:06:44 +02:00
// this.containerTransmutationTablet.tileEntityTransmutationTablet.consumeInventoryForEnergyValue(itemStack);
// this.containerTransmutationTablet.inventoryTransmutationTablet.setInventorySlotContents(this.getSlotIndex(), new ItemStack(itemStack.getItem(), 1, itemStack.getItemDamage()));
2015-04-02 07:26:01 +02:00
}
@Override
@SideOnly(Side.CLIENT)
public boolean func_111238_b()
{
return this.getHasStack();
}
}
private class SlotTabletInput extends Slot
{
2015-04-02 07:26:01 +02:00
private ContainerTransmutationTablet containerTransmutationTablet;
public SlotTabletInput(ContainerTransmutationTablet containerTransmutationTablet, IInventory iInventory, int slotIndex, int x, int y)
{
super(iInventory, slotIndex, x, y);
2015-04-02 07:26:01 +02:00
this.containerTransmutationTablet = containerTransmutationTablet;
}
@Override
public boolean isItemValid(ItemStack itemStack)
{
return EnergyValueRegistry.getInstance().hasEnergyValue(itemStack) && AbilityRegistry.getInstance().isRecoverable(itemStack);
}
2015-04-02 07:26:01 +02:00
@Override
public void onPickupFromSlot(EntityPlayer entityPlayer, ItemStack itemStack)
{
super.onPickupFromSlot(entityPlayer, itemStack);
this.containerTransmutationTablet.tileEntityTransmutationTablet.updateEnergyValueFromInventory();
this.containerTransmutationTablet.updateInventory();
}
@Override
public void putStack(ItemStack itemStack)
{
super.putStack(itemStack);
this.containerTransmutationTablet.tileEntityTransmutationTablet.updateEnergyValueFromInventory();
this.containerTransmutationTablet.updateInventory();
}
}
}