diff options
Diffstat (limited to 'src/main/java/gregtech/common/tileentities')
19 files changed, 6401 insertions, 0 deletions
diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_Hatch_DegasifierControlHatch.java b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_Hatch_DegasifierControlHatch.java new file mode 100644 index 0000000000..3d49f05dca --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_Hatch_DegasifierControlHatch.java @@ -0,0 +1,122 @@ +package gregtech.common.tileentities.machines.multi.purification; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch; +import gregtech.api.render.TextureFactory; + +public class GT_MetaTileEntity_Hatch_DegasifierControlHatch extends GT_MetaTileEntity_Hatch { + + private byte outputStrength = 0; + + private static final IIconContainer textureFont = Textures.BlockIcons.OVERLAY_HATCH_PH_SENSOR; + private static final IIconContainer textureFont_Glow = Textures.BlockIcons.OVERLAY_HATCH_PH_SENSOR_GLOW; + + public GT_MetaTileEntity_Hatch_DegasifierControlHatch(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, 0, "Outputs a control signal for the Degasser Purification Unit"); + } + + public GT_MetaTileEntity_Hatch_DegasifierControlHatch(String aName, int aTier, String[] aDescription, + ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + } + + @Override + public boolean isValidSlot(int aIndex) { + return false; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean allowGeneralRedstoneOutput() { + return true; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection Side, + ItemStack aStack) { + return false; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public void initDefaultModes(NBTTagCompound aNBT) { + getBaseMetaTileEntity().setActive(true); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_Hatch_DegasifierControlHatch(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public String[] getDescription() { + return new String[] { "Can be installed in the Degasser Purification Unit.", + "Outputs Redstone Signal Strength based on the current control signal." }; + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + outputStrength = aNBT.getByte("mOutputStrength"); + super.loadNBTData(aNBT); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setByte("mOutputStrength", outputStrength); + super.saveNBTData(aNBT); + } + + // Pass zero signal to disable output + public void updateOutputSignal(byte signal) { + outputStrength = signal; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (outputStrength > 0) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + aBaseMetaTileEntity.setStrongOutputRedstoneSignal(side, outputStrength); + } + } else { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + aBaseMetaTileEntity.setStrongOutputRedstoneSignal(side, (byte) 0); + } + } + super.onPostTick(aBaseMetaTileEntity, aTick); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont), TextureFactory.builder() + .addIcon(textureFont_Glow) + .glow() + .build() }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont) }; + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensHousing.java b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensHousing.java new file mode 100644 index 0000000000..bd025e0e69 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensHousing.java @@ -0,0 +1,52 @@ +package gregtech.common.tileentities.machines.multi.purification; + +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus; +import gregtech.client.GT_TooltipHandler; + +public class GT_MetaTileEntity_LensHousing extends GT_MetaTileEntity_Hatch_InputBus { + + public GT_MetaTileEntity_LensHousing(int id, String name, String nameRegional) { + super( + id, + name, + nameRegional, + GT_TooltipHandler.Tier.UV.ordinal(), + 1, + new String[] { "Holds a lens for UV laser focusing." }); + } + + public GT_MetaTileEntity_LensHousing(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_LensHousing(this.mName, this.mTier, this.mDescriptionArray, this.mTextures); + } + + @Override + public int getSizeInventory() { + return 1; + } + + @Override + public int getCircuitSlot() { + return -1; + } + + @Override + public boolean allowSelectCircuit() { + return false; + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + getBaseMetaTileEntity().add1by1Slot(builder); + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensIndicator.java b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensIndicator.java new file mode 100644 index 0000000000..c017025d42 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_LensIndicator.java @@ -0,0 +1,117 @@ +package gregtech.common.tileentities.machines.multi.purification; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch; +import gregtech.api.render.TextureFactory; + +public class GT_MetaTileEntity_LensIndicator extends GT_MetaTileEntity_Hatch { + + private boolean isOn = false; + + private static final IIconContainer textureFont = Textures.BlockIcons.OVERLAY_HATCH_PH_SENSOR; + private static final IIconContainer textureFont_Glow = Textures.BlockIcons.OVERLAY_HATCH_PH_SENSOR_GLOW; + + public GT_MetaTileEntity_LensIndicator(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, 0, "Indicates required lens swaps."); + } + + public GT_MetaTileEntity_LensIndicator(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + } + + @Override + public boolean isValidSlot(int aIndex) { + return false; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean allowGeneralRedstoneOutput() { + return true; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection Side, + ItemStack aStack) { + return false; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } + + @Override + public void initDefaultModes(NBTTagCompound aNBT) { + getBaseMetaTileEntity().setActive(true); + } + + @Override + public String[] getDescription() { + return new String[] { "Can be installed in the UV Treatment Purification Unit.", + "Outputs Redstone Signal when a lens swap is requested." }; + } + + /** + * Updates redstone output strength based on the pH of the multiblock. + */ + public void updateRedstoneOutput(boolean enabled) { + isOn = enabled; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (isOn) { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + aBaseMetaTileEntity.setInternalOutputRedstoneSignal(side, (byte) 15); + } + } else { + for (final ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) { + aBaseMetaTileEntity.setInternalOutputRedstoneSignal(side, (byte) 0); + } + } + super.onPostTick(aBaseMetaTileEntity, aTick); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_LensIndicator(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont), TextureFactory.builder() + .addIcon(textureFont_Glow) + .glow() + .build() }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, TextureFactory.of(textureFont) }; + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationPlant.java b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationPlant.java new file mode 100644 index 0000000000..42bfd06d7a --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/purification/GT_MetaTileEntity_PurificationPlant.java @@ -0,0 +1,740 @@ +package gregtech.common.tileentities.machines.multi.purification; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.lazy; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAnyMeta; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain; +import static gregtech.api.enums.GT_HatchElement.Energy; +import static gregtech.api.enums.GT_HatchElement.ExoticEnergy; +import static gregtech.api.enums.GT_HatchElement.Maintenance; +import static gregtech.api.enums.GT_Values.AuthorNotAPenguin; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_PROCESSING_ARRAY; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_PROCESSING_ARRAY_GLOW; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_StructureUtility.ofFrame; +import static gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitBase.WATER_BOOST_BONUS_CHANCE; +import static gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitBase.WATER_BOOST_NEEDED_FLUID; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import com.google.common.collect.ImmutableList; +import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; +import com.gtnewhorizons.modularui.api.drawable.shapes.Rectangle; +import com.gtnewhorizons.modularui.api.forge.ItemStackHandler; +import com.gtnewhorizons.modularui.api.math.Alignment; +import com.gtnewhorizons.modularui.api.math.Color; +import com.gtnewhorizons.modularui.api.math.Size; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.api.widget.Widget; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.DynamicPositionedColumn; +import com.gtnewhorizons.modularui.common.widget.DynamicPositionedRow; +import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget; +import com.gtnewhorizons.modularui.common.widget.Scrollable; +import com.gtnewhorizons.modularui.common.widget.SlotWidget; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Textures; +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.interfaces.IHatchElement; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ExtendedPowerMultiBlockBase; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_StructureUtility; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.shutdown.ShutDownReasonRegistry; +import gregtech.common.gui.modularui.widget.ShutDownReasonSyncer; +import gregtech.common.gui.modularui.widget.TextButtonWidget; + +public class GT_MetaTileEntity_PurificationPlant + extends GT_MetaTileEntity_ExtendedPowerMultiBlockBase<GT_MetaTileEntity_PurificationPlant> + implements ISurvivalConstructable { + + private static final String STRUCTURE_PIECE_MAIN = "main"; + private static final String STRUCTURE_PIECE_MAIN_SURVIVAL = "main_survival"; + + /** + * Maximum distance in each axis between the purification plant main controller and the controller blocks of the + * purification plant units. + */ + public static final int MAX_UNIT_DISTANCE = 32; + + /** + * Time in ticks for a full processing cycle to complete. + */ + public static final int CYCLE_TIME_TICKS = 120 * SECONDS; + + /** + * Stores all purification units linked to this controller. + * Normally all units in this list should be valid and unique, if not then there is a bug where they are not being + * unlinked properly on block destruction/relinking. + */ + private final List<LinkedPurificationUnit> mLinkedUnits = new ArrayList<>(); + + private static final IStructureDefinition<GT_MetaTileEntity_PurificationPlant> STRUCTURE_DEFINITION = StructureDefinition + .<GT_MetaTileEntity_PurificationPlant>builder() + .addShape(STRUCTURE_PIECE_MAIN, PurificationPlantStructureString.STRUCTURE_STRING) + // Create an identical structure for survival autobuild, with water replaced with air + .addShape( + STRUCTURE_PIECE_MAIN_SURVIVAL, + Arrays.stream(PurificationPlantStructureString.STRUCTURE_STRING) + .map( + sa -> Arrays.stream(sa) + .map(s -> s.replaceAll("F", " ")) + .toArray(String[]::new)) + .toArray(String[][]::new)) + // Superplasticizer-treated high strength concrete + .addElement('A', ofBlock(GregTech_API.sBlockCasings9, 3)) + // Sterile Water Plant Casing + .addElement('B', ofBlock(GregTech_API.sBlockCasings9, 4)) + // Reinforced Sterile Water Plant Casing + .addElement('C', ofBlock(GregTech_API.sBlockCasings9, 5)) + // Tinted Industrial Glass + .addElement('D', ofBlockAnyMeta(GregTech_API.sBlockTintedGlass, 0)) + .addElement('F', ofBlock(Blocks.water, 0)) + .addElement('G', ofFrame(Materials.Tungsten)) + // Hatch space + .addElement( + 'H', + ofChain( + lazy( + t -> GT_StructureUtility.<GT_MetaTileEntity_PurificationPlant>buildHatchAdder() + .atLeastList(t.getAllowedHatches()) + .dot(1) + .casingIndex(GT_Utility.getCasingTextureIndex(GregTech_API.sBlockCasings9, 4)) + .build()), + ofBlock(GregTech_API.sBlockCasings9, 4))) + .build(); + + public GT_MetaTileEntity_PurificationPlant(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GT_MetaTileEntity_PurificationPlant(String aName) { + super(aName); + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 3, 6, 0); + } + + @Override + public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) { + int built = survivialBuildPiece(STRUCTURE_PIECE_MAIN_SURVIVAL, stackSize, 3, 6, 0, elementBudget, env, true); + if (built == -1) { + GT_Utility.sendChatToPlayer( + env.getActor(), + EnumChatFormatting.GREEN + "Auto placing done ! Now go place the water yourself !"); + return 0; + } + return built; + } + + @Override + public IStructureDefinition<GT_MetaTileEntity_PurificationPlant> getStructureDefinition() { + return STRUCTURE_DEFINITION; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Purification Plant") + .addInfo("Main controller block for the Water Purification Plant.") + .addInfo( + "Freely place " + EnumChatFormatting.YELLOW + + "Purification Units " + + EnumChatFormatting.GRAY + + "within " + + EnumChatFormatting.RED + + MAX_UNIT_DISTANCE + + EnumChatFormatting.GRAY + + " blocks along each axis.") + .addInfo("Left click this controller with a data stick, then right click a purification unit to link.") + .addInfo("Supplies power to linked purification units. This multiblock accepts TecTech energy hatches.") + .addSeparator() + .addInfo( + "Works in fixed time processing cycles of " + EnumChatFormatting.RED + + CYCLE_TIME_TICKS / SECONDS + + EnumChatFormatting.GRAY + + " seconds.") + .addInfo("All linked units follow this cycle.") + .addSeparator() + .addInfo("Every recipe has a base chance of success. Success rate can be boosted") + .addInfo("by using a portion of the target output as a secondary input.") + .addInfo( + EnumChatFormatting.RED + GT_Utility.formatNumbers(WATER_BOOST_NEEDED_FLUID * 100) + + "%" + + EnumChatFormatting.GRAY + + " of output yield will be consumed in exchange for an") + .addInfo( + "additive " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(WATER_BOOST_BONUS_CHANCE * 100) + + "%" + + EnumChatFormatting.GRAY + + " increase to success.") + .addInfo( + "On recipe failure, each purification unit has a " + EnumChatFormatting.RED + + "50%" + + EnumChatFormatting.GRAY + + " chance") + .addInfo("to return water of the same quality as the input or lower.") + .addSeparator() + .addInfo("Every purification unit has a configuration window to configure maximum parallel amount.") + .addInfo( + "This will only scale purified water I/O and power usage. Other catalysts and outputs are unchanged.") + .addSeparator() + .addInfo( + EnumChatFormatting.AQUA + "" + + EnumChatFormatting.ITALIC + + "Contaminants and ionized particles in water can cause significant imperfections in delicate") + .addInfo( + EnumChatFormatting.AQUA + "" + + EnumChatFormatting.ITALIC + + "processes related to the cutting and engraving of silicon wafers and chips. It is crucial that") + .addInfo( + EnumChatFormatting.AQUA + "" + + EnumChatFormatting.ITALIC + + "the water is systematically purified through a series of increasingly precise and complex") + .addInfo( + EnumChatFormatting.AQUA + "" + + EnumChatFormatting.ITALIC + + "purification processes, and this multiblock is the heart of the operation.") + .addInfo(AuthorNotAPenguin) + .beginStructureBlock(7, 9, 8, false) + .addCasingInfoExactlyColored( + "Superplasticizer-Treated High Strength Concrete", + EnumChatFormatting.GRAY, + 56, + EnumChatFormatting.GOLD, + false) + .addCasingInfoExactlyColored( + "Sterile Water Plant Casing", + EnumChatFormatting.GRAY, + 77, + EnumChatFormatting.GOLD, + false) + .addCasingInfoRangeColored( + "Reinforced Sterile Water Plant Casing", + EnumChatFormatting.GRAY, + 71, + 72, + EnumChatFormatting.GOLD, + false) + .addCasingInfoExactlyColored( + "Tungsten Frame Box", + EnumChatFormatting.GRAY, + 30, + EnumChatFormatting.GOLD, + false) + .addCasingInfoExactlyColored( + "Tinted Industrial Glass", + EnumChatFormatting.GRAY, + 6, + EnumChatFormatting.GOLD, + false) + .addCasingInfoExactlyColored("Reinforced Door", EnumChatFormatting.GRAY, 1, EnumChatFormatting.GOLD, false) + .addController("Front center") + .addEnergyHatch(EnumChatFormatting.GOLD + "1", 1) + .addMaintenanceHatch(EnumChatFormatting.GOLD + "1", 1) + .addStructureInfo("Requires water to be placed in the tank.") + .addStructureInfo("Use the StructureLib Hologram Projector to build the structure.") + .toolTipFinisher("GregTech"); + return tt; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_PurificationPlant(this.mName); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean active, boolean redstoneLevel) { + if (side == facing) { + if (active) return new ITexture[] { + Textures.BlockIcons + .getCasingTextureForId(GT_Utility.getCasingTextureIndex(GregTech_API.sBlockCasings9, 4)), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY_ACTIVE_GLOW) + .extFacing() + .glow() + .build() }; + return new ITexture[] { + Textures.BlockIcons + .getCasingTextureForId(GT_Utility.getCasingTextureIndex(GregTech_API.sBlockCasings9, 4)), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_PROCESSING_ARRAY_GLOW) + .extFacing() + .glow() + .build() }; + } + return new ITexture[] { Textures.BlockIcons + .getCasingTextureForId(GT_Utility.getCasingTextureIndex(GregTech_API.sBlockCasings9, 4)) }; + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + private List<IHatchElement<? super GT_MetaTileEntity_PurificationPlant>> getAllowedHatches() { + return ImmutableList.of(Maintenance, Energy, ExoticEnergy); + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + // Check self + if (!checkPiece(STRUCTURE_PIECE_MAIN, 3, 6, 0)) { + return false; + } + + // Check hatches + if (!checkHatches()) { + return false; + } + + // using nano forge method of detecting hatches. + if (!checkExoticAndNormalEnergyHatches()) { + return false; + } + + return true; + } + + private boolean checkHatches() { + // Exactly one maintenance hatch is required + return mMaintenanceHatches.size() == 1; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPostTick(aBaseMetaTileEntity, aTick); + + if (aBaseMetaTileEntity.isServerSide()) { + // Trigger structure check of linked units, but never all in the same tick, and at most once per cycle. + for (int i = 0; i < mLinkedUnits.size(); ++i) { + if (aTick % CYCLE_TIME_TICKS == i) { + LinkedPurificationUnit unit = mLinkedUnits.get(i); + boolean structure = unit.metaTileEntity() + .checkStructure(true); + // If unit was active but deformed, set as inactive + if (unit.isActive() && !structure) { + unit.setActive(false); + // Also remember to recalculate power usage, since otherwise the deformed unit will + // keep drawing power + this.lEUt = -calculateEffectivePowerUsage(); + } + } + } + } + } + + @Override + protected void runMachine(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + updateCycleProgress(); + // Calculate efficiency based on maintenance issues + if (mMaxProgresstime > 0) { + mEfficiency = Math.max( + 0, + Math.min( + mEfficiency + mEfficiencyIncrease, + getMaxEfficiency(mInventory[1]) - ((getIdealStatus() - getRepairStatus()) * 1000))); + } + } + + private void updateCycleProgress() { + // Since the plant does not run recipes directly, we just continuously loop the base cycle + if (mMachine) { + // cycle is running, so simply advance it + if (mMaxProgresstime > 0) { + // onRunningTick is responsible for draining power + if (onRunningTick(mInventory[1])) { + markDirty(); + mProgresstime += 1; + // Update progress time for active units + for (LinkedPurificationUnit unit : this.mLinkedUnits) { + if (unit.isActive()) { + GT_MetaTileEntity_PurificationUnitBase<?> metaTileEntity = unit.metaTileEntity(); + metaTileEntity.mProgresstime = mProgresstime; + } + } + // Cycle finished + if (mProgresstime >= mMaxProgresstime) { + this.endCycle(); + } + } else { + // Power drain failed, shut down all other units due to power loss. + // Note that we do not need to shut down self, as this is done in + // onRunningTick already + for (LinkedPurificationUnit unit : mLinkedUnits) { + if (unit.isActive()) { + unit.metaTileEntity() + .stopMachine(ShutDownReasonRegistry.POWER_LOSS); + } + } + } + } + + // No cycle running, start a new cycle if the machine is turned on + if (mMaxProgresstime == 0 && isAllowedToWork()) { + this.startCycle(); + } + } + } + + private void startCycle() { + mProgresstime = 0; + mMaxProgresstime = CYCLE_TIME_TICKS; + mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000); + + // Find active units and notify them that the cycle started + for (LinkedPurificationUnit unit : this.mLinkedUnits) { + GT_MetaTileEntity_PurificationUnitBase<?> metaTileEntity = unit.metaTileEntity(); + PurificationUnitStatus status = metaTileEntity.status(); + // Unit needs to |