diff options
Diffstat (limited to 'src/main/java/jp/plusplus/fbs/tileentity/TileEntityFBSWorkbench.java')
| -rw-r--r-- | src/main/java/jp/plusplus/fbs/tileentity/TileEntityFBSWorkbench.java | 341 |
1 files changed, 341 insertions, 0 deletions
diff --git a/src/main/java/jp/plusplus/fbs/tileentity/TileEntityFBSWorkbench.java b/src/main/java/jp/plusplus/fbs/tileentity/TileEntityFBSWorkbench.java new file mode 100644 index 0000000..f31230f --- /dev/null +++ b/src/main/java/jp/plusplus/fbs/tileentity/TileEntityFBSWorkbench.java @@ -0,0 +1,341 @@ +package jp.plusplus.fbs.tileentity;
+
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import jp.plusplus.fbs.Registry;
+import jp.plusplus.fbs.block.BlockCore;
+import jp.plusplus.fbs.container.ContainerDummy;
+import jp.plusplus.fbs.item.ItemCore;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.ISidedInventory;
+import net.minecraft.inventory.InventoryCrafting;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.*;
+
+/**
+ * Created by pluslus_F on 2015/06/14.
+ */
+public class TileEntityFBSWorkbench extends TileEntity implements ISidedInventory,IFluidHandler {
+ public static final int TANK_CAPACITY=4000;
+ public TankFBS tank=new TankFBS(TANK_CAPACITY);
+
+ private static final int[] slotsMaterial=new int[]{0,1,2,3,4,5,6,7,8}, slotsProduct=new int[]{9}, slotsMana=new int[]{10,11};
+ public ItemStack[] itemStacks=new ItemStack[12];
+ public Container dummy=new ContainerDummy();
+ public InventoryCrafting dummyInv=new InventoryCrafting(dummy,3,3);
+ public Registry.RecipePair product;
+
+
+ @Override
+ public void readFromNBT(NBTTagCompound par1NBTTagCompound){
+ super.readFromNBT(par1NBTTagCompound);
+
+ NBTTagList nbttaglist = (NBTTagList)par1NBTTagCompound.getTag("Items");
+ itemStacks = new ItemStack[getSizeInventory()];
+ for (int i=0;i<nbttaglist.tagCount();i++){
+ NBTTagCompound nbt = nbttaglist.getCompoundTagAt(i);
+ byte b0 = nbt.getByte("Slot");
+
+ if (b0>=0 && b0<itemStacks.length){
+ itemStacks[b0] = ItemStack.loadItemStackFromNBT(nbt);
+ }
+ }
+
+ tank = new TankFBS(TANK_CAPACITY);
+ if (par1NBTTagCompound.hasKey("Tank")) {
+ tank.readFromNBT(par1NBTTagCompound.getCompoundTag("Tank"));
+ }
+
+ onInventoryChange();
+ }
+ @Override
+ public void writeToNBT(NBTTagCompound par1NBTTagCompound){
+ super.writeToNBT(par1NBTTagCompound);
+
+ NBTTagList nbttaglist = new NBTTagList();
+ for (int i=0;i<itemStacks.length;i++){
+ if (itemStacks[i] != null){
+ NBTTagCompound nbt = new NBTTagCompound();
+ nbt.setByte("Slot", (byte) i);
+ itemStacks[i].writeToNBT(nbt);
+ nbttaglist.appendTag(nbt);
+ }
+ }
+ par1NBTTagCompound.setTag("Items", nbttaglist);
+
+ NBTTagCompound nbt = new NBTTagCompound();
+ tank.writeToNBT(nbt);
+ par1NBTTagCompound.setTag("Tank", nbt);
+ }
+
+ @Override
+ public Packet getDescriptionPacket() {
+ NBTTagCompound nbtTagCompound = new NBTTagCompound();
+ this.writeToNBT(nbtTagCompound);
+ return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 1, nbtTagCompound);
+ }
+
+ @Override
+ public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
+ this.readFromNBT(pkt.func_148857_g());
+ }
+
+ public void updateEntity(){
+ //checking inventory
+ ItemStack fc=itemStacks[slotsMana[0]];
+ ItemStack ec=itemStacks[slotsMana[1]];
+ if (fc == null) return;
+ if (fc.stackSize <= 0) {
+ fc = null;
+ return;
+ }
+
+ FluidStack fluid2 = FluidContainerRegistry.getFluidForFilledItem(fc);
+ if(fluid2 != null && fluid2.getFluid()!=null && fluid2.getFluid()==BlockCore.mana) {
+ int put = fill(ForgeDirection.UNKNOWN, fluid2, false);
+
+ if (put == fluid2.amount) {
+ ItemStack emptyContainer = FluidContainerRegistry.drainFluidContainer(fc);
+ if (emptyContainer != null) {
+ if (ec != null) {
+ if (!ec.isItemEqual(emptyContainer)) return;
+ if (ec.stackSize + emptyContainer.stackSize > ec.getMaxStackSize()) return;
+ ec.stackSize+=emptyContainer.stackSize;
+ }
+ else {
+ setInventorySlotContents(slotsMana[1], emptyContainer);
+ }
+ }
+
+ fc.stackSize--;
+ if(fc.stackSize<=1){
+ setInventorySlotContents(slotsMana[0], null);
+ }
+
+ fill(ForgeDirection.UNKNOWN, fluid2, true);
+ markDirty();
+ }
+ }
+ else{
+ FluidStack fluid = tank.getFluid();
+ if (fluid != null && fluid.getFluid() != null) {
+
+ ItemStack get = FluidContainerRegistry.fillFluidContainer(fluid.copy(), fc);
+ if (get != null) {
+ int cap = FluidContainerRegistry.getContainerCapacity(get);
+ if (fluid.amount < cap) return;
+
+ if (ec != null) {
+ if (!ec.isItemEqual(get)) return;
+ if (ec.stackSize + get.stackSize > fc.getMaxStackSize()) return;
+ }
+
+ if (ec == null || ec.stackSize <= 0) {
+ setInventorySlotContents(slotsMana[1], get);
+ } else {
+ ec.stackSize += get.stackSize;
+ }
+
+ fc.stackSize--;
+ if (fc.stackSize <= 1) {
+ setInventorySlotContents(slotsMana[0], null);
+ }
+
+ drain(ForgeDirection.UNKNOWN, cap, true);
+ markDirty();
+ }
+ }
+ }
+ }
+
+ //-----------------------------------------------------------------------------
+ @Override
+ public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
+ if (resource == null || resource.getFluid() == null){
+ return 0;
+ }
+
+ FluidStack current = tank.getFluid();
+ FluidStack resourceCopy = resource.copy();
+ if (current != null && current.amount > 0 && !current.isFluidEqual(resourceCopy)){
+ return 0;
+ }
+
+ int i = 0;
+ int used = tank.fill(resourceCopy, doFill);
+ resourceCopy.amount -= used;
+ i += used;
+
+ return i;
+ }
+
+ @Override
+ public FluidStack drain(ForgeDirection forgeDirection, FluidStack resource, boolean doDrain) {
+ if (resource == null) {
+ return null;
+ }
+ if (tank.getFluidType() == resource.getFluid()) {
+ return tank.drain(resource.amount, doDrain);
+ }
+ return null;
+ }
+ @Override
+ public FluidStack drain(ForgeDirection forgeDirection, int max, boolean b) {
+ return tank.drain(max, b);
+ }
+
+ @Override
+ public boolean canFill(ForgeDirection from, Fluid fluid) {
+ return fluid == BlockCore.mana;
+ }
+
+ @Override
+ public boolean canDrain(ForgeDirection from, Fluid fluid) {
+ return !tank.isEmpty();
+ }
+
+ @Override
+ public FluidTankInfo[] getTankInfo(ForgeDirection from) {
+ return new FluidTankInfo[0];
+ }
+
+ @SideOnly(Side.CLIENT)
+ public IIcon getFluidIcon(){
+ Fluid fluid = tank.getFluidType();
+ return fluid != null ? fluid.getIcon() : null;
+ }
+
+ public void onInventoryChange() {
+ for (int i = 0; i < slotsMaterial.length; i++) {
+ dummyInv.setInventorySlotContents(i, itemStacks[slotsMaterial[i]]);
+ }
+ product = Registry.FindMatchingRecipe(dummyInv, worldObj);
+ if (product != null && tank.getFluidAmount()>=product.mana) setInventorySlotContents(slotsProduct[0], product.recipe.getCraftingResult(dummyInv));
+ else setInventorySlotContents(slotsProduct[0], null);
+ }
+
+ //------------------------------------------------------------------
+ @Override
+ public int getSizeInventory() {
+ return itemStacks.length;
+ }
+ @Override
+ public ItemStack getStackInSlot(int i) {
+ return itemStacks[i];
+ }
+ @Override
+ public ItemStack decrStackSize(int i, int j) {
+ if (itemStacks[i] != null){
+ ItemStack itemstack;
+
+ if (itemStacks[i].stackSize <= j){
+ itemstack = itemStacks[i];
+ itemStacks[i] = null;
+
+ if(i==slotsProduct[0] && product!=null){
+ tank.drain(product.mana*itemstack.stackSize, true);
+ }
+ onInventoryChange();
+
+ markDirty();
+ return itemstack;
+ }
+ else{
+ itemstack = itemStacks[i].splitStack(j);
+
+ if (itemStacks[i].stackSize == 0){
+ itemStacks[i] = null;
+ }
+
+ if(i==slotsProduct[0] && product!=null){
+ tank.drain(product.mana*itemstack.stackSize, true);
+ }
+ onInventoryChange();
+
+ markDirty();
+ return itemstack;
+ }
+ }
+ else{
+ return null;
+ }
+ }
+ @Override
+ public ItemStack getStackInSlotOnClosing(int i) {
+ if (itemStacks[i] != null){
+ ItemStack itemstack = itemStacks[i];
+ itemStacks[i] = null;
+ markDirty();
+ return itemstack;
+ }
+ else{
+ return null;
+ }
+ }
+ @Override
+ public void setInventorySlotContents(int i, ItemStack itemStack) {
+ itemStacks[i] = itemStack;
+ if (itemStack != null && itemStack.stackSize > this.getInventoryStackLimit()){
+ itemStack.stackSize = getInventoryStackLimit();
+ }
+ if(i!=slotsProduct[0]) onInventoryChange();
+ markDirty();
+ }
+ @Override
+ public String getInventoryName() {
+ return BlockCore.workbench.getLocalizedName();
+ }
+ @Override
+ public boolean hasCustomInventoryName() {
+ return false;
+ }
+ @Override
+ public int getInventoryStackLimit() {
+ return 64;
+ }
+ @Override
+ public boolean isUseableByPlayer(EntityPlayer entityPlayer) {
+ return worldObj.getTileEntity(xCoord, yCoord, zCoord) != this ? false : entityPlayer.getDistanceSq((double)xCoord+0.5D, (double)yCoord+0.5D, (double)zCoord+0.5D) <= 64.0D;
+ }
+ @Override
+ public void openInventory() {
+ }
+ @Override
+ public void closeInventory() {
+ }
+ @Override
+ public boolean isItemValidForSlot(int i, ItemStack itemstack) {
+ if(i==10){
+ FluidStack f=FluidContainerRegistry.getFluidForFilledItem(itemstack);
+ return f!=null && f.getFluid()==BlockCore.mana;
+ }
+ return false;
+ }
+
+ @Override
+ public int[] getAccessibleSlotsFromSide(int p_94128_1_) {
+ return slotsMana;
+ }
+
+ @Override
+ public boolean canInsertItem(int p_102007_1_, ItemStack p_102007_2_, int p_102007_3_) {
+ if(p_102007_1_!=slotsMana[0]) return false;
+ FluidStack fc=FluidContainerRegistry.getFluidForFilledItem(p_102007_2_);
+ return fc!=null && fc.getFluid()==BlockCore.mana;
+ }
+
+ @Override
+ public boolean canExtractItem(int p_102008_1_, ItemStack p_102008_2_, int p_102008_3_) {
+ return p_102008_1_==slotsMana[1];
+ }
+}
|