From 70c1354a4a96698758a88c032866288f79de6f5a Mon Sep 17 00:00:00 2001
From: Benjamin Culkin <scorpress@gmail.com>
Date: Sat, 24 Aug 2024 08:16:37 -0400
Subject: Initial commit

---
 .../fbs/tileentity/TileEntityFBSWorkbench.java     | 341 +++++++++++++++++++++
 1 file changed, 341 insertions(+)
 create mode 100644 src/main/java/jp/plusplus/fbs/tileentity/TileEntityFBSWorkbench.java

(limited to 'src/main/java/jp/plusplus/fbs/tileentity/TileEntityFBSWorkbench.java')

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];
+    }
+}
-- 
cgit v1.2.3