package tconstruct.smeltery.logic; import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.inventory.Container; import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.NetworkManager; import net.minecraft.network.Packet; import net.minecraft.network.play.server.S35PacketUpdateTileEntity; import net.minecraft.util.MathHelper; import net.minecraft.world.World; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidEvent; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.FluidTankInfo; import net.minecraftforge.fluids.IFluidHandler; import net.minecraftforge.fluids.IFluidTank; import cpw.mods.fml.common.eventhandler.Event; import mantle.blocks.abstracts.InventoryLogic; import mantle.blocks.iface.IFacingLogic; import tconstruct.TConstruct; import tconstruct.library.crafting.CastingRecipe; import tconstruct.library.crafting.LiquidCasting; import tconstruct.library.event.SmelteryCastEvent; import tconstruct.library.event.SmelteryCastedEvent; import tconstruct.library.event.SmelteryEvent; import tconstruct.library.tools.AbilityHelper; import tconstruct.library.util.IPattern; public abstract class CastingBlockLogic extends InventoryLogic implements IFluidTank, IFluidHandler, ISidedInventory, IFacingLogic { public FluidStack liquid; protected byte direction; protected int maxCastingDelay = 0; protected int castingDelay = 0; protected int renderOffset = 0; protected int capacity = 0; protected boolean needsUpdate; protected boolean init = true; protected int tick; protected final LiquidCasting liquidCasting; public CastingBlockLogic(LiquidCasting casting) { // input slot and output slot, 1 item in it max super(2, 1); this.liquidCasting = casting; } public int updateCapacity() // Only used to initialize { ItemStack inv = inventory[0]; int ret = TConstruct.ingotLiquidValue; int rec = liquidCasting.getCastingAmount(this.liquid, inv); if (rec > 0) ret = rec; else { if (inv != null && inv.getItem() instanceof IPattern) { int cost = ((IPattern) inv.getItem()).getPatternCost(inv); if (cost > 0) ret *= ((IPattern) inv.getItem()).getPatternCost(inv) * 0.5; } } return ret; } public int updateCapacity(int capacity) { int ret = TConstruct.ingotLiquidValue; if (capacity > 0) ret = capacity; else { ItemStack inv = inventory[0]; if (inv != null && inv.getItem() instanceof IPattern) { int cost = ((IPattern) inv.getItem()).getPatternCost(inv); if (cost > 0) ret *= cost * 0.5; } } return ret; } /* FluidHandler stuff. Mostly delegated to Tank stuff */ @Override public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { return fill(resource, doFill); } @Override public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) { // only same liquid if (liquid != null && liquid.getFluid() != resource.getFluid()) return null; return drain(resource.amount, doDrain); } @Override public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { return drain(maxDrain, doDrain); } @Override public boolean canFill(ForgeDirection from, Fluid fluid) { if (fluid == null) return false; return fill(from, new FluidStack(fluid, 1), false) > 0; } @Override public boolean canDrain(ForgeDirection from, Fluid fluid) { if (fluid == null) return false; FluidStack drained = drain(from, new FluidStack(fluid, 1), false); return drained != null && drained.amount > 0; } /* Tank stuff */ @Override public FluidTankInfo[] getTankInfo(ForgeDirection from) { return new FluidTankInfo[] { getInfo() }; } @Override public FluidStack getFluid() { return liquid == null ? null : liquid.copy(); } @Override public int getFluidAmount() { return liquid != null ? liquid.amount : 0; } /** Returns the current amount of the liquid FOR RENDERING */ public int getLiquidAmount() { return liquid.amount - renderOffset; } @Override public int getCapacity() { return this.capacity; } @Override public FluidTankInfo getInfo() { return new FluidTankInfo(this); } /** * Create and return the casting event here. It'll be fired automatically. */ public abstract SmelteryCastEvent getCastingEvent(CastingRecipe recipe, FluidStack metal); @Override public int fill(FluidStack resource, boolean doFill) { if (resource == null) return 0; if (this.liquid == null) { CastingRecipe recipe = liquidCasting.getCastingRecipe(resource, inventory[0]); if (recipe == null) return 0; SmelteryCastEvent event = getCastingEvent(recipe, resource); MinecraftForge.EVENT_BUS.post(event); if (event.getResult() == Event.Result.DENY) return 0; this.capacity = updateCapacity(recipe.castingMetal.amount); if (inventory[1] == null) { FluidStack copyLiquid = resource.copy(); if (copyLiquid.amount > this.capacity) { copyLiquid.amount = this.capacity; } if (doFill) { if (copyLiquid.amount == this.capacity) { maxCastingDelay = castingDelay = recipe.coolTime; } renderOffset = copyLiquid.amount; worldObj.func_147479_m(xCoord, yCoord, zCoord); this.liquid = copyLiquid; needsUpdate = true; } return copyLiquid.amount; } else { return 0; } } else if (resource.isFluidEqual(this.liquid)) { if (resource.amount + this.liquid.amount >= this.capacity) // Start timer here { int roomInTank = this.capacity - liquid.amount; if (doFill && roomInTank > 0) { renderOffset = roomInTank; maxCastingDelay = castingDelay = liquidCasting.getCastingDelay(this.liquid, inventory[0]); this.liquid.amount = this.capacity; worldObj.func_147479_m(xCoord, yCoord, zCoord); needsUpdate = true; } return roomInTank; } else { if (doFill) { renderOffset += resource.amount; this.liquid.amount += resource.amount; worldObj.func_147479_m(xCoord, yCoord, zCoord); needsUpdate = true; } return resource.amount; } } else { return 0; } } @Override public FluidStack drain(int maxDrain, boolean doDrain) { if (liquid == null || liquid.getFluid() == null || liquid.getFluidID() <= 0 || castingDelay > 0) return null; if (liquid.amount <= 0) return null; int used = maxDrain; if (liquid.amount < used) used = liquid.amount; if (doDrain) { liquid.amount -= used; } FluidStack drained = liquid.copy(); drained.amount = used; renderOffset = 0; // Reset liquid if emptied if (liquid.amount <= 0) liquid = null; if (doDrain) FluidEvent.fireEvent( new FluidEvent.FluidDrainingEvent( drained, this.worldObj, this.xCoord, this.yCoord, this.zCoord, this, used)); return drained; } /* Inventory, inserting/extracting */ public void interact(EntityPlayer player) { // only server side // if(worldObj.isRemote) // return; // can't interact with liquid inside // todo: maybe let it interact with a bucket or tank! if (liquid != null) return; // put stuff in? if (!isStackInSlot(0) && !isStackInSlot(1)) { ItemStack stack = player.inventory.decrStackSize(player.inventory.currentItem, stackSizeLimit); SmelteryEvent.ItemInsertedIntoCasting event = new SmelteryEvent.ItemInsertedIntoCasting( this, xCoord, yCoord, zCoord, stack, player); MinecraftForge.EVENT_BUS.post(event); if (!event.isCanceled()) setInventorySlotContents(0, event.item); else player.inventory.addItemStackToInventory(stack); // should never return false, since the itemstack was // taken from the inventory } // take stuff out. else { int slot = 0; // output-slot has higher priority if (isStackInSlot(1)) slot = 1; // Additional Info: Only 1 item can only be put into the casting block usually, however recipes // can have multiple blocks as output (compressed gravel -> brownstone for example) // we therefore spill the whole contents on extraction SmelteryEvent.ItemRemovedFromCasting event = new SmelteryEvent.ItemRemovedFromCasting( this, xCoord, yCoord, zCoord, getStackInSlot(slot), player); MinecraftForge.EVENT_BUS.post(event); // try to transfer the stack to the player inventory ItemStack output = event.item; AbilityHelper.spawnItemAtPlayer(player, output); // remove inventory contents, since we spilled the full contents of the slot inventory[slot] = null; } } @Override public ItemStack decrStackSize(int slot, int quantity) { ItemStack stack = super.decrStackSize(slot, quantity); worldObj.func_147479_m(xCoord, yCoord, zCoord); return stack; } @Override public int[] getAccessibleSlotsFromSide(int side) { return new int[] { 0, 1 }; } @Override public boolean canInsertItem(int slot, ItemStack itemstack, int side) { // can't insert if there's liquid in it if (liquid != null) return false; // only into input slot return slot == 0; } @Override public boolean canExtractItem(int slot, ItemStack itemstack, int side) { // only output slot return slot == 1; } /* We don't have a gui or anything */ @Override public Container getGuiContainer(InventoryPlayer inventoryplayer, World world, int x, int y, int z) { return null; } @Override protected String getDefaultName() { return null; } @Override public String getInventoryName() { return null; } @Override public String getInvName() { return null; } @Override public boolean hasCustomInventoryName() { return false; } @Override public void openInventory() {} @Override public void closeInventory() {} /* NBT, Updating */ @Override public void markDirty() // Isn't actually called? { super.markDirty(); worldObj.func_147479_m(xCoord, yCoord, zCoord); needsUpdate = true; } @Override public void updateEntity() { if (castingDelay > 0) { castingDelay--; if (castingDelay == 0) castLiquid(); } if (renderOffset > 0) { // renderOffset -= Math.max(renderOffset/3, 6); renderOffset -= 6; if (renderOffset < 0) renderOffset = 0; worldObj.func_147479_m(xCoord, yCoord, zCoord); } tick++; if (tick % 20 == 0) { tick = 0; if (needsUpdate) { needsUpdate = false; worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); } } } /** * Create and return the casting event here. It'll be fired automatically. */ public abstract SmelteryCastedEvent getCastedEvent(CastingRecipe recipe, ItemStack result); public void castLiquid() { CastingRecipe recipe = liquidCasting.getCastingRecipe(liquid, inventory[0]); if (recipe != null) { SmelteryCastedEvent event = getCastedEvent(recipe, recipe.getResult()); MinecraftForge.EVENT_BUS.post(event); maxCastingDelay = 0; inventory[1] = event.output; if (event.consumeCast) inventory[0] = null; // if we just created a cast, move it to the first slot so we can use it directly afterwards if (event.output != null && event.output.getItem() instanceof IPattern) { inventory[1] = inventory[0]; inventory[0] = event.output; } liquid = null; worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); } } @Override public void readFromNBT(NBTTagCompound tags) { super.readFromNBT(tags); readCustomNBT(tags); } public void readCustomNBT(NBTTagCompound tags) { if (tags.getBoolean("hasLiquid")) { this.liquid = FluidStack.loadFluidStackFromNBT(tags.getCompoundTag("Fluid")); } else this.liquid = null; if (tags.getBoolean("Initialized")) this.capacity = tags.getInteger("Capacity"); else this.capacity = updateCapacity(); this.castingDelay = tags.getInteger("castingDelay"); this.maxCastingDelay = tags.getInteger("maxCastingDelay"); this.renderOffset = tags.getInteger("RenderOffset"); this.direction = tags.getByte("direction"); } @Override public void writeToNBT(NBTTagCompound tags) { super.writeToNBT(tags); writeCustomNBT(tags); } public void writeCustomNBT(NBTTagCompound tags) { tags.setBoolean("hasLiquid", liquid != null); if (liquid != null) { NBTTagCompound nbt = new NBTTagCompound(); liquid.writeToNBT(nbt); tags.setTag("Fluid", nbt); } tags.setBoolean("Initialized", init); tags.setInteger("Capacity", capacity); tags.setInteger("castingDelay", castingDelay); tags.setInteger("maxCastingDelay", maxCastingDelay); tags.setInteger("RenderOffset", renderOffset); tags.setByte("direction", direction); } /* Packets */ @Override public Packet getDescriptionPacket() { NBTTagCompound tag = new NBTTagCompound(); writeToNBT(tag); return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, tag); } @Override public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) { readFromNBT(packet.func_148857_g()); worldObj.func_147479_m(xCoord, yCoord, zCoord); } public int getProgress() { if (castingDelay == 0 || maxCastingDelay == 0) { return 0; } return (int) (((maxCastingDelay - castingDelay) / (double) maxCastingDelay) * 100); } @Override public byte getRenderDirection() { return direction; } @Override public ForgeDirection getForgeDirection() { return ForgeDirection.VALID_DIRECTIONS[direction]; } @Override public void setDirection(int side) {} @Override public void setDirection(float yaw, float pitch, EntityLivingBase player) { int facing = MathHelper.floor_double((double) (yaw / 360) + 0.5D) & 3; switch (facing) { case 1 -> direction = 5; case 2 -> direction = 3; case 3 -> direction = 4; default -> direction = 2; } } }