From fdde96ab6fef30064b67e28390008ee4ba455655 Mon Sep 17 00:00:00 2001 From: Maxim Date: Sat, 22 Apr 2023 17:38:49 +0200 Subject: MuTE overhaul and ACR (#1883) * complex controller start * Added methods to get input fluids and items * Added logic to complex parallel mute * Added ACR and fixed many, many, many, many bugs * Added void protection setting to checkRecipe * do not init nbt, if mteID and mteRegistry are the same * Improved GUI design * Force structure check when pressing power switch * ACR Textures * Added T1 structure * Added perfect OC * Added WAILA * fix mutes resetting their nbt * Fix ACR GUI * fix npe * Added void protection for MuTEs * Fixed ACR starting recipe while another one is ongoing * nbt saving * maybe fix structure breaking * Fix complex machine disabling on startup * correctly update input tanks * move casings over * Changed logic of casings to change mode and facing in one go by sneaking * Fixed the casing target not resetting * Added side only annotations * don't leave it empty * Added power logic and tiered blocks to ACR * Change facing to wrench side if casing mode is currently none * lasers anyone? * Added ACR item chaining * Remove unncessary item lists * Use HashSet for process whitelists * Optimize list capacities * Fix potential recipe voiding bug * Rename methods for consistancy * Fix NPE * Duct tape fix structure check * allow MuTEs to connect to cables * Added separate tank inventories for input separation (#1887) * Fixed unregistering tank function * Fixed input busses not being automatable * Added fluid chaining * Fixed saving of input tanks * Forbid inventory registering with empty name * Display all input tanks in controller GUI * Fixed fluid hatch GUI height * Reset casing lists when checking the structure * Make inventory GUI size consistant * Make use of the tooltip cache * rename thing clean up * Forgot to put tooltip into map * Added tooltip to ACR * Reset whitelists when one whitelist window was opened * Refined scanner string * Fixed progress times * Fixed MuTE not consuming fluids * Properly register controller inventories * switch to ForgeDirection * switch to new Renderer * Added missing contains check on registerInventory * Fixed output tanks not registering * Fixed upgrade tank loading * fix machines not having active/inactive textures * fix overlays not loading correctly * Don't register controller directly * Remove magic strings all * fix active not setting to inactive * allow glow * item renderer * fix glow * MuTE improved hatch GUI and fluid output locking (#1889) * Allow output hatches to be fluid locked * Reworked hatch GUI * Check target before trying to open GUI * Make ACR GUI easier to look at * fix covers not rendering on mutes * fix covers not displaying above the item/fluid in/out * new folder texture structure * Reduce network traffic caused by covers * Fixed WAILA fluid locking display * Don't save everything to the itemstack NBT * Added possibility to save NBT of MuTE to its itemstack * fix textures, but make sacrifices * mah textures * Removed the need for all textures to be present * Added glow texture for active coke oven * Removed unncesssary upgrade casing textures * shorten nbt tags --------- Co-authored-by: BlueWeabo <76872108+BlueWeabo@users.noreply.github.com> Co-authored-by: Martin Robertz Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- src/main/java/gregtech/common/GT_Client.java | 6 +- .../common/render/GT_MultiTile_Renderer.java | 181 +++++++++ .../gregtech/common/render/GT_Renderer_Block.java | 300 ++++---------- .../common/render/MultiTileBasicRender.java | 10 + .../tileentities/casings/functional/Conveyor.java | 16 + .../tileentities/casings/functional/Emitter.java | 16 + .../casings/functional/FieldGenerator.java | 16 + .../tileentities/casings/functional/Motor.java | 16 + .../casings/functional/MotorCasing.java | 11 - .../tileentities/casings/functional/Piston.java | 16 + .../tileentities/casings/functional/Pump.java | 16 + .../tileentities/casings/functional/RobotArm.java | 16 + .../tileentities/casings/functional/Sensor.java | 16 + .../tileentities/casings/upgrade/Inventory.java | 108 ++++++ .../casings/upgrade/InventoryUpgrade.java | 108 ------ .../machines/multiblock/AdvChemicalReactor.java | 432 +++++++++++++++++++++ .../tileentities/machines/multiblock/CokeOven.java | 172 ++++++++ .../machines/multiblock/Macerator.java | 175 +++++++++ .../machines/multiblock/MultiBlock_CokeOven.java | 173 --------- .../machines/multiblock/MultiBlock_Macerator.java | 216 ----------- 20 files changed, 1276 insertions(+), 744 deletions(-) create mode 100644 src/main/java/gregtech/common/render/GT_MultiTile_Renderer.java create mode 100644 src/main/java/gregtech/common/render/MultiTileBasicRender.java create mode 100644 src/main/java/gregtech/common/tileentities/casings/functional/Conveyor.java create mode 100644 src/main/java/gregtech/common/tileentities/casings/functional/Emitter.java create mode 100644 src/main/java/gregtech/common/tileentities/casings/functional/FieldGenerator.java create mode 100644 src/main/java/gregtech/common/tileentities/casings/functional/Motor.java delete mode 100644 src/main/java/gregtech/common/tileentities/casings/functional/MotorCasing.java create mode 100644 src/main/java/gregtech/common/tileentities/casings/functional/Piston.java create mode 100644 src/main/java/gregtech/common/tileentities/casings/functional/Pump.java create mode 100644 src/main/java/gregtech/common/tileentities/casings/functional/RobotArm.java create mode 100644 src/main/java/gregtech/common/tileentities/casings/functional/Sensor.java create mode 100644 src/main/java/gregtech/common/tileentities/casings/upgrade/Inventory.java delete mode 100644 src/main/java/gregtech/common/tileentities/casings/upgrade/InventoryUpgrade.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multiblock/AdvChemicalReactor.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multiblock/CokeOven.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/multiblock/Macerator.java delete mode 100644 src/main/java/gregtech/common/tileentities/machines/multiblock/MultiBlock_CokeOven.java delete mode 100644 src/main/java/gregtech/common/tileentities/machines/multiblock/MultiBlock_Macerator.java (limited to 'src/main/java/gregtech/common') diff --git a/src/main/java/gregtech/common/GT_Client.java b/src/main/java/gregtech/common/GT_Client.java index 2874bde726..4ae0204636 100644 --- a/src/main/java/gregtech/common/GT_Client.java +++ b/src/main/java/gregtech/common/GT_Client.java @@ -64,6 +64,7 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; import gregtech.api.interfaces.tileentity.ITurnable; import gregtech.api.items.GT_MetaGenerated_Item; import gregtech.api.metatileentity.BaseMetaPipeEntity; +import gregtech.api.multitileentity.multiblock.base.MultiBlockPart; import gregtech.api.net.GT_Packet_ClientPreference; import gregtech.api.objects.GT_ItemStack; import gregtech.api.util.ColorsMetadataSection; @@ -567,6 +568,7 @@ public class GT_Client extends GT_Proxy implements Runnable { public void onLoad() { super.onLoad(); new GT_Renderer_Block(); + new GT_MultiTile_Renderer(); metaGeneratedItemRenderer = new GT_MetaGenerated_Item_Renderer(); for (GT_MetaGenerated_Item item : GT_MetaGenerated_Item.sInstances.values()) { metaGeneratedItemRenderer.registerItem(item); @@ -778,7 +780,9 @@ public class GT_Client extends GT_Proxy implements Runnable { if (!(aTileEntity instanceof ICoverable)) return; if (GT_Utility.isStackInList(aEvent.currentItem, GregTech_API.sWireCutterList) - || GT_Utility.isStackInList(aEvent.currentItem, GregTech_API.sSolderingToolList)) { + || GT_Utility.isStackInList(aEvent.currentItem, GregTech_API.sSolderingToolList) + || (GT_Utility.isStackInList(aEvent.currentItem, GregTech_API.sSoftHammerList) + && aTileEntity instanceof MultiBlockPart) && aEvent.player.isSneaking()) { if (((ICoverable) aTileEntity).getCoverIDAtSide((byte) aEvent.target.sideHit) == 0) drawGrid(aEvent, false, false, aEvent.player.isSneaking()); return; diff --git a/src/main/java/gregtech/common/render/GT_MultiTile_Renderer.java b/src/main/java/gregtech/common/render/GT_MultiTile_Renderer.java new file mode 100644 index 0000000000..4d55979658 --- /dev/null +++ b/src/main/java/gregtech/common/render/GT_MultiTile_Renderer.java @@ -0,0 +1,181 @@ +package gregtech.common.render; + +import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.IBlockAccess; +import net.minecraftforge.common.util.ForgeDirection; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; +import cpw.mods.fml.client.registry.RenderingRegistry; +import gregtech.GT_Mod; +import gregtech.api.interfaces.ITexture; +import gregtech.api.logic.ModelRenderLogic; +import gregtech.api.logic.interfaces.ModelRenderLogicHost; +import gregtech.api.multitileentity.MultiTileEntityBlockInternal; +import gregtech.api.multitileentity.MultiTileEntityClassContainer; +import gregtech.api.multitileentity.MultiTileEntityRegistry; +import gregtech.api.multitileentity.interfaces.IMultiBlockController; +import gregtech.api.multitileentity.multiblock.base.MultiBlockPart; + +public class GT_MultiTile_Renderer implements ISimpleBlockRenderingHandler { + + private final int renderID; + public static GT_MultiTile_Renderer INSTANCE; + + public GT_MultiTile_Renderer() { + this.renderID = RenderingRegistry.getNextAvailableRenderId(); + INSTANCE = this; + RenderingRegistry.registerBlockHandler(this); + } + + @Override + public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer) { + if (!(block instanceof MultiTileEntityBlockInternal)) { + return; + } + + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + + MultiTileEntityBlockInternal mteBlock = (MultiTileEntityBlockInternal) block; + MultiTileEntityRegistry registry = mteBlock.getRegistry(); + if (registry == null) return; + MultiTileEntityClassContainer classContainer = registry.getClassContainer(metadata); + if (classContainer == null) return; + renderer.setRenderBoundsFromBlock(mteBlock); + + for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + ITexture texture = classContainer.mCanonicalTileEntity.getTexture(side); + if (texture == null) continue; + switch (side) { + case DOWN -> renderYNegative(null, renderer, 0, 0, 0, block, texture, side); + case UP -> renderYPositive(null, renderer, 0, 0, 0, block, texture, side); + case WEST -> renderXNegative(null, renderer, 0, 0, 0, block, texture, side); + case EAST -> renderXPositive(null, renderer, 0, 0, 0, block, texture, side); + case NORTH -> renderZNegative(null, renderer, 0, 0, 0, block, texture, side); + case SOUTH -> renderZPositive(null, renderer, 0, 0, 0, block, texture, side); + default -> { + // Do nothing + } + } + } + + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } + + @Override + public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, + RenderBlocks renderer) { + TileEntity entity = world.getTileEntity(x, y, z); + if (entity == null) { + return false; + } + + renderer.enableAO = Minecraft.isAmbientOcclusionEnabled() && GT_Mod.gregtechproxy.mRenderTileAmbientOcclusion; + renderer.useInventoryTint = false; + + if (entity instanceof ModelRenderLogicHost modelEntity && modelEntity.shouldRenderModel()) { + ModelRenderLogic renderLogic = modelEntity.getRenderLogic(); + return true; + } + + if (!(entity instanceof MultiTileBasicRender)) { + return false; + } + + if (entity instanceof MultiBlockPart) { + IMultiBlockController controller = ((MultiBlockPart) entity).getTarget(false); + if (controller instanceof ModelRenderLogicHost && ((ModelRenderLogicHost) controller).shouldRenderModel()) { + return false; + } + } + + MultiTileBasicRender renderedEntity = (MultiTileBasicRender) entity; + + for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + ITexture texture = renderedEntity.getTexture(side); + if (texture == null) continue; + switch (side) { + case DOWN -> renderYNegative(world, renderer, x, y, z, block, texture, side); + case UP -> renderYPositive(world, renderer, x, y, z, block, texture, side); + case WEST -> renderXNegative(world, renderer, x, y, z, block, texture, side); + case EAST -> renderXPositive(world, renderer, x, y, z, block, texture, side); + case NORTH -> renderZNegative(world, renderer, x, y, z, block, texture, side); + case SOUTH -> renderZPositive(world, renderer, x, y, z, block, texture, side); + default -> { + // Do nothing + } + } + } + return true; + } + + @Override + public boolean shouldRender3DInInventory(int modelId) { + return true; + } + + @Override + public int getRenderId() { + return renderID; + } + + private static void renderYNegative(IBlockAccess world, RenderBlocks renderer, int x, int y, int z, Block block, + ITexture texture, ForgeDirection side) { + if (world != null) { + if (!block.shouldSideBeRendered(world, x, y - 1, z, side.ordinal())) return; + Tessellator.instance.setBrightness(block.getMixedBrightnessForBlock(world, x, y - 1, z)); + } + texture.renderYNeg(renderer, block, x, y, z); + } + + private static void renderZNegative(IBlockAccess world, RenderBlocks renderer, int x, int y, int z, Block block, + ITexture texture, ForgeDirection side) { + if (world != null) { + if (!block.shouldSideBeRendered(world, x, y, z - 1, side.ordinal())) return; + Tessellator.instance.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z - 1)); + } + texture.renderZNeg(renderer, block, x, y, z); + } + + private static void renderXNegative(IBlockAccess world, RenderBlocks renderer, int x, int y, int z, Block block, + ITexture texture, ForgeDirection side) { + if (world != null) { + if (!block.shouldSideBeRendered(world, x - 1, y, z, side.ordinal())) return; + Tessellator.instance.setBrightness(block.getMixedBrightnessForBlock(world, x - 1, y, z)); + } + texture.renderXNeg(renderer, block, x, y, z); + } + + private static void renderYPositive(IBlockAccess world, RenderBlocks renderer, int x, int y, int z, Block block, + ITexture texture, ForgeDirection side) { + if (world != null) { + if (!block.shouldSideBeRendered(world, x, y + 1, z, side.ordinal())) return; + Tessellator.instance.setBrightness(block.getMixedBrightnessForBlock(world, x, y + 1, z)); + } + texture.renderYPos(renderer, block, x, y, z); + } + + private static void renderXPositive(IBlockAccess world, RenderBlocks renderer, int x, int y, int z, Block block, + ITexture texture, ForgeDirection side) { + if (world != null) { + if (!block.shouldSideBeRendered(world, x + 1, y, z, side.ordinal())) return; + Tessellator.instance.setBrightness(block.getMixedBrightnessForBlock(world, x + 1, y, z)); + } + texture.renderXPos(renderer, block, x, y, z); + } + + private static void renderZPositive(IBlockAccess world, RenderBlocks renderer, int x, int y, int z, Block block, + ITexture texture, ForgeDirection side) { + if (world != null) { + if (!block.shouldSideBeRendered(world, x, y, z + 1, side.ordinal())) return; + Tessellator.instance.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z + 1)); + } + texture.renderZPos(renderer, block, x, y, z); + } +} diff --git a/src/main/java/gregtech/common/render/GT_Renderer_Block.java b/src/main/java/gregtech/common/render/GT_Renderer_Block.java index 7646ee31fa..012115efa3 100644 --- a/src/main/java/gregtech/common/render/GT_Renderer_Block.java +++ b/src/main/java/gregtech/common/render/GT_Renderer_Block.java @@ -1,9 +1,5 @@ package gregtech.common.render; -import static gregtech.api.enums.GT_Values.ALL_VALID_SIDES; -import static gregtech.api.enums.GT_Values.OFFX; -import static gregtech.api.enums.GT_Values.OFFY; -import static gregtech.api.enums.GT_Values.OFFZ; import static gregtech.api.interfaces.metatileentity.IConnectable.CONNECTED_DOWN; import static gregtech.api.interfaces.metatileentity.IConnectable.CONNECTED_EAST; import static gregtech.api.interfaces.metatileentity.IConnectable.CONNECTED_NORTH; @@ -27,7 +23,6 @@ import net.minecraft.client.particle.EffectRenderer; import net.minecraft.client.particle.EntityDiggingFX; import net.minecraft.client.renderer.RenderBlocks; import net.minecraft.client.renderer.Tessellator; -import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; @@ -529,150 +524,73 @@ public class GT_Renderer_Block implements ISimpleBlockRenderingHandler { GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); GL11.glTranslatef(-0.5F, -0.5F, -0.5F); - if (aBlock instanceof IRenderedBlock) { - boolean tNeedsToSetBounds = true; - final ItemStack aStack = new ItemStack(aBlock, 1, aMeta); - IRenderedBlock tRenderer = ((IRenderedBlock) aBlock).passRenderingToObject(aStack); - if (tRenderer != null) tRenderer = tRenderer.passRenderingToObject(aStack); - if (tRenderer == null) tRenderer = IRenderedBlock.ErrorRenderer.INSTANCE; - for (int i = 0, j = tRenderer.getRenderPasses(aBlock); i < j; i++) { - if (tRenderer.usesRenderPass(i)) { - if (tRenderer.setBlockBounds(aBlock, i)) { - tNeedsToSetBounds = true; - aRenderer.setRenderBoundsFromBlock(aBlock); - } else { - if (tNeedsToSetBounds) aBlock.setBlockBoundsForItemRender(); - aRenderer.setRenderBoundsFromBlock(aBlock); - tNeedsToSetBounds = false; - } + if (aBlock instanceof GT_Block_Ores_Abstract) { + final GT_TileEntity_Ores tTileEntity = new GT_TileEntity_Ores(); + tTileEntity.mMetaData = ((short) aMeta); - renderNegativeYFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tRenderer.getTexture(aBlock, (byte) DOWN.ordinal(), true, i), - !tNeedsToSetBounds); - renderPositiveYFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tRenderer.getTexture(aBlock, (byte) UP.ordinal(), true, i), - !tNeedsToSetBounds); - renderNegativeZFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tRenderer.getTexture(aBlock, (byte) NORTH.ordinal(), true, i), - !tNeedsToSetBounds); - renderPositiveZFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tRenderer.getTexture(aBlock, (byte) SOUTH.ordinal(), true, i), - !tNeedsToSetBounds); - renderNegativeXFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tRenderer.getTexture(aBlock, (byte) WEST.ordinal(), true, i), - !tNeedsToSetBounds); - renderPositiveXFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tRenderer.getTexture(aBlock, (byte) EAST.ordinal(), true, i), - !tNeedsToSetBounds); - } + aBlock.setBlockBoundsForItemRender(); + aRenderer.setRenderBoundsFromBlock(aBlock); + renderNegativeYFacing( + null, + aRenderer, + aBlock, + 0, + 0, + 0, + tTileEntity.getTexture(aBlock, (byte) DOWN.ordinal()), + true); + renderPositiveYFacing( + null, + aRenderer, + aBlock, + 0, + 0, + 0, + tTileEntity.getTexture(aBlock, (byte) UP.ordinal()), + true); + renderNegativeZFacing( + null, + aRenderer, + aBlock, + 0, + 0, + 0, + tTileEntity.getTexture(aBlock, (byte) NORTH.ordinal()), + true); + renderPositiveZFacing( + null, + aRenderer, + aBlock, + 0, + 0, + 0, + tTileEntity.getTexture(aBlock, (byte) SOUTH.ordinal()), + true); + renderNegativeXFacing( + null, + aRenderer, + aBlock, + 0, + 0, + 0, + tTileEntity.getTexture(aBlock, (byte) WEST.ordinal()), + true); + renderPositiveXFacing( + null, + aRenderer, + aBlock, + 0, + 0, + 0, + tTileEntity.getTexture(aBlock, (byte) EAST.ordinal()), + true); + } else if (aMeta > 0 && (aMeta < GregTech_API.METATILEENTITIES.length) + && aBlock instanceof GT_Block_Machines + && (GregTech_API.METATILEENTITIES[aMeta] != null) + && (!GregTech_API.METATILEENTITIES[aMeta].renderInInventory(aBlock, aMeta, aRenderer))) { + renderNormalInventoryMetaTileEntity(aBlock, aMeta, aRenderer); } - if (tNeedsToSetBounds) aBlock.setBlockBounds(0, 0, 0, 1, 1, 1); - - } else { - if (aBlock instanceof GT_Block_Ores_Abstract) { - final GT_TileEntity_Ores tTileEntity = new GT_TileEntity_Ores(); - tTileEntity.mMetaData = ((short) aMeta); - - aBlock.setBlockBoundsForItemRender(); - aRenderer.setRenderBoundsFromBlock(aBlock); - renderNegativeYFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tTileEntity.getTexture(aBlock, (byte) DOWN.ordinal()), - true); - renderPositiveYFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tTileEntity.getTexture(aBlock, (byte) UP.ordinal()), - true); - renderNegativeZFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tTileEntity.getTexture(aBlock, (byte) NORTH.ordinal()), - true); - renderPositiveZFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tTileEntity.getTexture(aBlock, (byte) SOUTH.ordinal()), - true); - renderNegativeXFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tTileEntity.getTexture(aBlock, (byte) WEST.ordinal()), - true); - renderPositiveXFacing( - null, - aRenderer, - aBlock, - 0, - 0, - 0, - tTileEntity.getTexture(aBlock, (byte) EAST.ordinal()), - true); - } else if (aMeta > 0 && (aMeta < GregTech_API.METATILEENTITIES.length) - && aBlock instanceof GT_Block_Machines - && (GregTech_API.METATILEENTITIES[aMeta] != null) - && (!GregTech_API.METATILEENTITIES[aMeta].renderInInventory(aBlock, aMeta, aRenderer))) { - renderNormalInventoryMetaTileEntity(aBlock, aMeta, aRenderer); - } - aBlock.setBlockBounds(blockMin, blockMin, blockMin, blockMax, blockMax, blockMax); - } + aBlock.setBlockBounds(blockMin, blockMin, blockMin, blockMax, blockMax, blockMax); aRenderer.setRenderBoundsFromBlock(aBlock); @@ -979,94 +897,6 @@ public class GT_Renderer_Block implements ISimpleBlockRenderingHandler { RenderBlocks aRenderer) { aRenderer.enableAO = Minecraft.isAmbientOcclusionEnabled() && GT_Mod.gregtechproxy.mRenderTileAmbientOcclusion; aRenderer.useInventoryTint = false; - if (aBlock instanceof IRenderedBlock) { - IRenderedBlock tRenderer = ((IRenderedBlock) aBlock).passRenderingToObject(aWorld, aX, aY, aZ); - if (tRenderer != null) tRenderer = tRenderer.passRenderingToObject(aWorld, aX, aY, aZ); - if (tRenderer == null) tRenderer = IRenderedBlock.ErrorRenderer.INSTANCE; - boolean tNeedsToSetBounds = true; - boolean rReturn = false; - if (tRenderer.renderBlock(aBlock, aRenderer, aWorld, aX, aY, aZ)) { - rReturn = true; - } else { - final boolean[] tSides = new boolean[6]; - if (tRenderer instanceof IRenderedBlockSideCheck) { - for (byte tSide : ALL_VALID_SIDES) rReturn |= (tSides[tSide] = ((IRenderedBlockSideCheck) tRenderer) - .renderFullBlockSide(aBlock, aRenderer, tSide)); - } else { - for (byte tSide : ALL_VALID_SIDES) rReturn |= (tSides[tSide] = aBlock - .shouldSideBeRendered(aWorld, aX + OFFX[tSide], aY + OFFY[tSide], aZ + OFFZ[tSide], tSide)); - } - for (int i = 0, j = tRenderer.getRenderPasses(aBlock); i < j; i++) { - if (tRenderer.usesRenderPass(i)) { - if (tRenderer.setBlockBounds(aBlock, i)) { - tNeedsToSetBounds = true; - aRenderer.setRenderBoundsFromBlock(aBlock); - } else { - if (tNeedsToSetBounds) aBlock.setBlockBounds(0, 0, 0, 1, 1, 1); - aRenderer.setRenderBoundsFromBlock(aBlock); - tNeedsToSetBounds = false; - } - renderNegativeYFacing( - aWorld, - aRenderer, - aBlock, - aX, - aY, - aZ, - tRenderer.getTexture(aBlock, (byte) DOWN.ordinal(), i, tSides), - tSides[DOWN.ordinal()]); - renderPositiveYFacing( - aWorld, - aRenderer, - aBlock, - aX, - aY, - aZ, - tRenderer.getTexture(aBlock, (byte) UP.ordinal(), i, tSides), - tSides[UP.ordinal()]); - renderNegativeZFacing( - aWorld, - aRenderer, - aBlock, - aX, - aY, - aZ, - tRenderer.getTexture(aBlock, (byte) NORTH.ordinal(), i, tSides), - tSides[NORTH.ordinal()]); - renderPositiveZFacing( - aWorld, - aRenderer, - aBlock, - aX, - aY, - aZ, - tRenderer.getTexture(aBlock, (byte) SOUTH.ordinal(), i, tSides), - tSides[SOUTH.ordinal()]); - renderNegativeXFacing( - aWorld, - aRenderer, - aBlock, - aX, - aY, - aZ, - tRenderer.getTexture(aBlock, (byte) WEST.ordinal(), i, tSides), - tSides[WEST.ordinal()]); - renderPositiveXFacing( - aWorld, - aRenderer, - aBlock, - aX, - aY, - aZ, - tRenderer.getTexture(aBlock, (byte) EAST.ordinal(), i, tSides), - tSides[EAST.ordinal()]); - } - } - if (tNeedsToSetBounds) aBlock.setBlockBounds(0, 0, 0, 1, 1, 1); - } - - return rReturn; - } final TileEntity tileEntity = aWorld.getTileEntity(aX, aY, aZ); if (tileEntity == null) return false; diff --git a/src/main/java/gregtech/common/render/MultiTileBasicRender.java b/src/main/java/gregtech/common/render/MultiTileBasicRender.java new file mode 100644 index 0000000000..be41739401 --- /dev/null +++ b/src/main/java/gregtech/common/render/MultiTileBasicRender.java @@ -0,0 +1,10 @@ +package gregtech.common.render; + +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; + +public interface MultiTileBasicRender { + + ITexture getTexture(ForgeDirection side); +} diff --git a/src/main/java/gregtech/common/tileentities/casings/functional/Conveyor.java b/src/main/java/gregtech/common/tileentities/casings/functional/Conveyor.java new file mode 100644 index 0000000000..31dea4cf38 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/casings/functional/Conveyor.java @@ -0,0 +1,16 @@ +package gregtech.common.tileentities.casings.functional; + +import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; + +public class Conveyor extends FunctionalCasing { + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.functional.conveyor"; + } + + @Override + public float getPartModifier() { + return 1.1f; + } +} diff --git a/src/main/java/gregtech/common/tileentities/casings/functional/Emitter.java b/src/main/java/gregtech/common/tileentities/casings/functional/Emitter.java new file mode 100644 index 0000000000..cce660ace4 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/casings/functional/Emitter.java @@ -0,0 +1,16 @@ +package gregtech.common.tileentities.casings.functional; + +import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; + +public class Emitter extends FunctionalCasing { + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.functional.emitter"; + } + + @Override + public float getPartModifier() { + return 1.3f; + } +} diff --git a/src/main/java/gregtech/common/tileentities/casings/functional/FieldGenerator.java b/src/main/java/gregtech/common/tileentities/casings/functional/FieldGenerator.java new file mode 100644 index 0000000000..3787d45af8 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/casings/functional/FieldGenerator.java @@ -0,0 +1,16 @@ +package gregtech.common.tileentities.casings.functional; + +import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; + +public class FieldGenerator extends FunctionalCasing { + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.functional.field.generator"; + } + + @Override + public float getPartModifier() { + return 2f; + } +} diff --git a/src/main/java/gregtech/common/tileentities/casings/functional/Motor.java b/src/main/java/gregtech/common/tileentities/casings/functional/Motor.java new file mode 100644 index 0000000000..cddb293cc2 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/casings/functional/Motor.java @@ -0,0 +1,16 @@ +package gregtech.common.tileentities.casings.functional; + +import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; + +public class Motor extends FunctionalCasing { + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.functional.motor"; + } + + @Override + public float getPartModifier() { + return 1; + } +} diff --git a/src/main/java/gregtech/common/tileentities/casings/functional/MotorCasing.java b/src/main/java/gregtech/common/tileentities/casings/functional/MotorCasing.java deleted file mode 100644 index 32a53d418a..0000000000 --- a/src/main/java/gregtech/common/tileentities/casings/functional/MotorCasing.java +++ /dev/null @@ -1,11 +0,0 @@ -package gregtech.common.tileentities.casings.functional; - -import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; - -public class MotorCasing extends FunctionalCasing { - - @Override - public String getTileEntityName() { - return "gt.multitileentity.multiblock.functional.motor"; - } -} diff --git a/src/main/java/gregtech/common/tileentities/casings/functional/Piston.java b/src/main/java/gregtech/common/tileentities/casings/functional/Piston.java new file mode 100644 index 0000000000..2255fbf8a2 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/casings/functional/Piston.java @@ -0,0 +1,16 @@ +package gregtech.common.tileentities.casings.functional; + +import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; + +public class Piston extends FunctionalCasing { + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.functional.piston"; + } + + @Override + public float getPartModifier() { + return 1.1f; + } +} diff --git a/src/main/java/gregtech/common/tileentities/casings/functional/Pump.java b/src/main/java/gregtech/common/tileentities/casings/functional/Pump.java new file mode 100644 index 0000000000..3acddbe9dc --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/casings/functional/Pump.java @@ -0,0 +1,16 @@ +package gregtech.common.tileentities.casings.functional; + +import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; + +public class Pump extends FunctionalCasing { + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.functional.pump"; + } + + @Override + public float getPartModifier() { + return 1.1f; + } +} diff --git a/src/main/java/gregtech/common/tileentities/casings/functional/RobotArm.java b/src/main/java/gregtech/common/tileentities/casings/functional/RobotArm.java new file mode 100644 index 0000000000..2273705397 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/casings/functional/RobotArm.java @@ -0,0 +1,16 @@ +package gregtech.common.tileentities.casings.functional; + +import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; + +public class RobotArm extends FunctionalCasing { + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.functional.robot.arm"; + } + + @Override + public float getPartModifier() { + return 1.5f; + } +} diff --git a/src/main/java/gregtech/common/tileentities/casings/functional/Sensor.java b/src/main/java/gregtech/common/tileentities/casings/functional/Sensor.java new file mode 100644 index 0000000000..e88060e902 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/casings/functional/Sensor.java @@ -0,0 +1,16 @@ +package gregtech.common.tileentities.casings.functional; + +import gregtech.api.multitileentity.multiblock.casing.FunctionalCasing; + +public class Sensor extends FunctionalCasing { + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.functional.sensor"; + } + + @Override + public float getPartModifier() { + return 1.3f; + } +} diff --git a/src/main/java/gregtech/common/tileentities/casings/upgrade/Inventory.java b/src/main/java/gregtech/common/tileentities/casings/upgrade/Inventory.java new file mode 100644 index 0000000000..c153e6c1c5 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/casings/upgrade/Inventory.java @@ -0,0 +1,108 @@ +package gregtech.common.tileentities.casings.upgrade; + +import java.util.UUID; + +import net.minecraft.nbt.NBTTagCompound; + +import com.gtnewhorizons.modularui.api.screen.ModularWindow.Builder; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget; + +import gregtech.api.enums.GT_Values.NBT; +import gregtech.api.multitileentity.interfaces.IMultiBlockController; +import gregtech.api.multitileentity.multiblock.casing.UpgradeCasing; +import gregtech.api.net.GT_Packet_MultiTileEntity; + +public class Inventory extends UpgradeCasing { + + public UUID mInventoryID; + public static final int INPUT = 0; + public static final int OUTPUT = 1; + public static final int BOTH = 2; + private String mInventoryName = "inventory"; + private int mInventorySize; + private int mType = BOTH; + + public String getInventoryName() { + return mInventoryName; + } + + public void setInventoryName(String aInventoryName) { + mInventoryName = aInventoryName; + } + + @Override + protected void customWork(IMultiBlockController aTarget) { + int tInvSize = mInventorySize; + if (mType == BOTH) { + tInvSize /= 2; + } + aTarget.registerInventory(mInventoryName, mInventoryID.toString(), tInvSize, mType); + } + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.inventory"; + } + + @Override + public void readMultiTileNBT(NBTTagCompound aNBT) { + super.readMultiTileNBT(aNBT); + if (aNBT.hasKey(NBT.UPGRADE_INVENTORY_UUID)) { + mInventoryID = UUID.fromString(aNBT.getString(NBT.UPGRADE_INVENTORY_UUID)); + } else { + mInventoryID = UUID.randomUUID(); + } + mInventorySize = aNBT.getInteger(NBT.UPGRADE_INVENTORY_SIZE); + mInventoryName = aNBT.getString(NBT.UPGRADE_INVENTORY_NAME); + + } + + @Override + public void writeMultiTileNBT(NBTTagCompound aNBT) { + super.writeMultiTileNBT(aNBT); + aNBT.setString(NBT.UPGRADE_INVENTORY_UUID, mInventoryID.toString()); + aNBT.setString(NBT.UPGRADE_INVENTORY_NAME, mInventoryName); + } + + @Override + protected void onBaseTEDestroyed() { + super.onBaseTEDestroyed(); + unregisterInventories(); + } + + private void unregisterInventories() { + final IMultiBlockController controller = getTarget(false); + if (controller != null) { + controller.unregisterInventory(mInventoryName, mInventoryID.toString(), mType); + } + } + + @Override + public boolean hasGui(byte aSide) { + return true; + } + + @Override + public void addUIWidgets(Builder builder, UIBuildContext buildContext) { + builder.widget( + new TextFieldWidget().setGetter(() -> mInventoryName) + .setSetter((val) -> { + mInventoryName = val; + final IMultiBlockController controller = getTarget(false); + if (controller != null) { + controller.changeInventoryName(mInventoryName, mInventoryID.toString(), mType); + } + }) + .setSize(100, 25) + .setPos(50, 30)); + } + + @Override + public GT_Packet_MultiTileEntity getClientDataPacket() { + final GT_Packet_MultiTileEntity packet = super.getClientDataPacket(); + String name = getInventoryName(); + packet.setInventoryName(name); + return packet; + } +} diff --git a/src/main/java/gregtech/common/tileentities/casings/upgrade/InventoryUpgrade.java b/src/main/java/gregtech/common/tileentities/casings/upgrade/InventoryUpgrade.java deleted file mode 100644 index 06bb75c62f..0000000000 --- a/src/main/java/gregtech/common/tileentities/casings/upgrade/InventoryUpgrade.java +++ /dev/null @@ -1,108 +0,0 @@ -package gregtech.common.tileentities.casings.upgrade; - -import java.util.UUID; - -import net.minecraft.nbt.NBTTagCompound; - -import com.gtnewhorizons.modularui.api.screen.ModularWindow.Builder; -import com.gtnewhorizons.modularui.api.screen.UIBuildContext; -import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget; - -import gregtech.api.enums.GT_Values.NBT; -import gregtech.api.multitileentity.interfaces.IMultiBlockController; -import gregtech.api.multitileentity.multiblock.casing.UpgradeCasing; -import gregtech.api.net.GT_Packet_MultiTileEntity; - -public class InventoryUpgrade extends UpgradeCasing { - - public UUID mInventoryID; - public static final int INPUT = 0; - public static final int OUTPUT = 1; - public static final int BOTH = 2; - private String mInventoryName = "inventory"; - private int mInventorySize; - private int mType = BOTH; - - public String getInventoryName() { - return mInventoryName; - } - - public void setInventoryName(String aInventoryName) { - mInventoryName = aInventoryName; - } - - @Override - protected void customWork(IMultiBlockController aTarget) { - int tInvSize = mInventorySize; - if (mType == BOTH) { - tInvSize /= 2; - } - aTarget.registerInventory(mInventoryName, mInventoryID.toString(), tInvSize, mType); - } - - @Override - public String getTileEntityName() { - return "gt.multitileentity.multiblock.inventory"; - } - - @Override - public void readMultiTileNBT(NBTTagCompound aNBT) { - super.readMultiTileNBT(aNBT); - if (aNBT.hasKey(NBT.UPGRADE_INVENTORY_UUID)) { - mInventoryID = UUID.fromString(aNBT.getString(NBT.UPGRADE_INVENTORY_UUID)); - } else { - mInventoryID = UUID.randomUUID(); - } - mInventorySize = aNBT.getInteger(NBT.UPGRADE_INVENTORY_SIZE); - mInventoryName = aNBT.getString(NBT.UPGRADE_INVENTORY_NAME); - - } - - @Override - public void writeMultiTileNBT(NBTTagCompound aNBT) { - super.writeMultiTileNBT(aNBT); - aNBT.setString(NBT.UPGRADE_INVENTORY_UUID, mInventoryID.toString()); - aNBT.setString(NBT.UPGRADE_INVENTORY_NAME, mInventoryName); - } - - @Override - protected void onBaseTEDestroyed() { - super.onBaseTEDestroyed(); - unregisterInventories(); - } - - private void unregisterInventories() { - final IMultiBlockController controller = getTarget(false); - if (controller != null) { - controller.unregisterInventory(mInventoryName, mInventoryID.toString(), mType); - } - } - - @Override - public boolean hasGui(byte aSide) { - return true; - } - - @Override - public void addUIWidgets(Builder builder, UIBuildContext buildContext) { - builder.widget( - new TextFieldWidget().setGetter(() -> mInventoryName) - .setSetter((val) -> { - mInventoryName = val; - final IMultiBlockController controller = getTarget(false); - if (controller != null) { - controller.changeInventoryName(mInventoryName, mInventoryID.toString(), mType); - } - }) - .setSize(100, 25) - .setPos(50, 30)); - } - - @Override - public GT_Packet_MultiTileEntity getClientDataPacket() { - final GT_Packet_MultiTileEntity packet = super.getClientDataPacket(); - String name = getInventoryName(); - packet.setInventoryName(name); - return packet; - } -} diff --git a/src/main/java/gregtech/common/tileentities/machines/multiblock/AdvChemicalReactor.java b/src/main/java/gregtech/common/tileentities/machines/multiblock/AdvChemicalReactor.java new file mode 100644 index 0000000000..ca8cc6332b --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multiblock/AdvChemicalReactor.java @@ -0,0 +1,432 @@ +package gregtech.common.tileentities.machines.multiblock; + +import static com.google.common.primitives.Ints.saturatedCast; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.*; +import static gregtech.api.enums.Mods.*; +import static gregtech.api.multitileentity.multiblock.base.MultiBlockPart.*; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.stream.Collectors; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraftforge.common.util.Constants; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidTank; + +import org.apache.commons.lang3.ArrayUtils; + +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; +import com.gtnewhorizon.structurelib.util.Vec3Impl; +import com.gtnewhorizons.modularui.api.forge.ItemStackHandler; +import com.gtnewhorizons.modularui.api.math.Alignment; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.MultiChildWidget; +import com.gtnewhorizons.modularui.common.widget.SlotGroup; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.HeatingCoilLevel; +import gregtech.api.fluid.FluidTankGT; +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.logic.ComplexParallelProcessingLogic; +import gregtech.api.multitileentity.enums.GT_MultiTileCasing; +import gregtech.api.multitileentity.multiblock.base.ComplexParallelController; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_StructureUtility; +import gregtech.common.tileentities.casings.upgrade.Inventory; + +public class AdvChemicalReactor extends ComplexParallelController { + + private static IStructureDefinition STRUCTURE_DEFINITION = null; + protected static final String STRUCTURE_PIECE_T1 = "T1"; + protected static final Vec3Impl STRUCTURE_OFFSET = new Vec3Impl(3, 1, 0); + protected static final int PROCESS_WINDOW_BASE_ID = 100; + protected static final int ITEM_WHITELIST_SLOTS = 8; + protected static final int FLUID_WHITELIST_SLOTS = 8; + protected static final int MAX_PROCESSES = 4; + protected int numberOfProcessors = MAX_PROCESSES; // TODO: Set this value depending on structure + protected HeatingCoilLevel coilTier; + protected final ArrayList> processWhitelists = new ArrayList<>(MAX_PROCESSES); + protected final ArrayList processWhitelistInventoryHandlers = new ArrayList<>(MAX_PROCESSES); + protected final ArrayList> processFluidWhiteLists = new ArrayList<>(MAX_PROCESSES); + protected boolean wasWhitelistOpened = false; + + public AdvChemicalReactor() { + super(); + for (int i = 0; i < MAX_PROCESSES; i++) { + processWhitelists.add(null); + processWhitelistInventoryHandlers.add(new ItemStackHandler(ITEM_WHITELIST_SLOTS)); + ArrayList processFluidTanks = new ArrayList<>(FLUID_WHITELIST_SLOTS); + for (int j = 0; j < FLUID_WHITELIST_SLOTS; j++) { + processFluidTanks.add(new FluidTankGT()); + } + processFluidWhiteLists.add(processFluidTanks); + } + processingLogic = new ComplexParallelProcessingLogic( + GT_Recipe.GT_Recipe_Map_LargeChemicalReactor.sChemicalRecipes, + MAX_PROCESSES); + } + + @Override + public void readMultiTileNBT(NBTTagCompound nbt) { + super.readMultiTileNBT(nbt); + final NBTTagCompound processWhiteLists = nbt.getCompoundTag("whiteLists"); + long capacity = 1000; + if (nbt.hasKey(GT_Values.NBT.TANK_CAPACITY)) { + capacity = saturatedCast(nbt.getLong(GT_Values.NBT.TANK_CAPACITY)); + } + for (int i = 0; i < MAX_PROCESSES; i++) { + registerInventory("processInventory" + i, "processInventory" + i, 8, Inventory.INPUT); + registerFluidInventory( + "processInventory" + i, + "processInventory" + i, + 8, + capacity, + maxParallel * 2L, + Inventory.INPUT); + if (processWhiteLists != null) { + final NBTTagCompound itemList = processWhiteLists.getCompoundTag("items" + i); + if (itemList != null) { + processWhitelistInventoryHandlers.get(i) + .deserializeNBT(itemList); + } + final NBTTagList fluidList = processWhiteLists.getTagList("fluids" + i, Constants.NBT.TAG_COMPOUND); + if (fluidList != null) { + for (int j = 0; j < fluidList.tagCount(); j++) { + final NBTTagCompound fluid = fluidList.getCompoundTagAt(j); + if (fluid != null) { + short index = fluid.getShort("s"); + FluidStack fluidStack = FluidStack.loadFluidStackFromNBT(fluid); + if (fluidStack != null) { + processFluidWhiteLists.get(i) + .get(index) + .fill(fluidStack, true); + } + } + } + } + } + } + } + + @Override + public void writeMultiTileNBT(NBTTagCompound nbt) { + super.writeMultiTileNBT(nbt); + final NBTTagCompound processWhiteLists = new NBTTagCompound(); + for (int i = 0; i < MAX_PROCESSES; i++) { + processWhiteLists.setTag( + "items" + i, + processWhitelistInventoryHandlers.get(i) + .serializeNBT()); + final NBTTagList fluidList = new NBTTagList(); + for (int j = 0; j < FLUID_WHITELIST_SLOTS; j++) { + final FluidStack fluidStack = processFluidWhiteLists.get(i) + .get(j) + .getFluid(); + if (fluidStack != null) { + final NBTTagCompound tag = new NBTTagCompound(); + tag.setByte("s", (byte) j); + fluidStack.writeToNBT(tag); + fluidList.appendTag(tag); + } + } + processWhiteLists.setTag("fluids" + i, fluidList); + } + nbt.setTag("whiteLists", processWhiteLists); + } + + @Override + public short getCasingRegistryID() { + return 0; + } + + @Override + public int getCasingMeta() { + return GT_MultiTileCasing.Chemical.getId(); + } + + @Override + public GT_Multiblock_Tooltip_Builder createTooltip() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Chemical Reactor") + .addInfo("Controller block for the Advanced Chemical Reactor") + .addInfo("Does not lose efficiency when overclocked") + .addInfo("Accepts fluids instead of fluid cells") + .addInfo("Can do multiple different recipes at once") + .addInfo("By using the whitelist filter a recipe can push its output") + .addInfo("to a different recipes input to chain them") + .addInfo(GT_Values.Authorminecraft7771) + .addSeparator() + .beginStructureBlock(5, 3, 3, false) + .addController("Front center") + .addCasingInfoExactly("PTFE Pipe Machine Casing", 8, false) + .addCasingInfoExactly("Heating Coils", 3, true) + .addCasingInfoExactly("EV+ Glass", 3, true) + .addCasingInfoExactly("Motor Casing", 3, true) + .addCasingInfoExactly("Chemical Casing", 27, false) + .toolTipFinisher("Gregtech"); + return tt; + } + + @Override + public Vec3Impl getStartingStructureOffset() { + return STRUCTURE_OFFSET; + } + + @Override + public boolean checkMachine() { + setCoilTier(HeatingCoilLevel.None); + setMaxComplexParallels(MAX_PROCESSES); + buildState.startBuilding(getStartingStructureOffset()); + boolean result = checkPiece(STRUCTURE_PIECE_T1, buildState.stopBuilding()); + return result && super.checkMachine(); + } + + @Override + public void construct(ItemStack trigger, boolean hintsOnly) { + buildState.startBuilding(getStartingStructureOffset()); + buildPiece(STRUCTURE_PIECE_T1, trigger, hintsOnly, buildState.stopBuilding()); + } + + @Override + public IStructureDefinition getStructureDefinition() { + if (STRUCTURE_DEFINITION == null) { + STRUCTURE_DEFINITION = StructureDefinition.builder() + .addShape( + STRUCTURE_PIECE_T1, + transpose( + new String[][] { { "CPCPC", "CCCCC", "CPCPC" }, { "CGC~C", "GWWWC", "CGCCC" }, + { "CPCPC", "CTTTC", "CPCPC" } })) + .addElement( + 'C', + addMultiTileCasing( + "gt.multitileentity.casings", + getCasingMeta(), + FLUID_IN | ITEM_IN | FLUID_OUT | ITEM_OUT | ENERGY_IN)) + .addElement('P', ofBlock(GregTech_API.sBlockCasings8, 1)) + .addElement('T', addMotorCasings(NOTHING)) + .addElement( + 'W', + GT_StructureUtility.ofCoil(AdvChemicalReactor::setCoilTier, AdvChemicalReactor::getCoilTier)) + .addElement( + 'G', + ofChain( + ofBlockUnlocalizedName(IndustrialCraft2.ID, "blockAlloyGlass", 0, true), + ofBlockUnlocalizedName(BartWorks.ID, "BW_GlasBlocks", 0, true), + ofBlockUnlocalizedName(BartWorks.ID, "BW_GlasBlocks2", 0, true), + ofBlockUnlocalizedName(Thaumcraft.ID, "blockCosmeticOpaque", 2, false))) + .build(); + } + return STRUCTURE_DEFINITION; + } + + @Override + protected FluidStack[] getInputFluids(int index) { + if (index < 0 || index >= MAX_PROCESSES) { + return null; + } + if (separateInputs) { + return ArrayUtils.addAll( + getFluidInputsForTankArray("processInventory" + index), + FluidTankGT.getFluidsFromTanks(inputTanks)); + } else { + return super.getInputFluids(index); + } + } + + @Override + protected ItemStack[] getInputItems(int index) { + if (index < 0 || index >= MAX_PROCESSES) { + return null; + } + if (separateInputs) { + return ArrayUtils.addAll( + getItemInputsForInventory("processInventory" + index), + inputInventory.getStacks() + .toArray(new ItemStack[0])); + } else { + return super.getInputItems(index); + } + } + + @Override + protected void outputItems(int index) { + ComplexParallelProcessingLogic processingLogic = getComplexProcessingLogic(); + if (processingLogic != null && index >= 0 && index < maxComplexParallels) { + for (int i = 0; i < MAX_PROCESSES; i++) { + // Regenerate whitelist, if it has been reset + if (processWhitelists.get(i) == null) { + generateWhitelist(i); + } + int outputIndex = i; + // Output items that are on the whitelist of this process + outputItems( + multiBlockInputInventory.get("processInventory" + i), + Arrays.stream(processingLogic.getOutputItems(index)) + .filter( + itemStack -> processWhitelists.get(outputIndex) + .contains(getWhitelistString(itemStack))) + .collect(Collectors.toList()) + .toArray(new ItemStack[0])); + } + // Output remaining items + if (processingLogic.getOutputItems(index) != null && processingLogic.getOutputItems(index).length > 0) { + outputItems(processingLogic.getOutputItems(index)); + } + } + } + + @Override + protected void outputFluids(int index) { + ComplexParallelProcessingLogic processingLogic = getComplexProcessingLogic(); + if (processingLogic != null && index >= 0 && index < maxComplexParallels) { + for (int i = 0; i < MAX_PROCESSES; i++) { + // Regenerate whitelist, if it has been reset + if (processWhitelists.get(i) == null) { + generateWhitelist(i); + } + int outputIndex = i; + // Output fluids that are on the whitelist of this process + outputFluids( + multiBlockInputTank.get("processInventory" + i), + Arrays.stream(processingLogic.getOutputFluids(index)) + .filter( + fluidStack -> processWhitelists.get(outputIndex) + .contains(getWhitelistString(fluidStack))) + .collect(Collectors.toList()) + .toArray(new FluidStack[0])); + } + // Output remaining fluids + if (processingLogic.getOutputFluids(index) != null && processingLogic.getOutputFluids(index).length > 0) { + outputFluids(processingLogic.getOutputFluids(index)); + } + } + } + + @Override + protected MultiChildWidget createMainPage() { + MultiChildWidget child = super.createMainPage(); + for (int i = 0; i < MAX_PROCESSES; i++) { + final int processIndex = i; + child.addChild( + new ButtonWidget().setPlayClickSound(true) + .setOnClick( + (clickData, widget) -> { + if (!widget.isClient()) widget.getContext() + .openSyncedWindow(PROCESS_WINDOW_BASE_ID + processIndex); + }) + .setBackground(GT_UITextures.BUTTON_STANDARD, GT_UITextures.OVERLAY_BUTTON_WHITELIST) + .setSize(18, 18) + .setPos(20 * i + 18, 18)); + } + return child; + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + super.addUIWidgets(builder, buildContext); + for (int i = 0; i < MAX_PROCESSES; i++) { + final int processIndex = i; + buildContext.addSyncedWindow( + PROCESS_WINDOW_BASE_ID + i, + (player) -> createProcessConfigWindow(player, processIndex)); + } + buildContext.addCloseListener(() -> { + // Reset HashSet, we will let it re-generate on next item output + if (wasWhitelistOpened) { + for (int i = 0; i < MAX_PROCESSES; i++) { + processWhitelists.set(i, null); + } + wasWhitelistOpened = false; + } + }); + } + + protected ModularWindow createProcessConfigWindow(final EntityPlayer player, final int processIndex) { + wasWhitelistOpened = true; + ModularWindow.Builder builder = ModularWindow.builder(86, 100); + builder.widget( + new TextWidget("Process " + processIndex).setTextAlignment(Alignment.Center) + .setPos(13, 7)); + builder.setBackground(GT_UITextures.BACKGROUND_SINGLEBLOCK_DEFAULT); + builder.widget( + SlotGroup.ofItemHandler(processWhitelistInventoryHandlers.get(processIndex), 4) + .startFromSlot(0) + .endAtSlot(ITEM_WHITELIST_SLOTS - 1) + .phantom(true) + .background(getGUITextureSet().getItemSlot()) + .build() + .setPos(7, 19)); + builder.widget( + SlotGroup.ofFluidTanks(processFluidWhiteLists.get(processIndex), 4) + .startFromSlot(0) + .endAtSlot(FLUID_WHITELIST_SLOTS - 1) + .phantom(true) + .build() + .setPos(7, 55)); + return builder.build(); + } + + @Override + public String getTileEntityName() { + return "gt.multitileentity.multiblock.advchemicalreactor"; + } + + @Override + public String getLocalName() { + return "Advanced Chemical Reactor"; + } + + public void setCoilTier(HeatingCoilLevel coilTier) { + this.coilTier = coilTier; + } + + public HeatingCoilLevel getCoilTier() { + return coilTier; + } + + @Override + protected boolean hasPerfectOverclock() { + return true; + } + + protected void generateWhitelist(int processIndex) { + HashSet whitelist = new HashSet<>(); + for (ItemStack itemStack : processWhitelistInventoryHandlers.get(processIndex) + .getStacks()) { + if (itemStack != null) { + whitelist.add(getWhitelistString(itemStack)); + } + } + for (IFluidTank tank : processFluidWhiteLists.get(processIndex)) { + if (tank.getFluid() != null) { + whitelist.add(getWhitelistString(tank.getFluid())); + } + } + processWhitelists.set(processIndex, whitelist); + } + + protected String getWhitelistString(ItemStack itemStack)