405 lines
14 KiB
Java
405 lines
14 KiB
Java
package com.pahimar.ee3.tileentity;
|
|
|
|
import java.util.Collections;
|
|
import java.util.Set;
|
|
|
|
import com.pahimar.ee3.api.blacklist.BlacklistRegistryProxy;
|
|
import com.pahimar.ee3.api.exchange.EnergyValue;
|
|
import com.pahimar.ee3.api.exchange.EnergyValueRegistryProxy;
|
|
import com.pahimar.ee3.api.exchange.ITransmutationContainer;
|
|
import com.pahimar.ee3.block.BlockAshInfusedStoneSlab;
|
|
import com.pahimar.ee3.item.ITransmutationStone;
|
|
import com.pahimar.ee3.item.ItemAlchenomicon;
|
|
import com.pahimar.ee3.knowledge.PlayerKnowledge;
|
|
import com.pahimar.ee3.network.PacketHandler;
|
|
import com.pahimar.ee3.network.message.MessageTileEntityTransmutationTablet;
|
|
import com.pahimar.ee3.reference.Names;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.inventory.ISidedInventory;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.network.Packet;
|
|
import net.minecraft.util.AxisAlignedBB;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
|
|
public class TileEntityTransmutationTablet
|
|
extends TileEntityEE implements ISidedInventory, ITransmutationContainer {
|
|
public static final int INVENTORY_SIZE = 10;
|
|
public static final int ITEM_INPUT_1 = 0;
|
|
public static final int ITEM_INPUT_2 = 1;
|
|
public static final int ITEM_INPUT_3 = 2;
|
|
public static final int ITEM_INPUT_4 = 3;
|
|
public static final int ITEM_INPUT_5 = 4;
|
|
public static final int ITEM_INPUT_6 = 5;
|
|
public static final int ITEM_INPUT_7 = 6;
|
|
public static final int ITEM_INPUT_8 = 7;
|
|
public static final int STONE_INDEX = 8;
|
|
public static final int ALCHENOMICON_INDEX = 9;
|
|
|
|
private EnergyValue storedEnergy, availableEnergy;
|
|
private ForgeDirection rotation;
|
|
private ItemStack[] inventory;
|
|
public PlayerKnowledge playerKnowledge;
|
|
|
|
public TileEntityTransmutationTablet() {
|
|
super();
|
|
rotation = ForgeDirection.UNKNOWN;
|
|
availableEnergy = new EnergyValue(0);
|
|
storedEnergy = new EnergyValue(0);
|
|
inventory = new ItemStack[INVENTORY_SIZE];
|
|
}
|
|
|
|
@Override
|
|
public EnergyValue getAvailableEnergy() {
|
|
if (inventory[STONE_INDEX] != null
|
|
&& inventory[STONE_INDEX].getItem() instanceof ITransmutationStone) {
|
|
return availableEnergy;
|
|
} else {
|
|
return new EnergyValue(0);
|
|
}
|
|
}
|
|
|
|
public EnergyValue getStoredEnergy() {
|
|
return storedEnergy;
|
|
}
|
|
|
|
public ForgeDirection getRotation() {
|
|
return rotation;
|
|
}
|
|
|
|
public void setRotation(ForgeDirection rotation) {
|
|
this.rotation = rotation;
|
|
}
|
|
|
|
@Override
|
|
public Set<ItemStack> getPlayerKnowledge() {
|
|
if (playerKnowledge != null) {
|
|
return playerKnowledge.getKnownItemStacks();
|
|
} else {
|
|
return Collections.emptySet();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void handlePlayerKnowledgeUpdate(PlayerKnowledge playerKnowledge) {
|
|
this.playerKnowledge = playerKnowledge;
|
|
}
|
|
|
|
/**
|
|
* https://github.com/pahimar/Equivalent-Exchange-3/issues/1062
|
|
*/
|
|
@Override
|
|
public void consumeInventoryForEnergyValue(ItemStack outputItemStack) {
|
|
EnergyValue outputEnergyValue
|
|
= EnergyValueRegistryProxy.getEnergyValueForStack(outputItemStack);
|
|
|
|
/**
|
|
* Algorithm:
|
|
*
|
|
* 1) Check the Stone slot, and attempt to take EMC out of the stone there (til
|
|
* 0) 2) Search the inventory for items that will most make up the difference,
|
|
* decrement them and consume their EMC 3) Repeat 2 until Stored EMC >
|
|
* outputItemStack EMC 4) Profit
|
|
*/
|
|
|
|
if (this.storedEnergy.compareTo(outputEnergyValue) >= 0) {
|
|
this.storedEnergy = new EnergyValue(
|
|
this.storedEnergy.getValue() - outputEnergyValue.getValue()
|
|
);
|
|
} else {
|
|
while (this.storedEnergy.compareTo(outputEnergyValue) < 0
|
|
&& this.availableEnergy.compareTo(outputEnergyValue) >= 0) {
|
|
for (int i = 0; i < STONE_INDEX; i++) {
|
|
ItemStack stackInSlot = getStackInSlot(i);
|
|
if (stackInSlot != null
|
|
&& EnergyValueRegistryProxy.hasEnergyValue(stackInSlot)) {
|
|
this.storedEnergy = new EnergyValue(
|
|
this.storedEnergy.getValue()
|
|
+ EnergyValueRegistryProxy.getEnergyValue(stackInSlot)
|
|
.getValue()
|
|
);
|
|
decrStackSize(i, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (this.storedEnergy.getValue() >= outputEnergyValue.getValue()) {
|
|
this.storedEnergy = new EnergyValue(
|
|
this.storedEnergy.getValue() - outputEnergyValue.getValue()
|
|
);
|
|
}
|
|
}
|
|
|
|
int damageAmount = 1;
|
|
|
|
if (outputEnergyValue.getValue() >= 8192) {
|
|
damageAmount = 200;
|
|
} else if (outputEnergyValue.getValue() >= 2048) {
|
|
damageAmount = 50;
|
|
} else if (outputEnergyValue.getValue() >= 64) {
|
|
damageAmount = 10;
|
|
}
|
|
|
|
ItemStack stone = this.inventory[STONE_INDEX];
|
|
|
|
if (stone != null && stone.isItemStackDamageable()) {
|
|
int newDamage = stone.getItemDamage() + damageAmount;
|
|
if (newDamage >= stone.getMaxDamage()) {
|
|
this.inventory[STONE_INDEX] = null;
|
|
} else {
|
|
stone.setItemDamage(newDamage);
|
|
}
|
|
}
|
|
|
|
updateEnergyValueFromInventory();
|
|
}
|
|
|
|
@Override
|
|
public void updateEnergyValueFromInventory() {
|
|
float newEnergyValue = storedEnergy.getValue();
|
|
for (int i = 0; i < STONE_INDEX; i++) {
|
|
if (inventory[i] != null
|
|
&& EnergyValueRegistryProxy.hasEnergyValue(inventory[i])) {
|
|
newEnergyValue
|
|
+= EnergyValueRegistryProxy.getEnergyValueForStack(inventory[i])
|
|
.getValue();
|
|
}
|
|
}
|
|
this.availableEnergy = new EnergyValue(newEnergyValue);
|
|
}
|
|
|
|
@Override
|
|
@SideOnly(Side.CLIENT)
|
|
public AxisAlignedBB getRenderBoundingBox() {
|
|
return AxisAlignedBB.getBoundingBox(
|
|
xCoord - 1.5d,
|
|
yCoord - 1,
|
|
zCoord - 1.5d,
|
|
xCoord + 1.5d,
|
|
yCoord + 1,
|
|
zCoord + 1.5d
|
|
);
|
|
}
|
|
|
|
public boolean isStructureValid() {
|
|
return (
|
|
(worldObj.getBlock(xCoord - 1, yCoord, zCoord - 1)
|
|
instanceof BlockAshInfusedStoneSlab
|
|
&& worldObj.getBlockMetadata(xCoord - 1, yCoord, zCoord - 1) == 1)
|
|
&& (worldObj.getBlock(xCoord, yCoord, zCoord - 1)
|
|
instanceof BlockAshInfusedStoneSlab
|
|
&& worldObj.getBlockMetadata(xCoord, yCoord, zCoord - 1) == 2)
|
|
&& (worldObj.getBlock(xCoord + 1, yCoord, zCoord - 1)
|
|
instanceof BlockAshInfusedStoneSlab
|
|
&& worldObj.getBlockMetadata(xCoord + 1, yCoord, zCoord - 1) == 3)
|
|
&& (worldObj.getBlock(xCoord - 1, yCoord, zCoord)
|
|
instanceof BlockAshInfusedStoneSlab
|
|
&& worldObj.getBlockMetadata(xCoord - 1, yCoord, zCoord) == 4)
|
|
&& (worldObj.getBlock(xCoord + 1, yCoord, zCoord)
|
|
instanceof BlockAshInfusedStoneSlab
|
|
&& worldObj.getBlockMetadata(xCoord + 1, yCoord, zCoord) == 5)
|
|
&& (worldObj.getBlock(xCoord - 1, yCoord, zCoord + 1)
|
|
instanceof BlockAshInfusedStoneSlab
|
|
&& worldObj.getBlockMetadata(xCoord - 1, yCoord, zCoord + 1) == 6)
|
|
&& (worldObj.getBlock(xCoord, yCoord, zCoord + 1)
|
|
instanceof BlockAshInfusedStoneSlab
|
|
&& worldObj.getBlockMetadata(xCoord, yCoord, zCoord + 1) == 7)
|
|
&& (worldObj.getBlock(xCoord + 1, yCoord, zCoord + 1)
|
|
instanceof BlockAshInfusedStoneSlab
|
|
&& worldObj.getBlockMetadata(xCoord + 1, yCoord, zCoord + 1) == 8)
|
|
);
|
|
}
|
|
|
|
@Override
|
|
public void updateEntity() {
|
|
super.updateEntity();
|
|
updateEnergyValueFromInventory();
|
|
}
|
|
|
|
@Override
|
|
public Packet getDescriptionPacket() {
|
|
return PacketHandler.INSTANCE.getPacketFrom(
|
|
new MessageTileEntityTransmutationTablet(this)
|
|
);
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbtTagCompound) {
|
|
super.readFromNBT(nbtTagCompound);
|
|
rotation = ForgeDirection.getOrientation(nbtTagCompound.getInteger("rotation"));
|
|
|
|
// Read in the ItemStacks in the inventory from NBT
|
|
NBTTagList tagList = nbtTagCompound.getTagList(Names.NBT.ITEMS, 10);
|
|
inventory = new ItemStack[this.getSizeInventory()];
|
|
for (int i = 0; i < tagList.tagCount(); ++i) {
|
|
NBTTagCompound tagCompound = tagList.getCompoundTagAt(i);
|
|
byte slotIndex = tagCompound.getByte("Slot");
|
|
if (slotIndex >= 0 && slotIndex < inventory.length) {
|
|
inventory[slotIndex] = ItemStack.loadItemStackFromNBT(tagCompound);
|
|
}
|
|
}
|
|
|
|
NBTTagCompound energyValueTagCompound
|
|
= nbtTagCompound.getCompoundTag("storedEnergy");
|
|
if (!energyValueTagCompound.hasNoTags()) {
|
|
storedEnergy = EnergyValue.loadEnergyValueFromNBT(energyValueTagCompound);
|
|
} else {
|
|
storedEnergy = new EnergyValue(0);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbtTagCompound) {
|
|
super.writeToNBT(nbtTagCompound);
|
|
nbtTagCompound.setInteger("rotation", rotation.ordinal());
|
|
|
|
// Write the ItemStacks in the inventory to NBT
|
|
NBTTagList tagList = new NBTTagList();
|
|
for (int currentIndex = 0; currentIndex < inventory.length; ++currentIndex) {
|
|
if (inventory[currentIndex] != null) {
|
|
NBTTagCompound tagCompound = new NBTTagCompound();
|
|
tagCompound.setByte("Slot", (byte) currentIndex);
|
|
inventory[currentIndex].writeToNBT(tagCompound);
|
|
tagList.appendTag(tagCompound);
|
|
}
|
|
}
|
|
nbtTagCompound.setTag(Names.NBT.ITEMS, tagList);
|
|
|
|
NBTTagCompound energyValueTagCompound = new NBTTagCompound();
|
|
if (storedEnergy != null) {
|
|
storedEnergy.writeToNBT(energyValueTagCompound);
|
|
}
|
|
nbtTagCompound.setTag("storedEnergy", energyValueTagCompound);
|
|
}
|
|
|
|
@Override
|
|
public int getSizeInventory() {
|
|
return inventory.length;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlot(int slotIndex) {
|
|
return inventory[slotIndex];
|
|
}
|
|
|
|
@Override
|
|
public ItemStack decrStackSize(int slotIndex, int decrementAmount) {
|
|
ItemStack itemStack = getStackInSlot(slotIndex);
|
|
if (itemStack != null) {
|
|
if (itemStack.stackSize <= decrementAmount) {
|
|
setInventorySlotContents(slotIndex, null);
|
|
} else {
|
|
itemStack = itemStack.splitStack(decrementAmount);
|
|
if (itemStack.stackSize == 0) {
|
|
setInventorySlotContents(slotIndex, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
return itemStack;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getStackInSlotOnClosing(int slotIndex) {
|
|
ItemStack itemStack = getStackInSlot(slotIndex);
|
|
if (itemStack != null) {
|
|
setInventorySlotContents(slotIndex, null);
|
|
}
|
|
return itemStack;
|
|
}
|
|
|
|
@Override
|
|
public void setInventorySlotContents(int slotIndex, ItemStack itemStack) {
|
|
if (slotIndex < getSizeInventory()) {
|
|
inventory[slotIndex] = itemStack;
|
|
if (itemStack != null && itemStack.stackSize > getInventoryStackLimit()) {
|
|
itemStack.stackSize = getInventoryStackLimit();
|
|
}
|
|
|
|
updateEnergyValueFromInventory();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String getInventoryName() {
|
|
return this.hasCustomName() ? this.getCustomName()
|
|
: Names.Containers.TRANSMUTATION_TABLET;
|
|
}
|
|
|
|
@Override
|
|
public boolean hasCustomInventoryName() {
|
|
return this.hasCustomName();
|
|
}
|
|
|
|
@Override
|
|
public int getInventoryStackLimit() {
|
|
return 64;
|
|
}
|
|
|
|
@Override
|
|
public boolean isUseableByPlayer(EntityPlayer entityPlayer) {
|
|
return this.worldObj.getTileEntity(xCoord, yCoord, zCoord) == this
|
|
&& isStructureValid()
|
|
&& entityPlayer.getDistanceSq(
|
|
(double) xCoord + 0.5D, (double) yCoord + 0.5D, (double) zCoord + 0.5D
|
|
)
|
|
<= 64D;
|
|
}
|
|
|
|
@Override
|
|
public void openInventory() {
|
|
// NOOP
|
|
}
|
|
|
|
@Override
|
|
public void closeInventory() {
|
|
// NOOP
|
|
}
|
|
|
|
@Override
|
|
public boolean isItemValidForSlot(int slotIndex, ItemStack itemStack) {
|
|
if (slotIndex < STONE_INDEX && EnergyValueRegistryProxy.hasEnergyValue(itemStack)
|
|
&& BlacklistRegistryProxy.isExchangeable(itemStack)) {
|
|
return true;
|
|
} else if (slotIndex == STONE_INDEX && itemStack.getItem() instanceof ITransmutationStone) {
|
|
return true;
|
|
} else if (slotIndex == ALCHENOMICON_INDEX && itemStack.getItem() instanceof ItemAlchenomicon) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int[] getAccessibleSlotsFromSide(int slotIndex) {
|
|
return new int[0];
|
|
}
|
|
|
|
@Override
|
|
public boolean canInsertItem(int slotIndex, ItemStack itemStack, int side) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canExtractItem(int slotIndex, ItemStack itemStack, int side) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int getXCoord() {
|
|
return xCoord;
|
|
}
|
|
|
|
@Override
|
|
public int getYCoord() {
|
|
return yCoord;
|
|
}
|
|
|
|
@Override
|
|
public int getZCoord() {
|
|
return zCoord;
|
|
}
|
|
}
|