diff --git a/src/main/scala/edx/basic/engineering/TileEngineeringTable.scala b/src/main/scala/edx/basic/engineering/TileEngineeringTable.scala index ddb295f20..f8ebb48dc 100644 --- a/src/main/scala/edx/basic/engineering/TileEngineeringTable.scala +++ b/src/main/scala/edx/basic/engineering/TileEngineeringTable.scala @@ -31,7 +31,6 @@ import resonantengine.api.tile.IRotatable import resonantengine.core.ResonantEngine import resonantengine.core.network.discriminator.{PacketTile, PacketType} import resonantengine.lib.collection.Pair -import resonantengine.lib.prefab.gui.ContainerDummy import resonantengine.lib.render.RenderItemOverlayUtility import resonantengine.lib.transform.region.Cuboid import resonantengine.lib.transform.vector.{Vector2, Vector3} @@ -40,6 +39,7 @@ import resonantengine.lib.utility.inventory.AutoCraftingManager.IAutoCrafter import resonantengine.lib.utility.inventory.{AutoCraftingManager, InventoryUtility} import resonantengine.prefab.block.itemblock.ItemBlockSaved import resonantengine.prefab.block.mixed.TileInventory +import resonantengine.prefab.gui.ContainerDummy import scala.collection.JavaConversions._ @@ -129,129 +129,6 @@ class TileEngineeringTable extends TileInventory(Material.wood) with IPacketRece } } - override def getSizeInventory: Int = - { - return 10 + (if (this.invPlayer != null) this.invPlayer.getSizeInventory else 0) - } - - override def setInventorySlotContents(slot: Int, itemStack: ItemStack) - { - if (slot < TileEngineeringTable.CRAFTING_MATRIX_END) - { - craftingMatrix(slot) = itemStack - } - else if (slot < TileEngineeringTable.CRAFTING_OUTPUT_END) - { - outputInventory(slot - TileEngineeringTable.CRAFTING_MATRIX_END) = itemStack - } - else if (slot < TileEngineeringTable.PLAYER_OUTPUT_END && this.invPlayer != null) - { - this.invPlayer.setInventorySlotContents(slot - TileEngineeringTable.CRAFTING_OUTPUT_END, itemStack) - val player: EntityPlayer = this.invPlayer.player - if (player.isInstanceOf[EntityPlayerMP]) - { - (player.asInstanceOf[EntityPlayerMP]).sendContainerToPlayer(player.inventoryContainer) - } - } - else if (searchInventories) - { - var idDisplacement: Int = TileEngineeringTable.PLAYER_OUTPUT_END - for (dir <- ForgeDirection.VALID_DIRECTIONS) - { - val tile: TileEntity = toVectorWorld.add(dir).getTileEntity - if (tile.isInstanceOf[IInventory]) - { - val inventory: IInventory = tile.asInstanceOf[IInventory] - val slotID: Int = slot - idDisplacement - if (slotID >= 0 && slotID < inventory.getSizeInventory) - { - inventory.setInventorySlotContents(slotID, itemStack) - } - idDisplacement += inventory.getSizeInventory - } - } - } - onInventoryChanged - } - - /** - * Updates all the output slots. Call this to update the Engineering Table. - */ - override def onInventoryChanged - { - if (worldObj != null) - { - if (!worldObj.isRemote) - { - this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = null - var didCraft: Boolean = false - val inventoryCrafting: InventoryCrafting = this.getCraftingMatrix - val matrixOutput: ItemStack = CraftingManager.getInstance.findMatchingRecipe(inventoryCrafting, this.worldObj) - if (matrixOutput != null && this.getCraftingManager.getIdealRecipe(matrixOutput) != null) - { - this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = matrixOutput - didCraft = true - } - if (!didCraft) - { - val filterStack: ItemStack = craftingMatrix(TileEngineeringTable.CENTER_SLOT) - if (filterStack != null && filterStack.getItem.isInstanceOf[ItemImprint]) - { - val filters: java.util.List[ItemStack] = ItemImprint.getFilters(filterStack) - for (o <- filters) - { - val outputStack: ItemStack = o - if (outputStack != null) - { - val idealRecipe: Pair[ItemStack, Array[ItemStack]] = this.getCraftingManager.getIdealRecipe(outputStack) - if (idealRecipe != null) - { - val recipeOutput: ItemStack = idealRecipe.left - if (recipeOutput != null & recipeOutput.stackSize > 0) - { - this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = recipeOutput - didCraft = true - worldObj.markBlockForUpdate(xCoord, yCoord, zCoord) - return - } - } - } - } - } - } - worldObj.markBlockForUpdate(xCoord, yCoord, zCoord) - } - } - } - - /** - * Gets the AutoCraftingManager that does all the crafting results - */ - def getCraftingManager: AutoCraftingManager = - { - if (craftManager == null) - { - craftManager = new AutoCraftingManager(this) - } - return craftManager - } - - /** - * Construct an InventoryCrafting Matrix on the fly. - * - * @return - */ - def getCraftingMatrix: InventoryCrafting = - { - val inventoryCrafting: InventoryCrafting = new InventoryCrafting(new ContainerDummy(this), 3, 3) - - for (i <- 0 until this.craftingMatrix.length) - { - inventoryCrafting.setInventorySlotContents(i, this.craftingMatrix(i)) - } - return inventoryCrafting - } - override def use(player: EntityPlayer, hitSide: Int, hit: Vector3): Boolean = { if (player.getCurrentEquippedItem != null && player.getCurrentEquippedItem.getItem.isInstanceOf[ItemHammer]) @@ -453,6 +330,49 @@ class TileEngineeringTable extends TileInventory(Material.wood) with IPacketRece nbt.setBoolean("searchInventories", this.searchInventories) } + override def getSizeInventory: Int = + { + return 10 + (if (this.invPlayer != null) this.invPlayer.getSizeInventory else 0) + } + + /** + * DO NOT USE THIS INTERNALLY. FOR EXTERNAL USE ONLY! + */ + override def getStackInSlot(slot: Int): ItemStack = + { + if (slot < TileEngineeringTable.CRAFTING_MATRIX_END) + { + return this.craftingMatrix(slot) + } + else if (slot < TileEngineeringTable.CRAFTING_OUTPUT_END) + { + return outputInventory(slot - TileEngineeringTable.CRAFTING_MATRIX_END) + } + else if (slot < TileEngineeringTable.PLAYER_OUTPUT_END && invPlayer != null) + { + return this.invPlayer.getStackInSlot(slot - TileEngineeringTable.CRAFTING_OUTPUT_END) + } + else if (searchInventories) + { + var idDisplacement: Int = TileEngineeringTable.PLAYER_OUTPUT_END + for (dir <- ForgeDirection.VALID_DIRECTIONS) + { + val tile: TileEntity = toVectorWorld.add(dir).getTileEntity + if (tile.isInstanceOf[IInventory]) + { + val inventory: IInventory = tile.asInstanceOf[IInventory] + val slotID: Int = slot - idDisplacement + if (slotID >= 0 && slotID < inventory.getSizeInventory) + { + return inventory.getStackInSlot(slotID) + } + idDisplacement += inventory.getSizeInventory + } + } + } + return null + } + def read(data: ByteBuf, player: EntityPlayer, `type`: PacketType) { try @@ -536,6 +456,124 @@ class TileEngineeringTable extends TileInventory(Material.wood) with IPacketRece } } + override def setInventorySlotContents(slot: Int, itemStack: ItemStack) + { + if (slot < TileEngineeringTable.CRAFTING_MATRIX_END) + { + craftingMatrix(slot) = itemStack + } + else if (slot < TileEngineeringTable.CRAFTING_OUTPUT_END) + { + outputInventory(slot - TileEngineeringTable.CRAFTING_MATRIX_END) = itemStack + } + else if (slot < TileEngineeringTable.PLAYER_OUTPUT_END && this.invPlayer != null) + { + this.invPlayer.setInventorySlotContents(slot - TileEngineeringTable.CRAFTING_OUTPUT_END, itemStack) + val player: EntityPlayer = this.invPlayer.player + if (player.isInstanceOf[EntityPlayerMP]) + { + (player.asInstanceOf[EntityPlayerMP]).sendContainerToPlayer(player.inventoryContainer) + } + } + else if (searchInventories) + { + var idDisplacement: Int = TileEngineeringTable.PLAYER_OUTPUT_END + for (dir <- ForgeDirection.VALID_DIRECTIONS) + { + val tile: TileEntity = toVectorWorld.add(dir).getTileEntity + if (tile.isInstanceOf[IInventory]) + { + val inventory: IInventory = tile.asInstanceOf[IInventory] + val slotID: Int = slot - idDisplacement + if (slotID >= 0 && slotID < inventory.getSizeInventory) + { + inventory.setInventorySlotContents(slotID, itemStack) + } + idDisplacement += inventory.getSizeInventory + } + } + } + onInventoryChanged + } + + /** + * Updates all the output slots. Call this to update the Engineering Table. + */ + override def onInventoryChanged + { + if (worldObj != null) + { + if (!worldObj.isRemote) + { + this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = null + var didCraft: Boolean = false + val inventoryCrafting: InventoryCrafting = this.getCraftingMatrix + val matrixOutput: ItemStack = CraftingManager.getInstance.findMatchingRecipe(inventoryCrafting, this.worldObj) + if (matrixOutput != null && this.getCraftingManager.getIdealRecipe(matrixOutput) != null) + { + this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = matrixOutput + didCraft = true + } + if (!didCraft) + { + val filterStack: ItemStack = craftingMatrix(TileEngineeringTable.CENTER_SLOT) + if (filterStack != null && filterStack.getItem.isInstanceOf[ItemImprint]) + { + val filters: java.util.List[ItemStack] = ItemImprint.getFilters(filterStack) + for (o <- filters) + { + val outputStack: ItemStack = o + if (outputStack != null) + { + val idealRecipe: Pair[ItemStack, Array[ItemStack]] = this.getCraftingManager.getIdealRecipe(outputStack) + if (idealRecipe != null) + { + val recipeOutput: ItemStack = idealRecipe.left + if (recipeOutput != null & recipeOutput.stackSize > 0) + { + this.outputInventory(TileEngineeringTable.CRAFTING_OUTPUT_SLOT) = recipeOutput + didCraft = true + worldObj.markBlockForUpdate(xCoord, yCoord, zCoord) + return + } + } + } + } + } + } + worldObj.markBlockForUpdate(xCoord, yCoord, zCoord) + } + } + } + + /** + * Gets the AutoCraftingManager that does all the crafting results + */ + def getCraftingManager: AutoCraftingManager = + { + if (craftManager == null) + { + craftManager = new AutoCraftingManager(this) + } + return craftManager + } + + /** + * Construct an InventoryCrafting Matrix on the fly. + * + * @return + */ + def getCraftingMatrix: InventoryCrafting = + { + val inventoryCrafting: InventoryCrafting = new InventoryCrafting(new ContainerDummy(this), 3, 3) + + for (i <- 0 until this.craftingMatrix.length) + { + inventoryCrafting.setInventorySlotContents(i, this.craftingMatrix(i)) + } + return inventoryCrafting + } + override def isItemValidForSlot(i: Int, itemstack: ItemStack): Boolean = { return true @@ -583,44 +621,6 @@ class TileEngineeringTable extends TileInventory(Material.wood) with IPacketRece return slot == optimalSlot } - /** - * DO NOT USE THIS INTERNALLY. FOR EXTERNAL USE ONLY! - */ - override def getStackInSlot(slot: Int): ItemStack = - { - if (slot < TileEngineeringTable.CRAFTING_MATRIX_END) - { - return this.craftingMatrix(slot) - } - else if (slot < TileEngineeringTable.CRAFTING_OUTPUT_END) - { - return outputInventory(slot - TileEngineeringTable.CRAFTING_MATRIX_END) - } - else if (slot < TileEngineeringTable.PLAYER_OUTPUT_END && invPlayer != null) - { - return this.invPlayer.getStackInSlot(slot - TileEngineeringTable.CRAFTING_OUTPUT_END) - } - else if (searchInventories) - { - var idDisplacement: Int = TileEngineeringTable.PLAYER_OUTPUT_END - for (dir <- ForgeDirection.VALID_DIRECTIONS) - { - val tile: TileEntity = toVectorWorld.add(dir).getTileEntity - if (tile.isInstanceOf[IInventory]) - { - val inventory: IInventory = tile.asInstanceOf[IInventory] - val slotID: Int = slot - idDisplacement - if (slotID >= 0 && slotID < inventory.getSizeInventory) - { - return inventory.getStackInSlot(slotID) - } - idDisplacement += inventory.getSizeInventory - } - } - } - return null - } - override def canExtractItem(slot: Int, itemstack: ItemStack, side: Int): Boolean = { val outputStack: ItemStack = getStackInSlot(TileEngineeringTable.CRAFTING_MATRIX_END) diff --git a/src/main/scala/edx/basic/fluid/grate/TileGrate.scala b/src/main/scala/edx/basic/fluid/grate/TileGrate.scala index c83909a8c..ff87602f5 100644 --- a/src/main/scala/edx/basic/fluid/grate/TileGrate.scala +++ b/src/main/scala/edx/basic/fluid/grate/TileGrate.scala @@ -82,7 +82,7 @@ class TileGrate extends TileFluidProvider(Material.rock) with TRotatable { val pressure = fluidNode.asInstanceOf[NodeFluidPressure].pressure(getDirection) val blockEffect = Math.abs(pressure * grateEffectMultiplier).toInt - fluidNode.getPrimaryTank.setCapacity(Math.max(blockEffect * FluidContainerRegistry.BUCKET_VOLUME * grateDrainSpeedMultiplier, FluidContainerRegistry.BUCKET_VOLUME).toInt) + fluidNode.getTank.setCapacity(Math.max(blockEffect * FluidContainerRegistry.BUCKET_VOLUME * grateDrainSpeedMultiplier, FluidContainerRegistry.BUCKET_VOLUME).toInt) if (pressure > 0) { diff --git a/src/main/scala/edx/basic/fluid/gutter/NodeFluidGravity.scala b/src/main/scala/edx/basic/fluid/gutter/NodeFluidGravity.scala index 6e9e1017f..85a44b20a 100644 --- a/src/main/scala/edx/basic/fluid/gutter/NodeFluidGravity.scala +++ b/src/main/scala/edx/basic/fluid/gutter/NodeFluidGravity.scala @@ -12,8 +12,8 @@ class NodeFluidGravity(parent: TileFluidProvider, volume: Int = FluidContainerRe { override protected def doDistribute(deltaTime: Double, dir: ForgeDirection, nodeA: NodeFluidPressure, nodeB: NodeFluidPressure, flowRate: Int) { - val tankA = nodeA.getPrimaryTank - val tankB = nodeB.getPrimaryTank + val tankA = nodeA.getTank + val tankB = nodeB.getTank val pressureA = nodeA.pressure(dir) val pressureB = nodeB.pressure(dir.getOpposite) val amountA = tankA.getFluidAmount diff --git a/src/main/scala/edx/basic/fluid/gutter/TileGutter.scala b/src/main/scala/edx/basic/fluid/gutter/TileGutter.scala index b1f833309..36700ae7e 100644 --- a/src/main/scala/edx/basic/fluid/gutter/TileGutter.scala +++ b/src/main/scala/edx/basic/fluid/gutter/TileGutter.scala @@ -5,7 +5,7 @@ import java.util.{ArrayList, List} import cpw.mods.fml.relauncher.{Side, SideOnly} import edx.basic.fluid.tank.TileTank import edx.core.Reference -import edx.core.prefab.node.{NodeFluidPressure, TileFluidProvider} +import edx.core.prefab.node.{NodeFluid, NodeFluidPressure, TileFluidProvider} import net.minecraft.block.Block import net.minecraft.block.material.Material import net.minecraft.entity.Entity @@ -19,7 +19,6 @@ import net.minecraftforge.common.util.ForgeDirection import net.minecraftforge.fluids._ import org.lwjgl.opengl.GL11 import resonantengine.api.edx.recipe.{MachineRecipes, RecipeType} -import resonantengine.lib.prefab.fluid.NodeFluid import resonantengine.lib.render.{FluidRenderUtility, RenderUtility} import resonantengine.lib.transform.region.Cuboid import resonantengine.lib.transform.vector.Vector3 @@ -215,6 +214,34 @@ class TileGutter extends TileFluidProvider(Material.rock) render(0, 0x0) } + override def renderDynamic(pos: Vector3, frame: Float, pass: Int) + { + GL11.glPushMatrix() + GL11.glTranslated(pos.x + 0.5, pos.y + 0.5, pos.z + 0.5) + + render(0, clientRenderMask) + + if (world != null) + { + val tank: IFluidTank = fluidNode + val percentageFilled = tank.getFluidAmount / tank.getCapacity.toDouble + + if (percentageFilled > 0.1) + { + GL11.glPushMatrix() + GL11.glScaled(0.99, 0.99, 0.99) + val ySouthEast = FluidUtility.getAveragePercentageFilledForSides(classOf[TileGutter], percentageFilled, world, toVectorWorld, ForgeDirection.SOUTH, ForgeDirection.EAST) + val yNorthEast = FluidUtility.getAveragePercentageFilledForSides(classOf[TileGutter], percentageFilled, world, toVectorWorld, ForgeDirection.NORTH, ForgeDirection.EAST) + val ySouthWest = FluidUtility.getAveragePercentageFilledForSides(classOf[TileGutter], percentageFilled, world, toVectorWorld, ForgeDirection.SOUTH, ForgeDirection.WEST) + val yNorthWest = FluidUtility.getAveragePercentageFilledForSides(classOf[TileGutter], percentageFilled, world, toVectorWorld, ForgeDirection.NORTH, ForgeDirection.WEST) + FluidRenderUtility.renderFluidTesselation(tank, ySouthEast, yNorthEast, ySouthWest, yNorthWest) + GL11.glPopMatrix() + } + } + + GL11.glPopMatrix() + } + def render(meta: Int, sides: Int) { RenderUtility.bind(TileGutter.texture) @@ -249,34 +276,6 @@ class TileGutter extends TileFluidProvider(Material.rock) } } - override def renderDynamic(pos: Vector3, frame: Float, pass: Int) - { - GL11.glPushMatrix() - GL11.glTranslated(pos.x + 0.5, pos.y + 0.5, pos.z + 0.5) - - render(0, clientRenderMask) - - if (world != null) - { - val tank: IFluidTank = fluidNode - val percentageFilled = tank.getFluidAmount / tank.getCapacity.toDouble - - if (percentageFilled > 0.1) - { - GL11.glPushMatrix() - GL11.glScaled(0.99, 0.99, 0.99) - val ySouthEast = FluidUtility.getAveragePercentageFilledForSides(classOf[TileGutter], percentageFilled, world, toVectorWorld, ForgeDirection.SOUTH, ForgeDirection.EAST) - val yNorthEast = FluidUtility.getAveragePercentageFilledForSides(classOf[TileGutter], percentageFilled, world, toVectorWorld, ForgeDirection.NORTH, ForgeDirection.EAST) - val ySouthWest = FluidUtility.getAveragePercentageFilledForSides(classOf[TileGutter], percentageFilled, world, toVectorWorld, ForgeDirection.SOUTH, ForgeDirection.WEST) - val yNorthWest = FluidUtility.getAveragePercentageFilledForSides(classOf[TileGutter], percentageFilled, world, toVectorWorld, ForgeDirection.NORTH, ForgeDirection.WEST) - FluidRenderUtility.renderFluidTesselation(tank, ySouthEast, yNorthEast, ySouthWest, yNorthWest) - GL11.glPopMatrix() - } - } - - GL11.glPopMatrix() - } - //Recurse through all gutter blocks private def findGutters(traverse: Set[NodeGutter] = Set(fluidNode.asInstanceOf[NodeGutter])): Set[NodeGutter] = { @@ -291,7 +290,7 @@ class TileGutter extends TileFluidProvider(Material.rock) return foundGutters } - private def findAllTanks = findGutters().map(_.getPrimaryTank).toList + private def findAllTanks = findGutters().map(_.getTank).toList class NodeGutter(parent: TileFluidProvider) extends NodeFluidGravity(parent) { diff --git a/src/main/scala/edx/basic/fluid/tank/TileTank.scala b/src/main/scala/edx/basic/fluid/tank/TileTank.scala index 1b6f997fb..b642b8a44 100644 --- a/src/main/scala/edx/basic/fluid/tank/TileTank.scala +++ b/src/main/scala/edx/basic/fluid/tank/TileTank.scala @@ -17,8 +17,8 @@ import net.minecraft.world.IBlockAccess import net.minecraftforge.common.util.ForgeDirection import net.minecraftforge.fluids._ import org.lwjgl.opengl.GL11 -import resonantengine.api.tile.IRemovable.ISneakPickup import resonantengine.api.graph.node.INode +import resonantengine.api.tile.IRemovable.ISneakPickup import resonantengine.lib.grid.core.Node import resonantengine.lib.render.block.RenderConnectedTexture import resonantengine.lib.render.{FluidRenderUtility, RenderBlockUtility, RenderUtility} @@ -85,9 +85,9 @@ class TileTank extends TileFluidProvider(Material.iron) with ISneakPickup with R override def getLightValue(access: IBlockAccess): Int = { - if (fluidNode.getPrimaryTank.getFluid != null && fluidNode.getPrimaryTank.getFluid.getFluid != null) + if (fluidNode.getTank.getFluid != null && fluidNode.getTank.getFluid.getFluid != null) { - return fluidNode.getPrimaryTank.getFluid.getFluid.getLuminosity + return fluidNode.getTank.getFluid.getFluid.getLuminosity } return super.getLightValue(access) @@ -103,7 +103,7 @@ class TileTank extends TileFluidProvider(Material.iron) with ISneakPickup with R @SideOnly(Side.CLIENT) override def renderDynamic(position: Vector3, frame: Float, pass: Int) { - renderTankFluid(position.x, position.y, position.z, fluidNode.getPrimaryTank.getFluid) + renderTankFluid(position.x, position.y, position.z, fluidNode.getTank.getFluid) } /** @@ -122,7 +122,7 @@ class TileTank extends TileFluidProvider(Material.iron) with ISneakPickup with R if (!fluid.getFluid.isGaseous) { GL11.glScaled(0.99, 0.99, 0.99) - val tank: IFluidTank = fluidNode.getPrimaryTank + val tank: IFluidTank = fluidNode.getTank val percentageFilled: Double = tank.getFluidAmount.toDouble / tank.getCapacity.toDouble val ySouthEast = FluidUtility.getAveragePercentageFilledForSides(classOf[TileTank], percentageFilled, world, toVector3, ForgeDirection.SOUTH, ForgeDirection.EAST) val yNorthEast = FluidUtility.getAveragePercentageFilledForSides(classOf[TileTank], percentageFilled, world, toVector3, ForgeDirection.NORTH, ForgeDirection.EAST) @@ -145,7 +145,7 @@ class TileTank extends TileFluidProvider(Material.iron) with ISneakPickup with R if (itemStack.getTagCompound != null && itemStack.getTagCompound.hasKey("fluid")) { - renderInventoryFluid(0, 0, 0, FluidStack.loadFluidStackFromNBT(itemStack.getTagCompound.getCompoundTag("fluid")), fluidNode.getPrimaryTank.getCapacity) + renderInventoryFluid(0, 0, 0, FluidStack.loadFluidStackFromNBT(itemStack.getTagCompound.getCompoundTag("fluid")), fluidNode.getTank.getCapacity) } GL11.glPopMatrix() diff --git a/src/main/scala/edx/core/prefab/item/ItemFluidBucket.java b/src/main/scala/edx/core/prefab/item/ItemFluidBucket.java new file mode 100644 index 000000000..cea9ffd6f --- /dev/null +++ b/src/main/scala/edx/core/prefab/item/ItemFluidBucket.java @@ -0,0 +1,196 @@ +package edx.core.prefab.item; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.world.World; +import net.minecraftforge.fluids.*; +import resonantengine.core.Reference; + +import java.util.List; + +/** + * Basic Item that acts like a bucket but stores its fluid inside NBT allowing it to contain any fluid + * + * @author Darkgurdsman + */ +public class ItemFluidBucket extends ItemFluidContainer +{ + //TODO implement materials for bucket body allowing for molten fluids to more realistically be stored + @SideOnly(Side.CLIENT) + IIcon icon_bucket; + + @SideOnly(Side.CLIENT) + IIcon icon_fluid; + + public ItemFluidBucket() + { + super(0, FluidContainerRegistry.BUCKET_VOLUME); + this.setUnlocalizedName(Items.bucket.getUnlocalizedName()); + this.setContainerItem(Items.bucket); + } + + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister reg) + { + this.icon_bucket = reg.registerIcon(Reference.prefix() + "bucket_pass"); + this.icon_fluid = reg.registerIcon(Reference.prefix() + "bucket_fluid_pass"); + } + + @SideOnly(Side.CLIENT) + public int getColorFromItemStack(ItemStack stack, int pass) + { + FluidStack fluidStack = this.getFluid(stack); + if (fluidStack != null && fluidStack.getFluid() != null && pass == 1) + { + return fluidStack.getFluid().getColor(); + } + return super.getColorFromItemStack(stack, pass); + } + + @SideOnly(Side.CLIENT) @Override + public IIcon getIcon(ItemStack stack, int pass) + { + FluidStack fluidStack = this.getFluid(stack); + if (fluidStack != null && fluidStack.getFluid() != null) + { + Fluid fluid = fluidStack.getFluid(); + if (fluid == FluidRegistry.LAVA) + { + return Items.lava_bucket.getIcon(stack, pass); + } + else if (fluid == FluidRegistry.WATER) + { + return Items.water_bucket.getIcon(stack, pass); + } + else if (pass == 0) + { + return icon_bucket; + } + else if (pass == 1) + { + return icon_fluid; + } + } + return Items.bucket.getIcon(stack, pass); + } + + @SideOnly(Side.CLIENT) @Override + public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean bool) + { + FluidStack fluidStack = this.getFluid(stack); + if (fluidStack != null && fluidStack.getFluid() != null) + { + list.add("F: " + fluidStack.getFluid()); + list.add("V: " + fluidStack.amount + "mL"); + } + } + + @Override + public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) + { + if (this.getFluid(stack) == null) + { + return new ItemStack(Items.bucket); + } + else + { + MovingObjectPosition movingobjectposition = this.getMovingObjectPositionFromPlayer(world, player, false); + if (movingobjectposition == null) + { + return stack; + } + if (movingobjectposition.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) + { + int i = movingobjectposition.blockX; + int j = movingobjectposition.blockY; + int k = movingobjectposition.blockZ; + + if (!world.canMineBlock(player, i, j, k)) + { + return stack; + } + + if (movingobjectposition.sideHit == 0) + { + --j; + } + + if (movingobjectposition.sideHit == 1) + { + ++j; + } + + if (movingobjectposition.sideHit == 2) + { + --k; + } + + if (movingobjectposition.sideHit == 3) + { + ++k; + } + + if (movingobjectposition.sideHit == 4) + { + --i; + } + + if (movingobjectposition.sideHit == 5) + { + ++i; + } + + if (!player.canPlayerEdit(i, j, k, movingobjectposition.sideHit, stack)) + { + return stack; + } + + //TODO if bored fix so that stacked buckets work correctly + if (this.tryPlaceContainedLiquid(stack, world, i, j, k) && !player.capabilities.isCreativeMode) + { + return new ItemStack(Items.bucket); + } + } + + return stack; + } + } + + /** + * Attempts to place the liquid contained inside the bucket. + */ + public boolean tryPlaceContainedLiquid(ItemStack stack, World world, int x, int y, int z) + { + FluidStack fluidStack = this.getFluid(stack); + if (fluidStack != null && fluidStack.getFluid() != null && fluidStack.getFluid().getBlock() != null) + { + Material material = world.getBlock(x, y, z).getMaterial(); + boolean flag = !material.isSolid(); + + if (!world.isAirBlock(x, y, z) && !flag) + { + return false; + } + else + { + + if (!world.isRemote && flag && !material.isLiquid()) + { + world.func_147480_a(x, y, z, true); + } + + world.setBlock(x, y, z, fluidStack.getFluid().getBlock(), 0, 3); + + return true; + } + } + return false; + } +} diff --git a/src/main/scala/edx/core/prefab/node/NodeFluid.scala b/src/main/scala/edx/core/prefab/node/NodeFluid.scala new file mode 100644 index 000000000..deaeccc9a --- /dev/null +++ b/src/main/scala/edx/core/prefab/node/NodeFluid.scala @@ -0,0 +1,106 @@ +package edx.core.prefab.node + +import net.minecraft.nbt.NBTTagCompound +import net.minecraftforge.common.util.ForgeDirection +import net.minecraftforge.fluids._ +import resonantengine.api.graph.INodeProvider +import resonantengine.api.graph.node.INode +import resonantengine.api.misc.ISave +import resonantengine.lib.grid.core.{NodeConnector, TTileConnector} +import resonantengine.prefab.fluid.{TFluidHandler, TFluidTank} + +/** + * A node that handles fluid interactions + * + * @param parent Parent(TileEntity or Multipart) that contains this node + * @param volume Amount of fluid in liters + * @author Calclavia + */ +class NodeFluid(parent: INodeProvider, volume: Int = FluidContainerRegistry.BUCKET_VOLUME) extends NodeConnector[IFluidHandler](parent) with ISave with TFluidHandler with TFluidTank with TTileConnector[IFluidHandler] +{ + var onFluidChanged: () => Unit = () => () + /** Internal tank */ + private var tank = new FluidTank(volume) + + override def fill(from: ForgeDirection, resource: FluidStack, doFill: Boolean): Int = + { + tank synchronized + { + if (canConnect(from)) + { + val ret = super.fill(from, resource, doFill) + onFluidChanged() + return ret + } + return 0 + } + } + + override def drain(from: ForgeDirection, resource: FluidStack, doDrain: Boolean): FluidStack = + { + tank synchronized + { + if (canConnect(from)) + { + val ret = super.drain(from, resource, doDrain) + onFluidChanged() + return ret + } + return null + } + } + + override def drain(from: ForgeDirection, maxDrain: Int, doDrain: Boolean): FluidStack = + { + tank synchronized + { + if (canConnect(from)) + { + val ret = super.drain(from, maxDrain, doDrain) + onFluidChanged() + return ret + } + + return null + } + } + + override def canFill(from: ForgeDirection, fluid: Fluid): Boolean = canConnect(from) + + override def canDrain(from: ForgeDirection, fluid: Fluid): Boolean = canConnect(from) + + override def load(nbt: NBTTagCompound) + { + getTank.readFromNBT(nbt.getCompoundTag("tank")) + } + + override def save(nbt: NBTTagCompound) + { + nbt.setTag("tank", getTank.writeToNBT(new NBTTagCompound)) + } + + override def getTank: FluidTank = tank + + /** + * Sets the primary tank (not checked) + * @param t - The new tank + */ + def setPrimaryTank(t: FluidTank) = tank = t + + /** + * The class used to compare when making connections + */ + override protected def getCompareClass: Class[_ <: NodeFluid with INode] = classOf[NodeFluid] + + protected def showConnectionsFor(obj: AnyRef, dir: ForgeDirection): Boolean = + { + if (obj != null) + { + if (obj.getClass.isAssignableFrom(getParent.getClass)) + { + return true + } + } + return false + } +} diff --git a/src/main/scala/edx/core/prefab/node/NodeFluidPressure.scala b/src/main/scala/edx/core/prefab/node/NodeFluidPressure.scala index 00f36af70..f0c0f1e00 100644 --- a/src/main/scala/edx/core/prefab/node/NodeFluidPressure.scala +++ b/src/main/scala/edx/core/prefab/node/NodeFluidPressure.scala @@ -2,9 +2,8 @@ package edx.core.prefab.node import net.minecraftforge.common.util.ForgeDirection import net.minecraftforge.fluids.{FluidContainerRegistry, IFluidHandler} -import resonantengine.api.graph.{IUpdate, INodeProvider} +import resonantengine.api.graph.{INodeProvider, IUpdate} import resonantengine.lib.grid.core.UpdateTicker -import resonantengine.lib.prefab.fluid.NodeFluid import scala.collection.convert.wrapAll._ @@ -66,7 +65,7 @@ class NodeFluidPressure(parent: INodeProvider, volume: Int = FluidContainerRegis //High pressure to low if (pressureA >= pressureB) { - val tankA = getPrimaryTank + val tankA = getTank if (tankA != null) { @@ -78,7 +77,7 @@ class NodeFluidPressure(parent: INodeProvider, volume: Int = FluidContainerRegis if (amountA > 0) { - val tankB = otherNode.getPrimaryTank + val tankB = otherNode.getTank if (tankB != null) { @@ -94,7 +93,7 @@ class NodeFluidPressure(parent: INodeProvider, volume: Int = FluidContainerRegis //It's a fluid handler. val pressure = this.pressure(dir) val tankPressure = 0 - val sourceTank = getPrimaryTank + val sourceTank = getTank val transferAmount = (Math.max(pressure, tankPressure) - Math.min(pressure, tankPressure)) * flowRate if (pressure > tankPressure) @@ -124,8 +123,8 @@ class NodeFluidPressure(parent: INodeProvider, volume: Int = FluidContainerRegis protected def doDistribute(deltaTime: Double, dir: ForgeDirection, nodeA: NodeFluidPressure, nodeB: NodeFluidPressure, flowRate: Int) { - val tankA = nodeA.getPrimaryTank - val tankB = nodeB.getPrimaryTank + val tankA = nodeA.getTank + val tankB = nodeB.getTank val pressureA = nodeA.pressure(dir) val pressureB = nodeB.pressure(dir.getOpposite) val amountA = tankA.getFluidAmount diff --git a/src/main/scala/edx/core/prefab/node/TileFluidProvider.scala b/src/main/scala/edx/core/prefab/node/TileFluidProvider.scala index 1402acc53..af7aeb4df 100644 --- a/src/main/scala/edx/core/prefab/node/TileFluidProvider.scala +++ b/src/main/scala/edx/core/prefab/node/TileFluidProvider.scala @@ -7,7 +7,6 @@ import net.minecraftforge.common.util.ForgeDirection import net.minecraftforge.fluids._ import resonantengine.core.network.discriminator.PacketType import resonantengine.lib.modcontent.block.ResonantTile -import resonantengine.lib.prefab.fluid.NodeFluid import resonantengine.lib.wrapper.ByteBufWrapper._ import resonantengine.prefab.block.impl.TBlockNodeProvider import resonantengine.prefab.network.{TPacketReceiver, TPacketSender} @@ -43,11 +42,11 @@ abstract class TileFluidProvider(material: Material) extends ResonantTile(materi { buf <<< colorID buf <<< clientRenderMask - buf <<< fluidNode.getPrimaryTank + buf <<< fluidNode.getTank } case 1 => { - buf <<< fluidNode.getPrimaryTank + buf <<< fluidNode.getTank } } } @@ -76,8 +75,6 @@ abstract class TileFluidProvider(material: Material) extends ResonantTile(materi } } - def fluidNode = _fluidNode - override def readFromNBT(nbt: NBTTagCompound) { super.readFromNBT(nbt) @@ -85,6 +82,17 @@ abstract class TileFluidProvider(material: Material) extends ResonantTile(materi colorID = nbt.getInteger("colorID") } + def fluidNode = _fluidNode + + override def writeToNBT(nbt: NBTTagCompound) + { + super.writeToNBT(nbt) + fluidNode.save(nbt) + nbt.setInteger("colorID", colorID) + } + + override def drain(from: ForgeDirection, resource: FluidStack, doDrain: Boolean): FluidStack = fluidNode.drain(from, resource, doDrain) + def fluidNode_=(newNode: NodeFluid) { _fluidNode = newNode @@ -97,15 +105,6 @@ abstract class TileFluidProvider(material: Material) extends ResonantTile(materi nodes.add(fluidNode) } - override def writeToNBT(nbt: NBTTagCompound) - { - super.writeToNBT(nbt) - fluidNode.save(nbt) - nbt.setInteger("colorID", colorID) - } - - override def drain(from: ForgeDirection, resource: FluidStack, doDrain: Boolean): FluidStack = fluidNode.drain(from, resource, doDrain) - override def drain(from: ForgeDirection, maxDrain: Int, doDrain: Boolean): FluidStack = fluidNode.drain(from, maxDrain, doDrain) override def canFill(from: ForgeDirection, fluid: Fluid): Boolean = fluidNode.canFill(from, fluid) diff --git a/src/main/scala/edx/electrical/battery/ItemBlockBattery.scala b/src/main/scala/edx/electrical/battery/ItemBlockBattery.scala index 2d4cae8f9..a16fcba52 100644 --- a/src/main/scala/edx/electrical/battery/ItemBlockBattery.scala +++ b/src/main/scala/edx/electrical/battery/ItemBlockBattery.scala @@ -8,11 +8,9 @@ import net.minecraft.entity.player.EntityPlayer import net.minecraft.item.{Item, ItemBlock, ItemStack} import net.minecraft.nbt.NBTTagCompound import net.minecraft.world.World -import resonantengine.api.item.IEnergyItem -import resonantengine.lib.render.EnumColor import resonantengine.lib.utility.LanguageUtility -import resonantengine.lib.utility.science.UnitDisplay import resonantengine.lib.wrapper.CollectionWrapper._ +import resonantengine.prefab.item.TEnergyItem object ItemBlockBattery { @@ -36,7 +34,7 @@ object ItemBlockBattery } } -class ItemBlockBattery(block: Block) extends ItemBlock(block) with IEnergyItem +class ItemBlockBattery(block: Block) extends ItemBlock(block) with TEnergyItem { this.setMaxStackSize(1) this.setMaxDamage(100) @@ -45,22 +43,7 @@ class ItemBlockBattery(block: Block) extends ItemBlock(block) with IEnergyItem override def addInformation(itemStack: ItemStack, entityPlayer: EntityPlayer, list: List[_], par4: Boolean) { list.add(LanguageUtility.getLocal("tooltip.tier") + ": " + (ItemBlockBattery.getTier(itemStack) + 1)) - var color: String = "" - val joules: Double = this.getEnergy(itemStack) - if (joules <= this.getEnergyCapacity(itemStack) / 3) - { - color = "\u00a74" - } - else if (joules > this.getEnergyCapacity(itemStack) * 2 / 3) - { - color = "\u00a72" - } - else - { - color = "\u00a76" - } - itemStack.getItemDamageForDisplay - list.add(LanguageUtility.getLocal("tooltip.battery.energy").replace("%0", color).replace("%1", EnumColor.GREY.toString).replace("%v0", new UnitDisplay(UnitDisplay.Unit.JOULES, joules).symbol.toString).replace("%v1", new UnitDisplay(UnitDisplay.Unit.JOULES, this.getEnergyCapacity(itemStack), true).symbol.toString)) + super.addInformation(itemStack, entityPlayer, list, par4) } /** @@ -72,28 +55,7 @@ class ItemBlockBattery(block: Block) extends ItemBlock(block) with IEnergyItem this.setEnergy(itemStack, 0) } - def recharge(itemStack: ItemStack, energy: Double, doReceive: Boolean): Double = - { - val rejectedElectricity: Double = Math.max((this.getEnergy(itemStack) + energy) - this.getEnergyCapacity(itemStack), 0) - val energyToReceive: Double = Math.min(energy - rejectedElectricity, getTransferRate(itemStack)) - if (doReceive) - { - this.setEnergy(itemStack, this.getEnergy(itemStack) + energyToReceive) - } - return energyToReceive - } - - def discharge(itemStack: ItemStack, energy: Double, doTransfer: Boolean): Double = - { - val energyToExtract: Double = Math.min(Math.min(this.getEnergy(itemStack), energy), getTransferRate(itemStack)) - if (doTransfer) - { - setEnergy(itemStack, this.getEnergy(itemStack) - energyToExtract) - } - return energyToExtract - } - - def setEnergy(itemStack: ItemStack, joules: Double): ItemStack = + override def setEnergy(itemStack: ItemStack, joules: Double): ItemStack = { if (itemStack.getTagCompound == null) { @@ -104,30 +66,30 @@ class ItemBlockBattery(block: Block) extends ItemBlock(block) with IEnergyItem return itemStack } - def getTransferRate(itemStack: ItemStack): Double = - { - return this.getEnergyCapacity(itemStack) / 100 - } - def getEnergyCapacity(theItem: ItemStack): Double = { return TileBattery.getEnergyForTier(ItemBlockBattery.getTier(theItem)) } - /** Gets the energy stored in the item. Energy is stored using item NBT */ - def getEnergy(itemStack: ItemStack): Double = + override def recharge(itemStack: ItemStack, energy: Double, doReceive: Boolean): Double = { - if (itemStack.getTagCompound == null) + val rejectedElectricity: Double = Math.max((this.getEnergy(itemStack) + energy) - this.getEnergyCapacity(itemStack), 0) + val energyToReceive: Double = Math.min(energy - rejectedElectricity, getTransferRate(itemStack)) + if (doReceive) { - itemStack.setTagCompound(new NBTTagCompound) + this.setEnergy(itemStack, this.getEnergy(itemStack) + energyToReceive) } - val energyStored = itemStack.getTagCompound.getDouble("energy") - return energyStored + return energyToReceive } - def getTransfer(itemStack: ItemStack): Double = + override def discharge(itemStack: ItemStack, energy: Double, doTransfer: Boolean): Double = { - return this.getEnergyCapacity(itemStack) - this.getEnergy(itemStack) + val energyToExtract: Double = Math.min(Math.min(this.getEnergy(itemStack), energy), getTransferRate(itemStack)) + if (doTransfer) + { + setEnergy(itemStack, this.getEnergy(itemStack) - energyToExtract) + } + return energyToExtract } override def getDisplayDamage(stack: ItemStack): Int = @@ -135,12 +97,10 @@ class ItemBlockBattery(block: Block) extends ItemBlock(block) with IEnergyItem return (100 - (getEnergy(stack) / getEnergyCapacity(stack)) * 100).toInt } - @SuppressWarnings(Array("unchecked")) override def getSubItems(par1: Item, par2CreativeTabs: CreativeTabs, list: List[_]) { for (tier <- 0 to TileBattery.maxTier) { - //TODO: Make traits for this list.add(setEnergy(ItemBlockBattery.setTier(new ItemStack(this), tier), 0)) list.add(setEnergy(ItemBlockBattery.setTier(new ItemStack(this), tier), TileBattery.getEnergyForTier(tier))) } diff --git a/src/main/scala/edx/electrical/multimeter/GuiMultimeter.scala b/src/main/scala/edx/electrical/multimeter/GuiMultimeter.scala index 160dca1b2..afc5bf3ed 100644 --- a/src/main/scala/edx/electrical/multimeter/GuiMultimeter.scala +++ b/src/main/scala/edx/electrical/multimeter/GuiMultimeter.scala @@ -6,10 +6,10 @@ package edx.electrical.multimeter import cpw.mods.fml.relauncher.{Side, SideOnly} import net.minecraft.client.gui.{GuiButton, GuiTextField} import net.minecraft.entity.player.InventoryPlayer -import resonantengine.lib.prefab.gui.GuiContainerBase import resonantengine.lib.render.EnumColor import resonantengine.lib.utility.LanguageUtility import resonantengine.lib.wrapper.CollectionWrapper._ +import resonantengine.prefab.gui.GuiContainerBase /** * Multimeter GUI diff --git a/src/main/scala/edx/mechanical/fluid/pipe/PartPipe.scala b/src/main/scala/edx/mechanical/fluid/pipe/PartPipe.scala index f723e96e2..065eb2abb 100644 --- a/src/main/scala/edx/mechanical/fluid/pipe/PartPipe.scala +++ b/src/main/scala/edx/mechanical/fluid/pipe/PartPipe.scala @@ -87,7 +87,7 @@ class PartPipe extends PartFramedNode with TMaterial[PipeMaterial] with TColorab //node Packet val nbt = new NBTTagCompound val averageAmount = averageTankData.reduce(_ + _) / averageTankData.size - val tempTank = node.getPrimaryTank //if (node.getFluid != null) new FluidTank(node.getFluid.getFluid, averageAmount, node.getCapacity) else new FluidTank(node.getCapacity) + val tempTank = node.getTank //if (node.getFluid != null) new FluidTank(node.getFluid.getFluid, averageAmount, node.getCapacity) else new FluidTank(node.getCapacity) tempTank.writeToNBT(nbt) packet.writeInt(node.getCapacity).writeNBTTagCompound(nbt) } @@ -102,7 +102,7 @@ class PartPipe extends PartFramedNode with TMaterial[PipeMaterial] with TColorab if (packetID == 3 && world.isRemote) { node.setPrimaryTank(new FluidTank(packet.readInt)) - node.getPrimaryTank.readFromNBT(packet.readNBTTagCompound) + node.getTank.readFromNBT(packet.readNBTTagCompound) } } diff --git a/src/main/scala/edx/quantum/QuantumContent.scala b/src/main/scala/edx/quantum/QuantumContent.scala index 38718bfe1..02d82c7c7 100644 --- a/src/main/scala/edx/quantum/QuantumContent.scala +++ b/src/main/scala/edx/quantum/QuantumContent.scala @@ -343,7 +343,7 @@ object QuantumContent extends ContentHolder */ if (tile.isInstanceOf[TileTank]) { - val fluidStack = tile.asInstanceOf[TileTank].fluidNode.getPrimaryTank.getFluid + val fluidStack = tile.asInstanceOf[TileTank].fluidNode.getTank.getFluid if (fluidStack != null) fluidStack.setTemperature(evt.temperature) diff --git a/src/main/scala/edx/quantum/items/ItemCell.scala b/src/main/scala/edx/quantum/items/ItemCell.scala index 05c7e4a1a..4cad6ecc4 100644 --- a/src/main/scala/edx/quantum/items/ItemCell.scala +++ b/src/main/scala/edx/quantum/items/ItemCell.scala @@ -3,8 +3,8 @@ package edx.quantum.items import edx.core.{EDXCreativeTab, Reference} import edx.quantum.QuantumContent import net.minecraft.item.ItemStack -import resonantengine.lib.prefab.item.ItemTooltip import resonantengine.lib.utility.LanguageUtility +import resonantengine.prefab.item.ItemTooltip class ItemCell extends ItemTooltip { diff --git a/src/main/scala/edx/quantum/machine/accelerator/ContainerAccelerator.scala b/src/main/scala/edx/quantum/machine/accelerator/ContainerAccelerator.scala index db8b6b9d5..0fae85baf 100644 --- a/src/main/scala/edx/quantum/machine/accelerator/ContainerAccelerator.scala +++ b/src/main/scala/edx/quantum/machine/accelerator/ContainerAccelerator.scala @@ -4,7 +4,7 @@ import edx.quantum.QuantumContent import net.minecraft.entity.player.EntityPlayer import net.minecraft.inventory.{IInventory, Slot, SlotFurnace} import net.minecraft.item.ItemStack -import resonantengine.lib.prefab.gui.ContainerBase +import resonantengine.prefab.gui.ContainerBase /** * Accelerator container diff --git a/src/main/scala/edx/quantum/machine/accelerator/GuiAccelerator.scala b/src/main/scala/edx/quantum/machine/accelerator/GuiAccelerator.scala index b0e9a3b3c..1a2b1be56 100644 --- a/src/main/scala/edx/quantum/machine/accelerator/GuiAccelerator.scala +++ b/src/main/scala/edx/quantum/machine/accelerator/GuiAccelerator.scala @@ -2,9 +2,9 @@ package edx.quantum.machine.accelerator import edx.core.Settings import net.minecraft.entity.player.EntityPlayer -import resonantengine.lib.prefab.gui.GuiContainerBase import resonantengine.lib.transform.vector.Vector3 import resonantengine.lib.utility.science.UnitDisplay +import resonantengine.prefab.gui.GuiContainerBase class GuiAccelerator(player: EntityPlayer, tileEntity: TileAccelerator) extends GuiContainerBase(new ContainerAccelerator(player, tileEntity)) { diff --git a/src/main/scala/edx/quantum/machine/boiler/ContainerNuclearBoiler.scala b/src/main/scala/edx/quantum/machine/boiler/ContainerNuclearBoiler.scala index c547dd11e..553f689f4 100644 --- a/src/main/scala/edx/quantum/machine/boiler/ContainerNuclearBoiler.scala +++ b/src/main/scala/edx/quantum/machine/boiler/ContainerNuclearBoiler.scala @@ -5,8 +5,8 @@ import net.minecraft.entity.player.EntityPlayer import net.minecraft.inventory.{IInventory, Slot} import net.minecraft.item.ItemStack import net.minecraftforge.fluids.FluidContainerRegistry -import resonantengine.lib.prefab.gui.ContainerBase -import resonantengine.lib.prefab.gui.slot.{SlotEnergyItem, SlotSpecific} +import resonantengine.prefab.gui.ContainerBase +import resonantengine.prefab.gui.slot.{SlotEnergyItem, SlotSpecific} /** * Nuclear boiler container diff --git a/src/main/scala/edx/quantum/machine/boiler/GuiNuclearBoiler.scala b/src/main/scala/edx/quantum/machine/boiler/GuiNuclearBoiler.scala index 24c0411e2..b3fb8b810 100644 --- a/src/main/scala/edx/quantum/machine/boiler/GuiNuclearBoiler.scala +++ b/src/main/scala/edx/quantum/machine/boiler/GuiNuclearBoiler.scala @@ -2,9 +2,9 @@ package edx.quantum.machine.boiler import net.minecraft.entity.player.EntityPlayer import net.minecraft.util.StatCollector -import resonantengine.lib.prefab.gui.GuiContainerBase -import resonantengine.lib.prefab.gui.GuiContainerBase.SlotType import resonantengine.lib.utility.science.UnitDisplay +import resonantengine.prefab.gui.GuiContainerBase +import resonantengine.prefab.gui.GuiContainerBase.SlotType class GuiNuclearBoiler(player: EntityPlayer, tileEntity: TileNuclearBoiler) extends GuiContainerBase(new ContainerNuclearBoiler(player, tileEntity)) { diff --git a/src/main/scala/edx/quantum/machine/centrifuge/ContainerCentrifuge.scala b/src/main/scala/edx/quantum/machine/centrifuge/ContainerCentrifuge.scala index 06b059922..8c98f9bd0 100644 --- a/src/main/scala/edx/quantum/machine/centrifuge/ContainerCentrifuge.scala +++ b/src/main/scala/edx/quantum/machine/centrifuge/ContainerCentrifuge.scala @@ -4,8 +4,8 @@ import edx.quantum.QuantumContent import net.minecraft.entity.player.{EntityPlayer, InventoryPlayer} import net.minecraft.inventory.{IInventory, Slot, SlotFurnace} import net.minecraft.item.ItemStack -import resonantengine.lib.prefab.gui.ContainerBase -import resonantengine.lib.prefab.gui.slot.SlotEnergyItem +import resonantengine.prefab.gui.ContainerBase +import resonantengine.prefab.gui.slot.SlotEnergyItem class ContainerCentrifuge(par1InventoryPlayer: InventoryPlayer, tileEntity: TileCentrifuge) extends ContainerBase(tileEntity) { diff --git a/src/main/scala/edx/quantum/machine/centrifuge/GuiCentrifuge.scala b/src/main/scala/edx/quantum/machine/centrifuge/GuiCentrifuge.scala index 5b7c60274..3f6eb92df 100644 --- a/src/main/scala/edx/quantum/machine/centrifuge/GuiCentrifuge.scala +++ b/src/main/scala/edx/quantum/machine/centrifuge/GuiCentrifuge.scala @@ -2,9 +2,9 @@ package edx.quantum.machine.centrifuge import net.minecraft.entity.player.InventoryPlayer import net.minecraft.util.StatCollector -import resonantengine.lib.prefab.gui.GuiContainerBase -import resonantengine.lib.prefab.gui.GuiContainerBase.SlotType import resonantengine.lib.utility.science.UnitDisplay +import resonantengine.prefab.gui.GuiContainerBase +import resonantengine.prefab.gui.GuiContainerBase.SlotType class GuiCentrifuge(par1InventoryPlayer: InventoryPlayer, tileEntity: TileCentrifuge) extends GuiContainerBase(new ContainerCentrifuge(par1InventoryPlayer, tileEntity)) { diff --git a/src/main/scala/edx/quantum/machine/extractor/ContainerChemicalExtractor.scala b/src/main/scala/edx/quantum/machine/extractor/ContainerChemicalExtractor.scala index 6abb113e1..c47089623 100644 --- a/src/main/scala/edx/quantum/machine/extractor/ContainerChemicalExtractor.scala +++ b/src/main/scala/edx/quantum/machine/extractor/ContainerChemicalExtractor.scala @@ -2,8 +2,8 @@ package edx.quantum.machine.extractor import net.minecraft.entity.player.InventoryPlayer import net.minecraft.inventory.{Slot, SlotFurnace} -import resonantengine.lib.prefab.gui.ContainerBase -import resonantengine.lib.prefab.gui.slot.SlotEnergyItem +import resonantengine.prefab.gui.ContainerBase +import resonantengine.prefab.gui.slot.SlotEnergyItem /** * Chemical extractor container diff --git a/src/main/scala/edx/quantum/machine/extractor/GuiChemicalExtractor.scala b/src/main/scala/edx/quantum/machine/extractor/GuiChemicalExtractor.scala index 2ba52ad2c..d2727015e 100644 --- a/src/main/scala/edx/quantum/machine/extractor/GuiChemicalExtractor.scala +++ b/src/main/scala/edx/quantum/machine/extractor/GuiChemicalExtractor.scala @@ -2,9 +2,9 @@ package edx.quantum.machine.extractor import net.minecraft.entity.player.InventoryPlayer import net.minecraft.util.StatCollector -import resonantengine.lib.prefab.gui.GuiContainerBase -import resonantengine.lib.prefab.gui.GuiContainerBase.SlotType import resonantengine.lib.utility.science.UnitDisplay +import resonantengine.prefab.gui.GuiContainerBase +import resonantengine.prefab.gui.GuiContainerBase.SlotType class GuiChemicalExtractor(par1InventoryPlayer: InventoryPlayer, tileEntity: TileChemicalExtractor) extends GuiContainerBase(new ContainerChemicalExtractor(par1InventoryPlayer, tileEntity)) { diff --git a/src/main/scala/edx/quantum/machine/quantum/GuiQuantumAssembler.scala b/src/main/scala/edx/quantum/machine/quantum/GuiQuantumAssembler.scala index 4373130dd..62ee18304 100644 --- a/src/main/scala/edx/quantum/machine/quantum/GuiQuantumAssembler.scala +++ b/src/main/scala/edx/quantum/machine/quantum/GuiQuantumAssembler.scala @@ -5,8 +5,8 @@ import edx.core.Reference import net.minecraft.entity.player.InventoryPlayer import net.minecraft.util.ResourceLocation import org.lwjgl.opengl.GL11 -import resonantengine.lib.prefab.gui.GuiContainerBase import resonantengine.lib.utility.science.UnitDisplay +import resonantengine.prefab.gui.GuiContainerBase object GuiQuantumAssembler { diff --git a/src/main/scala/edx/quantum/reactor/ContainerReactorCell.scala b/src/main/scala/edx/quantum/reactor/ContainerReactorCell.scala index 55952a7aa..7d5456a62 100644 --- a/src/main/scala/edx/quantum/reactor/ContainerReactorCell.scala +++ b/src/main/scala/edx/quantum/reactor/ContainerReactorCell.scala @@ -4,8 +4,8 @@ import edx.quantum.items.{ItemBreederFuel, ItemFuelRod} import net.minecraft.entity.player.EntityPlayer import net.minecraft.inventory.Slot import net.minecraft.item.ItemStack -import resonantengine.lib.prefab.gui.ContainerBase -import resonantengine.lib.prefab.gui.slot.SlotSpecific +import resonantengine.prefab.gui.ContainerBase +import resonantengine.prefab.gui.slot.SlotSpecific class ContainerReactorCell(player: EntityPlayer, tileEntity: TileReactorCell) extends ContainerBase(tileEntity) { diff --git a/src/main/scala/edx/quantum/reactor/GuiReactorCell.scala b/src/main/scala/edx/quantum/reactor/GuiReactorCell.scala index 5eaabdefe..bf12c59f4 100644 --- a/src/main/scala/edx/quantum/reactor/GuiReactorCell.scala +++ b/src/main/scala/edx/quantum/reactor/GuiReactorCell.scala @@ -2,8 +2,8 @@ package edx.quantum.reactor import net.minecraft.entity.player.InventoryPlayer import org.lwjgl.opengl.GL11 -import resonantengine.lib.prefab.gui.GuiContainerBase import resonantengine.lib.utility.LanguageUtility +import resonantengine.prefab.gui.GuiContainerBase class GuiReactorCell(inventory: InventoryPlayer, tileEntity: TileReactorCell) extends GuiContainerBase(new ContainerReactorCell(inventory.player, tileEntity)) {